def _print_model_folder_sample(self, section_name, model_path_tokens, control_option): """ Prints a model sample for a folder in a model, when more than just the section_name[:] is provided. :param section_name: the name of the model section :param model_path_tokens: a Python list of path elements built from model path :param control_option: A command-line switch that controls what is output to STDOUT """ _method_name = '_print_model_folder_sample' print("") # write the parent folders leading up to the specified folder. # include any name folders. indent = 0 _print_indent(section_name + ":", indent) indent += 1 model_path = section_name + ":" current_folder = self._schema for token in model_path_tokens[1:]: properties = _get_properties(current_folder) valid_subfolder_keys = _get_folder_names(properties) if token not in valid_subfolder_keys: ex = exception_helper.create_cla_exception( "WLSDPLY-10111", model_path, token, ', '.join(valid_subfolder_keys)) self._logger.throwing(ex, class_name=self._class_name, method_name=_method_name) raise ex current_folder = properties[token] _print_indent(token + ":", indent) indent += 1 if wko_schema_helper.is_multiple_folder(current_folder): name = token + '-1' _print_indent(name + ":", indent) indent += 1 model_path = model_path + "/" + token # list the attributes and folders, as specified if model_help_utils.show_attributes(control_option): # Print the attributes associated with schema folder self._print_attributes_sample(current_folder, indent) if model_help_utils.show_folders(control_option): self._print_subfolders_sample(current_folder, control_option, indent, model_path)
def _print_subfolders_sample(self, schema_folder, control_option, indent_level, path): """ Prints a model sample section for the folders in a model location. :param schema_folder: the schema folder being printed :param control_option: a command-line switch that controls what is output to STDOUT :param indent_level: the level to indent by, before printing output """ _method_name = '_print_subfolders_sample' folder_info = _get_properties(schema_folder) folder_map = dict() multi_folders = [] for key in folder_info: property_map = folder_info[key] if property_map is not None: if wko_schema_helper.is_single_folder(property_map): folder_map[key] = property_map elif wko_schema_helper.is_multiple_folder(property_map): folder_map[key] = wko_schema_helper.get_array_item_info( property_map) multi_folders.append(key) folder_keys = list(folder_map.keys()) folder_keys.sort() for key in folder_keys: folder_info = folder_map[key] if control_option != ControlOptions.RECURSIVE: print("") key_level = indent_level _print_indent(key + ":", key_level) child_level = key_level if key in multi_folders: name = key + "-1" child_level += 1 _print_indent(name + ":", child_level) if control_option == ControlOptions.RECURSIVE: # Call this method recursively self._print_subfolders_sample(folder_info, control_option, child_level + 1, path) else: next_path = path + "/" + key _print_indent("# see " + next_path, child_level + 1)
def _process_folder(self, model_dict, schema_folder, target_dict, schema_path, model_path): """ Transfer folders and attributes from the model dictionary to the target domain resource dictionary. :param model_dict: the source model dictionary :param schema_folder: the schema for this folder :param target_dict: the target dictionary for the domain resource file. :param schema_path: the path of schema elements (no multi-element names), used for supported check :param model_path: the path of model elements (including multi-element names), used for logging """ folder_properties = schema_folder["properties"] for key, model_value in model_dict.items(): properties = folder_properties[key] if wko_schema_helper.is_single_folder(properties): # single object instance next_schema_path = wko_schema_helper.append_path( schema_path, key) next_model_path = model_path + "/" + key if not wko_schema_helper.is_unsupported_folder( next_schema_path): next_target_dict = PyOrderedDict() target_dict[key] = next_target_dict self._process_folder(model_value, properties, next_target_dict, next_schema_path, next_model_path) elif wko_schema_helper.is_multiple_folder(properties): # multiple object instances next_schema_path = wko_schema_helper.append_path( schema_path, key) next_model_path = model_path + "/" + key if not wko_schema_helper.is_unsupported_folder( next_schema_path): item_info = wko_schema_helper.get_array_item_info( properties) target_dict[key] = \ self._process_multiple_folder(model_value, item_info, next_schema_path, next_model_path) elif wko_schema_helper.is_simple_map(properties): # map of key / value pairs target_dict[key] = model_value else: # simple type or array of simple type, such as number, string property_type = wko_schema_helper.get_type(properties) target_dict[key] = _get_target_value(model_value, property_type)
def _get_folder_names(schema_properties): """ Return the folder names (single and multiple) described by the schema properties. :param schema_properties: the properties to be examined :return: a list of folder names """ folder_names = [] for key in schema_properties: property_map = schema_properties[key] if property_map is not None: if wko_schema_helper.is_single_folder( property_map) or wko_schema_helper.is_multiple_folder( property_map): folder_names.append(key) return folder_names
def _get_properties(schema_folder): # in array elements, the properties are under "items" if wko_schema_helper.is_multiple_folder(schema_folder): return schema_folder['items']['properties'] else: return schema_folder['properties']
def validate_folder(self, model_folder, schema_folder, schema_path, model_path): """ Validate the specified model folder against the specified schema folder :param model_folder: the model folder to validate :param schema_folder: the schema folder to validate against :param schema_path: the path of schema elements (no multi-element names), used for supported check :param model_path: the path of model elements (including multi-element names), used for logging """ _method_name = 'validate_folder' self._log_debug(str(model_path)) if not isinstance(model_folder, dict): self._logger.severe("WLSDPLY-05038", model_path, class_name=self._class_name, method_name=_method_name) return schema_properties = wko_schema_helper.get_properties(schema_folder) for key in model_folder: properties = dictionary_utils.get_element(schema_properties, key) model_value = model_folder[key] if properties is not None: if wko_schema_helper.is_single_folder(properties): # single object instance self._log_debug(' ' + key + ': folder') next_schema_path = wko_schema_helper.append_path( schema_path, key) next_model_path = model_path + "/" + key if self._check_folder_path(next_schema_path, next_model_path): self.validate_folder(model_value, properties, next_schema_path, next_model_path) elif wko_schema_helper.is_multiple_folder(properties): # multiple object instances self._log_debug(' ' + key + ': multiple folder') next_schema_path = wko_schema_helper.append_path( schema_path, key) next_model_path = model_path + "/" + key if self._check_folder_path(next_schema_path, next_model_path): item_info = wko_schema_helper.get_array_item_info( properties) self._validate_multiple_folder(model_value, item_info, next_schema_path, next_model_path) elif wko_schema_helper.is_simple_map(properties): # map of key / value pairs element_type = wko_schema_helper.get_map_element_type( properties) self._log_debug(' ' + key + ': map of ' + element_type) self._validate_simple_map(model_value, key, model_path) elif wko_schema_helper.is_simple_array(properties): # array of simple type element_type = wko_schema_helper.get_array_element_type( properties) self._log_debug(' ' + key + ': array of ' + element_type) self._validate_simple_array(model_value, key, model_path) else: # simple type property_type = wko_schema_helper.get_type(properties) self._log_debug(' ' + key + ': ' + property_type) self._validate_simple_type(model_value, property_type, key, model_path) else: self._logger.severe("WLSDPLY-05026", key, len(schema_properties), model_path, class_name=self._class_name, method_name=_method_name)