NinoCode/Tool_Box/RelativityLib.py

"""

Relativity Library

Created by
Emanuel Borges
05.22.2014

This class will be my main Relativity library
Should DocumentTable and COTable be their own classes that subclass RelativityConnection?


TODO:
  Make it so taht you van overide the site, username and pw.  Right now it's created before you can overide.

"""

import requests,json

class Relativity_Connection(object):
    """An Advanced Relativity Connection Library and Toolkit"""
    version = '0.0.1'
    ## Dev
    #rootSite = 'http://dev.mcdermottdiscovery.com'
    #rootUserName = 'eborges@mwe.com'
    #rootPassword = 'MWEreldev2@'
    
    ## Prod
    rootSite = 'https://www.mcdermottdiscovery.com'
    rootUserName = 'eborges@mwe.com'
    rootPassword = 'QEst3kU2!'
    
    def __init__(self, workSpace = None):
        self.UpdateWorkspaceDict()
        self.workSpace = workSpace
        self.availableTables = None
        
    def UpdateWorkspaceDict(self):
        """Updates the instance varible workSpaceDict with a {workspaceName:ID} dictionary"""
        workSpaceDict = {}
        r = requests.get(self.rootSite+'/Relativity.REST/Relativity/Workspace',auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword), headers={'X-CSRF-Header':""})
        rawJson = r.json()
        rawResults = rawJson['Results']
        for i in rawResults:
            workSpaceDict[i['Relativity Text Identifier']] = i['Artifact ID']
        
        self.workSpaceDict = workSpaceDict
        
    def GetAvilableTables(self):
        """updates the list of available tables"""
        pass
        
    def LoadWorkspace(self, workspaceName):
        r = requests.get(self.rootSite+ '/Relativity.REST/Relativity/Workspace/%s'% self.workSpaceDict[workSpaceName],auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword), headers={'X-CSRF-Header':""})
        self.workSpace = workSpaceName
        
        
class DocumentTable(Relativity_Connection):
    
    def __init__ (self,workSpace):
        self.workSpace = workSpace
        super(DocumentTable,self).__init__(workSpace)
        r = requests.get(self.rootSite+ '/Relativity.REST/Relativity/Workspace/%s/Document'% self.workSpaceDict[self.workSpace],auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword), headers={'X-CSRF-Header':""})
        self.availableTables = r
        #return r.__dict__
    
    def UpdateField(self,field):
        d = {
            "Artifact ID":1078252,"Artifact Type Name":"Tasks","Billing Time Used":5
        }
        
        r = requests.put('https://dev.mcdermottdiscovery.com/Relativity.REST/Workspace/1016359/Tasks/1078252',
                         auth=requests.auth.HTTPBasicAuth('eborges@mwe.com','MWEreldev2@'),
                         headers={'X-CSRF-Header':"",'Content-Type':"application/json; charset=utf-8"},
                         data=json.dumps(d))
        
        
