696 lines
35 KiB
Python
696 lines
35 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from flectra import models, fields, api, _
|
|
from flectra.exceptions import UserError, ValidationError
|
|
|
|
MAP_INVOICE_TYPE_PARTNER_TYPE = {
|
|
'out_invoice': 'customer',
|
|
'out_refund': 'customer',
|
|
'in_invoice': 'supplier',
|
|
'in_refund': 'supplier',
|
|
}
|
|
# Since invoice amounts are unsigned, this is how we know if money comes in or goes out
|
|
MAP_INVOICE_TYPE_PAYMENT_SIGN = {
|
|
'out_invoice': 1,
|
|
'in_refund': -1,
|
|
'in_invoice': -1,
|
|
'out_refund': 1,
|
|
}
|
|
|
|
class account_payment_method(models.Model):
|
|
_name = "account.payment.method"
|
|
_description = "Payment Methods"
|
|
|
|
name = fields.Char(required=True, translate=True)
|
|
code = fields.Char(required=True) # For internal identification
|
|
payment_type = fields.Selection([('inbound', 'Inbound'), ('outbound', 'Outbound')], required=True)
|
|
|
|
|
|
class account_abstract_payment(models.AbstractModel):
|
|
_name = "account.abstract.payment"
|
|
_description = "Contains the logic shared between models which allows to register payments"
|
|
|
|
payment_type = fields.Selection([('outbound', 'Send Money'), ('inbound', 'Receive Money')], string='Payment Type', required=True)
|
|
payment_method_id = fields.Many2one('account.payment.method', string='Payment Method Type', required=True, oldname="payment_method",
|
|
help="Manual: Get paid by cash, check or any other method outside of Flectra.\n"\
|
|
"Electronic: Get paid automatically through a payment acquirer by requesting a transaction on a card saved by the customer when buying or subscribing online (payment token).\n"\
|
|
"Check: Pay bill by check and print it from Flectra.\n"\
|
|
"Batch Deposit: Encase several customer checks at once by generating a batch deposit to submit to your bank. When encoding the bank statement in Flectra, you are suggested to reconcile the transaction with the batch deposit.To enable batch deposit,module account_batch_deposit must be installed.\n"\
|
|
"SEPA Credit Transfer: Pay bill from a SEPA Credit Transfer file you submit to your bank. To enable sepa credit transfer, module account_sepa must be installed ")
|
|
payment_method_code = fields.Char(related='payment_method_id.code',
|
|
help="Technical field used to adapt the interface to the payment type selected.", readonly=True)
|
|
|
|
partner_type = fields.Selection([('customer', 'Customer'), ('supplier', 'Vendor')])
|
|
partner_id = fields.Many2one('res.partner', string='Partner')
|
|
|
|
amount = fields.Monetary(string='Payment Amount', required=True)
|
|
currency_id = fields.Many2one('res.currency', string='Currency', required=True, default=lambda self: self.env.user.company_id.currency_id)
|
|
payment_date = fields.Date(string='Payment Date', default=fields.Date.context_today, required=True, copy=False)
|
|
communication = fields.Char(string='Memo')
|
|
journal_id = fields.Many2one('account.journal', string='Payment Journal', required=True, domain=[('type', 'in', ('bank', 'cash'))])
|
|
company_id = fields.Many2one('res.company', related='journal_id.company_id', string='Company', readonly=True)
|
|
|
|
hide_payment_method = fields.Boolean(compute='_compute_hide_payment_method',
|
|
help="Technical field used to hide the payment method if the selected journal has only one available which is 'manual'")
|
|
|
|
@api.one
|
|
@api.constrains('amount')
|
|
def _check_amount(self):
|
|
if self.amount < 0:
|
|
raise ValidationError(_('The payment amount cannot be negative.'))
|
|
|
|
@api.multi
|
|
@api.depends('payment_type', 'journal_id')
|
|
def _compute_hide_payment_method(self):
|
|
for payment in self:
|
|
if not payment.journal_id:
|
|
payment.hide_payment_method = True
|
|
continue
|
|
journal_payment_methods = payment.payment_type == 'inbound'\
|
|
and payment.journal_id.inbound_payment_method_ids\
|
|
or payment.journal_id.outbound_payment_method_ids
|
|
payment.hide_payment_method = len(journal_payment_methods) == 1 and journal_payment_methods[0].code == 'manual'
|
|
|
|
@api.onchange('journal_id')
|
|
def _onchange_journal(self):
|
|
if self.journal_id:
|
|
self.currency_id = self.journal_id.currency_id or self.company_id.currency_id
|
|
# Set default payment method (we consider the first to be the default one)
|
|
payment_methods = self.payment_type == 'inbound' and self.journal_id.inbound_payment_method_ids or self.journal_id.outbound_payment_method_ids
|
|
self.payment_method_id = payment_methods and payment_methods[0] or False
|
|
# Set payment method domain (restrict to methods enabled for the journal and to selected payment type)
|
|
payment_type = self.payment_type in ('outbound', 'transfer') and 'outbound' or 'inbound'
|
|
return {'domain': {'payment_method_id': [('payment_type', '=', payment_type), ('id', 'in', payment_methods.ids)]}}
|
|
return {}
|
|
|
|
@api.model
|
|
def _compute_total_invoices_amount(self):
|
|
""" Compute the sum of the residual of invoices, expressed in the payment currency """
|
|
payment_currency = self.currency_id or self.journal_id.currency_id or self.journal_id.company_id.currency_id or self.env.user.company_id.currency_id
|
|
|
|
total = 0
|
|
for inv in self.invoice_ids:
|
|
if inv.currency_id == payment_currency:
|
|
total += inv.residual_signed
|
|
else:
|
|
total += inv.company_currency_id.with_context(date=self.payment_date).compute(
|
|
inv.residual_company_signed, payment_currency)
|
|
return abs(total)
|
|
|
|
|
|
class account_register_payments(models.TransientModel):
|
|
_name = "account.register.payments"
|
|
_inherit = 'account.abstract.payment'
|
|
_description = "Register payments on multiple invoices"
|
|
|
|
invoice_ids = fields.Many2many('account.invoice', string='Invoices', copy=False)
|
|
multi = fields.Boolean(string='Multi', help='Technical field indicating if the user selected invoices from multiple partners or from different types.')
|
|
|
|
@api.onchange('payment_type')
|
|
def _onchange_payment_type(self):
|
|
if self.payment_type:
|
|
return {'domain': {'payment_method_id': [('payment_type', '=', self.payment_type)]}}
|
|
|
|
@api.model
|
|
def _compute_payment_amount(self, invoice_ids):
|
|
payment_currency = self.currency_id or self.journal_id.currency_id or self.journal_id.company_id.currency_id
|
|
|
|
total = 0
|
|
for inv in invoice_ids:
|
|
if inv.currency_id == payment_currency:
|
|
total += MAP_INVOICE_TYPE_PAYMENT_SIGN[inv.type] * inv.residual_company_signed
|
|
else:
|
|
amount_residual = inv.company_currency_id.with_context(date=self.payment_date).compute(
|
|
inv.residual_company_signed, payment_currency)
|
|
total += MAP_INVOICE_TYPE_PAYMENT_SIGN[inv.type] * amount_residual
|
|
return total
|
|
|
|
@api.model
|
|
def default_get(self, fields):
|
|
rec = super(account_register_payments, self).default_get(fields)
|
|
active_ids = self._context.get('active_ids')
|
|
|
|
# Check for selected invoices ids
|
|
if not active_ids:
|
|
raise UserError(_("Programming error: wizard action executed without active_ids in context."))
|
|
|
|
invoices = self.env['account.invoice'].browse(active_ids)
|
|
|
|
# Check all invoices are open
|
|
if any(invoice.state != 'open' for invoice in invoices):
|
|
raise UserError(_("You can only register payments for open invoices"))
|
|
# Check all invoices have the same currency
|
|
if any(inv.currency_id != invoices[0].currency_id for inv in invoices):
|
|
raise UserError(_("In order to pay multiple invoices at once, they must use the same currency."))
|
|
|
|
# Look if we are mixin multiple commercial_partner or customer invoices with vendor bills
|
|
multi = any(inv.commercial_partner_id != invoices[0].commercial_partner_id
|
|
or MAP_INVOICE_TYPE_PARTNER_TYPE[inv.type] != MAP_INVOICE_TYPE_PARTNER_TYPE[invoices[0].type]
|
|
for inv in invoices)
|
|
|
|
total_amount = self._compute_payment_amount(invoices)
|
|
|
|
rec.update({
|
|
'amount': abs(total_amount),
|
|
'currency_id': invoices[0].currency_id.id,
|
|
'payment_type': total_amount > 0 and 'inbound' or 'outbound',
|
|
'partner_id': False if multi else invoices[0].commercial_partner_id.id,
|
|
'partner_type': False if multi else MAP_INVOICE_TYPE_PARTNER_TYPE[invoices[0].type],
|
|
'communication': ' '.join([ref for ref in invoices.mapped('reference') if ref]),
|
|
'invoice_ids': [(6, 0, invoices.ids)],
|
|
'multi': multi,
|
|
})
|
|
return rec
|
|
|
|
@api.multi
|
|
def _groupby_invoices(self):
|
|
'''Split the invoices linked to the wizard according to their commercial partner and their type.
|
|
|
|
:return: a dictionary mapping (commercial_partner_id, type) => invoices recordset.
|
|
'''
|
|
results = {}
|
|
# Create a dict dispatching invoices according to their commercial_partner_id and type
|
|
for inv in self.invoice_ids:
|
|
key = (inv.commercial_partner_id.id, MAP_INVOICE_TYPE_PARTNER_TYPE[inv.type])
|
|
if not key in results:
|
|
results[key] = self.env['account.invoice']
|
|
results[key] += inv
|
|
return results
|
|
|
|
@api.multi
|
|
def _prepare_payment_vals(self, invoices):
|
|
'''Create the payment values.
|
|
|
|
:param invoices: The invoices that should have the same commercial partner and the same type.
|
|
:return: The payment values as a dictionary.
|
|
'''
|
|
amount = self._compute_payment_amount(invoices) if self.multi else self.amount
|
|
payment_type = ('inbound' if amount > 0 else 'outbound') if self.multi else self.payment_type
|
|
return {
|
|
'journal_id': self.journal_id.id,
|
|
'payment_method_id': self.payment_method_id.id,
|
|
'payment_date': self.payment_date,
|
|
'communication': self.communication,
|
|
'invoice_ids': [(6, 0, invoices.ids)],
|
|
'payment_type': payment_type,
|
|
'amount': abs(amount),
|
|
'currency_id': self.currency_id.id,
|
|
'partner_id': invoices[0].commercial_partner_id.id,
|
|
'partner_type': MAP_INVOICE_TYPE_PARTNER_TYPE[invoices[0].type],
|
|
}
|
|
|
|
@api.multi
|
|
def get_payments_vals(self):
|
|
'''Compute the values for payments.
|
|
|
|
:return: a list of payment values (dictionary).
|
|
'''
|
|
if self.multi:
|
|
groups = self._groupby_invoices()
|
|
return [self._prepare_payment_vals(invoices) for invoices in groups.values()]
|
|
return [self._prepare_payment_vals(self.invoice_ids)]
|
|
|
|
@api.multi
|
|
def create_payments(self):
|
|
'''Create payments according to the invoices.
|
|
Having invoices with different commercial_partner_id or different type (Vendor bills with customer invoices)
|
|
leads to multiple payments.
|
|
In case of all the invoices are related to the same commercial_partner_id and have the same type,
|
|
only one payment will be created.
|
|
|
|
:return: The ir.actions.act_window to show created payments.
|
|
'''
|
|
Payment = self.env['account.payment']
|
|
payments = Payment
|
|
for payment_vals in self.get_payments_vals():
|
|
payments += Payment.create(payment_vals)
|
|
payments.post()
|
|
return {
|
|
'name': _('Payments'),
|
|
'domain': [('id', 'in', payments.ids), ('state', '=', 'posted')],
|
|
'view_type': 'form',
|
|
'view_mode': 'tree,form',
|
|
'res_model': 'account.payment',
|
|
'view_id': False,
|
|
'type': 'ir.actions.act_window',
|
|
}
|
|
|
|
|
|
class account_payment(models.Model):
|
|
_name = "account.payment"
|
|
_inherit = ['mail.thread', 'account.abstract.payment']
|
|
_description = "Payments"
|
|
_order = "payment_date desc, name desc"
|
|
|
|
@api.one
|
|
@api.depends('invoice_ids')
|
|
def _get_has_invoices(self):
|
|
self.has_invoices = bool(self.invoice_ids)
|
|
|
|
@api.multi
|
|
@api.depends('move_line_ids.reconciled')
|
|
def _get_move_reconciled(self):
|
|
for payment in self:
|
|
rec = True
|
|
for aml in payment.move_line_ids.filtered(lambda x: x.account_id.reconcile):
|
|
if not aml.reconciled:
|
|
rec = False
|
|
payment.move_reconciled = rec
|
|
|
|
@api.one
|
|
@api.depends('invoice_ids', 'amount', 'payment_date', 'currency_id')
|
|
def _compute_payment_difference(self):
|
|
if len(self.invoice_ids) == 0:
|
|
return
|
|
if self.invoice_ids[0].type in ['in_invoice', 'out_refund']:
|
|
self.payment_difference = self.amount - self._compute_total_invoices_amount()
|
|
else:
|
|
self.payment_difference = self._compute_total_invoices_amount() - self.amount
|
|
|
|
company_id = fields.Many2one(store=True)
|
|
name = fields.Char(readonly=True, copy=False, default="Draft Payment") # The name is attributed upon post()
|
|
state = fields.Selection([('draft', 'Draft'), ('posted', 'Posted'), ('sent', 'Sent'), ('reconciled', 'Reconciled'), ('cancelled', 'Cancelled')], readonly=True, default='draft', copy=False, string="Status")
|
|
|
|
payment_type = fields.Selection(selection_add=[('transfer', 'Internal Transfer')])
|
|
payment_reference = fields.Char(copy=False, readonly=True, help="Reference of the document used to issue this payment. Eg. check number, file name, etc.")
|
|
move_name = fields.Char(string='Journal Entry Name', readonly=True,
|
|
default=False, copy=False,
|
|
help="Technical field holding the number given to the journal entry, automatically set when the statement line is reconciled then stored to set the same number again if the line is cancelled, set to draft and re-processed again.")
|
|
|
|
# Money flows from the journal_id's default_debit_account_id or default_credit_account_id to the destination_account_id
|
|
destination_account_id = fields.Many2one('account.account', compute='_compute_destination_account_id', readonly=True)
|
|
# For money transfer, money goes from journal_id to a transfer account, then from the transfer account to destination_journal_id
|
|
destination_journal_id = fields.Many2one('account.journal', string='Transfer To', domain=[('type', 'in', ('bank', 'cash'))])
|
|
|
|
invoice_ids = fields.Many2many('account.invoice', 'account_invoice_payment_rel', 'payment_id', 'invoice_id', string="Invoices", copy=False, readonly=True)
|
|
has_invoices = fields.Boolean(compute="_get_has_invoices", help="Technical field used for usability purposes")
|
|
payment_difference = fields.Monetary(compute='_compute_payment_difference', readonly=True)
|
|
payment_difference_handling = fields.Selection([('open', 'Keep open'), ('reconcile', 'Mark invoice as fully paid')], default='open', string="Payment Difference", copy=False)
|
|
writeoff_account_id = fields.Many2one('account.account', string="Difference Account", domain=[('deprecated', '=', False)], copy=False)
|
|
writeoff_label = fields.Char(
|
|
string='Journal Item Label',
|
|
help='Change label of the counterpart that will hold the payment difference',
|
|
default='Write-Off')
|
|
|
|
# FIXME: ondelete='restrict' not working (eg. cancel a bank statement reconciliation with a payment)
|
|
move_line_ids = fields.One2many('account.move.line', 'payment_id', readonly=True, copy=False, ondelete='restrict')
|
|
move_reconciled = fields.Boolean(compute="_get_move_reconciled", readonly=True)
|
|
|
|
def open_payment_matching_screen(self):
|
|
# Open reconciliation view for customers/suppliers
|
|
move_line_id = False
|
|
for move_line in self.move_line_ids:
|
|
if move_line.account_id.reconcile:
|
|
move_line_id = move_line.id
|
|
break;
|
|
action_context = {'company_ids': [self.company_id.id], 'partner_ids': [self.partner_id.commercial_partner_id.id]}
|
|
if self.partner_type == 'customer':
|
|
action_context.update({'mode': 'customers'})
|
|
elif self.partner_type == 'supplier':
|
|
action_context.update({'mode': 'suppliers'})
|
|
if move_line_id:
|
|
action_context.update({'move_line_id': move_line_id})
|
|
return {
|
|
'type': 'ir.actions.client',
|
|
'tag': 'manual_reconciliation_view',
|
|
'context': action_context,
|
|
}
|
|
|
|
def _compute_journal_domain_and_types(self):
|
|
journal_type = ['bank', 'cash']
|
|
domain = []
|
|
if self.currency_id.is_zero(self.amount):
|
|
# In case of payment with 0 amount, allow to select a journal of type 'general' like
|
|
# 'Miscellaneous Operations' and set this journal by default.
|
|
journal_type = ['general']
|
|
self.payment_difference_handling = 'reconcile'
|
|
else:
|
|
if self.payment_type == 'inbound':
|
|
domain.append(('at_least_one_inbound', '=', True))
|
|
else:
|
|
domain.append(('at_least_one_outbound', '=', True))
|
|
return {'domain': domain, 'journal_types': set(journal_type)}
|
|
|
|
@api.onchange('amount', 'currency_id')
|
|
def _onchange_amount(self):
|
|
jrnl_filters = self._compute_journal_domain_and_types()
|
|
journal_types = jrnl_filters['journal_types']
|
|
domain_on_types = [('type', 'in', list(journal_types))]
|
|
if self.journal_id.type not in journal_types:
|
|
self.journal_id = self.env['account.journal'].search(domain_on_types, limit=1)
|
|
return {'domain': {'journal_id': jrnl_filters['domain'] + domain_on_types}}
|
|
|
|
@api.one
|
|
@api.depends('invoice_ids', 'payment_type', 'partner_type', 'partner_id')
|
|
def _compute_destination_account_id(self):
|
|
if self.invoice_ids:
|
|
self.destination_account_id = self.invoice_ids[0].account_id.id
|
|
elif self.payment_type == 'transfer':
|
|
if not self.company_id.transfer_account_id.id:
|
|
raise UserError(_('Transfer account not defined on the company.'))
|
|
self.destination_account_id = self.company_id.transfer_account_id.id
|
|
elif self.partner_id:
|
|
if self.partner_type == 'customer':
|
|
self.destination_account_id = self.partner_id.property_account_receivable_id.id
|
|
else:
|
|
self.destination_account_id = self.partner_id.property_account_payable_id.id
|
|
|
|
@api.onchange('partner_type')
|
|
def _onchange_partner_type(self):
|
|
# Set partner_id domain
|
|
if self.partner_type:
|
|
return {'domain': {'partner_id': [(self.partner_type, '=', True)]}}
|
|
|
|
@api.onchange('payment_type')
|
|
def _onchange_payment_type(self):
|
|
if not self.invoice_ids:
|
|
# Set default partner type for the payment type
|
|
if self.payment_type == 'inbound':
|
|
self.partner_type = 'customer'
|
|
elif self.payment_type == 'outbound':
|
|
self.partner_type = 'supplier'
|
|
# Set payment method domain
|
|
res = self._onchange_journal()
|
|
if not res.get('domain', {}):
|
|
res['domain'] = {}
|
|
jrnl_filters = self._compute_journal_domain_and_types()
|
|
journal_types = jrnl_filters['journal_types']
|
|
journal_types.update(['bank', 'cash'])
|
|
res['domain']['journal_id'] = jrnl_filters['domain'] + [('type', 'in', list(journal_types))]
|
|
return res
|
|
|
|
@api.model
|
|
def default_get(self, fields):
|
|
rec = super(account_payment, self).default_get(fields)
|
|
invoice_defaults = self.resolve_2many_commands('invoice_ids', rec.get('invoice_ids'))
|
|
if invoice_defaults and len(invoice_defaults) == 1:
|
|
invoice = invoice_defaults[0]
|
|
rec['communication'] = invoice['reference'] or invoice['name'] or invoice['number']
|
|
rec['currency_id'] = invoice['currency_id'][0]
|
|
rec['payment_type'] = invoice['type'] in ('out_invoice', 'in_refund') and 'inbound' or 'outbound'
|
|
rec['partner_type'] = MAP_INVOICE_TYPE_PARTNER_TYPE[invoice['type']]
|
|
rec['partner_id'] = invoice['partner_id'][0]
|
|
rec['amount'] = invoice['residual']
|
|
return rec
|
|
|
|
@api.multi
|
|
def button_journal_entries(self):
|
|
return {
|
|
'name': _('Journal Items'),
|
|
'view_type': 'form',
|
|
'view_mode': 'tree,form',
|
|
'res_model': 'account.move.line',
|
|
'view_id': False,
|
|
'type': 'ir.actions.act_window',
|
|
'domain': [('payment_id', 'in', self.ids)],
|
|
}
|
|
|
|
@api.multi
|
|
def button_invoices(self):
|
|
return {
|
|
'name': _('Paid Invoices'),
|
|
'view_type': 'form',
|
|
'view_mode': 'tree,form',
|
|
'res_model': 'account.invoice',
|
|
'view_id': False,
|
|
'type': 'ir.actions.act_window',
|
|
'domain': [('id', 'in', [x.id for x in self.invoice_ids])],
|
|
}
|
|
|
|
@api.multi
|
|
def button_dummy(self):
|
|
return True
|
|
|
|
@api.multi
|
|
def unreconcile(self):
|
|
""" Set back the payments in 'posted' or 'sent' state, without deleting the journal entries.
|
|
Called when cancelling a bank statement line linked to a pre-registered payment.
|
|
"""
|
|
for payment in self:
|
|
if payment.payment_reference:
|
|
payment.write({'state': 'sent'})
|
|
else:
|
|
payment.write({'state': 'posted'})
|
|
|
|
@api.multi
|
|
def cancel(self):
|
|
for rec in self:
|
|
for move in rec.move_line_ids.mapped('move_id'):
|
|
if rec.invoice_ids:
|
|
move.line_ids.remove_move_reconcile()
|
|
move.button_cancel()
|
|
move.unlink()
|
|
rec.state = 'cancelled'
|
|
|
|
@api.multi
|
|
def unlink(self):
|
|
if any(bool(rec.move_line_ids) for rec in self):
|
|
raise UserError(_("You can not delete a payment that is already posted"))
|
|
if any(rec.move_name for rec in self):
|
|
raise UserError(_('It is not allowed to delete a payment that already created a journal entry since it would create a gap in the numbering. You should create the journal entry again and cancel it thanks to a regular revert.'))
|
|
return super(account_payment, self).unlink()
|
|
|
|
@api.multi
|
|
def post(self):
|
|
""" Create the journal items for the payment and update the payment's state to 'posted'.
|
|
A journal entry is created containing an item in the source liquidity account (selected journal's default_debit or default_credit)
|
|
and another in the destination reconciliable account (see _compute_destination_account_id).
|
|
If invoice_ids is not empty, there will be one reconciliable move line per invoice to reconcile with.
|
|
If the payment is a transfer, a second journal entry is created in the destination journal to receive money from the transfer account.
|
|
"""
|
|
for rec in self:
|
|
|
|
if rec.state != 'draft':
|
|
raise UserError(_("Only a draft payment can be posted."))
|
|
|
|
if any(inv.state != 'open' for inv in rec.invoice_ids):
|
|
raise ValidationError(_("The payment cannot be processed because the invoice is not open!"))
|
|
|
|
# Use the right sequence to set the name
|
|
if rec.payment_type == 'transfer':
|
|
sequence_code = 'account.payment.transfer'
|
|
else:
|
|
if rec.partner_type == 'customer':
|
|
if rec.payment_type == 'inbound':
|
|
sequence_code = 'account.payment.customer.invoice'
|
|
if rec.payment_type == 'outbound':
|
|
sequence_code = 'account.payment.customer.refund'
|
|
if rec.partner_type == 'supplier':
|
|
if rec.payment_type == 'inbound':
|
|
sequence_code = 'account.payment.supplier.refund'
|
|
if rec.payment_type == 'outbound':
|
|
sequence_code = 'account.payment.supplier.invoice'
|
|
rec.name = self.env['ir.sequence'].with_context(ir_sequence_date=rec.payment_date).next_by_code(sequence_code)
|
|
if not rec.name and rec.payment_type != 'transfer':
|
|
raise UserError(_("You have to define a sequence for %s in your company.") % (sequence_code,))
|
|
|
|
# Create the journal entry
|
|
amount = rec.amount * (rec.payment_type in ('outbound', 'transfer') and 1 or -1)
|
|
move = rec._create_payment_entry(amount)
|
|
|
|
# In case of a transfer, the first journal entry created debited the source liquidity account and credited
|
|
# the transfer account. Now we debit the transfer account and credit the destination liquidity account.
|
|
if rec.payment_type == 'transfer':
|
|
transfer_credit_aml = move.line_ids.filtered(lambda r: r.account_id == rec.company_id.transfer_account_id)
|
|
transfer_debit_aml = rec._create_transfer_entry(amount)
|
|
(transfer_credit_aml + transfer_debit_aml).reconcile()
|
|
|
|
rec.write({'state': 'posted', 'move_name': move.name})
|
|
|
|
@api.multi
|
|
def action_draft(self):
|
|
return self.write({'state': 'draft'})
|
|
|
|
def action_validate_invoice_payment(self):
|
|
""" Posts a payment used to pay an invoice. This function only posts the
|
|
payment by default but can be overridden to apply specific post or pre-processing.
|
|
It is called by the "validate" button of the popup window
|
|
triggered on invoice form by the "Register Payment" button.
|
|
"""
|
|
if any(len(record.invoice_ids) != 1 for record in self):
|
|
# For multiple invoices, there is account.register.payments wizard
|
|
raise UserError(_("This method should only be called to process a single invoice's payment."))
|
|
self.post();
|
|
|
|
def _create_payment_entry(self, amount):
|
|
""" Create a journal entry corresponding to a payment, if the payment references invoice(s) they are reconciled.
|
|
Return the journal entry.
|
|
"""
|
|
aml_obj = self.env['account.move.line'].with_context(check_move_validity=False)
|
|
invoice_currency = False
|
|
if self.invoice_ids and all([x.currency_id == self.invoice_ids[0].currency_id for x in self.invoice_ids]):
|
|
#if all the invoices selected share the same currency, record the paiement in that currency too
|
|
invoice_currency = self.invoice_ids[0].currency_id
|
|
debit, credit, amount_currency, currency_id = aml_obj.with_context(date=self.payment_date).compute_amount_fields(amount, self.currency_id, self.company_id.currency_id, invoice_currency)
|
|
|
|
move = self.env['account.move'].create(self._get_move_vals())
|
|
|
|
#Write line corresponding to invoice payment
|
|
counterpart_aml_dict = self._get_shared_move_line_vals(debit, credit, amount_currency, move.id, False)
|
|
counterpart_aml_dict.update(self._get_counterpart_move_line_vals(self.invoice_ids))
|
|
counterpart_aml_dict.update({'currency_id': currency_id})
|
|
counterpart_aml = aml_obj.create(counterpart_aml_dict)
|
|
|
|
#Reconcile with the invoices
|
|
if self.payment_difference_handling == 'reconcile' and self.payment_difference:
|
|
writeoff_line = self._get_shared_move_line_vals(0, 0, 0, move.id, False)
|
|
amount_currency_wo, currency_id = aml_obj.with_context(date=self.payment_date).compute_amount_fields(self.payment_difference, self.currency_id, self.company_id.currency_id, invoice_currency)[2:]
|
|
# the writeoff debit and credit must be computed from the invoice residual in company currency
|
|
# minus the payment amount in company currency, and not from the payment difference in the payment currency
|
|
# to avoid loss of precision during the currency rate computations. See revision 20935462a0cabeb45480ce70114ff2f4e91eaf79 for a detailed example.
|
|
total_residual_company_signed = sum(invoice.residual_company_signed for invoice in self.invoice_ids)
|
|
total_payment_company_signed = self.currency_id.with_context(date=self.payment_date).compute(self.amount, self.company_id.currency_id)
|
|
if self.invoice_ids[0].type in ['in_invoice', 'out_refund']:
|
|
amount_wo = total_payment_company_signed - total_residual_company_signed
|
|
else:
|
|
amount_wo = total_residual_company_signed - total_payment_company_signed
|
|
# Align the sign of the secondary currency writeoff amount with the sign of the writeoff
|
|
# amount in the company currency
|
|
if amount_wo > 0:
|
|
debit_wo = amount_wo
|
|
credit_wo = 0.0
|
|
amount_currency_wo = abs(amount_currency_wo)
|
|
else:
|
|
debit_wo = 0.0
|
|
credit_wo = -amount_wo
|
|
amount_currency_wo = -abs(amount_currency_wo)
|
|
writeoff_line['name'] = self.writeoff_label
|
|
writeoff_line['account_id'] = self.writeoff_account_id.id
|
|
writeoff_line['debit'] = debit_wo
|
|
writeoff_line['credit'] = credit_wo
|
|
writeoff_line['amount_currency'] = amount_currency_wo
|
|
writeoff_line['currency_id'] = currency_id
|
|
writeoff_line = aml_obj.create(writeoff_line)
|
|
if counterpart_aml['debit'] or writeoff_line['credit']:
|
|
counterpart_aml['debit'] += credit_wo - debit_wo
|
|
if counterpart_aml['credit'] or writeoff_line['debit']:
|
|
counterpart_aml['credit'] += debit_wo - credit_wo
|
|
counterpart_aml['amount_currency'] -= amount_currency_wo
|
|
|
|
#Write counterpart lines
|
|
if not self.currency_id.is_zero(self.amount):
|
|
if not self.currency_id != self.company_id.currency_id:
|
|
amount_currency = 0
|
|
liquidity_aml_dict = self._get_shared_move_line_vals(credit, debit, -amount_currency, move.id, False)
|
|
liquidity_aml_dict.update(self._get_liquidity_move_line_vals(-amount))
|
|
aml_obj.create(liquidity_aml_dict)
|
|
|
|
#validate the payment
|
|
move.post()
|
|
|
|
#reconcile the invoice receivable/payable line(s) with the payment
|
|
self.invoice_ids.register_payment(counterpart_aml)
|
|
|
|
return move
|
|
|
|
def _create_transfer_entry(self, amount):
|
|
""" Create the journal entry corresponding to the 'incoming money' part of an internal transfer, return the reconciliable move line
|
|
"""
|
|
aml_obj = self.env['account.move.line'].with_context(check_move_validity=False)
|
|
debit, credit, amount_currency, dummy = aml_obj.with_context(date=self.payment_date).compute_amount_fields(amount, self.currency_id, self.company_id.currency_id)
|
|
amount_currency = self.destination_journal_id.currency_id and self.currency_id.with_context(date=self.payment_date).compute(amount, self.destination_journal_id.currency_id) or 0
|
|
|
|
dst_move = self.env['account.move'].create(self._get_move_vals(self.destination_journal_id))
|
|
|
|
dst_liquidity_aml_dict = self._get_shared_move_line_vals(debit, credit, amount_currency, dst_move.id)
|
|
dst_liquidity_aml_dict.update({
|
|
'name': _('Transfer from %s') % self.journal_id.name,
|
|
'account_id': self.destination_journal_id.default_credit_account_id.id,
|
|
'currency_id': self.destination_journal_id.currency_id.id,
|
|
'journal_id': self.destination_journal_id.id})
|
|
aml_obj.create(dst_liquidity_aml_dict)
|
|
|
|
transfer_debit_aml_dict = self._get_shared_move_line_vals(credit, debit, 0, dst_move.id)
|
|
transfer_debit_aml_dict.update({
|
|
'name': self.name,
|
|
'account_id': self.company_id.transfer_account_id.id,
|
|
'journal_id': self.destination_journal_id.id})
|
|
if self.currency_id != self.company_id.currency_id:
|
|
transfer_debit_aml_dict.update({
|
|
'currency_id': self.currency_id.id,
|
|
'amount_currency': -self.amount,
|
|
})
|
|
transfer_debit_aml = aml_obj.create(transfer_debit_aml_dict)
|
|
dst_move.post()
|
|
return transfer_debit_aml
|
|
|
|
def _get_move_vals(self, journal=None):
|
|
""" Return dict to create the payment move
|
|
"""
|
|
journal = journal or self.journal_id
|
|
if not journal.sequence_id:
|
|
raise UserError(_('Configuration Error !'), _('The journal %s does not have a sequence, please specify one.') % journal.name)
|
|
if not journal.sequence_id.active:
|
|
raise UserError(_('Configuration Error !'), _('The sequence of journal %s is deactivated.') % journal.name)
|
|
name = self.move_name or journal.with_context(ir_sequence_date=self.payment_date).sequence_id.next_by_id()
|
|
return {
|
|
'name': name,
|
|
'date': self.payment_date,
|
|
'ref': self.communication or '',
|
|
'company_id': self.company_id.id,
|
|
'journal_id': journal.id,
|
|
}
|
|
|
|
def _get_shared_move_line_vals(self, debit, credit, amount_currency, move_id, invoice_id=False):
|
|
""" Returns values common to both move lines (except for debit, credit and amount_currency which are reversed)
|
|
"""
|
|
return {
|
|
'partner_id': self.payment_type in ('inbound', 'outbound') and self.env['res.partner']._find_accounting_partner(self.partner_id).id or False,
|
|
'invoice_id': invoice_id and invoice_id.id or False,
|
|
'move_id': move_id,
|
|
'debit': debit,
|
|
'credit': credit,
|
|
'amount_currency': amount_currency or False,
|
|
'payment_id': self.id,
|
|
}
|
|
|
|
def _get_counterpart_move_line_vals(self, invoice=False):
|
|
if self.payment_type == 'transfer':
|
|
name = self.name
|
|
else:
|
|
name = ''
|
|
if self.partner_type == 'customer':
|
|
if self.payment_type == 'inbound':
|
|
name += _("Customer Payment")
|
|
elif self.payment_type == 'outbound':
|
|
name += _("Customer Credit Note")
|
|
elif self.partner_type == 'supplier':
|
|
if self.payment_type == 'inbound':
|
|
name += _("Vendor Credit Note")
|
|
elif self.payment_type == 'outbound':
|
|
name += _("Vendor Payment")
|
|
if invoice:
|
|
name += ': '
|
|
for inv in invoice:
|
|
if inv.move_id:
|
|
name += inv.number + ', '
|
|
name = name[:len(name)-2]
|
|
return {
|
|
'name': name,
|
|
'account_id': self.destination_account_id.id,
|
|
'journal_id': self.journal_id.id,
|
|
'currency_id': self.currency_id != self.company_id.currency_id and self.currency_id.id or False,
|
|
}
|
|
|
|
def _get_liquidity_move_line_vals(self, amount):
|
|
name = self.name
|
|
if self.payment_type == 'transfer':
|
|
name = _('Transfer to %s') % self.destination_journal_id.name
|
|
vals = {
|
|
'name': name,
|
|
'account_id': self.payment_type in ('outbound','transfer') and self.journal_id.default_debit_account_id.id or self.journal_id.default_credit_account_id.id,
|
|
'journal_id': self.journal_id.id,
|
|
'currency_id': self.currency_id != self.company_id.currency_id and self.currency_id.id or False,
|
|
}
|
|
|
|
# If the journal has a currency specified, the journal item need to be expressed in this currency
|
|
if self.journal_id.currency_id and self.currency_id != self.journal_id.currency_id:
|
|
amount = self.currency_id.with_context(date=self.payment_date).compute(amount, self.journal_id.currency_id)
|
|
debit, credit, amount_currency, dummy = self.env['account.move.line'].with_context(date=self.payment_date).compute_amount_fields(amount, self.journal_id.currency_id, self.company_id.currency_id)
|
|
vals.update({
|
|
'amount_currency': amount_currency,
|
|
'currency_id': self.journal_id.currency_id.id,
|
|
})
|
|
|
|
return vals
|