From 12de36565aa07c6900a5cb55dcecb24641fd9088 Mon Sep 17 00:00:00 2001 From: Valentin Lab Date: Thu, 19 Nov 2026 14:09:06 +0100 Subject: [PATCH 1/5] [IMP]hr_employee_stats_sheet:read the timesheet lines of all the days in one search Computing the hours of N days ran one search on the analytic lines per day. The days computed together now share a single search, whose lines are grouped back by employee and day. Each day keeps its lines in the search order (``date desc, id desc``), the order the per-day search returned them in, so the sums are the same to the last digit. ``get_total_hours_domain`` now returns the domain of all the days of the recordset, and ``_get_total_hours`` reads its value from the shared search. Assisted-by: Claude:claude-opus-5-5 Assisted-by: GPT:gpt-6.1-sol Assisted-by: GPT:gpt-6.2-astra-ultrafast --- .../models/hr_employee_stats.py | 61 +++++++++++++------ 1 file changed, 41 insertions(+), 20 deletions(-) diff --git a/hr_employee_stats_sheet/models/hr_employee_stats.py b/hr_employee_stats_sheet/models/hr_employee_stats.py index 4071de9..0e21d8f 100644 --- a/hr_employee_stats_sheet/models/hr_employee_stats.py +++ b/hr_employee_stats_sheet/models/hr_employee_stats.py @@ -1,10 +1,12 @@ import logging import pytz +from collections import defaultdict from odoo import api, fields, models, _ from datetime import timedelta from pytz import utc from odoo.exceptions import UserError +from odoo.osv import expression class HrEmployeeStats(models.Model): @@ -46,14 +48,28 @@ class HrEmployeeStats(models.Model): else: return False - def _compute_timesheet_line_ids(self): + def _dates_by_employee(self): + dates = defaultdict(set) for stat in self: - stat.timesheet_line_ids = self.env["account.analytic.line"].search( - [ - ("employee_id", "=", stat.employee_id.id), - ("date", "=", stat.date), - ] - ) + dates[stat.employee_id].add(stat.date) + return dates + + def _timesheet_lines_by_day(self): + """Return {(employee, date): lines} with a single search. Each day + keeps the search order (date desc, id desc), so sums are unchanged.""" + if not self: + return {} + lines = self.env["account.analytic.line"].search(self.get_total_hours_domain()) + line_ids = defaultdict(list) + for line in lines: + line_ids[line.employee_id, line.date].append(line.id) + return {day: lines.browse(ids) for day, ids in line_ids.items()} + + def _compute_timesheet_line_ids(self): + lines = self._timesheet_lines_by_day() + no_lines = self.env["account.analytic.line"] + for stat in self: + stat.timesheet_line_ids = lines.get((stat.employee_id, stat.date), no_lines) def _get_intersects( self, datetime1_start, datetime1_end, datetime2_start, datetime2_end @@ -64,22 +80,25 @@ class HrEmployeeStats(models.Model): return max(0, delta) def get_total_hours_domain(self): - return [ - ("employee_id", "=", self.employee_id.id), - ("date", "=", self.date), - ] + """Timesheet lines counted in the total hours of these days.""" + return expression.OR([ + [("employee_id", "=", employee.id), ("date", "in", list(dates))] + for employee, dates in self._dates_by_employee().items() + ]) + + def _total_hours_by_stat(self): + days = self.filtered(lambda stat: stat.date and stat.employee_id) + lines = days._timesheet_lines_by_day() + no_lines = self.env["account.analytic.line"] + return { + stat: sum(lines.get((stat.employee_id, stat.date), no_lines).mapped("unit_amount")) + for stat in days + } @api.depends("timesheet_line_ids") def _get_total_hours(self): self.ensure_one() - total_hours = 0 - timesheet_line = self.env["account.analytic.line"] - if self.date and self.employee_id: - timesheet_line_ids = timesheet_line.search( - self.get_total_hours_domain() - ) - total_hours = sum(timesheet_line_ids.mapped("unit_amount")) - return total_hours + return self._total_hours_by_stat().get(self, 0) def _get_total_planned_hours(self): self.ensure_one() @@ -230,8 +249,10 @@ class HrEmployeeStats(models.Model): "timesheet_line_ids", ) def _compute_hours(self): + # read what the days need once for all of them, not day by day + hours = self._total_hours_by_stat() for stat in self: - total_hours = stat._get_total_hours() + total_hours = hours.get(stat, 0) total_planned_hours = stat._get_total_planned_hours() total_recovery_hours = stat._get_total_recovery_hours() total_leave_hours = stat._get_total_leave_hours() -- 2.49.1 From 21cca44604176ef7ba088125faf924031f410f20 Mon Sep 17 00:00:00 2001 From: Valentin Lab Date: Thu, 19 Nov 2026 14:09:23 +0100 Subject: [PATCH 2/5] [IMP]hr_employee_stats_sheet:read the planned hours of all the days at once The planned hours of each day searched the employee calendar history, then the calendar attendances, day by day. The days computed together now share one search of the calendar histories and one of the attendances. The calendar of a day is chosen by the same rule as before, now in ``_select_stats_calendar`` and shared with ``_get_calendar_in_progress_during_a_time_period``: the history line covering the day, else the company calendar, and an error when two lines cover it. Assisted-by: Claude:claude-opus-5-5 Assisted-by: GPT:gpt-6.1-sol Assisted-by: GPT:gpt-6.2-astra-ultrafast --- hr_employee_stats_sheet/models/hr_employee.py | 8 +++ .../models/hr_employee_stats.py | 68 ++++++++++++------- .../tests/test_employee_stats.py | 35 ++++++++++ 3 files changed, 86 insertions(+), 25 deletions(-) diff --git a/hr_employee_stats_sheet/models/hr_employee.py b/hr_employee_stats_sheet/models/hr_employee.py index c6ceced..07860cc 100644 --- a/hr_employee_stats_sheet/models/hr_employee.py +++ b/hr_employee_stats_sheet/models/hr_employee.py @@ -23,6 +23,14 @@ class HrEmployee(models.Model): ("date_end", ">=", date_start), # date de fin après le début ], ) + return self._select_stats_calendar(calendars) + + def _select_stats_calendar(self, calendars): + """ + get the ressource calendar to use, given the hr_employee_calendar + lines running over the period + """ + self.ensure_one() if len(calendars) > 1: raise UserError( _("There is a calendar starting during the timesheet sheet time period for the employee %s " diff --git a/hr_employee_stats_sheet/models/hr_employee_stats.py b/hr_employee_stats_sheet/models/hr_employee_stats.py index 0e21d8f..269bf27 100644 --- a/hr_employee_stats_sheet/models/hr_employee_stats.py +++ b/hr_employee_stats_sheet/models/hr_employee_stats.py @@ -100,32 +100,49 @@ class HrEmployeeStats(models.Model): self.ensure_one() return self._total_hours_by_stat().get(self, 0) + def _planned_hours_by_stat(self): + """Return {stat: planned hours} from the calendar each employee had + that day. Public holidays and days without employee or date are left + out: they have no planned hours.""" + days = self.filtered(lambda stat: stat.employee_id and stat.date and not stat.is_public_holiday) + dates_by_employee = days._dates_by_employee() + if not dates_by_employee: + return {} + histories = self.env["hr.employee.calendar"].search(expression.OR([ + [ + ("employee_id", "=", employee.id), + ("date_start", "<=", max(dates)), + "|", ("date_end", "=", False), ("date_end", ">=", min(dates)), + ] + for employee, dates in dates_by_employee.items() + ])) + calendars = {} + for employee, dates in dates_by_employee.items(): + employee_histories = histories.filtered(lambda history: history.employee_id == employee) + for date in dates: + # same lines as _get_calendar_in_progress_during_a_time_period(date, date) + calendars[employee, date] = employee._select_stats_calendar(employee_histories.filtered( + lambda history: history.date_start <= date + and (not history.date_end or date <= history.date_end) + )) + attendances = self.env["resource.calendar.attendance"].search( + [("calendar_id", "in", [calendar.id for calendar in set(calendars.values())])] + ) + hours = defaultdict(float) + for attendance in attendances: + week_type = attendance.week_type if attendance.calendar_id.two_weeks_calendar else None + key = (attendance.calendar_id, attendance.dayofweek, week_type) + hours[key] += attendance.hour_to - attendance.hour_from + planned_hours = {} + for stat in days: + calendar = calendars[stat.employee_id, stat.date] + week_type = str(stat.date.isocalendar()[1] % 2) if calendar.two_weeks_calendar else None + planned_hours[stat] = hours.get((calendar, str(stat.date.weekday()), week_type), 0) + return planned_hours + def _get_total_planned_hours(self): self.ensure_one() - total_planned_hours = 0 - if self.employee_id and self.date and not self.is_public_holiday: - dayofweek = int(self.date.strftime("%u")) - 1 - calendar_id = self.employee_id._get_calendar_in_progress_during_a_time_period(self.date,self.date) - week_number = self.date.isocalendar()[1] % 2 - if calendar_id.two_weeks_calendar: - hours = calendar_id.attendance_ids.search( - [ - ("dayofweek", "=", dayofweek), - ("calendar_id", "=", calendar_id.id), - ("week_type", "=", week_number), - ] - ) - else: - hours = calendar_id.attendance_ids.search( - [ - ("dayofweek", "=", dayofweek), - ("calendar_id", "=", calendar_id.id), - ] - ) - total_planned_hours = sum( - hours.mapped(lambda r: r.hour_to - r.hour_from) - ) - return total_planned_hours + return self._planned_hours_by_stat().get(self, 0) def _get_total_recovery_hours(self): #TODO: duplicated code with _get_total_leave_hours, to refactor later @@ -251,9 +268,10 @@ class HrEmployeeStats(models.Model): def _compute_hours(self): # read what the days need once for all of them, not day by day hours = self._total_hours_by_stat() + planned_hours = self._planned_hours_by_stat() for stat in self: total_hours = hours.get(stat, 0) - total_planned_hours = stat._get_total_planned_hours() + total_planned_hours = planned_hours.get(stat, 0) total_recovery_hours = stat._get_total_recovery_hours() total_leave_hours = stat._get_total_leave_hours() stat.total_hours = total_hours diff --git a/hr_employee_stats_sheet/tests/test_employee_stats.py b/hr_employee_stats_sheet/tests/test_employee_stats.py index f65066e..2e8a45a 100644 --- a/hr_employee_stats_sheet/tests/test_employee_stats.py +++ b/hr_employee_stats_sheet/tests/test_employee_stats.py @@ -455,6 +455,41 @@ class TestHrEmployeeStatsRecovery(TransactionCase): self.assertEqual(len(recovery_allocation), 1, "Il doit y avoir une allocation de récupération générée") self.assertAlmostEqual(recovery_allocation.number_of_hours_display, 8.75, msg="The recovery allocation should display 8.75 hours") + # --- Reading many days at once ----------------------------------------- + + def _create_days(self, *days): + return self.env['hr.employee.stats'].create([ + {'employee_id': self.employee.id, 'date': day} for day in days + ]) + + def test_planned_hours_read_together_follow_calendar_history(self): + two_weeks = self.env['resource.calendar'].create({ + 'name': 'Alternating Mondays', + 'two_weeks_calendar': True, + 'attendance_ids': [ + (0, 0, {'name': 'Even Monday', 'dayofweek': '0', 'week_type': '0', + 'hour_from': 9, 'hour_to': 12}), + (0, 0, {'name': 'Odd Monday', 'dayofweek': '0', 'week_type': '1', + 'hour_from': 9, 'hour_to': 14}), + ], + }) + mondays = ['2025-03-03', '2025-03-10', '2025-03-17', '2025-03-24'] + self.env['hr.employee.calendar'].create({ + 'employee_id': self.employee.id, 'calendar_id': two_weeks.id, + 'date_start': mondays[0], 'date_end': mondays[1], + }) + one_day = self.env['hr.employee.calendar'].create({ + 'employee_id': self.employee.id, 'calendar_id': self.base_calendar.id, + 'date_start': mondays[2], 'date_end': mondays[2], + }) + days = self._create_days(*mondays) + # even week, odd week, base calendar, company calendar (8h) after the history + self.assertEqual(days.mapped('total_planned_hours'), [3, 5, 7, 8]) + one_day.date_start = mondays[1] # two calendars on March 10: an anomaly + self.env.invalidate_all() + with self.assertRaisesRegex(UserError, 'calendar starting'): + days.mapped('total_planned_hours') + @tagged("post_install", "-at_install") class TestHrEmployeeStatsLeaveAndRecoveryUnit(TransactionCase): -- 2.49.1 From 92dc0e2a582311c7d54b8fa7cd10d6a172b0b765 Mon Sep 17 00:00:00 2001 From: Valentin Lab Date: Thu, 19 Nov 2026 14:09:25 +0100 Subject: [PATCH 3/5] [IMP]hr_employee_stats_sheet:read the validated leaves of all the days in one search Each day ran two searches on the leaves, one for the recoveries and one for the other leaves. The days computed together now share one search, and ``_absence_hours_by_stat`` applies the existing rule to each day: a single-day request counts the hours Odoo computed for it, a day inside a longer request counts the planned hours of that day. The leaves of a day stay in the search order (``date_from desc``), so the sums are the same as before. Assisted-by: Claude:claude-opus-5-5 Assisted-by: GPT:gpt-6.2-sol-ultrafast --- .../models/hr_employee_stats.py | 92 ++++++++++--------- .../tests/test_employee_stats.py | 16 ++++ 2 files changed, 63 insertions(+), 45 deletions(-) diff --git a/hr_employee_stats_sheet/models/hr_employee_stats.py b/hr_employee_stats_sheet/models/hr_employee_stats.py index 269bf27..4662799 100644 --- a/hr_employee_stats_sheet/models/hr_employee_stats.py +++ b/hr_employee_stats_sheet/models/hr_employee_stats.py @@ -144,58 +144,60 @@ class HrEmployeeStats(models.Model): self.ensure_one() return self._planned_hours_by_stat().get(self, 0) - def _get_total_recovery_hours(self): - #TODO: duplicated code with _get_total_leave_hours, to refactor later - self.ensure_one() - recovery = self.env["hr.leave"] - total_recovery_hours = 0 - if self.date and self.employee_id and self._get_holiday_status_id(): - recovery_ids = recovery.search( + def _validated_leaves_by_day(self): + """Return {(employee, date): validated leaves} with a single search, + in its order (date_from desc).""" + dates_by_employee = self.filtered(lambda stat: stat.employee_id and stat.date)._dates_by_employee() + if not dates_by_employee: + return {} + leaves = self.env["hr.leave"].search(expression.AND([ + [("state", "=", "validate"), ("active", "=", True)], + expression.OR([ [ - ("employee_id", "=", self.employee_id.id), - ("holiday_status_id", "=", self._get_holiday_status_id()), - ("request_date_from", "<=", self.date), - ("request_date_to", ">=", self.date), - ("state", '=', 'validate'), - ("active", '=', True), - ], - ) - for recovery_id in recovery_ids: - if recovery_id.request_date_from == recovery_id.request_date_to: + ("employee_id", "=", employee.id), + ("request_date_from", "<=", max(dates)), + ("request_date_to", ">=", min(dates)), + ] + for employee, dates in dates_by_employee.items() + ]), + ])) + leaves_by_day = defaultdict(list) + for leave in leaves: + for date in dates_by_employee[leave.employee_id]: + if leave.request_date_from <= date <= leave.request_date_to: + leaves_by_day[leave.employee_id, date].append(leave) + return leaves_by_day + + def _absence_hours_by_stat(self, planned_hours): + """Return {stat: (recovery hours, other leave hours)}.""" + leaves = self._validated_leaves_by_day() + absence_hours = {} + for stat in self: + recovery_type = stat._get_holiday_status_id() + recovery_hours = leave_hours = 0 + for leave in leaves.get((stat.employee_id, stat.date), ()): + if leave.request_date_from == leave.request_date_to: # single-day request (hours or half-day): # Odoo already computed the hours from the calendar - total_recovery_hours += recovery_id.number_of_hours_display + hours = leave.number_of_hours_display else: # multi-day request: we take the planned hours # of THAT specific day - total_recovery_hours += self._get_total_planned_hours() - return total_recovery_hours + hours = planned_hours.get(stat, 0) + if recovery_type and leave.holiday_status_id.id == recovery_type: + recovery_hours += hours + else: + leave_hours += hours + absence_hours[stat] = (recovery_hours, leave_hours) + return absence_hours + + def _get_total_recovery_hours(self): + self.ensure_one() + return self._absence_hours_by_stat(self._planned_hours_by_stat())[self][0] def _get_total_leave_hours(self): self.ensure_one() - leave = self.env["hr.leave"] - total_leave_hours = 0 - if self.date and self.employee_id: - leave_ids = leave.search( - [ - ("employee_id", "=", self.employee_id.id), - ("holiday_status_id", "!=", self._get_holiday_status_id()), - ("request_date_from", "<=", self.date), - ("request_date_to", ">=", self.date), - ("state", '=', 'validate'), - ("active", '=', True), - ], - ) - for leave_id in leave_ids: - if leave_id.request_date_from == leave_id.request_date_to: - # single-day request (hours or half-day): - # Odoo already computed the hours from the calendar - total_leave_hours += leave_id.number_of_hours_display - else: - # multi-day request: we take the planned hours - # of THAT specific day - total_leave_hours += self._get_total_planned_hours() - return total_leave_hours + return self._absence_hours_by_stat(self._planned_hours_by_stat())[self][1] @api.depends("employee_id", "date") def _compute_name(self): @@ -269,11 +271,11 @@ class HrEmployeeStats(models.Model): # read what the days need once for all of them, not day by day hours = self._total_hours_by_stat() planned_hours = self._planned_hours_by_stat() + absence_hours = self._absence_hours_by_stat(planned_hours) for stat in self: total_hours = hours.get(stat, 0) total_planned_hours = planned_hours.get(stat, 0) - total_recovery_hours = stat._get_total_recovery_hours() - total_leave_hours = stat._get_total_leave_hours() + total_recovery_hours, total_leave_hours = absence_hours[stat] stat.total_hours = total_hours stat.total_planned_hours = total_planned_hours stat.gap_hours = stat._get_gap_hours(total_hours, total_recovery_hours, total_leave_hours, total_planned_hours) diff --git a/hr_employee_stats_sheet/tests/test_employee_stats.py b/hr_employee_stats_sheet/tests/test_employee_stats.py index 2e8a45a..317e470 100644 --- a/hr_employee_stats_sheet/tests/test_employee_stats.py +++ b/hr_employee_stats_sheet/tests/test_employee_stats.py @@ -706,6 +706,22 @@ class TestHrEmployeeStatsLeaveAndRecoveryUnit(TransactionCase): self.assertEqual(stat.total_leave_hours, 0, "recovery must not count as a leave") self.assertEqual(stat.total_recovery_hours, 7, "it must count as a recovery") + def test_leaves_read_together(self): + leave_type = self._create_leave_type('hour') + self.recovery_type.request_unit = 'half_day' + wednesday = self.tuesday + timedelta(days=1) + thursday = self.tuesday + timedelta(days=2) + self._create_leave(self.recovery_type, self.monday, self.monday, half=True, period='am') + self._create_leave(leave_type, self.monday, self.monday, hours=True, hour_from='13', hour_to='15') + self._create_leave(self._create_leave_type('day'), self.tuesday, wednesday) + days = self.env['hr.employee.stats'].create([ + {'employee_id': self.employee.id, 'date': day} + for day in (self.monday, self.tuesday, wednesday, thursday) + ]) + self.env.invalidate_all() + self.assertEqual(days.mapped('total_recovery_hours'), [3, 0, 0, 0]) + self.assertEqual(days.mapped('total_leave_hours'), [2, 7, 7, 0]) + -- 2.49.1 From 567a0a1d0de3c7c0350fd31dff9d9de2595b30ee Mon Sep 17 00:00:00 2001 From: Valentin Lab Date: Thu, 19 Nov 2026 14:09:26 +0100 Subject: [PATCH 4/5] [IMP]hr_employee_stats_sheet:read the public holidays once per employee Each day searched the public holidays of its own date. The days computed together now run one search per employee over their date range, then keep for each day the holidays the per-day search returned: those whose UTC range covers the day. The check in the employee time zone is unchanged, and two holidays on the same day still raise the same error. With this change, the number of SQL queries needed to compute the days of an employee no longer grows with the number of days. Assisted-by: Claude:claude-opus-5-5 Assisted-by: GPT:gpt-6.1-sol Assisted-by: GPT:gpt-6.2-astra-ultrafast --- .../models/hr_employee_stats.py | 29 ++++++++--- .../tests/test_employee_stats.py | 48 +++++++++++++++++++ 2 files changed, 71 insertions(+), 6 deletions(-) diff --git a/hr_employee_stats_sheet/models/hr_employee_stats.py b/hr_employee_stats_sheet/models/hr_employee_stats.py index 4662799..6b08b22 100644 --- a/hr_employee_stats_sheet/models/hr_employee_stats.py +++ b/hr_employee_stats_sheet/models/hr_employee_stats.py @@ -206,13 +206,16 @@ class HrEmployeeStats(models.Model): @api.depends("date","employee_id") def _compute_dayofweek(self): + public_holidays = self._public_holidays_by_day() for stat in self: if not stat.date: stat.dayofweek = None stat.is_public_holiday = False continue stat.dayofweek = int(stat.date.strftime("%u")) - 1 - stat.is_public_holiday = stat._is_public_holiday_accordig_to_employe_tz() + stat.is_public_holiday = stat._matches_public_holiday( + public_holidays.get((stat.employee_id, stat.date)) + ) def _convert_to_employee_tz(self, date): """Convert a UTC datetime to the employee's timezone datetime.""" @@ -224,14 +227,28 @@ class HrEmployeeStats(models.Model): dt = pytz.utc.localize(date) return dt.astimezone(employee_tz) + def _public_holidays_by_day(self): + """Return {(employee, date): public holidays} with one search per + employee: the holidays _get_public_holidays(date, date) returns.""" + public_holidays = {} + days = self.filtered(lambda stat: stat.employee_id and stat.date) + for employee, dates in days._dates_by_employee().items(): + holidays = employee._get_public_holidays(min(dates), max(dates)) + for date in dates: + # the search compares the UTC datetimes with the whole day + public_holidays[employee, date] = holidays.filtered( + lambda holiday: holiday.date_from.date() <= date <= holiday.date_to.date() + ) + return public_holidays + def _is_public_holiday_accordig_to_employe_tz(self): self.ensure_one() - if not self.date or not self.employee_id: - return False - #get public holidays for the employee - public_holidays = self.employee_id._get_public_holidays( - self.date, self.date + return self._matches_public_holiday( + self._public_holidays_by_day().get((self.employee_id, self.date)) ) + + def _matches_public_holiday(self, public_holidays): + self.ensure_one() if not public_holidays: return False if len(public_holidays) > 1: diff --git a/hr_employee_stats_sheet/tests/test_employee_stats.py b/hr_employee_stats_sheet/tests/test_employee_stats.py index 317e470..9c6c0fd 100644 --- a/hr_employee_stats_sheet/tests/test_employee_stats.py +++ b/hr_employee_stats_sheet/tests/test_employee_stats.py @@ -462,6 +462,54 @@ class TestHrEmployeeStatsRecovery(TransactionCase): {'employee_id': self.employee.id, 'date': day} for day in days ]) + def _count_queries(self, records, fnames): + """SQL queries needed to read fnames of records from an empty cache.""" + self.env.invalidate_all() + records.read(fnames) # fills the caches that invalidate_all keeps + self.env.invalidate_all() + before = self.env.cr.sql_log_count + records.read(fnames) + return self.env.cr.sql_log_count - before + + def test_query_count_does_not_grow_with_days(self): + start = Date.to_date("2025-03-03") + self.env['hr.employee.calendar'].create({ + 'employee_id': self.employee.id, + 'date_start': start, + 'calendar_id': self.base_calendar.id, + }) + days = self._create_days(*(start + timedelta(days=i) for i in range(14))) + self.env['account.analytic.line'].create([{ + 'employee_id': self.employee.id, 'date': day.date, 'unit_amount': 3, + 'account_id': self.analytic_account.id, 'name': 'Work Entry', + } for day in days]) + fnames = ['total_hours', 'total_planned_hours', 'total_leave_hours', + 'total_recovery_hours', 'gap_hours', 'is_public_holiday'] + self.assertLessEqual(self._count_queries(days, fnames), + self._count_queries(days[:2], fnames)) + self.assertEqual(days.mapped('total_hours'), [3] * 14) + + def test_public_holidays_read_together(self): + # Stored in UTC, this holiday is May 1st 00:00 to May 2nd 01:00 in + # Paris. A day counts only if it is in the UTC range AND in the + # employee's range: April 30 and May 2 do not count. + self.env['resource.calendar.leaves'].create({ + 'name': 'Late finish', + 'date_from': '2025-04-30 22:00:00', + 'date_to': '2025-05-01 23:00:00', + }) + days = self._create_days('2025-04-30', '2025-05-01', '2025-05-02') + self.assertEqual(days.mapped('is_public_holiday'), [False, True, False]) + # April 30 now has two holidays in its UTC range: that is an anomaly. + self.env['resource.calendar.leaves'].create({ + 'name': 'Earlier', + 'date_from': '2025-04-30 08:00:00', + 'date_to': '2025-04-30 09:00:00', + }) + self.env.invalidate_all() + with self.assertRaisesRegex(UserError, '2025-04-30'): + days.mapped('is_public_holiday') + def test_planned_hours_read_together_follow_calendar_history(self): two_weeks = self.env['resource.calendar'].create({ 'name': 'Alternating Mondays', -- 2.49.1 From b0823653a8d194674cad3b178c4f41d5386ad836 Mon Sep 17 00:00:00 2001 From: Valentin Lab Date: Thu, 19 Nov 2026 14:09:27 +0100 Subject: [PATCH 5/5] [IMP]hr_employee_stats_sheet:compute the days of all the sheets together Reading the totals of several timesheet sheets computed their days sheet by sheet. The days of all the sheets are now computed in one batch first, so a list or a grouped view of sheets needs as many SQL queries for 2 sheets as for 200. Assisted-by: Claude:claude-opus-5-5 Assisted-by: GPT:gpt-6.2-astra-ultrafast --- .../models/hr_timesheet_sheet.py | 13 +++++++------ .../tests/test_employee_stats.py | 15 +++++++++++++++ 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/hr_employee_stats_sheet/models/hr_timesheet_sheet.py b/hr_employee_stats_sheet/models/hr_timesheet_sheet.py index 5e59ac1..2803ac9 100644 --- a/hr_employee_stats_sheet/models/hr_timesheet_sheet.py +++ b/hr_employee_stats_sheet/models/hr_timesheet_sheet.py @@ -26,18 +26,19 @@ class HrTimesheetSheet(models.Model): @api.depends("employee_stats_ids.gap_hours", "employee_id") def _compute_hours(self): + # compute the days of all the sheets together, not sheet by sheet + self._stats_through_today().mapped("gap_hours") for sheet in self: sheet.timesheet_sheet_gap_hours = sheet._get_timesheet_sheet_gap_hours() sheet.timesheet_sheet_recovery_hours = sheet._get_timesheet_sheet_recovery_hours() + def _stats_through_today(self): + today = fields.Date.today() + return self.mapped("employee_stats_ids").filtered(lambda stat: stat.date <= today) + def _get_timesheet_sheet_gap_hours(self): self.ensure_one() - timesheet_sheet_gap_hours = sum( - self.employee_stats_ids.filtered( - lambda stat: stat.date <= fields.Date.today() - ).mapped("gap_hours") - ) - return timesheet_sheet_gap_hours + return sum(self._stats_through_today().mapped("gap_hours")) def _get_timesheet_sheet_recovery_hours(self): self.ensure_one() diff --git a/hr_employee_stats_sheet/tests/test_employee_stats.py b/hr_employee_stats_sheet/tests/test_employee_stats.py index 9c6c0fd..2f8964b 100644 --- a/hr_employee_stats_sheet/tests/test_employee_stats.py +++ b/hr_employee_stats_sheet/tests/test_employee_stats.py @@ -489,6 +489,21 @@ class TestHrEmployeeStatsRecovery(TransactionCase): self._count_queries(days[:2], fnames)) self.assertEqual(days.mapped('total_hours'), [3] * 14) + def test_query_count_does_not_grow_with_sheets(self): + start = Date.to_date("2025-03-03") + self.env['hr.employee.calendar'].create({ + 'employee_id': self.employee.id, + 'date_start': start, + 'calendar_id': self.base_calendar.id, + }) + sheets = self.env['hr_timesheet.sheet'].concat(*( + self._create_timesheet_sheet(start + timedelta(weeks=week)) for week in range(6) + )) + fnames = ['timesheet_sheet_gap_hours', 'timesheet_sheet_recovery_hours'] + self.assertLessEqual(self._count_queries(sheets, fnames), + self._count_queries(sheets[:2], fnames)) + self.assertEqual(sheets.mapped('timesheet_sheet_gap_hours'), [-35] * 6) + def test_public_holidays_read_together(self): # Stored in UTC, this holiday is May 1st 00:00 to May 2nd 01:00 in # Paris. A day counts only if it is in the UTC range AND in the -- 2.49.1