def run( CopiesPerParent, TargetTagList, TemplateXml, TemplateXmlFileName, TagPrefix, AutoExpandTemplate, EnableLoadFromFileName, StmTemplateMix, ): plLogger = PLLogger.GetLogger("methodology") plLogger.LogDebug("run LoadTemplateCommand") did_expand = False ctor = CScriptableCreator() stc_sys = CStcSystem.Instance() project = stc_sys.GetObject("Project") hnd_reg = CHandleRegistry.Instance() # Look up the StmTemplateMix parent_obj = hnd_reg.Find(StmTemplateMix) if parent_obj is None: plLogger.LogDebug("Was unable to find a StmTemplateMix with " + str(StmTemplateMix) + " using project ") parent_obj = project else: if not parent_obj.IsTypeOf("StmTemplateMix"): plLogger.LogError( "Incorrect handle passed in for " + "StmTemplateMix. Expected an " + "object of type StmTemplateMix, " + "instead received a(n) " + parent_obj.GetType() ) return False plLogger.LogDebug( "Was able to find a StmTemplateMix, using " + parent_obj.Get("Name") + " with id: " + str(StmTemplateMix) ) # Create an empty TemplateConfig object temp_conf = ctor.Create("StmTemplateConfig", parent_obj) if temp_conf is None: plLogger.LogError("ERROR: Failed to create an StmTemplateConfig") return False xml_value = None if not EnableLoadFromFileName: xml_value = TemplateXml elif TemplateXmlFileName != "": xml_value = xml_utils.load_xml_from_file(TemplateXmlFileName) if xml_value is None: plLogger.LogError("ERROR: No valid template source.") return False if TagPrefix != "": xml_value = xml_utils.add_prefix_to_tags(TagPrefix, xml_value) temp_conf.Set("TemplateXml", xml_value) # Pass the handles to the commands contained in this group cmd_count = config_contained_cmds(get_this_cmd(), temp_conf) # Set the output handle (since we already have the object) this_cmd = get_this_cmd() this_cmd.Set("StmTemplateConfig", temp_conf.GetObjectHandle()) # FIXME: WORKAROUND: on_last_command_complete() doesn't get called if # no children commands exist... if cmd_count == 0: on_complete([]) did_expand = True if did_expand: pass # END FIXME: WORKAROUND return True
def run(StmTemplateMix, InputJson, AutoExpandTemplate, CopiesPerParent, SrcTagList, TargetTagList): plLogger = PLLogger.GetLogger('methodology') plLogger.LogDebug("CreateTemplateConfigCommand.run") hnd_reg = CHandleRegistry.Instance() ctor = CScriptableCreator() this_cmd = get_this_cmd() project = CStcSystem.Instance().GetObject("Project") if InputJson == "": err_str = "InputJson is an empty string." plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False # Validate the InputJson against the schema res = json_utils.validate_json(InputJson, this_cmd.Get("InputJsonSchema")) if res != "": err_str = "InputJson is invalid or does not conform to the " + \ "schema: " + res plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False if StmTemplateMix != "" and StmTemplateMix != 0: mix = hnd_reg.Find(StmTemplateMix) if mix is None: err_str = "StmTemplateMix with given handle: " + \ str(StmTemplateMix) + " is invalid." plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False elif not mix.IsTypeOf("StmTemplateMix"): err_str = "Object with given handle: " + \ str(StmTemplateMix) + " is a " + \ mix.GetType() + ". If StmTemplateMix is " + \ "specified, object must be an StmTemplateMix." plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False parent = mix else: parent = project template = ctor.Create("StmTemplateConfig", parent) this_cmd.Set("StmTemplateConfig", template.GetObjectHandle()) # Breakdown the json err_str, conf_data = json_utils.load_json(InputJson) if err_str != "": plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False plLogger.LogDebug("conf_data: " + str(conf_data)) # Do the load first if "baseTemplateFile" not in conf_data.keys(): plLogger.LogError("InputJson is missing a baseTemplateFile.") return False xml_file = conf_data["baseTemplateFile"] xml_val = xml_utils.load_xml_from_file(xml_file) if xml_val is None: err_str = "Was unable to load template XML from " + xml_file plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False # Update the prefixes tag_prefix = "" if ("tagPrefix" in conf_data.keys() and conf_data["tagPrefix"] != ""): tag_prefix = conf_data["tagPrefix"] plLogger.LogDebug("using tag_prefix: " + tag_prefix) xml_val = xml_utils.add_prefix_to_tags(tag_prefix, xml_val) template.Set("TemplateXml", xml_val) plLogger.LogDebug("conf_data: " + str(conf_data)) # Iterate over the objects in the array and apply the appropriate # template modification. Order is determined by the list order. for mod_data in conf_data.get("modifyList", []): plLogger.LogDebug("mod_data: " + str(mod_data)) plLogger.LogDebug("mod_data.keys(): " + str(mod_data.keys())) err_str = "" res = True # Merge stuff in mergeList for merge_data in mod_data.get("mergeList", []): res = run_merge(template, tag_prefix, merge_data) err_str = "Failed to merge XML into the StmTemplateConfig " + \ "given JSON specified as: " + str(merge_data) # Process objects in the addObjectList for obj_data in mod_data.get("addObjectList", []): res = run_objectlist(template, tag_prefix, obj_data) err_str = "Failed to add object into the StmTemplateConfig " + \ "given JSON specified as: " + str(obj_data) # Modify the stuff in the PropertyValueList for prop_set in mod_data.get('propertyValueList', []): res = run_modify(template, tag_prefix, prop_set) err_str = "Failed to modify properties in the " + \ "StmTemplateConfig given JSON specified as: " + \ str(prop_set) # Modify the stuff in the StmPropertyModifierList for prop_set in mod_data.get("stmPropertyModifierList", []): res = run_config_prop_modifier(template, tag_prefix, prop_set) err_str = "Failed to add or configure " + \ "StmPropertyModifier objects in the StmTemplateConfig " + \ "given JSON specified as: " + str(prop_set) # Modify PDUs for pdu_mod in mod_data.get("pduModifierList", []): res = run_config_pdu(template, tag_prefix, pdu_mod) err_str = "Failed to modify PDU data in a streamblock's " + \ "FrameConfig in the StmTemplateConfig given JSON " + \ "specified as: " + str(pdu_mod) # Modify the stuff in the RelationList for rel_mod in mod_data.get("relationList", []): res = run_config_relation(template, tag_prefix, rel_mod) err_str = "Failed to add or remove a relation in the " + \ "StmTemplateConfig given JSON specified as " + str(rel_mod) if not res: plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False # Handle Expand if necessary if AutoExpandTemplate: res = run_expand(template, TargetTagList, SrcTagList, CopiesPerParent) if not res: err_str = "Failed to expand the StmTemplateConfig." plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False this_cmd.Set("Status", "") return True
def run( StmTemplateConfig, SrcTagList, TargetTagList, TagPrefix, TemplateXml, TemplateXmlFileName, EnableLoadFromFileName ): plLogger = PLLogger.GetLogger("methodology") plLogger.LogDebug("run MergeTemplateCommand") hnd_reg = CHandleRegistry.Instance() temp_conf = hnd_reg.Find(StmTemplateConfig) if temp_conf is None: plLogger.LogError("ERROR: Failed to find a valid StmTemplateConfig") return False # Get the template XML (target XML) and renormalize the IDs template = temp_conf.Get("TemplateXml") target_root = etree.fromstring(template) # FIXME: # RENORMALIZE must ALSO remove invalid relations and potentially invalid # property values (for type handle). Otherwise, renumbering the objects # may end up relating things that shouldn't be related. # Example: # <Relation type="DefaultSelection" target="15"/> # Object with ID 15 doesn't exist if the XML was stripped incorrectly # but it will probably exist when the objects are renumbered. xml_utils.renormalize_xml_obj_ids(target_root) # Get the new current object ID (1 + maximum object ID) curr_id = xml_utils.get_max_object_id(target_root, 0) + 1 # Find the target elements target_ele_list = find_tagged_filtered_elements(target_root, TargetTagList) if len(target_ele_list) < 1: plLogger.LogError( "Found no target elements in the " + "StmTemplateConfig in to which the " + "new XML should be merged into." ) return False # Get the source XML merge_xml = None if not EnableLoadFromFileName: merge_xml = TemplateXml if merge_xml == "": plLogger.LogError("No valid XML Template String defined.") return False elif TemplateXmlFileName != "": merge_xml = xml_utils.load_xml_from_file(TemplateXmlFileName) if merge_xml is None: plLogger.LogError("No valid XML Template File defined.") return False source_root = etree.fromstring(merge_xml) # Find the source elements src_ele_list = find_tagged_filtered_elements(source_root, SrcTagList) if len(src_ele_list) < 1: plLogger.LogError( "Found no source elements in the input XML " + "from which XML should be copied into the " + "StmTemplateConfig from." ) return False # FIXME: # Source elements should not contain other source elements # Need to prevent this from happening # Find the Tags object in the target XML target_tags_ele = target_root.find(".//Tags") if target_tags_ele is None: plLogger.LogError("ERROR: Target XML has no Tags element!") return False # Merge Tag objects from the XML source if necessary copy_src_tag_list = [] for src_ele in src_ele_list: tag_ele_list = src_ele.findall(".//Relation") for tag_ele in tag_ele_list: if tag_ele.get("type") == "UserTag": copy_src_tag_list.append(tag_ele.get("target")) copy_src_tag_list = set(copy_src_tag_list) plLogger.LogDebug("copy_src_tag_list: " + str(copy_src_tag_list)) # Find the tags in the source XML and extract the ones of interest copy_src_tag_ele_list = [] src_tag_ele_list = source_root.findall(".//Tag") for src_tag_ele in src_tag_ele_list: if src_tag_ele.get("id") in copy_src_tag_list: copy_src_tag_ele_list.append(src_tag_ele) plLogger.LogDebug("copy_src_tag_ele_list: " + str(copy_src_tag_ele_list)) # Store the mappings between the old ID, new ID, old and new name # These will be used later to update relations and # StmPropertyModifier objects new_src_tag_id_map = {} new_src_tag_name_map = {} for src_tag_ele in copy_src_tag_ele_list: src_tag_ele_copy = xml_utils.get_etree_copy(src_tag_ele) # Update the tag's Name if the TagPrefix is defined old_name = src_tag_ele_copy.get("Name") if TagPrefix != "": new_name = TagPrefix + old_name else: new_name = old_name src_tag_ele_copy.set("Name", new_name) # Update the ID old_id = src_tag_ele_copy.get("id") src_tag_ele_copy.set("id", str(curr_id)) # Store both for use later new_src_tag_id_map[old_id] = curr_id new_src_tag_name_map[old_name] = new_name target_tags_ele.append(src_tag_ele_copy) xml_utils.create_relation_element(target_tags_ele, "UserTag", str(curr_id)) curr_id = curr_id + 1 plLogger.LogDebug("new_src_tag_id_map: " + str(new_src_tag_id_map)) plLogger.LogDebug("new_src_tag_name_map: " + str(new_src_tag_name_map)) # Merge the sources into the target(s) for target_ele in target_ele_list: for src_ele in src_ele_list: plLogger.LogInfo("merging " + str(src_ele) + " into " + str(target_ele)) # Renumber the object IDs src_ele_copy = xml_utils.get_etree_copy(src_ele) xml_utils.renormalize_xml_obj_ids(src_ele_copy, start_id=curr_id) # Update the tag IDs (should have been lost # unless src_ele is Tags...which is not allowed). update_relation_targets(src_ele_copy, new_src_tag_id_map) # Update the StmPropertyModifiers update_property_modifier_tag_names(src_ele_copy, new_src_tag_name_map) plLogger.LogInfo(" src_ele_copy: " + etree.tostring(src_ele_copy)) target_ele.append(src_ele_copy) # Increment the current max ID curr_id = curr_id + 1 # Clean up the invalid handles xml_utils.remove_invalid_stc_handles(target_root) xml_value = etree.tostring(target_root) plLogger.LogInfo("FINAL xml_value: " + etree.tostring(target_root)) temp_conf.Set("TemplateXml", xml_value) return True