WIP: Write implementation

Signed-off-by: Carmen Bianca BAKKER <[email protected]>

resource_multi_week_calendar/__init__.py

@@ -3,3 +3,4 @@
 # SPDX-License-Identifier: AGPL-3.0-or-later
 
 from . import models
+from .hooks import post_load_hook

resource_multi_week_calendar/__manifest__.py

@@ -19,6 +19,5 @@
     "data": [
         "views/resource_calendar_views.xml",
     ],
-    "demo": [],
-    "qweb": [],
+    "post_load": "post_load_hook",
 }

resource_multi_week_calendar/hooks.py

@@ -0,0 +1,135 @@
+# SPDX-FileCopyrightText: 2024 Coop IT Easy SC
+# SPDX-FileCopyrightText: Odoo SA
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later AND LGPL-3.0-or-later
+
+# flake8: noqa
+
+import datetime
+import itertools
+from collections import defaultdict
+
+from dateutil.rrule import DAILY, rrule
+from pytz import timezone, utc
+
+from odoo.osv import expression
+
+from odoo.addons.resource.models.resource import (
+    Intervals,
+    ResourceCalendar,
+    float_to_time,
+)
+
+
+def post_load_hook():
+    if not hasattr(ResourceCalendar, "_attendance_intervals_batch_original"):
+        ResourceCalendar._attendance_intervals_batch_original = (
+            ResourceCalendar._attendance_intervals_batch
+        )
+
+    # fmt: off
+    def _new_attendance_intervals_batch(self, start_dt, end_dt, resources=None, domain=None, tz=None):
+        assert start_dt.tzinfo and end_dt.tzinfo
+        self.ensure_one()
+
+        if not resources:
+            resources = self.env['resource.resource']
+            resources_list = [resources]
+        else:
+            resources_list = list(resources) + [self.env['resource.resource']]
+        resource_ids = [r.id for r in resources_list]
+        domain = domain if domain is not None else []
+        domain = expression.AND([domain, [
+            ('calendar_id', '=', self.id),
+            ('resource_id', 'in', resource_ids),
+            ('display_type', '=', False),
+        ]])
+
+        attendances = self.env['resource.calendar.attendance'].search(domain)
+        # Since we only have one calendar to take in account
+        # Group resources per tz they will all have the same result
+        resources_per_tz = defaultdict(list)
+        for resource in resources_list:
+            resources_per_tz[tz or timezone((resource or self).tz)].append(resource)
+        # Resource specific attendances
+        attendance_per_resource = defaultdict(lambda: self.env['resource.calendar.attendance'])
+        # Calendar attendances per day of the week
+        # * 7 days per week * 2 for two week calendars
+        attendances_per_day = [self.env['resource.calendar.attendance']] * 7 * 2
+        weekdays = set()
+        for attendance in attendances:
+            if attendance.resource_id:
+                attendance_per_resource[attendance.resource_id] |= attendance
+            weekday = int(attendance.dayofweek)
+            weekdays.add(weekday)
+            if self.two_weeks_calendar:
+                weektype = int(attendance.week_type)
+                attendances_per_day[weekday + 7 * weektype] |= attendance
+            else:
+                attendances_per_day[weekday] |= attendance
+                attendances_per_day[weekday + 7] |= attendance
+
+        start = start_dt.astimezone(utc)
+        end = end_dt.astimezone(utc)
+        bounds_per_tz = {
+            tz: (start_dt.astimezone(tz), end_dt.astimezone(tz))
+            for tz in resources_per_tz.keys()
+        }
+        # Use the outer bounds from the requested timezones
+        for tz, bounds in bounds_per_tz.items():
+            start = min(start, bounds[0].replace(tzinfo=utc))
+            end = max(end, bounds[1].replace(tzinfo=utc))
+        # Generate once with utc as timezone
+        days = rrule(DAILY, start.date(), until=end.date(), byweekday=weekdays)
+        ResourceCalendarAttendance = self.env['resource.calendar.attendance']
+        base_result = []
+        per_resource_result = defaultdict(list)
+        for day in days:
+            # begin change
+            if not self._day_in_calendar(day):
+                continue
+            # end change
+            week_type = ResourceCalendarAttendance.get_week_type(day)
+            attendances = attendances_per_day[day.weekday() + 7 * week_type]
+            for attendance in attendances:
+                if (attendance.date_from and day.date() < attendance.date_from) or\
+                    (attendance.date_to and attendance.date_to < day.date()):
+                    continue
+                day_from = datetime.combine(day, float_to_time(attendance.hour_from))
+                day_to = datetime.combine(day, float_to_time(attendance.hour_to))
+                if attendance.resource_id:
+                    per_resource_result[attendance.resource_id].append((day_from, day_to, attendance))
+                else:
+                    base_result.append((day_from, day_to, attendance))
+
+        # Copy the result localized once per necessary timezone
+        # Strictly speaking comparing start_dt < time or start_dt.astimezone(tz) < time
+        # should always yield the same result. however while working with dates it is easier
+        # if all dates have the same format
+        result_per_tz = {
+            tz: [(max(bounds_per_tz[tz][0], tz.localize(val[0])),
+                min(bounds_per_tz[tz][1], tz.localize(val[1])),
+                val[2])
+                    for val in base_result]
+            for tz in resources_per_tz.keys()
+        }
+        result_per_resource_id = dict()
+        for tz, resources in resources_per_tz.items():
+            res = result_per_tz[tz]
+            res_intervals = Intervals(res)
+            for resource in resources:
+                if resource in per_resource_result:
+                    resource_specific_result = [(max(bounds_per_tz[tz][0], tz.localize(val[0])), min(bounds_per_tz[tz][1], tz.localize(val[1])), val[2])
+                        for val in per_resource_result[resource]]
+                    result_per_resource_id[resource.id] = Intervals(itertools.chain(res, resource_specific_result))
+                else:
+                    result_per_resource_id[resource.id] = res_intervals
+        return result_per_resource_id
+
+    # fmt: on
+
+    def _day_in_calendar(self, day):
+        return True
+
+    ResourceCalendar._attendance_intervals_batch = _new_attendance_intervals_batch
+    ResourceCalendar._day_in_calendar = _day_in_calendar

