[FIX] resource: fix flexible resource leave in planning gantt

Prior to this commit, flexible resources did not have their leaves
reflected as gray cells in the planning gantt view. This was due to the
work_intervals being ignored for the calculation of flexible resources
availability.

This commit adds measures to handle the leaves for flexible resources by
setting a dummy attendance (which covers the whole length of the period
in gantt interval), and then injects their leaves interval.

To replicate:
1. set a timeoff to a flexible resource
2. open planning app
3. in the gantt view, the day in which the timeoff was set should be grayed.

Ticket-id: 4492625
Enterprise: 79532
Part-of: odoo#198032
Related: odoo/enterprise#79532
Signed-off-by: Xavier Bol (xbo) <xbo@odoo.com>

Author: chrisduvivier

addons/hr_holidays/models/hr_leave_type.py

@@ -560,9 +560,7 @@ def get_allocation_data(self, employees, target_date=None):
                         datetime.combine(closest_expiration_date, time.max).replace(tzinfo=pytz.UTC),
                         resources=employee.resource_id
                     )
-                    closest_allocation_dict =\
-                        self.env['resource.calendar']._get_attendance_intervals_days_data(
-                            calendar_attendance[employee.resource_id.id])
+                    closest_allocation_dict = calendar._get_attendance_intervals_days_data(calendar_attendance[employee.resource_id.id])
                     if leave_type.request_unit in ['hour']:
                         closest_allocation_duration = closest_allocation_dict['hours']
                     else:

addons/resource/models/resource_calendar.py

@@ -4,7 +4,7 @@
 import itertools
 
 from collections import defaultdict
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, time
 from functools import partial
 from itertools import chain
 
@@ -367,14 +367,25 @@ def _attendance_intervals_batch(self, start_dt, end_dt, resources=None, domain=N
             res = result_per_tz[tz]
             res_intervals = WorkIntervals(res)
             for resource in resources:
-                if resource in per_resource_result:
+                if resource and resource._is_flexible():
+                # If the resource is flexible, return the whole period from start_dt to end_dt with a dummy attendance
+                    dummy_attendance = self.env['resource.calendar.attendance']
+                    result_per_resource_id[resource.id] = WorkIntervals([(start, end, dummy_attendance)])
+                elif 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] = WorkIntervals(itertools.chain(res, resource_specific_result))
                 else:
                     result_per_resource_id[resource.id] = res_intervals
         return result_per_resource_id
 
+    def _handle_flexible_leave_interval(self, dt0, dt1, leave):
+        """Hook method to handle flexible leave intervals. Can be overridden in other modules."""
+        tz = dt0.tzinfo  # Get the timezone information from dt0
+        dt0 = datetime.combine(dt0.date(), time.min).replace(tzinfo=tz)
+        dt1 = datetime.combine(dt1.date(), time.max).replace(tzinfo=tz)
+        return dt0, dt1
+
     def _leave_intervals(self, start_dt, end_dt, resource=None, domain=None, tz=None):
         if resource is None:
             resource = self.env['resource.resource']
@@ -431,6 +442,8 @@ def _leave_intervals_batch(self, start_dt, end_dt, resources=None, domain=None,
                     tz_dates[(tz, end_dt)] = end
                 dt0 = string_to_datetime(leave_date_from).astimezone(tz)
                 dt1 = string_to_datetime(leave_date_to).astimezone(tz)
+                if leave_resource and leave_resource._is_flexible():
+                    dt0, dt1 = self._handle_flexible_leave_interval(dt0, dt1, leave)
                 result[resource.id].append((max(start, dt0), min(end, dt1), leave))
 
         return {r.id: Intervals(result[r.id]) for r in resources_list}
@@ -472,7 +485,7 @@ def _unavailable_intervals_batch(self, start_dt, end_dt, resources=None, domain=
         resources_work_intervals = self._work_intervals_batch(start_dt, end_dt, resources, domain, tz)
         result = {}
         for resource in resources_list:
-            if resource and resource._is_flexible():
+            if resource and resource._is_fully_flexible():
                 continue
             work_intervals = [(start, stop) for start, stop, meta in resources_work_intervals[resource.id]]
             # start + flatten(intervals) + end
@@ -505,7 +518,10 @@ def _get_attendance_intervals_days_data(self, attendance_intervals):
             # take durations in days proportionally to what is left of the interval.
             interval_hours = (stop - start).total_seconds() / 3600
             day_hours[start.date()] += interval_hours
-            day_days[start.date()] += sum(meta.mapped('duration_days')) * interval_hours / sum(meta.mapped('duration_hours'))
+            if len(self) == 1 and self.flexible_hours and self.hours_per_day:
+                day_days[start.date()] += interval_hours / self.hours_per_day
+            else:
+                day_days[start.date()] += sum(meta.mapped('duration_days')) * interval_hours / sum(meta.mapped('duration_hours'))
 
         return {
             # Round the number of days to the closest 16th of a day.

addons/test_resource/tests/test_resource.py

@@ -1322,6 +1322,39 @@ def test_unavailable_intervals(self):
             (datetime(2022, 9, 21, 15, 0, tzinfo=utc), datetime(2022, 9, 22, 0, 0, tzinfo=utc)),
         ])
 
+    def test_flexible_resource_leave_interval(self):
+        """
+        Test whole day off for a flexible resource.
+        The standard 8 - 17 leave should be converted to a whole day leave interval for the flexible resource.
+        """
+
+        flexible_calendar = self.env['resource.calendar'].create({
+            'name': 'Flex Calendar',
+            'tz': 'UTC',
+            'flexible_hours': True,
+        })
+        flex_resource = self.env['resource.resource'].create({
+            'name': 'Test FlexResource',
+            'calendar_id': flexible_calendar.id,
+        })
+        self.env['resource.calendar.leaves'].create({
+            'name': 'Standard Time Off',
+            'calendar_id': flexible_calendar.id,
+            'resource_id': flex_resource.id,
+            'date_from': '2025-03-07 08:00:00',
+            'date_to': '2025-03-07 17:00:00',
+        })
+
+        start_dt = datetime(2025, 3, 7, 0, 0, 0, tzinfo=utc)
+        end_dt = datetime(2025, 3, 7, 23, 59, 59, 999999, tzinfo=utc)
+
+        intervals = flexible_calendar._leave_intervals_batch(start_dt, end_dt, [flex_resource])
+        intervals_list = list(intervals[flex_resource.id])
+        self.assertEqual(len(intervals_list), 1, "There should be one leave interval")
+        interval = intervals_list[0]
+        self.assertEqual(interval[0], start_dt, "The start of the interval should be 00:00:00")
+        self.assertEqual(interval[1], end_dt, "The end of the interval should be 23:59:59.999999")
+
 class TestResource(TestResourceCommon):
 
     def test_calendars_validity_within_period(self):