audrius/suite
1
0
Fork 1
mirror of https://gitlab.com/hibou-io/hibou-odoo/suite.git synced 2025-01-20 12:37:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'mig/15.0/hr_payroll_overtime' into '15.0-test'

Browse Source 
mig/15.0/hr_payroll_overtime into 15.0-test

See merge request hibou-io/hibou-odoo/suite!1117
This commit is contained in:
Hibou Bot
2021-10-07 16:29:39 +00:00
parent 0a048db3b9 a2dc4999cd
commit cab74b5c8d
15 changed files with 1004 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
hr_payroll_overtime/__init__.py Normal file
View File

@@ -0,0 +1 @@
from . import models

22
hr_payroll_overtime/__manifest__.py Normal file
View File

@@ -0,0 +1,22 @@
{
'name': 'Payroll Overtime',
'description': 'Provide mechanisms to calculate overtime.',
'version': '15.0.1.0.0',
'website': 'https://hibou.io/',
'author': 'Hibou Corp. <hello@hibou.io>',
'license': 'AGPL-3',
'category': 'Human Resources',
'data': [
'security/ir.model.access.csv',
'data/overtime_data.xml',
'views/hr_contract_views.xml',
'views/hr_payslip_views.xml',
'views/hr_work_entry_views.xml',
'views/resource_calendar_views.xml',
],
'depends': [
'hr_payroll_hibou',
'hr_work_entry',
'hr_work_entry_contract_enterprise', # only for menu!
],
}

12
hr_payroll_overtime/data/overtime_data.xml Normal file
View File

@@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8" ?>
<odoo>
<data noupdate="1">
<record id="work_entry_overtime_type" model="hr.work.entry.overtime.type">
<field name="name">Default Rules</field>
<field name="hours_per_week">40.0</field>
<field name="multiplier">1.5</field>
</record>
</data>
</odoo>

4
hr_payroll_overtime/models/__init__.py Normal file
View File

@@ -0,0 +1,4 @@
from . import hr_contract
from . import hr_payslip
from . import hr_work_entry
from . import resource_calendar

8
hr_payroll_overtime/models/hr_contract.py Normal file
View File

@@ -0,0 +1,8 @@
from odoo import fields, models
class HrContract(models.Model):
_inherit = 'hr.contract'
is_overtime_exempt = fields.Boolean(string='Overtime Exempt',
help='e.g. Agriculture or farm work exempt under the US FLSA.')

174
hr_payroll_overtime/models/hr_payslip.py Normal file
View File

