Merge branch 'main' into feature/eja-eli-204-add-api-gateway

Author: eddalmond1

infrastructure/Makefile

@@ -14,7 +14,7 @@ guard-%:
 # Initializes the Terraform configuration for the specified stack and environment.
 terraform-init: guard-env guard-stack
 	rm -rf ./stacks/$(stack)/.terraform
-	terraform -chdir=./stacks/$(stack) init -var-file=stacks/_shared/tfvars/$(env).tfvars -backend-config=backends/$(env).$(stack).tfbackend -upgrade
+	terraform -chdir=./stacks/$(stack) init -backend-config=backends/$(env).$(stack).tfbackend -upgrade -reconfigure
 	terraform -chdir=./stacks/$(stack) get -update
 
 # Selects or creates a Terraform workspace for the specified stack and environment.
@@ -35,7 +35,7 @@ terraform-workspace-delete: guard-env guard-stack
 
 # Runs a specified Terraform command (e.g., plan, apply) for the stack and environment.
 terraform: guard-env guard-stack guard-tf-command terraform-init terraform-workspace
-	terraform -chdir=./stacks/$(stack) $(tf-command) -var-file=../_shared/tfvars/$(env).tfvars $(args) $(if $(filter $(tf-command),init),,--parallelism=30)
+	terraform -chdir=./stacks/$(stack) $(tf-command) $(args) $(if $(filter $(tf-command),init),,--parallelism=30)
 	rm -f ./terraform_outputs_$(stack).json || true
 	terraform -chdir=./stacks/$(stack) output -json > ./build/terraform_outputs_$(stack).json
 
@@ -45,9 +45,9 @@ terraform: guard-env guard-stack guard-tf-command terraform-init terraform-works
 
 # Initializes the Terraform configuration for the bootstrap stack.
 bootstrap-terraform-init: guard-env
-	terraform -chdir=./stacks/bootstrap init -var-file=stacks/_shared/tfvars/$(env).tfvars -upgrade
+	terraform -chdir=./stacks/bootstrap init -upgrade
 	terraform -chdir=./stacks/bootstrap get -update
 
 # Runs a specified Terraform command (e.g., plan, apply) for the bootstrap stack.
 bootstrap-terraform: guard-env guard-tf-command bootstrap-terraform-init
-	terraform -chdir=./stacks/bootstrap $(tf-command) -var-file=../_shared/tfvars/$(env).tfvars $(args)
+	terraform -chdir=./stacks/bootstrap $(tf-command) $(args)

infrastructure/modules/dynamodb/kms.tf

@@ -1,11 +1,11 @@
 resource "aws_kms_key" "dynamodb_cmk" {
-  description             = "${var.table_name_suffix} Master Key"
+  description             = "${terraform.workspace == "default" ? "" : "${terraform.workspace}-"}${var.table_name_suffix} Master Key"
   deletion_window_in_days = 14
   is_enabled              = true
   enable_key_rotation     = true
 }
 
 resource "aws_kms_alias" "dynamodb_cmk" {
-  name          = "alias/${var.project_name}-${var.table_name_suffix}-cmk"
+  name          = "alias/${terraform.workspace == "default" ? "" : "${terraform.workspace}-"}${var.table_name_suffix}-cmk"
   target_key_id = aws_kms_key.dynamodb_cmk.key_id
 }

src/eligibility_signposting_api/config.py

@@ -1,7 +1,7 @@
 import logging
 import os
 from collections.abc import Sequence
-from functools import lru_cache
+from functools import cache
 from typing import Any, NewType
 
 from pythonjsonlogger.json import JsonFormatter
@@ -17,7 +17,7 @@
 AwsSecretAccessKey = NewType("AwsSecretAccessKey", str)
 
 
