Use John's response schema rather than FHIR.

Author: acerathereinspirative-nhs-nvir

src/eligibility_signposting_api/model/eligibility.py

@@ -1,14 +1,25 @@
+from dataclasses import dataclass
 from datetime import date
+from enum import Enum, auto
 from typing import NewType
 
-from pydantic import BaseModel
-
 NHSNumber = NewType("NHSNumber", str)
 DateOfBirth = NewType("DateOfBirth", date)
 Postcode = NewType("Postcode", str)
 
 
-class EligibilityStatus(BaseModel):
-    eligible: bool
-    reasons: list[dict]
-    actions: list[dict]
+class Status(Enum):
+    not_eligible = auto()
+    not_actionable = auto()
+    actionable = auto()
+
+
+@dataclass
+class Condition:
+    condition: str
+    status: Status
+
+
+@dataclass
+class EligibilityStatus:
+    conditions: list[Condition]

src/eligibility_signposting_api/services/eligibility_services.py

@@ -5,7 +5,7 @@
 from dateutil.relativedelta import relativedelta
 from wireup import service
 
-from eligibility_signposting_api.model.eligibility import EligibilityStatus, NHSNumber
+from eligibility_signposting_api.model.eligibility import Condition, EligibilityStatus, NHSNumber, Status
 from eligibility_signposting_api.model.rules import CampaignConfig, IterationRule, RuleAttributeLevel, RuleOperator
 from eligibility_signposting_api.repos import EligibilityRepo, NotFoundError, RulesRepo
 
@@ -49,17 +49,20 @@ def get_eligibility_status(self, nhs_number: NHSNumber | None = None) -> Eligibi
     def evaluate_eligibility(
         campaign_configs: list[CampaignConfig], person_data: list[dict[str, Any]]
     ) -> EligibilityStatus:
-        eligible, reasons, actions = True, [], []
-        for iteration_rule in [
-            iteration_rule
-            for campaign_config in campaign_configs
-            for iteration in campaign_config.iterations
-            for iteration_rule in iteration.iteration_rules
-        ]:
-            if EligibilityService.evaluate_exclusion(iteration_rule, person_data):
-                eligible = False
+        conditions: dict[str, Condition] = {}
+        for campaign_config in campaign_configs:
+            for iteration_rule in [
+                iteration_rule
+                for iteration in campaign_config.iterations
+                for iteration_rule in iteration.iteration_rules
+            ]:
+                condition = conditions.setdefault(
+                    campaign_config.target, Condition(condition=campaign_config.target, status=Status.actionable)
+                )
+                if EligibilityService.evaluate_exclusion(iteration_rule, person_data):
+                    condition.status = Status.not_actionable
 
-        return EligibilityStatus(eligible=eligible, reasons=reasons, actions=actions)
+        return EligibilityStatus(conditions=list(conditions.values()))
 
     @staticmethod
     def evaluate_exclusion(iteration_rule: IterationRule, person_data: list[dict[str, Any]]) -> bool:

src/eligibility_signposting_api/views/eligibility.py

@@ -1,18 +1,21 @@
 import logging
 from http import HTTPStatus
 
-from fhir.resources.R4B.bundle import Bundle, BundleEntry
-from fhir.resources.R4B.guidanceresponse import GuidanceResponse
-from fhir.resources.R4B.location import Location
 from fhir.resources.R4B.operationoutcome import OperationOutcome, OperationOutcomeIssue
-from fhir.resources.R4B.requestgroup import RequestGroup
-from fhir.resources.R4B.task import Task
 from flask import Blueprint, make_response, request
 from flask.typing import ResponseReturnValue
 from wireup import Injected
 
-from eligibility_signposting_api.model.eligibility import EligibilityStatus, NHSNumber
+from eligibility_signposting_api.model.eligibility import EligibilityStatus, NHSNumber, Status
 from eligibility_signposting_api.services import EligibilityService, UnknownPersonError
+from eligibility_signposting_api.views.response_models import EligibilityResponse, ProcessedSuggestion
+from eligibility_signposting_api.views.response_models import Status as ResponseStatus
+
+STATUS_MAPPING = {
+    Status.actionable: ResponseStatus.actionable,
+    Status.not_actionable: ResponseStatus.not_actionable,
+    Status.not_eligible: ResponseStatus.not_eligible,
+}
 
 logger = logging.getLogger(__name__)
 
