Feat/yuanrui/json

src/ansys/dynamicreporting/core/utils/report_remote_server.py

@@ -37,6 +37,16 @@
 from .encoders import BaseEncoder
 
 
+class TemplateEditorJSONLoadingError(Exception):
+    """
+    A specialized exception class for errors when loading a JSON file for the template editor
+    """
+
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message
+
+
 def disable_warn_logging(func):
     # Decorator to suppress harmless warning messages
     @functools.wraps(func)
@@ -983,7 +993,8 @@ def get_templates_as_json(self, root_guid):
         _build_template_data(root_guid, templates_data, templates, template_guid_id_map)
         return templates_data
 
-    def _populate_template(self, attr, parent_template):
+    def _populate_template(self, id_str, attr, parent_template):
+        _check_template(id_str, attr)
         template = self.create_template(
             name=attr["name"], parent=parent_template, report_type=attr["report_type"]
         )
@@ -997,6 +1008,7 @@ def _populate_template(self, attr, parent_template):
 
     def _update_changes(self, id_str, id_template_map, templates_json):
         children_id_strs = templates_json[id_str]["children"]
+
         if not children_id_strs:
             return
 
@@ -1012,7 +1024,9 @@ def _build_templates_from_parent(self, id_str, id_template_map, templates_json):
         child_templates = []
         for child_id_str in children_id_strs:
             child_attr = templates_json[child_id_str]
-            child_template = self._populate_template(child_attr, id_template_map[id_str])
+            child_template = self._populate_template(
+                child_id_str, child_attr, id_template_map[id_str]
+            )
             child_templates.append(child_template)
             id_template_map[child_id_str] = child_template
 
@@ -1033,14 +1047,118 @@ def load_templates(self, templates_json):
                 break
 
         root_attr = templates_json[root_id_str]
-        root_template = self._populate_template(root_attr, None)
+        root_template = self._populate_template(root_id_str, root_attr, None)
         self.put_objects(root_template)
         id_template_map = {}
         id_template_map[root_id_str] = root_template
         self._build_templates_from_parent(root_id_str, id_template_map, templates_json)
         self._update_changes(root_id_str, id_template_map, templates_json)
 
 
+def _check_template(template_id_str, template_attr):
+    # Check template_id_str
+    if not _check_template_name_convention(template_id_str):
+        raise TemplateEditorJSONLoadingError(
+            f"The loaded JSON file has an invalid template name: '{template_id_str}' as the key.\n"
+            "Please note that the naming convention is 'Template_{NONE_NEGATIVE_NUMBER}'"
+        )
+
+    # Check parent and children template name convention
+    if not _check_template_name_convention(template_attr["parent"]):
+        raise TemplateEditorJSONLoadingError(
+            f"The loaded JSON file has an invalid template name: '{template_attr['parent']}' "
+            f"that does not have the correct name convection under the key: 'parent' of '{template_id_str}'\n"
+            "Please note that the naming convention is 'Template_{NONE_NEGATIVE_NUMBER}'"
+        )
+
+    for child_name in template_attr["children"]:
+        if not _check_template_name_convention(child_name):
+            raise TemplateEditorJSONLoadingError(
+                f"The loaded JSON file has an invalid template name: '{child_name}' "
+                f"that does not have the correct name convection under the key: 'children' of '{template_id_str}'\n"
+                "Please note that the naming convention is 'Template_{NONE_NEGATIVE_NUMBER}'"
+            )
+
+    # Check key names
+    agreed_keys = {
+        "name",
+        "report_type",
+        "date",
+        "tags",
+        "params",
+        "sort_selection",
+        "item_filter",
+        "parent",
+        "children",
+    }
+    for key in template_attr.keys():
+        if key not in agreed_keys:
+            raise TemplateEditorJSONLoadingError(
+                f"The loaded JSON file is using an unknown key: '{key}' other than any in the JSON schema.\n"
+                f"Please check the '{key}' entry under '{template_id_str}' in your JSON file as you might have a typo in that entry."
+            )
+
+    # Check missing keys
+    if len(template_attr) != len(agreed_keys):  # Missing one or more entries
+        keys = template_attr.keys()
+        missing_keys = list(agreed_keys - set(keys))
+        raise TemplateEditorJSONLoadingError(
+            f"The loaded JSON file is missing keys: {missing_keys}.\n"
+            f"Please check them under '{template_id_str}' in your JSON file for the missing keys."
+        )
+
+    # Check report_type
+    report_types = {
+        "Layout:panel",
+        "Layout:basic",
+        "Layout:box",
+        "Layout:tabs",
+        "Layout:carousel",
+        "Layout:slider",
+        "Layout:footer",
+        "Layout:header",
+        "Layout:iterator",
+        "Layout:tagprops",
+        "Layout:toc",
+        "Layout:reportlink",
+        "Layout:userdefined",
+    }
+    if not template_attr["report_type"] in report_types:
+        raise TemplateEditorJSONLoadingError(
+            f"The loaded JSON file has an invalid 'report_type' value: '{template_attr['report_type']}'"
+        )
+
+    # Check item_filter
+    common_error_str = "The loaded JSON file does not follow the correct item_filter convention!\n"
+    for query_stanza in template_attr["item_filter"].split(";"):
+        if len(query_stanza) > 0:
+            parts = query_stanza.split("|")
+            if len(parts) != 4:
+                raise TemplateEditorJSONLoadingError(
+                    f"{common_error_str}Each part should be divided by '|', "
+                    f"while the input is '{query_stanza}' under '{template_id_str}', which does not have 3 '|'s"
+                )
+            if parts[0] not in ["A", "O"]:
+                raise TemplateEditorJSONLoadingError(
+                    f"{common_error_str}The first part of the filter can only be 'A' or 'O', "
+                    f"while the first part of the input is '{parts[0]}' under '{template_id_str}'"
+                )
+            prefix = ["i_", "s_", "d_", "t_"]
+            if parts[1][0:2] not in prefix:
+                raise TemplateEditorJSONLoadingError(
+                    f"{common_error_str}The second part of the filter can only be '{prefix}', "
+                    f"while the second part of the input is '{parts[1]}' under '{template_id_str}'"
+                )
+    # TODO: check 'sort_selection' and 'params'
+
+
+def _check_template_name_convention(template_name):
+    if template_name is None:
+        return True
+    parts = template_name.split("_")
+    return len(parts) == 2 and parts[0] == "Template" and parts[1].isdigit()
+
+
 def _build_template_data(guid, templates_data, templates, template_guid_id_map):
     curr_template = None
     for template in templates: