217 lines
11 KiB
Python
217 lines
11 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from odoo import models, fields, api, _
|
|
from odoo.exceptions import UserError, ValidationError
|
|
from odoo.tools.misc import formatLang, format_date
|
|
|
|
INV_LINES_PER_STUB = 9
|
|
|
|
class AccountRegisterPayments(models.TransientModel):
|
|
_inherit = "account.register.payments"
|
|
|
|
check_amount_in_words = fields.Char(string="Amount in Words")
|
|
check_manual_sequencing = fields.Boolean(related='journal_id.check_manual_sequencing', readonly=1)
|
|
# Note: a check_number == 0 means that it will be attributed when the check is printed
|
|
check_number = fields.Integer(string="Check Number", readonly=True, copy=False, default=0,
|
|
help="Number of the check corresponding to this payment. If your pre-printed check are not already numbered, "
|
|
"you can manage the numbering in the journal configuration page.")
|
|
|
|
@api.onchange('journal_id')
|
|
def _onchange_journal_id(self):
|
|
if hasattr(super(AccountRegisterPayments, self), '_onchange_journal_id'):
|
|
super(AccountRegisterPayments, self)._onchange_journal_id()
|
|
if self.journal_id.check_manual_sequencing:
|
|
self.check_number = self.journal_id.check_sequence_id.number_next_actual
|
|
|
|
@api.onchange('amount')
|
|
def _onchange_amount(self):
|
|
if hasattr(super(AccountRegisterPayments, self), '_onchange_amount'):
|
|
super(AccountRegisterPayments, self)._onchange_amount()
|
|
self.check_amount_in_words = self.currency_id.amount_to_text(self.amount)
|
|
|
|
def _prepare_payment_vals(self, invoices):
|
|
res = super(AccountRegisterPayments, self)._prepare_payment_vals(invoices)
|
|
if self.payment_method_id == self.env.ref('account_check_printing.account_payment_method_check'):
|
|
res.update({
|
|
'check_amount_in_words': self.currency_id.amount_to_text(res['amount']) if self.multi else self.check_amount_in_words,
|
|
})
|
|
return res
|
|
|
|
|
|
class AccountPayment(models.Model):
|
|
_inherit = "account.payment"
|
|
|
|
check_amount_in_words = fields.Char(string="Amount in Words")
|
|
check_manual_sequencing = fields.Boolean(related='journal_id.check_manual_sequencing', readonly=1)
|
|
check_number = fields.Integer(string="Check Number", readonly=True, copy=False,
|
|
help="The selected journal is configured to print check numbers. If your pre-printed check paper already has numbers "
|
|
"or if the current numbering is wrong, you can change it in the journal configuration page.")
|
|
|
|
@api.onchange('amount','currency_id')
|
|
def _onchange_amount(self):
|
|
res = super(AccountPayment, self)._onchange_amount()
|
|
self.check_amount_in_words = self.currency_id.amount_to_text(self.amount)
|
|
return res
|
|
|
|
def _check_communication(self, payment_method_id, communication):
|
|
super(AccountPayment, self)._check_communication(payment_method_id, communication)
|
|
if payment_method_id == self.env.ref('account_check_printing.account_payment_method_check').id:
|
|
if not communication:
|
|
return
|
|
if len(communication) > 60:
|
|
raise ValidationError(_("A check memo cannot exceed 60 characters."))
|
|
|
|
@api.multi
|
|
def post(self):
|
|
res = super(AccountPayment, self).post()
|
|
payment_method_check = self.env.ref('account_check_printing.account_payment_method_check')
|
|
for payment in self.filtered(lambda p: p.payment_method_id == payment_method_check and p.check_manual_sequencing):
|
|
sequence = payment.journal_id.check_sequence_id
|
|
payment.check_number = sequence.next_by_id()
|
|
return res
|
|
|
|
@api.multi
|
|
def print_checks(self):
|
|
""" Check that the recordset is valid, set the payments state to sent and call print_checks() """
|
|
# Since this method can be called via a client_action_multi, we need to make sure the received records are what we expect
|
|
self = self.filtered(lambda r: r.payment_method_id.code == 'check_printing' and r.state != 'reconciled')
|
|
|
|
if len(self) == 0:
|
|
raise UserError(_("Payments to print as a checks must have 'Check' selected as payment method and "
|
|
"not have already been reconciled"))
|
|
if any(payment.journal_id != self[0].journal_id for payment in self):
|
|
raise UserError(_("In order to print multiple checks at once, they must belong to the same bank journal."))
|
|
|
|
if not self[0].journal_id.check_manual_sequencing:
|
|
# The wizard asks for the number printed on the first pre-printed check
|
|
# so payments are attributed the number of the check the'll be printed on.
|
|
last_printed_check = self.search([
|
|
('journal_id', '=', self[0].journal_id.id),
|
|
('check_number', '!=', 0)], order="check_number desc", limit=1)
|
|
next_check_number = last_printed_check and last_printed_check.check_number + 1 or 1
|
|
return {
|
|
'name': _('Print Pre-numbered Checks'),
|
|
'type': 'ir.actions.act_window',
|
|
'res_model': 'print.prenumbered.checks',
|
|
'view_type': 'form',
|
|
'view_mode': 'form',
|
|
'target': 'new',
|
|
'context': {
|
|
'payment_ids': self.ids,
|
|
'default_next_check_number': next_check_number,
|
|
}
|
|
}
|
|
else:
|
|
self.filtered(lambda r: r.state == 'draft').post()
|
|
return self.do_print_checks()
|
|
|
|
@api.multi
|
|
def unmark_sent(self):
|
|
self.write({'state': 'posted'})
|
|
|
|
@api.multi
|
|
def do_print_checks(self):
|
|
""" This method is a hook for l10n_xx_check_printing modules to implement actual check printing capabilities """
|
|
raise UserError(_("You have to choose a check layout. For this, go in Apps, search for 'Checks layout' and install one."))
|
|
|
|
#######################
|
|
#CHECK PRINTING METHODS
|
|
#######################
|
|
def _check_fill_line(self, amount_str):
|
|
return amount_str and (amount_str + ' ').ljust(200, '*') or ''
|
|
|
|
def _check_build_page_info(self, i, p):
|
|
multi_stub = self.company_id.account_check_printing_multi_stub
|
|
return {
|
|
'sequence_number': self.check_number if (self.journal_id.check_manual_sequencing and self.check_number != 0) else False,
|
|
'payment_date': format_date(self.env, self.payment_date),
|
|
'partner_id': self.partner_id,
|
|
'partner_name': self.partner_id.name,
|
|
'currency': self.currency_id,
|
|
'state': self.state,
|
|
'amount': formatLang(self.env, self.amount, currency_obj=self.currency_id) if i == 0 else 'VOID',
|
|
'amount_in_word': self._check_fill_line(self.check_amount_in_words) if i == 0 else 'VOID',
|
|
'memo': self.communication,
|
|
'stub_cropped': not multi_stub and len(self.invoice_ids) > INV_LINES_PER_STUB,
|
|
# If the payment does not reference an invoice, there is no stub line to display
|
|
'stub_lines': p,
|
|
}
|
|
|
|
def _check_get_pages(self):
|
|
""" Returns the data structure used by the template : a list of dicts containing what to print on pages.
|
|
"""
|
|
stub_pages = self._check_make_stub_pages() or [False]
|
|
pages = []
|
|
for i, p in enumerate(stub_pages):
|
|
pages.append(self._check_build_page_info(i, p))
|
|
return pages
|
|
|
|
def _check_make_stub_pages(self):
|
|
""" The stub is the summary of paid invoices. It may spill on several pages, in which case only the check on
|
|
first page is valid. This function returns a list of stub lines per page.
|
|
"""
|
|
if len(self.invoice_ids) == 0:
|
|
return None
|
|
|
|
multi_stub = self.company_id.account_check_printing_multi_stub
|
|
|
|
invoices = self.invoice_ids.sorted(key=lambda r: r.date_due)
|
|
debits = invoices.filtered(lambda r: r.type == 'in_invoice')
|
|
credits = invoices.filtered(lambda r: r.type == 'in_refund')
|
|
|
|
# Prepare the stub lines
|
|
if not credits:
|
|
stub_lines = [self.make_stub_line(inv) for inv in invoices]
|
|
else:
|
|
stub_lines = [{'header': True, 'name': "Bills"}]
|
|
stub_lines += [self.make_stub_line(inv) for inv in debits]
|
|
stub_lines += [{'header': True, 'name': "Refunds"}]
|
|
stub_lines += [self.make_stub_line(inv) for inv in credits]
|
|
|
|
# Crop the stub lines or split them on multiple pages
|
|
if not multi_stub:
|
|
# If we need to crop the stub, leave place for an ellipsis line
|
|
num_stub_lines = len(stub_lines) > INV_LINES_PER_STUB and INV_LINES_PER_STUB - 1 or INV_LINES_PER_STUB
|
|
stub_pages = [stub_lines[:num_stub_lines]]
|
|
else:
|
|
stub_pages = []
|
|
i = 0
|
|
while i < len(stub_lines):
|
|
# Make sure we don't start the credit section at the end of a page
|
|
if len(stub_lines) >= i + INV_LINES_PER_STUB and stub_lines[i + INV_LINES_PER_STUB - 1].get('header'):
|
|
num_stub_lines = INV_LINES_PER_STUB - 1 or INV_LINES_PER_STUB
|
|
else:
|
|
num_stub_lines = INV_LINES_PER_STUB
|
|
stub_pages.append(stub_lines[i:i + num_stub_lines])
|
|
i += num_stub_lines
|
|
|
|
return stub_pages
|
|
|
|
def _check_make_stub_line(self, invoice):
|
|
""" Return the dict used to display an invoice/refund in the stub
|
|
"""
|
|
# Find the account.partial.reconcile which are common to the invoice and the payment
|
|
if invoice.type in ['in_invoice', 'out_refund']:
|
|
invoice_sign = 1
|
|
invoice_payment_reconcile = invoice.move_id.line_ids.mapped('matched_debit_ids').filtered(lambda r: r.debit_move_id in self.move_line_ids)
|
|
else:
|
|
invoice_sign = -1
|
|
invoice_payment_reconcile = invoice.move_id.line_ids.mapped('matched_credit_ids').filtered(lambda r: r.credit_move_id in self.move_line_ids)
|
|
|
|
if self.currency_id != self.journal_id.company_id.currency_id:
|
|
amount_paid = abs(sum(invoice_payment_reconcile.mapped('amount_currency')))
|
|
else:
|
|
amount_paid = abs(sum(invoice_payment_reconcile.mapped('amount')))
|
|
|
|
amount_residual = invoice_sign * invoice.residual
|
|
|
|
return {
|
|
'due_date': format_date(self.env, invoice.date_due),
|
|
'number': invoice.reference and invoice.number + ' - ' + invoice.reference or invoice.number,
|
|
'amount_total': formatLang(self.env, invoice_sign * invoice.amount_total, currency_obj=invoice.currency_id),
|
|
'amount_residual': formatLang(self.env, amount_residual, currency_obj=invoice.currency_id) if amount_residual * 10**4 != 0 else '-',
|
|
'amount_paid': formatLang(self.env, invoice_sign * amount_paid, currency_obj=invoice.currency_id),
|
|
'currency': invoice.currency_id,
|
|
}
|