@@ -38,20 +41,21 @@ def check_eligibility(eligibility_service: Injected[EligibilityService]) -> Resp
         )
         return make_response(problem.model_dump(by_alias=True), HTTPStatus.NOT_FOUND)
     else:
-        bundle = build_bundle(eligibility_status)
-        return make_response(bundle.model_dump(by_alias=True), HTTPStatus.OK)
-
-
-def build_bundle(_eligibility_status: EligibilityStatus) -> Bundle:
-    return Bundle(  # pyright: ignore[reportCallIssue]
-        id="dummy-bundle",
-        type="collection",
-        entry=[
-            BundleEntry(  # pyright: ignore[reportCallIssue]
-                resource=GuidanceResponse(id="dummy-guidance-response", status="requested", moduleCodeableConcept={})  # pyright: ignore[reportCallIssue]
-            ),
-            BundleEntry(resource=RequestGroup(id="dummy-request-group", intent="proposal", status="requested")),  # pyright: ignore[reportCallIssue]
-            BundleEntry(resource=Task(id="dummy-task", intent="proposal", status="requested")),  # pyright: ignore[reportCallIssue]
-            BundleEntry(resource=Location(id="dummy-location")),  # pyright: ignore[reportCallIssue]
-        ],
+        eligibility_response = build_eligibility_response(eligibility_status)
+        return make_response(eligibility_response.model_dump(by_alias=True), HTTPStatus.OK)
+
+
+def build_eligibility_response(eligibility_status: EligibilityStatus) -> EligibilityResponse:
+    return EligibilityResponse(  # pyright: ignore[reportCallIssue]
+        processed_suggestions=[  # pyright: ignore[reportCallIssue]
+            ProcessedSuggestion(  # pyright: ignore[reportCallIssue]
+                condition=condition.condition,
+                status=STATUS_MAPPING[condition.status],
+                status_text=f"{condition.status}",  # pyright: ignore[reportCallIssue]
+                eligibility_cohorts=[],  # pyright: ignore[reportCallIssue]
+                suitability_rules=[],  # pyright: ignore[reportCallIssue]
+                actions=[],
+            )
+            for condition in eligibility_status.conditions
+        ]
     )

src/eligibility_signposting_api/views/response_models.py

@@ -0,0 +1,57 @@
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class Status(str, Enum):
+    not_eligible = "NotEligible"
+    not_actionable = "NotActionable"
+    actionable = "Actionable"
+
+
+class RuleType(str, Enum):
+    filter = "F"
+    suppression = "S"
+    redirect = "R"
+
+
+class EligibilityCohort(BaseModel):
+    cohort_code: str = Field(..., alias="cohortCode")
+    cohort_text: str = Field(..., alias="cohortText")
+    cohort_status: Status = Field(..., alias="cohortStatus")
+
+    model_config = {"populate_by_name": True}
+
+
+class SuitabilityRule(BaseModel):
+    type: RuleType = Field(..., alias="ruleType")
+    rule_code: str = Field(..., alias="ruleCode")
+    rule_text: str = Field(..., alias="ruleText")
+
+    model_config = {"populate_by_name": True}
+
+
+class Action(BaseModel):
+    action_type: str = Field(..., alias="actionType")
+    action_code: str = Field(..., alias="actionCode")
+    description: str
+    url_link: str = Field(..., alias="urlLink")
+
+    model_config = {"populate_by_name": True}
+
+
+class ProcessedSuggestion(BaseModel):
+    condition: str
+    status: Status
+    status_text: str = Field(..., alias="statusText")
+    eligibility_cohorts: list[EligibilityCohort] = Field(..., alias="eligibilityCohorts")
+    suitability_rules: list[SuitabilityRule] = Field(..., alias="suitabilityRules")
+    actions: list[Action]
+
+    model_config = {"populate_by_name": True}
+
+
+class EligibilityResponse(BaseModel):
+    processed_suggestions: list[ProcessedSuggestion] = Field(..., alias="processedSuggestions")
+
+    model_config = {"populate_by_name": True}

tests/integration/in_process/test_eligibility_endpoint.py

@@ -3,7 +3,7 @@
 from brunns.matchers.data import json_matching as is_json_that
 from brunns.matchers.werkzeug import is_werkzeug_response as is_response
 from flask.testing import FlaskClient
-from hamcrest import assert_that, has_entries
+from hamcrest import assert_that, has_entries, has_key
 
 from eligibility_signposting_api.model.eligibility import DateOfBirth, NHSNumber, Postcode
 from eligibility_signposting_api.model.rules import CampaignConfig
@@ -23,7 +23,7 @@ def test_nhs_number_given(
     # Then
     assert_that(
         response,
-        is_response().with_status_code(HTTPStatus.OK).and_text(is_json_that(has_entries(resourceType="Bundle"))),
+        is_response().with_status_code(HTTPStatus.OK).and_text(is_json_that(has_key("processedSuggestions"))),
     )
 
 

tests/integration/lambda/test_app_running_as_lambda.py

@@ -10,7 +10,7 @@
 from brunns.matchers.data import json_matching as is_json_that
 from brunns.matchers.response import is_response
 from faker import Faker
-from hamcrest import assert_that, contains_exactly, contains_string, has_entries, has_item
+from hamcrest import assert_that, contains_exactly, contains_string, has_entries, has_item, has_key
 from yarl import URL
 
 from eligibility_signposting_api.model.eligibility import DateOfBirth, NHSNumber, Postcode
@@ -57,7 +57,7 @@ def test_install_and_call_lambda_flask(
     logger.info(response_payload)
     assert_that(
         response_payload,
-        has_entries(statusCode=HTTPStatus.OK, body=is_json_that(has_entries(resourceType="Bundle"))),
+        has_entries(statusCode=HTTPStatus.OK, body=is_json_that(has_key("processedSuggestions"))),
     )
 
     assert_that(log_output, contains_string("person_data"))
@@ -78,7 +78,7 @@ def test_install_and_call_flask_lambda_over_http(
     # Then
     assert_that(
         response,
-        is_response().with_status_code(HTTPStatus.OK).and_body(is_json_that(has_entries(resourceType="Bundle"))),
+        is_response().with_status_code(HTTPStatus.OK).and_body(is_json_that(has_key("processedSuggestions"))),
     )
 
 

tests/unit/services/test_eligibility_services.py

@@ -2,17 +2,16 @@
 from unittest.mock import MagicMock
 
 import pytest
-from brunns.matchers.object import false, true
 from dateutil.relativedelta import relativedelta
 from faker import Faker
-from hamcrest import assert_that
+from hamcrest import assert_that, empty, has_item
 
-from eligibility_signposting_api.model.eligibility import DateOfBirth, NHSNumber, Postcode
+from eligibility_signposting_api.model.eligibility import DateOfBirth, NHSNumber, Postcode, Status
 from eligibility_signposting_api.model.rules import RuleAttributeLevel, RuleOperator, RuleType
 from eligibility_signposting_api.repos import EligibilityRepo, NotFoundError, RulesRepo
 from eligibility_signposting_api.services import EligibilityService, UnknownPersonError
 from tests.utils.builders import CampaignConfigFactory, IterationFactory, IterationRuleFactory
-from tests.utils.matchers.eligibility import is_eligibility_status
+from tests.utils.matchers.eligibility import is_condition, is_eligibility_status
 
 
 @pytest.fixture(scope="session")
@@ -31,7 +30,7 @@ def test_eligibility_service_returns_from_repo():
     actual = ps.get_eligibility_status(NHSNumber("1234567890"))
 
     # Then
-    assert_that(actual, is_eligibility_status().with_eligible(true()))
+    assert_that(actual, is_eligibility_status().with_conditions(empty()))
 
 
 def test_eligibility_service_for_nonexistent_nhs_number():
@@ -99,7 +98,12 @@ def test_simple_rule_eligible(faker: Faker):
     actual = ps.get_eligibility_status(NHSNumber(nhs_number))
 
     # Then
-    assert_that(actual, is_eligibility_status().with_eligible(true()))
+    assert_that(
+        actual,
+        is_eligibility_status().with_conditions(
+            has_item(is_condition().with_condition("RSV").and_status(Status.actionable))
+        ),
+    )
 
 
 def test_simple_rule_ineligible(faker: Faker):
@@ -155,7 +159,12 @@ def test_simple_rule_ineligible(faker: Faker):
     actual = ps.get_eligibility_status(NHSNumber(nhs_number))
 
     # Then
-    assert_that(actual, is_eligibility_status().with_eligible(false()))
+    assert_that(
+        actual,
+        is_eligibility_status().with_conditions(
+            has_item(is_condition().with_condition("RSV").and_status(Status.not_actionable))
+        ),
+    )
 
 
 def test_equals_rule():

tests/unit/views/test_eligibility.py

@@ -5,11 +5,12 @@
 from brunns.matchers.werkzeug import is_werkzeug_response as is_response
 from flask import Flask
 from flask.testing import FlaskClient
-from hamcrest import assert_that, contains_exactly, has_entries
+from hamcrest import assert_that, contains_exactly, has_entries, has_key
 from wireup.integration.flask import get_app_container
 
 from eligibility_signposting_api.model.eligibility import EligibilityStatus, NHSNumber
 from eligibility_signposting_api.services import EligibilityService, UnknownPersonError
+from tests.utils.builders import EligibilityStatusFactory
 
 logger = logging.getLogger(__name__)
 
@@ -19,7 +20,7 @@ def __init__(self):
         pass
 
     def get_eligibility_status(self, _: NHSNumber | None = None) -> EligibilityStatus:
-        return EligibilityStatus(eligible=True, reasons=[], actions=[])
+        return EligibilityStatusFactory.build()
 
 
 class FakeUnknownPersonEligibilityService(EligibilityService):
@@ -47,7 +48,7 @@ def test_nhs_number_given(app: Flask, client: FlaskClient):
         # Then
     assert_that(
         response,
-        is_response().with_status_code(HTTPStatus.OK).and_text(is_json_that(has_entries(resourceType="Bundle"))),
+        is_response().with_status_code(HTTPStatus.OK).and_text(is_json_that(has_key("processedSuggestions"))),
     )
 
 

tests/utils/builders.py

@@ -2,9 +2,18 @@
 import string
 
 from polyfactory import Use
+from polyfactory.factories import DataclassFactory
 from polyfactory.factories.pydantic_factory import ModelFactory
 
+from eligibility_signposting_api.model.eligibility import Condition, EligibilityStatus
 from eligibility_signposting_api.model.rules import CampaignConfig, Iteration, IterationCohort, IterationRule
+from eligibility_signposting_api.views.response_models import (
+    Action,
+    EligibilityCohort,
+    EligibilityResponse,
+    ProcessedSuggestion,
+    SuitabilityRule,
+)
 
 
 class IterationCohortFactory(ModelFactory[IterationCohort]): ...
@@ -22,5 +31,31 @@ class CampaignConfigFactory(ModelFactory[CampaignConfig]):
     iterations = Use(IterationFactory.batch, size=2)
 
 
+class EligibilityCohortFactory(ModelFactory[EligibilityCohort]): ...
+
+
+class SuitabilityRuleFactory(ModelFactory[SuitabilityRule]): ...
+
+
+class ActionFactory(ModelFactory[Action]): ...
+
+
+class ProcessedSuggestionFactory(ModelFactory[ProcessedSuggestion]):
+    eligibility_cohorts = Use(EligibilityCohortFactory.batch, size=2)
+    suitability_rules = Use(SuitabilityRuleFactory.batch, size=2)
+    actions = Use(ActionFactory.batch, size=2)
+
+
+class EligibilityResponseFactory(ModelFactory[EligibilityResponse]):
+    processed_suggestions = Use(ProcessedSuggestionFactory.batch, size=2)
+
+
+class ConditionFactory(DataclassFactory[Condition]): ...
+
+
+class EligibilityStatusFactory(DataclassFactory[EligibilityStatus]):
+    condition = Use(ConditionFactory.batch, size=2)
+
+
 def random_str(length: int) -> str:
     return "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(length))  # noqa: S311