How to Create a l10n Payroll Structure

• Software Engineer, RD4HR Team Leader
EXPERIENCE
2019

● It has been largely improved
○ Functionally:
■ Easier structures deﬁnition
■ New dashboards
■ Less complexity (removed parent/children hierarchy)
■ New employee scheduler (Work Entries)
■ More tools for payroll management
■ New versioning mechanism

● It has been largely improved
○ Technically: The models have been refactored to:
■ Ease the accounting entries generation
■ Batch all the payslip computation and validation
■ Ease the structures deﬁnition
■ Allow easy methods inheritance for both rules
computation methods and evaluation context

● Attachment of salary
● Meal Vouchers Management
● Expense Reimbursement
● SEPA payment generation
● 281.10, 245.10, DMFA export
● Paid Time Off Allocation
● Company cars management
● Salary conﬁgurator
● Credit Time Management
● ...
l10n_be only

● Deﬁne the global parameters for the structures:
○ The scheduled pay (daily, monthly, …)
○ The default working hours (38h/week, …)
○ The wage type (Hours/month-based).
○ The default structure to use as regular pay

● Deﬁne some parameters to compute a payslip:
○ The rules to be computed on the payslip lines
○ The payslip name
○ Take the worked days into account or not
○ The unpaid work entry types
○ Other speciﬁc inputs

● Deﬁne some parameters to compute the payslip line:
○ The code
○ The name
○ The category
○ Displayed on the payslip or not
○ The applicability/amount rules
○ The journal on which to post the accounting entries
○ The contributor (ONSS, Fédéral State, …)

● Deﬁne the way a payslip line is computed:
○ A condition to apply it or not:
■ Always
■ Based on a ﬁeld and a particular range (min/max)
■ Based on a python code
NB: Bold means that the element is evaluated in python (using
safe_eval). This will be explained later.

● Define the way a payslip line in computed:
○ The amount, based on:
■ A fixed amount
■ A fixed percentage based on a field
■ On a python code
○ The quantity
NB: Bold means that the element is evaluated in python (using
safe_eval). This will be explained later.

● Some parameters are evaluated with safe_eval
● The evaluation context ?
○ localdict
try:
safe_eval(
self.amount_python_compute or 0.0,
localdict, mode='exec', nocopy=True)
return float(
localdict['result']),
localdict.get('result_qty', 1.0),
localdict.get('result_rate', 100.0)
except Exception as e:
raise UserError(_('Wrong python code defined for salary rule %s (%s).nError: %s') %
(self.name, self.code, e))

localdict = {
**self._get_base_local_dict(),
**{
'categories': BrowsableObject(employee.id, {}, self.env),
'rules': BrowsableObject(employee.id, {}, self.env),
'payslip': Payslips(employee.id, self, self.env),
'worked_days': WorkedDays(employee.id, worked_days_dict, self.env),
'inputs': InputLine(employee.id, inputs_dict, self.env),
'employee': employee,
'contract': contract
},
**{
'result': None,
'result_qty': 1.0,
'result_rate': 100
}
}
1
3
2

def _get_base_local_dict(self):
return {
'float_round': float_round
}
● The ﬁrst block is quite simple…
● It only contains a pointer to a classic Odoo method

● But can be overridden in your own module!
def _get_base_local_dict(self):
res = super()._get_base_local_dict()
res.update({
'compute_withholding_taxes': compute_withholding_taxes,
})
return res
def compute_withholding_taxes(payslip, categories, worked_days, inputs):
# Do smart stuff
return smart_amount

● BrowsableObject ? Vasistasse ?
● So ? It’s mostly the same thing than a browsed record or a
dictionary ?
class BrowsableObject(object):
def __init__(self, employee_id, dict, env):
self.employee_id = employee_id
self.dict = dict
self.env = env
def __getattr__(self, attr):
return attr in self.dict and self.dict.__getitem__(attr) or 0.0