class CustomObjectTable(Relativity_Connection):    
    '''You can just insts this object if you already know the workspace # and objectName. Otherwise insts a sep rl object
    to gather the workspace number and objectName'''
    def __init__ (self, workSpace, objectName):
        self.workSpace = workSpace
        super(CustomObjectTable,self).__init__(workSpace)
        r = requests.get(self.rootSite+ '/Relativity.REST/Workspace/%s/%s'% (self.workSpaceDict[self.workSpace],objectName),
                         auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword),
                         headers={'X-CSRF-Header':""})
        
        self.rlResponse = r.json()
        
        rlResponseCode = r.status_code
        print rlResponseCode
        
        ## This is the ID of the workspace, which is needed when you update or create new items
        ## This will only work if there are already items in this table, got to fix this...
        self.parentID = self.rlResponse['Results'][0]['Parent Artifact']['Artifact ID']
        
        ##  You wont get the field list until after you return 1 item from the RDO
        self.fieldMatrix = None
        
        ##  Count of the results both in total and on this page.
        self.totalResultCount = self.UpdateTotalResultCount()
        self.pageResultCount = self.UpdateCurrentResultCount()
        
        ##  The matrix if returned items with artifactID:name. Cant do other way around, since name can dupe.
        self.itemMatrix = self.UpdateItemMatrix()     
        
        
        ## The objectName stays the same, since you need a new instance for each table.
        self.objectName = objectName
        
        ##  Loading the item will update the field list and make that the active item
        self.currentItems = None
        
        ##  You may load 1 item using single item or query and get multiple items.
        self.currentItemCount = None
    
    
    def LoadSingleItem(self, itemID):
        '''loads a requested item into the instance and updates the field matrix'''
        r = requests.get(self.rootSite+ '/Relativity.REST/Workspace/%s/%s/%s'% (self.workSpaceDict[self.workSpace],self.objectName,itemID),
                         auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword),
                         headers={'X-CSRF-Header':""})
        rlResponse = r.json()
        rlResponseCode = r.status_code
        print rlResponseCode
        self.currentItems = [rlResponse,]
        self.UpdateFieldMatrix(self.currentItems[0]['__Fields'])
        self.currentItemCount = len(self.currentItems)
    
    def QueryForItems(self,searchString):
        '''takes a search string and brings back a matrix containing only those items that matched the search'''
        payload = {
            "condition":searchString,
            "fields":["*"]
        }
        ## Note that it will give you a max of 100 here because I'm setting the page size.
        r = requests.post(self.rootSite+ '/Relativity.REST/Workspace/%s/%s/QueryResult?pagesize=100'% (self.workSpaceDict[self.workSpace],self.objectName),
                         auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword),
                         headers={'X-CSRF-Header':"",'Content-Type':"application/json; charset=utf-8"},
                         data=json.dumps(payload))
        rlResponse = r.json()
        rlResponseCode = r.status_code
        print rlResponseCode
        self.currentItems = rlResponse['Results']
        #print self.currentItems
        self.UpdateFieldMatrix(self.currentItems[0]['__Fields'])
        self.currentItemCount = len(self.currentItems)
        return self.currentItems
    
    def UpdateItemMatrix(self):
        ''' Updates the item matrix with ArtifactID:name and also puts all names in the itemlist'''
        itemMatrix = {}
        for i in self.rlResponse['Results']:
            itemMatrix[i['Artifact ID']] = i['Relativity Text Identifier']
        return itemMatrix
    
    
    def UpdateTotalResultCount(self):
        '''Returns the current totalResultCount'''
        return self.rlResponse['TotalResultCount']
        
    def UpdateCurrentResultCount(self):
        '''Returns the current result count for the page that you are on'''
        return self.rlResponse['ResultCount']
    
    def UpdateFieldMatrix(self,rawFieldDict):
        '''Returns the list of fields in the table object'''
        fieldMatrix = {}
        for i in rawFieldDict:
            fieldMatrix[i['Name']] = i['Field Type']
        self.fieldMatrix = fieldMatrix
    
    
    def CreateNewItem(self, itemFieldMatrix):
        '''Allows you to create a new item in the DO, by passing a matrix of fields and their values'''
        itemFieldMatrix["Artifact Type Name"] = self.objectName
        itemFieldMatrix["Parent Artifact"] = {"Artifact ID":self.parentID}
        
        r = requests.post(self.rootSite+ '/Relativity.REST/Workspace/%s/%s'% (self.workSpaceDict[self.workSpace],self.objectName),
                         auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword),
                         headers={'X-CSRF-Header':"",'Content-Type':"application/json; charset=utf-8"},
                         data=json.dumps(itemFieldMatrix))
        rlResponse = r.json()
        rlResponseCode = r.status_code
        print rlResponseCode
        artID = rlResponse['Results'][0]['ArtifactID']
        ## Returning the artifact id?, not sure about this. maybe should return status and allow you to get at artifact...
        return artID
        #d = {
        #    "Name":"TEST","Artifact Type Name":"Tasks","Billing Time Used":5,"Parent Artifact":{"Artifact ID":1003663}
        #}
        #
        #r = requests.post('https://dev.mcdermottdiscovery.com/Relativity.REST/Workspace/1016359/Tasks',
        #                 auth=requests.auth.HTTPBasicAuth('eborges@mwe.com','MWEreldev2@'),
        #                 headers={'X-CSRF-Header':"",'Content-Type':"application/json; charset=utf-8"},
        #                 data=json.dumps(d))
    
    
    def UpdateField(self,field):
        
        d = {
            "Artifact ID":1078252,"Artifact Type Name":"Tasks","Billing Time Used":5,"Parent Artifact":{"Artifact ID":1003663}
        }
        
        r = requests.put(self.rootSite+ '/Relativity.REST/Workspace/1016359/Tasks/1078252',
                         auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword),
                         headers={'X-CSRF-Header':"",'Content-Type':"application/json; charset=utf-8"},
                         data=json.dumps(d))
        
        
