[ADD] account_payment_disperse: mig module v12 to v15

H4805

account_payment_disperse/__init__.py

@@ -0,0 +1,2 @@
+from . import models
+from . import wizard

account_payment_disperse/__manifest__.py

@@ -0,0 +1,19 @@
+{
+    'name': 'Payment Disperse',
+    'version': '15.0.1.0.0',
+    'author': 'Hibou Corp. <hello@hibou.io>',
+    'category': 'Accounting',
+    'summary': 'Pay multiple invoices with one Payment',
+    'description': """
+Pay multiple invoices with one Payment, and manually disperse the amount per invoice. 
+""",
+    'website': 'https://hibou.io/',
+    'depends': [
+        'account',
+    ],
+    'data': [
+        'wizard/register_payment_wizard_views.xml',
+    ],
+    'installable': True,
+    'auto_install': False,
+}

account_payment_disperse/models/__init__.py

@@ -0,0 +1 @@
+from . import account

account_payment_disperse/models/account.py

@@ -0,0 +1,69 @@
+from odoo import api, fields, models
+
+
+class AccountPayment(models.Model):
+    _inherit = 'account.payment'
+
+    # def _create_payment_entry(self, amount):
+    #     wizard_id = self.env.context.get('payment_wizard_id')
+    #     if wizard_id:
+    #         # wizard = self.env['account.register.payments'].browse(wizard_id)
+    #         wizard = self.env['account.payment.register'].browse(wizard_id)
+    #         assert wizard
+    #         if wizard.is_manual_disperse:
+    #             payment_amount = sum(wizard.invoice_line_ids.filtered(lambda p: p.partner_id == self.partner_id).mapped('amount'))
+    #             if amount < 0:
+    #                 payment_amount = -payment_amount
+    #             return self._create_payment_entry_manual_disperse(payment_amount, wizard)
+
+    #     return super(AccountPayment, self)._create_payment_entry(amount)
+
+    def _create_payment_entry_manual_disperse(self, amount, wizard):
+        # When registering payments for multiple partners at the same time, without setting
+        # the amount again, then the payment will not match the accounting.
+        self.amount = abs(amount)
+        if hasattr(self, 'check_amount_in_words'):
+            self.check_amount_in_words = self.currency_id.amount_to_text(self.amount)
+
+        aml_obj = self.env['account.move.line'].with_context(check_move_validity=False)
+        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)
+
+        move = self.env['account.move'].create(self._get_move_vals())
+
+        inv_lines = []
+        for partial_invoice in wizard.invoice_line_ids.filtered(lambda p: p.amount and p.partner_id == self.partner_id):
+            # Note that for customer payments, the amount will be reversed.
+            inv_amount = partial_invoice.amount if amount > 0 else -partial_invoice.amount
+            i_debit, i_credit, i_amount_currency, i_currency_id = aml_obj.with_context(date=self.payment_date)._compute_amount_fields(inv_amount, self.currency_id, self.company_id.currency_id)
+            counterpart_aml_dict = self._get_shared_move_line_vals(i_debit, i_credit, i_amount_currency, move.id, False)
+            counterpart_aml_dict.update(self._get_counterpart_move_line_vals(partial_invoice.invoice_id))
+            counterpart_aml_dict.update({'currency_id': currency_id})
+            counterpart_aml = aml_obj.create(counterpart_aml_dict)
+            counterpart_aml |= partial_invoice.invoice_id.move_id.line_ids.filtered(
+                lambda r: not r.reconciled and r.account_id.internal_type in ('payable', 'receivable'))
+            inv_lines.append((counterpart_aml, partial_invoice.writeoff_acc_id))
+
+        # Useful for debugging
+        # for aml_ids, writeoff_acc_id in inv_lines:
+        #     _logger.warn('pair:' + (' writeoff: ' + str(writeoff_acc_id)) if writeoff_acc_id else '')
+        #     for l in aml_ids:
+        #         _logger.warn('    ' + str(l) + ' debit: ' + str(l.debit) + ' credit: ' + str(l.credit))
+
+        # 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))
+            other = aml_obj.create(liquidity_aml_dict)
+            #_logger.warn('other line -- debit: ' + str(other.debit) + ' credit: ' + str(other.credit))
+
+        # validate the payment
+        if not self.journal_id.post_at_bank_rec:
+            move.post()
+
+        # reconcile the invoice receivable/payable line(s) with the payment
+        for aml_ids, writeoff_acc_id in inv_lines:
+            aml_ids.reconcile(writeoff_acc_id, wizard.writeoff_journal_id)
+
+        return move