@@ -0,0 +1,174 @@
from collections import defaultdict
from odoo import api, fields, models
from odoo.exceptions import UserError
class HRPayslip(models.Model):
_inherit = 'hr.payslip'
def _get_worked_day_lines_values(self, domain=None):
worked_day_lines_values = super()._get_worked_day_lines_values(domain=domain)
return self._process_worked_day_lines_values(worked_day_lines_values, domaian=domain)
def _process_worked_day_lines_values(self, worked_day_lines_values, domaian=None):
if not self.state in ('draft', 'verify'):
return worked_day_lines_values
worked_day_lines_values = self._filter_worked_day_lines_values(worked_day_lines_values)
work_data = self._pre_aggregate_work_data()
work_data = self._post_aggregate_work_data(work_data)
processed_data = self._aggregate_overtime(work_data)
worked_day_lines_values += [{
'number_of_days': data[0],
'number_of_hours': data[1],
'rate': data[2],
'contract_id': self.contract_id.id,
'work_entry_type_id': work_type.id,
} for work_type, data in processed_data.items()]
return worked_day_lines_values
def _filter_worked_day_lines_values(self, worked_day_lines_values):
# e.g. maybe you want to remove the stock 'WORK100' lines
# returns new worked_day_lines_values
return worked_day_lines_values
def _pre_aggregate_work_data(self):
# returns dict(iso_date: list(tuple(hr.work.entry.type(), hours, original_record))
return defaultdict(list)
def _post_aggregate_work_data(self, work_data):
# takes pre_aggregate data format and converts it.
# this is to simplify algorithm and guarantee ordered by iso_date semantics
# work_data: dict(iso_date: list(tuple(hr.work.entry.type(), hours, original_record))
# returns: list(tuple(iso_date, list(tuple(hr.work.entry.type(), hours, original_record))
return [(iso_date, work_data[iso_date]) for iso_date in sorted(work_data.keys())]
def _aggregate_overtime(self, work_data, day_week_start=None):
"""
:param work_data: list(tuple(iso_date, list(tuple(hr.work.entry.type(), hours, original_record))
:param day_week_start: day of the week to start (otherwise employee's resource calendar start day of week)
:return: dict(hr.work.entry.type(): list(days_worked, hours_worked, rate))
"""
if not day_week_start:
if self.employee_id.resource_calendar_id.day_week_start:
day_week_start = self.employee_id.resource_calendar_id.day_week_start
else:
day_week_start = '1'
day_week_start = int(day_week_start)
if day_week_start < 1 or day_week_start > 7:
day_week_start = 1
def _adjust_week(isodate):
if isodate[2] < day_week_start:
return (isodate[0], isodate[1] + 1, isodate[2])
return isodate
result = defaultdict(lambda: [0.0, 0.0, 1.0])
day_hours = defaultdict(float)
week_hours = defaultdict(float)
iso_days = set()
try:
for iso_date, entries in work_data:
iso_date = _adjust_week(iso_date)
for work_type, hours, _ in entries:
self._aggregate_overtime_add_work_type_hours(work_type, hours, iso_date, result, iso_days, day_hours, week_hours)
except RecursionError:
raise UserError('RecursionError raised. Ensure you have not overtime loops, you should have an '
'end work type that does not have any "overtime" version, and would be considered '
'the "highest overtime" work type and rate.')
return result
def _aggregate_overtime_add_work_type_hours(self, work_type, hours, iso_date, working_aggregation, iso_days, day_hours, week_hours):
"""
:param work_type: work type of hours being added
:param hours: hours being added
:param iso_date: date hours were worked
:param working_aggregation: dict of work type hours as they are processed
:param iso_days: set of iso days already seen
:param day_hours: hours worked on iso dates already processed
:param week_hours: hours worked on iso week already processed
:return:
"""
override = work_type.override_for_iso_date(iso_date)
if override:
new_work_type = override.work_type_id
multiplier = override.multiplier
if work_type == new_work_type:
# trivial infinite recursion from override
raise UserError('Work type "%s" (id %s) must not have itself as its override work type. '
'This occurred due to an override line "%s".' % (
work_type.name, work_type.id, override.name))
# update the work_type on this step.
work_type = new_work_type
working_aggregation[work_type][2] = multiplier
week = iso_date[1]
if not self.contract_id.is_overtime_exempt and work_type.overtime_work_type_id and work_type.overtime_type_id:
ot_h_w = work_type.overtime_type_id.hours_per_week
ot_h_d = work_type.overtime_type_id.hours_per_day
regular_hours = hours
# adjust the hours based on overtime conditions
if ot_h_d and (day_hours[iso_date] + hours) > ot_h_d:
# daily overtime in effect
remaining_hours = max(ot_h_d - day_hours[iso_date], 0.0)
regular_hours = min(remaining_hours, hours)
elif ot_h_w:
# not daily, but weekly limits....
remaining_hours = max(ot_h_w - week_hours[week], 0.0)
regular_hours = min(remaining_hours, hours)
ot_hours = hours - regular_hours
if regular_hours:
if iso_date not in iso_days:
iso_days.add(iso_date)
working_aggregation[work_type][0] += 1.0
working_aggregation[work_type][1] += regular_hours
day_hours[iso_date] += regular_hours
week_hours[week] += regular_hours
if ot_hours:
overtime_work_type = work_type.overtime_work_type_id
multiplier = work_type.overtime_type_id.multiplier
override = work_type.overtime_type_id.override_for_iso_date(iso_date)
if work_type == overtime_work_type:
# trivial infinite recursion
raise UserError('Work type "%s" (id %s) must not have itself as its next overtime type.' % (work_type.name, work_type.id))
if override:
overtime_work_type = override.work_type_id
multiplier = override.multiplier
if work_type == overtime_work_type:
# trivial infinite recursion from override
raise UserError('Work type "%s" (id %s) must not have itself as its next overtime type. '
'This occurred due to an override "%s" from overtime rules "%s".' % (
work_type.name, work_type.id, override.name, work_type.overtime_type_id.name))
# we need to save this because it won't be set once it reenter, we won't know what the original
# overtime multiplier was
working_aggregation[overtime_work_type][2] = multiplier
self._aggregate_overtime_add_work_type_hours(overtime_work_type, ot_hours, iso_date,
working_aggregation, iso_days, day_hours, week_hours)
else:
# No overtime, just needs added to set
if iso_date not in iso_days:
iso_days.add(iso_date)
working_aggregation[work_type][0] += 1.0
working_aggregation[work_type][1] += hours
day_hours[iso_date] += hours
week_hours[week] += hours
class HrPayslipWorkedDays(models.Model):
_inherit = 'hr.payslip.worked_days'
rate = fields.Float(string='Rate', default=1.0)
@api.depends('is_paid', 'number_of_hours', 'payslip_id', 'payslip_id.normal_wage', 'payslip_id.sum_worked_hours', 'rate')
def _compute_amount(self):
for worked_days in self:
if not worked_days.contract_id:
worked_days.amount = 0
continue
if worked_days.payslip_id.wage_type == "hourly":
worked_days.amount = worked_days.payslip_id.contract_id._get_contract_wage(work_type=worked_days.work_entry_type_id) * worked_days.number_of_hours * worked_days.rate if worked_days.is_paid else 0
else:
worked_days.amount = worked_days.payslip_id.normal_wage * worked_days.number_of_hours / (worked_days.payslip_id.sum_worked_hours or 1) if worked_days.is_paid else 0