resource_multi_week_calendar/models/resource_calendar.py

@@ -126,6 +126,16 @@ def _get_first_day_of_epoch_week(self):
             days=self.multi_week_epoch_date.weekday()
         )
 
+    def _get_week_number(self, day=None):
+        self.ensure_one()
+        if day is None:
+            day = fields.Date.today()
+        family_size = len(self.family_calendar_ids)
+        weeks_since_epoch = math.floor(
+            (day - self._get_first_day_of_epoch_week()).days / 7
+        )
+        return (weeks_since_epoch % family_size) + 1
+
     @api.depends(
         "multi_week_epoch_date",
         "week_number",
@@ -134,12 +144,7 @@ def _get_first_day_of_epoch_week(self):
     )
     def _compute_current_week(self):
         for calendar in self:
-            family_size = len(calendar.family_calendar_ids)
-            weeks_since_epoch = math.floor(
-                (fields.Date.today() - calendar._get_first_day_of_epoch_week()).days / 7
-            )
-            current_week_number = (weeks_since_epoch % family_size) + 1
-            # TODO: does this work in the negative, too?
+            current_week_number = calendar._get_week_number()
             calendar.current_week_number = current_week_number
             calendar.current_calendar_id = calendar.family_calendar_ids.filtered(
                 lambda item: item.week_number == current_week_number
@@ -225,3 +230,46 @@ def _check_epoch_date_matches_parent(self):
                         )
                         % calendar.name
                     )
+
+    def _attendance_intervals_batch(
+        self, start_dt, end_dt, resources=None, domain=None, tz=None
+    ):
+        self.ensure_one()
+        if not self.is_multi_week:
+            return super()._attendance_intervals_batch(
+                start_dt, end_dt, resources=resources, domain=domain, tz=tz
+            )
+        if self.parent_calendar_id:
+            return self.parent_calendar_id._attendance_intervals_batch(
+                start_dt, end_dt, resources=resources, domain=domain, tz=tz
+            )
+        calendars = self | self.child_calendar_ids
+        results = []
+        for calendar in calendars:
+            results.append(
+                super(
+                    ResourceCalendar,
+                    # This context isn't used here, but could be used by
+                    # dependencies to prevent loops.
+                    calendar.with_context(recursive_multi_week=True),
+                )._attendance_intervals_batch(
+                    start_dt, end_dt, resources=resources, domain=domain, tz=tz
+                )
+            )
+
+        result = {}
+        for item in results:
+            for resource, intervals in item.items():
+                if resource not in result:
+                    result[resource] = intervals
+                else:
+                    result[resource] += intervals
+
+        return result
+
+    # See hooks.py for where this is used.
+    def _day_in_calendar(self, day):
+        self.ensure_one()
+        if not self.is_multi_week:
+            return super()._day_in_calendar(day)
+        return self._get_week_number(day) == self.week_number