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)