Attempt single query for service and opening times

Author: mabe13

application/common/dos.py

@@ -264,6 +264,29 @@ def db_rows_to_spec_open_times(db_rows: Iterable[dict]) -> list[SpecifiedOpening
     return specified_opening_times
 
 
+def db_big_rows_to_spec_open_times(db_rows: Iterable[dict]) -> list[SpecifiedOpeningTime]:
+    """Turns a set of dos database rows into a list of SpecifiedOpenTime objects.
+
+    note: The rows must to be for the same service.
+    """
+    specified_opening_times = []
+    date_sorted_rows = sorted(db_rows, key=lambda row: (row["date"], row["starttime"]))
+    for date, db_rows in groupby(date_sorted_rows, lambda row: row["date"]):
+        is_open = True
+        open_periods = []
+        specified_op_times_ids = []
+        for row in list(db_rows):
+            if row["ssot_id"] is not None and row["ssot_id"] not in specified_op_times_ids:
+                specified_op_times_ids.append = row["ssot_id"]
+                if row["isclosed"] is True:
+                    is_open = False
+                else:
+                    open_periods.append(OpenPeriod(row["starttime"], row["endtime"]))
+        specified_opening_times.append(SpecifiedOpeningTime(open_periods, date, is_open))
+
+    return specified_opening_times
+
+
 def db_rows_to_std_open_times(db_rows: Iterable[dict]) -> StandardOpeningTimes:
     """Turns a set of dos database rows into a StandardOpeningTime object.
 
@@ -279,6 +302,24 @@ def db_rows_to_std_open_times(db_rows: Iterable[dict]) -> StandardOpeningTimes:
     return standard_opening_times
 
 
+def db_big_rows_to_std_open_times(db_rows: Iterable[dict]) -> StandardOpeningTimes:
+    """Turns a set of dos database rows into a StandardOpeningTime object.
+
+    note: The rows must be for the same service.
+    """
+    standard_opening_times = StandardOpeningTimes()
+    std_op_times_ids = []
+    for row in db_rows:
+        if row["sdot_id"] is not None and row["sdot_id"] not in std_op_times_ids:
+            std_op_times_ids.append = row["sdot_id"]
+            weekday = row["name"].lower()
+            start = row["day_starttime"]
+            end = row["day_endtime"]
+            open_period = OpenPeriod(start, end)
+            standard_opening_times.add_open_period(open_period, weekday)
+    return standard_opening_times
+
+
 def has_palliative_care(service: DoSService, connection: Connection) -> bool:
     """Checks if a service has palliative care.
 

application/service_sync/data_processing/get_data.py

@@ -4,6 +4,8 @@
 from .service_histories import ServiceHistories
 from common.dos import (
     DoSService,
+    db_big_rows_to_spec_open_times,
+    db_big_rows_to_std_open_times,
     get_specified_opening_times_from_db,
     get_standard_opening_times_from_db,
     has_blood_pressure,
@@ -67,3 +69,60 @@ def get_dos_service_and_history(service_id: int) -> tuple[DoSService, ServiceHis
         service_histories.create_service_histories_entry()
         # Connection closed by context manager
     return service, service_histories
+
+
+def get_dos_service_and_history_one_query(service_id: int) -> tuple[DoSService, ServiceHistories]:
+    """Retrieves DoS Services from DoS database.
+
+    Args:
+        service_id (str): Id of service to retrieve
+
+    Returns:
+        Tuple[DoSService, ServiceHistories]: Tuple of DoS service and service history
+
+    """
+    sql_query = (
+        "SELECT s.id, uid, s.name, odscode, address, town, postcode, web, typeid, statusid, ss.name status_name, "
+        "publicphone, publicname, st.name service_type_name, easting, northing, latitude, longitude, "
+        'sdo.id as "sdo_id", sdo.dayid, otd.name, sdot.id as "sdot_id", sdot.starttime as "day_starttime", '
+        'sdot.endtime as "day_endtime", ssod.id as "ssod_id", ssod.date, ssot.id as "ssot_id", '
+        "ssot.starttime, ssot.endtime, ssot.isclosed "
+        "FROM services s "
+        "INNER JOIN servicetypes st ON s.typeid = st.id INNER JOIN servicestatuses ss on s.statusid = ss.id "
+        "LEFT JOIN servicedayopenings sdo ON s.id = sdo.serviceid "
+        "LEFT JOIN openingtimedays otd ON sdo.dayid = otd.id "
+        "LEFT JOIN servicedayopeningtimes sdot ON sdo.id = sdot.servicedayopeningid "
+        "LEFT JOIN servicespecifiedopeningdates ssod ON s.id = ssod.serviceid "
+        "LEFT JOIN servicespecifiedopeningtimes ssot ON ssod.id = ssot.servicespecifiedopeningdateid "
+        "WHERE s.id = %(SERVICE_ID)s"
+    )
+    query_vars = {"SERVICE_ID": service_id}
+    # Connect to the DoS database
+    with connect_to_db_writer() as connection:
+        # Query the DoS database for the service
+        cursor = query_dos_db(connection=connection, query=sql_query, query_vars=query_vars)
+        rows: DictRow = cursor.fetchall()
+        if len(rows) == 1:
+            # Select first row (service) and create DoSService object
+            service = DoSService(rows[0])
+            logger.append_keys(service_name=service.name)
+            logger.append_keys(service_uid=service.uid)
+            logger.append_keys(type_id=service.typeid)
+        elif not rows:
+            msg = f"Service ID {service_id} not found"
+            raise ValueError(msg)
+        # Set up remaining service data
+        service.standard_opening_times = db_big_rows_to_std_open_times(rows)
+        service.specified_opening_times = db_big_rows_to_spec_open_times(rows)
+        # Set up palliative care flag
+        service.palliative_care = has_palliative_care(service=service, connection=connection)
+        # Set up blood pressure flag
+        service.blood_pressure = has_blood_pressure(service=service)
+        # Set up contraception flag
+        service.contraception = has_contraception(service=service)
+        # Set up service history
+        service_histories = ServiceHistories(service_id=service_id)
+        service_histories.get_service_history_from_db(connection)
+        service_histories.create_service_histories_entry()
+        # Connection closed by context manager
+    return service, service_histories