-@lru_cache
+@cache
 def config() -> dict[str, Any]:
     return {
         "aws_access_key_id": AwsAccessKey(os.getenv("AWS_ACCESS_KEY_ID", "dummy_key")),

src/eligibility_signposting_api/model/rules.py

@@ -165,6 +165,10 @@ def serialize_dates(v: date, _info: SerializationInfo) -> str:
 
 
 class Rules(BaseModel):
+    """Eligibility rules.
+
+    This is a Pydantic model, into which we can de-serialise rules stored in DPS's format."""
+
     campaign_config: CampaignConfig = Field(..., alias="CampaignConfig")
 
     model_config = {"populate_by_name": True}

src/eligibility_signposting_api/repos/eligibility_repo.py

@@ -25,6 +25,12 @@ def eligibility_table_factory(
 
 @service
 class EligibilityRepo:
+    """Repository class for the data held about a person which may be relevant to calculating their eligibility for
+    vaccination.
+
+    This data is held in a handful of records in a single Dynamodb table.
+    """
+
     def __init__(self, table: Annotated[Any, Inject(qualifier="eligibility_table")]) -> None:
         super().__init__()
         self.table = table

src/eligibility_signposting_api/repos/exceptions.py

@@ -1,2 +1,2 @@
 class NotFoundError(Exception):
-    pass
+    """Requested entity not found in repository."""

src/eligibility_signposting_api/repos/rules_repo.py

@@ -12,6 +12,10 @@
 
 @service
 class RulesRepo:
+    """Repository class for Campaign Rules, which we can use to calculate a person's eligibility for vaccination.
+
+    These rules are stored as JSON files in AWS S3."""
+
     def __init__(
         self,
         s3_client: Annotated[BaseClient, Inject(qualifier="s3")],

src/eligibility_signposting_api/services/eligibility_services.py

@@ -23,6 +23,7 @@ def __init__(self, eligibility_repo: EligibilityRepo, rules_repo: RulesRepo) ->
         self.rules_repo = rules_repo
 
     def get_eligibility_status(self, nhs_number: eligibility.NHSNumber | None = None) -> eligibility.EligibilityStatus:
+        """Calculate a person's eligibility for vaccination given an NHS number."""
         if nhs_number:
             try:
                 person_data = self.eligibility_repo.get_eligibility_data(nhs_number)

src/eligibility_signposting_api/services/rules/operators.py

@@ -18,7 +18,18 @@
 
 @dataclass
 class Operator(BaseMatcher[str | None], ABC):
+    """An operator compares some person's data attribute - date of birth, postcode, flags or so on - against a value
+    specified in a rule."""
+
+    ITEM_DEFAULT_PATTERN: ClassVar[str] = r"(?P<rule_value>[^\[]+)\[\[NVL:(?P<item_default>[^\]]+)\]\]"
+
     rule_value: str
+    item_default: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.rule_value and (match := re.match(self.ITEM_DEFAULT_PATTERN, self.rule_value)):
+            self.rule_value = match.group("rule_value")
+            self.item_default = match.group("item_default")
 
     @abstractmethod
     def _matches(self, item: str | None) -> bool: ...
@@ -28,6 +39,8 @@ def describe_to(self, description: Description) -> None:
 
 
 class OperatorRegistry:
+    """Operators are registered and made available for retrieval here for each RuleOperator."""
+
     registry: ClassVar[dict[RuleOperator, type[Operator]]] = {}
 
     @staticmethod
@@ -50,6 +63,7 @@ class ScalarOperator(Operator, ABC):
     comparator: ClassVar[Callable[[str | None, str | None], bool]]
 
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         data_comparator = cast("Callable[[str|int, str|int], bool]", self.comparator)
         person_data: str | int
         rule_value: str | int
@@ -100,37 +114,43 @@ def describe_to(self, description: Description) -> None:
 @OperatorRegistry.register(RuleOperator.contains)
 class Contains(Operator):
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         return bool(item) and self.rule_value in str(item)
 
 
 @OperatorRegistry.register(RuleOperator.not_contains)
 class NotContains(Operator):
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         return self.rule_value not in str(item)
 
 
 @OperatorRegistry.register(RuleOperator.starts_with)
 class StartsWith(Operator):
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         return str(item).startswith(self.rule_value)
 
 
 @OperatorRegistry.register(RuleOperator.not_starts_with)
 class NotStartsWith(Operator):
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         return not str(item).startswith(self.rule_value)
 
 
 @OperatorRegistry.register(RuleOperator.ends_with)
 class EndsWith(Operator):
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         return str(item).endswith(self.rule_value)
 
 
 @OperatorRegistry.register(RuleOperator.is_in)
 @OperatorRegistry.register(RuleOperator.member_of)
 class IsIn(Operator):
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         comparators = str(self.rule_value).split(",")
         return str(item) in comparators
 
@@ -139,6 +159,7 @@ def _matches(self, item: str | None) -> bool:
 @OperatorRegistry.register(RuleOperator.not_member_of)
 class NotIn(Operator):
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         comparators = str(self.rule_value).split(",")
         return str(item) not in comparators
 
@@ -156,8 +177,12 @@ def _matches(self, item: str | None) -> bool:
 
 
 class RangeOperator(Operator, ABC):
-    def __init__(self, rule_value: str) -> None:
-        super().__init__(rule_value=rule_value)
+    low_comparator: int
+    high_comparator: int
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+
         low_comparator_str, high_comparator_str = str(self.rule_value).split(",")
         self.low_comparator = min(int(low_comparator_str), int(high_comparator_str))
         self.high_comparator = max(int(low_comparator_str), int(high_comparator_str))
@@ -166,6 +191,7 @@ def __init__(self, rule_value: str) -> None:
 @OperatorRegistry.register(RuleOperator.is_between)
 class Between(RangeOperator):
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         if item in (None, ""):
             return False
         return self.low_comparator <= int(item) <= self.high_comparator
@@ -174,6 +200,7 @@ def _matches(self, item: str | None) -> bool:
 @OperatorRegistry.register(RuleOperator.is_not_between)
 class NotBetween(RangeOperator):
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         if item in (None, ""):
             return False
         return not self.low_comparator <= int(item) <= self.high_comparator
@@ -204,8 +231,17 @@ def _matches(self, item: str | None) -> bool:
 
 
 class DateOperator(Operator, ABC):
+    OFFSET_PATTERN: ClassVar[str] = r"(?P<rule_value>[^\[]+)\[\[OFFSET:(?P<offset>\d{8})\]\]"
     delta_type: ClassVar[str]
     comparator: ClassVar[Callable[[date, date], bool]]
+    offset: date | None = None
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+
+        if self.rule_value and (match := re.match(self.OFFSET_PATTERN, self.rule_value)):
+            self.rule_value = match.group("rule_value")
+            self.offset = datetime.strptime(match.group("offset"), "%Y%m%d").replace(tzinfo=UTC).date()
 
     @property
     def today(self) -> date:
@@ -219,9 +255,10 @@ def get_attribute_date(item: str | None) -> date | None:
     def cutoff(self) -> date:
         delta = relativedelta()
         setattr(delta, self.delta_type, int(self.rule_value))
-        return self.today + delta
+        return (self.offset if self.offset else self.today) + delta
 
     def _matches(self, item: str | None) -> bool:
+        item = item if item is not None else self.item_default
         if attribute_date := self.get_attribute_date(item):
             date_comparator = cast("Callable[[date, date], bool]", self.comparator)
             return date_comparator(attribute_date, self.cutoff)

src/eligibility_signposting_api/views/eligibility.py

@@ -10,12 +10,12 @@
 
 from eligibility_signposting_api.model.eligibility import EligibilityStatus, NHSNumber, Status
 from eligibility_signposting_api.services import EligibilityService, UnknownPersonError
-from eligibility_signposting_api.views import response_models
+from eligibility_signposting_api.views.response_model import eligibility
 
 STATUS_MAPPING = {
-    Status.actionable: response_models.Status.actionable,
-    Status.not_actionable: response_models.Status.not_actionable,
-    Status.not_eligible: response_models.Status.not_eligible,
+    Status.actionable: eligibility.Status.actionable,
+    Status.not_actionable: eligibility.Status.not_actionable,
+    Status.not_eligible: eligibility.Status.not_eligible,
 }
 
 logger = logging.getLogger(__name__)
@@ -48,23 +48,23 @@ def check_eligibility(nhs_number: NHSNumber, eligibility_service: Injected[Eligi
 
 def build_eligibility_response(
     eligibility_status: EligibilityStatus,
-) -> response_models.EligibilityResponse:
+) -> eligibility.EligibilityResponse:
     """Return an object representing the API response we are going to send, given an evaluation of the person's
     eligibility."""
-    return response_models.EligibilityResponse(  # pyright: ignore[reportCallIssue]
+    return eligibility.EligibilityResponse(  # pyright: ignore[reportCallIssue]
         response_id=uuid.uuid4(),  # pyright: ignore[reportCallIssue]
-        meta=response_models.Meta(last_updated=response_models.LastUpdated(datetime.now(tz=UTC))),  # pyright: ignore[reportCallIssue]
+        meta=eligibility.Meta(last_updated=eligibility.LastUpdated(datetime.now(tz=UTC))),  # pyright: ignore[reportCallIssue]
         processed_suggestions=[  # pyright: ignore[reportCallIssue]
-            response_models.ProcessedSuggestion(  # pyright: ignore[reportCallIssue]
-                condition_name=response_models.ConditionName(condition.condition_name),  # pyright: ignore[reportCallIssue]
+            eligibility.ProcessedSuggestion(  # pyright: ignore[reportCallIssue]
+                condition_name=eligibility.ConditionName(condition.condition_name),  # pyright: ignore[reportCallIssue]
                 status=STATUS_MAPPING[condition.status],
-                status_text=response_models.StatusText(f"{condition.status}"),  # pyright: ignore[reportCallIssue]
+                status_text=eligibility.StatusText(f"{condition.status}"),  # pyright: ignore[reportCallIssue]
                 eligibility_cohorts=[],  # pyright: ignore[reportCallIssue]
                 suitability_rules=[  # pyright: ignore[reportCallIssue]
-                    response_models.SuitabilityRule(  # pyright: ignore[reportCallIssue]
-                        type=response_models.RuleType(reason.rule_type.value),  # pyright: ignore[reportCallIssue]
-                        rule_code=response_models.RuleCode(reason.rule_name),  # pyright: ignore[reportCallIssue]
-                        rule_text=response_models.RuleText(reason.rule_result),  # pyright: ignore[reportCallIssue]
+                    eligibility.SuitabilityRule(  # pyright: ignore[reportCallIssue]
+                        type=eligibility.RuleType(reason.rule_type.value),  # pyright: ignore[reportCallIssue]
+                        rule_code=eligibility.RuleCode(reason.rule_name),  # pyright: ignore[reportCallIssue]
+                        rule_text=eligibility.RuleText(reason.rule_result),  # pyright: ignore[reportCallIssue]
                     )
                     for reason in condition.reasons
                 ],  # pyright: ignore[reportCallIssue]