[PRM-442] ITOC feedback -> IM (Slack/Teams) (#747)

Author: steph-torres-nhs

.github/workflows/base-lambdas-reusable-deploy-all.yml

@@ -316,7 +316,7 @@ jobs:
       sandbox: ${{ inputs.sandbox }}
       lambda_handler_name: send_feedback_handler
       lambda_aws_name: SendFeedbackLambda
-      lambda_layer_names: 'core_lambda_layer'
+      lambda_layer_names: 'core_lambda_layer,alerting_lambda_layer'
     secrets:
       AWS_ASSUME_ROLE: ${{ secrets.AWS_ASSUME_ROLE }}
 

lambdas/enums/lambda_error.py

@@ -302,6 +302,7 @@ def create_error_body(self, params: Optional[dict] = None, **kwargs) -> str:
         "message": "Failed to fetch parameters for sending email from SSM param store",
     }
 
+
     """
        Errors for Feature Flags lambda 
     """

lambdas/enums/message_templates.py

@@ -0,0 +1,6 @@
+from enum import StrEnum
+
+
+class MessageTemplates(StrEnum):
+    ITOC_FEEDBACK_TEST_SLACK = "./models/templates/itoc_slack_feedback_blocks.json"
+    ITOC_FEEDBACK_TEST_TEAMS = "./models/templates/itoc_feedback_teams_message.json"

lambdas/handlers/send_feedback_handler.py

@@ -1,26 +1,46 @@
+import os
+
 from enums.lambda_error import LambdaError
 from enums.logging_app_interaction import LoggingAppInteraction
+from models.feedback_model import Feedback
+from pydantic import ValidationError
 from services.send_feedback_service import SendFeedbackService
+from services.send_test_feedback_service import SendTestFeedbackService
 from utils.audit_logging_setup import LoggingService
 from utils.decorators.ensure_env_var import ensure_environment_variables
 from utils.decorators.handle_lambda_exceptions import handle_lambda_exceptions
 from utils.decorators.override_error_check import override_error_check
 from utils.decorators.set_audit_arg import set_request_context_for_logging
+from utils.exceptions import OdsErrorException
 from utils.lambda_exceptions import SendFeedbackException
 from utils.lambda_response import ApiGatewayResponse
 from utils.request_context import request_context
 
 logger = LoggingService(__name__)
+failure_msg = "Failed to send feedback by email"
 
 
 @set_request_context_for_logging
 @override_error_check
 @ensure_environment_variables(
-    ["FROM_EMAIL_ADDRESS", "EMAIL_SUBJECT", "EMAIL_RECIPIENT_SSM_PARAM_KEY"]
+    [
+        "FROM_EMAIL_ADDRESS",
+        "EMAIL_SUBJECT",
+        "EMAIL_RECIPIENT_SSM_PARAM_KEY",
+        "ITOC_TESTING_SLACK_BOT_TOKEN",
+        "ITOC_TESTING_CHANNEL_ID",
+        "ITOC_TESTING_TEAMS_WEBHOOK",
+        "ITOC_TESTING_ODS_CODES",
+    ]
 )
 @handle_lambda_exceptions
 def lambda_handler(event, context):
     request_context.app_interaction = LoggingAppInteraction.SEND_FEEDBACK.value
+    ods_code = request_context.authorization.get("selected_organisation", {}).get(
+        "org_ods_code"
+    )
+    if not ods_code:
+        raise OdsErrorException("No ODS code provided")
 
     logger.info("Send feedback handler triggered")
 
@@ -32,14 +52,40 @@ def lambda_handler(event, context):
         )
         raise SendFeedbackException(400, LambdaError.FeedbackMissingBody)
 
+    logger.info("Parsing feedback content...")
+    try:
+        feedback = Feedback.model_validate_json(event_body)
+
+    except ValidationError as e:
+        logger.error(e)
+        logger.error(
+            LambdaError.FeedbackInvalidBody.to_str(),
+            {"result": failure_msg},
+        )
+        raise SendFeedbackException(400, LambdaError.FeedbackInvalidBody)
+
     logger.info("Setting up SendFeedbackService...")
-    feedback_service = SendFeedbackService()
 
+    feedback_service = SendFeedbackService()
     logger.info("SendFeedbackService ready, start processing feedback")
-    feedback_service.process_feedback(event_body)
 
+    feedback_service.process_feedback(feedback)
     logger.info("Process complete", {"Result": "Successfully sent feedback by email"})
 
+    if is_itoc_test_feedback(ods_code):
+        logger.info("Setting up SendTestFeedbackService")
+
+        test_feedback_service = SendTestFeedbackService()
+        test_feedback_service.process_feedback(feedback)
+
+
+
     return ApiGatewayResponse(
         200, "Feedback email processed", "POST"
     ).create_api_gateway_response()