account_payment_disperse/security/ir.model.access.csv

@@ -0,0 +1,2 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_account_payment_disperse_account_payment_disperse,account_payment_disperse.account_payment_disperse,model_account_payment_disperse_account_payment_disperse,base.group_user,1,1,1,1

account_payment_disperse/tests/__init__.py

@@ -0,0 +1 @@
+from . import test_payment_multi

account_payment_disperse/tests/test_payment_multi.py

@@ -0,0 +1,157 @@
+from odoo.addons.account.tests.test_payment import TestPayment
+from odoo.exceptions import ValidationError
+import time
+
+
+class PaymentMultiTest(TestPayment):
+    
+    def test_multiple_payments_partial(self):
+        """ Create test to pay several vendor bills/invoices at once """
+        # One payment for inv_1 and inv_2 (same partner)
+        inv_1 = self.create_invoice(amount=100, currency_id=self.currency_eur_id, partner=self.partner_agrolait.id)
+        inv_2 = self.create_invoice(amount=500, currency_id=self.currency_eur_id, partner=self.partner_agrolait.id)
+
+        ids = [inv_1.id, inv_2.id]
+        register_payments = self.register_payments_model.with_context(active_ids=ids).create({
+            'payment_date': time.strftime('%Y') + '-07-15',
+            'journal_id': self.bank_journal_euro.id,
+            'payment_method_id': self.payment_method_manual_in.id,
+        })
+        register_payments.amount = 399.0
+        register_payments.is_manual_disperse = True
+
+        with self.assertRaises(ValidationError):
+            register_payments.create_payments()
+
+        for line in register_payments.invoice_line_ids:
+            if line.invoice_id == inv_1:
+                line.amount = 99.0
+            if line.invoice_id == inv_2:
+                line.amount = 300.0
+
+        register_payments.create_payments()
+
+        payment_ids = self.payment_model.search([('invoice_ids', 'in', ids)], order="id desc")
+        self.assertEqual(len(payment_ids), 1, 'Need only one payment.')
+        self.assertEqual(payment_ids.amount, 399.0)
+
+        self.assertEqual(inv_1.residual_signed, 1.0)
+        self.assertEqual(inv_2.residual_signed, 200.0)
+
+        register_payments = self.register_payments_model.with_context(active_ids=ids).create({
+            'payment_date': time.strftime('%Y') + '-07-15',
+            'journal_id': self.bank_journal_euro.id,
+            'payment_method_id': self.payment_method_manual_in.id,
+        })
+        register_payments.amount = 200.0
+        register_payments.is_manual_disperse = True
+
+        for line in register_payments.invoice_line_ids:
+            if line.invoice_id == inv_2:
+                line.amount = 200.0
+
+        register_payments.create_payments()
+        self.assertEqual(inv_1.residual_signed, 1.0)
+        self.assertEqual(inv_2.residual_signed, 0.0)
+
+    def test_multiple_payments_write_off(self):
+        inv_1 = self.create_invoice(amount=100, currency_id=self.currency_eur_id, partner=self.partner_agrolait.id)
+        inv_2 = self.create_invoice(amount=500, currency_id=self.currency_eur_id, partner=self.partner_agrolait.id)
+
+        ids = [inv_1.id, inv_2.id]
+        register_payments = self.register_payments_model.with_context(active_ids=ids).create({
+            'payment_date': time.strftime('%Y') + '-07-15',
+            'journal_id': self.bank_journal_euro.id,
+            'payment_method_id': self.payment_method_manual_in.id,
+        })
+        register_payments.amount = 400.0
+        register_payments.is_manual_disperse = True
+        register_payments.writeoff_journal_id = inv_1.journal_id
+
+        with self.assertRaises(ValidationError):
+            register_payments.create_payments()
+
+        for line in register_payments.invoice_line_ids:
+            if line.invoice_id == inv_1:
+                line.amount = 100.0
+            if line.invoice_id == inv_2:
+                line.amount = 300.0
+                line.writeoff_acc_id = self.account_revenue
+
+        register_payments.create_payments()
+
+        payment_ids = self.payment_model.search([('invoice_ids', 'in', ids)], order="id desc")
+        self.assertEqual(len(payment_ids), 1, 'Need only one payment.')
+        self.assertEqual(payment_ids.amount, 400.0)
+
+        self.assertEqual(inv_1.residual_signed, 0.0)
+        self.assertEqual(inv_2.residual_signed, 0.0)
+
+    def test_multiple_payments_partial_multi(self):
+        """ Create test to pay several vendor bills/invoices at once """
+        # One payment for inv_1 and inv_2 (same partner)
+        inv_1 = self.create_invoice(amount=100, currency_id=self.currency_eur_id, partner=self.partner_agrolait.id)
+        inv_2 = self.create_invoice(amount=500, currency_id=self.currency_eur_id, partner=self.partner_china_exp.id)
+
+        ids = [inv_1.id, inv_2.id]
+        register_payments = self.register_payments_model.with_context(active_ids=ids).create({
+            'payment_date': time.strftime('%Y') + '-07-15',
+            'journal_id': self.bank_journal_euro.id,
+            'payment_method_id': self.payment_method_manual_in.id,
+        })
+        register_payments.amount = 400.0
+        register_payments.is_manual_disperse = True
+
+        for line in register_payments.invoice_line_ids:
+            if line.invoice_id == inv_1:
+                line.amount = 100.0
+            if line.invoice_id == inv_2:
+                line.amount = 300.0
+
+        register_payments.create_payments()
+
+        payment_ids = self.payment_model.search([('invoice_ids', 'in', ids)], order="id desc")
+        self.assertEqual(len(payment_ids), 2, 'Need two payments.')
+        # Useful for logging amounts of payments and their accounting
+        # for pay in payment_ids:
+        #     _logger.warn(str(pay) + ' amount: ' + str(pay.amount))
+        #     for line in pay.move_line_ids:
+        #         _logger.warn('  ' +
+        #                      str(line) + ' name: ' + str(line.name) + ' :: credit: ' + str(line.credit) + ' debit: ' +
+        #                      str(line.debit))
+        self.assertEqual(sum(payment_ids.mapped('amount')), 400.0)
+
+        self.assertEqual(inv_1.residual_signed, 0.0)
+        self.assertEqual(inv_2.residual_signed, 200.0)
+
+    def test_vendor_multiple_payments_write_off(self):
+        inv_1 = self.create_invoice(amount=100, type='in_invoice', currency_id=self.currency_eur_id, partner=self.partner_agrolait.id)
+        inv_2 = self.create_invoice(amount=500, type='in_invoice', currency_id=self.currency_eur_id, partner=self.partner_agrolait.id)
+        ids = [inv_1.id, inv_2.id]
+        register_payments = self.register_payments_model.with_context(active_ids=ids).create({
+            'payment_date': time.strftime('%Y') + '-07-15',
+            'journal_id': self.bank_journal_euro.id,
+            'payment_method_id': self.payment_method_manual_out.id,
+        })
+        register_payments.amount = 400.0
+        register_payments.is_manual_disperse = True
+        register_payments.writeoff_journal_id = inv_1.journal_id
+
+        with self.assertRaises(ValidationError):
+            register_payments.create_payments()
+
+        for line in register_payments.invoice_line_ids:
+            if line.invoice_id == inv_1:
+                line.amount = 100.0
+            if line.invoice_id == inv_2:
+                line.amount = 300.0
+                line.writeoff_acc_id = self.account_revenue
+
+        register_payments.create_payments()
+
+        payment_ids = self.payment_model.search([('invoice_ids', 'in', ids)], order="id desc")
+        self.assertEqual(len(payment_ids), 1, 'Need only one payment.')
+        self.assertEqual(payment_ids.amount, 400.0)
+
+        self.assertEqual(inv_1.residual_signed, 0.0)
+        self.assertEqual(inv_2.residual_signed, 0.0)

