Merge branch 'new/13.0/sale_payment_web' into '13.0'

new/13.0/sale_payment_web into 13.0

See merge request hibou-io/hibou-odoo/suite!506

sale_payment_web/__init__.py

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

sale_payment_web/__manifest__.py

@@ -0,0 +1,27 @@
+{
+    'name': 'Sale Payment Web',
+    'author': 'Hibou Corp. <hello@hibou.io>',
+    'category': 'Sales',
+    'version': '13.0.1.0.0',
+    'description':
+        """
+Sale Payment Web
+================
+
+Allow sales people to register payments for sale orders.
+
+Electronic payments will create transactions and automatically reconcile on the invoice.
+
+        """,
+    'depends': [
+        'payment',
+        'sale',
+    ],
+    'auto_install': False,
+    'data': [
+        'security/sale_security.xml',
+        'security/ir.model.access.csv',
+        'wizard/account_payment_register_views.xml',
+        'views/sale_views.xml',
+    ],
+}

sale_payment_web/models/__init__.py

@@ -0,0 +1,2 @@
+from . import payment
+from . import sale

sale_payment_web/models/payment.py

@@ -0,0 +1,18 @@
+from odoo import api, fields, models
+
+
+class PaymentTransaction(models.Model):
+    _inherit = 'payment.transaction'
+
+    @api.model
+    def create(self, values):
+        active_ids = self._context.get('active_ids')
+        if active_ids and self._context.get('active_model') == 'sale.order':
+            values['sale_order_ids'] = [(6, 0, active_ids)]
+        return super(PaymentTransaction, self).create(values)
+
+
+class AccountPayment(models.Model):
+    _inherit = 'account.payment'
+
+    sale_order_id = fields.Many2one('sale.order', string="Sale Order")

sale_payment_web/models/sale.py

@@ -0,0 +1,36 @@
+from odoo import api, fields, models, _
+from odoo.tools.safe_eval import safe_eval
+
+
+class SaleOrder(models.Model):
+    _inherit = 'sale.order'
+
+    manual_payment_ids = fields.One2many('account.payment', 'sale_order_id', string='Manual Payments')
+    manual_amount_registered_payment = fields.Monetary('Manually Registered Amount', compute='_compute_manual_amount_registered_payment')
+    manual_amount_remaining = fields.Monetary('Remaining Amount Due', compute='_compute_manual_amount_registered_payment')
+
+    @api.depends('manual_payment_ids.amount', 'amount_total')
+    def _compute_manual_amount_registered_payment(self):
+        for so in self:
+            so.manual_amount_registered_payment = sum(so.manual_payment_ids.mapped('amount'))
+            so.manual_amount_remaining = so.amount_total - so.manual_amount_registered_payment
+
+
+    def action_manual_payments(self):
+        action = self.env.ref('account.action_account_payments').read()[0]
+        domain = action['domain'] or '[]'
+        domain = safe_eval(domain)
+        domain.append(('id', 'in', self.manual_payment_ids.ids))
+        action['domain'] = domain
+        return action
+
+    def action_payment_register(self):
+        return {
+            'name': _('Register Payment'),
+            'res_model': 'account.payment.register',
+            'view_mode': 'form',
+            'view_id': self.env.ref('account.view_account_payment_form_multi').id,
+            'context': {'active_ids': self.ids, 'active_model': 'sale.order'},
+            'target': 'new',
+            'type': 'ir.actions.act_window',
+        }

sale_payment_web/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_payment_method,account.payment.method,account.model_account_payment_method,group_payment_web,1,0,0,0

sale_payment_web/security/sale_security.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<odoo>
+
+    <record id="group_payment_web" model="res.groups">
+        <field name="name">Sale Order Payments</field>
+        <field name="category_id" ref="base.module_category_hidden"/>
+    </record>
+
+</odoo>

sale_payment_web/tests/__init__.py

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

sale_payment_web/tests/test_sale_payment.py

@@ -0,0 +1,42 @@
+from odoo.addons.sale.tests.test_sale_to_invoice import TestSaleToInvoice
+from odoo.exceptions import UserError
+
+
+class TestSalePayment(TestSaleToInvoice):
+
+    def setUp(self):
+        super(TestSalePayment, self).setUp()
+        self.context = {
+            'active_model': 'sale.order',
+            'active_ids': [self.sale_order.id],
+            'active_id': self.sale_order.id,
+        }
+
+    def test_payment(self):
+        self.sale_order.action_confirm()
+
+        payment_wizard = self.env['account.payment.register'].with_context(self.context).create({'amount': -15})
+        self.assertTrue(payment_wizard.journal_id)
+        with self.assertRaises(UserError):
+            payment_wizard.create_payments()
+
+        payment_wizard = self.env['account.payment.register'].with_context(self.context).create({'amount': 0})
+        self.assertTrue(payment_wizard.journal_id)
+        with self.assertRaises(UserError):
+            payment_wizard.create_payments()
+
+        payment_wizard = self.env['account.payment.register'].with_context(self.context).create({})
+        self.assertTrue(payment_wizard.journal_id)
+
+        payment_action = payment_wizard.create_payments()
+        self.assertTrue(isinstance(payment_action, dict))
+        payment = self.env[payment_action['res_model']].browse(payment_action['res_id'])
+        self.assertTrue(payment.exists())
+        self.assertEqual(payment.amount, self.sale_order.amount_total)
+
+        self.assertEqual(payment.sale_order_id, self.sale_order)
+
+        payment_wizard = self.env['account.payment.register'].with_context(self.context).create({'amount': 15})
+        self.assertTrue(payment_wizard.journal_id)
+        with self.assertRaises(UserError):
+            payment_wizard.create_payments()

