tricc-oo 1.5.26__py3-none-any.whl → 1.6.8__py3-none-any.whl

tricc_oo/strategies/output/openmrs_form.py

@@ -21,6 +21,7 @@ from tricc_oo.models.tricc import (
     TriccNodeSelectOption,
     TriccNodeInputModel,
     TriccNodeBaseModel,
+    TriccNodeSelect,
     TriccNodeDisplayModel,
 )
 
@@ -69,6 +70,9 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         self.current_segment = None
         self.current_activity = None
         self.concept_map = {}
+        self.calculated_fields = []  # Store calculated fields to add to first section of each page
+        self.calculated_fields_added = set()  # Track which pages have had calculated fields added
+        self.inject_version()
 
     def get_export_name(self, r):
         if isinstance(r, TriccNodeSelectOption):
@@ -146,6 +150,9 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         logger.info("generate the export format")
         self.process_export(self.project.start_pages, pages=self.project.pages)
 
+        logger.info("create calculation page")
+        self.create_calculation_page()
+
         logger.info("print the export")
         self.export(self.project.start_pages, version=version)
 
@@ -160,7 +167,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
             'select_multiple': 'multiCheckbox',
             'select_yesno': 'select',
             'not_available': 'checkbox',
-            'note': 'text'
+            'note': 'markdown'
         }
 
         # if issubclass(node.__class__, TriccNodeSelectYesNo):
@@ -250,7 +257,9 @@ class OpenMRSStrategy(BaseOutPutStrategy):
                         }
                     }
                 }
-                return question
+                # Collect calculated fields to add to first section of each page
+                self.calculated_fields.append(question)
+                return None  # Don't return the question, it will be added to first section
         return None
 
     def generate_calculate(self, node, processed_nodes, **kwargs):
@@ -400,6 +409,8 @@ class OpenMRSStrategy(BaseOutPutStrategy):
             return f"'{option}'"
         elif issubclass(r.__class__, TriccNodeInputModel):
             return self.get_export_name(r)
+        elif issubclass(r.__class__, TriccNodeSelect):
+            return "(" + self.get_export_name(r) + " ?? [])"
         elif issubclass(r.__class__, TriccNodeBaseModel):
             return self.get_export_name(r)
         else:
@@ -439,7 +450,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         if len(ref_expressions) == 1:
             return ref_expressions[0]
         if len(ref_expressions) > 1:
-            return " || ".join(ref_expressions)
+            return "(" + " || ".join(ref_expressions) + ")"
         else:
             return "true"
 
@@ -447,7 +458,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         return f"!({ref_expressions[0]})"
 
     def tricc_operation_plus(self, ref_expressions):
-        return " + ".join(ref_expressions)
+        return "(" + " + ".join(ref_expressions) + ")"
 
     def tricc_operation_minus(self, ref_expressions):
         if len(ref_expressions) > 1:
@@ -472,7 +483,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         return f"({ref_expressions[0]}.includes({ref_expressions[1]}))"
 
     def tricc_operation_count(self, ref_expressions):
-        return f"({ref_expressions[0]}.length)"
+        return f"{ref_expressions[0]}.length"
 
     def tricc_operation_multiplied(self, ref_expressions):
         return "*".join(ref_expressions)
@@ -638,6 +649,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
             "label": section_label,
             "questions": []
         })
+
         if group_node.relevance:
             relevance_str = self.convert_expression_to_string(not_clean(group_node.relevance))
             if relevance_str and relevance_str != 'false':
@@ -645,3 +657,38 @@ class OpenMRSStrategy(BaseOutPutStrategy):
                     "hideWhenExpression": f"{relevance_str}"
                 }
         logger.debug(f"Started section: {section_label}")
+
+    def create_calculation_page(self):
+        """Create a dedicated page for all calculated fields"""
+        if self.calculated_fields:
+            self.clean_sections()
+            self.clean_pages()
+            page = {
+                "label": "Calculations",
+                "sections": [
+                    {
+                        "label": "Calculations",
+                        "questions": self.calculated_fields
+                    }
+                ]
+            }
+            self.form_data["pages"].append(page)
+            logger.debug("Created calculation page")
+
+    def inject_version(self):
+        # Add hidden version field using version() function
+        question = {
+            "id": "version",
+            "type": "control",
+            "label": "",
+            "hide": {
+                "hideWhenExpression": "true"
+            },
+            "questionOptions": {
+                "calculate": {
+                    "calculateExpression": "version()"
+                }
+            }
+        }
+        # Collect calculated fields to add to first section of each page
+        self.calculated_fields.append(question)

