def __init__(self):
CdbDbEntityHandler.__init__(self)
self.entityInfoHandler = EntityInfoHandler()
self.domainHandler = DomainHandler()
self.entityTypeHandler = EntityTypeHandler()
self.sourceHandler = SourceHandler()
self.logHandler = LogHandler()
self.propertyValueHandler = PropertyValueHandler()
self.relationshipTypeHandler = RelationshipTypeHandler()
self.resourceTypeHandler = ResourceTypeHandler()
self.userInfoHandler = UserInfoHandler()
def __init__(self):
CdbDbApi.__init__(self)
self.propertyTypeHandler = PropertyTypeHandler()
self.propertyValueHandler = PropertyValueHandler()
self.propertyTypeHandlerHandler = PropertyTypeHandlerHandler()
self.propertyTypeCategoryHandler = PropertyTypeCategoryHandler()
class PropertyDbApi(CdbDbApi):
def __init__(self):
CdbDbApi.__init__(self)
self.propertyTypeHandler = PropertyTypeHandler()
self.propertyValueHandler = PropertyValueHandler()
self.propertyTypeHandlerHandler = PropertyTypeHandlerHandler()
self.propertyTypeCategoryHandler = PropertyTypeCategoryHandler()
@CdbDbApi.executeQuery
def getPropertyValuesByPropertyTypeId(self, propertyTypeId, **kwargs):
"""
Get all property values with a given property type id.
:param propertyTypeId:
:param kwargs:
:return: CdbObject List of resulting records.
"""
session = kwargs['session']
dbPropertyType = self.propertyValueHandler.findPropertyValuesByPropertyTypeId(session, propertyTypeId)
return self.toCdbObjectList(dbPropertyType)
@CdbDbApi.executeQuery
def getPropertyHandlerTypeHandlerByPropertyHandlerName(self, propertyHandlerName, **kwargs):
"""
Get a property type handler by its name.
:param propertyHandlerName:
:param kwargs:
:return: (CdbObject) resulting record.
"""
session = kwargs['session']
dbPropertyTypeHandler = self.propertyTypeHandlerHandler.getPropertyTypeHandlerByName(session, propertyHandlerName)
return dbPropertyTypeHandler.getCdbObject()
@CdbDbApi.executeQuery
def getPropertyTypesByHandlerId(self, propertyHandlerid, **kwargs):
"""
Get all property types by their handler id.
:param propertyHandlerid:
:param kwargs:
:return: CdbObject List of resulting records.
"""
session = kwargs['session']
dbPropertyTypes = self.propertyTypeHandler.getPropertyTypesByHandlerId(session, propertyHandlerid)
return self.toCdbObjectList(dbPropertyTypes)
@CdbDbApi.executeTransaction
def addPropertyTypeHandler(self, propertyTypeHandlerName, description, **kwargs):
"""
Add a property type handler.
:param propertyTypeHandlerName:
:param description:
:param kwargs:
:return: (CdbObject) newly added record.
"""
session = kwargs['session']
dbPropertyTypeHandler = self.propertyTypeHandlerHandler.addPropertyTypeHandler(session, propertyTypeHandlerName, description)
return dbPropertyTypeHandler.getCdbObject()
@CdbDbApi.executeQuery
def getPropertyTypeHandlers(self, **kwargs):
"""
Get all property type handler records.
:param kwargs:
:return: CdbObject List of resulting records.
"""
session = kwargs['session']
dbPropertyTypeHandlers = self.propertyTypeHandlerHandler.getPropertyTypeHandlers(session)
return self.toCdbObjectList(dbPropertyTypeHandlers)
@CdbDbApi.executeQuery
def getPropertyTypes(self, **kwargs):
"""
Get all property type records.
:param kwargs:
:return: CdbObject List of resulting records.
"""
session = kwargs['session']
dbPropertyTypes = self.propertyTypeHandler.getPropertyTypes(session)
return self.toCdbObjectList(dbPropertyTypes)
@CdbDbApi.executeQuery
def getPropertyTypeById(self, propertyTypeId, **kwargs):
"""
Get property type record by id.
:param propertyTypeId:
:param kwargs:
:return:
"""
session = kwargs['session']
dbPropertyType = self.propertyTypeHandler.getPropertyTypeById(session, propertyTypeId)
return dbPropertyType.toCdbObject()
@CdbDbApi.executeQuery
def getAllowedPropertyValuesForPropertyType(self, propertyTypeId, **kwargs):
"""
Get a list of allowed property values for a certain property type
:param propertyTypeId:
:param kwargs:
:return:
"""
session = kwargs['session']
dbAllowedPropertyValues = self.propertyTypeHandler.getAllowedPropertyTypeValuesById(session, propertyTypeId)
return self.toCdbObjectList(dbAllowedPropertyValues)
@CdbDbApi.executeQuery
def getPropertyTypeCategories(self, **kwargs):
"""
Get all property type category records.
:param kwargs:
:return: CdbObject List of resulting records.
"""
session = kwargs['session']
dbPropertyTypeCategories = self.propertyTypeCategoryHandler.getPropertyTypeCategories(session)
return self.toCdbObjectList(dbPropertyTypeCategories)
@CdbDbApi.executeTransaction
def addPropertyTypeCategory(self, propertyTypeCategoryName, description, **kwargs):
"""
Add a property type category record.
:param propertyTypeCategoryName:
:param description:
:param kwargs:
:return: (CdbObject) newly added record.
"""
session = kwargs['session']
dbPropertyTypeCategories = self.propertyTypeCategoryHandler.addPropertyTypeCategory(session, propertyTypeCategoryName, description)
return dbPropertyTypeCategories.getCdbObject()
@CdbDbApi.executeTransaction
def addPropertyType(self, propertyTypeName, description, propertyTypeCategoryName, propertyTypeHandlerName,
defaultValue, defaultUnits, isUserWriteable, isDynamic, isInternal, isActive, **kwargs):
"""
Add a property type record.
:param propertyTypeName:
:param description:
:param propertyTypeCategoryName:
:param propertyTypeHandlerName:
:param defaultValue:
:param defaultUnits:
:param isUserWriteable:
:param isDynamic:
:param isInternal:
:param isActive:
:param kwargs:
:return: (CdbObject) newly added record.
"""
session = kwargs['session']
dbPropertyType = self.propertyTypeHandler.addPropertyType(session, propertyTypeName, description,
propertyTypeCategoryName, propertyTypeHandlerName,
defaultValue, defaultUnits, isUserWriteable,
isDynamic, isInternal, isActive)
return dbPropertyType.toCdbObject()
@CdbDbApi.executeTransaction
def addAllowedPropertyValue(self, propertyTypeName, value, units, description, sortOrder, **kwargs):
"""
Add an allowed property value record.
:param propertyTypeName:
:param value:
:param units:
:param description:
:param sortOrder:
:param kwargs:
:return: (CdbObject) newly added record.
"""
session = kwargs['session']
dbAllowedPropertyValue = self.propertyTypeHandler.addAllowedPropertyValue(session, propertyTypeName, value, units, description, sortOrder)
return dbAllowedPropertyValue.toCdbObject()
@CdbDbApi.executeQuery
def getPropertyValueListForItemElementId(self, itemElementId, propertyTypeName = None, **kwargs):
"""
Get a property value list for a particular item element id.
NOTE: Item properties are in their 'self element'.
:param itemElementId:
:param propertyTypeName:
:param kwargs:
:return: CdbObject List of resulting records.
"""
session = kwargs['session']
dbPropertyValues = self.propertyValueHandler.getPropertyValueListForItemElementId(session, itemElementId, propertyTypeName)
return self.toCdbObjectList(dbPropertyValues)
@CdbDbApi.executeQuery
def getPropertyMetadataForPropertyValueId(self, propertyValueId, **kwargs):
"""
Get a property value metadata list for a property value with a certain id.
:param propertyValueId:
:param kwargs:
:return: CdbObject List of resulting records
"""
session = kwargs['session']
dbPropertyMetadata = self.propertyValueHandler.getPropertyValueMetadata(session, propertyValueId)
return self.toCdbObjectList(dbPropertyMetadata)
@CdbDbApi.executeTransaction
def addPropertyMetadataForPropertyValueId(self, propertyValueId, metadataKey, metadataValue, userId, **kwargs):
"""
Add propertyMetadata for a certain property value.
:param propertyValueId:
:param metadataKey:
:param metadataValue:
:param kwargs:
:return:
"""
session = kwargs['session']
dbProperyMetadata = self.propertyValueHandler.addPropertyValueMetadata(session, propertyValueId, metadataKey, metadataValue, userId)
return dbProperyMetadata.toCdbObject()
@CdbDbApi.executeTransaction
def addPropertyValueMetadataFromDict(self, propertyValueId, propertyValueMetadataKeyValueDict, userId, **kwargs):
"""
Add propertyMetadata for a certain property value using a key value dict.
:param propertyValueId:
:param propertyValueMetadataKeyValueDict:
:param kwargs:
:return:
"""
session = kwargs['session']
dbPropertyMetadata = self.propertyValueHandler.addPropertyValueMetadataFromDict(session, propertyValueId, propertyValueMetadataKeyValueDict, userId)
return self.toCdbObjectList(dbPropertyMetadata)
class ItemHandler(CdbDbEntityHandler):
CDB_ADMIN_GROUP_NAME = 'CDB_ADMIN'
def __init__(self):
CdbDbEntityHandler.__init__(self)
self.entityInfoHandler = EntityInfoHandler()
self.domainHandler = DomainHandler()
self.entityTypeHandler = EntityTypeHandler()
self.sourceHandler = SourceHandler()
self.logHandler = LogHandler()
self.propertyValueHandler = PropertyValueHandler()
self.relationshipTypeHandler = RelationshipTypeHandler()
self.resourceTypeHandler = ResourceTypeHandler()
self.userInfoHandler = UserInfoHandler()
def verifyPermissionsForWriteToItemElement(self,
session,
userId,
itemElementId=None,
dbItemElementObject=None):
if dbItemElementObject is None and itemElementId is None:
raise InvalidArgument(
"At least the item element id or item element object must be provided."
)
if dbItemElementObject is None:
dbItemElementObject = self.getItemElementById(
session, itemElementId)
else:
itemElementId = dbItemElementObject.id
dbUserInfo = self.userInfoHandler.getUserInfoById(session, userId)
dbEntityInfo = dbItemElementObject.entityInfo
ownerUserId = dbEntityInfo.ownerUserInfo.id
if ownerUserId == userId:
return True
ownerGroupWriteable = dbEntityInfo.is_group_writeable
ownerUserGroupId = dbEntityInfo.ownerUserGroup.id
for userGroup in dbUserInfo.userGroupList:
if ownerGroupWriteable:
if ownerUserGroupId == userGroup.id:
return True
if userGroup.name == self.CDB_ADMIN_GROUP_NAME:
return True
raise InvalidSession(
"User %s does not have permissions to modify item element %s" %
(userId, itemElementId))
def getItemById(self, session, id):
return self._findDbObjById(session, Item, id)
def getItemByQrId(self, session, qrId):
entityDisplayName = self._getEntityDisplayName(Item)
try:
dbItem = session.query(Item).filter(Item.qr_id == qrId).one()
return dbItem
except NoResultFound as ex:
raise ObjectNotFound('No %s with QR-Id: %s found.' %
(entityDisplayName, qrId))
def getItemElementsByName(self, session, name):
return self._findDbObjByName(session, ItemElement, name)
def getItemElementById(self, session, id):
return self._findDbObjById(session, ItemElement, id)
def getItemElementsByItemId(self, session, itemId):
entityDisplayName = self._getEntityDisplayName(ItemCategory)
try:
dbItemElements = session.query(ItemElement).filter(
ItemElement.parent_item_id == itemId).all()
return dbItemElements
except NoResultFound as ex:
raise ObjectNotFound('No %s with item id: %s found.' %
(entityDisplayName, itemId))
def addItemCategory(self, session, itemCategoryName, description,
domainName):
entityDisplayName = self._getEntityDisplayName(ItemCategory)
self.logger.debug('Adding %s %s' %
(entityDisplayName, itemCategoryName))
dbDomain = self.domainHandler.findDomainByName(session, domainName)
try:
self.getItemCategoryByName(session, itemCategoryName, dbDomain.id)
raise ObjectAlreadyExists(
'%s %s for domain %s already exists.' %
(entityDisplayName, itemCategoryName, dbDomain.name))
except ObjectNotFound as ex:
# ok
pass
# Create Entity Db Object
dbItemCategory = ItemCategory(name=itemCategoryName)
if description:
dbItemCategory.description = description
dbItemCategory.domain = dbDomain
session.add(dbItemCategory)
session.flush()
self.logger.debug('Inserted %s id %s' %
(entityDisplayName, dbItemCategory.id))
return dbItemCategory
def addItemProject(self, session, itemProjectName, description):
return self._addSimpleNameDescriptionTable(session, ItemProject,
itemProjectName,
description)
def getItemProjects(self, session):
self.logger.debug('Retrieving item projects.')
dbItemProjects = session.query(ItemProject).all()
return dbItemProjects
def addItemType(self, session, itemTypeName, description, domainName):
entityDisplayName = self._getEntityDisplayName(ItemType)
self.logger.debug('Adding %s %s' % (entityDisplayName, itemTypeName))
dbDomain = self.domainHandler.findDomainByName(session, domainName)
try:
self.getItemTypeByName(session, itemTypeName, dbDomain.id)
raise ObjectAlreadyExists(
'%s %s for domain %s already exists.' %
(entityDisplayName, itemTypeName, dbDomain.name))
except ObjectNotFound as ex:
# ok
pass
# Create Entity Db Object
dbItemType = ItemType(name=itemTypeName)
if description:
dbItemType.description = description
dbItemType.domain = dbDomain
session.add(dbItemType)
session.flush()
self.logger.debug('Inserted %s id %s' %
(entityDisplayName, dbItemType.id))
return dbItemType
def getItemCategoryByName(self, session, name, domainId):
entityDisplayName = self._getEntityDisplayName(ItemCategory)
try:
dbItem = session.query(ItemCategory).filter(ItemCategory.name==name)\
.filter(ItemCategory.domain_id == domainId).one()
return dbItem
except NoResultFound as ex:
raise ObjectNotFound('No %s with name: %s, domain id: %s exists.' %
(entityDisplayName, name, domainId))
def getItemProjectByName(self, session, itemProjectName):
return self._findDbObjByName(session, ItemProject, itemProjectName)
def getItemTypeByName(self, session, name, domainId):
entityDisplayName = self._getEntityDisplayName(ItemType)
try:
dbItem = session.query(ItemType).filter(ItemType.name==name)\
.filter(ItemType.domain_id == domainId).one()
return dbItem
except NoResultFound as ex:
raise ObjectNotFound('No %s with name: %s, domain id: %s exists.' %
(entityDisplayName, name, domainId))
def getItemConnectorById(self, session, id):
return self._findDbObjById(session, ItemConnector, id)
def getItemElementRelationshipById(self, session, id):
return self._findDbObjById(session, ItemElementRelationship, id)
def getItemByUniqueAttributes(self, session, domainId, name,
itemIdentifier1, itemIdentifier2,
derivedFromItemId):
entityDisplayName = self._getEntityDisplayName(Item)
try:
dbItem = session.query(Item).filter(Item.domain_id==domainId)\
.filter(Item.name==name)\
.filter(Item.item_identifier1==itemIdentifier1)\
.filter(Item.item_identifier2==itemIdentifier2)\
.filter(Item.derived_from_item_id==derivedFromItemId).one()
return dbItem
except NoResultFound as ex:
raise ObjectNotFound(
'No %s with name: %s, item identifier 1: %s, item identifier 2: %s in domain id %s exists.'
% (entityDisplayName, name, itemIdentifier1, itemIdentifier1,
domainId))
def addItem(self,
session,
domainName,
name,
derivedFromItemId,
itemIdentifier1,
itemIdentifier2,
entityTypeNames,
qrId,
description,
createdByUserId,
ownerUserId,
ownerGroupId,
isGroupWriteable,
createdOnDataTime=None,
lastModifiedOnDateTime=None):
dbItems = session.query(Item).filter(Item.name == name).all()
for item in dbItems:
if item.item_identifier1 == itemIdentifier1 \
and item.item_identifier2 == itemIdentifier2 \
and item.domain.name == domainName \
and item.derived_from_item_id == derivedFromItemId:
raise ObjectAlreadyExists('Item with name %s already exists.' %
name)
# Create entity info
entityInfoArgs = (createdByUserId, ownerUserId, ownerGroupId,
isGroupWriteable, createdOnDataTime,
lastModifiedOnDateTime)
# Create item
dbItem = Item(name=name)
dbItem.domain = self.domainHandler.findDomainByName(
session, domainName)
dbItem.derived_from_item_id = derivedFromItemId
dbItem.qr_id = qrId
dbItem.item_identifier1 = itemIdentifier1
dbItem.item_identifier2 = itemIdentifier2
session.add(dbItem)
session.flush()
# Add self element
self.addItemElement(session, None, dbItem.id, None, False, description,
*entityInfoArgs)
self.logger.debug('Inserted item id %s' % dbItem.id)
if entityTypeNames is not None:
if type(entityTypeNames) is list:
for entityTypeName in entityTypeNames:
self.addItemEntityType(session, None, entityTypeName,
dbItem)
elif type(entityTypeNames) is str:
self.addItemEntityType(session, None, entityTypeNames, dbItem)
return dbItem
def getSelfElementByItemId(self, session, itemId):
entityDisplayName = self._getEntityDisplayName(ItemElement)
try:
dbItemElement = session.query(ItemElement)\
.filter(ItemElement.parent_item_id==itemId)\
.filter(ItemElement.name==None)\
.filter(ItemElement.derived_from_item_element_id==None).one()
return dbItemElement
except NoResultFound as ex:
raise ObjectNotFound('No %s with id %s exists.' %
(entityDisplayName, id))
def getItemsOfDomain(self, session, domainName):
entityDisplayName = self._getEntityDisplayName(Item)
try:
query = session.query(Item).join(Domain)
query = query.filter(Domain.name == domainName)
dbItems = query.all()
return dbItems
except NoResultFound as ex:
raise ObjectNotFound("No %ss with domain %s found." %
(entityDisplayName, domainName))
def getItemsDerivedFromItem(self, session, derivedItemId):
entityDisplayName = self._getEntityDisplayName(Item)
try:
query = session.query(Item).join(Domain)
query = query.filter(Item.derived_from_item_id == derivedItemId)
dbItems = query.all()
return dbItems
except NoResultFound as ex:
raise ObjectNotFound("No %ss derived from item id %s found." %
(entityDisplayName, derivedItemId))
def getItemsWithPropertyTypeName(self,
session,
propertyTypeName,
itemDomainName=None,
itemDerivedFromItemId=None,
propertyValueMatch=None):
entityDisplayName = self._getEntityDisplayName(Item)
try:
query = session.query(Item)\
.join(ItemElement.parentItem)\
.join(ItemElementProperty)\
.join(PropertyValue)\
.join(PropertyType)\
.filter(PropertyType.name == propertyTypeName)
if itemDerivedFromItemId is not None:
query = query.filter(
Item.derived_from_item_id == itemDerivedFromItemId)
if propertyValueMatch is not None:
query = query.filter(PropertyValue.value == propertyValueMatch)
if itemDomainName is not None:
query = query.join(Domain)
query = query.filter(Domain.name == itemDomainName)
dbItems = query.all()
return dbItems
except NoResultFound as ex:
raise ObjectNotFound("No %ss with property type %s found." %
(entityDisplayName, propertyTypeName))
def addItemEntityType(self, session, itemId, entityTypeName, item=None):
dbItemEntityType = ItemEntityType()
if item:
dbItemEntityType.item = item
else:
dbItemEntityType.item = self.getItemById(session, itemId)
dbItemEntityType.entityType = self.entityTypeHandler.findEntityTypeByName(
session, entityTypeName)
session.add(dbItemEntityType)
session.flush()
self.logger.debug('Inserted Item Entity Type for item id %s' %
dbItemEntityType.item.id)
return dbItemEntityType
def addItemElement(self,
session,
name,
parentItemId,
containedItemId,
isRequired,
description,
createdByUserId,
ownerUserId,
ownerGroupId,
isGroupWriteable,
createdOnDataTime=None,
lastModifiedOnDateTime=None):
dbItemElements = session.query(ItemElement).filter(
ItemElement.name == name).all()
for element in dbItemElements:
if element.parent_item_id == parentItemId and element.name == name:
raise ObjectAlreadyExists(
'Item Element with name %s already exists.' % name)
parentSelfElement = self.getSelfElementByItemId(session, parentItemId)
self.verifyPermissionsForWriteToItemElement(
session, createdByUserId, dbItemElementObject=parentSelfElement)
# Create entity info
dbEntityInfo = self.entityInfoHandler.createEntityInfo(
session, createdByUserId, ownerUserId, ownerGroupId,
isGroupWriteable, createdOnDataTime, lastModifiedOnDateTime)
# Create item
dbItemElement = ItemElement(name=name, description=description)
dbItemElement.entityInfo = dbEntityInfo
if parentItemId:
dbItemElement.parentItem = self.getItemById(session, parentItemId)
if containedItemId:
dbItemElement.containedItem = self.getItemById(
session, containedItemId)
entityInfo = parentSelfElement.entityInfo
parentSelfElement.entityInfo = self.entityInfoHandler.updateEntityInfo(
session, entityInfo, createdByUserId)
session.add(parentSelfElement)
session.add(dbItemElement)
session.flush()
self.logger.debug('Inserted item Element id %s' % dbItemElement.id)
return dbItemElement
def addItemSource(self, session, itemId, sourceName, partNumber, cost,
description, isVendor, isManufacturer, contactInfo, url):
dbItem = self.getItemById(session, itemId)
dbSource = self.sourceHandler.findSourceByName(session, sourceName)
dbItemSource = ItemSource()
dbItemSource.item = dbItem
dbItemSource.source = dbSource
if partNumber:
dbItemSource.part_number = partNumber
if cost:
dbItemSource.cost = cost
if description:
dbItemSource.description = description
if isVendor:
dbItemSource.is_vendor = isVendor
if isManufacturer:
dbItemSource.is_manufacturer = isManufacturer
if contactInfo:
dbItemSource.contact_info = contactInfo
if url:
dbItemSource.url = url
session.add(dbItemSource)
session.flush()
self.logger.debug('Inserted item source %s' % dbItemSource.id)
return dbItemSource
def addItemItemCategory(self, session, itemId, itemCategoryName):
dbItem = self.getItemById(session, itemId)
domainId = dbItem.domain.id
dbCategory = self.getItemCategoryByName(session, itemCategoryName,
domainId)
dbItemItemCategory = ItemItemCategory()
dbItemItemCategory.item = dbItem
dbItemItemCategory.category = dbCategory
session.add(dbItemItemCategory)
session.flush()
self.logger.debug('Added category %s for item id %s' %
(itemCategoryName, itemId))
return dbItemItemCategory
def addItemItemProject(self, session, itemId, itemProjectName):
dbItem = self.getItemById(session, itemId)
dbProject = self.getItemProjectByName(session, itemProjectName)
dbItemItemProject = ItemItemProject()
dbItemItemProject.item = dbItem
dbItemItemProject.project = dbProject
session.add(dbItemItemProject)
session.flush()
self.logger.debug('Added category %s for item id %s' %
(itemProjectName, itemId))
return dbItemItemProject
def addItemItemType(self, session, itemId, itemTypeName):
dbItem = self.getItemById(session, itemId)
domainId = dbItem.domain.id
dbType = self.getItemTypeByName(session, itemTypeName, domainId)
dbItemItemType = ItemItemType()
dbItemItemType.item = dbItem
dbItemItemType.type = dbType
session.add(dbItemItemType)
session.flush()
self.logger.debug('Added type %s for item id %s' %
(itemTypeName, itemId))
return dbItemItemType
def addItemElementLog(self,
session,
itemElementId,
text,
enteredByUserId,
effectiveFromDateTime,
effectiveToDateTime,
logTopicName,
enteredOnDateTime=None,
systemLogLevelName=None):
dbItemElement = self.getItemElementById(session, itemElementId)
self.verifyPermissionsForWriteToItemElement(
session, enteredByUserId, dbItemElementObject=dbItemElement)
dbLog = self.logHandler.addLog(session, text, enteredByUserId,
effectiveFromDateTime,
effectiveToDateTime, logTopicName,
enteredOnDateTime)
if systemLogLevelName is not None:
self.logHandler.addSystemLog(session, dbLog, systemLogLevelName)
dbItemElementLog = ItemElementLog()
dbItemElementLog.itemElement = dbItemElement
dbItemElementLog.log = dbLog
entityInfo = dbItemElement.entityInfo
dbItemElement.entityInfo = self.entityInfoHandler.updateEntityInfo(
session, entityInfo, enteredByUserId)
session.add(dbItemElement)
session.add(dbItemElementLog)
session.flush()
self.logger.debug('Added log for itemElement id %s' % (itemElementId))
return dbItemElementLog
def addItemElementProperty(self,
session,
itemElementId,
propertyTypeName,
tag,
value,
units,
description,
enteredByUserId,
isUserWriteable,
isDynamic,
displayValue,
targetValue,
enteredOnDateTime=None):
dbItemElement = self.getItemElementById(session, itemElementId)
self.verifyPermissionsForWriteToItemElement(
session, enteredByUserId, dbItemElementObject=dbItemElement)
dbPropertyValue = self.propertyValueHandler.createPropertyValue(
session, propertyTypeName, tag, value, units, description,
enteredByUserId, isUserWriteable, isDynamic, displayValue,
targetValue, enteredOnDateTime)
session.add(dbPropertyValue)
dbItemElementProperty = ItemElementProperty()
dbItemElementProperty.itemElement = dbItemElement
dbItemElementProperty.propertyValue = dbPropertyValue
entityInfo = dbItemElement.entityInfo
dbItemElement.entityInfo = self.entityInfoHandler.updateEntityInfo(
session, entityInfo, enteredByUserId)
session.add(dbItemElement)
session.add(dbItemElementProperty)
session.flush()
self.logger.debug(
'Added property value (type: %s) for item element id %s' %
(propertyTypeName, itemElementId))
return dbItemElementProperty
def addItemElementRelationship(self, session, firstItemElementId,
secondItemElementId, firstItemConnectorId,
secondItemConnectorId, linkItemElementId,
relationshipTypeName, relationshipDetails,
resourceTypeName, label, description):
if firstItemElementId is None:
raise InvalidArgument(
"First item element Id must be specified for a item element relationship"
)
firstItemElement = self.getItemElementById(session, firstItemElementId)
dbItemElementRelationship = ItemElementRelationship()
dbItemElementRelationship.firstItemElement = firstItemElement
if secondItemElementId is not None:
secondItemElement = self.getItemElementById(
session, secondItemElementId)
dbItemElementRelationship.secondItemElement = secondItemElement
relationshipType = self.relationshipTypeHandler.getRelationshipTypeByName(
session, relationshipTypeName)
dbItemElementRelationship.relationshipType = relationshipType
dbItemElementRelationship.relationship_details = relationshipDetails
dbItemElementRelationship.label = label
dbItemElementRelationship.description = description
if firstItemConnectorId:
dbItemElementRelationship.firstItemConnector = self.getItemConnectorById(
firstItemConnectorId)
if secondItemConnectorId:
dbItemElementRelationship.secondItemConnector = self.getItemConnectorById(
secondItemConnectorId)
if linkItemElementId:
dbItemElementRelationship.linkItemElement = self.getItemElementById(
linkItemElementId)
if resourceTypeName:
dbItemElementRelationship.resourceType = self.resourceTypeHandler.getResourceTypeByName(
session, resourceTypeName)
session.add(dbItemElementRelationship)
session.flush()
entityDisplayName = self._getEntityDisplayName(ItemElementRelationship)
self.logger.debug('Inserted %s %s' %
(entityDisplayName, dbItemElementRelationship.id))
return dbItemElementRelationship
def addItemElementRelationshipHistory(
self, session, itemRelationshipId, firstItemElementId,
secondItemElementId, firstItemConnectorId, secondItemConnectorId,
linkItemElementId, relationshipDetails, resourceTypeName, label,
description, enteredByUserId, enteredOnDateTime):
firstItemElement = self.getItemElementById(session, firstItemElementId)
secondItemElement = self.getItemElementById(session,
secondItemElementId)
dbItemElementRelationship = self.getItemElementRelationshipById(
session, itemRelationshipId)
dbItemElementRelationshipHistory = ItemElementRelationshipHistory()
dbItemElementRelationshipHistory.firstItemElement = firstItemElement
dbItemElementRelationshipHistory.secondItemElement = secondItemElement
dbItemElementRelationshipHistory.itemElementRelationship = dbItemElementRelationship
dbItemElementRelationshipHistory.relationship_details = relationshipDetails
dbItemElementRelationshipHistory.label = label
dbItemElementRelationshipHistory.description = description
dbItemElementRelationshipHistory.enteredByUserInfo = self.userInfoHandler.getUserInfoById(
session, enteredByUserId)
dbItemElementRelationshipHistory.entered_on_date_time = enteredOnDateTime
if firstItemConnectorId:
dbItemElementRelationshipHistory.firstItemConnector = self.getItemConnectorById(
firstItemConnectorId)
if secondItemConnectorId:
dbItemElementRelationshipHistory.secondItemConnector = self.getItemConnectorById(
secondItemConnectorId)
if linkItemElementId:
dbItemElementRelationshipHistory.linkItemElement = self.getItemElementById(
linkItemElementId)
if resourceTypeName:
dbItemElementRelationshipHistory.resourceType = self.resourceTypeHandler.getResourceTypeByName(
session, resourceTypeName)
session.add(dbItemElementRelationshipHistory)
session.flush()
entityDisplayName = self._getEntityDisplayName(
ItemElementRelationshipHistory)
self.logger.debug(
'Inserted %s %s' %
(entityDisplayName, dbItemElementRelationshipHistory.id))
return dbItemElementRelationshipHistory
def __init__(self):
CdbDbApi.__init__(self)
self.propertyValueHandler = PropertyValueHandler()
self.itemHandler = ItemHandler()
class DeveloperDbApi(CdbDbApi):
"""
Db apis that perform updates/inserts with specific dates,
should only be used if moving data with date importance.
Usually, dates should just be auto-generated at the time of adding to db.
"""
def __init__(self):
CdbDbApi.__init__(self)
self.propertyValueHandler = PropertyValueHandler()
self.itemHandler = ItemHandler()
@CdbDbApi.executeTransaction
def addPropertyValueHistory(self, propertyValueId, tag, value, units,
description, enteredByUserId,
enteredOnDateTime, displayValue, targetValue,
**kwargs):
"""
Adds a property value history record.
:param propertyValueId: id of the property value history is being added for.
:param tag:
:param value:
:param units:
:param description:
:param enteredByUserId:
:param enteredOnDateTime:
:param displayValue:
:param targetValue:
:param kwargs:
:return: newly added record
"""
session = kwargs['session']
dbPropertyValueHistory = self.propertyValueHandler.addPropertyValueHistory(
session, propertyValueId, tag, value, units, description,
enteredByUserId, enteredOnDateTime, displayValue, targetValue)
return dbPropertyValueHistory.toCdbObject()
@CdbDbApi.executeTransaction
def addItemElementRelationshipHistory(
self, itemRelationshipId, firstItemElementId, secondItemElementId,
firstItemConnectorId, secondItemConnectorId, linkItemElementId,
relationshipDetails, resourceTypeName, label, description,
enteredByUserId, enteredOnDateTime, **kwargs):
"""
Adds an item element relationship history record.
:param itemRelationshipId: id of the relationship that history is being added for.
:param firstItemElementId:
:param secondItemElementId:
:param firstItemConnectorId:
:param secondItemConnectorId:
:param linkItemElementId:
:param relationshipDetails:
:param resourceTypeName:
:param label:
:param description:
:param enteredByUserId:
:param enteredOnDateTime:
:param kwargs:
:return: newly added record.
"""
session = kwargs['session']
dbItemElementRelationshipHistory = self.itemHandler.addItemElementRelationshipHistory(
session, itemRelationshipId, firstItemElementId,
secondItemElementId, firstItemConnectorId, secondItemConnectorId,
linkItemElementId, relationshipDetails, resourceTypeName, label,
description, enteredByUserId, enteredOnDateTime)
return dbItemElementRelationshipHistory.toCdbObject()
