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 4071de9..6b08b22 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,102 +80,124 @@ 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 _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 - 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): @@ -168,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.""" @@ -186,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: @@ -230,11 +285,14 @@ 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() + planned_hours = self._planned_hours_by_stat() + absence_hours = self._absence_hours_by_stat(planned_hours) for stat in self: - total_hours = stat._get_total_hours() - total_planned_hours = stat._get_total_planned_hours() - total_recovery_hours = stat._get_total_recovery_hours() - total_leave_hours = stat._get_total_leave_hours() + total_hours = hours.get(stat, 0) + total_planned_hours = planned_hours.get(stat, 0) + 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/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 f65066e..2f8964b 100644 --- a/hr_employee_stats_sheet/tests/test_employee_stats.py +++ b/hr_employee_stats_sheet/tests/test_employee_stats.py @@ -455,6 +455,104 @@ 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 _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_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 + # 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', + '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): @@ -671,6 +769,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]) +