● So ? It’s mostly the same thing than a browsed record ?
○ NO ! Because we can deﬁne more local information on it !
○ Example: categories is initially empty.
'categories': BrowsableObject(employee.id, {}, self.env)

○ But on each computed payslip line, the sum for each rule
category is recomputed
def _sum_salary_rule_category(localdict, category, amount):
if category.parent_id:
localdict = _sum_salary_rule_category(
localdict,
category.parent_id,
amount)
old_value = localdict['categories'].dict.get(category.code, 0)
localdict['categories'].dict[category.code] = old_value + amount
return localdict

○ Then, in a salary rule, you can use a shortcut like:
○ In that case, you get the sum of all the payslip lines amount
that belong to the categories ‘BASIC’ and ‘ALW’.
result = categories.BASIC + categories.ALW

● Same for rules, which is also initially empty
● But, is updated each time a payslip line is computed
● You can then access to all the evaluated rules
'rules': BrowsableObject(employee.id, rules_dict, self.env)
rules_dict[rule.code] = rule
result = 20 if 'CHILD' in rules else 10

● For payslip, it’s a little more complicated
● You could do something like:
class Payslips(BrowsableObject):
def sum(self, code, from_date, to_date=None):
self.env.cr.execute("""SMART SQL QUERY""")
res = self.env.cr.fetchone()
return res and res[0] or 0.0
def sum_category(self, code, from_date, to_date=None):
self.env.cr.execute("""SMART SQL QUERY""")
res = self.env.cr.fetchone()
return res and res[0] or 0.0
result = payslip.sum('NET', '2018-01-01', '2018-12-31')

def rule_parameter(self, code):
return self.env['hr.rule.parameter']._get_parameter_from_code(
code, self.dict.date_to)

● What is a hr.rule.parameter ?
○ It’s a constant used in a salary rule, that may have different
values over the time. (Example: the Child Allowances)

result = categories.BRUT <= payslip.rule_parameter('work_bonus_reference_wage_high')
● What is a hr.rule.parameter ?
○ So, we could retrieve the current value for a given parameter,
for example in a applicability condition like the following:

● By default, we retrieve the basic salary (wage - unpaid amount) like
this:
@property
def paid_amount(self):
return self.dict._get_paid_amount()
result = payslip.paid_amount

● worked_days and inputs also are BrowsableObjects, with sum and
sum_hours methods, as for payslip
● They are deﬁned as:
'worked_days': WorkedDays(employee.id, worked_days_dict, self.env),
'inputs': InputLine(employee.id, inputs_dict, self.env),
worked_days_dict = {line.code: line for line in self.worked_days_line_ids if line.code}
inputs_dict = {line.code: line for line in self.input_line_ids if line.code}

● It is thus possible to retrieve the number of worked days on a
payslip like:
● Or retrieve the value for an additional payslip line from an input like:
worked_days.WORK100.number_of_days
result = inputs.YEAREND_BONUS.amount if inputs.YEAREND_BONUS else 0

● employee and contract are simple browsed records, and can be
used in a classical way
result = 100 if employee.children == 1 else 200
result = contract.car_atn

● You probably noticed, that we often set a variable result on the
rules computation formulae
● In fact, for each payslip line, the default value is:
● The python rule can set all those 3 variables for a payslip line:
{
'result': None,
'result_qty': 1.0,
'result_rate': 100
}
result = categories.TERMINAISON_DOUBLE
result_rate = -13.07
result_qty = 6.8/7.67

<record id="structure_type_employee_cp200" model="hr.payroll.structure.type">
<field name="name">CP200: Belgian Employee</field>
<field name="default_resource_calendar_id" ref="resource.resource_calendar_std_38h"/>
<field name="country_id" ref="base.be"/>
</record>

