tricc-oo 1.5.26__py3-none-any.whl → 1.6.14__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,8 +2,13 @@ import datetime
 import logging
 import os
 import shutil
+import subprocess
+import tempfile
+import zipfile
 import pandas as pd
 
+from pyxform.xls2xform import convert
+
 from tricc_oo.models.lang import SingletonLangClass
 from tricc_oo.models.calculate import TriccNodeEnd
 from tricc_oo.models.tricc import TriccNodeDisplayModel
@@ -33,6 +38,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 +621,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 +668,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 +717,128 @@ 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")
+        if not self.validate(generated_files):
+            logger.error("CHT validation failed - aborting build")
+            exit(1)
+
+    def validate(self, generated_files=None):
+        """Validate the generated XLS form(s) using pyxform conversion and ODK Validate JAR."""
+        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 ODK Validate JAR is available
+        jar_path = self._ensure_odk_validate_jar()
+        if not jar_path:
+            logger.error("ODK Validate JAR 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:
+                # Convert XLS to XForm using pyxform (without validation)
+                xform_path = xls_file.replace('.xlsx', '.xml')
+                convert_result = convert(
+                    xlsform=xls_file,
+                    validate=False,  # Don't validate during conversion
+                    pretty_print=True
+                )
+                xform_content = convert_result.xform
+
+                # Write XForm to temporary file for validation
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.xml', delete=False) as temp_file:
+                    temp_file.write(xform_content)
+                    temp_xform_path = temp_file.name
+
+                try:
+                    # Run ODK Validate JAR on the XForm
+                    result = subprocess.run(
+                        ["java", "-Djava.awt.headless=true", "-jar", jar_path, temp_xform_path],
+                        capture_output=True,
+                        text=True,
+                        cwd=self.output_path
+                    )
+
+                    if result.returncode == 0 or "Cycle detected" in result.stderr:
+                        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
+
+                finally:
+                    # Clean up temporary XForm file
+                    os.unlink(temp_xform_path)
+
+            except Exception as e:
+                logger.error(f"CHT XLSForm validation error for {os.path.basename(xls_file)}: {str(e)}")
+                all_valid = False
+
+                jar_in_zip = "site-packages/pyxform/validators/odk_validate/bin/ODK_Validate.jar"
+                zip_ref.extract(jar_in_zip, os.path.dirname(__file__))
+
+                # Move to final location
+                extracted_jar = os.path.join(os.path.dirname(__file__), jar_in_zip)
+                shutil.move(extracted_jar, jar_path)
+
+            logger.info(f"Extracted ODK Validate JAR to {jar_path}")
+            return jar_path
+
+    def _ensure_odk_validate_jar(self):
+        """Ensure ODK Validate JAR is available by downloading from GitHub releases."""
+        jar_path = os.path.join(os.path.dirname(__file__), "ODK_Validate.jar")
+
+        # Check if JAR already exists
+        if os.path.exists(jar_path):
+            return jar_path
+
+        # Download JAR from GitHub releases
+        jar_url = "https://github.com/getodk/validate/releases/download/v1.20.0/ODK-Validate-v1.20.0.jar"
+        try:
+            import urllib.request
+            urllib.request.urlretrieve(jar_url, jar_path)
+            logger.info(f"Downloaded ODK Validate JAR to {jar_path}")
+            return jar_path
+        except Exception as e:
+            logger.error(f"Failed to download ODK Validate JAR: {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));
@@ -729,7 +863,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
             self.clean_coalesce(ref_expressions[2])
             } ,{
             self.clean_coalesce(ref_expressions[3])
-            }, true)"""
+            }, true"""
 
     def tricc_operation_drug_dosage(self, ref_expressions):
         # drug name