79
hr_payroll_overtime/models/hr_work_entry.py Normal file
View File

@@ -0,0 +1,79 @@
from odoo import api, fields, models
from odoo.exceptions import ValidationError
from .resource_calendar import WEEKDAY_SELECTION
class WorkEntryOverride(models.AbstractModel):
_name = 'hr.work.entry.type.override.abstract'
_order = 'date desc, day_of_week'
name = fields.Char(string='Description')
work_type_id = fields.Many2one('hr.work.entry.type', string='Override Work Type', required=True,
help='Distinct Work Type for when this applies.')
multiplier = fields.Float(string='Multiplier',
help='Rate for override. E.g. maybe you have "Sunday Pay" at 2.0x')
day_of_week = fields.Selection(WEEKDAY_SELECTION, string='Day of Week')
date = fields.Date(string='Date')
@api.constrains('day_of_week', 'date')
def _constrain_days(self):
for override in self:
if override.day_of_week and override.date:
raise ValidationError('An override should only have a Date OR Day of Week.')
def iso_date_applies(self, iso_date):
for override in self:
if override.date and override.date.isocalendar() == iso_date:
return override
if int(override.day_of_week) == iso_date[2]:
return override
class HRWorkEntryType(models.Model):
_inherit = 'hr.work.entry.type'
overtime_work_type_id = fields.Many2one('hr.work.entry.type', string='Overtime Work Type')
overtime_type_id = fields.Many2one('hr.work.entry.overtime.type', string='Overtime Rules')
override_ids = fields.One2many('hr.work.entry.type.override', 'original_type_id', string='Overrides',
help='Override work entry type on payslip.')
def override_for_iso_date(self, iso_date):
return self.override_ids.iso_date_applies(iso_date)
class HRWorkEntryTypeOverride(models.Model):
_name = 'hr.work.entry.type.override'
_inherit = 'hr.work.entry.type.override.abstract'
_description = 'Work Type Override'
original_type_id = fields.Many2one('hr.work.entry.type',
string='Work Entry Type')
class HRWorkEntryOvertime(models.Model):
_name = 'hr.work.entry.overtime.type'
_description = 'Overtime Rules'
name = fields.Char(string='Name')
hours_per_day = fields.Float(string='Hours/Day',
help='Number of hours worked in a single day to trigger overtime.')
hours_per_week = fields.Float(string='Hours/Week',
help='Number of hours worked in a week to trigger overtime.')
multiplier = fields.Float(string='Multiplier',
help='Rate for when overtime is reached.')
override_ids = fields.One2many('hr.work.entry.overtime.type.override', 'overtime_type_id',
string='Overrides',
help='Override lines with a Date will be considered before Day of Week.')
def override_for_iso_date(self, iso_date):
return self.override_ids.iso_date_applies(iso_date)
class HRWorkEntryOvertimeOverride(models.Model):
_name = 'hr.work.entry.overtime.type.override'
_inherit = 'hr.work.entry.type.override.abstract'
_description = 'Overtime Rule Override'
overtime_type_id = fields.Many2one('hr.work.entry.overtime.type',
string='Overtime Rules')