<record id="hr_payroll_structure_cp200_employee_salary" model="hr.payroll.structure">
<field name="name">CP200: Employees Monthly Pay</field>
<field name="country_id" ref="base.be"/>
<field name="type_id" ref="l10n_be_hr_payroll.structure_type_employee_cp200"/>
<field name="regular_pay" eval="True"/>
<field name="unpaid_work_entry_type_ids" eval="[
(4, ref('hr_payroll.work_entry_type_unpaid_leave')),
(4, ref('l10n_be_hr_payroll.work_entry_type_unpredictable')),
(4, ref('l10n_be_hr_payroll.work_entry_type_long_sick')),
(4, ref('l10n_be_hr_payroll.work_entry_type_part_sick')),
(4, ref('l10n_be_hr_payroll.work_entry_type_maternity')),
(4, ref('l10n_be_hr_payroll.work_entry_type_breast_feeding')),
]"/>
</record>

<record id="cp200_employees_salary_atn_internet" model="hr.salary.rule">
<field name="category_id" ref="hr_payroll_head_div_impos"/>
<field name="name">ATN Internet</field>
<field name="code">ATN.INT</field>
<field name="sequence">16</field>
<field name="condition_select">python</field>
<field name="condition_python">result = bool(contract.internet)</field>
<field name="amount_select">code</field>
<field name="amount_python_compute">result = 5.0</field>
<field name="struct_id" ref="hr_payroll_structure_cp200_employee_salary"/>
</record>

<record id="cp200_employees_salary_mis_ex_onss" model="hr.salary.rule">
<field name="category_id" ref="hr_salary_rule_category_spec_soc_contribution"/>
<field name="name">Special social cotisation</field>
<field name="code">M.ONSS</field>
<field name="amount_select">fix</field>
<field name="sequence">165</field>
<field name="appears_on_payslip" eval="False"/>
<field name="amount_select">code</field>
<field name="amount_python_compute">result =
compute_special_social_cotisations(payslip, categories, worked_days, inputs)</field>
<field name="struct_id" ref="hr_payroll_structure_cp200_employee_salary"/>
</record>

● Be careful! By default, a structure has already 3 default rules.
○ BASIC
{
'name': 'Basic Salary',
'sequence': 1,
'code': 'BASIC',
'category_id': self.env.ref('hr_payroll.BASIC').id,
'condition_select': 'none',
'amount_select': 'code',
'amount_python_compute': 'result = payslip.paid_amount',
}

○ GROSS
{
'name': 'Gross',
'sequence': 100,
'code': 'GROSS',
'category_id': self.env.ref('hr_payroll.GROSS').id,
'amount_python_compute': 'result = categories.BASIC + categories.ALW',
}

○ NET
{
'name': 'Net Salary',
'sequence': 200,
'code': 'NET',
'category_id': self.env.ref('hr_payroll.NET').id,
'amount_python_compute': 'result = categories.BASIC + categories.ALW + categories.DED',
}

● Don’t recreate those lines, override them ;)
<function model="hr.salary.rule" name="write">
<value model="hr.salary.rule" search="[
('struct_id', '=', ref('l10n_be_hr_payroll.hr_payroll_structure_cp200_double_holiday')),
('code', '=', 'NET')]"/>
<value eval="{'amount_python_compute': 'result = categories.DP + categories.ALW +
categories.DED', 'sequence': '201'}"/>
</function>

● Beneﬁts : Your module is under our responsibility concerning the
maintenance + less customizations for your customers.
● Contact yti@odoo.com, and open a PR with your modiﬁcations.
● It should be included in a l10_CODE_hr_payroll module.
● Try to be generic (Only data for the salary structures, or new
computation methods)
● You may propose new features as well (reports, ...), that will be
validated internally with the product owner.
⇒ THANK YOU FOR YOUR HELP !

#odooexperience
https://github.com/tivisse/
EXPERIENCE
2019

How to Create a l10n Payroll Structure

More Related Content

What's hot (20)

Similar to How to Create a l10n Payroll Structure (20)

More from Odoo (20)

Recently uploaded (20)

How to Create a l10n Payroll Structure