+
+
+def is_itoc_test_feedback(ods_code: str) -> bool:
+    ods_codes = os.environ["ITOC_TESTING_ODS_CODES"].split(",")
+    return ods_code in ods_codes
+

lambdas/models/templates/itoc_feedback_teams_message.json

@@ -0,0 +1,37 @@
+{
+    "type": "message",
+    "attachments": [
+        {
+            "contentType": "application/vnd.microsoft.card.adaptive",
+            "contentUrl": null,
+            "content": {
+                "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
+                "type": "AdaptiveCard",
+                "version": "1.4",
+                "body": [
+                    {
+                        "type": "TextBlock",
+                        "size": "Medium",
+                        "weight": "Bolder",
+                        "text": "ITOC Testing",
+                        "wrap": true
+                    },
+                    {
+                        "type": "TextBlock",
+                        "text": "Name: {{ name }}"
+                    },
+                    {
+                        "type": "TextBlock",
+                        "text": "Overall experience: {{ experience }}",
+                        "wrap": true
+                    },
+                    {
+                        "type": "TextBlock",
+                        "text": "Feedback: {{ feedback }}",
+                        "wrap": true
+                    }
+                ]
+            }
+        }
+    ]
+}

lambdas/models/templates/itoc_slack_feedback_blocks.json

@@ -0,0 +1,33 @@
+[
+    {
+        "type": "header",
+        "text": {
+            "type": "plain_text",
+            "text": "ITOC Testing"
+        }
+    },
+    {
+        "type": "divider"
+    },
+    {
+        "type": "section",
+        "text": {
+            "type": "plain_text",
+            "text": "Name: {{ name }}"
+        }
+    },
+    {
+        "type": "section",
+        "text": {
+            "type": "plain_text",
+            "text": "Overall Experience: {{ experience }}"
+        }
+    },
+    {
+        "type": "section",
+        "text": {
+            "type": "plain_text",
+            "text": "Feedback: {{ feedback }}"
+        }
+    }
+]

lambdas/requirements/layers/requirements_core_lambda_layer.txt

@@ -4,13 +4,13 @@ boto3==1.34.128
 botocore==1.34.128
 charset-normalizer==3.2.0
 cryptography==44.0.1
-email-validator==2.1.0.post1
 idna==3.7
 inflection==0.5.1
 jmespath==1.0.1
 oauthlib==3.2.2
 packaging==23.0.0
 pydantic==2.11
+pydantic[email]==2.11
 pypdf==6.0.0
 requests==2.32.4
 responses==0.23.1

lambdas/services/send_feedback_service.py

@@ -5,7 +5,6 @@
 from botocore.exceptions import ClientError
 from enums.lambda_error import LambdaError
 from models.feedback_model import Feedback
-from pydantic import ValidationError
 from services.base.ssm_service import SSMService
 from utils.audit_logging_setup import LoggingService
 from utils.lambda_exceptions import SendFeedbackException
@@ -21,18 +20,7 @@ def __init__(self):
         self.email_subject: str = os.environ["EMAIL_SUBJECT"]
         self.recipient_email_list: list[str] = self.get_email_recipients_list()
 
-    def process_feedback(self, body: str):
-        logger.info("Parsing feedback content...")
-        try:
-            feedback = Feedback.model_validate_json(body)
-        except ValidationError as e:
-            logger.error(e)
-            logger.error(
-                LambdaError.FeedbackInvalidBody.to_str(),
-                {"Result": failure_msg},
-            )
-            raise SendFeedbackException(400, LambdaError.FeedbackInvalidBody)
-
+    def process_feedback(self, feedback: Feedback):
         email_body_html = self.build_email_body(feedback)
         self.send_feedback_by_email(email_body_html)
 

lambdas/services/send_test_feedback_service.py

