uk_bin_collection 0.134.0__py3-none-any.whl → 0.135.2__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/BolsoverCouncil.py

@@ -0,0 +1,298 @@
+import time
+
+import requests
+
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+# import the wonderful Beautiful Soup and the URL grabber
+class CouncilClass(AbstractGetBinDataClass):
+    """
+    Concrete classes have to implement all abstract operations of the
+    base class. They can also override some operations with a default
+    implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        SESSION_URL = "https://selfservice.bolsover.gov.uk/authapi/isauthenticated?uri=https%253A%252F%252Fselfservice.bolsover.gov.uk%252Fservice%252FCheck_your_Bin_Day&hostname=selfservice.bolsover.gov.uk&withCredentials=true"
+
+        API_URL = "https://selfservice.bolsover.gov.uk/apibroker/runLookup"
+
+        data = {
+            "formValues": {"Bin Collection": {"uprnLoggedIn": {"value": user_uprn}}},
+        }
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": "https://selfservice.bolsover.gov.uk/fillform/?iframe_id=fillform-frame-1&db_id=",
+        }
+        s = requests.session()
+        r = s.get(SESSION_URL)
+        r.raise_for_status()
+        session_data = r.json()
+        sid = session_data["auth-session"]
+        params = {
+            "id": "6023d37e037c3",
+            "repeat_against": "",
+            "noRetry": "true",
+            "getOnlyTokens": "undefined",
+            "log_id": "",
+            "app_name": "AF-Renderer::Self",
+            # unix_timestamp
+            "_": str(int(time.time() * 1000)),
+            "sid": sid,
+        }
+
+        r = s.post(API_URL, json=data, headers=headers, params=params)
+        r.raise_for_status()
+
+        data = r.json()
+        rows_data = data["integration"]["transformed"]["rows_data"]["0"]
+        if not isinstance(rows_data, dict):
+            raise ValueError("Invalid data returned from API")
+
+        # print(rows_data)
+
+        route = rows_data["Route"]
+
+        # print(route)
+
+        def get_route_number(route):
+            if route[:2] == "Mo":
+                return 0
+            elif route[:2] == "Tu":
+                return 1
+            elif route[:2] == "We":
+                return 2
+            elif route[:2] == "Th":
+                return 3
+            elif route[:2] == "Fr":
+                return 4
+            else:
+                return None  # Default case if none of the conditions match
+
+        dayOfCollectionAsNumber = get_route_number(route)
+        # print(dayOfCollectionAsNumber)
+
+        def calculate_collection_date(
+            dayOfCollectionAsNumber,
+            currentDayAsNumber,
+            today,
+            dayDiffPlus,
+            dayDiffMinus,
+        ):
+            if dayOfCollectionAsNumber == currentDayAsNumber:
+                return today
+            elif dayOfCollectionAsNumber > currentDayAsNumber:
+                return today + timedelta(days=dayDiffPlus)
+            else:
+                return today + timedelta(days=dayDiffMinus)
+
+        # Example usage
+        today = datetime.today()  # Current date
+        currentDayAsNumber = today.weekday()
+        dayDiffPlus = dayOfCollectionAsNumber - currentDayAsNumber
+        dayDiffMinus = dayOfCollectionAsNumber - currentDayAsNumber + 7
+
+        week1 = calculate_collection_date(
+            dayOfCollectionAsNumber,
+            currentDayAsNumber,
+            today,
+            dayDiffPlus,
+            dayDiffMinus,
+        )
+        week2 = week1 + timedelta(days=7)
+        week3 = week2 + timedelta(days=7)
+        week4 = week3 + timedelta(days=7)
+
+        # print(week1.strftime(date_format))
+        # print(week2.strftime(date_format))
+        # print(week3.strftime(date_format))
+        # print(week4.strftime(date_format))
+
+        greenSusStart = datetime.strptime("2024-11-08", "%Y-%m-%d")
+        greenSusEnd = datetime.strptime("2025-03-18", "%Y-%m-%d")
+
+        def is_within_green_sus(dtDay0, greenSusStart, greenSusEnd):
+            return "Yes" if greenSusStart <= dtDay0 < greenSusEnd else "No"
+
+        week1InSus = is_within_green_sus(week1, greenSusStart, greenSusEnd)
+        week2InSus = is_within_green_sus(week2, greenSusStart, greenSusEnd)
+        week3InSus = is_within_green_sus(week3, greenSusStart, greenSusEnd)
+        week4InSus = is_within_green_sus(week4, greenSusStart, greenSusEnd)
+
+        # print(week1InSus)
+        # print(week2InSus)
+        # print(week3InSus)
+        # print(week4InSus)
+
+        WeekBlack = rows_data["WeekBlack"]
+        WeekBandG = rows_data["WeekBandG"]
+
+        if WeekBlack == "1":
+            WeekBandG = ""
+        if WeekBandG == "1":
+            WeekBlack = ""
+
+        def determine_bin_collection_week1(
+            txtBlack, txtBurgGreen, dtDay0, today, week1InSus
+        ):
+            # Check for empty values
+            if txtBlack == "" and txtBurgGreen == "":
+                return ""
+
+            # Black Bin Collection
+            if txtBlack == "1" and dtDay0 >= today:
+                return "Black Bin"
+
+            # Burgundy Bin Collection
+            if txtBurgGreen == "1" and dtDay0 > today:
+                if week1InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week1InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            # Default cases based on week1InSus
+            if txtBlack == "" and dtDay0 >= today:
+                if week1InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week1InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            return ""  # Default empty case
+
+        def determine_bin_collection_week2(
+            txtBlack, txtBurgGreen, dtDay7, today, week2InSus
+        ):
+            # Check for empty values
+            if txtBlack == "" and txtBurgGreen == "":
+                return ""
+
+            # Black Bin Collection
+            if txtBlack == "" and dtDay7 >= today:
+                return "Black Bin"
+
+            # Burgundy Bin Collection (week2InSus check)
+            if txtBurgGreen == "1" and dtDay7 > today:
+                if week2InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week2InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            # Burgundy Bin Collection for txtBlack = '1'
+            if txtBlack == "1" and dtDay7 >= today:
+                if week2InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week2InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            return ""  # Default empty case
+
+        def determine_bin_collection_week3(
+            txtBlack, txtBurgGreen, dtDay14, today, week3InSus
+        ):
+            # Check for empty values
+            if txtBlack == "" and txtBurgGreen == "":
+                return ""
+
+            # Black Bin Collection
+            if txtBlack == "1" and dtDay14 >= today:
+                return "Black Bin"
+
+            # Burgundy Bin Collection (week3InSus check)
+            if txtBurgGreen == "1" and dtDay14 > today:
+                if week3InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week3InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            # Burgundy Bin Collection for txtBlack = ''
+            if txtBlack == "" and dtDay14 >= today:
+                if week3InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week3InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            return ""  # Default empty case
+
+        def determine_bin_collection_week4(
+            txtBlack, txtBurgGreen, dtDay21, today, week4InSus
+        ):
+            # Check for empty values
+            if txtBlack == "" and txtBurgGreen == "":
+                return ""
+
+            # Black Bin Collection
+            if txtBlack == "" and dtDay21 >= today:
+                return "Black Bin"
+
+            # Burgundy Bin Collection (week4InSus check)
+            if txtBurgGreen == "1" and dtDay21 > today:
+                if week4InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week4InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            # Burgundy Bin Collection for txtBlack = '1'
+            if txtBlack == "1" and dtDay21 >= today:
+                if week4InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week4InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            return ""  # Default empty case
+
+        week1Text = determine_bin_collection_week1(
+            WeekBlack, WeekBandG, week1, today, week1InSus
+        )
+        week2Text = determine_bin_collection_week2(
+            WeekBlack, WeekBandG, week2, today, week2InSus
+        )
+        week3Text = determine_bin_collection_week3(
+            WeekBlack, WeekBandG, week3, today, week3InSus
+        )
+        week4Text = determine_bin_collection_week4(
+            WeekBlack, WeekBandG, week4, today, week4InSus
+        )
+
+        # print(week1Text)
+        # print(week2Text)
+        # print(week3Text)
+        # print(week4Text)
+
+        week_data = [
+            (week1Text, week1),
+            (week2Text, week2),
+            (week3Text, week3),
+            (week4Text, week4),
+        ]
+
+        # print(week_data)
+
+        # Iterate through the array
+        for week_text, week_date in week_data:
+            # Check if '&' exists and split
+            if "&" in week_text:
+                split_texts = [text.strip() for text in week_text.split("&")]
+                for text in split_texts:
+                    dict_data = {
+                        "type": text,
+                        "collectionDate": week_date.strftime(date_format),
+                    }
+                    bindata["bins"].append(dict_data)
+            else:
+                dict_data = {
+                    "type": week_text,
+                    "collectionDate": week_date.strftime(date_format),
+                }
+                bindata["bins"].append(dict_data)
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/CheltenhamBoroughCouncil.py

@@ -1,18 +1,18 @@
-import re
-import time
+# import re
 
 import requests
-from bs4 import BeautifulSoup
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.support.ui import Select
-from selenium.webdriver.support.wait import WebDriverWait
 
-from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.common import (
+    check_postcode,
+    check_uprn,
+    datetime,
+    get_dates_every_x_days,
+    json,
+    timedelta,
+)
 from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
 
 
-# import the wonderful Beautiful Soup and the URL grabber
 class CouncilClass(AbstractGetBinDataClass):
     """
     Concrete classes have to implement all abstract operations of the
