refactor code to use interfaces

Akol125 · Akol125 · commit 2915b1b856b7 · 2025-11-10T03:52:19.000Z
diff --git a/lambdas/shared/src/common/validator/error_report/error_reporter.py b/lambdas/shared/src/common/validator/error_report/error_reporter.py
@@ -29,10 +29,6 @@ def check_error_record_for_fail(expression_identifier: str, error_records: list[
 
 
 def build_error_report(event_id: str, data_parser: dict, error_records: list[ErrorReport]) -> dict:
-    occurrence_date_time = data_parser.get_fhir_value("occurrenceDateTime")
+    occurrence_date_time = data_parser.extract_field_value("occurrenceDateTime")
     dq_reporter = DQReporter()
     return dq_reporter.generate_error_report(event_id, occurrence_date_time, error_records)
-
-
-def has_validation_failed(error_records: list[ErrorReport]) -> bool:
-    return any(er.error_level == ErrorLevels.CRITICAL_ERROR for er in error_records)
diff --git a/lambdas/shared/src/common/validator/parsers/fetch_parsers.py b/lambdas/shared/src/common/validator/parsers/fetch_parsers.py
diff --git a/lambdas/shared/src/common/validator/parsers/paser_interface.py b/lambdas/shared/src/common/validator/parsers/paser_interface.py
@@ -0,0 +1,44 @@
+# validation_engine/sources/source_definitions.py
+
+from abc import ABC, abstractmethod
+
+from common.validator.parsers.csv_line_parser import CSVLineParser
+from common.validator.parsers.fhir_parser import FHIRParser
+
+
+class PaserInterface(ABC):
+    """Defines a common interface for all data extractors."""
+
+    @abstractmethod
+    def extract_field_values(self, field_path: str, data) -> dict:
+        pass
+
+    @abstractmethod
+    def get_data_format(self) -> str:
+        pass
+
+
+class FHIRInterface(PaserInterface):
+    def __init__(self, fhir_data: dict):
+        self.fhir_parser = FHIRParser()
+        self.fhir_parser.parse_fhir_data(fhir_data)
+
+    def get_data_format(self) -> str:
+        return "fhir"
+
+    def extract_field_values(self, field_path):
+        fhir_value = self.fhir_parser.get_fhir_value_list(field_path)
+        return fhir_value
+
+
+class BatchInterface(PaserInterface):
+    def __init__(self, csv_row: str, csv_header: str):
+        self.csv_line_parser = CSVLineParser()
+        self.csv_line_parser.parse_csv_line(csv_row, csv_header)
+
+    def get_data_format(self) -> str:
+        return "batch"
+
+    def extract_field_values(self, field_path):
+        csv_value = self.csv_line_parser.get_key_value(field_path)
+        return csv_value
diff --git a/lambdas/shared/src/common/validator/parsers/schema_parser.py b/lambdas/shared/src/common/validator/parsers/schema_parser.py
@@ -31,6 +31,7 @@ def parse_schema(self, schema_file: dict) -> None:
         """
         self.schema_file = schema_file
         self.expressions = self.schema_file["expressions"]
+        return self
 
     def expression_count(self) -> int:
         """Returns the number of expressions containing the 'expression' key."""
diff --git a/lambdas/shared/src/common/validator/validator.py b/lambdas/shared/src/common/validator/validator.py
@@ -9,26 +9,28 @@
 from common.validator.error_report.error_reporter import add_error_record, check_error_record_for_fail
 from common.validator.error_report.record_error import ErrorReport
 from common.validator.expression_checker import ExpressionChecker
-from common.validator.parsers.fetch_parsers import FetchParsers
+from common.validator.parsers.schema_parser import SchemaParser
+from src.common.validator.parsers.paser_interface import BatchInterface, FHIRInterface, PaserInterface
 
 
 class Validator:
     def __init__(self, schema_file=""):
         self.schema_file = schema_file
-        self.get_data_from_parsers = FetchParsers()
+        self.schema_parser = SchemaParser()
 
-    #  validate a single expression against the data file
+    #  validate expression against incoming data
     def _validate_expression(
         self,
         expression_validator: ExpressionChecker,
         expression: dict,
-        data_parser,
+        data_parser: PaserInterface,
         error_records: list[ErrorReport],
         inc_header_in_row_count: bool,
-        is_csv: bool,
     ) -> ErrorReport | int:
         row = 2 if inc_header_in_row_count else 1
-        expression_fieldname = expression["fieldNameFlat"] if is_csv else expression["fieldNameFHIR"]
+
+        data_format = data_parser.get_data_format()
+        expression_fieldname = expression["fieldNameFlat"] if data_format == "batch" else expression["fieldNameFHIR"]
 
         expression_id = expression["expressionId"]
         error_level = expression["errorLevel"]
@@ -51,7 +53,8 @@ def _validate_expression(
                 return
 
         try:
-            expression_values = data_parser.get_key_value(expression_fieldname)
+            expression_values = data_parser.extract_field_values(expression_fieldname)
+            print(f"Extracted values for field {expression_fieldname}: {expression_values}")
         except Exception as e:
             message = f"Data get values Unexpected exception [{e.__class__.__name__}]: {e}"
             error_record = ErrorReport(code=ExceptionLevels.PARSING_ERROR, message=message)
@@ -127,7 +130,6 @@ def run_validation(
         self,
         data_type: DataType,
         fhir_data: dict = None,
-        batch_filepath: str = None,
         csv_row: str = None,
         csv_header: list[str] = None,
         summarise=False,
@@ -139,24 +141,22 @@ def run_validation(
         try:
             match data_type:
                 case DataType.FHIR:
-                    data_parser = self.get_data_from_parsers._get_fhir_parser(fhir_data)
-                    is_csv = False
+                    data_parser = FHIRInterface(fhir_data)
                 case DataType.CSVROW:
-                    data_parser = self.get_data_from_parsers._get_csv_line_parser(csv_row, csv_header)
-                    is_csv = True
+                    data_parser = BatchInterface(csv_row, csv_header)
 
         except Exception as e:
             if report_unexpected_exception:
                 message = f"Data Parser Unexpected exception [{e.__class__.__name__}]: {e}"
                 return [ErrorReport(code=0, message=message)]
 
-        schema_parser = self.get_data_from_parsers._get_schema_parser(self.schema_file)
+        schema_parser = self.schema_parser.parse_schema(self.schema_file)
         expression_validator = ExpressionChecker(data_parser, summarise, report_unexpected_exception)
-        expressions = schema_parser.get_expressions()
+        expressions_in_schema = schema_parser.get_expressions()
 
-        for expression in expressions:
+        for expression in expressions_in_schema:
             self._validate_expression(
-                expression_validator, expression, data_parser, error_records, inc_header_in_row_count, is_csv
+                expression_validator, expression, data_parser, error_records, inc_header_in_row_count
             )
 
         return error_records
diff --git a/lambdas/shared/tests/test_common/validator/test_application_fhir.py b/lambdas/shared/tests/test_common/validator/test_application_fhir.py
@@ -14,17 +14,16 @@ def setUp(self):
         validation_folder = Path(__file__).resolve().parent
         self.FHIRFilePath = validation_folder / "sample_data/vaccination2.json"
         self.schemaFilePath = validation_folder / "test_schemas/test_schema.json"
-        self.fhir_resources = None
 
     def test_validation(self):
         start = time.time()
 
         SchemaFile = parse_test_file(self.schemaFilePath)
         self.fhir_resources = parse_test_file(self.FHIRFilePath)
         fhir_parser = Mock()
-        fhir_parser.get_fhir_value.return_value = "2025-11-06T12:00:00Z"
+        fhir_parser.extract_field_value.return_value = "2025-11-06T12:00:00Z"
 
-        validator = Validator(SchemaFile)  # FHIR File Path not needed
+        validator = Validator(SchemaFile)
         error_list = validator.validate_fhir(self.fhir_resources, True, True, True)
         error_report = build_error_report(
             "25a8cc4d-1875-4191-ac6d-2d63a0ebc64b", fhir_parser, error_list
diff --git a/lambdas/shared/tests/test_common/validator/test_schemas/test_schema.json b/lambdas/shared/tests/test_common/validator/test_schemas/test_schema.json
@@ -78,8 +78,8 @@
       "errorLevel": 2,
       "expression": {
         "expressionName": "Defaults to",
-        "expressionType": "",
-        "expressionRule": "NOTEMPTY"
+        "expressionType": "NOTEMPTY",
+        "expressionRule": ""
       },
       "errorGroup": "completeness"
     },
@@ -91,7 +91,7 @@
       "errorLevel": 0,
       "expression": {
         "expressionName": "Date Convert",
-        "expressionType": "",
+        "expressionType": "NOTEMPTY",
         "expressionRule": ""
       },
       "errorGroup": "consistency"
@@ -117,7 +117,7 @@
       "errorLevel": 1,
       "expression": {
         "expressionName": "Defaults to",
-        "expressionType": "DEFAULT",
+        "expressionType": "NOTEMPTY",
         "expressionRule": ""
       },
       "errorGroup": "consistency"
@@ -195,7 +195,7 @@
       "errorLevel": 1,
       "expression": {
         "expressionName": "Recorded Date Convert",
-        "expressionType": "DATECONVERT",
+        "expressionType": "NOTEMPTY",
         "expressionRule": ""
       },
       "errorGroup": "consistency"
@@ -442,7 +442,7 @@
       "errorLevel": 1,
       "expression": {
         "expressionName": "Location Code Type URI Default Check",
-        "expressionType": "DEFAULT",
+        "expressionType": "NOTEMPTY",
         "expressionRule": ""
       },
       "errorGroup": "consistency"
