def loadLatticeCsvFile(cls, fileName):
if fileName.find('.') < 0 or fileName.split('.')[-1].lower() != 'csv':
raise InvalidArgument('Input file must be in CSV format.')
if not os.path.exists(fileName):
raise InvalidArgument('Input file %s does not exist.' % fileName)
# These keys are design element attributes (not properties).
# Any other keys are property names.
replacementKeyMap = {
'ElementName': 'name',
'ElementType': 'componentName'
}
# Read headers
csvFile = open(fileName, 'r')
content = csvFile.read()
if content.find('\r'):
lineList = content.split('\r')
elif content.find('\n'):
lineList = content.split('\n')
else:
raise InvalidArgument('Input file %s cannot be parsed.' % fileName)
headerList = lineList[0].split(',')
index = 0
headerMap = {}
for h in headerList:
key = h.strip()
if key is not None:
headerMap[key] = index
index += 1
designElementList = []
nColumns = index
sortOrder = 1.0
for line in lineList[1:]:
if not line:
break
valueList = line.split(',')
if len(valueList) != nColumns:
break
designElementDict = {'sortOrder': sortOrder}
for (key, index) in headerMap.items():
if valueList[index] is None:
continue
if replacementKeyMap.has_key(key):
# Design element attribute
designElementDict[replacementKeyMap.get(
key)] = valueList[index]
else:
# Design element property
value = '%s' % valueList[index]
if len(value) > 0:
propertyList = designElementDict.get(
'propertyList', [])
property = {'name': key, 'value': valueList[index]}
propertyList.append(property)
designElementDict['propertyList'] = propertyList
designElementList.append(designElementDict)
sortOrder += 1.0
return designElementList
def addItemEntityType(self, session, itemId, entityTypeName, item=None):
dbItemEntityType = ItemEntityType()
dbEntityType = self.entityTypeHandler.findEntityTypeByName(
session, entityTypeName)
if not item:
item = self.getItemById(session, itemId)
dbAllowedEntityTypeDomains = self.domainHandler.getAllowedEntityTypeDomain(
session, item.domain_id)
found = False
for allowedEntityTypeDomain in dbAllowedEntityTypeDomains:
allowedEntityType = allowedEntityTypeDomain.entityType
if entityTypeName == allowedEntityType.name:
found = True
break
if not found:
raise InvalidArgument(
"Entity type name: %s cannot be added to domain of item." %
entityTypeName)
dbItemEntityType.item = item
dbItemEntityType.entityType = dbEntityType
session.add(dbItemEntityType)
session.flush()
self.logger.debug('Inserted Item Entity Type for item id %s' %
dbItemEntityType.item.id)
return dbItemEntityType
def updateLog(self,
session,
logId,
enteredByUserId,
text=None,
effectiveFromDateTime=None,
effectiveToDateTime=None,
logTopicName=None):
if text is None and effectiveFromDateTime is None and effectiveToDateTime is None and logTopicName is None:
raise InvalidArgument("No argument was provided to update log %s" %
logId)
dbLogEntry = self.findLogById(session, logId)
self.verifyUserCreatedLogEntry(session,
enteredByUserId,
dbLogObject=dbLogEntry)
if text is not None:
dbLogEntry.text = text
if effectiveFromDateTime is not None:
dbLogEntry.effective_from_date_time = effectiveFromDateTime
if effectiveToDateTime is not None:
dbLogEntry.effective_to_date_time = effectiveToDateTime
if logTopicName is not None:
dbLogTopic = self.findLogTopicByName(session, logTopicName)
dbLogEntry.logTopic = dbLogTopic
session.add(dbLogEntry)
session.flush()
self.logger.debug('Updated Log id %s' % logId)
return dbLogEntry
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 updateItemStatus(self, session, itemId, itemStatusName,
enteredByUserId):
dbItem = self.getItemById(session, itemId)
if (dbItem.domain.name != itemDomain.INVENTORY_DOMAIN_NAME):
# Item is not inventory item
raise InvalidArgument("Item id: %s is not inventory item.")
selfElement = self.getSelfElementByItemId(session, itemId)
selfElementId = selfElement.id
self.permissionHandler.verifyPermissionsForWriteToItemElement(
session, enteredByUserId, dbItemElementObject=selfElement)
propertyValueList = self.propertyValueHandler.getPropertyValueListForItemElementId\
(session, selfElementId, self.ITEM_STATUS_PROPERTY_TYPE_NAME)
if (propertyValueList.__len__() == 0):
return self.addItemElementProperty(
session,
selfElementId,
self.ITEM_STATUS_PROPERTY_TYPE_NAME,
value=itemStatusName,
enteredByUserId=enteredByUserId,
allowInternal=True)
else:
propertyValueId = propertyValueList[0].id
return self.propertyValueHandler.updatePropertyValueById(
session,
propertyValueId,
value=itemStatusName,
enteredByUserId=enteredByUserId)
def addItemElementRelationship(self,
session,
firstItemElementId,
secondItemElementId,
firstItemConnectorId,
secondItemConnectorId,
linkItemElementId,
relationshipTypeName,
relationshipDetails,
resourceTypeName,
label,
description,
existingRelationship=None):
if firstItemElementId is None:
raise InvalidArgument(
"First item element Id must be specified for a item element relationship"
)
firstItemElement = self.getItemElementById(session, firstItemElementId)
if existingRelationship is None:
dbItemElementRelationship = ItemElementRelationship()
else:
dbItemElementRelationship = existingRelationship
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 __init__(self, dict={}):
if isinstance(dict, dict):
UserDict.UserDict.__init__(self, dict)
elif isinstance(dict, UserDict.UserDict):
UserDict.UserDict.__init__(self, dict.data)
else:
raise InvalidArgument('CdbObject instance must be initialized using dictionary.')
self.logger = None
def checkPropertyValueIsAllowed(cls, propertyValue, dbAllowedPropertyValueList):
# If allowed property value list is empty, value is ok
if dbAllowedPropertyValueList is None or len(dbAllowedPropertyValueList) == 0:
return
for dbAllowedPropertyValue in dbAllowedPropertyValueList:
if propertyValue == dbAllowedPropertyValue.value:
return
raise InvalidArgument('Property value %s is not allowed.' % propertyValue)
def getDisplayString(self, displayKeyList=[], displayFormat=TEXT_DISPLAY_FORMAT):
""" Get display string. """
if displayFormat == CdbObject.DICT_DISPLAY_FORMAT:
return self.getDictRep(displayKeyList)
elif displayFormat == CdbObject.TEXT_DISPLAY_FORMAT:
return self.getTextRep(displayKeyList)
elif displayFormat == CdbObject.JSON_DISPLAY_FORMAT:
return self.getJsonRep(displayKeyList)
raise InvalidArgument('Unrecognized display displayFormat: %s.' (displayFormat))
def verifyUserCreatedLogEntry(self,
session,
userId,
logId=None,
dbLogObject=None):
if logId is None and dbLogObject is None:
raise InvalidArgument(
"At least log id or db log object must be provided.")
if dbLogObject is None:
dbLogObject = self.findLogById(session, logId)
else:
logId = dbLogObject.id
if userId == dbLogObject.entered_by_user_id:
return True
raise InvalidSession("The log entry %s was created by another user." %
logId)
def parseArgs(self, usage=None):
if usage:
self.parser.usage = usage
try:
(self.options, self.args) = self.parser.parse_args()
self.processArgs()
except SystemExit as rc:
sys.stdout.flush()
sys.stderr.flush()
sys.exit(int(str(rc)))
if self.validArgCount < len(self.args):
# Positional args are not enabled and we have some
msg = 'Invalid positional argument(s):'
for arg in self.args[self.validArgCount:]:
msg += ' ' + arg
msg += ' (This command allows %s positional arguments.)' % self.validArgCount
raise InvalidArgument(msg)
optDict = self.options.__dict__
if optDict.get('version'):
print('CDB Software Version: %s' % (cdb.__version__))
sys.exit(0)
# Logging level. First try from command line, then from env variable.
consoleLogLevel = optDict.get('consoleLogLevel', None)
if consoleLogLevel:
LoggingManager.getInstance().setConsoleLogLevel(consoleLogLevel)
else:
consoleLogLevel = ConfigurationManager.getInstance(
).getConsoleLogLevelFromEnvVar()
if consoleLogLevel:
LoggingManager.getInstance().setConsoleLogLevel(
consoleLogLevel)
# Check session cache.
configManager = ConfigurationManager.getInstance()
try:
self.checkSessionCache()
except Exception as ex:
self.logger.warn('Disabling session cache: %s' % ex)
configManager.setSessionCacheFile(None)
return (self.options, self.args)
def getRepKeyList(self, keyList):
if keyList is None:
return self.DEFAULT_KEY_LIST
elif type(keyList) == list:
if not len(keyList):
return self.DEFAULT_KEY_LIST
else:
return keyList
elif type(keyList) == bytes:
if keyList == CdbObject.ALL_KEYS:
return list(self.data.keys())
elif keyList == CdbObject.DEFAULT_KEYS:
return self.DEFAULT_KEY_LIST
else:
# Assume keys are separated by comma
return keyList.split(',')
else:
# Unknown key list parameter.
raise InvalidArgument('Key list parameter must be one of: None, string "%s", string "%s", string containing comma-separated keys, or list of strings.' (CdbObject.ALL_KEYS, CdbObject.DEFAULT_KEYS))
def addItemItemProject(self,
session,
itemProjectName,
dbItem=None,
itemId=None):
if itemId is None and dbItem is None:
raise InvalidArgument("item id must be provided.")
if dbItem is None:
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 checkDrawingNumber(cls, drawingNumber):
if drawingNumber.count('.') != 1 or drawingNumber.split('.')[-1].lower() not in cls.VALID_EXTENSION_LIST:
raise InvalidArgument('PDMLink drawing name must have one of the following extensions: %s' % cls.VALID_EXTENSION_LIST)
def addValidItemElementRelationship(self,
session,
firstItemElementId,
secondItemElementId,
relationshipTypeName,
enteredByUserId,
relationshipDetails=None,
description=None):
# defaults
firstItemConnectorId = None
secondItemConnectorId = None
linkItemElementId = None
resourceTypeName = None
label = None
mayAdd = False
existingItemElementRelationship = None
relationshipType = self.relationshipTypeHandler.getRelationshipTypeByName(
session, relationshipTypeName)
relationshipTypeName = relationshipType.name
firstItemElement = self.getItemElementById(session, firstItemElementId)
secondItemElement = self.getItemElementById(session,
secondItemElementId)
firstDomainName = firstItemElement.parentItem.domain.name
secondDomainName = secondItemElement.parentItem.domain.name
ierList = self.getItemElementRelationshipListByRelationshipTypeNameAndFirstItemElementId(
session, relationshipTypeName, firstItemElementId)
if relationshipTypeName == self.relationshipTypeHandler.LOCATION_RELATIONSHIP_TYPE_NAME:
if firstDomainName == self.domainHandler.INVENTORY_DOMAIN_NAME and secondDomainName == self.domainHandler.LOCATION_DOMAIN_NAME:
if ierList.__len__() > 0:
# Only one is allowed update
if ierList.__len__() > 1:
raise InvalidObjectState(
"Item has multiple location relationships.")
locationRelationship = ierList[0]
if locationRelationship.second_item_element_id == secondItemElementId:
raise InvalidObjectState(
"Item is already in the specified location")
existingItemElementRelationship = locationRelationship
mayAdd = True
else:
mayAdd = True
else:
raise InvalidArgument(
"First item element should be inventory and second location. Invalid item element ids provided."
)
elif relationshipTypeName == self.relationshipTypeHandler.MAARC_CONNECTION_RELATIONSHIP_TYPE_NAME:
if firstDomainName == self.domainHandler.INVENTORY_DOMAIN_NAME or firstDomainName == self.domainHandler.MACHINE_DESIGN_NAME:
if secondDomainName == self.domainHandler.MAARC_DOMAIN_NAME:
# Check for duplicates
for itemElementRelationship in ierList:
if itemElementRelationship.first_item_element_id == firstItemElementId and itemElementRelationship.second_item_element_id == secondItemElementId:
raise ObjectAlreadyExists(
"The maarc connection relationship between the specified item elements already exists"
)
mayAdd = True
if not mayAdd:
raise InvalidArgument(
"First item element should be inventory or machine design and second maarc. Invalid item element ids provided."
)
else:
raise InvalidArgument(
"Unsupported relationship type name has been specified: %s." %
relationshipTypeName)
if mayAdd:
dbItemElementRelationship = self.addItemElementRelationship(
session, firstItemElementId, secondItemElementId,
firstItemConnectorId, secondItemConnectorId, linkItemElementId,
relationshipTypeName, relationshipDetails, resourceTypeName,
label, description, existingItemElementRelationship)
# Add initial history item
self.addItemElementRelationshipHistory(
session, dbItemElementRelationship.id, firstItemElementId,
secondItemElementId, firstItemConnectorId,
secondItemConnectorId, linkItemElementId, relationshipDetails,
resourceTypeName, label, description, enteredByUserId)
return dbItemElementRelationship
class CdbCli(object):
""" Base cdb command line interface class. """
DEFAULT_SESSION_CACHE_FILE = OsUtility.getUserHomeDir() + '/.cdb/.session.cache'
ANY_NUMBER_OF_POSITIONAL_ARGS = 10000000
def __init__(self, validArgCount=0):
self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
# Do not log into a file for CLIs
LoggingManager.getInstance().setFileLogLevel('CRITICAL')
LoggingManager.getInstance().setConsoleLogLevel('CRITICAL')
self.parser = CdbOptionParser()
self.options = {}
self.args = []
self.validArgCount = validArgCount
self.optionGroupDict = {}
commonGroup = 'Common Options'
self.addOptionGroup(commonGroup, None)
self.addOptionToGroup(commonGroup, '-h', '--help', action='help', help='Show this help message and exit.')
self.addOptionToGroup(commonGroup, '-?', '', action='help', help='Show this help message and exit.')
self.addOptionToGroup(commonGroup, '-v', '--version', action='store_true', dest='version', default=False, help='Print version and exit.')
self.addOptionToGroup(commonGroup, '-d', '--debug', dest='consoleLogLevel', help='Set debug level (valid values: CRITICAL, ERROR, WARNING, INFO, DEBUG). Console log level can also be set via CDB_CONSOLE_LOG_LEVEL environment variable,')
self.addOptionToGroup(commonGroup, '', '--display-format', dest='displayFormat', default=CdbObject.TEXT_DISPLAY_FORMAT, help='Display format for output objects. Possible options are: %s, %s, and %s (default: %s).' % (CdbObject.TEXT_DISPLAY_FORMAT, CdbObject.DICT_DISPLAY_FORMAT, CdbObject.JSON_DISPLAY_FORMAT, CdbObject.TEXT_DISPLAY_FORMAT))
self.addOptionToGroup(commonGroup, '', '--display-keys', dest='displayKeys', default=CdbObject.DEFAULT_KEYS, help='List of output object keys to display. Possible options are: %s, %s, and string containing comma-separated keys (default: %s, represents class default keys).' % (CdbObject.DEFAULT_KEYS, CdbObject.ALL_KEYS, CdbObject.DEFAULT_KEYS))
def getDefaultServiceHost(self):
return ConfigurationManager.getInstance().getServiceHost()
def getDefaultServicePort(self):
return ConfigurationManager.getInstance().getServicePort()
def getDefaultServiceProtocol(self):
return ConfigurationManager.getInstance().getServiceProtocol()
def getUsername(self):
return None
def getPassword(self):
return None
def getDisplayFormat(self):
return self.options.displayFormat
def getDisplayKeys(self):
return self.options.displayKeys
def getLogger(self):
return self.logger
def getParser(self):
return self.parser
def addOption(self, *args, **kwargs):
self.parser.add_option(*args, **kwargs)
def addOptionToGroup(self, groupName, *args, **kwargs):
""" Add group option. Group must be created using addOptionGroup(). """
group = self.optionGroupDict.get(groupName)
group.add_option(*args, **kwargs)
def addOptionGroup(self, groupName, desc):
group = OptionGroup(self.parser, groupName, desc)
self.parser.add_option_group(group)
self.optionGroupDict[groupName] = group
def processArgs(self):
pass
def parseArgs(self, usage=None):
if usage:
self.parser.usage = usage
try:
(self.options, self.args) = self.parser.parse_args()
self.processArgs()
except SystemExit, rc:
sys.stdout.flush()
sys.stderr.flush()
sys.exit(int(str(rc)))
if self.validArgCount < len(self.args):
# Positional args are not enabled and we have some
msg = 'Invalid positional argument(s):'
for arg in self.args[self.validArgCount:]:
msg += ' ' + arg
msg += ' (This command allows %s positional arguments.)' % self.validArgCount
raise InvalidArgument(msg)
optDict = self.options.__dict__
if optDict.get('version'):
print 'CDB Software Version: %s' % (cdb.__version__)
sys.exit(0)
# Logging level. First try from command line, then from env variable.
consoleLogLevel = optDict.get('consoleLogLevel', None)
if consoleLogLevel:
LoggingManager.getInstance().setConsoleLogLevel(consoleLogLevel)
else:
consoleLogLevel = ConfigurationManager.getInstance().getConsoleLogLevelFromEnvVar()
if consoleLogLevel:
LoggingManager.getInstance().setConsoleLogLevel(consoleLogLevel)
# Check session cache.
configManager = ConfigurationManager.getInstance()
try:
self.checkSessionCache()
except Exception, ex:
self.logger.warn('Disabling session cache: %s' % ex)
configManager.setSessionCacheFile(None)
def addItem(self,
session,
domainName,
name,
createdByUserId,
ownerUserId,
ownerGroupId,
itemProjectName,
itemIdentifier1=None,
itemIdentifier2=None,
qrId=None,
description=None,
isGroupWriteable=True,
createdOnDataTime=None,
lastModifiedOnDateTime=None,
derivedFromItemId=None,
entityTypeNames=None):
# Create entity info
entityInfoArgs = (createdByUserId, ownerUserId, ownerGroupId,
isGroupWriteable, createdOnDataTime,
lastModifiedOnDateTime)
domain = self.domainHandler.findDomainByName(session, domainName)
# Verify valid project
if itemProjectName is None:
raise InvalidArgument(
"Please specify an item project for the new item")
self.getItemProjectByName(session, itemProjectName)
try:
if self.getItemByUniqueAttributes(session, domain.id, name,
itemIdentifier1, itemIdentifier2,
derivedFromItemId):
raise ObjectAlreadyExists(
"Item with attributes already exists: "
"(domain=%s, name='%s', item_identifier1=%s, item_identifier2=%s and derivedFromItemId=%s)"
% (domain.name, name, itemIdentifier1, itemIdentifier2,
derivedFromItemId))
except ObjectNotFound:
pass
if (itemDomain.INVENTORY_DOMAIN_NAME == domainName):
if derivedFromItemId is None:
raise InvalidArgument(
"To create an inventory item, the derived from item id must be provided."
)
else:
derivedItem = self.getItemById(session, derivedFromItemId)
if not derivedItem.domain.name == itemDomain.CATALOG_DOMAIN_NAME:
raise InvalidArgument(
"To create an inventory item, the derived from item id must be of a catalog item."
)
# Create item
dbItem = Item(name=name)
dbItem.domain = domain
dbItem.derived_from_item_id = derivedFromItemId
dbItem.qr_id = qrId
dbItem.item_identifier1 = itemIdentifier1
dbItem.item_identifier2 = itemIdentifier2
try:
session.add(dbItem)
session.flush()
except OperationalError, err:
raise DbError(err.message)