18
hr_payroll_overtime/models/resource_calendar.py Normal file
View File

@@ -0,0 +1,18 @@
from odoo import fields, models
WEEKDAY_SELECTION = [
('1', 'Monday'),
('2', 'Tuesday'),
('3', 'Wednesday'),
('4', 'Thursday'),
('5', 'Friday'),
('6', 'Saturday'),
('7', 'Sunday'),
]
class ResourceCalendar(models.Model):
_inherit = 'resource.calendar'
day_week_start = fields.Selection(WEEKDAY_SELECTION, string='Day Week Starts', required=True, default='1')

7
hr_payroll_overtime/security/ir.model.access.csv Normal file
View File

@@ -0,0 +1,7 @@
id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
access_hr_work_entry_overtime_type,access_hr_work_entry_overtime_type,model_hr_work_entry_overtime_type,base.group_user,1,0,0,0
manage_hr_work_entry_overtime_type,manage_hr_work_entry_overtime_type,model_hr_work_entry_overtime_type,hr_payroll.group_hr_payroll_manager,1,1,1,1
access_hr_work_entry_overtime_type_override,access_hr_work_entry_overtime_type_override,model_hr_work_entry_overtime_type_override,base.group_user,1,0,0,0
manage_hr_work_entry_overtime_type_override,manage_hr_work_entry_overtime_type_override,model_hr_work_entry_overtime_type_override,hr_payroll.group_hr_payroll_manager,1,1,1,1
access_hr_work_entry_type_override,access_hr_work_entry_type_override,model_hr_work_entry_type_override,base.group_user,1,0,0,0
manage_hr_work_entry_type_override,manage_hr_work_entry_type_override,model_hr_work_entry_type_override,hr_payroll.group_hr_payroll_manager,1,1,1,1
1 id name model_id:id group_id:id perm_read perm_write perm_create perm_unlink
2 access_hr_work_entry_overtime_type access_hr_work_entry_overtime_type model_hr_work_entry_overtime_type base.group_user 1 0 0 0
3 manage_hr_work_entry_overtime_type manage_hr_work_entry_overtime_type model_hr_work_entry_overtime_type hr_payroll.group_hr_payroll_manager 1 1 1 1
4 access_hr_work_entry_overtime_type_override access_hr_work_entry_overtime_type_override model_hr_work_entry_overtime_type_override base.group_user 1 0 0 0
5 manage_hr_work_entry_overtime_type_override manage_hr_work_entry_overtime_type_override model_hr_work_entry_overtime_type_override hr_payroll.group_hr_payroll_manager 1 1 1 1
6 access_hr_work_entry_type_override access_hr_work_entry_type_override model_hr_work_entry_type_override base.group_user 1 0 0 0
7 manage_hr_work_entry_type_override manage_hr_work_entry_type_override model_hr_work_entry_type_override hr_payroll.group_hr_payroll_manager 1 1 1 1

1
hr_payroll_overtime/tests/__init__.py Normal file
View File

@@ -0,0 +1 @@
from . import test_overtime

527
hr_payroll_overtime/tests/test_overtime.py Normal file
View File