tricc_oo/strategies/output/xls_form.py

@@ -8,6 +8,7 @@ import logging
 import os
 import re
 import pandas as pd
+from pyxform import create_survey_from_xls
 
 from tricc_oo.converters.utils import clean_name
 from tricc_oo.models.base import (
@@ -131,7 +132,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
         return generate_xls_form_export(self, node, **kwargs)
 
     def inject_version(self):
-        # Add hidden version field using ODK's jr:version()
+        # Add hidden version field using ODK's version()
         empty = langs.get_trads("", force_dict=True)
         self.df_survey.loc[len(self.df_survey)] = [
             "hidden",
@@ -148,7 +149,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
             "",  # required
             *list(empty.values()),  # required_message
             "",  # read only
-            "jr:version()",  # calculation
+            "version()",  # calculation
             "",  # trigger
             "",  # repeat_count
             "",  # image
@@ -409,7 +410,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
         return f"count-selected({self.clean_coalesce(ref_expressions[0])})"
 
     def tricc_operation_multiplied(self, ref_expressions):
-        return "*".join(ref_expressions)
+        return "*".join(map(str, ref_expressions))
 
     def tricc_operation_divided(self, ref_expressions):
         return f"{ref_expressions[0]} div {ref_expressions[1]}"
@@ -430,7 +431,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
             return f"-{ref_expressions[0]}"
 
     def tricc_operation_plus(self, ref_expressions):
-        return " + ".join(ref_expressions)
+        return " + ".join(map(str, ref_expressions))
 
     def tricc_operation_not(self, ref_expressions):
         return f"not({ref_expressions[0]})"
@@ -460,9 +461,9 @@ class XLSFormStrategy(BaseOutPutStrategy):
             return "1"
 
     def tricc_operation_native(self, ref_expressions):
-    
+
         if len(ref_expressions) > 0:
-            if ref_expressions[0].startswith(("'","`",)):
+            if ref_expressions[0].startswith(("'", "`",)):
                 ref_expressions[0] = ref_expressions[0][1:-1]
             if ref_expressions[0] == "GetChoiceName":
                 return f"""jr:choice-name({
@@ -474,7 +475,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
                 return "0"
                 # return f"jr:choice-name({','.join(ref_expressions[1:])})"
             else:
-                return f"{ref_expressions[0]}({','.join(ref_expressions[1:])})"
+                return f"{ref_expressions[0]}({','.join(map(str, ref_expressions[1:]))})"
 
     def tricc_operation_istrue(self, ref_expressions):
         if str(BOOLEAN_MAP[str(TRICC_TRUE_VALUE)]).isnumeric():
@@ -495,7 +496,12 @@ class XLSFormStrategy(BaseOutPutStrategy):
         parts = []
         for s in ref_expressions[1:]:
             # for option with numeric value
-            cleaned_s = s if isinstance(s, str) else "'" + str(s) + "'"
+            if isinstance(s, str):
+                cleaned_s = s
+            elif isinstance(s, TriccNodeSelectOption):
+                cleaned_s = s.name
+            else:
+                cleaned_s = "'" + str(s) + "'"
             parts.append(f"selected({self.clean_coalesce(ref_expressions[0])}, {cleaned_s})")
         if len(parts) == 1:
             return parts[0]
@@ -548,15 +554,15 @@ class XLSFormStrategy(BaseOutPutStrategy):
         ifs = 0
         parts = []
         else_found = False
-        if not isinstance(ref_expressions[0], list):
+        if isinstance(ref_expressions[0], list):
             return self.tricc_operation_ifs(ref_expressions)
-        for i in range(int(len(ref_expressions))):
+        for i in range(int(len(ref_expressions[1:]))):
             if isinstance(ref_expressions[i], list):
-                parts.append(f"if({ref_expressions[i][0]},{ref_expressions[i][1]}")
+                parts.append(f"if({ref_expressions[0]}={ref_expressions[i+1][0]},{ref_expressions[i+1][1]}")
                 ifs += 1
             else:
                 else_found = True
-                parts.append(ref_expressions[i])
+                parts.append(ref_expressions[i+1])
         # join the if
         exp = ",".join(map(str, parts))
         # in case there is no default put ''
@@ -571,15 +577,16 @@ class XLSFormStrategy(BaseOutPutStrategy):
         ifs = 0
         parts = []
         else_found = False
-        for i in range(int(len(ref_expressions[1:]))):
-            if isinstance(ref_expressions[i + 1], list):
-                parts.append(f"if({ref_expressions[0]}={ref_expressions[i+1][0]},{ref_expressions[i+1][1]}")
+        for i in range(int(len(ref_expressions))):
+            if isinstance(ref_expressions[i], list):
+                parts.append(f"if({ref_expressions[i][0]},{ref_expressions[i][1]}")
                 ifs += 1
             else:
                 else_found = True
-                parts.append(ref_expressions[i + 1])
+                parts.append(ref_expressions[i])
+                break
         # join the if
-        exp = ",".join(parts)
+        exp = ",".join(map(str, parts))
         # in case there is no default put ''
         if not else_found:
             exp += ",''"
@@ -588,11 +595,14 @@ class XLSFormStrategy(BaseOutPutStrategy):
             exp += ")"
         return exp
 
+    def get_empty_label(self):
+        return "."
+
     def tricc_operation_if(self, ref_expressions):
         return f"if({ref_expressions[0]},{ref_expressions[1]},{ref_expressions[2]})"
 
     def tricc_operation_contains(self, ref_expressions):
-        return f"contains('{self.clean_coalesce(ref_expressions[0])}', '{self.clean_coalesce(ref_expressions[1])}')"
+        return f"contains({self.clean_coalesce(ref_expressions[0])}, {self.clean_coalesce(ref_expressions[1])})"
 
     def tricc_operation_exists(self, ref_expressions):
         parts = []
@@ -720,22 +730,12 @@ class XLSFormStrategy(BaseOutPutStrategy):
         # @param r reference to be translated
         if isinstance(r, TriccOperation):
             return self.get_tricc_operation_expression(r)
+        elif isinstance(r, (TriccStatic, str, int, float)):
+            return get_export_name(r)
         elif isinstance(r, TriccReference):
             logger.warning(f"reference `{r.value}` still used in a calculate")
             return f"${{{get_export_name(r.value)}}}"
-        elif isinstance(r, TriccStatic):
-            return get_export_name(r)
-        elif isinstance(r, str):
-            if r == TRICC_TRUE_VALUE:
-                return BOOLEAN_MAP[str(TRICC_TRUE_VALUE)]
-            elif r == TRICC_FALSE_VALUE:
-                return BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]
-            elif isinstance(r, str):
-                return f"'{r}'"
-            else:
-                return str(r)
-        elif isinstance(r, (int, float)):
-            return str(r)
+
         elif isinstance(r, TriccNodeSelectOption):
             logger.debug(f"select option {r.get_name()} from {r.select.get_name()} was used as a reference")
             return get_export_name(r)
@@ -747,4 +747,34 @@ class XLSFormStrategy(BaseOutPutStrategy):
             raise NotImplementedError(f"This type of node {r.__class__} is not supported within an operation")
 
     def tricc_operation_concatenate(self, ref_expressions):
-        return f"concat({','.join(ref_expressions)})"
+        return f"concat({','.join(map(str, ref_expressions))})"
+
+    def validate(self):
+        """Validate the generated XLS form using pyxform."""
+        try:
+            # Determine the XLS file path
+            if self.project.start_pages["main"].root.form_id is not None:
+                form_id = str(self.project.start_pages["main"].root.form_id)
+                xls_path = os.path.join(self.output_path, form_id + ".xlsx")
+
+                if not os.path.exists(xls_path):
+                    logger.error(f"XLS file not found: {xls_path}")
+                    return False
+
+                # Validate using pyxform
+                survey = create_survey_from_xls(xls_path)
+                xml_output = survey.to_xml()
+
+                # Check if XML was generated successfully
+                if xml_output and len(xml_output.strip()) > 0:
+                    logger.info("XLSForm validation successful")
+                    return True
+                else:
+                    logger.error("XLSForm validation failed: Empty XML output")
+                    return False
+            else:
+                logger.error("Form ID not found for validation")
+                return False
+        except Exception as e:
+            logger.error(f"XLSForm validation failed: {str(e)}")
+            return False

tricc_oo/strategies/output/xlsform_cht.py

@@ -2,6 +2,7 @@ import datetime
 import logging
 import os
 import shutil
+import subprocess
 import pandas as pd
 
 from tricc_oo.models.lang import SingletonLangClass
@@ -33,6 +34,9 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
 
         self.inject_version()
 
+    def get_empty_label(self):
+        return "NO_LABEL"
+
     def get_cht_input(self, start_pages, **kwargs):
         empty = langs.get_trads("", force_dict=True)
         df_input = pd.DataFrame(columns=SURVEY_MAP.keys())
@@ -613,6 +617,9 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
         newpath = os.path.join(self.output_path, newfilename)
         media_path = os.path.join(self.output_path, form_id + "-media")
 
+        # Track all generated XLS files for validation
+        generated_files = [newpath]
+
         settings = {
             "form_title": title,
             "form_id": form_id,
@@ -657,6 +664,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
                 new_form_id = f"{form_id}_{clean_name(e.name)}"
                 newfilename = f"{new_form_id}.xlsx"
                 newpath = os.path.join(self.output_path, newfilename)
+                generated_files.append(newpath)  # Track additional XLS files
                 settings = {
                     "form_title": title,
                     "form_id": f"{new_form_id}",
@@ -705,6 +713,105 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
                 shutil.move(os.path.join(media_path_tmp, file_name), media_path)
             shutil.rmtree(media_path_tmp)
 
+        return generated_files
+
+    def execute(self):
+        """Override execute to handle multiple output files from CHT strategy."""
+        version = datetime.datetime.now().strftime("%Y%m%d%H%M")
+        logger.info(f"build version: {version}")
+        if "main" in self.project.start_pages:
+            self.process_base(self.project.start_pages, pages=self.project.pages, version=version)
+        else:
+            logger.critical("Main process required")
+
+        logger.info("generate the relevance based on edges")
+
+        # create relevance Expression
+
+        # create calculate Expression
+        self.process_calculate(self.project.start_pages, pages=self.project.pages)
+        logger.info("generate the export format")
+        # create calculate Expression
+        self.process_export(self.project.start_pages, pages=self.project.pages)
+
+        logger.info("print the export")
+
+        # Export returns list of generated files for CHT strategy
+        generated_files = self.export(self.project.start_pages, version=version)
+
+        logger.info("validate the output")
+        self.validate(generated_files)
+
+    def validate(self, generated_files=None):
+        """Validate the generated XLS form(s) using xls2xform-medic."""
+        if generated_files is None:
+            # Fallback for single file validation
+            if self.project.start_pages["main"].root.form_id is not None:
+                form_id = str(self.project.start_pages["main"].root.form_id)
+                generated_files = [os.path.join(self.output_path, form_id + ".xlsx")]
+            else:
+                logger.error("Form ID not found for validation")
+                return False
+
+        # Ensure xls2xform-medic is available
+        medic_tool = self._ensure_xls2xform_medic()
+        if not medic_tool:
+            logger.error("xls2xform-medic tool not available, skipping CHT validation")
+            return False
+
+        all_valid = True
+        for xls_file in generated_files:
+            if not os.path.exists(xls_file):
+                logger.error(f"XLS file not found: {xls_file}")
+                all_valid = False
+                continue
+
+            try:
+                # Run xls2xform-medic validation
+                result = subprocess.run(
+                    [medic_tool, xls_file],
+                    capture_output=True,
+                    text=True,
+                    cwd=self.output_path
+                )
+
+                if result.returncode == 0:
+                    logger.info(f"CHT XLSForm validation successful: {os.path.basename(xls_file)}")
+                else:
+                    logger.error(f"CHT XLSForm validation failed for {os.path.basename(xls_file)}: {result.stderr}")
+                    all_valid = False
+
+            except Exception as e:
+                logger.error(f"CHT XLSForm validation error for {os.path.basename(xls_file)}: {str(e)}")
+                all_valid = False
+
+        return all_valid
+
+    def _ensure_xls2xform_medic(self):
+        """Ensure xls2xform-medic tool is available."""
+        # Check if it's in PATH
+        medic_tool = shutil.which("xls2xform-medic")
+        if medic_tool:
+            return medic_tool
+
+        # Check if we need to download it
+        medic_path = os.path.join(os.path.dirname(__file__), "xls2xform-medic")
+        if os.path.exists(medic_path):
+            return medic_path
+
+        # Try to download from the provided URL
+        try:
+            import urllib.request
+            medic_url = "https://github.com/medic/pyxform/releases/download/v4.0.0-medic/xls2xform-medic"
+            logger.info(f"Downloading xls2xform-medic from {medic_url}")
+            urllib.request.urlretrieve(medic_url, medic_path)
+            # Make executable
+            os.chmod(medic_path, 0o755)
+            return medic_path
+        except Exception as e:
+            logger.error(f"Failed to download xls2xform-medic: {str(e)}")
+            return None
+
     def tricc_operation_zscore(self, ref_expressions):
         y, ll, m, s = self.get_zscore_params(ref_expressions)
         #  return ((Math.pow((y / m), l) - 1) / (s * l));