# Part of Odoo. See LICENSE file for full copyright and licensing details. # Copyright (c) 2005-2006 Axelor SARL. (http://www.axelor.com) from collections import defaultdict from datetime import timedelta from itertools import groupby from pytz import timezone, utc from odoo import api, models, _ from odoo.tools import format_time from odoo.tools.misc import get_lang def convert_time_to_string(env, time, time_format='medium'): lang_time_string = time.strftime(get_lang(env).time_format) lang_time = time.strptime(lang_time_string, get_lang(env).time_format) return format_time(env, lang_time, tz=timezone(env.user.tz or 'UTC'), time_format=time_format) def format_date(env, date): return date.strftime(get_lang(env).date_format) class HrLeave(models.Model): _inherit = "hr.leave" @api.model def _get_leave_interval(self, date_from, date_to, employee_ids): # Validated hr.leave create a resource.calendar.leaves calendar_leaves = self.env['resource.calendar.leaves'].search([ ('time_type', '=', 'leave'), '|', ('company_id', 'in', employee_ids.mapped('company_id').ids), ('company_id', '=', False), '|', ('resource_id', 'in', employee_ids.mapped('resource_id').ids), ('resource_id', '=', False), ('date_from', '<', date_to), ('date_to', '>', date_from), ], order='date_from') leaves = defaultdict(list) for leave in calendar_leaves: for employee in employee_ids: if (not leave.company_id or leave.company_id == employee.company_id) and\ (not leave.resource_id or leave.resource_id == employee.resource_id) and\ (not leave.calendar_id or leave.calendar_id == employee.resource_calendar_id): leaves[employee.id].append(leave) # Get non-validated time off leaves_query = self.env['hr.leave'].search([ ('employee_id', 'in', employee_ids.ids), ('state', 'in', ['confirm', 'validate1']), ('date_from', '<=', date_to), ('date_to', '>=', date_from) ], order='date_from') for leave in leaves_query: leaves[leave.employee_id.id].append(leave) return leaves def _get_leave_warning_parameters(self, leaves, employee, date_from, date_to): loc_cache = {} def localize(date): if date not in loc_cache: loc_cache[date] = utc.localize(date).astimezone(timezone(self.env.user.tz or 'UTC')).replace(tzinfo=None) return loc_cache[date] periods = self._group_leaves(leaves, employee, date_from, date_to) periods_by_states = [list(b) for a, b in groupby(periods, key=lambda x: x['is_validated'])] res = {} for periods in periods_by_states: leaves_for_employee = {'name': employee.name, "leaves": []} for period in periods: dfrom = period['from'] dto = period['to'] number_of_days = period['number_of_days'] if number_of_days == 1: leaves_for_employee['leaves'].append({ "start_date": format_date(self.env, localize(dfrom)), }) elif number_of_days < 1: leaves_for_employee['leaves'].append({ "start_date": format_date(self.env, localize(dfrom)), "start_time": convert_time_to_string(self.env, localize(dfrom), 'short'), "end_time": convert_time_to_string(self.env, localize(dto), 'short') }) else: leaves_for_employee['leaves'].append({ "start_date": format_date(self.env, localize(dfrom)), "end_date": format_date(self.env, localize(dto)), }) res["validated" if periods[0].get('is_validated') else "requested"] = leaves_for_employee return res def format_date_range_to_string(self, date_dict): if len(date_dict) == 3: return _('on %(start_date)s from %(start_time)s to %(end_time)s', **date_dict) elif len(date_dict) == 2: return _('from %(start_date)s to %(end_date)s', **date_dict) else: return _('on %(start_date)s', **date_dict) def _get_leave_warning(self, leaves, employee, date_from, date_to): leaves_parameters = self._get_leave_warning_parameters(leaves, employee, date_from, date_to) warning = '' for leave_type, leaves_for_employee in leaves_parameters.items(): if not leaves_for_employee: continue if leave_type == "validated": warning += _( '%(name)s is on time off %(leaves)s. \n', name=leaves_for_employee["name"], leaves=', '.join(map(self.format_date_range_to_string, leaves_for_employee["leaves"])) ) else: warning += _( '%(name)s requested time off %(leaves)s. \n', name=leaves_for_employee["name"], leaves=', '.join(map(self.format_date_range_to_string, leaves_for_employee["leaves"])) ) return warning def _group_leaves(self, leaves, employee_id, date_from, date_to): """ Returns all the leaves happening between `planned_date_begin` and `date_deadline` """ work_times = {wk[0]: wk[1] for wk in employee_id._list_work_time_per_day(date_from, date_to)[employee_id.id]} def has_working_hours(start_dt, end_dt): """ Returns `True` if there are any working days between `start_dt` and `end_dt`. """ diff_days = (end_dt - start_dt).days all_dates = [start_dt.date() + timedelta(days=delta) for delta in range(diff_days + 1)] return any(d in work_times for d in all_dates) periods = [] for leave in leaves: if leave.date_from > date_to or leave.date_to < date_from: continue # Can handle both hr.leave and resource.calendar.leaves number_of_days = 0 is_validated = True if isinstance(leave, self.pool['hr.leave']): number_of_days = leave.number_of_days is_validated = False else: dt_delta = (leave.date_to - leave.date_from) if leave.holiday_id and not (leave.holiday_id.sudo().request_unit_half or leave.holiday_id.sudo().request_unit_hours): number_of_days = dt_delta.days + 1 else: number_of_days = dt_delta.days + ((dt_delta.seconds / 3600) / 24) # leaves are ordered by date_from and grouped by type. When go from the batch of validated time offs to the # requested ones, we need to bypass the second condition with the third one if not periods or has_working_hours(periods[-1]['from'], leave.date_to) or \ periods[-1]['is_validated'] != is_validated: periods.append({'is_validated': is_validated, 'from': leave.date_from, 'to': leave.date_to, 'number_of_days': number_of_days}) else: periods[-1]['is_validated'] = is_validated if periods[-1]['to'] < leave.date_to: periods[-1]['to'] = leave.date_to periods[-1]['number_of_days'] = periods[-1].get('number_of_days') or number_of_days return periods @api.model def _gantt_unavailability(self, field, res_ids, start, stop, scale): if field != "employee_id": return super()._gantt_unavailability(field, res_ids, start, stop, scale) employees = self.env['hr.employee'].browse(res_ids) return employees._get_employee_unavailable_intervals(start, stop) def tag_employee_rows(rows): """ Add `employee_id` key in rows and subsrows recursively if necessary :return: a set of ids with all concerned employees (subrows included) """ employee_ids = set() for row in rows: group_bys = row.get('groupedBy') res_id = row.get('resId') if group_bys: # if employee_id is the first grouping attribute, we mark the row if group_bys[0] == 'employee_id' and res_id: employee_id = res_id employee_ids.add(employee_id) row['employee_id'] = employee_id # else we recursively traverse the rows where employee_id appears in the group_by elif 'employee_id' in group_bys: employee_ids.update(tag_employee_rows(row.get('rows'))) return employee_ids # function to recursively replace subrows with the ones returned by func def traverse(func, row): new_row = dict(row) if new_row.get('employee_id'): for sub_row in new_row.get('rows'): sub_row['employee_id'] = new_row['employee_id'] new_row['rows'] = [traverse(func, row) for row in new_row.get('rows')] return func(new_row)