account_payment_disperse/wizard/__init__.py

@@ -0,0 +1 @@
+from . import register_payment_wizard

account_payment_disperse/wizard/register_payment_wizard.py

@@ -0,0 +1,98 @@
+# from odoo import api, fields, models
+# from odoo.exceptions import ValidationError
+
+
+# class AccountRegisterPayments(models.TransientModel):
+#     # _inherit = 'account.register.payments'
+#     _inherit = 'account.payment.register'
+
+#     is_manual_disperse = fields.Boolean(string='Disperse Manually')
+#     invoice_line_ids = fields.One2many('account.register.payments.invoice.line', 'wizard_id', string='Invoices')
+#     writeoff_journal_id = fields.Many2one('account.journal', string='Write-off Journal')
+#     due_date_cutoff = fields.Date(string='Due Date Cutoff', default=fields.Date.today)
+
+#     @api.model
+#     def default_get(self, fields):
+#         rec = super(AccountRegisterPayments, self).default_get(fields)
+#         if 'invoice_ids' in rec:
+#             invoice_ids = rec['invoice_ids'][0][2]
+#             rec['invoice_line_ids'] = [(0, 0, {'invoice_id': i, 'amount': 0.0}) for i in invoice_ids]
+#         return rec
+
+#     # @api.multi
+#     def create_payments(self):
+#         for payment in self.filtered(lambda p: p.is_manual_disperse):
+#             line_amount = sum(payment.invoice_line_ids.mapped('amount'))
+#             if abs(line_amount - payment.amount) >= 0.01:
+#                 raise ValidationError(_('Cannot pay for %0.2f worth of invoices with %0.2f total.' %
+#                                       (line_amount, payment.amount)))
+#             if not payment.writeoff_journal_id and payment.invoice_line_ids.filtered(lambda l: l.writeoff_acc_id):
+#                 raise ValidationError(_('Cannot write off without a write off journal.'))
+#         new_self = self.with_context(payment_wizard_id=self.id)
+#         return super(AccountRegisterPayments, new_self).create_payments()
+
+#     # @api.multi
+#     def action_fill_residual(self):
+#         for payment in self:
+#             for line in payment.invoice_line_ids:
+#                 line.amount = line.residual
+#             action = self.env.ref('account.action_account_payment_from_invoices').read()[0]
+#             action['res_id'] = payment.id
+#             return action
+
+#     # @api.multi
+#     def action_fill_residual_due(self):
+#         for payment in self:
+#             for line in payment.invoice_line_ids:
+#                 line.amount = line.residual_due
+#             action = self.env.ref('account.action_account_payment_from_invoices').read()[0]
+#             action['res_id'] = payment.id
+#             return action
+
+
+# class AccountRegisterPaymentsInvoiceLine(models.TransientModel):
+#     _name = 'account.register.payments.invoice.line'
+
+#     wizard_id = fields.Many2one('account.register.payments')
+#     invoice_id = fields.Many2one('account.invoice', string='Invoice', required=True)
+#     partner_id = fields.Many2one('res.partner', string='Partner', compute='_compute_balances', compute_sudo=True)
+#     residual = fields.Float(string='Remaining', compute='_compute_balances', compute_sudo=True)
+#     residual_due = fields.Float(string='Due', compute='_compute_balances', compute_sudo=True)
+#     difference = fields.Float(string='Difference', default=0.0)
+#     amount = fields.Float(string='Amount')
+#     writeoff_acc_id = fields.Many2one('account.account', string='Write-off Account')
+
+#     @api.depends('invoice_id', 'wizard_id.due_date_cutoff', 'invoice_id.partner_id')
+#     def _compute_balances(self):
+#         for line in self:
+#             # Bug in the ORM 12.0?  The invoice is set, but there is no residual
+#             # on anything other than the first invoice/line processed.
+#             invoice = line.invoice_id.browse(line.invoice_id.id)
+#             residual = invoice.residual
+
+#             cutoff_date = line.wizard_id.due_date_cutoff
+#             total_amount = 0.0
+#             total_reconciled = 0.0
+#             for move_line in invoice.move_id.line_ids.filtered(lambda r: (
+#                     not r.reconciled
+#                     and r.account_id.internal_type in ('payable', 'receivable')
+#                     and r.date_maturity <= cutoff_date
+#                     )):
+#                 amount = abs(move_line.debit - move_line.credit)
+#                 total_amount += amount
+#                 for partial_line in move_line.matched_debit_ids:
+#                     total_reconciled += partial_line.amount
+#                 for partial_line in move_line.matched_credit_ids:
+#                     total_reconciled += partial_line.amount
+#             values = {
+#                 'residual': residual,
+#                 'residual_due': total_amount - total_reconciled,
+#                 'difference': residual - (line.amount or 0.0),
+#                 'partner_id': invoice.partner_id.id,
+#             }
+#             line.update(values)
+
+#     @api.onchange('amount')
+#     def _onchange_amount(self):
+#         for line in self:
+#             line.difference = line.residual - line.amount