@@ -0,0 +1,527 @@
from datetime import date
from odoo.tests import common
from odoo.exceptions import UserError, ValidationError
class TestOvertime(common.TransactionCase):
def setUp(self):
super().setUp()
self.overtime_rules = self.env['hr.work.entry.overtime.type'].create({
'name': 'Test',
'hours_per_week': 40.0,
'multiplier': 1.5,
})
self.work_type_overtime = self.env['hr.work.entry.type'].create({
'name': 'Test Overtime',
'code': 'TEST_OT'
})
self.work_type = self.env['hr.work.entry.type'].create({
'name': 'Test',
'code': 'TEST',
'overtime_type_id': self.overtime_rules.id,
'overtime_work_type_id': self.work_type_overtime.id,
})
self.employee = self.env.ref('hr.employee_hne')
self.contract = self.employee.contract_ids.create({
'name': 'testing contract',
'employee_id': self.employee.id,
'date_start': '2020-01-01',
'wage': 2000.0,
})
self.payslip = self.env['hr.payslip'].create({
'name': 'test slip',
'employee_id': self.employee.id,
'contract_id': self.contract.id,
'date_from': '2020-06-11',
'date_to': '2020-06-15',
})
def test_02_overtime_aggregation(self):
# 38 hours in 1 week
work_data = [
((2020, 24, 1), [
(self.work_type, 4.0, None),
(self.work_type, 4.0, None),
]),
((2020, 24, 2), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
((2020, 24, 3), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
((2020, 24, 4), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertTrue(self.work_type_overtime not in result_data)
self.assertEqual(result_data[self.work_type][0], 4)
self.assertEqual(result_data[self.work_type][1], 38.0)
# 48 hours in 1 week
work_data += [
((2020, 24, 5), [
(self.work_type, 10.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 5)
self.assertEqual(result_data[self.work_type][1], 40.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 8.0)
# 52 hours in 1 week
work_data += [
((2020, 24, 6), [
(self.work_type, 4.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 5)
self.assertEqual(result_data[self.work_type][1], 40.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 1)
self.assertEqual(result_data[self.work_type_overtime][1], 12.0)
# reset and make two weeks
# 38 hours in 1 week x 2
input_work_data = [
((2020, 24, 1), [
(self.work_type, 4.0, None),
(self.work_type, 4.0, None),
]),
((2020, 24, 2), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
((2020, 24, 3), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
((2020, 24, 4), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
work_data = []
for data in input_work_data:
work_data.append(data)
work_data.append(((data[0][0], data[0][1]+1, data[0][2]), data[1]))
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertTrue(self.work_type_overtime not in result_data)
self.assertEqual(result_data[self.work_type][0], 8)
self.assertEqual(result_data[self.work_type][1], 76.0)
# 48 hours in 1 week, 38 hours in 1 week
work_data += [
((2020, 24, 5), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 9)
self.assertEqual(result_data[self.work_type][1], 78.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 8.0)
# 52 hours in 1 week, 38 hours in 1 week
work_data += [
((2020, 24, 6), [
(self.work_type, 4.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 9)
self.assertEqual(result_data[self.work_type][1], 78.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 1)
self.assertEqual(result_data[self.work_type_overtime][1], 12.0)
def test_03_overtime_aggregation_week_start(self):
self.employee.resource_calendar_id.day_week_start = '7'
self.test_02_overtime_aggregation()
def test_10_overtime_aggregation_daily(self):
self.overtime_rules.hours_per_day = 8.0
self.overtime_rules.multiplier = 1.5
# 38 hours in 1 week
work_data = [
((2020, 24, 1), [
(self.work_type, 4.0, None),
(self.work_type, 4.0, None),
]),
((2020, 24, 2), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
((2020, 24, 3), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
((2020, 24, 4), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 4)
self.assertEqual(result_data[self.work_type][1], 32.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 6.0)
# 48 hours in 1 week
work_data += [
((2020, 24, 5), [
(self.work_type, 10.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 5)
self.assertEqual(result_data[self.work_type][1], 40.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 8.0)
# 52 hours in 1 week
work_data += [
((2020, 24, 6), [
(self.work_type, 4.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 5)
self.assertEqual(result_data[self.work_type][1], 40.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 1)
self.assertEqual(result_data[self.work_type_overtime][1], 12.0)
# reset and make two weeks
# 38 hours in 1 week x 2
input_work_data = [
((2020, 24, 1), [
(self.work_type, 4.0, None),
(self.work_type, 4.0, None),
]),
((2020, 24, 2), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
((2020, 24, 3), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
((2020, 24, 4), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
work_data = []
for data in input_work_data:
work_data.append(data)
work_data.append(((data[0][0], data[0][1]+1, data[0][2]), data[1]))
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type][0], 8)
self.assertEqual(result_data[self.work_type][1], 64.0)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 12.0)
# 48 hours in 1 week, 38 hours in 1 week
work_data += [
((2020, 24, 5), [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 9)
self.assertEqual(result_data[self.work_type][1], 70.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 16.0)
# 52 hours in 1 week, 38 hours in 1 week
work_data += [
((2020, 24, 6), [
(self.work_type, 4.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 9)
self.assertEqual(result_data[self.work_type][1], 70.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 1)
self.assertEqual(result_data[self.work_type_overtime][1], 20.0)
def test_11_overtime_aggregation_daily_week_start(self):
self.employee.resource_calendar_id.day_week_start = '7'
self.test_10_overtime_aggregation_daily()
def test_12_recursive_daily(self):
# recursive will use a second overtime
self.work_type_overtime2 = self.env['hr.work.entry.type'].create({
'name': 'Test Overtime 2',
'code': 'TEST_OT2'
})
self.overtime_rules2 = self.env['hr.work.entry.overtime.type'].create({
'name': 'Test2',
'hours_per_week': 999.0,
'hours_per_day': 12.0,
'multiplier': 2.0,
})
self.overtime_rules.hours_per_day = 8.0
self.overtime_rules.multiplier = 1.5
self.work_type_overtime.overtime_type_id = self.overtime_rules2
self.work_type_overtime.overtime_work_type_id = self.work_type_overtime2
work_data = [
((2020, 24, 1), [
# regular day
(self.work_type, 4.0, None),
(self.work_type, 4.0, None),
]),
((2020, 24, 2), [
# 2hr overtime
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
((2020, 24, 3), [
# 4hr overtime
(self.work_type, 6.0, None),
(self.work_type, 6.0, None),
]),
((2020, 24, 4), [
# 4hr overtime
# 2hr overtime2
(self.work_type, 6.0, None),
(self.work_type, 8.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 4)
self.assertEqual(result_data[self.work_type][1], 32.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 10.0)
self.assertTrue(self.work_type_overtime2 in result_data)
self.assertEqual(result_data[self.work_type_overtime2][0], 0)
self.assertEqual(result_data[self.work_type_overtime2][1], 2.0)
def test_13_recursive_infinite_trivial(self):
# recursive should will use a second overtime, but not this time!
self.overtime_rules.hours_per_day = 8.0
self.overtime_rules.multiplier = 1.5
self.work_type.overtime_type_id = self.overtime_rules
# overtime goes to itself
self.work_type.overtime_work_type_id = self.work_type
work_data = [
((2020, 24, 2), [
# 2hr overtime
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
with self.assertRaises(UserError):
result_data = self.payslip._aggregate_overtime(work_data)
def test_14_recursive_infinite_loop(self):
# recursive will use a second overtime, but not this time!
self.overtime_rules.hours_per_day = 8.0
self.overtime_rules.multiplier = 1.5
self.work_type_overtime.overtime_type_id = self.overtime_rules
# overtime goes back to worktype
self.work_type_overtime.overtime_work_type_id = self.work_type
work_data = [
((2020, 24, 2), [
# 2hr overtime
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
with self.assertRaises(UserError):
result_data = self.payslip._aggregate_overtime(work_data)
def test_15_override_day_of_week(self):
iso_date = (2020, 24, 1)
self.overtime_rules.hours_per_day = 8.0
self.overtime_rules.multiplier = 1.5
work_data = [
(iso_date, [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 1)
self.assertEqual(result_data[self.work_type][1], 8.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 2.0)
self.assertEqual(result_data[self.work_type_overtime][2], 1.5)
# Now lets make an override line
self.overtime_rules.write({
'override_ids': [(0, 0, {
'name': 'Day 1 Override',
'multiplier': 2.0,
'day_of_week': str(iso_date[2]),
'work_type_id': self.work_type_overtime.id, # Note that this wouldn't be good in practice
})]
})
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 1)
self.assertEqual(result_data[self.work_type][1], 8.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 2.0)
self.assertEqual(result_data[self.work_type_overtime][2], 2.0) # rate 2x
def test_16_override_date(self):
iso_date = (2020, 24, 1)
self.overtime_rules.hours_per_day = 8.0
self.overtime_rules.multiplier = 1.5
work_data = [
(iso_date, [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 1)
self.assertEqual(result_data[self.work_type][1], 8.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 2.0)
self.assertEqual(result_data[self.work_type_overtime][2], 1.5)
# Now lets make a specific date override
self.overtime_rules.write({
'override_ids': [(0, 0, {
'name': 'Day (2020, 24, 1) Override',
'multiplier': 3.0,
'date': date(2020, 6, 8), # date.fromisocalendar(*iso_date),
'work_type_id': self.work_type_overtime.id, # Note that this wouldn't be good in practice
})]
})
self.overtime_rules.flush()
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 1)
self.assertEqual(result_data[self.work_type][1], 8.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 2.0)
self.assertEqual(result_data[self.work_type_overtime][2], 3.0) # rate 3x
def test_17_override_config(self):
with self.assertRaises(ValidationError):
self.overtime_rules.write({
'override_ids': [(0, 0, {
'name': 'Day (2020, 24, 1) Override',
'multiplier': 3.0,
# cannot have both date and day_of_week
'date': date(2020, 6, 8),
'day_of_week': '1',
'work_type_id': self.work_type_overtime.id, # Note that this wouldn't be good in practice
})]
})
def test_18_override_day_of_week_on_work_type(self):
iso_date = (2020, 24, 1)
iso_date2 = (2020, 24, 2)
work_data = [
(iso_date, [
(self.work_type, 4.0, None),
]),
(iso_date2, [
(self.work_type, 4.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 2)
self.assertEqual(result_data[self.work_type][1], 8.0)
# Now lets make an override line
test_multiplier = 3.0
self.work_type.write({
'override_ids': [(0, 0, {
'name': 'Day 2 Override',
'multiplier': test_multiplier,
'day_of_week': str(iso_date[2]),
'work_type_id': self.work_type_overtime.id, # Note that this wouldn't be good in practice
})]
})
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 1)
self.assertEqual(result_data[self.work_type][1], 4.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 1)
self.assertEqual(result_data[self.work_type_overtime][1], 4.0)
self.assertEqual(result_data[self.work_type_overtime][2], test_multiplier)
def test_19_overtime_exempt(self):
iso_date = (2020, 24, 1)
self.overtime_rules.hours_per_day = 8.0
work_data = [
(iso_date, [
(self.work_type, 4.0, None),
(self.work_type, 6.0, None),
]),
]
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 1)
self.assertEqual(result_data[self.work_type][1], 8.0)
self.assertTrue(self.work_type_overtime in result_data)
self.assertEqual(result_data[self.work_type_overtime][0], 0)
self.assertEqual(result_data[self.work_type_overtime][1], 2.0)
self.assertEqual(result_data[self.work_type_overtime][2], 1.5)
self.payslip.contract_id.is_overtime_exempt = True
self.assertTrue(self.payslip.contract_id)
self.assertTrue(self.payslip.contract_id.is_overtime_exempt)
result_data = self.payslip._aggregate_overtime(work_data)
self.assertTrue(self.work_type in result_data)
self.assertEqual(result_data[self.work_type][0], 1)
self.assertEqual(result_data[self.work_type][1], 10.0)
self.assertTrue(self.work_type_overtime not in result_data)

15
hr_payroll_overtime/views/hr_contract_views.xml Normal file
View File

@@ -0,0 +1,15 @@
<?xml version="1.0" encoding="utf-8"?>
<odoo>
<record id="hr_contract_form_inherit" model="ir.ui.view">
<field name="name">hr.contract.form.inherit</field>
<field name="model">hr.contract</field>
<field name="inherit_id" ref="hr_contract.hr_contract_view_form"/>
<field name="arch" type="xml">
<xpath expr="//field[@name='wage_type']" position="after">
<field name="is_overtime_exempt" />
</xpath>
</field>
</record>
</odoo>

19
hr_payroll_overtime/views/hr_payslip_views.xml Normal file
View File

@@ -0,0 +1,19 @@
<?xml version="1.0" encoding="UTF-8" ?>
<odoo>
<!-- Payslip Form -->
<record id="view_hr_payslip_form_inherit" model="ir.ui.view">
<field name="name">hr.payslip.form.inherit</field>
<field name="model">hr.payslip</field>
<field name="inherit_id" ref="hr_payroll.view_hr_payslip_form"/>
<field name="arch" type="xml">
<xpath expr="//field[@name='worked_days_line_ids']/tree/field[@name='number_of_hours']" position="after">
<field name="rate"/>
</xpath>
<xpath expr="//field[@name='worked_days_line_ids']/form//field[@name='number_of_hours']" position="after">
<field name="rate"/>
</xpath>
</field>
</record>
</odoo>

102
hr_payroll_overtime/views/hr_work_entry_views.xml Normal file
View File

@@ -0,0 +1,102 @@
<?xml version="1.0" encoding="UTF-8" ?>
<odoo>
<!-- Work Entry Type -->
<record id="hr_work_entry_type_view_form_inherit" model="ir.ui.view">
<field name="name">hr.work.entry.type.form.inherit</field>
<field name="model">hr.work.entry.type</field>
<field name="inherit_id" ref="hr_work_entry.hr_work_entry_type_view_form"/>
<field name="arch" type="xml">
<xpath expr="//group[@name='main_group']" position="after">
<group name="overtime_group">
<field name="overtime_work_type_id"
domain="[('id', '!=', id)]"
attrs="{'required': [('overtime_type_id', '!=', False)]}" />
<field name="overtime_type_id"
domain="[('id', '!=', id)]"
attrs="{'required': [('overtime_work_type_id', '!=', False)]}" />
<field name="override_ids" nolabel="1" colspan="2">
<tree editable="top">
<field name="work_type_id"/>
<field name="multiplier"/>
<field name="date"/>
<field name="day_of_week"/>
<field name="name"/>
</tree>
</field>
</group>
</xpath>
</field>
</record>
<!-- Work Entry Overtime Type -->
<record id="hr_work_entry_overtime_type_tree" model="ir.ui.view">
<field name="name">hr.work.entry.overtime.type.tree</field>
<field name="model">hr.work.entry.overtime.type</field>
<field name="arch" type="xml">
<tree string="Overtime Rules">
<field name="name"/>
<field name="hours_per_day"/>
<field name="hours_per_week"/>
<field name="multiplier"/>
</tree>
</field>
</record>
<record id="hr_work_entry_overtime_type_form" model="ir.ui.view">
<field name="name">hr.work.entry.overtime.type.form</field>
<field name="model">hr.work.entry.overtime.type</field>
<field name="arch" type="xml">
<form string="Overtime Rules">
<group>
<group>
<field name="name"/>
<field name="multiplier"/>
</group>
<group>
<field name="hours_per_day"/>
<field name="hours_per_week"/>
</group>
</group>
<group name="overrides" string="Overrides">
<field name="override_ids" nolabel="1">
<tree editable="top">
<field name="work_type_id"/>
<field name="multiplier"/>
<field name="date"/>
<field name="day_of_week"/>
<field name="name"/>
</tree>
</field>
</group>
</form>
</field>
</record>
<record id="hr_work_entry_overtime_type_search" model="ir.ui.view">
<field name="name">hr.work.entry.overtime.type.search</field>
<field name="model">hr.work.entry.overtime.type</field>
<field name="arch" type="xml">
<search string="Overtime Rules Search">
<field name="name"/>
</search>
</field>
</record>
<record id="hr_work_entry_overtime_type_action_main" model="ir.actions.act_window">
<field name="name">Overtime Rules</field>
<field name="res_model">hr.work.entry.overtime.type</field>
<field name="view_mode">tree,form</field>
<field name="help" type="html">
<p>
No Overtime Rules
</p>
</field>
</record>
<menuitem id="hr_work_entry_overtime_type_menu_main" name="Overtime Rules"
action="hr_work_entry_overtime_type_action_main"
sequence="11" parent="hr_work_entry_contract_enterprise.menu_hr_work_entry_type_view"/>
</odoo>

15
hr_payroll_overtime/views/resource_calendar_views.xml Normal file
View File

@@ -0,0 +1,15 @@
<?xml version="1.0" encoding="UTF-8" ?>
<odoo>
<record id="resource_calendar_form_inherit" model="ir.ui.view">
<field name="name">resource.calendar.form.inherit</field>
<field name="model">resource.calendar</field>
<field name="inherit_id" ref="resource.resource_calendar_form"/>
<field name="arch" type="xml">
<xpath expr="//field[@name='tz']" position="after">
<field name="day_week_start"/>
</xpath>
</field>
</record>
</odoo>