def WriteObjectPropertyChangeLog(oType, sObjectID, sLabel, sFrom, sTo): if sFrom and sTo: if sFrom != sTo: sLog = "Changed: " + sLabel + " from [" + catocommon.tick_slash( sFrom) + "] to [" + catocommon.tick_slash(sTo) + "]." AddSecurityLog(uiGlobals.SecurityLogTypes.Object, uiGlobals.SecurityLogActions.ObjectAdd, oType, sObjectID, sLog)
def WriteObjectChangeLog(oType, sObjectID, sObjectName, sLog = ""): if sObjectID and sObjectName: if not sObjectName: sObjectName = "[" + catocommon.tick_slash(sObjectName) + "]." else: sLog = "Changed: [" + catocommon.tick_slash(sObjectName) + "] - [" + sLog + "]" AddSecurityLog(uiGlobals.SecurityLogTypes.Object, uiGlobals.SecurityLogActions.ObjectAdd, oType, sObjectID, sLog)
def WriteObjectChangeLog(oType, sObjectID, sObjectName, sLog=""): if sObjectID and sObjectName: if not sObjectName: sObjectName = "[" + catocommon.tick_slash(sObjectName) + "]." else: sLog = "Changed: [" + catocommon.tick_slash( sObjectName) + "] - [" + sLog + "]" AddSecurityLog(uiGlobals.SecurityLogTypes.Object, uiGlobals.SecurityLogActions.ObjectAdd, oType, sObjectID, sLog)
def DBUpdate(self): try: db = catocommon.new_conn() # if the password has not changed leave it as is. sPasswordUpdate = "" if self.Password and self.Password != "~!@@!~": sPasswordUpdate = ", password = '******'" # same for privileged_password sPriviledgedPasswordUpdate = "" if self.PrivilegedPassword != "~!@@!~": # updated password # priviledged password can be blank, so if it is, set it to null if self.PrivilegedPassword: sPriviledgedPasswordUpdate = ", privileged_password = null" else: sPriviledgedPasswordUpdate = ", privileged_password = '******'" sSQL = "update asset_credential " \ "set username = '******'," \ "domain = '" + self.Domain + "'," \ "shared_or_local = '" + self.SharedOrLocal + "'," \ "shared_cred_desc = '" + catocommon.tick_slash(self.Description) + "'" \ + sPasswordUpdate + sPriviledgedPasswordUpdate + \ "where credential_id = '" + self.ID + "'" if not db.exec_db_noexcep(sSQL): return False, db.error # # add security log # uiCommon.WriteObjectPropertyChangeLog(uiGlobals.CatoObjectTypes.Asset, sAssetID, sAssetName.strip().replace("'", "''") + "Changed credential", sOriginalUserName, sCredUsername) return True, None except Exception, ex: raise ex
def SetNodeAttributeinXMLColumn(sTable, sXMLColumn, sWhereClause, sNodeToSet, sAttribute, sValue): # THIS ONE WILL do adds if the attribute doesn't exist, or update it if it does. try: db = catocommon.new_conn() log( "Setting [%s] attribute [%s] to [%s] in [%s.%s where %s]" % (sNodeToSet, sAttribute, sValue, sTable, sXMLColumn, sWhereClause), 4) sXML = "" sSQL = "select " + sXMLColumn + " from " + sTable + " where " + sWhereClause sXML = db.select_col_noexcep(sSQL) if db.error: log("Unable to get xml." + db.error) return "" if sXML: # parse the doc from the table xd = ET.fromstring(sXML) if xd is None: log("Unable to parse xml." + db.error) return "" # get the specified node from the doc # here's the rub - the request might be or the "root" node, # which "find" will not, er ... find. # so let's first check if the root node is the name we want. xNodeToSet = None if xd.tag == sNodeToSet: xNodeToSet = xd else: xNodeToSet = xd.find(sNodeToSet) if xNodeToSet is None: # do nothing if we didn't find the node return "" else: # set it xNodeToSet.attrib[sAttribute] = sValue # then send the whole doc back to the database sSQL = "update " + sTable + " set " + sXMLColumn + " = '" + catocommon.tick_slash(ET.tostring(xd)) + "'" \ " where " + sWhereClause if not db.exec_db_noexcep(sSQL): log("Unable to update XML Column [" + sXMLColumn + "] on [" + sTable + "]." + db.error) return "" except Exception: log_nouser(traceback.format_exc(), 0) finally: if db.conn.socket: db.close()
def AddSecurityLog(LogType, Action, ObjectType, ObjectID, LogMessage): sTrimmedLog = catocommon.tick_slash(LogMessage).strip() if sTrimmedLog: if len(sTrimmedLog) > 7999: sTrimmedLog = sTrimmedLog[:7998] sSQL = """insert into user_security_log (log_type, action, user_id, log_dt, object_type, object_id, log_msg) values ('%s', '%s', '%s', now(), %d, '%s', '%s')""" % (LogType, Action, GetSessionUserID(), ObjectType, ObjectID, sTrimmedLog) db = catocommon.new_conn() if not db.exec_db_noexcep(sSQL): log_nouser(db.error, 0) db.close()
def DBUpdate(self): try: if not self.Name or not self.EcotemplateID or not self.AccountID: return False, "Name, EcotemplateID and Account ID are required Ecosystem properties." sSQL = "update ecosystem set" \ " ecosystem_name = '" + self.Name + "'," \ " ecotemplate_id = '" + self.EcotemplateID + "'," \ " account_id = '" + self.AccountID + "'," \ " ecosystem_desc = " + (" null" if not self.Description else " '" + catocommon.tick_slash(self.Description) + "'") + "," \ " last_update_dt = now()," \ " storm_file = " + (" null" if not self.StormFile else " '" + catocommon.tick_slash(self.StormFile) + "'") + \ " where ecosystem_id = '" + self.ID + "'" db = catocommon.new_conn() if not db.exec_db_noexcep(sSQL): return False, db.error return True, "" except Exception, ex: raise Exception(ex)
def AddSecurityLog(LogType, Action, ObjectType, ObjectID, LogMessage): sTrimmedLog = catocommon.tick_slash(LogMessage).strip() if sTrimmedLog: if len(sTrimmedLog) > 7999: sTrimmedLog = sTrimmedLog[:7998] sSQL = """insert into user_security_log (log_type, action, user_id, log_dt, object_type, object_id, log_msg) values ('%s', '%s', '%s', now(), %d, '%s', '%s')""" % ( LogType, Action, GetSessionUserID(), ObjectType, ObjectID, sTrimmedLog) db = catocommon.new_conn() if not db.exec_db_noexcep(sSQL): log_nouser(db.error, 0) db.close()
def SetNodeAttributeinXMLColumn(sTable, sXMLColumn, sWhereClause, sNodeToSet, sAttribute, sValue): # THIS ONE WILL do adds if the attribute doesn't exist, or update it if it does. try: db = catocommon.new_conn() log("Setting [%s] attribute [%s] to [%s] in [%s.%s where %s]" % (sNodeToSet, sAttribute, sValue, sTable, sXMLColumn, sWhereClause), 4) sXML = "" sSQL = "select " + sXMLColumn + " from " + sTable + " where " + sWhereClause sXML = db.select_col_noexcep(sSQL) if db.error: log("Unable to get xml." + db.error) return "" if sXML: # parse the doc from the table xd = ET.fromstring(sXML) if xd is None: log("Unable to parse xml." + db.error) return "" # get the specified node from the doc # here's the rub - the request might be or the "root" node, # which "find" will not, er ... find. # so let's first check if the root node is the name we want. xNodeToSet = None if xd.tag == sNodeToSet: xNodeToSet = xd else: xNodeToSet = xd.find(sNodeToSet) if xNodeToSet is None: # do nothing if we didn't find the node return "" else: # set it xNodeToSet.attrib[sAttribute] = sValue # then send the whole doc back to the database sSQL = "update " + sTable + " set " + sXMLColumn + " = '" + catocommon.tick_slash(ET.tostring(xd)) + "'" \ " where " + sWhereClause if not db.exec_db_noexcep(sSQL): log("Unable to update XML Column [" + sXMLColumn + "] on [" + sTable + "]." + db.error) return "" except Exception: log_nouser(traceback.format_exc(), 0) finally: if db.conn.socket: db.close()
def RemoveNodeFromXMLColumn(sTable, sXMLColumn, sWhereClause, sNodeToRemove): try: db = catocommon.new_conn() log( "Removing node [%s] from [%s.%s where %s]." % (sNodeToRemove, sTable, sXMLColumn, sWhereClause), 4) sSQL = "select " + sXMLColumn + " from " + sTable + " where " + sWhereClause sXML = db.select_col_noexcep(sSQL) if not sXML: log("Unable to get xml." + db.error) else: # parse the doc from the table xd = ET.fromstring(sXML) if xd is None: log("Error: Unable to parse XML.") # get the specified node from the doc xNodeToWhack = xd.find(sNodeToRemove) if xNodeToWhack is None: log( "INFO: attempt to remove [%s] - the element was not found." % sNodeToRemove, 4) # no worries... what you want to delete doesn't exist? perfect! return # OK, here's the deal... # we have found the node we want to delete, but we found it using an xpath, # ElementTree doesn't support deleting by xpath. # so, we'll use a parent map to find the immediate parent of the node we found, # and on the parent we can call ".remove" parent_map = dict((c, p) for p in xd.getiterator() for c in p) xParentOfNodeToWhack = parent_map[xNodeToWhack] # whack it if xParentOfNodeToWhack is not None: xParentOfNodeToWhack.remove(xNodeToWhack) sSQL = "update " + sTable + " set " + sXMLColumn + " = '" + catocommon.tick_slash(ET.tostring(xd)) + "'" \ " where " + sWhereClause if not db.exec_db_noexcep(sSQL): log("Unable to update XML Column [" + sXMLColumn + "] on [" + sTable + "]." + db.error) return except Exception: log_nouser(traceback.format_exc(), 0) finally: if db.conn.socket: db.close()
def DBCreateNew(sName, sEcotemplateID, sAccountID, sDescription="", sStormStatus="", sParameterXML="", sCloudID=""): try: if not sName or not sEcotemplateID or not sAccountID: return None, "Name, Ecotemplate and Cloud Account are required Ecosystem properties." db = catocommon.new_conn() sID = catocommon.new_guid() sSQL = "insert into ecosystem (ecosystem_id, ecosystem_name, ecosystem_desc, account_id, ecotemplate_id," \ " storm_file, storm_status, storm_parameter_xml, storm_cloud_id, created_dt, last_update_dt)" \ " select '" + sID + "'," \ " '" + sName + "'," \ + (" null" if not sDescription else " '" + catocommon.tick_slash(sDescription) + "'") + "," \ " '" + sAccountID + "'," \ " ecotemplate_id," \ " storm_file," \ + (" null" if not sStormStatus else " '" + catocommon.tick_slash(sStormStatus) + "'") + "," \ + (" null" if not sParameterXML else " '" + catocommon.tick_slash(sParameterXML) + "'") + "," \ + (" null" if not sCloudID else " '" + sCloudID + "'") + "," \ " now(), now()" \ " from ecotemplate where ecotemplate_id = '" + sEcotemplateID + "'" if not db.exec_db_noexcep(sSQL): if db.error == "key_violation": return None, "An Ecosystem with that name already exists. Please select another name." else: return None, db.error #now it's inserted and in the session... lets get it back from the db as a complete object for confirmation. e = Ecosystem() e.FromID(sID) #yay! return e, None except Exception, ex: raise Exception(ex)
def wmSaveSchedule(self): sScheduleID = uiCommon.getAjaxArg("sScheduleID") aMonths = uiCommon.getAjaxArg("sMonths") aDays = uiCommon.getAjaxArg("sDays") aHours = uiCommon.getAjaxArg("sHours") aMinutes = uiCommon.getAjaxArg("sMinutes") sDaysOrWeeks = uiCommon.getAjaxArg("sDaysOrWeeks") sParameterXML = uiCommon.getAjaxArg("sParameterXML") iDebugLevel = uiCommon.getAjaxArg("iDebugLevel") """ * JUST AS A REMINDER: * There is no parameter 'merging' happening here. This is a Scheduled Plan ... * it has ALL the parameters it needs to pass to the CE. * * """ if not sScheduleID or not aMonths or not aDays or not aHours or not aMinutes or not sDaysOrWeeks: uiCommon.log("Missing Schedule ID or invalid timetable.") # we encoded this in javascript before the ajax call. # the safest way to unencode it is to use the same javascript lib. # (sometimes the javascript and .net libs don't translate exactly, google it.) sParameterXML = uiCommon.unpackJSON(sParameterXML) # we gotta peek into the XML and encrypt any newly keyed values sParameterXML = task.Task.PrepareAndEncryptParameterXML(sParameterXML) # whack all plans for this schedule, it's been changed sSQL = "delete from action_plan where schedule_id = '" + sScheduleID + "'" self.db.exec_db(sSQL) # figure out a label sLabel, sDesc = catocommon.GenerateScheduleLabel(aMonths, aDays, aHours, aMinutes, sDaysOrWeeks) sSQL = "update action_schedule set" \ " months = '" + ",".join([str(x) for x in aMonths]) + "'," \ " days = '" + ",".join([str(x) for x in aDays]) + "'," \ " hours = '" + ",".join([str(x) for x in aHours]) + "'," \ " minutes = '" + ",".join([str(x) for x in aMinutes]) + "'," \ " days_or_weeks = '" + sDaysOrWeeks + "'," \ " label = " + ("'" + sLabel + "'" if sLabel else "null") + "," \ " descr = " + ("'" + sDesc + "'" if sDesc else "null") + "," \ " parameter_xml = " + ("'" + catocommon.tick_slash(sParameterXML) + "'" if sParameterXML else "null") + "," \ " debug_level = " + (iDebugLevel if iDebugLevel > -1 else "null") + \ " where schedule_id = '" + sScheduleID + "'" self.db.exec_db(sSQL)
def FixIt(xd, node): if node.get("input_type") is None: print "-- Action appears to be correct." return old_step = node.text print "fixing action ... " print " - referenced step is %s" % old_step sql = "select replace(function_xml, 'command_type=', 'name=') as function_xml from task_step where step_id = '%s'" % old_step embedded_xml = db.select_col_noexcep(sql) print " - referenced steps xml is \n%s" % embedded_xml if not embedded_xml: print " - Found no xml for the embedded command - it doesn't exist. Emptying it..." node.clear() else: xNew = ET.fromstring(embedded_xml) if xNew is not None: # we remove the input_type attrib, that's how we knew it was old school # and empty it node.clear() node.append(xNew) else: print " - ERROR: embedded xml didn't parse." print " - success! New xml is \n%s" % ET.tostring(xd) print " - updating ..." sql = "update task_step set function_xml = '%s' where step_id = '%s'" % (catocommon.tick_slash(ET.tostring(xd)), this_step) if not db.exec_db_noexcep(sql): print db.error print " - removing old school step %s..." % old_step sql = "delete from task_step where step_id = '%s'" % old_step if not db.exec_db_noexcep(sql): print db.error print " - removing codeblock %s..." % this_step sql = "delete from task_codeblock where codeblock_name = '%s'" % this_step[:32] print sql print db.error print "^^^^^" if not db.exec_db_noexcep(sql): print db.error
def RemoveNodeFromXMLColumn(sTable, sXMLColumn, sWhereClause, sNodeToRemove): try: db = catocommon.new_conn() log("Removing node [%s] from [%s.%s where %s]." % (sNodeToRemove, sTable, sXMLColumn, sWhereClause), 4) sSQL = "select " + sXMLColumn + " from " + sTable + " where " + sWhereClause sXML = db.select_col_noexcep(sSQL) if not sXML: log("Unable to get xml." + db.error) else: # parse the doc from the table xd = ET.fromstring(sXML) if xd is None: log("Error: Unable to parse XML.") # get the specified node from the doc xNodeToWhack = xd.find(sNodeToRemove) if xNodeToWhack is None: log("INFO: attempt to remove [%s] - the element was not found." % sNodeToRemove, 4) # no worries... what you want to delete doesn't exist? perfect! return # OK, here's the deal... # we have found the node we want to delete, but we found it using an xpath, # ElementTree doesn't support deleting by xpath. # so, we'll use a parent map to find the immediate parent of the node we found, # and on the parent we can call ".remove" parent_map = dict((c, p) for p in xd.getiterator() for c in p) xParentOfNodeToWhack = parent_map[xNodeToWhack] # whack it if xParentOfNodeToWhack is not None: xParentOfNodeToWhack.remove(xNodeToWhack) sSQL = "update " + sTable + " set " + sXMLColumn + " = '" + catocommon.tick_slash(ET.tostring(xd)) + "'" \ " where " + sWhereClause if not db.exec_db_noexcep(sSQL): log("Unable to update XML Column [" + sXMLColumn + "] on [" + sTable + "]." + db.error) return except Exception: log_nouser(traceback.format_exc(), 0) finally: if db.conn.socket: db.close()
def SetNodeValueinXMLColumn(sTable, sXMLColumn, sWhereClause, sNodeToSet, sValue): try: db = catocommon.new_conn() log( "Setting node [%s] to [%s] in [%s.%s where %s]." % (sNodeToSet, sValue, sTable, sXMLColumn, sWhereClause), 4) sSQL = "select " + sXMLColumn + " from " + sTable + " where " + sWhereClause sXML = db.select_col_noexcep(sSQL) if not sXML: log("Unable to get xml." + db.error) else: # parse the doc from the table xd = ET.fromstring(sXML) if xd is None: log("Error: Unable to parse XML.") # get the specified node from the doc, IF IT'S NOT THE ROOT if xd.tag == sNodeToSet: xNodeToSet = xd else: xNodeToSet = xd.find(sNodeToSet) if xNodeToSet is not None: xNodeToSet.text = sValue # then send the whole doc back to the database sSQL = "update " + sTable + " set " + sXMLColumn + " = '" + catocommon.tick_slash( ET.tostring(xd)) + "' where " + sWhereClause if not db.exec_db_noexcep(sSQL): log("Unable to update XML Column [" + sXMLColumn + "] on [" + sTable + "]." + db.error) else: log("Unable to update XML Column ... [" + sNodeToSet + "] not found.") return except Exception: log_nouser(traceback.format_exc(), 0) finally: if db.conn.socket: db.close()
def AddTaskInstance(sUserID, sTaskID, sEcosystemID, sAccountID, sAssetID, sParameterXML, sDebugLevel): try: if not sUserID: return "" if not sTaskID: return "" sParameterXML = unpackJSON(sParameterXML) # we gotta peek into the XML and encrypt any newly keyed values sParameterXML = PrepareAndEncryptParameterXML(sParameterXML) if IsGUID(sTaskID) and IsGUID(sUserID): sSQL = "call addTaskInstance ('" + sTaskID + "','" + \ sUserID + "',NULL," + \ sDebugLevel + ",NULL,'" + \ catocommon.tick_slash(sParameterXML) + "','" + \ sEcosystemID + "','" + \ sAccountID + "')" db = catocommon.new_conn() row = db.exec_proc(sSQL) if db.error: log("Unable to run task [" + sTaskID + "]." + db.error) db.close() # this needs fixing, this whole weird result set. log( "Starting Task [%s] ... Instance is [%s]" % (sTaskID, row[0]["_task_instance"]), 3) return row[0]["_task_instance"] else: log("Unable to run task. Missing or invalid task [" + sTaskID + "] or user [" + sUserID + "] id.") #uh oh, return nothing return "" except Exception: log_nouser(traceback.format_exc(), 0) return ""
def DBUpdate(self): try: if not self.Name: return False, "Name is required." sSQL = "update ecotemplate set" \ " ecotemplate_name = '" + self.Name + "'," \ " ecotemplate_desc = " + (" null" if not self.Description else " '" + catocommon.tick_slash(self.Description) + "'") + "," \ " storm_file_type = " + (" null" if not self.StormFileType else " '" + catocommon.tick_slash(self.StormFileType) + "'") + "," \ " storm_file = " + (" null" if not self.StormFile else " '" + catocommon.tick_slash(self.StormFile) + "'") + \ " where ecotemplate_id = '" + self.ID + "'" db = catocommon.new_conn() if not db.exec_db_noexcep(sSQL): print db.error if db.error == "key_violation": return None, "An Ecotemplate with that name already exists. Please select another name." else: return False, db.error return True, "" except Exception, ex: raise Exception(ex)
def AddTaskInstance(sUserID, sTaskID, sEcosystemID, sAccountID, sAssetID, sParameterXML, sDebugLevel): try: if not sUserID: return "" if not sTaskID: return "" sParameterXML = unpackJSON(sParameterXML) # we gotta peek into the XML and encrypt any newly keyed values sParameterXML = PrepareAndEncryptParameterXML(sParameterXML); if IsGUID(sTaskID) and IsGUID(sUserID): sSQL = "call addTaskInstance ('" + sTaskID + "','" + \ sUserID + "',NULL," + \ sDebugLevel + ",NULL,'" + \ catocommon.tick_slash(sParameterXML) + "','" + \ sEcosystemID + "','" + \ sAccountID + "')" db = catocommon.new_conn() row = db.exec_proc(sSQL) if db.error: log("Unable to run task [" + sTaskID + "]." + db.error) db.close() # this needs fixing, this whole weird result set. log("Starting Task [%s] ... Instance is [%s]" % (sTaskID, row[0]["_task_instance"]), 3) return row[0]["_task_instance"] else: log("Unable to run task. Missing or invalid task [" + sTaskID + "] or user [" + sUserID + "] id.") #uh oh, return nothing return "" except Exception: log_nouser(traceback.format_exc(), 0) return ""
def SetNodeValueinXMLColumn(sTable, sXMLColumn, sWhereClause, sNodeToSet, sValue): try: db = catocommon.new_conn() log("Setting node [%s] to [%s] in [%s.%s where %s]." % (sNodeToSet, sValue, sTable, sXMLColumn, sWhereClause), 4) sSQL = "select " + sXMLColumn + " from " + sTable + " where " + sWhereClause sXML = db.select_col_noexcep(sSQL) if not sXML: log("Unable to get xml." + db.error) else: # parse the doc from the table xd = ET.fromstring(sXML) if xd is None: log("Error: Unable to parse XML.") # get the specified node from the doc, IF IT'S NOT THE ROOT if xd.tag == sNodeToSet: xNodeToSet = xd else: xNodeToSet = xd.find(sNodeToSet) if xNodeToSet is not None: xNodeToSet.text = sValue # then send the whole doc back to the database sSQL = "update " + sTable + " set " + sXMLColumn + " = '" + catocommon.tick_slash(ET.tostring(xd)) + "' where " + sWhereClause if not db.exec_db_noexcep(sSQL): log("Unable to update XML Column [" + sXMLColumn + "] on [" + sTable + "]." + db.error) else: log("Unable to update XML Column ... [" + sNodeToSet + "] not found.") return except Exception: log_nouser(traceback.format_exc(), 0) finally: if db.conn.socket: db.close()
def DBSave(self): try: if not self.Name or not self.ID: return False, "ID and Name are required Ecotemplate properties." db = catocommon.new_conn() if self.DBExists: # uh oh... this ecotemplate exists. unless told to do so, we stop here. if self.OnConflict == "cancel": return False, "Another Ecotemplate with that ID or Name exists. [" + self.ID + "/" + self.Name + "] Conflict directive set to 'cancel'. (Default is 'cancel' if omitted.)" else: # ok, what are we supposed to do then? if self.OnConflict == "replace": # whack it all so we can re-insert # but by name or ID? which was the conflict? # no worries! the _DBExists function called when we created the object # will have resolved any name/id issues. # if the ID existed it doesn't matter, we'll be plowing it anyway. # by "plow" I mean drop and recreate the actions... the ecotemplate row will be UPDATED sSQL = "update ecotemplate" \ " set ecotemplate_name = '" + self.Name + "'," \ " ecotemplate_desc = " + (" null" if not self.Description else " '" + catocommon.tick_slash(self.Description + "'")) + "," \ " storm_file_type = " + (" null" if not self.StormFileType else " '" + self.StormFileType + "'") + "," \ " storm_file = " + (" null" if not self.StormFile else " '" + catocommon.tick_slash(self.StormFile + "'")) + \ " where ecotemplate_id = '" + self.ID + "'" if not db.tran_exec_noexcep(sSQL): return False, db.error sSQL = "delete from ecotemplate_action" \ " where ecotemplate_id = '" + self.ID + "'" if not db.tran_exec_noexcep(sSQL): return False, db.error else: # there is no default action... if the on_conflict didn't match we have a problem... bail. return False, "There is an ID or Name conflict, and the on_conflict directive isn't a valid option. (replace/cancel)" else: # doesn't exist, we'll add it sSQL = "insert into ecotemplate (ecotemplate_id, ecotemplate_name, ecotemplate_desc, storm_file_type, storm_file)" \ " values ('" + self.ID + "'," \ " '" + self.Name + "'," + \ (" null" if not self.Description else " '" + catocommon.tick_slash(self.Description) + "'") + "," + \ (" null" if not self.StormFileType else " '" + self.StormFileType + "'") + "," + \ (" null" if not self.StormFile else " '" + catocommon.tick_slash(self.StormFile) + "'") + \ ")" if not db.tran_exec_noexcep(sSQL): return False, db.error # create the actions # actions aren't referenced by id anywhere, so we'll just give them a new guid # to prevent any risk of PK issues. for ea in self.Actions.itervalues(): print ea.Name sSQL = "insert into ecotemplate_action" \ " (action_id, ecotemplate_id, action_name, action_desc, category, action_icon, original_task_id, task_version, parameter_defaults)" \ " values (" \ " uuid()," \ " '" + self.ID + "'," \ " '" + catocommon.tick_slash(ea.Name) + "'," + \ ("null" if not ea.Description else " '" + catocommon.tick_slash(ea.Description) + "'") + "," + \ ("null" if not ea.Category else " '" + catocommon.tick_slash(ea.Category) + "'") + "," + \ ("null" if not ea.Icon else " '" + ea.Icon + "'") + "," + \ ("null" if not ea.OriginalTaskID else " '" + ea.OriginalTaskID + "'") + "," + \ ("null" if not ea.TaskVersion else " '" + ea.TaskVersion + "'") + "," + \ ("null" if not ea.ParameterDefaultsXML else " '" + catocommon.tick_slash(ea.ParameterDefaultsXML) + "'") + \ ")" if not db.tran_exec_noexcep(sSQL): return False, db.error # now, does this action contain a <task> section? If so, we'll branch off and do # the create task logic. if ea.Task is not None: result, msg = ea.Task.DBSave() if not result: # the task 'should' have rolled back on any errors, but in case it didn't. db.tran_rollback() return False, msg # finally, don't forget to update the action with the new values if any ea.OriginalTaskID = ea.Task.OriginalTaskID # we don't update the version if the action referenced the default (it was empty) if ea.TaskVersion: ea.TaskVersion = ea.Task.Version # yay! print "done" db.tran_commit() return True, None except Exception, ex: raise ex
def AddNodeToXMLColumn(sTable, sXMLColumn, sWhereClause, sXPath, sXMLToAdd): # BE WARNED! this function is shared by many things, and should not be enhanced # with sorting or other niceties. If you need that stuff, build your own function. # AddRegistry:Node is a perfect example... we wanted sorting on the registries, and also we don't allow array. # but parameters for example are by definition arrays of parameter nodes. try: db = catocommon.new_conn() log("Adding node [%s] to [%s] in [%s.%s where %s]." % (sXMLToAdd, sXPath, sTable, sXMLColumn, sWhereClause), 4) sSQL = "select " + sXMLColumn + " from " + sTable + " where " + sWhereClause sXML = db.select_col_noexcep(sSQL) if not sXML: log("Unable to get xml." + db.error) else: # parse the doc from the table log(sXML, 4) xd = ET.fromstring(sXML) if xd is None: log("Error: Unable to parse XML.") # get the specified node from the doc, IF IT'S NOT THE ROOT # either a blank xpath, or a single word that matches the root, both match the root. # any other path DOES NOT require the root prefix. if sXPath == "": xNodeToEdit = xd elif xd.tag == sXPath: xNodeToEdit = xd else: xNodeToEdit = xd.find(sXPath) if xNodeToEdit is None: log("Error: XML does not contain path [" + sXPath + "].") return # now parse the new section from the text passed in xNew = ET.fromstring(sXMLToAdd) if xNew is None: log("Error: XML to be added cannot be parsed.") # if the node we are adding to has a text value, sadly it has to go. # we can't detect that, as the Value property shows the value of all children. # but this works, even if it seems backwards. # if the node does not have any children, then clear it. that will safely clear any # text but not stomp the text of the children. if len(xNodeToEdit) == 0: xNodeToEdit.text = "" # add it to the doc xNodeToEdit.append(xNew) # then send the whole doc back to the database sSQL = "update " + sTable + " set " + sXMLColumn + " = '" + catocommon.tick_slash(ET.tostring(xd)) + "'" \ " where " + sWhereClause if not db.exec_db_noexcep(sSQL): log("Unable to update XML Column [" + sXMLColumn + "] on [" + sTable + "]." + db.error) return except Exception: log_nouser(traceback.format_exc(), 0) finally: if db.conn.socket: db.close()
def WriteObjectPropertyChangeLog(oType, sObjectID, sLabel, sFrom, sTo): if sFrom and sTo: if sFrom != sTo: sLog = "Changed: " + sLabel + " from [" + catocommon.tick_slash(sFrom) + "] to [" + catocommon.tick_slash(sTo) + "]." AddSecurityLog(uiGlobals.SecurityLogTypes.Object, uiGlobals.SecurityLogActions.ObjectAdd, oType, sObjectID, sLog)
def DBSave(self): try: db = catocommon.new_conn() sSQL = "update object_registry set registry_xml = '%s' where object_id = '%s'" % (catocommon.tick_slash(self.xml_text), self.object_id) if not db.exec_db_noexcep(sSQL): return False, "Error: Could not create Registry." + db.error return True, "" except Exception, ex: raise Exception(ex)
def AddNodeToXMLColumn(sTable, sXMLColumn, sWhereClause, sXPath, sXMLToAdd): # BE WARNED! this function is shared by many things, and should not be enhanced # with sorting or other niceties. If you need that stuff, build your own function. # AddRegistry:Node is a perfect example... we wanted sorting on the registries, and also we don't allow array. # but parameters for example are by definition arrays of parameter nodes. try: db = catocommon.new_conn() log( "Adding node [%s] to [%s] in [%s.%s where %s]." % (sXMLToAdd, sXPath, sTable, sXMLColumn, sWhereClause), 4) sSQL = "select " + sXMLColumn + " from " + sTable + " where " + sWhereClause sXML = db.select_col_noexcep(sSQL) if not sXML: log("Unable to get xml." + db.error) else: # parse the doc from the table log(sXML, 4) xd = ET.fromstring(sXML) if xd is None: log("Error: Unable to parse XML.") # get the specified node from the doc, IF IT'S NOT THE ROOT # either a blank xpath, or a single word that matches the root, both match the root. # any other path DOES NOT require the root prefix. if sXPath == "": xNodeToEdit = xd elif xd.tag == sXPath: xNodeToEdit = xd else: xNodeToEdit = xd.find(sXPath) if xNodeToEdit is None: log("Error: XML does not contain path [" + sXPath + "].") return # now parse the new section from the text passed in xNew = ET.fromstring(sXMLToAdd) if xNew is None: log("Error: XML to be added cannot be parsed.") # if the node we are adding to has a text value, sadly it has to go. # we can't detect that, as the Value property shows the value of all children. # but this works, even if it seems backwards. # if the node does not have any children, then clear it. that will safely clear any # text but not stomp the text of the children. if len(xNodeToEdit) == 0: xNodeToEdit.text = "" # add it to the doc xNodeToEdit.append(xNew) # then send the whole doc back to the database sSQL = "update " + sTable + " set " + sXMLColumn + " = '" + catocommon.tick_slash(ET.tostring(xd)) + "'" \ " where " + sWhereClause if not db.exec_db_noexcep(sSQL): log("Unable to update XML Column [" + sXMLColumn + "] on [" + sTable + "]." + db.error) return except Exception: log_nouser(traceback.format_exc(), 0) finally: if db.conn.socket: db.close()