account_payment_disperse/wizard/register_payment_wizard_views.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<odoo>
+    <!-- <record id="view_account_payment_from_invoices_inherited" model="ir.ui.view">
+        <field name="name">account.register.payments.wizard.inherited</field>
+        <field name="model">account.register.payments</field>
+        <field name="inherit_id" ref="account.view_account_payment_from_invoices"/>
+        <field name="arch" type="xml">
+            <xpath expr="//field[@name='amount']" position="attributes">
+                <attribute name="attrs">{'readonly': [('multi', '=', True), ('is_manual_disperse', '!=', True)]}</attribute>
+            </xpath>
+            <xpath expr="//field[@name='payment_method_code']" position="after">
+                <field name="is_manual_disperse"/>
+            </xpath>
+            <xpath expr="//group[3]" position="attributes">
+                <attribute name="attrs">{'invisible': ['|', ('payment_difference', '=', 0.0), ('is_manual_disperse', '=', True)]}</attribute>
+            </xpath>
+            <xpath expr="//form/group[1]" position="after">
+                <group name="invoice_lines" attrs="{'invisible': [('is_manual_disperse', '=', False)]}">
+                    <group>
+                        <button type="object" name="action_fill_residual"
+                                string="Fill with Remaining" class="btn-default"/>
+                        <button type="object" name="action_fill_residual_due"
+                                string="Fill with Due" class="btn-default"/>
+                    </group>
+                    <field name="invoice_line_ids" nolabel="1">
+                        <tree editable="bottom" create="false">
+                            <field name="wizard_id" invisible="1"/>
+                            <field name="partner_id" readonly="1"/>
+                            <field name="invoice_id" readonly="1" force_save="1"/>
+                            <field name="residual" readonly="1" sum="Total Residual"/>
+                            <field name="residual_due" readonly="1" sum="Total Due"/>
+                            <field name="amount" sum="Total Amount"/>
+                            <field name="difference" readonly="1" sum="Total Difference"/>
+                            <field name="writeoff_acc_id"/>
+                        </tree>
+                    </field>
+                </group>
+                <group name="invoice_totals" attrs="{'invisible': [('is_manual_disperse', '=', False)]}">
+                    <group>
+                        <field name="writeoff_journal_id"/>
+                        <field name="due_date_cutoff"/>
+                    </group>
+                    <group/>
+                </group>
+            </xpath>
+        </field>
+    </record> -->
+</odoo>