Revision:	570
Committed:	Wed Feb 4 16:05:05 2015 UTC (11 years, 1 month ago) by nino.borges
Content type:	text/x-python
File size:	9589 byte(s)
Log Message:	A library for connecting to Relativity.
#	User	Rev	Content
1	nino.borges	570	"""
2
3			Relativity Library
4
5			Created by
6			Emanuel Borges
7			05.22.2014
8
9			This class will be my main Relativity library
10			Should DocumentTable and COTable be their own classes that subclass RelativityConnection?
11
12
13			TODO:
14			Make it so taht you van overide the site, username and pw. Right now it's created before you can overide.
15
16			"""
17
18			import requests,json
19
20			class Relativity_Connection(object):
21			"""An Advanced Relativity Connection Library and Toolkit"""
22			version = '0.0.1'
23			## Dev
24			#rootSite = 'http://dev.mcdermottdiscovery.com'
25			#rootUserName = 'eborges@mwe.com'
26			#rootPassword = 'MWEreldev2@'
27
28			## Prod
29			rootSite = 'https://www.mcdermottdiscovery.com'
30			rootUserName = 'eborges@mwe.com'
31			rootPassword = 'QEst3kU2!'
32
33			def __init__(self, workSpace = None):
34			self.UpdateWorkspaceDict()
35			self.workSpace = workSpace
36			self.availableTables = None
37
38			def UpdateWorkspaceDict(self):
39			"""Updates the instance varible workSpaceDict with a {workspaceName:ID} dictionary"""
40			workSpaceDict = {}
41			r = requests.get(self.rootSite+'/Relativity.REST/Relativity/Workspace',auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword), headers={'X-CSRF-Header':""})
42			rawJson = r.json()
43			rawResults = rawJson['Results']
44			for i in rawResults:
45			workSpaceDict[i['Relativity Text Identifier']] = i['Artifact ID']
46
47			self.workSpaceDict = workSpaceDict
48
49			def GetAvilableTables(self):
50			"""updates the list of available tables"""
51			pass
52
53			def LoadWorkspace(self, workspaceName):
54			r = requests.get(self.rootSite+ '/Relativity.REST/Relativity/Workspace/%s'% self.workSpaceDict[workSpaceName],auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword), headers={'X-CSRF-Header':""})
55			self.workSpace = workSpaceName
56
57
58
59			class DocumentTable(Relativity_Connection):
60
61			def __init__ (self,workSpace):
62			self.workSpace = workSpace
63			super(DocumentTable,self).__init__(workSpace)
64			r = requests.get(self.rootSite+ '/Relativity.REST/Relativity/Workspace/%s/Document'% self.workSpaceDict[self.workSpace],auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword), headers={'X-CSRF-Header':""})
65			self.availableTables = r
66			#return r.__dict__
67
68			def UpdateField(self,field):
69			d = {
70			"Artifact ID":1078252,"Artifact Type Name":"Tasks","Billing Time Used":5
71			}
72
73			r = requests.put('https://dev.mcdermottdiscovery.com/Relativity.REST/Workspace/1016359/Tasks/1078252',
74			auth=requests.auth.HTTPBasicAuth('eborges@mwe.com','MWEreldev2@'),
75			headers={'X-CSRF-Header':"",'Content-Type':"application/json; charset=utf-8"},
76			data=json.dumps(d))
77
78
79
80
81			class CustomObjectTable(Relativity_Connection):
82			'''You can just insts this object if you already know the workspace # and objectName. Otherwise insts a sep rl object
83			to gather the workspace number and objectName'''
84			def __init__ (self, workSpace, objectName):
85			self.workSpace = workSpace
86			super(CustomObjectTable,self).__init__(workSpace)
87			r = requests.get(self.rootSite+ '/Relativity.REST/Workspace/%s/%s'% (self.workSpaceDict[self.workSpace],objectName),
88			auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword),
89			headers={'X-CSRF-Header':""})
90
91			self.rlResponse = r.json()
92
93			rlResponseCode = r.status_code
94			print rlResponseCode
95
96			## This is the ID of the workspace, which is needed when you update or create new items
97			## This will only work if there are already items in this table, got to fix this...
98			self.parentID = self.rlResponse['Results'][0]['Parent Artifact']['Artifact ID']
99
100			## You wont get the field list until after you return 1 item from the RDO
101			self.fieldMatrix = None
102
103			## Count of the results both in total and on this page.
104			self.totalResultCount = self.UpdateTotalResultCount()
105			self.pageResultCount = self.UpdateCurrentResultCount()
106
107			## The matrix if returned items with artifactID:name. Cant do other way around, since name can dupe.
108			self.itemMatrix = self.UpdateItemMatrix()
109
110
111			## The objectName stays the same, since you need a new instance for each table.
112			self.objectName = objectName
113
114			## Loading the item will update the field list and make that the active item
115			self.currentItems = None
116
117			## You may load 1 item using single item or query and get multiple items.
118			self.currentItemCount = None
119
120
121
122			def LoadSingleItem(self, itemID):
123			'''loads a requested item into the instance and updates the field matrix'''
124			r = requests.get(self.rootSite+ '/Relativity.REST/Workspace/%s/%s/%s'% (self.workSpaceDict[self.workSpace],self.objectName,itemID),
125			auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword),
126			headers={'X-CSRF-Header':""})
127			rlResponse = r.json()
128			rlResponseCode = r.status_code
129			print rlResponseCode
130			self.currentItems = [rlResponse,]
131			self.UpdateFieldMatrix(self.currentItems[0]['__Fields'])
132			self.currentItemCount = len(self.currentItems)
133
134			def QueryForItems(self,searchString):
135			'''takes a search string and brings back a matrix containing only those items that matched the search'''
136			payload = {
137			"condition":searchString,
138			"fields":["*"]
139			}
140			## Note that it will give you a max of 100 here because I'm setting the page size.
141			r = requests.post(self.rootSite+ '/Relativity.REST/Workspace/%s/%s/QueryResult?pagesize=100'% (self.workSpaceDict[self.workSpace],self.objectName),
142			auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword),
143			headers={'X-CSRF-Header':"",'Content-Type':"application/json; charset=utf-8"},
144			data=json.dumps(payload))
145			rlResponse = r.json()
146			rlResponseCode = r.status_code
147			print rlResponseCode
148			self.currentItems = rlResponse['Results']
149			#print self.currentItems
150			self.UpdateFieldMatrix(self.currentItems[0]['__Fields'])
151			self.currentItemCount = len(self.currentItems)
152			return self.currentItems
153
154			def UpdateItemMatrix(self):
155			''' Updates the item matrix with ArtifactID:name and also puts all names in the itemlist'''
156			itemMatrix = {}
157			for i in self.rlResponse['Results']:
158			itemMatrix[i['Artifact ID']] = i['Relativity Text Identifier']
159			return itemMatrix
160
161
162			def UpdateTotalResultCount(self):
163			'''Returns the current totalResultCount'''
164			return self.rlResponse['TotalResultCount']
165
166			def UpdateCurrentResultCount(self):
167			'''Returns the current result count for the page that you are on'''
168			return self.rlResponse['ResultCount']
169
170			def UpdateFieldMatrix(self,rawFieldDict):
171			'''Returns the list of fields in the table object'''
172			fieldMatrix = {}
173			for i in rawFieldDict:
174			fieldMatrix[i['Name']] = i['Field Type']
175			self.fieldMatrix = fieldMatrix
176
177
178			def CreateNewItem(self, itemFieldMatrix):
179			'''Allows you to create a new item in the DO, by passing a matrix of fields and their values'''
180			itemFieldMatrix["Artifact Type Name"] = self.objectName
181			itemFieldMatrix["Parent Artifact"] = {"Artifact ID":self.parentID}
182
183			r = requests.post(self.rootSite+ '/Relativity.REST/Workspace/%s/%s'% (self.workSpaceDict[self.workSpace],self.objectName),
184			auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword),
185			headers={'X-CSRF-Header':"",'Content-Type':"application/json; charset=utf-8"},
186			data=json.dumps(itemFieldMatrix))
187			rlResponse = r.json()
188			rlResponseCode = r.status_code
189			print rlResponseCode
190			artID = rlResponse['Results'][0]['ArtifactID']
191			## Returning the artifact id?, not sure about this. maybe should return status and allow you to get at artifact...
192			return artID
193			#d = {
194			# "Name":"TEST","Artifact Type Name":"Tasks","Billing Time Used":5,"Parent Artifact":{"Artifact ID":1003663}
195			#}
196			#
197			#r = requests.post('https://dev.mcdermottdiscovery.com/Relativity.REST/Workspace/1016359/Tasks',
198			# auth=requests.auth.HTTPBasicAuth('eborges@mwe.com','MWEreldev2@'),
199			# headers={'X-CSRF-Header':"",'Content-Type':"application/json; charset=utf-8"},
200			# data=json.dumps(d))
201
202
203			def UpdateField(self,field):
204
205			d = {
206			"Artifact ID":1078252,"Artifact Type Name":"Tasks","Billing Time Used":5,"Parent Artifact":{"Artifact ID":1003663}
207			}
208
209			r = requests.put(self.rootSite+ '/Relativity.REST/Workspace/1016359/Tasks/1078252',
210			auth=requests.auth.HTTPBasicAuth(self.rootUserName,self.rootPassword),
211			headers={'X-CSRF-Header':"",'Content-Type':"application/json; charset=utf-8"},
212			data=json.dumps(d))
213
214