uplift validation rules and create utility used in expression checker

Author: Akol125

lambdas/shared/src/common/validator/expression_checker.py

@@ -1,11 +1,13 @@
 import datetime
 import re
 import uuid
+from typing import Optional
 
 from common.validator.constants.enums import MESSAGES, ExceptionLevels, MessageLabel
 from common.validator.error_report.record_error import ErrorReport, RecordError
 from common.validator.lookup_expressions.key_data import KeyData
 from common.validator.lookup_expressions.lookup_data import LookUpData
+from common.validator.validation_utils import check_if_future_date
 
 
 class ExpressionChecker:
@@ -28,8 +30,10 @@ def validate_expression(
                 return self._validate_datetime(expression_rule, field_name, field_value, row)
             case "STRING":
                 return self._validate_for_string_values(expression_rule, field_name, field_value, row)
+            case "LIST":
+                return self._validate_for_list_values(expression_rule, field_name, field_value, row)
             case "DATE":
-                return self._validate_datetime(expression_rule, field_name, field_value, row)
+                return self.validate_for_date(expression_rule, field_name, field_value, row)
             case "UUID":
                 return self._validate_uuid(expression_rule, field_name, field_value, row)
             case "INT":
@@ -97,6 +101,23 @@ def _validate_datetime(self, _expression_rule, field_name, field_value, row) ->
                 message = MESSAGES[ExceptionLevels.UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)
                 return ErrorReport(ExceptionLevels.UNEXPECTED_EXCEPTION, message, row, field_name, "", self.summarise)
 
+    def validate_for_date(self, _expression_rule, field_name, field_value, row, future_date_allowed: bool = False):
+        """
+        Apply pre-validation to a date field to ensure that it is a string (JSON dates must be
+        written as strings) containing a valid date in the format "YYYY-MM-DD"
+        """
+        if not isinstance(field_value, str):
+            raise TypeError(f"{field_name} must be a string")
+
+        try:
+            parsed_date = datetime.strptime(field_value, "%Y-%m-%d").date()
+        except ValueError as value_error:
+            raise ValueError(f'{field_name} must be a valid date string in the format "YYYY-MM-DD"') from value_error
+
+        # Enforce future date rule using central checker after successful parse
+        if not future_date_allowed and check_if_future_date(parsed_date):
+            raise ValueError(f"{field_name} must not be in the future")
+
     # UUID validate
     def _validate_uuid(self, _expression_rule: str, field_name: str, field_value: str, row: dict) -> ErrorReport:
         try:
@@ -206,6 +227,42 @@ def _validate_equal(self, expression_rule: str, field_name: str, field_value: st
                 message = MESSAGES[ExceptionLevels.UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)
                 return ErrorReport(ExceptionLevels.UNEXPECTED_EXCEPTION, message, row, field_name, "", self.summarise)
 
+    def for_list(self, expression_rule: str, field_name: str, field_value: list, row: dict):
+        """
+        Apply validation to a list field to ensure it is a non-empty list which meets the length requirements and
+        requirements, if applicable, for each list element to be a non-empty string or non-empty dictionary
+        """
+        defined_length: Optional[int] = (None,)
+        max_length: Optional[int] = (None,)
+        elements_are_strings: bool = (False,)
+        string_element_max_length: Optional[int] = (None,)
+        elements_are_dicts: bool = (False,)
+        if not isinstance(field_value, list):
+            raise TypeError(f"{field_name} must be an array")
+
+        if defined_length:
+            if len(field_value) != defined_length:
+                raise ValueError(f"{field_name} must be an array of length {defined_length}")
+        else:
+            if len(field_value) == 0:
+                raise ValueError(f"{field_name} must be a non-empty array")
+
+        if max_length is not None and len(field_value) > max_length:
+            raise ValueError(f"{field_name} must be an array of maximum length {max_length}")
+
+        if elements_are_strings:
+            for idx, element in enumerate(field_value):
+                self._validate_for_string_values.for_string(
+                    element, f"{field_name}[{idx}]", max_length=string_element_max_length
+                )
+
+        if elements_are_dicts:
+            for element in field_value:
+                if not isinstance(element, dict):
+                    raise TypeError(f"{field_name} must be an array of objects")
+                if len(element) == 0:
+                    raise ValueError(f"{field_name} must be an array of non-empty objects")
+
     # Not Equal Validate
     def _validate_not_equal(self, expression_rule: str, field_name: str, field_value: str, row: dict) -> ErrorReport:
         try:

lambdas/shared/src/common/validator/validation_utils.py

@@ -0,0 +1,58 @@
+from datetime import date, datetime
+
+from stdnum.verhoeff import validate
+
+
+def check_if_future_date(parsed_value: date | datetime):
+    """
+    Ensure a parsed date or datetime object is not in the future.
+    """
+    if isinstance(parsed_value, datetime):
+        now = datetime.now(parsed_value.tzinfo) if parsed_value.tzinfo else datetime.now()
+    elif isinstance(parsed_value, date):
+        now = datetime.now().date()
+    if parsed_value > now:
+        return True
+    return False
+
+
+def is_valid_simple_snomed(simple_snomed: str) -> bool:
+    "check the snomed code valid or not."
+    min_snomed_length = 6
+    max_snomed_length = 18
+    return (
+        simple_snomed is not None
+        and simple_snomed.isdigit()
+        and simple_snomed[0] != "0"
+        and min_snomed_length <= len(simple_snomed) <= max_snomed_length
+        and validate(simple_snomed)
+        and (simple_snomed[-3:-1] in ("00", "10"))
+    )
+
+
+def nhs_number_mod11_check(nhs_number: str) -> bool:
+    """
+    Parameters:-
+    nhs_number: str
+        The NHS number to be checked.
+    Returns:-
+        True if the nhs number passes the mod 11 check, False otherwise.
+
+    Definition of NHS number can be found at:
+    https://www.datadictionary.nhs.uk/attributes/nhs_number.html
+    """
+    is_mod11 = False
+    if nhs_number.isdigit() and len(nhs_number) == 10:
+        # Create a reversed list of weighting factors
+        weighting_factors = list(range(2, 11))[::-1]
+        # Multiply each of the first nine digits by the weighting factor and add the results of each multiplication
+        # together
+        total = sum(int(digit) * weight for digit, weight in zip(nhs_number[:-1], weighting_factors))
+        # Divide the total by 11 and establish the remainder and subtract the remainder from 11 to give the check digit.
+        # If the result is 11 then a check digit of 0 is used. If the result is 10 then the NHS NUMBER is invalid and
+        # not used.
+        check_digit = 0 if (total % 11 == 0) else (11 - (total % 11))
+        # Check the remainder matches the check digit. If it does not, the NHS NUMBER is invalid.
+        is_mod11 = check_digit == int(nhs_number[-1])
+
+    return is_mod11

lambdas/shared/tests/test_common/validator/test_schemas/test_schema.json

@@ -25,7 +25,7 @@
       "errorLevel": 0,
       "expression": {
         "expressionName": "Person Forname Not Empty Check",
-        "expressionType": "NOTEMPTY",
+        "expressionType": "LIST",
         "expressionRule": ""
       },
       "errorGroup": "completeness"
@@ -39,7 +39,7 @@
       "parentExpression": "01K5EGR0C7Y1WJ0BC803SQDWK4",
       "expression": {
         "expressionName": "Person Surname Not Empty Check",
-        "expressionType": "NOTEMPTY",
+        "expressionType": "STRING",
         "expressionRule": ""
       },
       "errorGroup": "completeness"
@@ -52,7 +52,7 @@
       "errorLevel": 1,
       "expression": {
         "expressionName": "Date of Birth Not Empty Check",
-        "expressionType": "NOTEMPTY",
+        "expressionType": "DATE",
         "expressionRule": ""
       },
       "errorGroup": "consistency"
@@ -65,7 +65,7 @@
       "errorLevel": 1,
       "expression": {
         "expressionName": "Gender Valid Check",
-        "expressionType": "NOTEMPTY",
+        "expressionType": "STRING",
         "expressionRule": ""
       },
       "errorGroup": "consistency"