@@ -0,0 +1,76 @@
+import json
+import os
+
+import requests
+from enums.message_templates import MessageTemplates
+from enums.supported_document_types import logger
+from jinja2 import Template
+from models.feedback_model import Feedback
+from requests.exceptions import HTTPError
+
+
+class SendTestFeedbackService:
+
+    def process_feedback(self, feedback: Feedback):
+        self.send_itoc_feedback_via_slack(feedback)
+        self.send_itoc_feedback_via_teams(feedback)
+
+
+    def send_itoc_feedback_via_slack(self, feedback: Feedback):
+        logger.info("Sending ITOC test feedback via slack")
+        headers = {
+            "Content-type": "application/json; charset=utf-8",
+            "Authorization": "Bearer " + os.environ["ITOC_TESTING_SLACK_BOT_TOKEN"],
+        }
+
+        body = {
+            "blocks": self.compose_message(
+                feedback, MessageTemplates.ITOC_FEEDBACK_TEST_SLACK
+            ),
+            "channel": os.environ["ITOC_TESTING_CHANNEL_ID"],
+        }
+        try:
+            response = requests.post(
+                url="https://slack.com/api/chat.postMessage", json=body, headers=headers
+            )
+            response.raise_for_status()
+            logger.info("Successfully sent ITOC test feedback via slack.")
+        except HTTPError as e:
+            logger.error(e)
+            logger.error("Failed to send ITOC test feedback via slack.")
+
+    def send_itoc_feedback_via_teams(self, feedback: Feedback):
+        logger.info("Sending ITOC test feedback via teams")
+        try:
+            payload = self.compose_message(
+                feedback, MessageTemplates.ITOC_FEEDBACK_TEST_TEAMS
+            )
+
+            headers = {"Content-type": "application/json"}
+
+            response = requests.post(
+                url=os.environ["ITOC_TESTING_TEAMS_WEBHOOK"],
+                headers=headers,
+                json=payload,
+            )
+            response.raise_for_status()
+            logger.info("ITOC test feedback successfully sent via teams.")
+        except HTTPError as e:
+            logger.error(e)
+            logger.error("ITOC test feedback failed via teams.")
+
+    def compose_message(self, feedback: Feedback, messaging_template: str):
+        logger.info("Composing ITOC test feedback message...")
+        with open(messaging_template, "r") as f:
+            template_content = f.read()
+
+        template = Template(template_content)
+
+        context = {
+            "name": feedback.respondent_name,
+            "experience": feedback.experience,
+            "feedback": feedback.feedback_content,
+        }
+
+        rendered_json = template.render(context)
+        return json.loads(rendered_json)

lambdas/tests/unit/conftest.py

@@ -121,6 +121,11 @@
 
 TEST_BASE_DIRECTORY = os.path.dirname(os.path.abspath(__file__))
 
+
+MOCK_ITOC_ODS_CODES = "Y12345,Y12"
+MOCK_ITOC_SLACK_CHANNEL_ID = "slack_channel_id"
+MOCK_ITOC_TEST_EMAIL_ADDRESS = "[email protected]"
+MOCK_ITOC_TEAMS_WEBHOOK = "https://webhook.team"
 MOCK_CONFLUENCE_URL = "https://confluence.example.com"
 MOCK_ALARM_HISTORY_TABLE = "test_alarm_history_table"
 MOCK_TEAMS_WEBHOOK = "test_teams_webhook"
@@ -203,11 +208,16 @@ def set_env(monkeypatch):
         "DOCUMENT_RETRIEVE_ENDPOINT_APIM", f"{APIM_API_URL}/DocumentReference"
     )
     monkeypatch.setenv("VIRUS_SCAN_STUB", "True")
+    monkeypatch.setenv("ITOC_TESTING_SLACK_BOT_TOKEN", MOCK_SLACK_BOT_TOKEN)
+    monkeypatch.setenv("ITOC_TESTING_CHANNEL_ID", MOCK_ITOC_SLACK_CHANNEL_ID)
+    monkeypatch.setenv("ITOC_TESTING_EMAIL_ADDRESS", MOCK_ITOC_TEST_EMAIL_ADDRESS)
+    monkeypatch.setenv("ITOC_TESTING_TEAMS_WEBHOOK", MOCK_ITOC_TEAMS_WEBHOOK)
     monkeypatch.setenv("CONFLUENCE_BASE_URL", MOCK_CONFLUENCE_URL)
     monkeypatch.setenv("ALARM_HISTORY_DYNAMODB_NAME", MOCK_ALARM_HISTORY_TABLE)
     monkeypatch.setenv("TEAMS_WEBHOOK_URL", MOCK_TEAMS_WEBHOOK)
     monkeypatch.setenv("SLACK_BOT_TOKEN", MOCK_SLACK_BOT_TOKEN)
     monkeypatch.setenv("SLACK_CHANNEL_ID", MOCK_ALERTING_SLACK_CHANNEL_ID)
+    monkeypatch.setenv("ITOC_TESTING_ODS_CODES", MOCK_ITOC_ODS_CODES)
 
 
 EXPECTED_PARSED_PATIENT_BASE_CASE = PatientDetails(
@@ -350,3 +360,9 @@ def expect_not_to_raise(exception, message_when_fail=""):
     except exception:
         message_when_fail = message_when_fail or "DID RAISE {0}".format(exception)
         raise pytest.fail(message_when_fail)
+
+
+@pytest.fixture
+def mock_jwt_encode(mocker):
+    decoded_token = {"selected_organisation": {"org_ods_code": "ODS123"}}
+    yield mocker.patch("jwt.decode", return_value=decoded_token)