Files
hr-tools/l10n_fr_hr_holidays/models/hr_leave.py
Laetitia Da Costa ef3c9143dd [REF]l10n_fr_hr_holidays:clean up leave days computation
- remove unused _round_to_nearest_half
- evaluate _l10n_fr_leave_applies once in _get_number_of_days_batch and
  count working dates without a day-by-day loop
- compute the calendar working hours once per date lookup loop
- move pytz import to the top of resource_calendar.py

No functional change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 10:46:57 +00:00

292 lines
16 KiB
Python

# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
from datetime import datetime, time
from dateutil.relativedelta import relativedelta
from pytz import timezone, UTC
from odoo import fields, models, _, api
from odoo.exceptions import UserError
class HrLeave(models.Model):
_inherit = 'hr.leave'
resource_calendar_id = fields.Many2one('resource.calendar', compute='_compute_resource_calendar_id', store=True, readonly=False, copy=False)
l10n_fr_date_to_changed = fields.Boolean()
@api.depends(
'holiday_type',
'employee_id',
'employee_id.resource_calendar_id',
'request_date_from',
'request_date_to',
)
def _compute_resource_calendar_id(self):
for leave in self:
calendar = False
if leave.holiday_type == 'employee':
calendar = leave.employee_id.resource_calendar_id
# YTI: Crappy hack: Move this to a new dedicated hr_holidays_contract module
# We use the request dates to find the contracts, because date_from
# and date_to are not set yet at this point. Since these dates are
# used to get the contracts for which these leaves apply and
# contract start- and end-dates are just dates (and not datetimes)
# these dates are comparable.
if 'hr.contract' in self.env and leave.employee_id:
contracts = self.env['hr.contract'].search([
'|', ('state', 'in', ['open', 'close']),
'&', ('state', '=', 'draft'),
('kanban_state', '=', 'done'),
('employee_id', '=', leave.employee_id.id),
('date_start', '<=', leave.request_date_to),
'|', ('date_end', '=', False),
('date_end', '>=', leave.request_date_from),
])
if contracts:
# If there are more than one contract they should all have the
# same calendar, otherwise a constraint is violated.
calendar = contracts[:1].resource_calendar_id
# Crappy hack again : if hr_employee_calendar_planning is installed
# use planning calendar instead of contract calendar
if 'hr.employee.calendar' in self.env:
calendar_planning = self.env["hr.employee.calendar"].search(
[
("employee_id", "=", leave.employee_id.id),
("date_start", "<=", leave.request_date_to),
"|", ("date_end", "=", False), # pas de date de fin OU
("date_end", ">=", leave.request_date_from), # date de fin après le début
],
limit=1,
)
if calendar_planning:
calendar = calendar_planning.calendar_id
elif leave.holiday_type == 'department':
calendar = leave.department_id.company_id.resource_calendar_id
elif leave.holiday_type == 'company':
calendar = leave.mode_company_id.resource_calendar_id
leave.resource_calendar_id = calendar or self.env.company.resource_calendar_id
def _l10n_fr_leave_applies(self):
# The french l10n is meant to be computed only in very specific cases:
# - there is only one employee affected by the leave
# - the company is french
# - the leave_type is the reference leave_type of that company
self.ensure_one()
return self.employee_id and \
self.employee_company_id.country_id.code == 'FR' and \
self.resource_calendar_id != self.employee_company_id.resource_calendar_id and \
self.holiday_status_id == self.employee_company_id._get_fr_reference_leave_type()
def _l10n_fr_is_public_holiday(self, date):
"""Return True if `date` is fully covered by a global leave (public
holiday) registered on the employee calendar, the company calendar or
on no calendar at all."""
self.ensure_one()
calendar = self.resource_calendar_id
company_calendar = self.employee_company_id.resource_calendar_id
tz = timezone(calendar.tz or company_calendar.tz or 'UTC')
day_start = tz.localize(datetime.combine(date, time.min)).astimezone(UTC).replace(tzinfo=None)
day_end = tz.localize(datetime.combine(date, time.max)).astimezone(UTC).replace(tzinfo=None)
calendar_ids = [False] + (calendar | company_calendar).ids
holidays = self.env['resource.calendar.leaves'].sudo().search([
('resource_id', '=', False),
('time_type', '=', 'leave'),
('calendar_id', 'in', calendar_ids),
('date_from', '<=', day_end),
('date_to', '>=', day_start),
])
if not holidays:
return False
# The holiday must cover all the employee attendances of that day
attendance_intervals = calendar._attendance_intervals_batch(
tz.localize(datetime.combine(date, time.min)),
tz.localize(datetime.combine(date, time.max)),
)[False]
for start, stop, _meta in attendance_intervals:
start_utc = start.astimezone(UTC).replace(tzinfo=None)
stop_utc = stop.astimezone(UTC).replace(tzinfo=None)
if not any(h.date_from <= start_utc and h.date_to >= stop_utc for h in holidays):
return False
return True
def _l10n_fr_employee_works_on_date(self, date, working_days=None):
"""Return True if the employee actually works on `date`: the day is a
working day in their calendar and is not a public holiday."""
self.ensure_one()
return (self.resource_calendar_id._works_on_date(date, working_days)
and not self._l10n_fr_is_public_holiday(date))
def _get_fr_date_from_to(self, date_from, date_to):
self.ensure_one()
# What we need to compute is how much we will need to push date_to in order to account for the lost days
# This gets even more complicated in two_weeks_calendars
# The following computation doesn't work for resource calendars in
# which the employee works zero hours.
if not (self.resource_calendar_id.attendance_ids):
raise UserError(_("An employee cannot take a paid time off in a period they work no hours."))
calendar = self.resource_calendar_id
working_days = calendar._get_working_hours()
if self.request_unit_half and self.request_date_from_period == 'am':
# In normal workflows request_unit_half implies that date_from and date_to are the same
# request_unit_half allows us to choose between `am` and `pm`
# In a case where we work from mon-wed and request a half day in the morning
# we do not want to push date_to since the next work attendance is actually in the afternoon
date_from_weektype = str(self.env['resource.calendar.attendance'].get_week_type(date_from))
date_from_dayofweek = str(date_from.weekday())
# Get morning and afternoon attendances for that day
attendances_am = self.resource_calendar_id.attendance_ids.filtered(lambda a:
a.dayofweek == date_from_dayofweek
and a.day_period == 'morning'
and (not self.resource_calendar_id.two_weeks_calendar or a.week_type == date_from_weektype))
attendances_pm = self.resource_calendar_id.attendance_ids.filtered(lambda a:
a.dayofweek == date_from_dayofweek
and a.day_period == 'afternoon'
and (not self.resource_calendar_id.two_weeks_calendar or a.week_type == date_from_weektype))
if attendances_am and not attendances_pm:
# If the employee does not work in the afternoon, postpone date_to to the next working day
next_date = date_from + relativedelta(days=1)
while not self._l10n_fr_employee_works_on_date(next_date, working_days):
next_date += relativedelta(days=1)
return (date_from, next_date)
elif attendances_am and attendances_pm:
# The employee also works in the afternoon, no postponement
return (date_from, date_to)
# Special handling for two-weeks calendars
if self.resource_calendar_id.two_weeks_calendar:
# Count the number of days actually worked by the employee between date_from and date_to
current_date = date_from
days_count = 0
while current_date <= date_to:
if calendar._works_on_date(current_date, working_days):
days_count += 1
current_date += relativedelta(days=1)
# Adjust date_to so it matches the expected number of days
# If the expected number of days is less than the period, reduce date_to
if days_count > 0:
# Find the date_to that gives the right number of worked days
current_date = date_from
counted = 0
while counted < days_count:
if calendar._works_on_date(current_date, working_days):
counted += 1
if counted == days_count:
break
current_date += relativedelta(days=1)
return (date_from, current_date)
# Check calendars for working days until we find the right target, start at date_to + 1 day
# Postpone date_target until the next working day
date_start = date_from
date_target = date_to
# It is necessary to move the start date up to the first work day of
# the employee calendar as otherwise days worked on by the company
# calendar before the actual start of the leave would be taken into
# account.
while not calendar._works_on_date(date_start, working_days):
date_start += relativedelta(days=1)
# Public holidays are skipped too: if the employee's next scheduled
# working day is a public holiday, they only come back on the following
# actual working day, so the leave must cover the days in between.
while not self._l10n_fr_employee_works_on_date(date_target + relativedelta(days=1), working_days):
date_target += relativedelta(days=1)
# Undo the last day increment
return (date_start, date_target)
def _compute_date_from_to(self):
super()._compute_date_from_to()
for leave in self:
if leave._l10n_fr_leave_applies():
new_date_from, new_date_to = leave._get_fr_date_from_to(leave.date_from, leave.date_to)
if new_date_from != leave.date_from:
leave.date_from = new_date_from
if new_date_to != leave.date_to:
leave.date_to = new_date_to
leave.l10n_fr_date_to_changed = True
else:
leave.l10n_fr_date_to_changed = False
#@overwrite
def _get_calendar(self):
"""
In France, paid time off for part-time employees is counted on the company's working days (not the employee's own schedule).
The company's calendar must be used for the legal leave day count.
"""
self.ensure_one()
if self._l10n_fr_leave_applies():
return self.employee_company_id.resource_calendar_id or self.env.company.resource_calendar_id
return super()._get_calendar()
#@overwrite
def _get_number_of_days_batch(self, date_from, date_to, employee_ids):
"""
Returns a dict with the number of legal leave days for each employee.
In France, part-time employees' leave is counted in company working days
(jours ouvrables) from the first day of absence to the return day
(exclusive). The absence period is determined by the employee's calendar,
but the day count uses the company's calendar. Public holidays and other
global leaves registered on the company calendar are excluded.
For half-day requests, the first day counts as 0.5 if the employee
works the other half of that day (returns same day), or 1 otherwise.
"""
employee = self.env['hr.employee'].browse(employee_ids)
# Force the company in the domain, as we are likely in a compute_sudo context
domain = [
('time_type', '=', 'leave'),
('company_id', 'in', self.env.company.ids + self.env.context.get('allowed_company_ids', []))
]
calendar = self._get_calendar()
result = employee._get_work_days_data_batch(date_from, date_to, calendar=calendar, domain=domain)
l10n_fr_applies = self._l10n_fr_leave_applies()
for employee_id in result:
if l10n_fr_applies:
company_calendar = calendar
employee_calendar = self.resource_calendar_id
first_day = date_from.date()
last_date = date_to.date()
# _get_fr_date_from_to returns date_to with different semantics:
# - AM half-day, employee doesn't work PM: date_to = return day
# (must be excluded from the count)
# - AM half-day, employee works PM: date_to = same day (leave day)
# - General case (full-day, PM half-day): date_to = last leave day
# (day before the return, must be included)
# Only the first case has date_to as the return day. It is
# detected by: AM half-day, date_to strictly after date_from.
if (self.request_unit_half and self.request_date_from_period == 'am'
and last_date > first_day):
last_date -= relativedelta(days=1)
# Get the set of dates where the company actually works between
# first_day and last_date, excluding public holidays (global leaves).
# Don't pass the company_id-filtered domain here: the leave is
# already matched by calendar_id in _leave_intervals_batch, and
# the company_id filter would exclude holidays created on the
# french company when self.env.company is the main company.
working_dates = company_calendar._get_working_dates(first_day, last_date)
if self.request_unit_half:
# Check if the employee works the other half of the first day
dayofweek = str(first_day.weekday())
other_period = 'afternoon' if self.request_date_from_period == 'am' else 'morning'
other_half = employee_calendar.attendance_ids.filtered(
lambda a: a.dayofweek == dayofweek and a.day_period == other_period
)
if first_day in working_dates:
days_count = 0.5 if other_half else 1.0
else:
days_count = 0.0
current_date = first_day + relativedelta(days=1)
else:
days_count = 0.0
current_date = first_day
days_count += sum(1 for d in working_dates if current_date <= d <= last_date)
result[employee_id]['days'] = float(days_count)
elif self.request_unit_half and result[employee_id]['hours'] > 0:
# Non-French context: a half-day leave always counts as 0.5 day
result[employee_id]['days'] = 0.5
return result