Added logic to check and correct for duplicate records. (#55)

Adjusted existing compartment tests to use this logic

<!-- markdownlint-disable-next-line first-line-heading -->
## Description

<!-- Describe your changes in detail. -->
Made C5 only select distinct NHS Numbers when obtaining test data

## Context

<!-- Why is this change required? What problem does it solve? -->
Fixed an issue in compartment 5 where it wold fail due to obtaining
duplicate results.

## Type of changes

<!-- What types of changes does your code introduce? Put an `x` in all
the boxes that apply. -->

- [x] Refactoring (non-breaking change)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would change existing
functionality)
- [ ] Bug fix (non-breaking change which fixes an issue)

## Checklist

<!-- Go over all the following points, and put an `x` in all the boxes
that apply. -->

- [x] I am familiar with the [contributing
guidelines](https://github.com/nhs-england-tools/playwright-python-blueprint/blob/main/CONTRIBUTING.md)
- [x] I have followed the code style of the project
- [x] I have added tests to cover my changes (where appropriate)
- [ ] I have updated the documentation accordingly
- [ ] This PR is a result of pair or mob programming

---

## Sensitive Information Declaration

To ensure the utmost confidentiality and protect your and others
privacy, we kindly ask you to NOT including [PII (Personal Identifiable
Information) / PID (Personal Identifiable
Data)](https://digital.nhs.uk/data-and-information/keeping-data-safe-and-benefitting-the-public)
or any other sensitive data in this PR (Pull Request) and the codebase
changes. We will remove any PR that do contain any sensitive
information. We really appreciate your cooperation in this matter.

- [x] I confirm that neither PII/PID nor sensitive data are included in
this PR and the codebase changes.

Author: adrianoaru-nhs

utils/oracle/oracle.py

@@ -29,7 +29,7 @@ def connect_to_db(self) -> oracledb.Connection:
             return conn
         except Exception as queryExecutionError:
             logging.error(
-                f"Failed to to extract subject ID with error: {queryExecutionError}"
+                f"Failed to extract subject ID with error: {queryExecutionError}"
             )
 
     def disconnect_from_db(self, conn: oracledb.Connection) -> None:
@@ -147,15 +147,15 @@ def delete_all_users_from_approved_users_table(
                 self.disconnect_from_db(conn)
 
     def execute_query(
-        self, query: str, parameters: list | None = None
+        self, query: str, parameters: dict | None = None
     ) -> pd.DataFrame:  # To use when "select xxxx" (stored procedures)
         """
         This is used to execute any sql queries.
         A query is provided and then the result is returned as a pandas dataframe
 
         Args:
             query (str): The SQL query you wish to run
-            parameters (list | None): Optional - Any parameters you want to pass on in a list
+            parameters (dict | None): Optional - Any parameters you want to pass on in a dictionary
 
         Returns:
             df (pd.DataFrame): A pandas dataframe of the result of the query

utils/oracle/oracle_specific_functions.py

@@ -29,21 +29,30 @@ def get_kit_id_from_db(
         kit_id_df (pd.DataFrame): A pandas DataFrame containing the result of the query
     """
     logging.info("Retrieving useable test kit ids")
-    kit_id_df = OracleDB().execute_query(
-        f"""select tk.kitid, tk.screening_subject_id, sst.subject_nhs_number
+    query = """select tk.kitid, tk.screening_subject_id, sst.subject_nhs_number
     from tk_items_t tk
     inner join ep_subject_episode_t se on se.screening_subject_id = tk.screening_subject_id
     inner join screening_subject_t sst on (sst.screening_subject_id = tk.screening_subject_id)
     inner join sd_contact_t sdc on (sdc.nhs_number = sst.subject_nhs_number)
-    where tk.tk_type_id = {tk_type_id}
+    where tk.tk_type_id = :tk_type_id
     and tk.logged_in_flag = 'N'
-    and sdc.hub_id = {hub_id}
+    and sdc.hub_id = :hub_id
     and device_id is null
     and tk.invalidated_date is null
-    and se.latest_event_status_id in ({SqlQueryValues.S10_EVENT_STATUS}, {SqlQueryValues.S19_EVENT_STATUS})
+    and se.latest_event_status_id in (:s10_event_status, :s19_event_status)
     order by tk.kitid DESC
-    fetch first {no_of_kits_to_retrieve} rows only"""
-    )
+    fetch first :subjects_to_retrieve rows only"""
+
+    params = {
+        "s10_event_status": SqlQueryValues.S10_EVENT_STATUS,
+        "s19_event_status": SqlQueryValues.S19_EVENT_STATUS,
+        "tk_type_id": tk_type_id,
+        "hub_id": hub_id,
+        "subjects_to_retrieve": no_of_kits_to_retrieve,
+    }
+
+    kit_id_df = OracleDB().execute_query(query, params)
+
     return kit_id_df
 
 
@@ -83,22 +92,29 @@ def get_kit_id_logged_from_db(smokescreen_properties: dict) -> pd.DataFrame:
     Returns:
         return kit_id_df (pd.DataFrame): A pandas DataFrame containing the result of the query
     """
-    kit_id_df = OracleDB().execute_query(
-        f"""SELECT tk.kitid,tk.device_id,tk.screening_subject_id
+    query = """SELECT tk.kitid,tk.device_id,tk.screening_subject_id
     FROM tk_items_t tk
     INNER JOIN kit_queue kq ON kq.device_id = tk.device_id
     INNER JOIN ep_subject_episode_t se ON se.screening_subject_id = tk.screening_subject_id
     WHERE tk.logged_in_flag = 'Y'
     AND kq.test_kit_status IN ('LOGGED', 'POSTED')
-    AND se.episode_status_id = {SqlQueryValues.OPEN_EPISODE_STATUS_ID}
+    AND se.episode_status_id = :open_episode_status_id
     AND tk.tk_type_id = 2
-    AND se.latest_event_status_id = {SqlQueryValues.S43_EVENT_STATUS}
-    AND tk.logged_in_at = {smokescreen_properties["c3_fit_kit_results_test_org_id"]}
+    AND se.latest_event_status_id = :s43_event_status
+    AND tk.logged_in_at = :logged_in_at
     AND tk.reading_flag = 'N'
     AND tk.test_results IS NULL
-    fetch first {smokescreen_properties["c3_total_fit_kits_to_retrieve"]} rows only
+    fetch first :subjects_to_retrieve rows only
     """
-    )
+
+    params = {
+        "s43_event_status": SqlQueryValues.S43_EVENT_STATUS,
+        "logged_in_at": smokescreen_properties["c3_fit_kit_results_test_org_id"],
+        "open_episode_status_id": SqlQueryValues.OPEN_EPISODE_STATUS_ID,
+        "subjects_to_retrieve": smokescreen_properties["c3_total_fit_kits_to_retrieve"],
+    }
+
+    kit_id_df = OracleDB().execute_query(query, params)
 
     return kit_id_df
 
@@ -263,25 +279,31 @@ def get_subjects_for_appointments(subjects_to_retrieve: int) -> pd.DataFrame:
     Returns:
         subjects_df (pd.DataFrame): A pandas DataFrame containing the result of the query
     """
-    subjects_df = OracleDB().execute_query(
-        f"""
-    select tk.kitid, ss.subject_nhs_number, se.screening_subject_id
+
+    query = """select tk.kitid, ss.subject_nhs_number, se.screening_subject_id
     from tk_items_t tk
     inner join ep_subject_episode_t se on se.screening_subject_id = tk.screening_subject_id
     inner join screening_subject_t ss on ss.screening_subject_id = se.screening_subject_id
     inner join sd_contact_t c on c.nhs_number = ss.subject_nhs_number
-    where se.latest_event_status_id = {SqlQueryValues.A8_EVENT_STATUS}
+    where se.latest_event_status_id = :a8_event_status
     and tk.logged_in_flag = 'Y'
-    and se.episode_status_id = {SqlQueryValues.OPEN_EPISODE_STATUS_ID}
+    and se.episode_status_id = :open_episode_status_id
     and ss.screening_status_id != 4008
     and tk.logged_in_at = 23159
     and c.hub_id = 23159
     and tk.tk_type_id = 2
     and tk.datestamp > add_months(sysdate,-24)
     order by ss.subject_nhs_number desc
-    fetch first {subjects_to_retrieve} rows only
+    fetch first :subjects_to_retrieve rows only
     """
-    )
+    params = {
+        "a8_event_status": SqlQueryValues.A8_EVENT_STATUS,
+        "open_episode_status_id": SqlQueryValues.OPEN_EPISODE_STATUS_ID,
+        "subjects_to_retrieve": subjects_to_retrieve,
+    }
+
+    subjects_df = OracleDB().execute_query(query, params)
+
     return subjects_df
 
 
@@ -297,9 +319,8 @@ def get_subjects_with_booked_appointments(subjects_to_retrieve: int) -> pd.DataF
     Returns:
         subjects_df (pd.DataFrame): A pandas DataFrame containing the result of the query
     """
-    subjects_df = OracleDB().execute_query(
-        f"""
-    select a.appointment_date, s.subject_nhs_number, c.person_family_name, c.person_given_name
+
+    query = """select distinct(s.subject_nhs_number), a.appointment_date, c.person_family_name, c.person_given_name
     from
     (select count(*), ds.screening_subject_id
     from
@@ -318,10 +339,11 @@ def get_subjects_with_booked_appointments(subjects_to_retrieve: int) -> pd.DataF
     inner join screening_subject_t s on s.screening_subject_id = se.screening_subject_id
     inner join sd_contact_t c on c.nhs_number = s.subject_nhs_number
     inner join appointment_t a on se.subject_epis_id = a.subject_epis_id
-    where se.latest_event_status_id = {SqlQueryValues.POSITIVE_APPOINTMENT_BOOKED}
+    where se.latest_event_status_id = :positive_appointment_booked
     and tk.logged_in_flag = 'Y'
-    and se.episode_status_id = {SqlQueryValues.OPEN_EPISODE_STATUS_ID}
+    and se.episode_status_id = :open_episode_status_id
     and tk.logged_in_at = 23159
+    and tk.algorithm_sc_id = 23162
     --and a.appointment_date > sysdate-27
     and a.cancel_date is null
     and a.attend_info_id is null and a.attend_date is null
@@ -330,7 +352,15 @@ def get_subjects_with_booked_appointments(subjects_to_retrieve: int) -> pd.DataF
     and tk.tk_type_id = 2
     --and tk.datestamp > add_months(sysdate,-24)
     order by a.appointment_date desc
-    fetch first {subjects_to_retrieve} rows only
+    fetch first :subjects_to_retrieve rows only
     """
-    )
+
+    params = {
+        "positive_appointment_booked": SqlQueryValues.POSITIVE_APPOINTMENT_BOOKED,
+        "open_episode_status_id": SqlQueryValues.OPEN_EPISODE_STATUS_ID,
+        "subjects_to_retrieve": subjects_to_retrieve,
+    }
+
+    subjects_df = OracleDB().execute_query(query, params)
+
     return subjects_df