william-andre
d8d47f9ff8
TLDR:
* invoices are implemented using computed methods instead of onchange
* the synchronization only happens when switching tabs in the Form view
to improve perfs.
_______________________________________________________________________
The whole engine of the synchronization of Invoices to the Journal
Entries has been refactored
* by using computed fields instead of onchange functions
* by synchronizing only from invoice to journal entry in `create` and
`write`
* by saving when switching tabs on the Invoice form, to synchronize
before showing the values
This comes with numerous advantages:
* no need to call the onchange methods manually
* no need to use the Form emulator to build invoices (i.e. EDI, OCR,
intercompany, ...)
* the performance for invoices with many lines improves drastically, going
from 2 minutes to 4 seconds to create an invoice with 500 lines
* the model is more declarative, we can now see how the values are computed
instead of having the values being copied from various places.
* remove the hack in `onchange` that disabled the recursivity of it,
which was unexpected and needed to be managed manually in all the
onchange methods
This means that:
* Some fields need to be exclusively computed on journal entries values
or invoice values, more specifically the Tax Summary widget.
It is now
- computed from entry lines, when opening the view
- computed from invoice lines when changing those, because the tax lines
will need to be recomputed anyways, erasing previously set values
- set with an inverse function when saving; after the sync has been done
* Some possible operations previously possible have been dropped.
(i.e. look at the removed test test_in_invoice_line_onchange_accounting_fields_1)
This is because such a behavior was undefined (how is changing the balance going
to affect the unit price? How is the amount currency going to affect it?)
_______________________________________________________________________
Implementation Details
----------------------
The "dynamic lines", meaning the payment terms and the tax lines are now
only created in the `create` and `write` functions.
In order to reduce code duplication, it has been implemented using
context managers used in both `account.move` and `account.move.line`
These context managers help comparing the values before/after, acting
like a local `onchange`, but getting benefit from the dirty flags from
the `compute` dependences.
This is relying on computed fields on the move (`needed_terms`) and on
the lines (`compute_all_tax`) which contain the values needed for the
related move.
Depending on the needed values and the existing values (`term_key` and
`tax_key`, respectively) the context manager will determine what needs
to be created/updated/deleted.
Some related changes are to produce a `dict` instead of a `str` for the
`tax_totals` (previously `tax_totals_json`) fields, by simplicity to
reduce the complexity of IO, and simplicity of debugging, because the
logic of the field needed to change (cannot be computed at the same time
anymore since it needed the lines to be synced)
By simplicity, and also because it makes more sense, some boolean fields
have been merged into `display_type`:
* `is_rounding_line`
* `exclude_from_invoice_tab`
* `is_anglo_saxon_line`
The `price_unit`, `quantity` and other "invoice fields" are now not set
anymore on lines that are not product lines since it didn't make any
sense to have it.
Performances
------------
You have to keep in mind that a simple `create` didn't compute a lot of
fields, for instance not taxes were set, no payment terms,...
Now it does.
```python
import random
from timeit import timeit
from odoo import Command
domain = [('company_id', 'in', (False, self.env.company.id))]
products = self.env['product.product'].search(domain).ids
partners = self.env['res.partner'].search(domain).ids
taxes = self.env['account.tax'].search(domain).ids
def create(nmove, nline):
self.env['account.move'].create([
{
'move_type': 'out_invoice',
'partner_id': random.choice(partners),
'invoice_line_ids': [
Command.create({
'name': f'line{i}',
'product_id': random.choice(products),
'tax_ids': [Command.set([random.choice(taxes)])],
})
for i in range(nline)
]
}
for j in range(nmove)
])
# After | Before
print(timeit("create(1, 1)", globals=globals(), number=1)) # 0.11 | 0.09
print(timeit("create(100, 1)", globals=globals(), number=1)) # 2.76 | 2.50
print(timeit("create(500, 1)", globals=globals(), number=1)) # 14.56 | 12.34
print(timeit("create(1, 100)", globals=globals(), number=1)) # 1.03 | 5.52
print(timeit("create(1, 500)", globals=globals(), number=1)) # 3.99 | 125.02
print(timeit("create(50, 50)", globals=globals(), number=1)) # 19.44 | 79.55
```
Another metric that can be used is running the test suite with
`--test-tags=/account` (only `account` installed)
* before: 404s, 267127 queries (366 tests)
* after: 318s, 232125 queries (362 tests)
Why this commit title?
----------------------
Someone told me that this was the perfect way of naming your commits.
c04065abd8
task-2711317
closes odoo/odoo#96134
Related: odoo/upgrade#3715
Related: odoo/enterprise#29758
Signed-off-by: Laurent Smet <las@odoo.com>
1230 lines
63 KiB
Python
1230 lines
63 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import re
|
|
from markupsafe import Markup
|
|
from odoo import api, fields, Command, models, _
|
|
from odoo.tools import float_round
|
|
from odoo.exceptions import UserError, ValidationError
|
|
from odoo.tools import email_split, float_is_zero, float_repr, float_compare, is_html_empty
|
|
from odoo.tools.misc import clean_context, format_date
|
|
|
|
|
|
class HrExpense(models.Model):
|
|
|
|
_name = "hr.expense"
|
|
_inherit = ['mail.thread', 'mail.activity.mixin']
|
|
_description = "Expense"
|
|
_order = "date desc, id desc"
|
|
_check_company_auto = True
|
|
|
|
@api.model
|
|
def _default_employee_id(self):
|
|
employee = self.env.user.employee_id
|
|
if not employee and not self.env.user.has_group('hr_expense.group_hr_expense_team_approver'):
|
|
raise ValidationError(_('The current user has no related employee. Please, create one.'))
|
|
return employee
|
|
|
|
@api.model
|
|
def _default_product_uom_id(self):
|
|
return self.env['uom.uom'].search([], limit=1, order='id')
|
|
|
|
@api.model
|
|
def _default_account_id(self):
|
|
return self.env['ir.property']._get('property_account_expense_categ_id', 'product.category')
|
|
|
|
@api.model
|
|
def _get_employee_id_domain(self):
|
|
res = [('id', '=', 0)] # Nothing accepted by domain, by default
|
|
if self.user_has_groups('hr_expense.group_hr_expense_user') or self.user_has_groups('account.group_account_user'):
|
|
res = "['|', ('company_id', '=', False), ('company_id', '=', company_id)]" # Then, domain accepts everything
|
|
elif self.user_has_groups('hr_expense.group_hr_expense_team_approver') and self.env.user.employee_ids:
|
|
user = self.env.user
|
|
employee = self.env.user.employee_id
|
|
res = [
|
|
'|', '|', '|',
|
|
('department_id.manager_id', '=', employee.id),
|
|
('parent_id', '=', employee.id),
|
|
('id', '=', employee.id),
|
|
('expense_manager_id', '=', user.id),
|
|
'|', ('company_id', '=', False), ('company_id', '=', employee.company_id.id),
|
|
]
|
|
elif self.env.user.employee_id:
|
|
employee = self.env.user.employee_id
|
|
res = [('id', '=', employee.id), '|', ('company_id', '=', False), ('company_id', '=', employee.company_id.id)]
|
|
return res
|
|
|
|
name = fields.Char('Description', compute='_compute_from_product_id_company_id', readonly=False, store=True, required=True, copy=True,
|
|
states={'done': [('readonly', True)]})
|
|
date = fields.Date(states={'done': [('readonly', True)]}, default=fields.Date.context_today, string="Expense Date")
|
|
accounting_date = fields.Date(string="Accounting Date", related='sheet_id.accounting_date', store=True, groups='account.group_account_invoice,account.group_account_readonly')
|
|
employee_id = fields.Many2one('hr.employee', compute='_compute_employee_id', string="Employee",
|
|
store=True, required=True, readonly=False, tracking=True,
|
|
states={'approved': [('readonly', True)], 'done': [('readonly', True)]},
|
|
default=_default_employee_id, domain=lambda self: self._get_employee_id_domain(), check_company=True)
|
|
# product_id not required to allow create an expense without product via mail alias, but should be required on the view.
|
|
product_id = fields.Many2one('product.product', string='Product', tracking=True, states={'done': [('readonly', True)]}, domain="[('can_be_expensed', '=', True), '|', ('company_id', '=', False), ('company_id', '=', company_id)]", ondelete='restrict')
|
|
product_description = fields.Html(compute='_compute_product_description')
|
|
product_uom_id = fields.Many2one('uom.uom', string='Unit of Measure', compute='_compute_from_product_id_company_id',
|
|
store=True, copy=True, states={'draft': [('readonly', False)], 'refused': [('readonly', False)]},
|
|
default=_default_product_uom_id, domain="[('category_id', '=', product_uom_category_id)]")
|
|
product_uom_category_id = fields.Many2one(related='product_id.uom_id.category_id', readonly=True, string="UoM Category")
|
|
unit_amount = fields.Float("Unit Price", compute='_compute_from_product_id_company_id', readonly=False, store=True, required=True, copy=True,
|
|
states={'done': [('readonly', True)]}, digits='Product Price')
|
|
unit_amount_display = fields.Float("Unit Price Display", compute='_compute_unit_amount_display')
|
|
quantity = fields.Float(required=True, states={'done': [('readonly', True)]}, digits='Product Unit of Measure', default=1)
|
|
tax_ids = fields.Many2many('account.tax', 'expense_tax', 'expense_id', 'tax_id',
|
|
compute='_compute_from_product_id_company_id', store=True, readonly=False,
|
|
domain="[('company_id', '=', company_id), ('type_tax_use', '=', 'purchase')]", string='Included taxes')
|
|
amount_tax = fields.Monetary(string='Tax amount in Currency', help="Tax amount in currency", compute='_compute_amount_tax', store=True, currency_field='currency_id')
|
|
amount_tax_company = fields.Monetary('Tax amount', help="Tax amount in company currency", compute='_compute_total_amount_company', store=True, currency_field='company_currency_id')
|
|
amount_residual = fields.Monetary(string='Amount Due', compute='_compute_amount_residual')
|
|
total_amount = fields.Monetary("Total In Currency", compute='_compute_amount', store=True, currency_field='currency_id', tracking=True, readonly=False)
|
|
untaxed_amount = fields.Monetary("Total Untaxed Amount In Currency", compute='_compute_amount_tax', store=True, currency_field='currency_id')
|
|
company_currency_id = fields.Many2one('res.currency', string="Report Company Currency", related='company_id.currency_id', readonly=True)
|
|
total_amount_company = fields.Monetary('Total', compute='_compute_total_amount_company', store=True, currency_field='company_currency_id')
|
|
company_id = fields.Many2one('res.company', string='Company', required=True, readonly=True, states={'draft': [('readonly', False)], 'refused': [('readonly', False)]}, default=lambda self: self.env.company)
|
|
currency_id = fields.Many2one('res.currency', string='Currency', required=True, readonly=False, store=True, states={'reported': [('readonly', True)], 'approved': [('readonly', True)], 'done': [('readonly', True)]}, compute='_compute_currency_id', default=lambda self: self.env.company.currency_id)
|
|
currency_rate = fields.Float(compute='_compute_currency_rate')
|
|
analytic_account_id = fields.Many2one('account.analytic.account', string='Analytic Account', check_company=True)
|
|
analytic_tag_ids = fields.Many2many('account.analytic.tag', string='Analytic Tags', states={'post': [('readonly', True)], 'done': [('readonly', True)]}, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
|
|
account_id = fields.Many2one('account.account', compute='_compute_from_product_id_company_id', store=True, readonly=False, string='Account',
|
|
default=_default_account_id, domain="[('account_type', 'not in', ('asset_receivable','liability_payable','asset_cash','liability_credit_card')), ('company_id', '=', company_id)]", help="An expense account is expected")
|
|
description = fields.Text('Notes...', readonly=True, states={'draft': [('readonly', False)], 'reported': [('readonly', False)], 'refused': [('readonly', False)]})
|
|
payment_mode = fields.Selection([
|
|
("own_account", "Employee (to reimburse)"),
|
|
("company_account", "Company")
|
|
], default='own_account', tracking=True, states={'done': [('readonly', True)], 'approved': [('readonly', True)], 'reported': [('readonly', True)]}, string="Paid By")
|
|
attachment_number = fields.Integer('Number of Attachments', compute='_compute_attachment_number')
|
|
state = fields.Selection([
|
|
('draft', 'To Submit'),
|
|
('reported', 'Submitted'),
|
|
('approved', 'Approved'),
|
|
('done', 'Paid'),
|
|
('refused', 'Refused')
|
|
], compute='_compute_state', string='Status', copy=False, index=True, readonly=True, store=True, default='draft')
|
|
sheet_id = fields.Many2one('hr.expense.sheet', string="Expense Report", domain="[('employee_id', '=', employee_id), ('company_id', '=', company_id)]", readonly=True, copy=False)
|
|
sheet_is_editable = fields.Boolean(compute='_compute_sheet_is_editable')
|
|
approved_by = fields.Many2one('res.users', string='Approved By', related='sheet_id.user_id')
|
|
approved_on = fields.Datetime(string='Approved On', related='sheet_id.approval_date')
|
|
reference = fields.Char("Bill Reference")
|
|
is_refused = fields.Boolean("Explicitly Refused by manager or accountant", readonly=True, copy=False)
|
|
|
|
is_editable = fields.Boolean("Is Editable By Current User", compute='_compute_is_editable')
|
|
is_ref_editable = fields.Boolean("Reference Is Editable By Current User", compute='_compute_is_ref_editable')
|
|
product_has_cost = fields.Boolean("Is product with non zero cost selected", compute='_compute_product_has_cost')
|
|
product_has_tax = fields.Boolean("Whether tax is defined on a selected product", compute='_compute_product_has_cost')
|
|
same_currency = fields.Boolean("Is currency_id different from the company_currency_id", compute='_compute_same_currency')
|
|
duplicate_expense_ids = fields.Many2many('hr.expense', compute='_compute_duplicate_expense_ids')
|
|
|
|
sample = fields.Boolean()
|
|
label_convert_rate = fields.Char(compute='_compute_label_convert_rate')
|
|
|
|
def attach_document(self, **kwargs):
|
|
pass
|
|
|
|
@api.depends('product_has_cost')
|
|
def _compute_currency_id(self):
|
|
for expense in self.filtered("product_has_cost"):
|
|
expense.currency_id = expense.company_currency_id
|
|
|
|
@api.onchange('product_has_cost')
|
|
def _onchange_product_has_cost(self):
|
|
# Reset quantity to 1, in case of 0-cost product
|
|
if not self.product_has_cost:
|
|
self.quantity = 1
|
|
|
|
@api.depends('date', 'currency_id', 'company_currency_id', 'company_id')
|
|
def _compute_currency_rate(self):
|
|
date_today = fields.Date.context_today(self.env.user)
|
|
for expense in self:
|
|
target_currency = expense.currency_id or self.env.company.currency_id
|
|
expense.currency_rate = self.env['res.currency']._get_conversion_rate(
|
|
from_currency=target_currency,
|
|
to_currency=expense.company_currency_id,
|
|
company=expense.company_id,
|
|
date=expense.date or date_today,
|
|
)
|
|
|
|
@api.depends('currency_id', 'company_currency_id')
|
|
def _compute_same_currency(self):
|
|
for expense in self:
|
|
expense.same_currency = bool(not expense.company_id or (expense.currency_id and expense.currency_id == expense.company_currency_id))
|
|
|
|
@api.depends('product_id')
|
|
def _compute_product_has_cost(self):
|
|
for expense in self:
|
|
expense.product_has_cost = expense.product_id and (float_compare(expense.product_id.standard_price, 0.0, precision_digits=2) != 0)
|
|
tax_ids = expense.product_id.supplier_taxes_id.filtered(lambda tax: tax.company_id == expense.company_id)
|
|
expense.product_has_tax = bool(tax_ids)
|
|
|
|
@api.depends('sheet_id', 'sheet_id.account_move_id', 'sheet_id.state')
|
|
def _compute_state(self):
|
|
for expense in self:
|
|
if not expense.sheet_id or expense.sheet_id.state == 'draft':
|
|
expense.state = "draft"
|
|
elif expense.sheet_id.state == "cancel":
|
|
expense.state = "refused"
|
|
elif expense.sheet_id.state == "approve" or expense.sheet_id.state == "post":
|
|
expense.state = "approved"
|
|
elif not expense.sheet_id.account_move_id:
|
|
expense.state = "reported"
|
|
else:
|
|
expense.state = "done"
|
|
|
|
@api.depends('quantity', 'unit_amount', 'tax_ids', 'currency_id')
|
|
def _compute_amount(self):
|
|
for expense in self:
|
|
if expense.product_id and not expense.product_has_cost:
|
|
continue
|
|
taxes = expense._get_taxes(price=expense.unit_amount, quantity=expense.quantity)
|
|
expense.total_amount = taxes['total_included']
|
|
|
|
@api.depends('total_amount', 'tax_ids', 'currency_id')
|
|
def _compute_amount_tax(self):
|
|
"""Note: as total_amount can be set directly by the user (for product without cost) or needs to be computed (for product with cost),
|
|
`untaxed_amount` can't be computed in the same method as `total_amount`.
|
|
"""
|
|
for expense in self:
|
|
taxes = expense._get_taxes(price=expense.total_amount, quantity=1.0)
|
|
expense.amount_tax = taxes['total_included'] - taxes['total_excluded'] if expense.tax_ids else 0.0
|
|
expense.untaxed_amount = taxes['total_excluded']
|
|
|
|
def _get_taxes(self, price, quantity):
|
|
self.ensure_one()
|
|
return self.tax_ids.with_context(force_price_include=True).compute_all(price_unit=price, currency=self.currency_id, quantity=quantity, product=self.product_id, partner=self.employee_id.user_id.partner_id)
|
|
|
|
@api.depends("sheet_id.account_move_id.line_ids")
|
|
def _compute_amount_residual(self):
|
|
for expense in self:
|
|
if not expense.sheet_id:
|
|
expense.amount_residual = expense.total_amount
|
|
continue
|
|
if not expense.currency_id or expense.currency_id == expense.company_id.currency_id:
|
|
residual_field = 'amount_residual'
|
|
else:
|
|
residual_field = 'amount_residual_currency'
|
|
payment_term_lines = expense.sheet_id.account_move_id.sudo().line_ids \
|
|
.filtered(lambda line: line.expense_id == expense and line.account_type in ('asset_receivable', 'liability_payable'))
|
|
expense.amount_residual = -sum(payment_term_lines.mapped(residual_field))
|
|
|
|
@api.depends('currency_rate', 'total_amount', 'amount_tax')
|
|
def _compute_total_amount_company(self):
|
|
for expense in self:
|
|
expense.total_amount_company = expense.total_amount * expense.currency_rate
|
|
expense.amount_tax_company = expense.amount_tax * expense.currency_rate
|
|
|
|
@api.depends('currency_rate')
|
|
def _compute_label_convert_rate(self):
|
|
records_with_diff_currency = self.filtered(lambda x: not x.same_currency and x.currency_id)
|
|
(self - records_with_diff_currency).label_convert_rate = False
|
|
for expense in records_with_diff_currency:
|
|
rate_txt = _('1 %(exp_cur)s = %(rate)s %(comp_cur)s', exp_cur=expense.currency_id.name, rate=float_repr(expense.currency_rate, 6), comp_cur=expense.company_currency_id.name)
|
|
expense.label_convert_rate = rate_txt
|
|
|
|
def _compute_attachment_number(self):
|
|
attachment_data = self.env['ir.attachment']._read_group([('res_model', '=', 'hr.expense'), ('res_id', 'in', self.ids)], ['res_id'], ['res_id'])
|
|
attachment = dict((data['res_id'], data['res_id_count']) for data in attachment_data)
|
|
for expense in self:
|
|
expense.attachment_number = attachment.get(expense._origin.id, 0)
|
|
|
|
@api.depends('employee_id')
|
|
def _compute_is_editable(self):
|
|
is_account_manager = self.env.user.has_group('account.group_account_user') or self.env.user.has_group('account.group_account_manager')
|
|
for expense in self:
|
|
if expense.state == 'draft' or expense.sheet_id.state in ['draft', 'submit']:
|
|
expense.is_editable = True
|
|
elif expense.sheet_id.state == 'approve':
|
|
expense.is_editable = is_account_manager
|
|
else:
|
|
expense.is_editable = False
|
|
|
|
@api.depends('sheet_id.is_editable', 'sheet_id')
|
|
def _compute_sheet_is_editable(self):
|
|
for expense in self:
|
|
expense.sheet_is_editable = not expense.sheet_id or expense.sheet_id.is_editable
|
|
|
|
@api.depends('employee_id')
|
|
def _compute_is_ref_editable(self):
|
|
is_account_manager = self.env.user.has_group('account.group_account_user') or self.env.user.has_group('account.group_account_manager')
|
|
for expense in self:
|
|
if expense.state == 'draft' or expense.sheet_id.state in ['draft', 'submit']:
|
|
expense.is_ref_editable = True
|
|
else:
|
|
expense.is_ref_editable = is_account_manager
|
|
|
|
@api.depends_context('lang')
|
|
@api.depends('product_id')
|
|
def _compute_product_description(self):
|
|
for expense in self:
|
|
expense.product_description = not is_html_empty(expense.product_id.description) and expense.product_id.description
|
|
|
|
@api.depends('unit_amount', 'total_amount_company', 'product_has_cost')
|
|
def _compute_unit_amount_display(self):
|
|
for expense in self:
|
|
expense.unit_amount_display = expense.unit_amount if expense.product_has_cost else expense.total_amount_company
|
|
|
|
@api.depends('product_id', 'company_id')
|
|
def _compute_from_product_id_company_id(self):
|
|
for expense in self:
|
|
if not expense.product_id:
|
|
continue
|
|
# Only change unit_amount if the product has no cost defined on it
|
|
if not expense.attachment_number or (expense.attachment_number and not expense.unit_amount):
|
|
expense.unit_amount = expense.product_id.price_compute('standard_price', currency=expense.currency_id)[expense.product_id.id]
|
|
expense = expense.with_company(expense.company_id)
|
|
expense.name = expense.name or expense.product_id.display_name
|
|
expense.product_uom_id = expense.product_id.uom_id
|
|
expense.tax_ids = expense.product_id.supplier_taxes_id.filtered(lambda tax: tax.company_id == expense.company_id) # taxes only from the same company
|
|
account = expense.product_id.product_tmpl_id._get_product_accounts()['expense']
|
|
if account:
|
|
expense.account_id = account
|
|
|
|
@api.depends('company_id')
|
|
def _compute_employee_id(self):
|
|
if not self.env.context.get('default_employee_id'):
|
|
for expense in self:
|
|
expense.employee_id = self.env.user.with_company(expense.company_id).employee_id
|
|
|
|
@api.depends('employee_id', 'product_id', 'total_amount')
|
|
def _compute_duplicate_expense_ids(self):
|
|
self.duplicate_expense_ids = [(5, 0, 0)]
|
|
|
|
expenses = self.filtered(lambda e: e.employee_id and e.product_id and e.total_amount)
|
|
if expenses.ids:
|
|
duplicates_query = """
|
|
SELECT ARRAY_AGG(DISTINCT he.id)
|
|
FROM hr_expense AS he
|
|
JOIN hr_expense AS ex ON he.employee_id = ex.employee_id
|
|
AND he.product_id = ex.product_id
|
|
AND he.date = ex.date
|
|
AND he.total_amount = ex.total_amount
|
|
AND he.company_id = ex.company_id
|
|
AND he.currency_id = ex.currency_id
|
|
WHERE ex.id in %(expense_ids)s
|
|
GROUP BY he.employee_id, he.product_id, he.date, he.total_amount, he.company_id, he.currency_id
|
|
HAVING COUNT(he.id) > 1
|
|
"""
|
|
self.env.cr.execute(duplicates_query, {
|
|
'expense_ids': tuple(expenses.ids),
|
|
})
|
|
duplicates = [x[0] for x in self.env.cr.fetchall()]
|
|
|
|
for ids in duplicates:
|
|
exp = expenses.filtered(lambda e: e.id in ids)
|
|
exp.duplicate_expense_ids = [(6, 0, ids)]
|
|
expenses = expenses - exp
|
|
|
|
# sgv todo replace with depends?
|
|
@api.onchange('product_id', 'date', 'account_id')
|
|
def _onchange_product_id_date_account_id(self):
|
|
rec = self.env['account.analytic.default'].sudo().account_get(
|
|
product_id=self.product_id.id,
|
|
account_id=self.account_id.id,
|
|
company_id=self.company_id.id,
|
|
date=self.date
|
|
)
|
|
self.analytic_account_id = self.analytic_account_id or rec.analytic_id.id
|
|
self.analytic_tag_ids = self.analytic_tag_ids or rec.analytic_tag_ids.ids
|
|
|
|
@api.constrains('payment_mode')
|
|
def _check_payment_mode(self):
|
|
self.sheet_id._check_payment_mode()
|
|
|
|
@api.constrains('product_id', 'product_uom_id')
|
|
def _check_product_uom_category(self):
|
|
for expense in self:
|
|
if expense.product_id and expense.product_uom_id.category_id != expense.product_id.uom_id.category_id:
|
|
raise UserError(_(
|
|
'Selected Unit of Measure for expense %(expense)s does not belong to the same category as the Unit of Measure of product %(product)s.',
|
|
expense=expense.name, product=expense.product_id.name,
|
|
))
|
|
|
|
def create_expense_from_attachments(self, attachment_ids=None, view_type='list'):
|
|
''' Create the expenses from files.
|
|
:return: An action redirecting to hr.expense tree view.
|
|
'''
|
|
if attachment_ids is None:
|
|
attachment_ids = []
|
|
attachments = self.env['ir.attachment'].browse(attachment_ids)
|
|
if not attachments:
|
|
raise UserError(_("No attachment was provided"))
|
|
expenses = self.env['hr.expense']
|
|
|
|
if any(attachment.res_id or attachment.res_model != 'hr.expense' for attachment in attachments):
|
|
raise UserError(_("Invalid attachments!"))
|
|
|
|
product = self.env['product.product'].search([('can_be_expensed', '=', True)])
|
|
if product:
|
|
product = product.filtered(lambda p: p.default_code == "EXP_GEN") or product[0]
|
|
else:
|
|
raise UserError(_("You need to have at least one category that can be expensed in your database to proceed!"))
|
|
|
|
for attachment in attachments:
|
|
expense = self.env['hr.expense'].create({
|
|
'name': product.display_name,
|
|
'unit_amount': 0,
|
|
'product_id': product.id,
|
|
})
|
|
attachment.write({
|
|
'res_model': 'hr.expense',
|
|
'res_id': expense.id,
|
|
})
|
|
|
|
attachment.register_as_main_attachment()
|
|
expenses += expense
|
|
return {
|
|
'name': _('Generate Expenses'),
|
|
'res_model': 'hr.expense',
|
|
'type': 'ir.actions.act_window',
|
|
'views': [[False, view_type], [False, "form"]],
|
|
'context': {'search_default_my_expenses': 1, 'search_default_no_report': 1},
|
|
}
|
|
|
|
# ----------------------------------------
|
|
# ORM Overrides
|
|
# ----------------------------------------
|
|
|
|
@api.ondelete(at_uninstall=False)
|
|
def _unlink_except_posted_or_approved(self):
|
|
for expense in self:
|
|
if expense.state in ['done', 'approved']:
|
|
raise UserError(_('You cannot delete a posted or approved expense.'))
|
|
|
|
def write(self, vals):
|
|
if 'tax_ids' in vals or 'analytic_account_id' in vals or 'account_id' in vals:
|
|
if any(not expense.is_editable for expense in self):
|
|
raise UserError(_('You are not authorized to edit this expense report.'))
|
|
if 'reference' in vals:
|
|
if any(not expense.is_ref_editable for expense in self):
|
|
raise UserError(_('You are not authorized to edit the reference of this expense report.'))
|
|
res = super(HrExpense, self).write(vals)
|
|
if 'employee_id' in vals:
|
|
# In case expense has sheet which has only one expense_line_ids,
|
|
# then changing the expense.employee_id triggers changing the sheet.employee_id too.
|
|
# Otherwise we unlink the expense line from sheet, (so that the user can create a new report).
|
|
if self.sheet_id:
|
|
employees = self.sheet_id.expense_line_ids.mapped('employee_id')
|
|
if len(employees) == 1:
|
|
self.sheet_id.write({'employee_id': vals['employee_id']})
|
|
elif len(employees) > 1:
|
|
self.sheet_id = False
|
|
return res
|
|
|
|
@api.model
|
|
def get_empty_list_help(self, help_message):
|
|
return super(HrExpense, self).get_empty_list_help(help_message or '' + self._get_empty_list_mail_alias())
|
|
|
|
@api.model
|
|
def _get_empty_list_mail_alias(self):
|
|
use_mailgateway = self.env['ir.config_parameter'].sudo().get_param('hr_expense.use_mailgateway')
|
|
alias_record = use_mailgateway and self.env.ref('hr_expense.mail_alias_expense') or False
|
|
if alias_record and alias_record.alias_domain and alias_record.alias_name:
|
|
return Markup("""
|
|
<p>
|
|
Or send your receipts at <a href="mailto:%(email)s?subject=Lunch%%20with%%20customer%%3A%%20%%2412.32">%(email)s</a>.
|
|
</p>""") % {'email': '%s@%s' % (alias_record.alias_name, alias_record.alias_domain)}
|
|
return ""
|
|
|
|
# ----------------------------------------
|
|
# Actions
|
|
# ----------------------------------------
|
|
|
|
def action_view_sheet(self):
|
|
self.ensure_one()
|
|
return {
|
|
'type': 'ir.actions.act_window',
|
|
'view_mode': 'form',
|
|
'res_model': 'hr.expense.sheet',
|
|
'target': 'current',
|
|
'res_id': self.sheet_id.id
|
|
}
|
|
|
|
def _get_default_expense_sheet_values(self):
|
|
# If there is an expense with total_amount_company == 0, it means that expense has not been processed by OCR yet
|
|
expenses_with_amount = self.filtered(lambda expense: not float_compare(expense.total_amount_company, 0.0, precision_rounding=expense.company_currency_id.rounding) == 0)
|
|
|
|
if any(expense.state != 'draft' or expense.sheet_id for expense in expenses_with_amount):
|
|
raise UserError(_("You cannot report twice the same line!"))
|
|
if not expenses_with_amount:
|
|
raise UserError(_("You cannot report the expenses without amount!"))
|
|
if len(expenses_with_amount.mapped('employee_id')) != 1:
|
|
raise UserError(_("You cannot report expenses for different employees in the same report."))
|
|
if any(not expense.product_id for expense in expenses_with_amount):
|
|
raise UserError(_("You can not create report without category."))
|
|
|
|
# Check if two reports should be created
|
|
own_expenses = expenses_with_amount.filtered(lambda x: x.payment_mode == 'own_account')
|
|
company_expenses = expenses_with_amount - own_expenses
|
|
create_two_reports = own_expenses and company_expenses
|
|
|
|
sheets = [own_expenses, company_expenses] if create_two_reports else [expenses_with_amount]
|
|
values = []
|
|
for todo in sheets:
|
|
if len(todo) == 1:
|
|
expense_name = todo.name
|
|
else:
|
|
dates = todo.mapped('date')
|
|
min_date = format_date(self.env, min(dates))
|
|
max_date = format_date(self.env, max(dates))
|
|
expense_name = min_date if max_date == min_date else "%s - %s" % (min_date, max_date)
|
|
|
|
vals = {
|
|
'company_id': self.company_id.id,
|
|
'employee_id': self[0].employee_id.id,
|
|
'name': expense_name,
|
|
'expense_line_ids': [Command.set(todo.ids)],
|
|
'state': 'draft',
|
|
}
|
|
values.append(vals)
|
|
return values
|
|
|
|
def action_submit_expenses(self):
|
|
context_vals = self._get_default_expense_sheet_values()
|
|
if len(context_vals) > 1:
|
|
sheets = self.env['hr.expense.sheet'].create(context_vals)
|
|
return {
|
|
'name': _('New Expense Reports'),
|
|
'type': 'ir.actions.act_window',
|
|
'view_mode': 'list,form',
|
|
'res_model': 'hr.expense.sheet',
|
|
'domain': [('id', 'in', sheets.ids)],
|
|
'context': self.env.context,
|
|
}
|
|
else:
|
|
context_vals_def = {}
|
|
for key in context_vals[0]:
|
|
context_vals_def['default_' + key] = context_vals[0][key]
|
|
return {
|
|
'name': _('New Expense Report'),
|
|
'type': 'ir.actions.act_window',
|
|
'view_mode': 'form',
|
|
'res_model': 'hr.expense.sheet',
|
|
'target': 'current',
|
|
'context': context_vals_def,
|
|
}
|
|
|
|
def action_get_attachment_view(self):
|
|
self.ensure_one()
|
|
res = self.env['ir.actions.act_window']._for_xml_id('base.action_attachment')
|
|
res['domain'] = [('res_model', '=', 'hr.expense'), ('res_id', 'in', self.ids)]
|
|
res['context'] = {'default_res_model': 'hr.expense', 'default_res_id': self.id}
|
|
return res
|
|
|
|
def action_approve_duplicates(self):
|
|
root = self.env['ir.model.data']._xmlid_to_res_id("base.partner_root")
|
|
for expense in self.duplicate_expense_ids:
|
|
expense.message_post(
|
|
body=_('%(user)s confirms this expense is not a duplicate with similar expense.', user=self.env.user.name),
|
|
author_id=root
|
|
)
|
|
|
|
def _get_split_values(self):
|
|
self.ensure_one()
|
|
half_price = self.total_amount / 2
|
|
price_round_up = float_round(half_price, precision_digits=2, rounding_method='UP')
|
|
price_round_down = float_round(half_price, precision_digits=2, rounding_method='DOWN')
|
|
|
|
return [{
|
|
'name': self.name,
|
|
'product_id': self.product_id.id,
|
|
'total_amount': price,
|
|
'tax_ids': self.tax_ids.ids,
|
|
'currency_id': self.currency_id.id,
|
|
'company_id': self.company_id.id,
|
|
'analytic_account_id': self.analytic_account_id.id,
|
|
'employee_id': self.employee_id.id,
|
|
'expense_id': self.id,
|
|
} for price in [price_round_up, price_round_down]]
|
|
|
|
def action_split_wizard(self):
|
|
self.ensure_one()
|
|
splits = self.env['hr.expense.split'].create(self._get_split_values())
|
|
|
|
wizard = self.env['hr.expense.split.wizard'].create({
|
|
'expense_split_line_ids': splits.ids,
|
|
'expense_id': self.id,
|
|
})
|
|
return {
|
|
'name': _('Expense split'),
|
|
'type': 'ir.actions.act_window',
|
|
'view_mode': 'form',
|
|
'res_model': 'hr.expense.split.wizard',
|
|
'res_id': wizard.id,
|
|
'target': 'new',
|
|
'context': self.env.context,
|
|
}
|
|
|
|
# ----------------------------------------
|
|
# Business
|
|
# ----------------------------------------
|
|
|
|
def _get_expense_account_destination(self):
|
|
self.ensure_one()
|
|
account_dest = self.env['account.account']
|
|
if self.payment_mode == 'company_account':
|
|
journal = self.sheet_id.bank_journal_id
|
|
account_dest = (
|
|
journal.outbound_payment_method_line_ids[0].payment_account_id
|
|
or journal.company_id.account_journal_payment_credit_account_id
|
|
)
|
|
else:
|
|
if not self.employee_id.sudo().address_home_id:
|
|
raise UserError(_("No Home Address found for the employee %s, please configure one.") % (self.employee_id.name))
|
|
partner = self.employee_id.sudo().address_home_id.with_company(self.company_id)
|
|
account_dest = partner.property_account_payable_id or partner.parent_id.property_account_payable_id
|
|
return account_dest.id
|
|
|
|
def action_move_create(self):
|
|
'''
|
|
main function that is called when trying to create the accounting entries related to an expense
|
|
'''
|
|
moves = self.env['account.move'].create([
|
|
{
|
|
'journal_id': (
|
|
sheet.bank_journal_id
|
|
if sheet.payment_mode == 'company_account' else
|
|
sheet.journal_id
|
|
).id,
|
|
'move_type': 'in_receipt',
|
|
'company_id': sheet.company_id.id,
|
|
'date': sheet.accounting_date or fields.Date.context_today(sheet),
|
|
'invoice_date': sheet.accounting_date or fields.Date.context_today(sheet),
|
|
'ref': sheet.name,
|
|
# force the name to the default value, to avoid an eventual 'default_name' in the context
|
|
# to set it to '' which cause no number to be given to the account.move when posted.
|
|
'name': '/',
|
|
'expense_sheet_id': [Command.set(sheet.ids)],
|
|
'line_ids':[
|
|
Command.create({
|
|
'name': expense.employee_id.name + ': ' + expense.name.split('\n')[0][:64],
|
|
'quantity': expense.quantity or 1,
|
|
'price_unit': expense.total_amount,
|
|
'product_id': expense.product_id.id,
|
|
'product_uom_id': expense.product_uom_id.id,
|
|
'analytic_account_id': expense.analytic_account_id.id,
|
|
'analytic_tag_ids': [(6, 0, expense.analytic_tag_ids.ids)],
|
|
'expense_id': expense.id,
|
|
'partner_id': expense.employee_id.sudo().address_home_id.commercial_partner_id.id,
|
|
'tax_ids': [(6, 0, expense.tax_ids.ids)],
|
|
'currency_id': expense.currency_id.id,
|
|
})
|
|
for expense in sheet.expense_line_ids
|
|
]
|
|
}
|
|
for sheet in self.sheet_id
|
|
])
|
|
moves._post()
|
|
|
|
for expense in self:
|
|
if expense.payment_mode == 'company_account':
|
|
expense.sheet_id.paid_expense_sheets()
|
|
|
|
return {move.expense_sheet_id.id: move for move in moves}
|
|
|
|
def refuse_expense(self, reason):
|
|
self.write({'is_refused': True})
|
|
self.sheet_id.write({'state': 'cancel'})
|
|
self.sheet_id.message_post_with_view('hr_expense.hr_expense_template_refuse_reason',
|
|
values={'reason': reason, 'is_sheet': False, 'name': self.name})
|
|
|
|
@api.model
|
|
def get_expense_dashboard(self):
|
|
expense_state = {
|
|
'draft': {
|
|
'description': _('to report'),
|
|
'amount': 0.0,
|
|
'currency': self.env.company.currency_id.id,
|
|
},
|
|
'reported': {
|
|
'description': _('under validation'),
|
|
'amount': 0.0,
|
|
'currency': self.env.company.currency_id.id,
|
|
},
|
|
'approved': {
|
|
'description': _('to be reimbursed'),
|
|
'amount': 0.0,
|
|
'currency': self.env.company.currency_id.id,
|
|
}
|
|
}
|
|
if not self.env.user.employee_ids:
|
|
return expense_state
|
|
target_currency = self.env.company.currency_id
|
|
expenses = self.read_group(
|
|
[
|
|
('employee_id', 'in', self.env.user.employee_ids.ids),
|
|
('payment_mode', '=', 'own_account'),
|
|
('state', 'in', ['draft', 'reported', 'approved'])
|
|
], ['total_amount', 'currency_id', 'state'], ['state', 'currency_id'], lazy=False)
|
|
for expense in expenses:
|
|
state = expense['state']
|
|
currency = self.env['res.currency'].browse(expense['currency_id'][0]) if expense['currency_id'] else target_currency
|
|
amount = currency._convert(
|
|
expense['total_amount'], target_currency, self.env.company, fields.Date.today())
|
|
expense_state[state]['amount'] += amount
|
|
return expense_state
|
|
|
|
# ----------------------------------------
|
|
# Mail Thread
|
|
# ----------------------------------------
|
|
|
|
@api.model
|
|
def message_new(self, msg_dict, custom_values=None):
|
|
email_address = email_split(msg_dict.get('email_from', False))[0]
|
|
|
|
employee = self.env['hr.employee'].search([
|
|
'|',
|
|
('work_email', 'ilike', email_address),
|
|
('user_id.email', 'ilike', email_address)
|
|
], limit=1)
|
|
|
|
expense_description = msg_dict.get('subject', '')
|
|
|
|
if employee.user_id:
|
|
company = employee.user_id.company_id
|
|
currencies = company.currency_id | employee.user_id.company_ids.mapped('currency_id')
|
|
else:
|
|
company = employee.company_id
|
|
currencies = company.currency_id
|
|
|
|
if not company: # ultimate fallback, since company_id is required on expense
|
|
company = self.env.company
|
|
|
|
# The expenses alias is the same for all companies, we need to set the proper context
|
|
# To select the product account
|
|
self = self.with_company(company)
|
|
|
|
product, price, currency_id, expense_description = self._parse_expense_subject(expense_description, currencies)
|
|
vals = {
|
|
'employee_id': employee.id,
|
|
'name': expense_description,
|
|
'unit_amount': price,
|
|
'product_id': product.id if product else None,
|
|
'product_uom_id': product.uom_id.id,
|
|
'tax_ids': [(4, tax.id, False) for tax in product.supplier_taxes_id.filtered(lambda r: r.company_id == company)],
|
|
'quantity': 1,
|
|
'company_id': company.id,
|
|
'currency_id': currency_id.id
|
|
}
|
|
|
|
account = product.product_tmpl_id._get_product_accounts()['expense']
|
|
if account:
|
|
vals['account_id'] = account.id
|
|
|
|
expense = super(HrExpense, self).message_new(msg_dict, dict(custom_values or {}, **vals))
|
|
self._send_expense_success_mail(msg_dict, expense)
|
|
return expense
|
|
|
|
@api.model
|
|
def _parse_product(self, expense_description):
|
|
"""
|
|
Parse the subject to find the product.
|
|
Product code should be the first word of expense_description
|
|
Return product.product and updated description
|
|
"""
|
|
product_code = expense_description.split(' ')[0]
|
|
product = self.env['product.product'].search([('can_be_expensed', '=', True), ('default_code', '=ilike', product_code)], limit=1)
|
|
if product:
|
|
expense_description = expense_description.replace(product_code, '', 1)
|
|
|
|
return product, expense_description
|
|
|
|
@api.model
|
|
def _parse_price(self, expense_description, currencies):
|
|
""" Return price, currency and updated description """
|
|
symbols, symbols_pattern, float_pattern = [], '', '[+-]?(\d+[.,]?\d*)'
|
|
price = 0.0
|
|
for currency in currencies:
|
|
symbols.append(re.escape(currency.symbol))
|
|
symbols.append(re.escape(currency.name))
|
|
symbols_pattern = '|'.join(symbols)
|
|
price_pattern = "((%s)?\s?%s\s?(%s)?)" % (symbols_pattern, float_pattern, symbols_pattern)
|
|
matches = re.findall(price_pattern, expense_description)
|
|
if matches:
|
|
match = max(matches, key=lambda match: len([group for group in match if group])) # get the longuest match. e.g. "2 chairs 120$" -> the price is 120$, not 2
|
|
full_str = match[0]
|
|
currency_str = match[1] or match[3]
|
|
price = match[2].replace(',', '.')
|
|
|
|
if currency_str:
|
|
currency = currencies.filtered(lambda c: currency_str in [c.symbol, c.name])[0]
|
|
currency = currency or currencies[0]
|
|
expense_description = expense_description.replace(full_str, ' ') # remove price from description
|
|
expense_description = re.sub(' +', ' ', expense_description.strip())
|
|
|
|
price = float(price)
|
|
return price, currency, expense_description
|
|
|
|
@api.model
|
|
def _parse_expense_subject(self, expense_description, currencies):
|
|
""" Fetch product, price and currency info from mail subject.
|
|
|
|
Product can be identified based on product name or product code.
|
|
It can be passed between [] or it can be placed at start.
|
|
|
|
When parsing, only consider currencies passed as parameter.
|
|
This will fetch currency in symbol($) or ISO name (USD).
|
|
|
|
Some valid examples:
|
|
Travel by Air [TICKET] USD 1205.91
|
|
TICKET $1205.91 Travel by Air
|
|
Extra expenses 29.10EUR [EXTRA]
|
|
"""
|
|
product, expense_description = self._parse_product(expense_description)
|
|
price, currency_id, expense_description = self._parse_price(expense_description, currencies)
|
|
|
|
return product, price, currency_id, expense_description
|
|
|
|
# TODO: Make api.multi
|
|
def _send_expense_success_mail(self, msg_dict, expense):
|
|
mail_template_id = 'hr_expense.hr_expense_template_register' if expense.employee_id.user_id else 'hr_expense.hr_expense_template_register_no_user'
|
|
rendered_body = self.env['ir.qweb']._render(mail_template_id, {'expense': expense})
|
|
body = self.env['mail.render.mixin']._replace_local_links(rendered_body)
|
|
# TDE TODO: seems louche, check to use notify
|
|
if expense.employee_id.user_id.partner_id:
|
|
expense.message_post(
|
|
partner_ids=expense.employee_id.user_id.partner_id.ids,
|
|
subject='Re: %s' % msg_dict.get('subject', ''),
|
|
body=body,
|
|
subtype_id=self.env.ref('mail.mt_note').id,
|
|
email_layout_xmlid='mail.mail_notification_light',
|
|
)
|
|
else:
|
|
self.env['mail.mail'].sudo().create({
|
|
'email_from': self.env.user.email_formatted,
|
|
'author_id': self.env.user.partner_id.id,
|
|
'body_html': body,
|
|
'subject': 'Re: %s' % msg_dict.get('subject', ''),
|
|
'email_to': msg_dict.get('email_from', False),
|
|
'auto_delete': True,
|
|
'references': msg_dict.get('message_id'),
|
|
}).send()
|
|
|
|
|
|
class HrExpenseSheet(models.Model):
|
|
"""
|
|
Here are the rights associated with the expense flow
|
|
|
|
Action Group Restriction
|
|
=================================================================================
|
|
Submit Employee Only his own
|
|
Officer If he is expense manager of the employee, manager of the employee
|
|
or the employee is in the department managed by the officer
|
|
Manager Always
|
|
Approve Officer Not his own and he is expense manager of the employee, manager of the employee
|
|
or the employee is in the department managed by the officer
|
|
Manager Always
|
|
Post Anybody State = approve and journal_id defined
|
|
Done Anybody State = approve and journal_id defined
|
|
Cancel Officer Not his own and he is expense manager of the employee, manager of the employee
|
|
or the employee is in the department managed by the officer
|
|
Manager Always
|
|
=================================================================================
|
|
"""
|
|
_name = "hr.expense.sheet"
|
|
_inherit = ['mail.thread', 'mail.activity.mixin']
|
|
_description = "Expense Report"
|
|
_order = "accounting_date desc, id desc"
|
|
_check_company_auto = True
|
|
|
|
@api.model
|
|
def _default_employee_id(self):
|
|
return self.env.user.employee_id
|
|
|
|
@api.model
|
|
def _default_journal_id(self):
|
|
""" The journal is determining the company of the accounting entries generated from expense. We need to force journal company and expense sheet company to be the same. """
|
|
company_journal_id = self.env.company.expense_journal_id
|
|
if company_journal_id:
|
|
return company_journal_id.id
|
|
default_company_id = self.default_get(['company_id'])['company_id']
|
|
journal = self.env['account.journal'].search([('type', '=', 'purchase'), ('company_id', '=', default_company_id)], limit=1)
|
|
return journal.id
|
|
|
|
@api.model
|
|
def _default_bank_journal_id(self):
|
|
default_company_id = self.default_get(['company_id'])['company_id']
|
|
return self.env['account.journal'].search([('type', 'in', ['cash', 'bank']), ('company_id', '=', default_company_id)], limit=1)
|
|
|
|
name = fields.Char('Expense Report Summary', required=True, tracking=True)
|
|
expense_line_ids = fields.One2many('hr.expense', 'sheet_id', string='Expense Lines', copy=False)
|
|
is_editable = fields.Boolean("Expense Lines Are Editable By Current User", compute='_compute_is_editable')
|
|
expense_number = fields.Integer(compute='_compute_expense_number', string='Number of Expenses')
|
|
state = fields.Selection([
|
|
('draft', 'Draft'),
|
|
('submit', 'Submitted'),
|
|
('approve', 'Approved'),
|
|
('post', 'Posted'),
|
|
('done', 'Done'),
|
|
('cancel', 'Refused')
|
|
], string='Status', index=True, readonly=True, tracking=True, copy=False, default='draft', required=True)
|
|
payment_state = fields.Selection(
|
|
selection=lambda self: self.env["account.move"]._fields["payment_state"].selection,
|
|
string="Payment Status",
|
|
store=True, readonly=True, copy=False, tracking=True, compute='_compute_payment_state')
|
|
employee_id = fields.Many2one('hr.employee', string="Employee", required=True, readonly=True, tracking=True, states={'draft': [('readonly', False)]}, default=_default_employee_id, check_company=True, domain= lambda self: self.env['hr.expense']._get_employee_id_domain())
|
|
address_id = fields.Many2one('res.partner', compute='_compute_from_employee_id', store=True, readonly=False, copy=True, string="Employee Home Address", check_company=True)
|
|
payment_mode = fields.Selection(related='expense_line_ids.payment_mode', readonly=True, string="Paid By", tracking=True)
|
|
user_id = fields.Many2one('res.users', 'Manager', compute='_compute_from_employee_id', store=True, readonly=True, copy=False, states={'draft': [('readonly', False)]}, tracking=True, domain=lambda self: [('groups_id', 'in', self.env.ref('hr_expense.group_hr_expense_team_approver').id)])
|
|
total_amount = fields.Monetary('Total Amount', currency_field='currency_id', compute='_compute_amount', store=True, tracking=True)
|
|
untaxed_amount = fields.Monetary('Untaxed Amount', currency_field='currency_id', compute='_compute_amount', store=True)
|
|
total_amount_taxes = fields.Monetary('Taxes', currency_field='currency_id', compute='_compute_amount', store=True)
|
|
# sgv FIXME - this has a problem for expense in when there is one foreign currency. Maybe use amount_residual_signed
|
|
amount_residual = fields.Monetary(
|
|
string="Amount Due", store=True,
|
|
currency_field='currency_id',
|
|
related='account_move_id.amount_residual')
|
|
company_id = fields.Many2one('res.company', string='Company', required=True, readonly=True, states={'draft': [('readonly', False)]}, default=lambda self: self.env.company)
|
|
currency_id = fields.Many2one('res.currency', string='Currency', readonly=True, states={'draft': [('readonly', False)]}, default=lambda self: self.env.company.currency_id)
|
|
attachment_number = fields.Integer(compute='_compute_attachment_number', string='Number of Attachments')
|
|
journal_id = fields.Many2one('account.journal', string='Expense Journal', states={'done': [('readonly', True)], 'post': [('readonly', True)]}, check_company=True, domain="[('type', '=', 'purchase'), ('company_id', '=', company_id)]",
|
|
default=_default_journal_id, help="The journal used when the expense is done.")
|
|
bank_journal_id = fields.Many2one('account.journal', string='Bank Journal', states={'done': [('readonly', True)], 'post': [('readonly', True)]}, check_company=True, domain="[('type', 'in', ['cash', 'bank']), ('company_id', '=', company_id)]",
|
|
default=_default_bank_journal_id, help="The payment method used when the expense is paid by the company.")
|
|
accounting_date = fields.Date("Accounting Date")
|
|
account_move_id = fields.Many2one('account.move', string='Journal Entry', ondelete='restrict', copy=False, readonly=True)
|
|
department_id = fields.Many2one('hr.department', compute='_compute_from_employee_id', store=True, readonly=False, copy=False, string='Department', states={'post': [('readonly', True)], 'done': [('readonly', True)]})
|
|
is_multiple_currency = fields.Boolean("Handle lines with different currencies", compute='_compute_is_multiple_currency')
|
|
can_reset = fields.Boolean('Can Reset', compute='_compute_can_reset')
|
|
can_approve = fields.Boolean('Can Approve', compute='_compute_can_approve')
|
|
approval_date = fields.Datetime('Approval Date', readonly=True)
|
|
|
|
_sql_constraints = [
|
|
('journal_id_required_posted', "CHECK((state IN ('post', 'done') AND journal_id IS NOT NULL) OR (state NOT IN ('post', 'done')))", 'The journal must be set on posted expense'),
|
|
]
|
|
|
|
@api.depends('expense_line_ids.total_amount_company', 'expense_line_ids.amount_tax_company')
|
|
def _compute_amount(self):
|
|
for sheet in self:
|
|
sheet.total_amount = sum(sheet.expense_line_ids.mapped('total_amount_company'))
|
|
sheet.total_amount_taxes = sum(sheet.expense_line_ids.mapped('amount_tax_company'))
|
|
sheet.untaxed_amount = sheet.total_amount - sheet.total_amount_taxes
|
|
|
|
@api.depends('account_move_id.payment_state')
|
|
def _compute_payment_state(self):
|
|
for sheet in self:
|
|
sheet.payment_state = sheet.account_move_id.payment_state or 'not_paid'
|
|
|
|
def _compute_attachment_number(self):
|
|
for sheet in self:
|
|
sheet.attachment_number = sum(sheet.expense_line_ids.mapped('attachment_number'))
|
|
|
|
@api.depends('expense_line_ids.currency_id')
|
|
def _compute_is_multiple_currency(self):
|
|
for sheet in self:
|
|
sheet.is_multiple_currency = len(sheet.expense_line_ids.mapped('currency_id')) > 1
|
|
|
|
@api.depends('employee_id')
|
|
def _compute_can_reset(self):
|
|
is_expense_user = self.user_has_groups('hr_expense.group_hr_expense_team_approver')
|
|
for sheet in self:
|
|
sheet.can_reset = is_expense_user if is_expense_user else sheet.employee_id.user_id == self.env.user
|
|
|
|
@api.depends_context('uid')
|
|
@api.depends('employee_id')
|
|
def _compute_can_approve(self):
|
|
is_approver = self.user_has_groups('hr_expense.group_hr_expense_team_approver, hr_expense.group_hr_expense_user')
|
|
is_manager = self.user_has_groups('hr_expense.group_hr_expense_manager')
|
|
for sheet in self:
|
|
sheet.can_approve = is_manager or (is_approver and sheet.employee_id.user_id != self.env.user)
|
|
|
|
@api.depends('expense_line_ids')
|
|
def _compute_expense_number(self):
|
|
read_group_result = self.env['hr.expense']._read_group([('sheet_id', 'in', self.ids)], ['sheet_id'], ['sheet_id'])
|
|
result = dict((data['sheet_id'][0], data['sheet_id_count']) for data in read_group_result)
|
|
for sheet in self:
|
|
sheet.expense_number = result.get(sheet.id, 0)
|
|
|
|
@api.depends('employee_id')
|
|
def _compute_from_employee_id(self):
|
|
for sheet in self:
|
|
sheet.address_id = sheet.employee_id.sudo().address_home_id
|
|
sheet.department_id = sheet.employee_id.department_id
|
|
sheet.user_id = sheet.employee_id.expense_manager_id or sheet.employee_id.parent_id.user_id
|
|
|
|
@api.depends_context('uid')
|
|
@api.depends('employee_id', 'user_id', 'state')
|
|
def _compute_is_editable(self):
|
|
is_manager = self.user_has_groups('hr_expense.group_hr_expense_manager')
|
|
is_approver = self.user_has_groups('hr_expense.group_hr_expense_user')
|
|
for report in self:
|
|
# Employee can edit his own expense in draft only
|
|
is_editable = (report.employee_id.user_id == self.env.user and report.state == 'draft') or (is_manager and report.state in ['draft', 'submit', 'approve'])
|
|
if not is_editable and report.state in ['draft', 'submit', 'approve']:
|
|
# expense manager can edit, unless it's own expense
|
|
current_managers = report.employee_id.expense_manager_id | report.employee_id.parent_id.user_id | report.employee_id.department_id.manager_id.user_id | report.user_id
|
|
is_editable = (is_approver or self.env.user in current_managers) and report.employee_id.user_id != self.env.user
|
|
report.is_editable = is_editable
|
|
|
|
@api.constrains('expense_line_ids')
|
|
def _check_payment_mode(self):
|
|
for sheet in self:
|
|
expense_lines = sheet.mapped('expense_line_ids')
|
|
if expense_lines and any(expense.payment_mode != expense_lines[0].payment_mode for expense in expense_lines):
|
|
raise ValidationError(_("Expenses must have the same To Reimburse status."))
|
|
|
|
@api.constrains('expense_line_ids', 'employee_id')
|
|
def _check_employee(self):
|
|
for sheet in self:
|
|
employee_ids = sheet.expense_line_ids.mapped('employee_id')
|
|
if len(employee_ids) > 1 or (len(employee_ids) == 1 and employee_ids != sheet.employee_id):
|
|
raise ValidationError(_('You cannot add expenses of another employee.'))
|
|
|
|
@api.constrains('expense_line_ids', 'company_id')
|
|
def _check_expense_lines_company(self):
|
|
for sheet in self:
|
|
if any(expense.company_id != sheet.company_id for expense in sheet.expense_line_ids):
|
|
raise ValidationError(_('An expense report must contain only lines from the same company.'))
|
|
|
|
@api.model_create_multi
|
|
def create(self, vals_list):
|
|
context = clean_context(self.env.context)
|
|
context.update({
|
|
'mail_create_nosubscribe': True,
|
|
'mail_auto_subscribe_no_notify': True
|
|
})
|
|
sheets = super(HrExpenseSheet, self.with_context(context)).create(vals_list)
|
|
sheets.activity_update()
|
|
return sheets
|
|
|
|
@api.ondelete(at_uninstall=False)
|
|
def _unlink_except_posted_or_paid(self):
|
|
for expense in self:
|
|
if expense.state in ['post', 'done']:
|
|
raise UserError(_('You cannot delete a posted or paid expense.'))
|
|
|
|
# --------------------------------------------
|
|
# Mail Thread
|
|
# --------------------------------------------
|
|
|
|
def _get_mail_thread_data_attachments(self):
|
|
"""
|
|
In order to see in the sheet attachment preview the corresponding
|
|
expenses' attachments, the latter attachments are added to the fetched data for the sheet record.
|
|
"""
|
|
self.ensure_one()
|
|
res = super()._get_mail_thread_data_attachments()
|
|
expense_ids = self.expense_line_ids
|
|
expense_attachments = self.env['ir.attachment'].search([('res_id', 'in', expense_ids.ids), ('res_model', '=', 'hr.expense')], order='id desc')
|
|
return res | expense_attachments
|
|
|
|
def _track_subtype(self, init_values):
|
|
self.ensure_one()
|
|
if 'state' in init_values and self.state == 'approve':
|
|
return self.env.ref('hr_expense.mt_expense_approved')
|
|
elif 'state' in init_values and self.state == 'cancel':
|
|
return self.env.ref('hr_expense.mt_expense_refused')
|
|
elif 'state' in init_values and self.state == 'done':
|
|
return self.env.ref('hr_expense.mt_expense_paid')
|
|
return super(HrExpenseSheet, self)._track_subtype(init_values)
|
|
|
|
def _message_auto_subscribe_followers(self, updated_values, subtype_ids):
|
|
res = super(HrExpenseSheet, self)._message_auto_subscribe_followers(updated_values, subtype_ids)
|
|
if updated_values.get('employee_id'):
|
|
employee = self.env['hr.employee'].browse(updated_values['employee_id'])
|
|
if employee.user_id:
|
|
res.append((employee.user_id.partner_id.id, subtype_ids, False))
|
|
return res
|
|
|
|
# --------------------------------------------
|
|
# Actions
|
|
# --------------------------------------------
|
|
|
|
def action_sheet_move_create(self):
|
|
samples = self.mapped('expense_line_ids.sample')
|
|
if samples.count(True):
|
|
if samples.count(False):
|
|
raise UserError(_("You can't mix sample expenses and regular ones"))
|
|
self.write({'state': 'post'})
|
|
return
|
|
|
|
if any(sheet.state != 'approve' for sheet in self):
|
|
raise UserError(_("You can only generate accounting entry for approved expense(s)."))
|
|
|
|
if any(not sheet.journal_id for sheet in self):
|
|
raise UserError(_("Specify expense journal to generate accounting entries."))
|
|
|
|
expense_line_ids = self.mapped('expense_line_ids')\
|
|
.filtered(lambda r: not float_is_zero(r.total_amount, precision_rounding=(r.currency_id or self.env.company.currency_id).rounding))
|
|
res = expense_line_ids.with_context(clean_context(self.env.context)).action_move_create()
|
|
for sheet in self.filtered(lambda s: not s.accounting_date):
|
|
sheet.accounting_date = sheet.account_move_id.date
|
|
to_post = self.filtered(lambda sheet: sheet.payment_mode == 'own_account' and sheet.expense_line_ids)
|
|
to_post.write({'state': 'post'})
|
|
(self - to_post).write({'state': 'done'})
|
|
self.activity_update()
|
|
return res
|
|
|
|
def action_unpost(self):
|
|
for sheet in self:
|
|
move = sheet.account_move_id
|
|
sheet.account_move_id = False
|
|
if move.state == 'draft':
|
|
move.unlink()
|
|
else:
|
|
move._reverse_moves(cancel=True)
|
|
sheet.write({'state': 'draft'})
|
|
|
|
def action_get_attachment_view(self):
|
|
res = self.env['ir.actions.act_window']._for_xml_id('base.action_attachment')
|
|
res['domain'] = [('res_model', '=', 'hr.expense'), ('res_id', 'in', self.expense_line_ids.ids)]
|
|
res['context'] = {
|
|
'default_res_model': 'hr.expense.sheet',
|
|
'default_res_id': self.id,
|
|
'create': False,
|
|
'edit': False,
|
|
}
|
|
return res
|
|
|
|
def action_get_expense_view(self):
|
|
self.ensure_one()
|
|
return {
|
|
'name': _('Expenses'),
|
|
'type': 'ir.actions.act_window',
|
|
'view_mode': 'list,form',
|
|
'res_model': 'hr.expense',
|
|
'domain': [('id', 'in', self.expense_line_ids.ids)],
|
|
}
|
|
|
|
def action_open_account_move(self):
|
|
self.ensure_one()
|
|
return {
|
|
'name': self.account_move_id.name,
|
|
'type': 'ir.actions.act_window',
|
|
'view_type': 'form',
|
|
'view_mode': 'form',
|
|
'res_model': 'account.move',
|
|
'res_id': self.account_move_id.id
|
|
}
|
|
|
|
# --------------------------------------------
|
|
# Business
|
|
# --------------------------------------------
|
|
|
|
def set_to_paid(self):
|
|
self.write({'state': 'done'})
|
|
|
|
def action_submit_sheet(self):
|
|
self.write({'state': 'submit'})
|
|
self.sudo().activity_update()
|
|
|
|
def _check_can_approve(self):
|
|
if not self.user_has_groups('hr_expense.group_hr_expense_team_approver'):
|
|
raise UserError(_("Only Managers and HR Officers can approve expenses"))
|
|
elif not self.user_has_groups('hr_expense.group_hr_expense_manager'):
|
|
current_managers = self.employee_id.expense_manager_id | self.employee_id.parent_id.user_id | self.employee_id.department_id.manager_id.user_id | self.user_id
|
|
|
|
if self.employee_id.user_id == self.env.user:
|
|
raise UserError(_("You cannot approve your own expenses"))
|
|
|
|
if not self.env.user in current_managers and not self.user_has_groups('hr_expense.group_hr_expense_user') and self.employee_id.expense_manager_id != self.env.user:
|
|
raise UserError(_("You can only approve your department expenses"))
|
|
|
|
def approve_expense_sheets(self):
|
|
self._check_can_approve()
|
|
|
|
duplicates = self.expense_line_ids.duplicate_expense_ids.filtered(lambda exp: exp.state in ['approved', 'done'])
|
|
if duplicates:
|
|
action = self.env["ir.actions.act_window"]._for_xml_id('hr_expense.hr_expense_approve_duplicate_action')
|
|
action['context'] = {'default_sheet_ids': self.ids, 'default_expense_ids': duplicates.ids}
|
|
return action
|
|
self._do_approve()
|
|
|
|
def _do_approve(self):
|
|
self._check_can_approve()
|
|
|
|
notification = {
|
|
'type': 'ir.actions.client',
|
|
'tag': 'display_notification',
|
|
'params': {
|
|
'title': _('There are no expense reports to approve.'),
|
|
'type': 'warning',
|
|
'sticky': False, #True/False will display for few seconds if false
|
|
},
|
|
}
|
|
|
|
filtered_sheet = self.filtered(lambda s: s.state in ['submit', 'draft'])
|
|
if not filtered_sheet:
|
|
return notification
|
|
for sheet in filtered_sheet:
|
|
sheet.write({'state': 'approve', 'user_id': sheet.user_id.id or self.env.user.id})
|
|
notification['params'].update({
|
|
'title': _('The expense reports were successfully approved.'),
|
|
'type': 'success',
|
|
'next': {'type': 'ir.actions.act_window_close'},
|
|
})
|
|
|
|
self.activity_update()
|
|
return notification
|
|
|
|
def paid_expense_sheets(self):
|
|
self.write({'state': 'done'})
|
|
|
|
def refuse_sheet(self, reason):
|
|
if not self.user_has_groups('hr_expense.group_hr_expense_team_approver'):
|
|
raise UserError(_("Only Managers and HR Officers can approve expenses"))
|
|
elif not self.user_has_groups('hr_expense.group_hr_expense_manager'):
|
|
current_managers = self.employee_id.expense_manager_id | self.employee_id.parent_id.user_id | self.employee_id.department_id.manager_id.user_id | self.user_id
|
|
|
|
if self.employee_id.user_id == self.env.user:
|
|
raise UserError(_("You cannot refuse your own expenses"))
|
|
|
|
if not self.env.user in current_managers and not self.user_has_groups('hr_expense.group_hr_expense_user') and self.employee_id.expense_manager_id != self.env.user:
|
|
raise UserError(_("You can only refuse your department expenses"))
|
|
|
|
self.write({'state': 'cancel'})
|
|
for sheet in self:
|
|
sheet.message_post_with_view('hr_expense.hr_expense_template_refuse_reason', values={'reason': reason, 'is_sheet': True, 'name': sheet.name})
|
|
self.activity_update()
|
|
|
|
def reset_expense_sheets(self):
|
|
if not self.can_reset:
|
|
raise UserError(_("Only HR Officers or the concerned employee can reset to draft."))
|
|
self.mapped('expense_line_ids').write({'is_refused': False})
|
|
self.sudo().write({'state': 'draft', 'approval_date': False})
|
|
self.activity_update()
|
|
return True
|
|
|
|
def _get_responsible_for_approval(self):
|
|
if self.user_id:
|
|
return self.user_id
|
|
elif self.employee_id.parent_id.user_id:
|
|
return self.employee_id.parent_id.user_id
|
|
elif self.employee_id.department_id.manager_id.user_id:
|
|
return self.employee_id.department_id.manager_id.user_id
|
|
return self.env['res.users']
|
|
|
|
def activity_update(self):
|
|
reports_requiring_feedback = self.env['hr.expense.sheet']
|
|
reports_activity_unlink = self.env['hr.expense.sheet']
|
|
for expense_report in self:
|
|
if expense_report.state == 'submit':
|
|
expense_report.activity_schedule(
|
|
'hr_expense.mail_act_expense_approval',
|
|
user_id=expense_report.sudo()._get_responsible_for_approval().id or self.env.user.id)
|
|
elif expense_report.state == 'approve':
|
|
reports_requiring_feedback |= expense_report
|
|
elif expense_report.state in ('draft', 'cancel'):
|
|
reports_activity_unlink |= expense_report
|
|
if reports_requiring_feedback:
|
|
reports_requiring_feedback.activity_feedback(['hr_expense.mail_act_expense_approval'])
|
|
if reports_activity_unlink:
|
|
reports_activity_unlink.activity_unlink(['hr_expense.mail_act_expense_approval'])
|
|
|
|
def action_register_payment(self):
|
|
''' Open the account.payment.register wizard to pay the selected journal entries.
|
|
:return: An action opening the account.payment.register wizard.
|
|
'''
|
|
return {
|
|
'name': _('Register Payment'),
|
|
'res_model': 'account.payment.register',
|
|
'view_mode': 'form',
|
|
'context': {
|
|
'active_model': 'account.move',
|
|
'active_ids': self.account_move_id.ids,
|
|
'partner_bank_id': self.employee_id.bank_account_id.id
|
|
},
|
|
'target': 'new',
|
|
'type': 'ir.actions.act_window',
|
|
}
|