# -*- 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._check_make_stub_line(inv) for inv in invoices] else: stub_lines = [{'header': True, 'name': "Bills"}] stub_lines += [self._check_make_stub_line(inv) for inv in debits] stub_lines += [{'header': True, 'name': "Refunds"}] stub_lines += [self._check_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, }