@@ -20,42 +20,193 @@ class CouncilClass(AbstractGetBinDataClass):
     implementation.
     """
 
-    def parse_data(self, page: str, **kwargs) -> dict:
+    def parse_data(self, page: str, **kwargs: str) -> dict[str, list[dict[str, str]]]:
+        if (postcode := kwargs.get("postcode")) is None:
+            raise KeyError("Missing: postcode")
+        if (uprn := kwargs.get("uprn")) is None:
+            raise KeyError("Missing: uprn")
+        check_postcode(postcode)
+        check_uprn(uprn)
+        bindata: dict[str, list[dict[str, str]]] = {"bins": []}
+        location_x: int = 0
+        location_y: int = 0
+        location_usrn: str = ""
 
-        collection_day = kwargs.get("paon")
-        collection_week = kwargs.get("postcode")
-        bindata = {"bins": []}
+        # Ensure any cookies set are maintained in a requests session
+        s = requests.session()
+
+        # Ask for a new SessionId from the server
+        session_id_url = "https://maps.cheltenham.gov.uk/map/Aurora.svc/"\
+            "RequestSession?userName=guest+CBC&password=&"\
+            "script=%5CAurora%5CCBC+Waste+Streets.AuroraScript%24"
+        session_id_response = s.get(session_id_url)
+        session_id_response.raise_for_status()
+        session_id = session_id_response.json().get("Session").get("SessionId")
+
+        # Ask what tasks we can do within the session
+        tasks_url = f"https://maps.cheltenham.gov.uk/map/Aurora.svc/"\
+            f"GetWorkflow?sessionId={session_id}&workflowId=wastestreet"
+        tasks_response = s.get(tasks_url)
+        tasks_response.raise_for_status()
+        # JSON response contained a BOM marker
+        tasks = json.loads(tasks_response.text[1:])
+        retrieve_results_task_id, initialise_map_task_id, drilldown_task_id = None, None, None
+        # Pull out the ID's of the tasks we will need
+        for task in tasks.get("Tasks"):
+            if task.get("$type") == "StatMap.Aurora.FetchResultSetTask, StatMapService":
+                retrieve_results_task_id = task.get("Id")
+            elif task.get("$type") == "StatMap.Aurora.SaveStateTask, StatMapService":
+                initialise_map_task_id = task.get("Id")
+            elif task.get("$type") == "StatMap.Aurora.DrillDownTask, StatMapService":
+                drilldown_task_id = task.get("Id")
+        if not all([retrieve_results_task_id, initialise_map_task_id, drilldown_task_id]):
+            raise ValueError("Not all task ID's found")
+
+        # Find the X / Y coordinates for the requested postcode
+        postcode_search_url = "https://maps.cheltenham.gov.uk/map/Aurora.svc/FindLocation?"\
+            f"sessionId={session_id}&address={postcode}&limit=1000"
+        postcode_search_response = s.get(postcode_search_url)
+        postcode_search_response.raise_for_status()
+        if len(locations_list := postcode_search_response.json().get("Locations")) == 0:
+            raise ValueError("Address locations empty")
+        for location in locations_list:
+            location_search_url = "https://maps.cheltenham.gov.uk/map/Aurora.svc/FindLocation?"\
+                f"sessionId={session_id}&locationId={location.get('Id')}"
+            location_search_response = s.get(location_search_url)
+            location_search_response.raise_for_status()
+            if not (location_list := location_search_response.json().get("Locations")):
+                raise KeyError("Locations wasn't present in results")
+            if not (location_detail := location_list[0].get("Details")):
+                raise KeyError("Details wasn't present in location")
+            location_uprn = [detail.get(
+                "Value") for detail in location_detail if detail.get("Name") == "UPRN"][0]
+            if str(location_uprn) == uprn:
+                location_usrn = str([detail.get(
+                    "Value") for detail in location_detail if detail.get("Name") == "USRN"][0])
+                location_x = location_list[0].get("X")
+                location_y = location_list[0].get("Y")
+                break
+
+        # Needed to initialise the server to allow follow on call
+        open_map_url = "https://maps.cheltenham.gov.uk/map/Aurora.svc/OpenScriptMap?"\
+            f"sessionId={session_id}"
+        if res := s.get(open_map_url):
+            res.raise_for_status()
+
+        # Needed to initialise the server to allow follow on call
+        save_state_map_url = "https://maps.cheltenham.gov.uk/map/Aurora.svc/ExecuteTaskJob?"\
+            f"sessionId={session_id}&taskId={initialise_map_task_id}&job="\
+            "%7BTask%3A+%7B+%24type%3A+%27StatMap.Aurora.SaveStateTask%2C"\
+            "+StatMapService%27+%7D%7D"
+        if res := s.get(save_state_map_url):
+            res.raise_for_status()
+
+        # Start search for address given by x / y coord
+        drilldown_map_url = "https://maps.cheltenham.gov.uk/map/Aurora.svc/ExecuteTaskJob?"\
+            f"sessionId={session_id}&taskId={drilldown_task_id}&job=%7B%22"\
+            f"QueryX%22%3A{location_x}%2C%22QueryY%22%3A{location_y}%2C%22"\
+            "Task%22%3A%7B%22Type%22%3A%22StatMap.Aurora.DrillDownTask%2C"\
+            "+StatMapService%22%7D%7D"
+        if res := s.get(drilldown_map_url):
+            res.raise_for_status()
+
+        # Get results from search for address given by x / y coord
+        address_details_url = "https://maps.cheltenham.gov.uk/map/Aurora.svc/ExecuteTaskJob?"\
+            f"sessionId={session_id}&taskId={retrieve_results_task_id}"\
+            f"&job=%7B%22QueryX%22%3A{location_x}%2C%22QueryY%22%3A"\
+            f"{location_y}%2C%22Task%22%3A%7B%22Type%22%3A%22"\
+            "StatMap.Aurora.FetchResultSetTask%2C+StatMapService"\
+            "%22%2C%22ResultSetName%22%3A%22inspection%22%7D%7D"
+        address_details_response = s.get(address_details_url)
+        address_details_response.raise_for_status()
+        # JSON response contained a BOM marker, skip first character
+        address_details = json.loads(address_details_response.text[1:])
+        if not (task_results := address_details.get("TaskResult")):
+            raise KeyError("TaskResult wasn't present in results")
+        if not (distance_export_set := task_results.get("DistanceOrderedSet")):
+            raise KeyError("DistanceOrderedSet wasn't present in TaskResult")
+        if not (result_set := distance_export_set.get("ResultSet")):
+            raise KeyError("ResultSet wasn't present in DistanceOrderedSet")
+        if not (result_tables := result_set.get("Tables")):
+            raise KeyError("Tables wasn't present in ResultSet")
+        result = result_tables[0]
+        column_names: dict[int, str] = {}
+        result_dict: dict[str, str | int] = {}
+        for column in result.get("ColumnDefinitions"):
+            column_names[column.get("ColumnIndex")] = column.get("ColumnName")
+        for r in result.get("Records"):
+            result_dict: dict[str, str | int] = {}
+            for idx, column_value in enumerate(r):
+                if not (column_name := column_names.get(idx)):
+                    raise IndexError("Column index out of range")
+                result_dict[column_name.upper()] = column_value
+            # Validate the street against the USRN. Some locations can return multiple results.
+            # Break on first match of USRN
+            # TODO: Need to select the correct option out of all available options
+            if location_usrn == str(result_dict.get("USRN")):
+                break
+
+        refuse_week, recycling_week, garden_week = 0, 0, 0
+        # After we've got the correct result, pull out the week number each bin type is taken on
+        if (refuse_week_raw := result_dict.get("New_Refuse_Week".upper())) is not None:
+            refuse_week = int(refuse_week_raw)
+        if (recycling_week_raw := result_dict.get("New_Recycling_Week".upper())) is not None:
+            recycling_week = int(recycling_week_raw)
+        if (garden_week_raw := result_dict.get("Garden_Bin_Week".upper())) is not None:
+            garden_week = int(garden_week_raw)
+
+        if not all([refuse_week, recycling_week, garden_week]):
+            raise KeyError("Not all week numbers found")
 
         days_of_week = [
-            "Monday",
-            "Tuesday",
-            "Wednesday",
-            "Thursday",
-            "Friday",
-            "Saturday",
-            "Sunday",
+            "MON",
+            "TUE",
+            "WED",
+            "THU",
+            "FRI",
+            "SAT",
+            "SUN",
         ]
 
-        week = ["Week 1", "Week 2"]
+        refuse_day_offset = days_of_week.index(
+            str(result_dict.get("New_Refuse_Day_internal".upper())).upper())
+        recycling_day_offset = days_of_week.index(
+            str(result_dict.get("New_Recycling_Day".upper())).upper())
+        garden_day_offset = days_of_week.index(
+            str(result_dict.get("New_Garden_Day".upper())).upper())
+        food_day_offset = days_of_week.index(
+            str(result_dict.get("New_Food_Day".upper())).upper())
 
-        offset_days = days_of_week.index(collection_day)
-        collection_week = week.index(collection_week)
+        # Initialise WEEK-1/WEEK-2 based on known details
+        week_1_epoch = datetime(2025, 1, 13)
 
-        if collection_week == 0:
-            refusestartDate = datetime(2024, 11, 25)
-            recyclingstartDate = datetime(2024, 11, 18)
-        else:
-            refusestartDate = datetime(2024, 11, 18)
-            recyclingstartDate = datetime(2024, 11, 25)
+        # Start of this week
+        this_week = datetime.now() - timedelta(days=datetime.now().weekday())
 
-        refuse_dates = get_dates_every_x_days(refusestartDate, 14, 28)
-        recycling_dates = get_dates_every_x_days(recyclingstartDate, 14, 28)
-        food_dates = get_dates_every_x_days(recyclingstartDate, 7, 56)
+        # If there's an even number of weeks between the week-1
+        # epoch and this week, then this week is of type week-1
+        if (((this_week - week_1_epoch).days // 7)) % 2 == 0:
+            week = {
+                1: this_week,
+                2: this_week + timedelta(days=7)
+            }
+        else:
+            week = {
+                1: this_week - timedelta(days=7),
+                2: this_week
+            }
 
-        for refuseDate in refuse_dates:
+        refuse_dates: list[str] = get_dates_every_x_days(
+            week[refuse_week], 14, 28)
+        recycling_dates: list[str] = get_dates_every_x_days(
+            week[recycling_week], 14, 28)
+        garden_dates: list[str] = get_dates_every_x_days(
+            week[garden_week], 14, 28)
 
+        for refuse_date in refuse_dates:
             collection_date = (
-                datetime.strptime(refuseDate, "%d/%m/%Y") + timedelta(days=offset_days)
+                datetime.strptime(refuse_date, "%d/%m/%Y") +
+                timedelta(days=refuse_day_offset)
             ).strftime("%d/%m/%Y")
 
             dict_data = {
@@ -64,11 +215,11 @@ class CouncilClass(AbstractGetBinDataClass):
             }
             bindata["bins"].append(dict_data)
 
-        for recyclingDate in recycling_dates:
+        for recycling_date in recycling_dates:
 
             collection_date = (
-                datetime.strptime(recyclingDate, "%d/%m/%Y")
-                + timedelta(days=offset_days)
+                datetime.strptime(recycling_date, "%d/%m/%Y") +
+                timedelta(days=recycling_day_offset)
             ).strftime("%d/%m/%Y")
 
             dict_data = {
@@ -77,26 +228,81 @@ class CouncilClass(AbstractGetBinDataClass):
             }
             bindata["bins"].append(dict_data)
 
-            dict_data = {
-                "type": "Garden Waste Bin",
-                "collectionDate": collection_date,
-            }
-            bindata["bins"].append(dict_data)
-
-        for food_date in food_dates:
+        for garden_date in garden_dates:
 
             collection_date = (
-                datetime.strptime(food_date, "%d/%m/%Y") + timedelta(days=offset_days)
+                datetime.strptime(garden_date, "%d/%m/%Y") +
+                timedelta(days=garden_day_offset)
             ).strftime("%d/%m/%Y")
 
             dict_data = {
-                "type": "Food Waste Bin",
+                "type": "Garden Waste Bin",
                 "collectionDate": collection_date,
             }
             bindata["bins"].append(dict_data)
 
+        if ((food_waste_week := str(result_dict.get("FOOD_WASTE_WEEK_EXTERNAL", "")).upper())
+                == "weekly".upper()):
+            food_dates: list[str] = get_dates_every_x_days(week[1], 7, 56)
+
+            for food_date in food_dates:
+
+                collection_date = (
+                    datetime.strptime(food_date, "%d/%m/%Y") +
+                    timedelta(days=food_day_offset)
+                ).strftime("%d/%m/%Y")
+
+                dict_data = {
+                    "type": "Food Waste Bin",
+                    "collectionDate": collection_date,
+                }
+                bindata["bins"].append(dict_data)
+        # Sometimes the food bin is collected on different days between
+        # week-1 and week-2
+        else:
+            first_week: str | int
+            second_week_detail: str
+            first_week, _, second_week_detail = food_waste_week.partition("&")
+            first_week = int(first_week.strip())
+
+            second_week_day, _, second_week_number = second_week_detail.partition(
+                "WEEK")
+            second_week_number = int(second_week_number.strip())
+            second_week_day: str = second_week_day.strip()[:3]
+
+            food_dates_first: list[str] = get_dates_every_x_days(
+                week[first_week], 14, 28)
+            food_dates_second: list[str] = get_dates_every_x_days(
+                week[second_week_number], 14, 28)
+            second_week_offset = days_of_week.index(second_week_day)
+
+            for food_date in food_dates_first:
+
+                collection_date = (
+                    datetime.strptime(food_date, "%d/%m/%Y") +
+                    timedelta(days=food_day_offset)
+                ).strftime("%d/%m/%Y")
+
+                dict_data = {
+                    "type": "Food Waste Bin",
+                    "collectionDate": collection_date,
+                }
+                bindata["bins"].append(dict_data)
+            for food_date in food_dates_second:
+
+                collection_date = (
+                    datetime.strptime(food_date, "%d/%m/%Y") +
+                    timedelta(days=second_week_offset)
+                ).strftime("%d/%m/%Y")
+
+                dict_data = {
+                    "type": "Food Waste Bin",
+                    "collectionDate": collection_date,
+                }
+                bindata["bins"].append(dict_data)
+
         bindata["bins"].sort(
-            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+            key=lambda x: datetime.strptime(
+                x.get("collectionDate", ""), "%d/%m/%Y")
         )
-
         return bindata