def addLogAttachment(self,
logId,
attachmentName,
attachmentDescription=None,
**kwargs):
if not logId:
raise InvalidRequest("Invalid logId provided")
if not attachmentName:
raise InvalidRequest("Invalid attachment name provided")
attachmentName = Encoder.decode(attachmentName)
attachmentDescription = Encoder.decode(attachmentDescription)
cherrypyData = cherrypy.request.body
sessionUser = self.getSessionUser()
attachmentAddedByUserId = sessionUser.get('id')
logAttachmentAdded = self.logControllerImpl.addLogAttachment(
logId, attachmentName, attachmentDescription,
attachmentAddedByUserId, cherrypyData)
response = logAttachmentAdded.getFullJsonRep()
self.logger.debug(
'Returning log attachment info for log with id %s: %s' %
(logId, response))
return response
def getItemByUniqueAttributes(self,
domainName,
itemName,
itemIdentifier1=None,
itemIdentifier2=None,
derivedFromItemId=None):
if not domainName:
raise InvalidRequest("Invalid domain name provided")
if not itemName:
raise InvalidRequest("Invalid itemName provided")
domainName = Encoder.decode(domainName)
itemName = Encoder.decode(itemName)
if itemIdentifier1 is not None:
itemIdentifier1 = Encoder.decode(itemIdentifier1)
if itemIdentifier2 is not None:
itemIdentifier2 = Encoder.decode(itemIdentifier2)
item = self.itemControllerImpl.getItemByUniqueAttributes(
domainName, itemName, itemIdentifier1, itemIdentifier2,
derivedFromItemId)
response = item.getFullJsonRep()
self.logger.debug(
'Returning item info for item in domain %s with name %s: %s' %
(domainName, itemName, response))
return response
def updateItemElement(self,
itemElementId,
containedItemId=-1,
isRequired=-1,
name=None,
description=None,
ownerUserId=None,
ownerGroupId=None,
isGroupWriteable=None):
sessionUser = self.getSessionUser()
lastModifiedUserId = sessionUser.get('id')
if containedItemId != -1:
containedItemId = eval(containedItemId)
if isRequired != -1:
isRequired = eval(isRequired)
if name is not None:
name = Encoder.decode(name)
if description is not None:
description = Encoder.decode(description)
if ownerUserId is not None:
ownerUserId = eval(ownerUserId)
if ownerGroupId is not None:
ownerGroupId = eval(ownerGroupId)
if isGroupWriteable is not None:
isGroupWriteable = eval(isGroupWriteable)
response = self.itemElementImplController.updateItemElement(
itemElementId, lastModifiedUserId, containedItemId, isRequired,
name, description, ownerUserId, ownerGroupId, isGroupWriteable)
self.logger.debug('Returning updated item element: %s' % (response))
return response.getFullJsonRep()
def getItemByUniqueAttributes(self,
domainName,
itemName,
itemIdentifier1=None,
itemIdentifier2=None,
derivedFromItemId=None):
if domainName is None or not len(domainName):
raise InvalidRequest("domainName must be provided")
if itemName is None or not len(itemName):
raise InvalidRequest("itemName must be provided")
domainName = Encoder.encode(domainName)
itemName = Encoder.encode(itemName)
url = '%s/items/uniqueAttributes/%s/%s' % (self.getContextRoot(),
domainName, itemName)
if itemIdentifier1 is not None:
itemIdentifier1 = Encoder.encode(str(itemIdentifier1))
url = self._appendUrlParameter(url, "itemIdentifier1",
itemIdentifier1)
if itemIdentifier2 is not None:
itemIdentifier2 = Encoder.encode(str(itemIdentifier2))
url = self._appendUrlParameter(url, "itemIdentifier2",
itemIdentifier2)
if derivedFromItemId is not None:
url = self._appendUrlParameter(url, "derivedFromItemId",
derivedFromItemId)
responseData = self.sendRequest(url=url, method="GET")
return Item(responseData)
def packageOptionalPropertyValueVariables(self, tag=None, value=None, units=None, description=None, isUserWriteable=None, isDynamic=None, displayValue=None):
optionalParameters = {}
if tag is not None:
tag = Encoder.decode(tag)
optionalParameters.update({'tag': tag})
if value is not None:
value = Encoder.decode(value)
optionalParameters.update({'value': value})
if displayValue is not None:
displayValue = Encoder.decode(displayValue)
optionalParameters.update({'displayValue': displayValue})
if units is not None:
units = Encoder.decode(units)
optionalParameters.update({'units': units})
if description is not None:
description = Encoder.decode(description)
optionalParameters.update({'description': description})
if isUserWriteable is not None:
isUserWriteable = eval(isUserWriteable)
optionalParameters.update({'isUserWriteable': isUserWriteable})
if isDynamic is not None:
isDynamic = eval(isDynamic)
optionalParameters.update({'isDynamic', isDynamic})
return optionalParameters
def updateLogEntry(self,
logId,
text=None,
effectiveFromDateTime=None,
effectiveToDateTime=None,
logTopicName=None):
if logId is None or not len(logId):
raise InvalidRequest('Log id must be provided.')
url = '%s/logs/%s/update' % (self.getContextRoot(), logId)
if text is not None:
text = Encoder.encode(text)
url = self._appendUrlParameter(url, 'text', text)
if effectiveFromDateTime is not None:
effectiveFromDateTime = Encoder.encode(effectiveFromDateTime)
url = self._appendUrlParameter(url, 'effectiveFromDateTime',
effectiveFromDateTime)
if effectiveToDateTime is not None:
effectiveToDateTime = Encoder.encode(effectiveToDateTime)
url = self._appendUrlParameter(url, 'effectiveToDateTime',
effectiveToDateTime)
if logTopicName is not None:
logTopicName = Encoder.encode(logTopicName)
url = self._appendUrlParameter(url, 'logTopicName', logTopicName)
responseDict = self.sendSessionRequest(url=url, method='PUT')
return Log(responseDict)
def updateLogEntry(self,
logId,
text=None,
effectiveFromDateTime=None,
effectiveToDateTime=None,
logTopicName=None):
sessionUser = self.getSessionUser()
userId = sessionUser.get('id')
if text is not None:
text = Encoder.decode(text)
if effectiveFromDateTime is not None:
effectiveFromDateTime = Encoder.decode(effectiveFromDateTime)
if effectiveToDateTime is not None:
effectiveToDateTime = Encoder.decode(effectiveToDateTime)
if logTopicName is not None:
logTopicName = Encoder.decode(logTopicName)
logObject = self.logControllerImpl.updateLogEntry(
logId, userId, text, effectiveFromDateTime, effectiveToDateTime,
logTopicName)
response = logObject.getFullJsonRep()
self.logger.debug('Return updated log entry for log with id %s' %
logId)
return response
def addItemElementRelationship(self,
relationshipTypeName,
firstItemId=None,
secondItemId=None,
firstItemQrId=None,
secondItemQrId=None,
relationshipDetails=None,
description=None):
if not firstItemId and not firstItemQrId:
raise InvalidRequest("Invalid first item id provided")
if not secondItemId and not secondItemQrId:
raise InvalidRequest("Invalid second item id provided")
if not relationshipTypeName:
raise InvalidRequest("Invalid relationship type name provided")
usingQrIds = None
if firstItemId and secondItemId:
usingQrIds = False
elif firstItemQrId and secondItemQrId:
usingQrIds = True
else:
raise InvalidRequest("Must either specify both qrIds or both Ids")
relationshipTypeName = Encoder.decode(relationshipTypeName)
if relationshipDetails is not None:
relationshipDetails = Encoder.decode(relationshipDetails)
if description is not None:
description = Encoder.decode(description)
sessionUser = self.getSessionUser()
enteredByUserId = sessionUser.get('id')
logMessageStart = "Returning item element relationship between "
if usingQrIds:
itemElementRelationship = self.itemControllerImpl.addItemElementRelationshipByQrId(
firstItemQrId, secondItemQrId, relationshipTypeName,
enteredByUserId, relationshipDetails, description)
logMessageStart += "item qr: %s and item qr: %s" % (firstItemQrId,
secondItemQrId)
else:
itemElementRelationship = self.itemControllerImpl.addItemElementRelationship(
firstItemId, secondItemId, relationshipTypeName,
enteredByUserId, relationshipDetails, description)
logMessageStart += "item id: %s and item id: %s" % (firstItemId,
secondItemId)
response = itemElementRelationship.getFullJsonRep()
self.logger.debug("%s of type: %s : %s" %
(logMessageStart, relationshipTypeName, response))
return response
def __finalizeAddItemRelationship(self, url, relationshipDetails,
description):
if relationshipDetails is not None:
relationshipDetails = Encoder.encode(relationshipDetails)
url = self._appendUrlParameter(url, "relationshipDetails",
relationshipDetails)
if description is not None:
description = Encoder.encode(description)
url = self._appendUrlParameter(url, "description", description)
responseData = self.sendSessionRequest(url=url, method='POST')
return ItemElementRelationship(responseData)
def addItemElement(self,
parentItemId,
itemElementName,
containedItemId=None,
description=None,
ownerUserId=None,
ownerGroupId=None,
isRequired=None,
isGroupWriteable=None):
sessionUser = self.getSessionUser()
createdByUserId = sessionUser.get('id')
if ownerUserId is None:
ownerUserId = createdByUserId
if ownerGroupId is None:
userGroupList = sessionUser.data['userGroupList']
if len(userGroupList) > 0:
ownerGroupId = userGroupList[0].data['id']
else:
raise InvalidRequest(
"Invalid, current session user is not assigned to any groups... please specify owner group id."
)
optionalParameters = {}
itemElementName = Encoder.decode(itemElementName)
if containedItemId is not None:
optionalParameters.update({'containedItemId': containedItemId})
if description is not None:
description = Encoder.decode(description)
optionalParameters.update({'description': description})
if isRequired is not None:
isRequired = eval(isRequired)
optionalParameters.update({'isRequired': isRequired})
if isGroupWriteable is not None:
isGroupWriteable = eval(isGroupWriteable)
optionalParameters.update({'isGroupWriteable': isGroupWriteable})
response = self.itemElementImplController.addItemElement(
parentItemId, itemElementName, createdByUserId, ownerUserId,
ownerGroupId, **optionalParameters)
self.logger.debug('Returning new item element: %s' % (response))
return response.getFullJsonRep()
def __finalizeAddLogEntryToItem(self, url, logEntry, attachment=None):
if logEntry is None or not len(logEntry):
raise InvalidRequest('Log entry must be provided.')
url += '?logEntry=%s' % Encoder.encode(logEntry)
if attachment is not None and len(attachment) > 0:
fileName, data = self._generateFileData(attachment)
url += '&attachmentName=%s' % Encoder.encode(fileName)
responseDict = self.sendSessionRequest(url=url,
method='POST',
data=data)
else:
responseDict = self.sendSessionRequest(url=url, method='POST')
return Log(responseDict)
def updateItemElement(self,
itemElementId,
containedItemId=-1,
isRequired=-1,
name=None,
description=None,
ownerUserId=None,
ownerGroupId=None,
isGroupWriteable=None):
if itemElementId is not None:
itemElementId = str(itemElementId)
if itemElementId is None or not len(itemElementId):
raise InvalidRequest("itemElementId must be provided")
url = '%s/itemElements/update/%s' % (self.getContextRoot(),
itemElementId)
if name is not None:
name = Encoder.encode(name)
url = self._appendUrlParameter(url, "name", name)
url = self.__appendOptionalItemElementParametersToUrl(
url, containedItemId, description, ownerUserId, ownerGroupId,
isRequired, isGroupWriteable)
responseData = self.sendSessionRequest(url=url, method='PUT')
return ItemElement(responseData)
def addPropertyValueToItemByItemId(self,
itemId,
propertyTypeName,
tag=None,
value=None,
displayValue=None,
units=None,
description=None,
isUserWriteable=None,
isDynamic=None):
if not itemId:
raise InvalidRequest("Invalid itemId provided")
if not propertyTypeName:
raise InvalidRequest("Invalid propertyTypeName provided")
propertyTypeName = Encoder.decode(propertyTypeName)
sessionUser = self.getSessionUser()
enteredByUserId = sessionUser.get('id')
optionalParameters = self.propertyControllerImpl.packageOptionalPropertyValueVariables(
tag, value, units, description, isUserWriteable, isDynamic,
displayValue)
itemElementPropertyValueAdded = self.itemControllerImpl.addPropertyValueForItemWithId(
itemId, propertyTypeName, enteredByUserId, **optionalParameters)
propertyValueAdded = itemElementPropertyValueAdded.data[
'propertyValue']
response = propertyValueAdded.getFullJsonRep()
self.logger.debug(
'Returning new property value created for item with id %s: %s' %
(itemId, propertyValueAdded))
return response
def addItemElement(self,
itemElementName,
parentItemId,
containedItemId=-1,
description=None,
ownerUserId=None,
ownerGroupId=None,
isRequired=-1,
isGroupWriteable=None):
if parentItemId is not None:
parentItemId = str(parentItemId)
if parentItemId is None or not len(parentItemId):
raise InvalidRequest("parentItemId must be provided")
if itemElementName is None or not len(itemElementName):
raise InvalidRequest("itemElementName must be provided")
itemElementName = Encoder.encode(itemElementName)
url = '%s/itemElements/add/%s/%s' % (self.getContextRoot(),
itemElementName, parentItemId)
url = self.__appendOptionalItemElementParametersToUrl(
url, containedItemId, description, ownerUserId, ownerGroupId,
isRequired, isGroupWriteable)
responseData = self.sendSessionRequest(url=url, method='POST')
return ItemElement(responseData)
def test_encoder(self):
encoder = Encoder()
someData = "Hello World"
encoded = encoder.encode(someData)
self.assertEqual(someData, encoder.decode(encoded),
"Encoder failed to decode/encode data")
def writeFile(self, fileName, **kwargs):
if 'parentDirectory' not in kwargs:
raise InvalidRequest('Missing parent directory.')
parentDirectory = kwargs.get('parentDirectory')
encodedFileContent = kwargs.get('encodedFileContent', '')
fileContent = Encoder.decode(encodedFileContent)
filePath = '%s/%s' % (parentDirectory, fileName)
response = '%s' % self.fileSystemControllerImpl.writeFile(filePath, fileContent).getFullJsonRep()
self.logger.debug('Returning: %s' % response)
return response
def addLogEntryToItemWithQrId(self, qrId, logEntry, attachment):
if qrId is None or not len(qrId):
raise InvalidRequest("QrId must be provided")
url = '%s/items/%s/addLogEntry' % (self.getContextRoot(), qrId)
if logEntry is None or not len(logEntry):
raise InvalidRequest('Log entry must be provided.')
url += '?logEntry=%s' % Encoder.encode(logEntry)
if attachment is not None and len(attachment) > 0:
fileName, data = self._generateFileData(attachment)
url += '&attachmentName=%s' % Encoder.encode(fileName)
responseDict = self.sendSessionRequest(url=url, method='POST', data=data)
else:
responseDict = self.sendSessionRequest(url=url, method='POST')
return Log(responseDict)
def writeFile(self, path, content):
try:
fileName = os.path.basename(path)
parentDirectory = os.path.dirname(path)
encodedFileContent = Encoder.encode(content)
url = '%s/files/%s?parentDirectory=%s&encodedFileContent=%s' % (self.getContextRoot(), fileName, parentDirectory, encodedFileContent)
responseDict = self.sendSessionRequest(url=url, method='POST')
return responseDict
except CdbException, ex:
raise
def addImagePropertyToItemWithId(self, itemId, imageFile):
url = '%s/items/%s/addImageProperty' % (self.getContextRoot(), itemId)
fileName, data = self._generateFileData(imageFile)
fileName = Encoder.encode(fileName)
url = self._appendUrlParameter(url, 'imageFileName', fileName)
response = self.sendSessionRequest(url=url, method='POST', data=data)
return PropertyValue(response)
def deletePropertyValuesFromItemWithId(self, itemId, propertyTypeName):
if itemId is not None:
itemId = str(itemId)
if itemId is None or not len(itemId):
raise InvalidRequest("itemId must be provided")
if propertyTypeName is None or not len(propertyTypeName):
raise InvalidRequest("propertyTypeName must be provided")
propertyTypeName = Encoder.encode(propertyTypeName)
url = '%s/items/%s/deletePropertyValues/%s'
url = url % (self.getContextRoot(), itemId, propertyTypeName)
responseData = self.sendSessionRequest(url=url, method='DELETE')
return self.toCdbObjectList(responseData, PropertyValue)
def addPropertyImageToItem(self,
itemId,
imageFileName,
dataEncodedBase64=False):
if not itemId:
raise InvalidRequest("Invalid item id provided")
if not imageFileName:
raise InvalidRequest("Invalid image file name provided")
sessionUser = self.getSessionUser()
enteredByUserId = sessionUser.get('id')
imageFileName = Encoder.decode(imageFileName)
cherrypyData = cherrypy.request.body
if dataEncodedBase64:
cherrypyData = Encoder.decode(cherrypyData.read())
imagePropertyAdded = self.itemControllerImpl.addPropertyImageToItem(
itemId, imageFileName, enteredByUserId, cherrypyData)
return imagePropertyAdded.getFullJsonRep()
def addLogAttachment(self, logId, attachment, attachmentDescription=None):
if logId is None or not len(logId):
raise InvalidRequest('Log id must be provided.')
if attachment is None or len(attachment) == 0:
raise InvalidRequest('Attachment must be specified.')
url = '%s/logs/%s/addAttachment' % (self.getContextRoot(), logId)
# Add attachment information
fileName, data = self._generateFileData(attachment)
url += '?attachmentName=%s' % Encoder.encode(fileName)
if attachmentDescription is not None and len(
attachmentDescription) > 0:
url += '&attachmentDescription=%s' % Encoder.encode(
attachmentDescription)
responseDict = self.sendSessionRequest(url=url,
method='POST',
data=data)
return LogAttachment(responseDict)
def getFirstItemRelationshipList(self, itemId, relationshipTypeName):
if itemId is None:
raise InvalidRequest("item id must be provided")
if relationshipTypeName is None or not len(relationshipTypeName):
raise InvalidRequest("relationship type name must be provided")
relationshipTypeName = Encoder.encode(relationshipTypeName)
url = "%s/items/%s/firstItemElementRelationships/%s" % (
self.getContextRoot(), itemId, relationshipTypeName)
responseData = self.sendRequest(url=url, method="GET")
return self.toCdbObjectList(responseData, ItemElementRelationship)
def addLogToItemByItemId(self,
itemId,
logEntry,
attachmentName=None,
**kwargs):
if not itemId:
raise InvalidRequest("Invalid itemId provided")
if not logEntry:
raise InvalidRequest("Log entry must be provided")
sessionUser = self.getSessionUser()
enteredByUserId = sessionUser.get('id')
attachmentName = Encoder.decode(attachmentName)
cherrypyData = cherrypy.request.body
logEntry = Encoder.decode(logEntry)
logAdded = self.itemControllerImpl.addLogEntryForItemWithItemId(
itemId, logEntry, enteredByUserId, attachmentName, cherrypyData)
response = logAdded.getFullJsonRep()
self.logger.debug('Returning log info for item with item id %s: %s' %
(itemId, response))
return response
def addPropertyMetadataToPropertyValue(self,
propertyValueId,
metadataKey=None,
metadataValue=None,
metadataDict=None):
if propertyValueId is not None:
propertyValueId = str(propertyValueId)
if propertyValueId is None or not len(propertyValueId):
raise InvalidRequest("propertyValueId must be provided")
url = '%s/property/values/%s/addMetadata' % (self.getContextRoot(),
propertyValueId)
list = False
if metadataKey is None or not len(metadataKey):
if metadataDict is None or not len(metadataDict):
raise InvalidRequest(
"metadataKey and value or metadataDict must be provided")
# use metadata dict
metadataDict = json.dumps(metadataDict)
url += '?metadataDict=%s' % Encoder.encode(metadataDict)
list = True
else:
if metadataValue is None or not len(metadataValue):
raise InvalidRequest("metadataValue must be provided")
url = '%s/%s' % (url, metadataKey)
url += '?metadataValue=%s' % Encoder.encode(metadataValue)
response = self.sendSessionRequest(url=url, method='POST')
if list:
return self.toCdbObjectList(response, PropertyMetadata)
else:
return PropertyMetadata(response)
def deletePropertyValuesFromItemByItemId(self, itemId, propertyTypeName):
if not itemId:
raise InvalidRequest("Invalid itemId provided")
if not propertyTypeName:
raise InvalidRequest("Invalid propertyTypeName provided")
propertyTypeName = Encoder.decode(propertyTypeName)
sessionUser = self.getSessionUser()
enteredByUserId = sessionUser.get('id')
deletedPropertyValues = self.itemControllerImpl.deletePropertyValuesFromItemByItemId(
itemId, propertyTypeName, enteredByUserId)
response = self.listToJson(deletedPropertyValues)
return response
def updateInventoryItemStatus(self, itemId, status):
if not itemId:
raise InvalidRequest("Item id must be provided")
if not status:
raise InvalidRequest("Status must be provided")
status = Encoder.decode(status)
sessionUser = self.getSessionUser()
enteredByUserId = sessionUser.get('id')
response = self.itemControllerImpl.updateInventoryItemStatus(
itemId, status, enteredByUserId)
self.logger.debug("Returning updated status: %s" % (response))
return response.getFullJsonRep()
def updateInventoryItemStatus(self, itemId, status):
if itemId is None:
raise InvalidRequest("Item id must be provided")
if status is None:
raise InvalidRequest("Status must be provided")
itemId = str(itemId)
status = Encoder.encode(status)
url = "%s/items/domain/inventory/status/%s/%s" % (
self.getContextRoot(), itemId, status)
response = self.sendSessionRequest(url, method="POST")
return PropertyValue(response)
def getFirstItemRelationship(self, itemId, relationshipTypeName):
if not itemId:
raise InvalidRequest("Invalid item id provided")
if not relationshipTypeName:
raise InvalidRequest("Invalid relationship type name provided")
relationshipTypeName = Encoder.decode(relationshipTypeName)
itemElementRelationshipList = self.itemControllerImpl.getFirstItemRelationship(
itemId, relationshipTypeName)
response = self.listToJson(itemElementRelationshipList)
self.logger.debug(
'Returning item element relationship list of type: %s for item: %s : %s'
% (relationshipTypeName, itemId, response))
return response
def addItemRelationshipByQrId(self,
firstItemQrId,
secondItemQrId,
relationshipTypeName,
relationshipDetails=None,
description=None):
if firstItemQrId is None:
raise InvalidRequest("first item qr id must be provided")
if secondItemQrId is None:
raise InvalidRequest("second item qr id must be provided")
relationshipTypeName = Encoder.encode(relationshipTypeName)
url = "%s/items/%s/%s/addItemElementRelationshipByQrId/%s" \
% (self.getContextRoot(), firstItemQrId, secondItemQrId, relationshipTypeName)
return self.__finalizeAddItemRelationship(url, relationshipDetails,
description)
