# -*- coding: utf-8 -*- import time from collections import OrderedDict from odoo import api, fields, models, _ from odoo.osv import expression from odoo.exceptions import RedirectWarning, UserError, ValidationError from odoo.tools.misc import formatLang from odoo.tools import float_is_zero, float_compare from odoo.tools.safe_eval import safe_eval import odoo.addons.decimal_precision as dp from lxml import etree #---------------------------------------------------------- # Entries #---------------------------------------------------------- class AccountMove(models.Model): _name = "account.move" _description = "Account Entry" _order = 'date desc, id desc' @api.multi @api.depends('name', 'state') def name_get(self): result = [] for move in self: if move.state == 'draft': name = '* ' + str(move.id) else: name = move.name result.append((move.id, name)) return result @api.multi @api.depends('line_ids.debit', 'line_ids.credit') def _amount_compute(self): for move in self: total = 0.0 for line in move.line_ids: total += line.debit move.amount = total @api.depends('line_ids.debit', 'line_ids.credit', 'line_ids.matched_debit_ids.amount', 'line_ids.matched_credit_ids.amount', 'line_ids.account_id.user_type_id.type') def _compute_matched_percentage(self): """Compute the percentage to apply for cash basis method. This value is relevant only for moves that involve journal items on receivable or payable accounts. """ for move in self: total_amount = 0.0 total_reconciled = 0.0 for line in move.line_ids: if line.account_id.user_type_id.type in ('receivable', 'payable'): amount = abs(line.debit - line.credit) total_amount += amount for partial_line in (line.matched_debit_ids + line.matched_credit_ids): total_reconciled += partial_line.amount precision_currency = move.currency_id or move.company_id.currency_id if float_is_zero(total_amount, precision_rounding=precision_currency.rounding): move.matched_percentage = 1.0 else: move.matched_percentage = total_reconciled / total_amount @api.one @api.depends('company_id') def _compute_currency(self): self.currency_id = self.company_id.currency_id or self.env.user.company_id.currency_id @api.multi def _get_default_journal(self): if self.env.context.get('default_journal_type'): return self.env['account.journal'].search([('type', '=', self.env.context['default_journal_type'])], limit=1).id @api.multi @api.depends('line_ids.partner_id') def _compute_partner_id(self): for move in self: partner = move.line_ids.mapped('partner_id') move.partner_id = partner.id if len(partner) == 1 else False name = fields.Char(string='Number', required=True, copy=False, default='/') ref = fields.Char(string='Reference', copy=False) date = fields.Date(required=True, states={'posted': [('readonly', True)]}, index=True, default=fields.Date.context_today) journal_id = fields.Many2one('account.journal', string='Journal', required=True, states={'posted': [('readonly', True)]}, default=_get_default_journal) currency_id = fields.Many2one('res.currency', compute='_compute_currency', store=True, string="Currency") state = fields.Selection([('draft', 'Unposted'), ('posted', 'Posted')], string='Status', required=True, readonly=True, copy=False, default='draft', help='All manually created new journal entries are usually in the status \'Unposted\', ' 'but you can set the option to skip that status on the related journal. ' 'In that case, they will behave as journal entries automatically created by the ' 'system on document validation (invoices, bank statements...) and will be created ' 'in \'Posted\' status.') line_ids = fields.One2many('account.move.line', 'move_id', string='Journal Items', states={'posted': [('readonly', True)]}, copy=True) partner_id = fields.Many2one('res.partner', compute='_compute_partner_id', string="Partner", store=True, readonly=True) amount = fields.Monetary(compute='_amount_compute', store=True) narration = fields.Text(string='Internal Note') company_id = fields.Many2one('res.company', related='journal_id.company_id', string='Company', store=True, readonly=True, default=lambda self: self.env.user.company_id) matched_percentage = fields.Float('Percentage Matched', compute='_compute_matched_percentage', digits=0, store=True, readonly=True, help="Technical field used in cash basis method") statement_line_id = fields.Many2one('account.bank.statement.line', index=True, string='Bank statement line reconciled with this entry', copy=False, readonly=True) # Dummy Account field to search on account.move by account_id dummy_account_id = fields.Many2one('account.account', related='line_ids.account_id', string='Account', store=False, readonly=True) @api.model def fields_view_get(self, view_id=None, view_type='form', toolbar=False, submenu=False): res = super(AccountMove, self).fields_view_get( view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu) if self._context.get('vat_domain'): res['fields']['line_ids']['views']['tree']['fields']['tax_line_id']['domain'] = [('tag_ids', 'in', [self.env.ref(self._context.get('vat_domain')).id])] return res @api.model def create(self, vals): move = super(AccountMove, self.with_context(check_move_validity=False, partner_id=vals.get('partner_id'))).create(vals) move.assert_balanced() return move @api.multi def write(self, vals): if 'line_ids' in vals: res = super(AccountMove, self.with_context(check_move_validity=False)).write(vals) self.assert_balanced() else: res = super(AccountMove, self).write(vals) return res @api.multi def post(self): invoice = self._context.get('invoice', False) self._post_validate() for move in self: move.line_ids.create_analytic_lines() if move.name == '/': new_name = False journal = move.journal_id if invoice and invoice.move_name and invoice.move_name != '/': new_name = invoice.move_name else: if journal.sequence_id: # If invoice is actually refund and journal has a refund_sequence then use that one or use the regular one sequence = journal.sequence_id if invoice and invoice.type in ['out_refund', 'in_refund'] and journal.refund_sequence: if not journal.refund_sequence_id: raise UserError(_('Please define a sequence for the refunds')) sequence = journal.refund_sequence_id new_name = sequence.with_context(ir_sequence_date=move.date).next_by_id() else: raise UserError(_('Please define a sequence on the journal.')) if new_name: move.name = new_name return self.write({'state': 'posted'}) @api.multi def button_cancel(self): for move in self: if not move.journal_id.update_posted: raise UserError(_('You cannot modify a posted entry of this journal.\nFirst you should set the journal to allow cancelling entries.')) if self.ids: self.check_access_rights('write') self.check_access_rule('write') self._check_lock_date() self._cr.execute('UPDATE account_move '\ 'SET state=%s '\ 'WHERE id IN %s', ('draft', tuple(self.ids),)) self.invalidate_cache() self._check_lock_date() return True @api.multi def unlink(self): for move in self: #check the lock date + check if some entries are reconciled move.line_ids._update_check() move.line_ids.unlink() return super(AccountMove, self).unlink() @api.multi def _post_validate(self): for move in self: if move.line_ids: if not all([x.company_id.id == move.company_id.id for x in move.line_ids]): raise UserError(_("Cannot create moves for different companies.")) self.assert_balanced() return self._check_lock_date() @api.multi def _check_lock_date(self): for move in self: lock_date = max(move.company_id.period_lock_date, move.company_id.fiscalyear_lock_date) if self.user_has_groups('account.group_account_manager'): lock_date = move.company_id.fiscalyear_lock_date if move.date <= lock_date: if self.user_has_groups('account.group_account_manager'): message = _("You cannot add/modify entries prior to and inclusive of the lock date %s") % (lock_date) else: message = _("You cannot add/modify entries prior to and inclusive of the lock date %s. Check the company settings or ask someone with the 'Adviser' role") % (lock_date) raise UserError(message) return True @api.multi def assert_balanced(self): if not self.ids: return True prec = self.env['decimal.precision'].precision_get('Account') self._cr.execute("""\ SELECT move_id FROM account_move_line WHERE move_id in %s GROUP BY move_id HAVING abs(sum(debit) - sum(credit)) > %s """, (tuple(self.ids), 10 ** (-max(5, prec)))) if len(self._cr.fetchall()) != 0: raise UserError(_("Cannot create unbalanced journal entry.")) return True # Do not forward port in >= saas-14 def _reconcile_reversed_pair(self, move, reversed_move): amls_to_reconcile = (move.line_ids + reversed_move.line_ids).filtered(lambda l: not l.reconciled) # Do not forward port changes in this file in >= saas-14 accounts_reconcilable = amls_to_reconcile.mapped('account_id').filtered(lambda a: a.reconcile or a.internal_type == 'liquidity') for account in accounts_reconcilable: amls_for_account = amls_to_reconcile.filtered(lambda l: l.account_id.id == account.id) amls_for_account.reconcile() amls_to_reconcile = amls_to_reconcile - amls_for_account @api.multi def _reverse_move(self, date=None, journal_id=None): self.ensure_one() reversed_move = self.copy(default={ 'date': date, 'journal_id': journal_id.id if journal_id else self.journal_id.id, 'ref': _('reversal of: ') + self.name}) for acm_line in reversed_move.line_ids.with_context(check_move_validity=False): acm_line.write({ 'debit': acm_line.credit, 'credit': acm_line.debit, 'amount_currency': -acm_line.amount_currency }) self._reconcile_reversed_pair(self, reversed_move) return reversed_move @api.multi def reverse_moves(self, date=None, journal_id=None): date = date or fields.Date.today() reversed_moves = self.env['account.move'] for ac_move in self: reversed_move = ac_move._reverse_move(date=date, journal_id=journal_id) reversed_moves |= reversed_move if reversed_moves: reversed_moves._post_validate() reversed_moves.post() return [x.id for x in reversed_moves] return [] @api.multi def open_reconcile_view(self): return self.line_ids.open_reconcile_view() class AccountMoveLine(models.Model): _name = "account.move.line" _description = "Journal Item" _order = "date desc, id desc" @api.model_cr def init(self): """ change index on partner_id to a multi-column index on (partner_id, ref), the new index will behave in the same way when we search on partner_id, with the addition of being optimal when having a query that will search on partner_id and ref at the same time (which is the case when we open the bank reconciliation widget) """ cr = self._cr cr.execute('DROP INDEX IF EXISTS account_move_line_partner_id_index') cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = %s', ('account_move_line_partner_id_ref_idx',)) if not cr.fetchone(): cr.execute('CREATE INDEX account_move_line_partner_id_ref_idx ON account_move_line (partner_id, ref)') @api.depends('debit', 'credit', 'amount_currency', 'currency_id', 'matched_debit_ids', 'matched_credit_ids', 'matched_debit_ids.amount', 'matched_credit_ids.amount', 'move_id.state') def _amount_residual(self): """ Computes the residual amount of a move line from a reconciliable account in the company currency and the line's currency. This amount will be 0 for fully reconciled lines or lines from a non-reconciliable account, the original line amount for unreconciled lines, and something in-between for partially reconciled lines. """ for line in self: if not line.account_id.reconcile: line.reconciled = False line.amount_residual = 0 line.amount_residual_currency = 0 continue #amounts in the partial reconcile table aren't signed, so we need to use abs() amount = abs(line.debit - line.credit) amount_residual_currency = abs(line.amount_currency) or 0.0 sign = 1 if (line.debit - line.credit) > 0 else -1 if not line.debit and not line.credit and line.amount_currency and line.currency_id: #residual for exchange rate entries sign = 1 if float_compare(line.amount_currency, 0, precision_rounding=line.currency_id.rounding) == 1 else -1 for partial_line in (line.matched_debit_ids + line.matched_credit_ids): # If line is a credit (sign = -1) we: # - subtract matched_debit_ids (partial_line.credit_move_id == line) # - add matched_credit_ids (partial_line.credit_move_id != line) # If line is a debit (sign = 1), do the opposite. sign_partial_line = sign if partial_line.credit_move_id == line else (-1 * sign) amount += sign_partial_line * partial_line.amount #getting the date of the matched item to compute the amount_residual in currency if line.currency_id: if partial_line.currency_id and partial_line.currency_id == line.currency_id: amount_residual_currency += sign_partial_line * partial_line.amount_currency else: if line.balance and line.amount_currency: rate = line.amount_currency / line.balance else: date = partial_line.credit_move_id.date if partial_line.debit_move_id == line else partial_line.debit_move_id.date rate = line.currency_id.with_context(date=date).rate amount_residual_currency += sign_partial_line * line.currency_id.round(partial_line.amount * rate) #computing the `reconciled` field. As we book exchange rate difference on each partial matching, #we can only check the amount in company currency reconciled = False digits_rounding_precision = line.company_id.currency_id.rounding if float_is_zero(amount, precision_rounding=digits_rounding_precision): if line.currency_id and line.amount_currency: if float_is_zero(amount_residual_currency, precision_rounding=line.currency_id.rounding): reconciled = True else: reconciled = True line.reconciled = reconciled line.amount_residual = line.company_id.currency_id.round(amount * sign) line.amount_residual_currency = line.currency_id and line.currency_id.round(amount_residual_currency * sign) or 0.0 @api.depends('debit', 'credit') def _store_balance(self): for line in self: line.balance = line.debit - line.credit @api.model def _get_currency(self): currency = False context = self._context or {} if context.get('default_journal_id', False): currency = self.env['account.journal'].browse(context['default_journal_id']).currency_id return currency @api.depends('debit', 'credit', 'move_id.matched_percentage', 'move_id.journal_id') def _compute_cash_basis(self): for move_line in self: if move_line.journal_id.type in ('sale', 'purchase'): move_line.debit_cash_basis = move_line.debit * move_line.move_id.matched_percentage move_line.credit_cash_basis = move_line.credit * move_line.move_id.matched_percentage else: move_line.debit_cash_basis = move_line.debit move_line.credit_cash_basis = move_line.credit move_line.balance_cash_basis = move_line.debit_cash_basis - move_line.credit_cash_basis @api.one @api.depends('move_id.line_ids') def _get_counterpart(self): counterpart = set() for line in self.move_id.line_ids: if (line.account_id.code != self.account_id.code): counterpart.add(line.account_id.code) if len(counterpart) > 2: counterpart = list(counterpart)[0:2] + ["..."] self.counterpart = ",".join(counterpart) name = fields.Char(required=True, string="Label") quantity = fields.Float(digits=dp.get_precision('Product Unit of Measure'), help="The optional quantity expressed by this line, eg: number of product sold. The quantity is not a legal requirement but is very useful for some reports.") product_uom_id = fields.Many2one('product.uom', string='Unit of Measure') product_id = fields.Many2one('product.product', string='Product') debit = fields.Monetary(default=0.0, currency_field='company_currency_id') credit = fields.Monetary(default=0.0, currency_field='company_currency_id') balance = fields.Monetary(compute='_store_balance', store=True, currency_field='company_currency_id', help="Technical field holding the debit - credit in order to open meaningful graph views from reports") debit_cash_basis = fields.Monetary(currency_field='company_currency_id', compute='_compute_cash_basis', store=True) credit_cash_basis = fields.Monetary(currency_field='company_currency_id', compute='_compute_cash_basis', store=True) balance_cash_basis = fields.Monetary(compute='_compute_cash_basis', store=True, currency_field='company_currency_id', help="Technical field holding the debit_cash_basis - credit_cash_basis in order to open meaningful graph views from reports") amount_currency = fields.Monetary(default=0.0, help="The amount expressed in an optional other currency if it is a multi-currency entry.") company_currency_id = fields.Many2one('res.currency', related='company_id.currency_id', string="Company Currency", readonly=True, help='Utility field to express amount currency', store=True) currency_id = fields.Many2one('res.currency', string='Currency', default=_get_currency, help="The optional other currency if it is a multi-currency entry.") amount_residual = fields.Monetary(compute='_amount_residual', string='Residual Amount', store=True, currency_field='company_currency_id', help="The residual amount on a journal item expressed in the company currency.") amount_residual_currency = fields.Monetary(compute='_amount_residual', string='Residual Amount in Currency', store=True, help="The residual amount on a journal item expressed in its currency (possibly not the company currency).") account_id = fields.Many2one('account.account', string='Account', required=True, index=True, ondelete="cascade", domain=[('deprecated', '=', False)], default=lambda self: self._context.get('account_id', False)) move_id = fields.Many2one('account.move', string='Journal Entry', ondelete="cascade", help="The move of this entry line.", index=True, required=True, auto_join=True) narration = fields.Text(related='move_id.narration', string='Narration') ref = fields.Char(related='move_id.ref', string='Reference', store=True, copy=False, index=True) payment_id = fields.Many2one('account.payment', string="Originator Payment", help="Payment that created this entry", copy=False) statement_id = fields.Many2one('account.bank.statement', string='Statement', help="The bank statement used for bank reconciliation", index=True, copy=False) reconciled = fields.Boolean(compute='_amount_residual', store=True) full_reconcile_id = fields.Many2one('account.full.reconcile', string="Matching Number", copy=False) matched_debit_ids = fields.One2many('account.partial.reconcile', 'credit_move_id', String='Matched Debits', help='Debit journal items that are matched with this journal item.') matched_credit_ids = fields.One2many('account.partial.reconcile', 'debit_move_id', String='Matched Credits', help='Credit journal items that are matched with this journal item.') journal_id = fields.Many2one('account.journal', related='move_id.journal_id', string='Journal', index=True, store=True, copy=False) # related is required blocked = fields.Boolean(string='No Follow-up', default=False, help="You can check this box to mark this journal item as a litigation with the associated partner") date_maturity = fields.Date(string='Due date', index=True, required=True, help="This field is used for payable and receivable journal entries. You can put the limit date for the payment of this line.") date = fields.Date(related='move_id.date', string='Date', index=True, store=True, copy=False) # related is required analytic_line_ids = fields.One2many('account.analytic.line', 'move_id', string='Analytic lines', oldname="analytic_lines") tax_ids = fields.Many2many('account.tax', string='Taxes') tax_line_id = fields.Many2one('account.tax', string='Originator tax', ondelete='restrict') analytic_account_id = fields.Many2one('account.analytic.account', string='Analytic Account') analytic_tag_ids = fields.Many2many('account.analytic.tag', string='Analytic tags') company_id = fields.Many2one('res.company', related='account_id.company_id', string='Company', store=True) counterpart = fields.Char("Counterpart", compute='_get_counterpart', help="Compute the counter part accounts of this journal item for this journal entry. This can be needed in reports.") # TODO: put the invoice link and partner_id on the account_move invoice_id = fields.Many2one('account.invoice', oldname="invoice") partner_id = fields.Many2one('res.partner', string='Partner', ondelete='restrict') user_type_id = fields.Many2one('account.account.type', related='account_id.user_type_id', index=True, store=True, oldname="user_type") tax_exigible = fields.Boolean(string='Appears in VAT report', default=True, help="Technical field used to mark a tax line as exigible in the vat report or not (only exigible journal items are displayed). By default all new journal items are directly exigible, but with the module account_tax_cash_basis, some will become exigible only when the payment is recorded.") _sql_constraints = [ ('credit_debit1', 'CHECK (credit*debit=0)', 'Wrong credit or debit value in accounting entry !'), ('credit_debit2', 'CHECK (credit+debit>=0)', 'Wrong credit or debit value in accounting entry !'), ] @api.multi @api.constrains('currency_id', 'account_id') def _check_currency(self): for line in self: if line.account_id.currency_id: if not line.currency_id or line.currency_id.id != line.account_id.currency_id.id: raise ValidationError(_('The selected account of your Journal Entry forces to provide a secondary currency. You should remove the secondary currency on the account.')) @api.multi @api.constrains('currency_id', 'amount_currency') def _check_currency_and_amount(self): for line in self: if (line.amount_currency and not line.currency_id): raise ValidationError(_("You cannot create journal items with a secondary currency without filling both 'currency' and 'amount currency' field.")) @api.multi @api.constrains('amount_currency', 'debit', 'credit') def _check_currency_amount(self): for line in self: if line.amount_currency: if (line.amount_currency > 0.0 and line.credit > 0.0) or (line.amount_currency < 0.0 and line.debit > 0.0): raise ValidationError(_('The amount expressed in the secondary currency must be positive when account is debited and negative when account is credited.')) #################################################### # Reconciliation interface methods #################################################### @api.model def get_data_for_manual_reconciliation_widget(self, partner_ids, account_ids): """ Returns the data required for the invoices & payments matching of partners/accounts. If an argument is None, fetch all related reconciliations. Use [] to fetch nothing. """ return { 'customers': self.get_data_for_manual_reconciliation('partner', partner_ids, 'receivable'), 'suppliers': self.get_data_for_manual_reconciliation('partner', partner_ids, 'payable'), 'accounts': self.get_data_for_manual_reconciliation('account', account_ids), } @api.model def get_data_for_manual_reconciliation(self, res_type, res_ids=None, account_type=None): """ Returns the data required for the invoices & payments matching of partners/accounts (list of dicts). If no res_ids is passed, returns data for all partners/accounts that can be reconciled. :param res_type: either 'partner' or 'account' :param res_ids: ids of the partners/accounts to reconcile, use None to fetch data indiscriminately of the id, use [] to prevent from fetching any data at all. :param account_type: if a partner is both customer and vendor, you can use 'payable' to reconcile the vendor-related journal entries and 'receivable' for the customer-related entries. """ if res_ids is not None and len(res_ids) == 0: # Note : this short-circuiting is better for performances, but also required # since postgresql doesn't implement empty list (so 'AND id in ()' is useless) return [] res_ids = res_ids and tuple(res_ids) assert res_type in ('partner', 'account') assert account_type in ('payable', 'receivable', None) is_partner = res_type == 'partner' res_alias = is_partner and 'p' or 'a' query = (""" SELECT {0} account_id, account_name, account_code, max_date, to_char(last_time_entries_checked, 'YYYY-MM-DD') AS last_time_entries_checked FROM ( SELECT {1} {res_alias}.last_time_entries_checked AS last_time_entries_checked, a.id AS account_id, a.name AS account_name, a.code AS account_code, MAX(l.write_date) AS max_date FROM account_move_line l RIGHT JOIN account_account a ON (a.id = l.account_id) RIGHT JOIN account_account_type at ON (at.id = a.user_type_id) {2} WHERE a.reconcile IS TRUE AND l.full_reconcile_id is NULL {3} {4} {5} AND l.company_id = {6} AND EXISTS ( SELECT NULL FROM account_move_line l WHERE l.account_id = a.id {7} AND l.amount_residual > 0 ) AND EXISTS ( SELECT NULL FROM account_move_line l WHERE l.account_id = a.id {7} AND l.amount_residual < 0 ) GROUP BY {8} a.id, a.name, a.code, {res_alias}.last_time_entries_checked ORDER BY {res_alias}.last_time_entries_checked ) as s WHERE (last_time_entries_checked IS NULL OR max_date > last_time_entries_checked) """.format( is_partner and 'partner_id, partner_name,' or ' ', is_partner and 'p.id AS partner_id, p.name AS partner_name,' or ' ', is_partner and 'RIGHT JOIN res_partner p ON (l.partner_id = p.id)' or ' ', is_partner and ' ' or "AND at.type <> 'payable' AND at.type <> 'receivable'", account_type and "AND at.type = %(account_type)s" or '', res_ids and 'AND ' + res_alias + '.id in %(res_ids)s' or '', self.env.user.company_id.id, is_partner and 'AND l.partner_id = p.id' or ' ', is_partner and 'l.partner_id, p.id,' or ' ', res_alias=res_alias )) self.env.cr.execute(query, locals()) # Apply ir_rules by filtering out rows = self.env.cr.dictfetchall() ids = [x['account_id'] for x in rows] allowed_ids = set(self.env['account.account'].browse(ids).ids) rows = [row for row in rows if row['account_id'] in allowed_ids] if is_partner: ids = [x['partner_id'] for x in rows] allowed_ids = set(self.env['res.partner'].browse(ids).ids) rows = [row for row in rows if row['partner_id'] in allowed_ids] # Fetch other data for row in rows: account = self.env['account.account'].browse(row['account_id']) row['currency_id'] = account.currency_id.id or account.company_id.currency_id.id partner_id = is_partner and row['partner_id'] or None row['reconciliation_proposition'] = self.get_reconciliation_proposition(account.id, partner_id) return rows @api.model def get_reconciliation_proposition(self, account_id, partner_id=False): """ Returns two lines whose amount are opposite """ # Get pairs partner_id_condition = partner_id and 'AND a.partner_id = %(partner_id)s AND b.partner_id = %(partner_id)s' or '' query = """ SELECT a.id, b.id FROM account_move_line a, account_move_line b WHERE a.amount_residual = -b.amount_residual AND NOT a.reconciled AND NOT b.reconciled AND a.account_id = %(account_id)s AND b.account_id = %(account_id)s {partner_id_condition} ORDER BY a.date asc LIMIT 10 """.format(**locals()) self.env.cr.execute(query, locals()) pairs = self.env.cr.fetchall() # Apply ir_rules by filtering out all_pair_ids = [element for tupl in pairs for element in tupl] allowed_ids = set(self.env['account.move.line'].browse(all_pair_ids).ids) pairs = [pair for pair in pairs if pair[0] in allowed_ids and pair[1] in allowed_ids] # Return lines formatted if len(pairs) > 0: target_currency = (self.currency_id and self.amount_currency) and self.currency_id or self.company_id.currency_id lines = self.browse(list(pairs[0])) return lines.prepare_move_lines_for_reconciliation_widget(target_currency=target_currency) return [] @api.model def domain_move_lines_for_reconciliation(self, excluded_ids=None, str=False): """ Returns the domain which is common to both manual and bank statement reconciliation. :param excluded_ids: list of ids of move lines that should not be fetched :param str: search string """ context = (self._context or {}) if excluded_ids is None: excluded_ids = [] domain = [] if excluded_ids: domain = expression.AND([domain, [('id', 'not in', excluded_ids)]]) if str: str_domain = [ '|', ('move_id.name', 'ilike', str), '|', ('move_id.ref', 'ilike', str), '|', ('date_maturity', 'like', str), '&', ('name', '!=', '/'), ('name', 'ilike', str) ] try: amount = float(str) amount_domain = [ '|', ('amount_residual', '=', amount), '|', ('amount_residual_currency', '=', amount), '|', ('amount_residual', '=', -amount), '|', ('amount_residual_currency', '=', -amount), '&', ('account_id.internal_type', '=', 'liquidity'), '|', '|', ('debit', '=', amount), ('credit', '=', amount), ('amount_currency', '=', amount), ] str_domain = expression.OR([str_domain, amount_domain]) except: pass # When building a domain for the bank statement reconciliation, if there's no partner # and a search string, search also a match in the partner names if 'bank_statement_line' in context and not context['bank_statement_line'].partner_id.id: str_domain = expression.OR([str_domain, [('partner_id.name', 'ilike', str)]]) domain = expression.AND([domain, str_domain]) return domain def _domain_move_lines_for_manual_reconciliation(self, account_id, partner_id=False, excluded_ids=None, str=False): """ Create domain criteria that are relevant to manual reconciliation. """ domain = ['&', ('reconciled', '=', False), ('account_id', '=', account_id)] if partner_id: domain = expression.AND([domain, [('partner_id', '=', partner_id)]]) generic_domain = self.domain_move_lines_for_reconciliation(excluded_ids=excluded_ids, str=str) return expression.AND([generic_domain, domain]) @api.model def get_move_lines_for_manual_reconciliation(self, account_id, partner_id=False, excluded_ids=None, str=False, offset=0, limit=None, target_currency_id=False): """ Returns unreconciled move lines for an account or a partner+account, formatted for the manual reconciliation widget """ domain = self._domain_move_lines_for_manual_reconciliation(account_id, partner_id, excluded_ids, str) lines = self.search(domain, offset=offset, limit=limit, order="date_maturity asc, id asc") if target_currency_id: target_currency = self.env['res.currency'].browse(target_currency_id) else: account = self.env['account.account'].browse(account_id) target_currency = account.currency_id or account.company_id.currency_id return lines.prepare_move_lines_for_reconciliation_widget(target_currency=target_currency) @api.multi def prepare_move_lines_for_reconciliation_widget(self, target_currency=False, target_date=False): """ Returns move lines formatted for the manual/bank reconciliation widget :param target_currency: currency (browse_record or ID) you want the move line debit/credit converted into :param target_date: date to use for the monetary conversion """ context = dict(self._context or {}) ret = [] if target_currency: # re-browse in case we were passed a currency ID via RPC call target_currency = self.env['res.currency'].browse(int(target_currency)) for line in self: company_currency = line.account_id.company_id.currency_id ret_line = { 'id': line.id, 'name': line.name != '/' and line.move_id.name + ': ' + line.name or line.move_id.name, 'ref': line.move_id.ref or '', # For reconciliation between statement transactions and already registered payments (eg. checks) # NB : we don't use the 'reconciled' field because the line we're selecting is not the one that gets reconciled 'already_paid': line.account_id.internal_type == 'liquidity', 'account_code': line.account_id.code, 'account_name': line.account_id.name, 'account_type': line.account_id.internal_type, 'date_maturity': line.date_maturity, 'date': line.date, 'journal_name': line.journal_id.name, 'partner_id': line.partner_id.id, 'partner_name': line.partner_id.name, 'currency_id': (line.currency_id and line.amount_currency) and line.currency_id.id or False, } debit = line.debit credit = line.credit amount = line.amount_residual amount_currency = line.amount_residual_currency # For already reconciled lines, don't use amount_residual(_currency) if line.account_id.internal_type == 'liquidity': amount = abs(debit - credit) amount_currency = abs(line.amount_currency) # Get right debit / credit: target_currency = target_currency or company_currency line_currency = (line.currency_id and line.amount_currency) and line.currency_id or company_currency amount_currency_str = "" total_amount_currency_str = "" if line_currency != company_currency and target_currency == line_currency: # The payment currency is the invoice currency, but they are different than the company currency # We use the `amount_currency` computed during the invoice validation, at the invoice date # to avoid exchange gain/loss # e.g. an invoice of 100€ must be paid with 100€, whatever the company currency and the exchange rates total_amount = line.amount_currency actual_debit = debit > 0 and amount_currency or 0.0 actual_credit = credit > 0 and -amount_currency or 0.0 currency = line_currency else: # Either: # - the invoice, payment, company currencies are all the same, # - the payment currency is the company currency, but the invoice currency is different, # - the invoice currency is the company currency, but the payment currency is different, # - the invoice, payment and company currencies are all different. # For the two first cases, we can simply use the debit/credit of the invoice move line, which are always in the company currency, # and this is what the target need. # For the two last cases, we can use the debit/credit which are in the company currency, and then change them to the target currency total_amount = abs(debit - credit) actual_debit = debit > 0 and amount or 0.0 actual_credit = credit > 0 and -amount or 0.0 currency = company_currency if line_currency != target_currency: amount_currency_str = formatLang(self.env, abs(actual_debit or actual_credit), currency_obj=line_currency) total_amount_currency_str = formatLang(self.env, total_amount, currency_obj=line_currency) if currency != target_currency: ctx = context.copy() ctx.update({'date': target_date or line.date}) total_amount = currency.with_context(ctx).compute(total_amount, target_currency) actual_debit = currency.with_context(ctx).compute(actual_debit, target_currency) actual_credit = currency.with_context(ctx).compute(actual_credit, target_currency) amount_str = formatLang(self.env, abs(actual_debit or actual_credit), currency_obj=target_currency) total_amount_str = formatLang(self.env, total_amount, currency_obj=target_currency) ret_line['debit'] = abs(actual_debit) ret_line['credit'] = abs(actual_credit) ret_line['amount_str'] = amount_str ret_line['total_amount_str'] = total_amount_str ret_line['amount_currency_str'] = amount_currency_str ret_line['total_amount_currency_str'] = total_amount_currency_str ret.append(ret_line) return ret @api.model def process_reconciliations(self, data): """ Used to validate a batch of reconciliations in a single call :param data: list of dicts containing: - 'type': either 'partner' or 'account' - 'id': id of the affected res.partner or account.account - 'mv_line_ids': ids of exisiting account.move.line to reconcile - 'new_mv_line_dicts': list of dicts containing values suitable for account_move_line.create() """ for datum in data: if len(datum['mv_line_ids']) >= 1 or len(datum['mv_line_ids']) + len(datum['new_mv_line_dicts']) >= 2: self.env['account.move.line'].browse(datum['mv_line_ids']).process_reconciliation(datum['new_mv_line_dicts']) if datum['type'] == 'partner': partners = self.env['res.partner'].browse(datum['id']) partners.mark_as_reconciled() if datum['type'] == 'account': accounts = self.env['account.account'].browse(datum['id']) accounts.mark_as_reconciled() @api.multi def process_reconciliation(self, new_mv_line_dicts): """ Create new move lines from new_mv_line_dicts (if not empty) then call reconcile_partial on self and new move lines :param new_mv_line_dicts: list of dicts containing values suitable fot account_move_line.create() """ if len(self) < 1 or len(self) + len(new_mv_line_dicts) < 2: raise UserError(_('A reconciliation must involve at least 2 move lines.')) # Create writeoff move lines if len(new_mv_line_dicts) > 0: writeoff_lines = self.env['account.move.line'] company_currency = self[0].account_id.company_id.currency_id writeoff_currency = self[0].currency_id or company_currency for mv_line_dict in new_mv_line_dicts: if writeoff_currency != company_currency: mv_line_dict['debit'] = writeoff_currency.compute(mv_line_dict['debit'], company_currency) mv_line_dict['credit'] = writeoff_currency.compute(mv_line_dict['credit'], company_currency) writeoff_lines += self._create_writeoff(mv_line_dict) (self + writeoff_lines).reconcile() else: self.reconcile() #################################################### # Reconciliation methods #################################################### def _get_pair_to_reconcile(self): #field is either 'amount_residual' or 'amount_residual_currency' (if the reconciled account has a secondary currency set) field = self[0].account_id.currency_id and 'amount_residual_currency' or 'amount_residual' if not self[0].account_id.reconcile and self[0].account_id.internal_type == 'liquidity': field = 'balance' rounding = self[0].company_id.currency_id.rounding if self[0].currency_id and all([x.amount_currency and x.currency_id == self[0].currency_id for x in self]): #or if all lines share the same currency field = 'amount_residual_currency' rounding = self[0].currency_id.rounding if self._context.get('skip_full_reconcile_check') == 'amount_currency_excluded': field = 'amount_residual' elif self._context.get('skip_full_reconcile_check') == 'amount_currency_only': field = 'amount_residual_currency' #target the pair of move in self that are the oldest sorted_moves = sorted(self, key=lambda a: a.date_maturity or a.date) debit = credit = False for aml in sorted_moves: if credit and debit: break if float_compare(aml[field], 0, precision_rounding=rounding) == 1 and not debit: debit = aml elif float_compare(aml[field], 0, precision_rounding=rounding) == -1 and not credit: credit = aml return debit, credit def auto_reconcile_lines(self): """ This function iterates recursively on the recordset given as parameter as long as it can find a debit and a credit to reconcile together. It returns the recordset of the account move lines that were not reconciled during the process. """ if not self.ids: return self sm_debit_move, sm_credit_move = self._get_pair_to_reconcile() #there is no more pair to reconcile so return what move_line are left if not sm_credit_move or not sm_debit_move: return self field = self[0].account_id.currency_id and 'amount_residual_currency' or 'amount_residual' if not sm_debit_move.debit and not sm_debit_move.credit: #both debit and credit field are 0, consider the amount_residual_currency field because it's an exchange difference entry field = 'amount_residual_currency' if self[0].currency_id and all([x.currency_id == self[0].currency_id for x in self]): #all the lines have the same currency, so we consider the amount_residual_currency field field = 'amount_residual_currency' if self._context.get('skip_full_reconcile_check') == 'amount_currency_excluded': field = 'amount_residual' elif self._context.get('skip_full_reconcile_check') == 'amount_currency_only': field = 'amount_residual_currency' #Reconcile the pair together amount_reconcile = min(sm_debit_move[field], -sm_credit_move[field]) #Remove from recordset the one(s) that will be totally reconciled if amount_reconcile == sm_debit_move[field]: self -= sm_debit_move if amount_reconcile == -sm_credit_move[field]: self -= sm_credit_move #Check for the currency and amount_currency we can set currency = False amount_reconcile_currency = 0 if sm_debit_move.currency_id == sm_credit_move.currency_id and sm_debit_move.currency_id.id: currency = sm_credit_move.currency_id.id amount_reconcile_currency = min(sm_debit_move.amount_residual_currency, -sm_credit_move.amount_residual_currency) amount_reconcile = min(sm_debit_move.amount_residual, -sm_credit_move.amount_residual) if self._context.get('skip_full_reconcile_check') == 'amount_currency_excluded': amount_reconcile_currency = 0.0 currency = self._context.get('manual_full_reconcile_currency') elif self._context.get('skip_full_reconcile_check') == 'amount_currency_only': currency = self._context.get('manual_full_reconcile_currency') self.env['account.partial.reconcile'].create({ 'debit_move_id': sm_debit_move.id, 'credit_move_id': sm_credit_move.id, 'amount': amount_reconcile, 'amount_currency': amount_reconcile_currency, 'currency_id': currency, }) #Iterate process again on self return self.auto_reconcile_lines() @api.multi def reconcile(self, writeoff_acc_id=False, writeoff_journal_id=False): # Empty self can happen if the user tries to reconcile entries which are already reconciled. # The calling method might have filtered out reconciled lines. if not self: return True #Perform all checks on lines company_ids = set() all_accounts = [] partners = set() for line in self: company_ids.add(line.company_id.id) all_accounts.append(line.account_id) if (line.account_id.internal_type in ('receivable', 'payable')): partners.add(line.partner_id.id) if line.reconciled: raise UserError(_('You are trying to reconcile some entries that are already reconciled!')) if len(company_ids) > 1: raise UserError(_('To reconcile the entries company should be the same for all entries!')) if len(set(all_accounts)) > 1: raise UserError(_('Entries are not of the same account!')) if not (all_accounts[0].reconcile or all_accounts[0].internal_type == 'liquidity'): raise UserError(_('The account %s (%s) is not marked as reconciliable !') % (all_accounts[0].name, all_accounts[0].code)) #reconcile everything that can be remaining_moves = self.auto_reconcile_lines() #if writeoff_acc_id specified, then create write-off move with value the remaining amount from move in self if writeoff_acc_id and writeoff_journal_id and remaining_moves: all_aml_share_same_currency = all([x.currency_id == self[0].currency_id for x in self]) writeoff_vals = { 'account_id': writeoff_acc_id.id, 'journal_id': writeoff_journal_id.id } if not all_aml_share_same_currency: writeoff_vals['amount_currency'] = False writeoff_to_reconcile = remaining_moves._create_writeoff(writeoff_vals) #add writeoff line to reconcile algo and finish the reconciliation remaining_moves = (remaining_moves + writeoff_to_reconcile).auto_reconcile_lines() return writeoff_to_reconcile return True def _create_writeoff(self, vals): """ Create a writeoff move for the account.move.lines in self. If debit/credit is not specified in vals, the writeoff amount will be computed as the sum of amount_residual of the given recordset. :param vals: dict containing values suitable fot account_move_line.create(). The data in vals will be processed to create bot writeoff acount.move.line and their enclosing account.move. """ # Check and complete vals if 'account_id' not in vals or 'journal_id' not in vals: raise UserError(_("It is mandatory to specify an account and a journal to create a write-off.")) if ('debit' in vals) ^ ('credit' in vals): raise UserError(_("Either pass both debit and credit or none.")) if 'date' not in vals: vals['date'] = self._context.get('date_p') or time.strftime('%Y-%m-%d') if 'name' not in vals: vals['name'] = self._context.get('comment') or _('Write-Off') if 'analytic_account_id' not in vals: vals['analytic_account_id'] = self.env.context.get('analytic_id', False) #compute the writeoff amount if not given if 'credit' not in vals and 'debit' not in vals: amount = sum([r.amount_residual for r in self]) vals['credit'] = amount > 0 and amount or 0.0 vals['debit'] = amount < 0 and abs(amount) or 0.0 vals['partner_id'] = self.env['res.partner']._find_accounting_partner(self[0].partner_id).id company_currency = self[0].account_id.company_id.currency_id writeoff_currency = self[0].currency_id or company_currency if not self._context.get('skip_full_reconcile_check') == 'amount_currency_excluded' and 'amount_currency' not in vals and writeoff_currency != company_currency: vals['currency_id'] = writeoff_currency.id sign = 1 if vals['debit'] > 0 else -1 vals['amount_currency'] = sign * abs(sum([r.amount_residual_currency for r in self])) # Writeoff line in the account of self first_line_dict = self._prepare_writeoff_first_line_values(vals) # Writeoff line in specified writeoff account second_line_dict = self._prepare_writeoff_second_line_values(vals) # Create the move writeoff_move = self.env['account.move'].with_context(apply_taxes=True).create({ 'journal_id': vals['journal_id'], 'date': vals['date'], 'state': 'draft', 'line_ids': [(0, 0, first_line_dict), (0, 0, second_line_dict)], }) writeoff_move.post() # Return the writeoff move.line which is to be reconciled return writeoff_move.line_ids.filtered(lambda r: r.account_id == self[0].account_id) @api.multi def _prepare_writeoff_first_line_values(self, values): line_values = values.copy() line_values['account_id'] = self[0].account_id.id if 'analytic_account_id' in line_values: del line_values['analytic_account_id'] if 'tax_ids' in line_values: tax_ids = [] # vals['tax_ids'] is a list of commands [[4, tax_id, None], ...] for tax_id in values['tax_ids']: tax_ids.append(tax_id[1]) amount = line_values['credit'] - line_values['debit'] amount_tax = self.env['account.tax'].browse(tax_ids).compute_all(amount)['total_included'] line_values['credit'] = amount_tax > 0 and amount_tax or 0.0 line_values['debit'] = amount_tax < 0 and abs(amount_tax) or 0.0 del line_values['tax_ids'] return line_values @api.multi def _prepare_writeoff_second_line_values(self, values): line_values = values.copy() line_values['debit'], line_values['credit'] = line_values['credit'], line_values['debit'] if 'amount_currency' in values: line_values['amount_currency'] = -line_values['amount_currency'] return line_values @api.model def compute_full_after_batch_reconcile(self): """ After running the manual reconciliation wizard and making full reconciliation, we need to run this method to create potentially an exchange rate entry that will balance the remaining amount_residual_currency (possibly several aml). This ensure that all aml in the full reconciliation are reconciled (amount_residual = amount_residual_currency = 0). """ total_debit = 0 total_credit = 0 total_amount_currency = 0 currency = False aml_to_balance_currency = self.env['account.move.line'] partial_rec_set = self.env['account.partial.reconcile'] aml_id = False partial_rec_id = False maxdate = None for aml in self: total_debit += aml.debit total_credit += aml.credit if aml.amount_residual_currency: aml_to_balance_currency |= aml maxdate = max(aml.date, maxdate) if not currency and aml.currency_id: currency = aml.currency_id if aml.currency_id and aml.currency_id == currency: total_amount_currency += aml.amount_currency partial_rec_set |= aml.matched_debit_ids | aml.matched_credit_ids if currency and aml_to_balance_currency: aml = aml_to_balance_currency[0] #eventually create journal entries to book the difference due to foreign currency's exchange rate that fluctuates partial_rec = aml.credit and aml.matched_debit_ids[0] or aml.matched_credit_ids[0] aml_id, partial_rec_id = partial_rec.with_context(skip_full_reconcile_check=True).create_exchange_rate_entry(aml_to_balance_currency, 0.0, total_amount_currency, currency, maxdate) self |= aml_id partial_rec_set |= partial_rec_id total_amount_currency += aml_id.amount_currency partial_rec_ids = [x.id for x in list(partial_rec_set)] #if the total debit and credit are equal, and the total amount in currency is 0, the reconciliation is full digits_rounding_precision = self[0].company_id.currency_id.rounding if float_compare(total_debit, total_credit, precision_rounding=digits_rounding_precision) == 0 \ and (not currency or float_is_zero(total_amount_currency, precision_rounding=currency.rounding)): #in that case, mark the reference on the partial reconciliations and the entries self.env['account.full.reconcile'].with_context(check_move_validity=False).create({ 'partial_reconcile_ids': [(6, 0, partial_rec_ids)], 'reconciled_line_ids': [(6, 0, self.ids)], 'exchange_move_id': aml_id.move_id.id if aml_id else False, 'exchange_partial_rec_id': partial_rec_id.id if partial_rec_id else False}) @api.multi def remove_move_reconcile(self): """ Undo a reconciliation """ if not self: return True rec_move_ids = self.env['account.partial.reconcile'] for account_move_line in self: for invoice in account_move_line.payment_id.invoice_ids: if invoice.id == self.env.context.get('invoice_id') and account_move_line in invoice.payment_move_line_ids: account_move_line.payment_id.write({'invoice_ids': [(3, invoice.id, None)]}) rec_move_ids += account_move_line.matched_debit_ids rec_move_ids += account_move_line.matched_credit_ids if self.env.context.get('invoice_id'): current_invoice = self.env['account.invoice'].browse(self.env.context['invoice_id']) aml_to_keep = current_invoice.move_id.line_ids | current_invoice.move_id.line_ids.mapped('full_reconcile_id.exchange_move_id.line_ids') rec_move_ids = rec_move_ids.filtered( lambda r: (r.debit_move_id + r.credit_move_id) & aml_to_keep ) return rec_move_ids.unlink() #################################################### # CRUD methods #################################################### #TODO: to check/refactor @api.model def create(self, vals): """ :context's key apply_taxes: set to True if you want vals['tax_ids'] to result in the creation of move lines for taxes and eventual adjustment of the line amount (in case of a tax included in price). :context's key `check_move_validity`: check data consistency after move line creation. Eg. set to false to disable verification that the move debit-credit == 0 while creating the move lines composing the move. """ context = dict(self._context or {}) amount = vals.get('debit', 0.0) - vals.get('credit', 0.0) if not vals.get('partner_id') and context.get('partner_id'): vals['partner_id'] = context.get('partner_id') move = self.env['account.move'].browse(vals['move_id']) account = self.env['account.account'].browse(vals['account_id']) if account.deprecated: raise UserError(_('You cannot use deprecated account.')) if 'journal_id' in vals and vals['journal_id']: context['journal_id'] = vals['journal_id'] if 'date' in vals and vals['date']: context['date'] = vals['date'] if 'journal_id' not in context: context['journal_id'] = move.journal_id.id context['date'] = move.date #we need to treat the case where a value is given in the context for period_id as a string if not context.get('journal_id', False) and context.get('search_default_journal_id', False): context['journal_id'] = context.get('search_default_journal_id') if 'date' not in context: context['date'] = fields.Date.context_today(self) journal = vals.get('journal_id') and self.env['account.journal'].browse(vals['journal_id']) or move.journal_id vals['date_maturity'] = vals.get('date_maturity') or vals.get('date') or move.date ok = not (journal.type_control_ids or journal.account_control_ids) if journal.type_control_ids: type = account.user_type_id for t in journal.type_control_ids: if type == t: ok = True break if journal.account_control_ids and not ok: for a in journal.account_control_ids: if a.id == vals['account_id']: ok = True break # Automatically convert in the account's secondary currency if there is one and # the provided values were not already multi-currency if account.currency_id and 'amount_currency' not in vals and account.currency_id.id != account.company_id.currency_id.id: vals['currency_id'] = account.currency_id.id if self._context.get('skip_full_reconcile_check') == 'amount_currency_excluded': vals['amount_currency'] = 0.0 else: ctx = {} if 'date' in vals: ctx['date'] = vals['date'] vals['amount_currency'] = account.company_id.currency_id.with_context(ctx).compute(amount, account.currency_id) if not ok: raise UserError(_('You cannot use this general account in this journal, check the tab \'Entry Controls\' on the related journal.')) # Create tax lines tax_lines_vals = [] if context.get('apply_taxes') and vals.get('tax_ids'): # Get ids from triplets : https://www.odoo.com/documentation/master/reference/orm.html#openerp.models.Model.write tax_ids = [tax['id'] for tax in self.resolve_2many_commands('tax_ids', vals['tax_ids']) if tax.get('id')] # Since create() receives ids instead of recordset, let's just use the old-api bridge taxes = self.env['account.tax'].browse(tax_ids) currency = self.env['res.currency'].browse(vals.get('currency_id')) partner = self.env['res.partner'].browse(vals.get('partner_id')) res = taxes.with_context(round=True).compute_all(amount, currency, 1, vals.get('product_id'), partner) # Adjust line amount if any tax is price_include if abs(res['total_excluded']) < abs(amount): if vals['debit'] != 0.0: vals['debit'] = res['total_excluded'] if vals['credit'] != 0.0: vals['credit'] = -res['total_excluded'] if vals.get('amount_currency'): vals['amount_currency'] = self.env['res.currency'].browse(vals['currency_id']).round(vals['amount_currency'] * (res['total_excluded']/amount)) # Create tax lines for tax_vals in res['taxes']: if tax_vals['amount']: tax = self.env['account.tax'].browse([tax_vals['id']]) account_id = (amount > 0 and tax_vals['account_id'] or tax_vals['refund_account_id']) if not account_id: account_id = vals['account_id'] temp = { 'account_id': account_id, 'name': vals['name'] + ' ' + tax_vals['name'], 'tax_line_id': tax_vals['id'], 'move_id': vals['move_id'], 'partner_id': vals.get('partner_id'), 'statement_id': vals.get('statement_id'), 'debit': tax_vals['amount'] > 0 and tax_vals['amount'] or 0.0, 'credit': tax_vals['amount'] < 0 and -tax_vals['amount'] or 0.0, 'analytic_account_id': vals.get('analytic_account_id') if tax.analytic else False, } bank = self.env["account.bank.statement"].browse(vals.get('statement_id')) if bank.currency_id != bank.company_id.currency_id: ctx = {} if 'date' in vals: ctx['date'] = vals['date'] temp['currency_id'] = bank.currency_id.id temp['amount_currency'] = bank.company_id.currency_id.with_context(ctx).compute(tax_vals['amount'], bank.currency_id, round=True) tax_lines_vals.append(temp) new_line = super(AccountMoveLine, self).create(vals) for tax_line_vals in tax_lines_vals: # TODO: remove .with_context(context) once this context nonsense is solved self.with_context(context).create(tax_line_vals) if self._context.get('check_move_validity', True): move.with_context(context)._post_validate() return new_line @api.multi def unlink(self): self._update_check() move_ids = set() for line in self: if line.move_id.id not in move_ids: move_ids.add(line.move_id.id) result = super(AccountMoveLine, self).unlink() if self._context.get('check_move_validity', True) and move_ids: self.env['account.move'].browse(list(move_ids))._post_validate() return result @api.multi def write(self, vals): if ('account_id' in vals) and self.env['account.account'].browse(vals['account_id']).deprecated: raise UserError(_('You cannot use deprecated account.')) if any(key in vals for key in ('account_id', 'journal_id', 'date', 'move_id', 'debit', 'credit')): self._update_check() if not self._context.get('allow_amount_currency') and any(key in vals for key in ('amount_currency', 'currency_id')): #hackish workaround to write the amount_currency when assigning a payment to an invoice through the 'add' button #this is needed to compute the correct amount_residual_currency and potentially create an exchange difference entry self._update_check() #when we set the expected payment date, log a note on the invoice_id related (if any) if vals.get('expected_pay_date') and self.invoice_id: msg = _('New expected payment date: ') + vals['expected_pay_date'] + '.\n' + vals.get('internal_note', '') self.invoice_id.message_post(body=msg) #TODO: check it is an internal note (not a regular email)! #when making a reconciliation on an existing liquidity journal item, mark the payment as reconciled for record in self: if 'statement_id' in vals and record.payment_id: # In case of an internal transfer, there are 2 liquidity move lines to match with a bank statement if all(line.statement_id for line in record.payment_id.move_line_ids.filtered(lambda r: r.id != record.id and r.account_id.internal_type=='liquidity')): record.payment_id.state = 'reconciled' result = super(AccountMoveLine, self).write(vals) if self._context.get('check_move_validity', True): move_ids = set() for line in self: if line.move_id.id not in move_ids: move_ids.add(line.move_id.id) self.env['account.move'].browse(list(move_ids))._post_validate() return result @api.multi def _update_check(self): """ Raise Warning to cause rollback if the move is posted, some entries are reconciled or the move is older than the lock date""" move_ids = set() for line in self: err_msg = _('Move name (id): %s (%s)') % (line.move_id.name, str(line.move_id.id)) if line.move_id.state != 'draft': raise UserError(_('You cannot do this modification on a posted journal entry, you can just change some non legal fields. You must revert the journal entry to cancel it.\n%s.') % err_msg) if line.reconciled and not (line.debit == 0 and line.credit == 0): raise UserError(_('You cannot do this modification on a reconciled entry. You can just change some non legal fields or you must unreconcile first.\n%s.') % err_msg) if line.move_id.id not in move_ids: move_ids.add(line.move_id.id) self.env['account.move'].browse(list(move_ids))._check_lock_date() return True #################################################### # Misc / utility methods #################################################### @api.multi @api.depends('ref', 'move_id') def name_get(self): result = [] for line in self: if line.ref: result.append((line.id, (line.move_id.name or '') + '(' + line.ref + ')')) else: result.append((line.id, line.move_id.name)) return result @api.model def compute_amount_fields(self, amount, src_currency, company_currency, invoice_currency=False): """ Helper function to compute value for fields debit/credit/amount_currency based on an amount and the currencies given in parameter""" amount_currency = False currency_id = False if src_currency and src_currency != company_currency: amount_currency = amount amount = src_currency.with_context(self._context).compute(amount, company_currency) currency_id = src_currency.id debit = amount > 0 and amount or 0.0 credit = amount < 0 and -amount or 0.0 if invoice_currency and invoice_currency != company_currency and not amount_currency: amount_currency = src_currency.with_context(self._context).compute(amount, invoice_currency) currency_id = invoice_currency.id return debit, credit, amount_currency, currency_id @api.multi def create_analytic_lines(self): """ Create analytic items upon validation of an account.move.line having an analytic account. This method first remove any existing analytic item related to the line before creating any new one. """ self.mapped('analytic_line_ids').unlink() for obj_line in self: if obj_line.analytic_account_id: vals_line = obj_line._prepare_analytic_line()[0] self.env['account.analytic.line'].create(vals_line) @api.one def _prepare_analytic_line(self): """ Prepare the values used to create() an account.analytic.line upon validation of an account.move.line having an analytic account. This method is intended to be extended in other modules. """ amount = (self.credit or 0.0) - (self.debit or 0.0) return { 'name': self.name, 'date': self.date, 'account_id': self.analytic_account_id.id, 'tag_ids': [(6, 0, self.analytic_tag_ids.ids)], 'unit_amount': self.quantity, 'product_id': self.product_id and self.product_id.id or False, 'product_uom_id': self.product_uom_id and self.product_uom_id.id or False, 'amount': self.company_currency_id.with_context(date=self.date or fields.Date.context_today(self)).compute(amount, self.analytic_account_id.currency_id) if self.analytic_account_id.currency_id else amount, 'general_account_id': self.account_id.id, 'ref': self.ref, 'move_id': self.id, 'user_id': self.invoice_id.user_id.id or self._uid, } @api.model def _query_get(self, domain=None): context = dict(self._context or {}) domain = domain or [] if not isinstance(domain, (list, tuple)): domain = safe_eval(domain) date_field = 'date' if context.get('aged_balance'): date_field = 'date_maturity' if context.get('date_to'): domain += [(date_field, '<=', context['date_to'])] if context.get('date_from'): if not context.get('strict_range'): domain += ['|', (date_field, '>=', context['date_from']), ('account_id.user_type_id.include_initial_balance', '=', True)] elif context.get('initial_bal'): domain += [(date_field, '<', context['date_from'])] else: domain += [(date_field, '>=', context['date_from'])] if context.get('journal_ids'): domain += [('journal_id', 'in', context['journal_ids'])] state = context.get('state') if state and state.lower() != 'all': domain += [('move_id.state', '=', state)] if context.get('company_id'): domain += [('company_id', '=', context['company_id'])] if 'company_ids' in context: domain += [('company_id', 'in', context['company_ids'])] if context.get('reconcile_date'): domain += ['|', ('reconciled', '=', False), '|', ('matched_debit_ids.create_date', '>', context['reconcile_date']), ('matched_credit_ids.create_date', '>', context['reconcile_date'])] if context.get('account_tag_ids'): domain += [('account_id.tag_ids', 'in', context['account_tag_ids'].ids)] if context.get('analytic_tag_ids'): domain += ['|', ('analytic_account_id.tag_ids', 'in', context['analytic_tag_ids'].ids), ('analytic_tag_ids', 'in', context['analytic_tag_ids'].ids)] if context.get('analytic_account_ids'): domain += [('analytic_account_id', 'in', context['analytic_account_ids'].ids)] where_clause = "" where_clause_params = [] tables = '' if domain: query = self._where_calc(domain) tables, where_clause, where_clause_params = query.get_sql() return tables, where_clause, where_clause_params @api.multi def open_reconcile_view(self): [action] = self.env.ref('account.action_account_moves_all_a').read() ids = [] for aml in self: if aml.account_id.reconcile: ids.extend([r.debit_move_id.id for r in aml.matched_debit_ids] if aml.credit > 0 else [r.credit_move_id.id for r in aml.matched_credit_ids]) ids.append(aml.id) action['domain'] = [('id', 'in', ids)] return action class AccountPartialReconcile(models.Model): _name = "account.partial.reconcile" _description = "Partial Reconcile" debit_move_id = fields.Many2one('account.move.line', index=True, required=True) credit_move_id = fields.Many2one('account.move.line', index=True, required=True) amount = fields.Monetary(currency_field='company_currency_id', help="Amount concerned by this matching. Assumed to be always positive") amount_currency = fields.Monetary(string="Amount in Currency") currency_id = fields.Many2one('res.currency', string='Currency') company_currency_id = fields.Many2one('res.currency', related='company_id.currency_id', readonly=True, help='Utility field to express amount currency') company_id = fields.Many2one('res.company', related='debit_move_id.company_id', store=True, string='Currency') full_reconcile_id = fields.Many2one('account.full.reconcile', string="Full Reconcile", copy=False) def create_exchange_rate_entry(self, aml_to_fix, amount_diff, diff_in_currency, currency, move_date): """ Automatically create a journal entry to book the exchange rate difference. That new journal entry is made in the company `currency_exchange_journal_id` and one of its journal items is matched with the other lines to balance the full reconciliation. """ for rec in self: if not rec.company_id.currency_exchange_journal_id: raise UserError(_("You should configure the 'Exchange Rate Journal' in the accounting settings, to manage automatically the booking of accounting entries related to differences between exchange rates.")) if not rec.company_id.income_currency_exchange_account_id.id: raise UserError(_("You should configure the 'Gain Exchange Rate Account' in the accounting settings, to manage automatically the booking of accounting entries related to differences between exchange rates.")) if not rec.company_id.expense_currency_exchange_account_id.id: raise UserError(_("You should configure the 'Loss Exchange Rate Account' in the accounting settings, to manage automatically the booking of accounting entries related to differences between exchange rates.")) move_vals = {'journal_id': rec.company_id.currency_exchange_journal_id.id} # The move date should be the maximum date between payment and invoice (in case # of payment in advance). However, we should make sure the move date is not # recorded after the end of year closing. if move_date > rec.company_id.fiscalyear_lock_date: move_vals['date'] = move_date move = rec.env['account.move'].create(move_vals) amount_diff = rec.company_id.currency_id.round(amount_diff) diff_in_currency = currency.round(diff_in_currency) line_to_reconcile = rec.env['account.move.line'].with_context(check_move_validity=False).create({ 'name': _('Currency exchange rate difference'), 'debit': amount_diff < 0 and -amount_diff or 0.0, 'credit': amount_diff > 0 and amount_diff or 0.0, 'account_id': rec.debit_move_id.account_id.id, 'move_id': move.id, 'currency_id': currency.id, 'amount_currency': -diff_in_currency, 'partner_id': rec.debit_move_id.partner_id.id, }) rec.env['account.move.line'].create({ 'name': _('Currency exchange rate difference'), 'debit': amount_diff > 0 and amount_diff or 0.0, 'credit': amount_diff < 0 and -amount_diff or 0.0, 'account_id': amount_diff > 0 and rec.company_id.currency_exchange_journal_id.default_debit_account_id.id or rec.company_id.currency_exchange_journal_id.default_credit_account_id.id, 'move_id': move.id, 'currency_id': currency.id, 'amount_currency': diff_in_currency, 'partner_id': rec.debit_move_id.partner_id.id, }) for aml in aml_to_fix: partial_rec = rec.env['account.partial.reconcile'].create({ 'debit_move_id': aml.credit and line_to_reconcile.id or aml.id, 'credit_move_id': aml.debit and line_to_reconcile.id or aml.id, 'amount': abs(aml.amount_residual), 'amount_currency': abs(aml.amount_residual_currency), 'currency_id': currency.id, }) move.post() return line_to_reconcile, partial_rec # Do not forwardport in master as of 2017-07-20 def _fix_multiple_exchange_rates_diff(self, amls_to_fix, amount_diff, diff_in_currency, currency, move): self.ensure_one() move_lines = self.env['account.move.line'].with_context(check_move_validity=False) partial_reconciles = self.with_context(skip_full_reconcile_check=True) amount_diff = self.company_id.currency_id.round(amount_diff) diff_in_currency = currency.round(diff_in_currency) for aml in amls_to_fix: account_payable_line = move_lines.create({ 'name': _('Currency exchange rate difference'), 'debit': amount_diff < 0 and -aml.amount_residual or 0.0, 'credit': amount_diff > 0 and aml.amount_residual or 0.0, 'account_id': self.debit_move_id.account_id.id, 'move_id': move.id, 'currency_id': currency.id, 'amount_currency': -aml.amount_residual_currency, 'partner_id': self.debit_move_id.partner_id.id, }) move_lines.create({ 'name': _('Currency exchange rate difference'), 'debit': amount_diff > 0 and aml.amount_residual or 0.0, 'credit': amount_diff < 0 and -aml.amount_residual or 0.0, 'account_id': amount_diff > 0 and self.company_id.currency_exchange_journal_id.default_debit_account_id.id or self.company_id.currency_exchange_journal_id.default_credit_account_id.id, 'move_id': move.id, 'currency_id': currency.id, 'amount_currency': aml.amount_residual_currency, 'partner_id': self.debit_move_id.partner_id.id}) partial_rec = super(AccountPartialReconcile, partial_reconciles).create({ 'debit_move_id': aml.credit and account_payable_line.id or aml.id, 'credit_move_id': aml.debit and account_payable_line.id or aml.id, 'amount': abs(aml.amount_residual), 'amount_currency': abs(aml.amount_residual_currency), 'currency_id': currency.id, }) move_lines |= account_payable_line partial_reconciles |= partial_rec partial_reconciles._compute_partial_lines() return move_lines, partial_reconciles # Do not forwardport in master as of 2017-07-20 def _compute_partial_lines(self): if self._context.get('skip_full_reconcile_check'): #when running the manual reconciliation wizard, don't check the partials separately for full #reconciliation or exchange rate because it is handled manually after the whole processing return self #check if the reconcilation is full #first, gather all journal items involved in the reconciliation just created partial_rec_set = OrderedDict.fromkeys([x for x in self]) aml_set = aml_to_balance = self.env['account.move.line'] total_debit = 0 total_credit = 0 total_amount_currency = 0 #make sure that all partial reconciliations share the same secondary currency otherwise it's not #possible to compute the exchange difference entry and it has to be done manually. currency = list(partial_rec_set)[0].currency_id maxdate = None for partial_rec in partial_rec_set: if partial_rec.currency_id != currency: #no exchange rate entry will be created currency = None for aml in [partial_rec.debit_move_id, partial_rec.credit_move_id]: if aml not in aml_set: if aml.amount_residual or aml.amount_residual_currency: aml_to_balance |= aml maxdate = max(aml.date, maxdate) total_debit += aml.debit total_credit += aml.credit aml_set |= aml if aml.currency_id and aml.currency_id == currency: total_amount_currency += aml.amount_currency elif partial_rec.currency_id and partial_rec.currency_id == currency: #if the aml has no secondary currency but is reconciled with other journal item(s) in secondary currency, the amount #currency is recorded on the partial rec and in order to check if the reconciliation is total, we need to convert the #aml.balance in that foreign currency total_amount_currency += aml.company_id.currency_id.with_context(date=aml.date).compute(aml.balance, partial_rec.currency_id) for x in aml.matched_debit_ids | aml.matched_credit_ids: partial_rec_set[x] = None partial_rec_ids = [x.id for x in partial_rec_set.keys()] aml_ids = aml_set.ids #then, if the total debit and credit are equal, or the total amount in currency is 0, the reconciliation is full digits_rounding_precision = aml_set[0].company_id.currency_id.rounding if (currency and float_is_zero(total_amount_currency, precision_rounding=currency.rounding)) or float_compare(total_debit, total_credit, precision_rounding=digits_rounding_precision) == 0: exchange_move_id = False exchange_partial_rec_id = False if currency and aml_to_balance: exchange_move = (self.env['account.move'] .create(self.env['account.full.reconcile'] ._prepare_exchange_diff_move(move_date=maxdate, company=aml_to_balance[0].company_id))) #eventually create a journal entry to book the difference due to foreign currency's exchange rate that fluctuates rate_diff_amls, rate_diff_partial_recs = partial_rec._fix_multiple_exchange_rates_diff(aml_to_balance, total_debit - total_credit, total_amount_currency, currency, exchange_move) aml_ids += rate_diff_amls.ids partial_rec_ids += rate_diff_partial_recs.ids exchange_move.post() exchange_move_id = exchange_move.id exchange_partial_rec_id = rate_diff_partial_recs[-1:].id #mark the reference of the full reconciliation on the partial ones and on the entries self.env['account.full.reconcile'].with_context(check_move_validity=False).create({ 'partial_reconcile_ids': [(4, p_id) for p_id in partial_rec_ids], 'reconciled_line_ids': [(4, a_id) for a_id in aml_ids], 'exchange_move_id': exchange_move_id, 'exchange_partial_rec_id': exchange_partial_rec_id, }) # Do not forwardport in master as of 2017-07-20 @api.model def create(self, vals): res = super(AccountPartialReconcile, self).create(vals) res._compute_partial_lines() return res @api.multi def unlink(self): """ When removing a partial reconciliation, also unlink its full reconciliation if it exists """ to_unlink = self full_to_unlink = self.env['account.full.reconcile'] res = True if self._context.get('full_rec_lookup', True): for rec in self: #exclude partial reconciliations related to an exchange rate entry, because the unlink of the full reconciliation will already do it if self.env['account.full.reconcile'].search([('exchange_partial_rec_id', '=', rec.id)]): to_unlink = to_unlink - rec #without the deleted partial reconciliations, the full reconciliation won't be full anymore if rec.full_reconcile_id: full_to_unlink |= rec.full_reconcile_id if to_unlink: res = super(AccountPartialReconcile, to_unlink).unlink() if full_to_unlink: full_to_unlink.unlink() return res class AccountFullReconcile(models.Model): _name = "account.full.reconcile" _description = "Full Reconcile" name = fields.Char(string='Number', required=True, copy=False, default=lambda self: self.env['ir.sequence'].next_by_code('account.reconcile')) partial_reconcile_ids = fields.One2many('account.partial.reconcile', 'full_reconcile_id', string='Reconciliation Parts') reconciled_line_ids = fields.One2many('account.move.line', 'full_reconcile_id', string='Matched Journal Items') exchange_move_id = fields.Many2one('account.move') exchange_partial_rec_id = fields.Many2one('account.partial.reconcile') @api.multi def unlink(self): """ When removing a full reconciliation, we need to revert the eventual journal entries we created to book the fluctuation of the foreign currency's exchange rate. We need also to reconcile together the origin currency difference line and its reversal in order to completly cancel the currency difference entry on the partner account (otherwise it will still appear on the aged balance for example). """ for rec in self: if not rec.exchange_move_id or not rec.exchange_partial_rec_id: continue #reverse the exchange rate entry reversed_move_id = rec.exchange_move_id.reverse_moves()[0] reversed_move = self.env['account.move'].browse(reversed_move_id) #search the original line and its newly created reversal for aml in reversed_move.line_ids: if aml.account_id.reconcile: break if aml: precision = aml.currency_id and aml.currency_id.rounding or aml.company_id.currency_id.rounding if aml.debit or float_compare(aml.amount_currency, 0, precision_rounding=precision) == 1: pair_to_rec = aml | rec.exchange_partial_rec_id.credit_move_id else: pair_to_rec = aml | rec.exchange_partial_rec_id.debit_move_id #remove the partial reconciliation of the exchange rate entry as well rec.exchange_partial_rec_id.with_context(full_rec_lookup=False).unlink() #reconcile together the original exchange rate line and its reversal pair_to_rec.reconcile() return super(AccountFullReconcile, self).unlink() # Do not forwardport in master as of 2017-07-20 @api.model def _prepare_exchange_diff_move(self, move_date, company): if not company.currency_exchange_journal_id: raise UserError(_("You should configure the 'Exchange Rate Journal' in the accounting settings, to manage automatically the booking of accounting entries related to differences between exchange rates.")) if not company.income_currency_exchange_account_id.id: raise UserError(_("You should configure the 'Gain Exchange Rate Account' in the accounting settings, to manage automatically the booking of accounting entries related to differences between exchange rates.")) if not company.expense_currency_exchange_account_id.id: raise UserError(_("You should configure the 'Loss Exchange Rate Account' in the accounting settings, to manage automatically the booking of accounting entries related to differences between exchange rates.")) res = {'journal_id': company.currency_exchange_journal_id.id} # The move date should be the maximum date between payment and invoice # (in case of payment in advance). However, we should make sure the # move date is not recorded after the end of year closing. if move_date > company.fiscalyear_lock_date: res['date'] = move_date return res