789 lines
39 KiB
Python
789 lines
39 KiB
Python
from collections import defaultdict
|
|
from datetime import timedelta
|
|
|
|
from odoo import api, Command, fields, models, _
|
|
from odoo.exceptions import UserError
|
|
from odoo.tools import groupby, SQL
|
|
from odoo.tools.misc import formatLang
|
|
|
|
|
|
class AccountReconcileWizard(models.TransientModel):
|
|
""" This wizard is used to reconcile selected account.move.line. """
|
|
_name = 'account.reconcile.wizard'
|
|
_description = 'Account reconciliation wizard'
|
|
_check_company_auto = True
|
|
|
|
@api.model
|
|
def default_get(self, fields):
|
|
res = super().default_get(fields)
|
|
if 'move_line_ids' not in fields:
|
|
return res
|
|
if self.env.context.get('active_model') != 'account.move.line' or not self.env.context.get('active_ids'):
|
|
raise UserError(_('This can only be used on journal items'))
|
|
move_line_ids = self.env['account.move.line'].browse(self.env.context['active_ids'])
|
|
accounts = move_line_ids.account_id
|
|
if len(accounts) > 2:
|
|
raise UserError(_(
|
|
'You can only reconcile entries with up to two different accounts: %s',
|
|
', '.join(accounts.mapped('display_name')),
|
|
))
|
|
shadowed_aml_values = None
|
|
if len(accounts) == 2:
|
|
shadowed_aml_values = {
|
|
aml: {'account_id': move_line_ids[0].account_id}
|
|
for aml in move_line_ids.filtered(lambda line: line.account_id != move_line_ids[0].account_id)
|
|
}
|
|
move_line_ids._check_amls_exigibility_for_reconciliation(shadowed_aml_values=shadowed_aml_values)
|
|
res['move_line_ids'] = [Command.set(move_line_ids.ids)]
|
|
return res
|
|
|
|
company_id = fields.Many2one(comodel_name='res.company', required=True, readonly=True, compute='_compute_company_id')
|
|
move_line_ids = fields.Many2many(
|
|
comodel_name='account.move.line',
|
|
string='Move lines to reconcile',
|
|
required=True)
|
|
reco_account_id = fields.Many2one(
|
|
comodel_name='account.account',
|
|
string='Reconcile Account',
|
|
compute='_compute_reco_wizard_data')
|
|
amount = fields.Monetary(
|
|
string='Amount in company currency',
|
|
currency_field='company_currency_id',
|
|
compute='_compute_reco_wizard_data')
|
|
company_currency_id = fields.Many2one(comodel_name='res.currency', string='Company currency', related='company_id.currency_id')
|
|
amount_currency = fields.Monetary(
|
|
string='Amount',
|
|
currency_field='reco_currency_id',
|
|
compute='_compute_reco_wizard_data')
|
|
reco_currency_id = fields.Many2one(
|
|
comodel_name='res.currency',
|
|
string='Currency to use for reconciliation',
|
|
compute='_compute_reco_wizard_data')
|
|
edit_mode_amount = fields.Monetary(
|
|
currency_field='company_currency_id',
|
|
compute='_compute_edit_mode_amount',
|
|
)
|
|
edit_mode_amount_currency = fields.Monetary(
|
|
string='Edit mode amount',
|
|
currency_field='edit_mode_reco_currency_id',
|
|
compute='_compute_edit_mode_amount_currency',
|
|
store=True,
|
|
readonly=False,
|
|
)
|
|
edit_mode_reco_currency_id = fields.Many2one(
|
|
comodel_name='res.currency',
|
|
compute='_compute_edit_mode_reco_currency',
|
|
)
|
|
edit_mode = fields.Boolean(
|
|
compute='_compute_edit_mode',
|
|
)
|
|
single_currency_mode = fields.Boolean(compute='_compute_single_currency_mode')
|
|
allow_partials = fields.Boolean(string="Allow partials", compute='_compute_allow_partials', store=True, readonly=False)
|
|
force_partials = fields.Boolean(compute='_compute_reco_wizard_data')
|
|
display_allow_partials = fields.Boolean(compute='_compute_display_allow_partials')
|
|
date = fields.Date(string='Date', compute='_compute_date', store=True, readonly=False)
|
|
journal_id = fields.Many2one(
|
|
comodel_name='account.journal',
|
|
string='Journal',
|
|
check_company=True,
|
|
domain="[('type', '=', 'general')]",
|
|
compute='_compute_journal_id',
|
|
store=True,
|
|
readonly=False,
|
|
required=True,
|
|
precompute=True)
|
|
account_id = fields.Many2one(
|
|
comodel_name='account.account',
|
|
string='Account',
|
|
check_company=True,
|
|
domain="[('account_type', '!=', 'off_balance')]")
|
|
is_rec_pay_account = fields.Boolean(compute='_compute_is_rec_pay_account')
|
|
to_partner_id = fields.Many2one(
|
|
comodel_name='res.partner',
|
|
string='Partner',
|
|
check_company=True,
|
|
compute='_compute_to_partner_id',
|
|
store=True,
|
|
readonly=False,
|
|
)
|
|
label = fields.Char(string='Label', default='Write-Off')
|
|
tax_id = fields.Many2one(
|
|
comodel_name='account.tax',
|
|
string='Tax',
|
|
default=False,
|
|
check_company=True)
|
|
to_check = fields.Boolean(
|
|
string='To Check',
|
|
default=False,
|
|
help='Check if you are not certain of all the information of the counterpart.')
|
|
is_write_off_required = fields.Boolean(
|
|
string='Is a write-off move required to reconcile',
|
|
compute='_compute_is_write_off_required')
|
|
is_transfer_required = fields.Boolean(
|
|
string='Is an account transfer required',
|
|
compute='_compute_reco_wizard_data')
|
|
transfer_warning_message = fields.Char(
|
|
string='Is an account transfer required to reconcile',
|
|
compute='_compute_reco_wizard_data')
|
|
transfer_from_account_id = fields.Many2one(
|
|
comodel_name='account.account',
|
|
string='Account Transfer From',
|
|
compute='_compute_reco_wizard_data')
|
|
lock_date_violated_warning_message = fields.Char(
|
|
string='Is the date violating the lock date of moves',
|
|
compute='_compute_lock_date_violated_warning_message')
|
|
reco_model_id = fields.Many2one(
|
|
comodel_name='account.reconcile.model',
|
|
string='Reconciliation model',
|
|
store=False,
|
|
check_company=True)
|
|
reco_model_autocomplete_ids = fields.Many2many(
|
|
comodel_name='account.reconcile.model',
|
|
string='All reconciliation models',
|
|
compute='_compute_reco_model_autocomplete_ids')
|
|
|
|
# ==== Compute methods ====
|
|
@api.depends('move_line_ids.company_id')
|
|
def _compute_company_id(self):
|
|
for wizard in self:
|
|
wizard.company_id = wizard.move_line_ids[0].company_id
|
|
|
|
@api.depends('move_line_ids')
|
|
def _compute_single_currency_mode(self):
|
|
for wizard in self:
|
|
wizard.single_currency_mode = len(wizard.move_line_ids.currency_id - wizard.company_currency_id) <= 1
|
|
|
|
@api.depends('force_partials')
|
|
def _compute_allow_partials(self):
|
|
for wizard in self:
|
|
wizard.allow_partials = wizard.display_allow_partials and wizard.force_partials
|
|
|
|
@api.depends('move_line_ids')
|
|
def _compute_display_allow_partials(self):
|
|
""" We only display the allow partial checkbox if there is both credit and debit lines involved. """
|
|
for wizard in self:
|
|
wizard.display_allow_partials = has_debit_line = has_credit_line = False
|
|
for aml in wizard.move_line_ids:
|
|
if aml.balance > 0.0 or aml.amount_currency > 0.0:
|
|
has_debit_line = True
|
|
elif aml.balance < 0.0 or aml.amount_currency < 0.0:
|
|
has_credit_line = True
|
|
if has_debit_line and has_credit_line:
|
|
wizard.display_allow_partials = True
|
|
break
|
|
|
|
@api.depends('move_line_ids', 'journal_id', 'tax_id')
|
|
def _compute_date(self):
|
|
for wizard in self:
|
|
highest_date = max(aml.date for aml in wizard.move_line_ids)
|
|
temp_move = self.env['account.move'].new({'journal_id': wizard.journal_id.id})
|
|
wizard.date = temp_move._get_accounting_date(highest_date, bool(wizard.tax_id))
|
|
|
|
@api.depends('company_id')
|
|
def _compute_journal_id(self):
|
|
for wizard in self:
|
|
wizard.journal_id = self.env['account.journal'].search([
|
|
*self.env['account.journal']._check_company_domain(wizard.company_id),
|
|
('type', '=', 'general')
|
|
], limit=1)
|
|
|
|
@api.depends('account_id')
|
|
def _compute_is_rec_pay_account(self):
|
|
for wizard in self:
|
|
wizard.is_rec_pay_account = wizard.account_id.account_type in ('asset_receivable', 'liability_payable')
|
|
|
|
@api.depends('is_rec_pay_account')
|
|
def _compute_to_partner_id(self):
|
|
for wizard in self:
|
|
if wizard.is_rec_pay_account:
|
|
partners = wizard.move_line_ids.partner_id
|
|
wizard.to_partner_id = partners if len(partners) == 1 else None
|
|
else:
|
|
wizard.to_partner_id = None
|
|
|
|
@api.depends('amount', 'amount_currency')
|
|
def _compute_is_write_off_required(self):
|
|
""" We need a write-off if the balance is not 0 and if we don't allow partial reconciliation."""
|
|
for wizard in self:
|
|
wizard.is_write_off_required = not wizard.company_currency_id.is_zero(wizard.amount) \
|
|
or (wizard.reco_currency_id and not wizard.reco_currency_id.is_zero(wizard.amount_currency))
|
|
|
|
@api.depends('move_line_ids')
|
|
def _compute_reco_wizard_data(self):
|
|
""" Compute various data needed for the reco wizard.
|
|
1. The currency to use for the reconciliation:
|
|
- if only one foreign currency is present in move lines we use it, unless the reco_account is not
|
|
payable nor receivable,
|
|
- if no foreign currency or more than 1 are used we use the company's default currency.
|
|
2. The account the reconciliation will happen on.
|
|
3. Transfer data.
|
|
4. Write-off amounts.
|
|
"""
|
|
|
|
def get_transfer_data(move_lines):
|
|
amounts_per_account = defaultdict(float)
|
|
for line in move_lines:
|
|
amounts_per_account[line.account_id] += line.amount_residual
|
|
if abs(amounts_per_account[accounts[0]]) < abs(amounts_per_account[accounts[1]]):
|
|
transfer_from_account, transfer_to_account = accounts[0], accounts[1]
|
|
else:
|
|
transfer_from_account, transfer_to_account = accounts[1], accounts[0]
|
|
|
|
amls_to_transfer = amls.filtered(lambda aml: aml.account_id == transfer_from_account)
|
|
transfer_foreign_curr = amls.currency_id - amls.company_currency_id
|
|
if len(transfer_foreign_curr) == 1:
|
|
transfer_currency = transfer_foreign_curr
|
|
transfer_amount_currency = sum(aml.amount_currency for aml in amls_to_transfer)
|
|
else:
|
|
transfer_currency = amls.company_currency_id
|
|
transfer_amount_currency = sum(aml.balance for aml in amls_to_transfer)
|
|
|
|
if transfer_amount_currency == 0.0 and transfer_currency != amls.company_currency_id:
|
|
# handle the transfer of exchange diff
|
|
transfer_currency = amls.company_currency_id
|
|
transfer_amount_currency = sum(aml.balance for aml in amls_to_transfer)
|
|
|
|
amount_formatted = formatLang(self.env, abs(transfer_amount_currency), currency_obj=transfer_currency)
|
|
transfer_warning_message = _(
|
|
'An entry will transfer %(amount)s from %(from_account)s to %(to_account)s.',
|
|
amount=amount_formatted,
|
|
from_account=transfer_from_account.display_name if transfer_amount_currency < 0 else transfer_to_account.display_name,
|
|
to_account=transfer_to_account.display_name if transfer_amount_currency < 0 else transfer_from_account.display_name,
|
|
)
|
|
return {
|
|
'transfer_from_account_id': transfer_from_account,
|
|
'reco_account_id': transfer_to_account,
|
|
'transfer_warning_message': transfer_warning_message,
|
|
}
|
|
|
|
def get_reco_currency(amls, aml_values_map):
|
|
company_currency = amls.company_currency_id
|
|
foreign_currencies = amls.currency_id - company_currency
|
|
if len(foreign_currencies) == 0:
|
|
return company_currency
|
|
elif len(foreign_currencies) == 1:
|
|
return foreign_currencies
|
|
else:
|
|
lines_with_residuals = self.env['account.move.line']
|
|
for residual, residual_values in aml_values_map.items():
|
|
if residual_values['amount_residual'] or residual_values['amount_residual_currency']:
|
|
lines_with_residuals += residual
|
|
if lines_with_residuals and len(lines_with_residuals.currency_id - company_currency) > 1:
|
|
# there is more than one residual and more than one currency in them
|
|
return False
|
|
return (lines_with_residuals.currency_id - company_currency) or company_currency
|
|
|
|
for wizard in self:
|
|
amls = wizard.move_line_ids._origin
|
|
accounts = amls.account_id # there is only 1 or 2 possible accounts
|
|
|
|
wizard.reco_currency_id = False
|
|
wizard.amount_currency = wizard.amount = 0.0
|
|
wizard.force_partials = True
|
|
wizard.transfer_from_account_id = wizard.transfer_warning_message = False
|
|
wizard.is_transfer_required = len(accounts) == 2
|
|
if wizard.is_transfer_required:
|
|
wizard.update(get_transfer_data(amls))
|
|
else:
|
|
wizard.reco_account_id = accounts
|
|
|
|
# Compute the residual amounts for each account.
|
|
shadowed_aml_values = {
|
|
aml: {'account_id': wizard.reco_account_id}
|
|
for aml in amls
|
|
}
|
|
|
|
# Batch the amls all together to know what should be reconciled and when.
|
|
plan_list, all_amls = amls._optimize_reconciliation_plan([amls], shadowed_aml_values=shadowed_aml_values)
|
|
|
|
# Prefetch data
|
|
all_amls.move_id
|
|
all_amls.matched_debit_ids
|
|
all_amls.matched_credit_ids
|
|
|
|
# All residual amounts are collected and updated until the creation of partials in batch.
|
|
# This is done that way to minimize the orm time for fields invalidation/mark as recompute and
|
|
# re-computation.
|
|
aml_values_map = {
|
|
aml: {
|
|
'aml': aml,
|
|
'amount_residual': aml.amount_residual,
|
|
'amount_residual_currency': aml.amount_residual_currency,
|
|
}
|
|
for aml in all_amls
|
|
}
|
|
|
|
plan = plan_list[0]
|
|
# residuals are subtracted from aml_values_map
|
|
amls._prepare_reconciliation_plan(plan, aml_values_map, shadowed_aml_values=shadowed_aml_values)
|
|
|
|
reco_currency = get_reco_currency(amls, aml_values_map)
|
|
if not reco_currency:
|
|
continue # stop the computation, no possible write-off => force partials
|
|
|
|
residual_amounts = {
|
|
aml: aml._prepare_move_line_residual_amounts(aml_values, reco_currency, shadowed_aml_values=shadowed_aml_values)
|
|
for aml, aml_values in aml_values_map.items()
|
|
}
|
|
|
|
if all(reco_currency in residual_values for residual_values in residual_amounts.values() if residual_values):
|
|
wizard.reco_currency_id = reco_currency
|
|
elif all(amls.company_currency_id in residual_values for residual_values in residual_amounts.values() if residual_values):
|
|
wizard.reco_currency_id = amls.company_currency_id
|
|
reco_currency = wizard.reco_currency_id
|
|
else:
|
|
continue # stop the computation, no possible write-off => force partials
|
|
|
|
# Compute write-off amounts
|
|
most_recent_line = max(amls, key=lambda aml: aml.date)
|
|
if not most_recent_line.amount_currency:
|
|
rate = rate_lower_bound = rate_upper_bound = 0.0
|
|
elif most_recent_line.currency_id == reco_currency:
|
|
rate = abs(most_recent_line.balance / most_recent_line.amount_currency)
|
|
# By estimating the rate from the most recent line, we are exposing ourselves to an estimation error because
|
|
# balance is amount_currency * rate, rounded to the nearest precision of the company currency. We now compute
|
|
# the lower/upper bounds of the estimated rate in order to determine which other AMLs share the same rate.
|
|
# For AMLs that share the same rate, we will use the existing amount_residual instead of recomputing it
|
|
# based on the amount_residual_currency and the rate.
|
|
rate_tolerance = amls.company_currency_id.rounding / 2 / abs(most_recent_line.amount_currency)
|
|
rate_lower_bound = rate - rate_tolerance
|
|
rate_upper_bound = rate + rate_tolerance
|
|
else:
|
|
rate = self.env['res.currency']._get_conversion_rate(reco_currency, amls.company_currency_id, amls.company_id, most_recent_line.date)
|
|
rate_lower_bound = rate_upper_bound = rate
|
|
|
|
# If an AML's rate is close enough to the reconciliation rate that it could be the same,
|
|
# use the `amount_residual` instead of computing `amount_residual_currency / rate` and rounding.
|
|
# We do this for the case where a single rate is used for all reconciled AMLs so we want to avoid
|
|
# creating an exchange diff because that would be weird.
|
|
amls_where_amounts_at_correct_rate = {
|
|
aml
|
|
for aml, residual_values in residual_amounts.items()
|
|
if (
|
|
aml.currency_id == reco_currency
|
|
and abs(aml.balance) >= aml.company_currency_id.round(abs(aml.amount_currency) * rate_lower_bound)
|
|
and abs(aml.balance) <= aml.company_currency_id.round(abs(aml.amount_currency) * rate_upper_bound)
|
|
)
|
|
}
|
|
|
|
wizard.amount_currency = sum(
|
|
residual_values[wizard.reco_currency_id]['residual']
|
|
for residual_values in residual_amounts.values()
|
|
if residual_values
|
|
)
|
|
amount_raw = sum(
|
|
(
|
|
residual_values[amls.company_currency_id]['residual']
|
|
if aml in amls_where_amounts_at_correct_rate and amls.company_currency_id in residual_values else
|
|
residual_values[wizard.reco_currency_id]['residual'] * rate
|
|
)
|
|
for aml, residual_values in residual_amounts.items()
|
|
if residual_values
|
|
)
|
|
wizard.amount = amls.company_currency_id.round(amount_raw)
|
|
wizard.force_partials = False
|
|
|
|
@api.depends('move_line_ids')
|
|
def _compute_edit_mode_amount_currency(self):
|
|
for wizard in self:
|
|
if wizard.edit_mode:
|
|
wizard.edit_mode_amount_currency = wizard.amount_currency
|
|
else:
|
|
wizard.edit_mode_amount_currency = 0.0
|
|
|
|
@api.depends('edit_mode_amount_currency')
|
|
def _compute_edit_mode_amount(self):
|
|
for wizard in self:
|
|
if wizard.edit_mode:
|
|
single_line = wizard.move_line_ids
|
|
rate = abs(single_line.amount_currency / single_line.balance) if single_line.balance else 0.0
|
|
wizard.edit_mode_amount = single_line.company_currency_id.round(wizard.edit_mode_amount_currency / rate) if rate else 0.0
|
|
else:
|
|
wizard.edit_mode_amount = 0.0
|
|
|
|
@api.depends('move_line_ids')
|
|
def _compute_edit_mode_reco_currency(self):
|
|
for wizard in self:
|
|
if wizard.edit_mode:
|
|
wizard.edit_mode_reco_currency_id = wizard.move_line_ids.currency_id
|
|
else:
|
|
wizard.edit_mode_reco_currency_id = False
|
|
|
|
@api.depends('move_line_ids')
|
|
def _compute_edit_mode(self):
|
|
for wizard in self:
|
|
wizard.edit_mode = len(wizard.move_line_ids) == 1
|
|
|
|
@api.depends('move_line_ids.move_id', 'date')
|
|
def _compute_lock_date_violated_warning_message(self):
|
|
for wizard in self:
|
|
date_after_lock = wizard._get_date_after_lock_date()
|
|
lock_date_violated_warning_message = None
|
|
if date_after_lock:
|
|
lock_date_violated_warning_message = _(
|
|
'The date you set violates the lock date of one of your entry. It will be overriden by the following date : %(replacement_date)s',
|
|
replacement_date=date_after_lock,
|
|
)
|
|
wizard.lock_date_violated_warning_message = lock_date_violated_warning_message
|
|
|
|
@api.depends('company_id', 'move_line_ids.partner_id', 'amount')
|
|
def _compute_reco_model_autocomplete_ids(self):
|
|
""" Computes available reconcile models, we only take manually created models that
|
|
have one (and only one) line, and have partners, amount, or journal that match the
|
|
ones of the entries.
|
|
"""
|
|
for wizard in self:
|
|
domain = [
|
|
('company_id', '=', wizard.company_id.id),
|
|
'|',
|
|
('match_partner_ids', '=', False),
|
|
('match_partner_ids', 'any', [('id', 'in', wizard.move_line_ids.partner_id.ids)]),
|
|
'|',
|
|
('match_amount', '=', False),
|
|
'|',
|
|
'&',
|
|
('match_amount', '=', 'lower'),
|
|
('match_amount_max', '>', wizard.amount),
|
|
'|',
|
|
'&',
|
|
('match_amount', '=', 'greater'),
|
|
('match_amount_min', '<', wizard.amount),
|
|
'&',
|
|
('match_amount', '=', 'between'),
|
|
'&',
|
|
('match_amount_min', '<', wizard.amount),
|
|
('match_amount_max', '>', wizard.amount),
|
|
'|',
|
|
('match_journal_ids', '=', False),
|
|
('match_journal_ids', 'in', wizard.move_line_ids.journal_id.ids),
|
|
('created_automatically', '=', False),
|
|
]
|
|
query = self.env['account.reconcile.model']._search(domain, bypass_access=True)
|
|
reco_model_ids = [r[0] for r in self.env.execute_query(SQL("""
|
|
SELECT account_reconcile_model.id
|
|
FROM %s
|
|
JOIN account_reconcile_model_line line ON line.model_id = account_reconcile_model.id
|
|
WHERE %s
|
|
GROUP BY account_reconcile_model.id
|
|
HAVING COUNT(account_reconcile_model.id) = 1
|
|
""", query.from_clause, query.where_clause or SQL("TRUE")))]
|
|
wizard.reco_model_autocomplete_ids = self.env['account.reconcile.model'].browse(reco_model_ids)
|
|
|
|
# ==== Onchange methods ====
|
|
@api.onchange('reco_model_id')
|
|
def _onchange_reco_model_id(self):
|
|
""" We prefill the write-off data with the reconcile model selected. """
|
|
if self.reco_model_id:
|
|
self.label = self.reco_model_id.line_ids.label
|
|
self.tax_id = self.reco_model_id.line_ids.tax_ids[0] if self.reco_model_id.line_ids[0].tax_ids else None
|
|
self.account_id = self.reco_model_id.line_ids.account_id
|
|
|
|
# ==== Python constrains ====
|
|
@api.constrains('edit_mode_amount_currency')
|
|
def _check_min_max_edit_mode_amount_currency(self):
|
|
for wizard in self:
|
|
if wizard.edit_mode:
|
|
if wizard.edit_mode_amount_currency == 0.0:
|
|
raise UserError(_('The amount of the write-off of a single line cannot be 0.'))
|
|
is_debit_line = wizard.move_line_ids.balance > 0.0 or wizard.move_line_ids.amount_currency > 0.0
|
|
if is_debit_line and wizard.edit_mode_amount_currency < 0.0:
|
|
raise UserError(_('The amount of the write-off of a single debit line should be strictly positive.'))
|
|
elif not is_debit_line and wizard.edit_mode_amount_currency > 0.0:
|
|
raise UserError(_('The amount of the write-off of a single credit line should be strictly negative.'))
|
|
|
|
# ==== Actions methods ====
|
|
def _action_open_wizard(self):
|
|
self.ensure_one()
|
|
return {
|
|
'name': _('Write-Off Entry'),
|
|
'type': 'ir.actions.act_window',
|
|
'view_type': 'form',
|
|
'view_mode': 'form',
|
|
'res_model': 'account.reconcile.wizard',
|
|
'target': 'new',
|
|
}
|
|
|
|
# ==== Business methods ====
|
|
|
|
def _get_date_after_lock_date(self):
|
|
self.ensure_one()
|
|
lock_dates = self.company_id._get_violated_lock_dates(self.date, bool(self.tax_id), self.journal_id)
|
|
if lock_dates:
|
|
return lock_dates[-1][0] + timedelta(days=1)
|
|
|
|
def _compute_write_off_taxes_data(self, partner):
|
|
""" Computes the data needed to fill the write-off lines related to taxes.
|
|
:return: a dict of the form {
|
|
'base_amount': 100.0,
|
|
'base_amount_currency': 200.0,
|
|
'tax_lines_data': [{
|
|
'tax_amount': 21.0,
|
|
'tax_amount_currency': 42.0,
|
|
'tax_tag_ids': [tax_tags],
|
|
'tax_account_id': id_of_account,
|
|
} * nr of repartition lines of the self.tax_id ],
|
|
}
|
|
"""
|
|
AccountTax = self.env['account.tax']
|
|
amount_currency = self.edit_mode_amount_currency or self.amount_currency
|
|
amount = self.edit_mode_amount or self.amount
|
|
rate = abs(amount_currency / amount)
|
|
tax_type = self.tax_id.type_tax_use if self.tax_id else None
|
|
is_refund = (tax_type == 'sale' and amount_currency > 0.0) or (tax_type == 'purchase' and amount_currency < 0.0)
|
|
base_line = AccountTax._prepare_base_line_for_taxes_computation(
|
|
self,
|
|
partner_id=partner,
|
|
currency_id=self.reco_currency_id,
|
|
tax_ids=self.tax_id,
|
|
price_unit=amount_currency,
|
|
quantity=1.0,
|
|
account_id=self.account_id,
|
|
is_refund=is_refund,
|
|
rate=rate,
|
|
special_mode='total_included',
|
|
)
|
|
base_lines = [base_line]
|
|
AccountTax._add_tax_details_in_base_lines(base_lines, self.company_id)
|
|
AccountTax._round_base_lines_tax_details(base_lines, self.company_id)
|
|
AccountTax._add_accounting_data_in_base_lines_tax_details(base_lines, self.company_id, include_caba_tags=True)
|
|
tax_results = AccountTax._prepare_tax_lines(base_lines, self.company_id)
|
|
_base_line, base_to_update = tax_results['base_lines_to_update'][0] # we can only have one baseline
|
|
tax_lines_data = []
|
|
for tax_line_vals in tax_results['tax_lines_to_add']:
|
|
tax_lines_data.append({
|
|
'tax_amount': tax_line_vals['balance'],
|
|
'tax_amount_currency': tax_line_vals['amount_currency'],
|
|
'tax_tag_ids': tax_line_vals['tax_tag_ids'],
|
|
'tax_account_id': tax_line_vals['account_id'],
|
|
})
|
|
base_amount_currency = base_to_update['amount_currency']
|
|
base_amount = amount - sum(entry['tax_amount'] for entry in tax_lines_data)
|
|
|
|
return {
|
|
'base_amount': base_amount,
|
|
'base_amount_currency': base_amount_currency,
|
|
'base_tax_tag_ids': base_to_update['tax_tag_ids'],
|
|
'tax_lines_data': tax_lines_data,
|
|
}
|
|
|
|
def _create_write_off_lines(self, partner=None):
|
|
if not partner:
|
|
partner = self.env['res.partner']
|
|
to_partner = self.to_partner_id if self.is_rec_pay_account else partner
|
|
tax_data = self._compute_write_off_taxes_data(to_partner) if self.tax_id else None
|
|
amount_currency = self.edit_mode_amount_currency or self.amount_currency
|
|
amount = self.edit_mode_amount or self.amount
|
|
line_ids_commands = [
|
|
Command.create({
|
|
'name': self.label or _('Write-Off'),
|
|
'account_id': self.reco_account_id.id,
|
|
'partner_id': partner.id,
|
|
'currency_id': self.reco_currency_id.id,
|
|
'amount_currency': -amount_currency,
|
|
'balance': -amount,
|
|
}),
|
|
Command.create({
|
|
'name': self.label,
|
|
'account_id': self.account_id.id,
|
|
'partner_id': to_partner.id,
|
|
'currency_id': self.reco_currency_id.id,
|
|
'tax_ids': self.tax_id.ids,
|
|
'tax_tag_ids': None if not tax_data else tax_data['base_tax_tag_ids'],
|
|
'amount_currency': amount_currency if not tax_data else tax_data['base_amount_currency'],
|
|
'balance': amount if not tax_data else tax_data['base_amount'],
|
|
}),
|
|
]
|
|
# Add taxes lines to the write-off lines, one per repartition line
|
|
if tax_data:
|
|
for tax_datum in tax_data['tax_lines_data']:
|
|
line_ids_commands.append(Command.create({
|
|
'name': self.tax_id.name,
|
|
'account_id': tax_datum['tax_account_id'],
|
|
'partner_id': to_partner.id,
|
|
'currency_id': self.reco_currency_id.id,
|
|
'tax_tag_ids': tax_datum['tax_tag_ids'],
|
|
'amount_currency': tax_datum['tax_amount_currency'],
|
|
'balance': tax_datum['tax_amount'],
|
|
}))
|
|
return line_ids_commands
|
|
|
|
def create_write_off(self):
|
|
""" Create write-off move lines with the data provided in the wizard. """
|
|
self.ensure_one()
|
|
partners = self.move_line_ids.partner_id
|
|
partner = partners if len(partners) == 1 else None
|
|
write_off_vals = {
|
|
'journal_id': self.journal_id.id,
|
|
'company_id': self.company_id.id,
|
|
'date': self._get_date_after_lock_date() or self.date,
|
|
'move_type': 'entry',
|
|
'checked': not self.to_check,
|
|
'line_ids': self._create_write_off_lines(partner=partner)
|
|
}
|
|
write_off_move = self.env['account.move'].with_context(
|
|
skip_invoice_sync=True,
|
|
skip_invoice_line_sync=True,
|
|
).create(write_off_vals)
|
|
write_off_move.action_post()
|
|
return write_off_move
|
|
|
|
def create_transfer(self):
|
|
""" Create transfer move.
|
|
We transfer lines squashed by partner and by currency to keep the partner ledger correct.
|
|
By default, the source line and the destination line of each transfer are linked to the same partner.
|
|
However, it can happen that the moves that are being reconciled together come from different partners
|
|
(e.g. reconciling an invoice of Partner X with a bill of Parnter Y).
|
|
In that case, one of the transfer lines should be set to the other partner.
|
|
Otherwise, the partner ledger will be wrong for both users.
|
|
"""
|
|
self.ensure_one()
|
|
line_ids = []
|
|
lines_to_transfer = self.move_line_ids.filtered(lambda line: line.account_id == self.transfer_from_account_id)
|
|
# The lines that are not transferred will be used to determine the partners of the destination lines
|
|
other_lines = self.move_line_ids.filtered(lambda line: line.account_id == self.reco_account_id)
|
|
# Default dict for the destination lines. It contains the inverse of the source lines
|
|
# {(partner, currency, sign): {'balance': float, 'amount_currency': float}}
|
|
default_destination_data = dict()
|
|
# Dict generated from the lines linked to the reconcile model.
|
|
# It is splitted by partner and represents the possible partners and the amount max that can be used
|
|
# for the destination lines.
|
|
# {(currency, sign): {(partner): {'balance': float, 'amount_currency': float}}}
|
|
amounts_by_partner = defaultdict(lambda: defaultdict(lambda: defaultdict(float)))
|
|
# Final dict containing the data from which the destination lines will be created
|
|
# {(partner, currency, sign): {'balance': float, 'amount_currency': float}}
|
|
destination_data = defaultdict(lambda: defaultdict(float))
|
|
|
|
for (partner, currency), lines_to_transfer_partner in groupby(lines_to_transfer, lambda l: (l.partner_id, l.currency_id)):
|
|
amount = sum(line.amount_residual for line in lines_to_transfer_partner)
|
|
amount_currency = sum(line.amount_residual_currency for line in lines_to_transfer_partner)
|
|
line_ids += [
|
|
Command.create({
|
|
'name': _('Transfer to %s', self.reco_account_id.display_name),
|
|
'account_id': self.transfer_from_account_id.id,
|
|
'partner_id': partner.id,
|
|
'currency_id': currency.id,
|
|
'amount_currency': -amount_currency,
|
|
'balance': -amount,
|
|
}),
|
|
]
|
|
sign = -1 if amount < 0 else 1
|
|
# By default, the partner of the destination line will be the same than the one of the source line.
|
|
# As the transfer move should be balanced, the amounts defined here represent the total amount that
|
|
# will be in the destination lines.
|
|
# They may be split between several partners though.
|
|
default_destination_data[partner, currency, sign] = {
|
|
'balance': amount,
|
|
'amount_currency': amount_currency,
|
|
}
|
|
# Run through the lines linked to the reconcile account to determine the possible partners and amounts for the destination
|
|
# lines of the transfer
|
|
for (partner, currency), lines_to_transfer_partner in groupby(other_lines, lambda l: (l.partner_id, l.currency_id)):
|
|
amount = -sum(line.amount_residual for line in lines_to_transfer_partner)
|
|
amount_currency = -sum(line.amount_residual_currency for line in lines_to_transfer_partner)
|
|
sign = -1 if amount < 0 else 1
|
|
# If the partner, currency and sign of the amounts match one of the default data, it is kept for the destination lines.
|
|
# The amounts will be adapted with the remaining amounts.
|
|
if (partner, currency, sign) in default_destination_data:
|
|
default_amount = default_destination_data[partner, currency, sign]['balance']
|
|
default_amount_currency = default_destination_data[partner, currency, sign]['amount_currency']
|
|
amount_to_transfer = min(abs(amount), abs(default_amount)) * sign
|
|
amount_currency_to_transfer = min(abs(amount_currency), abs(default_amount_currency)) * sign
|
|
destination_data[partner, currency, sign] = {
|
|
'balance': amount_to_transfer,
|
|
'amount_currency': amount_currency_to_transfer,
|
|
}
|
|
default_amount -= amount_to_transfer
|
|
default_amount_currency -= amount_currency_to_transfer
|
|
amount -= amount_to_transfer
|
|
amount_currency -= amount_currency_to_transfer
|
|
if not currency.is_zero(abs(default_amount)):
|
|
# Update the default amounts with the remaining amounts that have not been kept
|
|
default_destination_data[partner, currency, sign] = {
|
|
'balance': default_amount,
|
|
'amount_currency': default_amount_currency,
|
|
}
|
|
else:
|
|
# Delete the key if there is no remaining amount
|
|
del default_destination_data[partner, currency, sign]
|
|
if not currency.is_zero(abs(amount)):
|
|
amounts_by_partner[currency, sign][partner] = {
|
|
'balance': amount,
|
|
'amount_currency': amount_currency,
|
|
}
|
|
# Run through what's left of the default data and try to find a partner that matches the currency and sign.
|
|
# If none is found, the partner from the source line is used.
|
|
for (partner, currency, sign) in default_destination_data:
|
|
amount = default_destination_data[partner, currency, sign]['balance']
|
|
amount_currency = default_destination_data[partner, currency, sign]['amount_currency']
|
|
# Loop on all the partners with the same currency and sign
|
|
for p in amounts_by_partner[currency, sign]:
|
|
if amount == 0:
|
|
break
|
|
amount_to_transfer = min(abs(amount), abs(amounts_by_partner[currency, sign][p]['balance'])) * sign
|
|
amount_currency_to_transfer = min(abs(amount_currency), abs(amounts_by_partner[currency, sign][p]['amount_currency'])) * sign
|
|
amount -= amount_to_transfer
|
|
amount_currency -= amount_currency_to_transfer
|
|
|
|
destination_data[p, currency, sign]['balance'] += amount_to_transfer
|
|
destination_data[p, currency, sign]['amount_currency'] += amount_currency_to_transfer
|
|
amounts_by_partner[currency, sign][p]['balance'] -= amount_to_transfer
|
|
amounts_by_partner[currency, sign][p]['amount_currency'] -= amount_currency_to_transfer
|
|
# Residual amount that couldn't be associated to another partner keeps the partner from the source line
|
|
if not currency.is_zero(abs(amount)):
|
|
destination_data[partner, currency, sign]['balance'] += amount
|
|
destination_data[partner, currency, sign]['amount_currency'] += amount_currency
|
|
# Create the destination lines
|
|
for (partner, currency, sign) in destination_data:
|
|
line_ids += [
|
|
Command.create({
|
|
'name': _('Transfer from %s', self.transfer_from_account_id.display_name),
|
|
'account_id': self.reco_account_id.id,
|
|
'partner_id': partner.id,
|
|
'currency_id': currency.id,
|
|
'amount_currency': destination_data[partner, currency, sign]['amount_currency'],
|
|
'balance': destination_data[partner, currency, sign]['balance'],
|
|
}),
|
|
]
|
|
transfer_vals = {
|
|
'journal_id': self.journal_id.id,
|
|
'company_id': self.company_id.id,
|
|
'date': self._get_date_after_lock_date() or self.date,
|
|
'line_ids': line_ids,
|
|
}
|
|
transfer_move = self.env['account.move'].create(transfer_vals)
|
|
transfer_move.action_post()
|
|
return transfer_move
|
|
|
|
def reconcile(self):
|
|
""" Reconcile selected moves, with a transfer and/or write-off move if necessary."""
|
|
self.ensure_one()
|
|
move_lines_to_reconcile = self.move_line_ids._origin
|
|
do_transfer = self.is_transfer_required
|
|
do_write_off = self.edit_mode or (self.is_write_off_required and not self.allow_partials)
|
|
if do_transfer:
|
|
transfer_move = self.create_transfer()
|
|
lines_to_transfer = move_lines_to_reconcile \
|
|
.filtered(lambda line: line.account_id == self.transfer_from_account_id)
|
|
transfer_line_from = transfer_move.line_ids \
|
|
.filtered(lambda line: line.account_id == self.transfer_from_account_id)
|
|
transfer_line_to = transfer_move.line_ids \
|
|
.filtered(lambda line: line.account_id == self.reco_account_id)
|
|
(lines_to_transfer + transfer_line_from).reconcile()
|
|
move_lines_to_reconcile = move_lines_to_reconcile - lines_to_transfer + transfer_line_to
|
|
|
|
if do_write_off:
|
|
write_off_move = self.create_write_off()
|
|
write_off_line_to_reconcile = write_off_move.line_ids[0]
|
|
move_lines_to_reconcile += write_off_line_to_reconcile
|
|
amls_plan = [[move_lines_to_reconcile, write_off_line_to_reconcile]]
|
|
else:
|
|
amls_plan = [move_lines_to_reconcile]
|
|
|
|
self.env['account.move.line']._reconcile_plan(amls_plan)
|
|
return move_lines_to_reconcile if not do_transfer else (move_lines_to_reconcile + transfer_move.line_ids)
|
|
|
|
def reconcile_open(self):
|
|
""" Reconcile selected move lines and open them in dedicated view. """
|
|
self.ensure_one()
|
|
return self.reconcile().open_reconcile_view()
|