sale_payment_web/views/sale_views.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<odoo>
+
+    <record id="view_order_form_inherit" model="ir.ui.view">
+        <field name="name">sale.order.form.inherit</field>
+        <field name="model">sale.order</field>
+        <field name="inherit_id" ref="sale.view_order_form"/>
+        <field name="arch" type="xml">
+            <xpath expr="//button[@name='action_draft']" position="after">
+                <button name="action_payment_register" type="object" string="Register Payment"/>
+            </xpath>
+            <xpath expr="//field[@name='amount_total']" position="after">
+                <field name="manual_amount_remaining" widget="monetary"/>
+            </xpath>
+            <xpath expr="//div[@name='button_box']" position="inside">
+                <field name="manual_payment_ids" invisible="1"/>
+                <button name="action_manual_payments" string="Manual Payments" type="object" class="oe_stat_button"
+                        icon="fa-dollar" attrs="{'invisible':[('manual_payment_ids', '=', [])]}"/>
+            </xpath>
+        </field>
+    </record>
+
+</odoo>

sale_payment_web/wizard/__init__.py

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

sale_payment_web/wizard/account_payment_register.py

@@ -0,0 +1,134 @@
+from odoo import api, fields, models, _
+from odoo.exceptions import UserError
+
+
+class AccountPaymentRegister(models.TransientModel):
+    _inherit = 'account.payment.register'
+
+    sale_order_id = fields.Many2one('sale.order', string='Sale Order')
+    payment_token_id = fields.Many2one('payment.token', string="Saved payment token",
+                                       domain="[('acquirer_id.capture_manually', '=', False), ('company_id', '=', company_id)]",
+                                       help="Note that tokens from acquirers set to only authorize transactions "
+                                            "(instead of capturing the amount) are not available.")
+    company_id = fields.Many2one('res.company')  # technical requirement for acquirer domain
+    partner_id = fields.Many2one('res.partner')  # technical payment mode/token domain
+
+    currency_id = fields.Many2one(related='journal_id.currency_id')
+    amount = fields.Monetary('Amount')
+    so_amount_registered_payment = fields.Monetary(related='sale_order_id.manual_amount_registered_payment')
+    so_amount_remaining = fields.Monetary(related='sale_order_id.manual_amount_remaining')
+    so_amount_over = fields.Boolean()
+
+    @api.onchange('amount')
+    def _compute_amount_remaining(self):
+        self.so_amount_over = self.amount > self.so_amount_remaining
+
+    @api.model
+    def default_get(self, fields):
+        # super implementation checks active_ids, but not active_model
+        active_ids = self._context.get('active_ids')
+        if self._context.get('active_model') != 'sale.order' or not active_ids:
+            return super(AccountPaymentRegister, self).default_get(fields)
+
+        rec = super(AccountPaymentRegister, self.with_context(active_ids=None)).default_get(fields)
+        sale_order = self.env['sale.order'].browse(active_ids)
+        if len(sale_order) != 1:
+            raise UserError('Register payment must be called on a sale order.')
+
+        if 'sale_order_id' not in rec:
+            rec['sale_order_id'] = sale_order.id
+            rec['so_amount_registered_payment'] = sale_order.manual_amount_registered_payment
+            rec['so_amount_remaining'] = sale_order.manual_amount_remaining
+            if 'amount' not in rec:
+                rec['amount'] = sale_order.manual_amount_remaining
+        if 'company_id' not in rec:
+            rec['company_id'] = sale_order.company_id.id
+        if 'partner_id' not in rec:
+            rec['partner_id'] = sale_order.partner_id.id
+            account_receivable = sale_order.partner_id.property_account_receivable_id
+            if not account_receivable:
+                raise UserError('Your partner must have an Account Receivable setup.')
+        if 'journal_id' not in rec:
+            rec['journal_id'] = self.env['account.journal'].search([('company_id', '=', sale_order.company_id.id), ('type', 'in', ('bank', 'cash'))], limit=1).id
+        if 'payment_method_id' not in rec:
+            domain = [('payment_type', '=', 'inbound')]
+            rec['payment_method_id'] = self.env['account.payment.method'].search(domain, limit=1).id
+        return rec
+
+    @api.onchange('partner_id', 'payment_method_id', 'journal_id')
+    def _onchange_set_payment_token_id(self):
+        res = {}
+
+        if not self.payment_method_id.code == 'electronic' or not self.partner_id or not self.journal_id:
+            self.payment_token_id = False
+            return res
+
+        partners = self.partner_id | self.partner_id.commercial_partner_id | self.partner_id.commercial_partner_id.child_ids
+        domain = [('partner_id', 'in', partners.ids), ('acquirer_id.journal_id', '=', self.journal_id.id)]
+        self.payment_token_id = self.env['payment.token'].search(domain, limit=1)
+
+        res['domain'] = {'payment_token_id': domain}
+        return res
+
+    @api.onchange('journal_id', 'invoice_ids', 'sale_order_id')
+    def _onchange_journal(self):
+        active_ids = self._context.get('active_ids')
+        if self._context.get('active_model') != 'sale.order' or not active_ids:
+            return super(AccountPaymentRegister, self).default_get(fields)
+        journal = self.journal_id
+        if journal:
+            domain_payment = [('payment_type', '=', 'inbound'), ('id', 'in', journal.inbound_payment_method_ids.ids)]
+        return {'domain': {'payment_method_id': domain_payment}}
+
+    def _prepare_communication_sale_orders(self, sale_order):
+        return " ".join(o.reference or o.name for o in sale_order)
+
+    def _prepare_payment_vals_sale_orders(self, sale_order):
+        '''Create the payment values.
+
+        :param sale_order: The sale orders to pay. In case of multiple
+            documents.
+        :return: The payment values as a dictionary.
+        '''
+        if self.amount <= 0:
+            raise UserError("You must enter a positive amount.")
+        elif self.amount > self.so_amount_remaining:
+            raise UserError("You cannot make a payment for more than the difference of the total amount and existing "
+                            "payments: %.2f" % self.so_amount_remaining)
+        values = {
+            'journal_id': self.journal_id.id,
+            'payment_method_id': self.payment_method_id.id,
+            'payment_date': self.payment_date,
+            'communication': self._prepare_communication_sale_orders(sale_order),
+            # TODO sale orders need to get to transactions somehow
+            # 'invoice_ids': [(6, 0, invoices.ids)],
+            'payment_type': 'inbound',  # if amount can be negative we need to allow this to be outbound
+            'amount': self.amount,
+            'currency_id': sale_order.currency_id.id,
+            'partner_id': sale_order.partner_id.id,
+            'partner_type': 'customer',
+            'payment_token_id': self.payment_token_id.id,
+        }
+        return values
+
+    def get_payments_vals(self):
+        if self.sale_order_id:
+            return [self._prepare_payment_vals_sale_orders(self.sale_order_id)]
+        return super(AccountPaymentRegister, self).get_payments_vals()
+
+    def create_payments(self):
+        if self.sale_order_id:
+            # user may not be able to create payment
+            res = super(AccountPaymentRegister, self.sudo()).create_payments()
+        else:
+            res = super(AccountPaymentRegister, self).create_payments()
+        if res and 'res_id' in res and self.sale_order_id:
+            payment = self.env['account.payment'].browse(res['res_id'])
+            self.sale_order_id.manual_payment_ids += payment
+            if payment.name:  # if we don't have a name, then it started a transaction and that will be in chatter
+                payment_link = payment._get_payment_chatter_link()
+                for order in self.sale_order_id:
+                    order.message_post(body=_('A %s payment has been registered: %s') % (payment.payment_method_code, payment_link))
+            # return a 'dummy' action like object for tests
+            return {'res_id': payment.id, 'res_model': payment._name}
+        return res

sale_payment_web/wizard/account_payment_register_views.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<odoo>
+
+    <record id="view_account_payment_form_multi_inherit" model="ir.ui.view">
+        <field name="name">account.payment.form.multi.inherit</field>
+        <field name="model">account.payment.register</field>
+        <field name="inherit_id" ref="account.view_account_payment_form_multi"/>
+        <field name="arch" type="xml">
+            <xpath expr="//group/group[1]" position="inside">
+                <field name="company_id" invisible="1" />
+                <field name="partner_id" invisible="1" />
+                <field name="payment_token_id" nocreate="1" />
+            </xpath>
+            <xpath expr="//field[@name='payment_date']" position="after">
+                <field name="currency_id" invisible="True"/>
+                <field name="amount"/>
+                <field name="so_amount_remaining" invisible="1"/>
+                <field name="so_amount_over" invisible="1"/>
+                <div attrs="{'invisible':[('so_amount_over', '=', False)]}" class="text-danger" colspan="4">
+                    <p>
+                        You cannot make a payment for more than the difference of the total amount and existing payments:
+                        <field name="so_amount_remaining"/>
+                    </p>
+                </div>
+            </xpath>
+        </field>
+    </record>
+
+</odoo>