ingadhoc / account-payment / 767

pending completion

Build # 767

Build Type

Pull #171

travis-ci

Committed by

web-flow

Commit Message

[FIX] doble payment on inv cancel due to pay now

With this change odoo now allows to cancel paid invoices https://github.com/odoo/odoo/commit/5cca55dac
So we only leave pay_now_journal_id if invoice was on draft state

Pull Request Pull Request #171: [FIX] doble payment on inv cancel due to pay now

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

648 of 1844 relevant lines covered (35.14%)

0.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

28.79

/account_payment_group/models/account_invoice.py

# © 2016 ADHOC SA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).

from odoo import models, api, fields, _
from odoo.exceptions import ValidationError


class AccountInvoice(models.Model):
    _inherit = "account.invoice"

    open_move_line_ids = fields.One2many(
        'account.move.line',
        compute='_compute_open_move_lines'
    )
    pay_now_journal_id = fields.Many2one(
        'account.journal',
        'Pay now Journal',
        help='If you set a journal here, after invoice validation, the invoice'
        ' will be automatically paid with this journal. As manual payment'
        'method is used, only journals with manual method are shown.',
        readonly=True,
        states={'draft': [('readonly', False)]},
    )
    payment_group_ids = fields.Many2many(
        'account.payment.group',
        compute='_compute_payment_groups',
        string='Payment Groups',
    )

    @api.multi
    @api.depends('payment_move_line_ids')
    def _compute_payment_groups(self):
        """
        El campo en invoices "payment_id" no lo seteamos con los payment groups
        Por eso tenemos que calcular este campo
        """
        for rec in self:
            rec.payment_group_ids = rec.payment_move_line_ids.mapped(
                'payment_id.payment_group_id')

    @api.multi
    def _get_tax_factor(self):
        self.ensure_one()
        return (self.amount_total and (
            self.amount_untaxed / self.amount_total) or 1.0)

    @api.multi
    def _compute_open_move_lines(self):
        for rec in self:
            rec.open_move_line_ids = rec.move_id.line_ids.filtered(
                lambda r: not r.reconciled and r.account_id.internal_type in (
                    'payable', 'receivable'))

    @api.multi
    def action_account_invoice_payment_group(self):
        self.ensure_one()
        if self.state != 'open':
            raise ValidationError(_(
                'You can only register payment if invoice is open'))
        return {
            'name': _('Register Payment'),
            'view_type': 'form',
            'view_mode': 'form',
            'res_model': 'account.payment.group',
            'view_id': False,
            'target': 'current',
            'type': 'ir.actions.act_window',
            'context': {
                # si bien el partner se puede adivinar desde los apuntes
                # con el default de payment group, preferimos mandar por aca
                # ya que puede ser un contacto y no el commercial partner (y
                # en los apuntes solo hay commercial partner)
                'default_partner_id': self.partner_id.id,
                'to_pay_move_line_ids': self.open_move_line_ids.ids,
                'pop_up': True,
                # We set this because if became from other view and in the
                # context has 'create=False' you can't crate payment lines
                #  (for ej: subscription)
                'create': True,
                'default_company_id': self.company_id.id,
            },
        }

    @api.multi
    def invoice_validate(self):
        res = super(AccountInvoice, self).invoice_validate()
        self.pay_now()
        return res

    @api.multi
    def pay_now(self):
        # validate_payment = not self._context.get('validate_payment')
        for rec in self:
            pay_journal = rec.pay_now_journal_id
            if pay_journal and rec.state == 'open':
                # si bien no hace falta mandar el partner_type al paygroup
                # porque el defaults lo calcula solo en funcion al tipo de
                # cuenta, es mas claro mandarlo y podria evitar error si
                # estamos usando cuentas cruzadas (payable, receivable) con
                # tipo de factura
                if rec.type in ['in_invoice', 'in_refund']:
                    partner_type = 'supplier'
                else:
                    partner_type = 'customer'

                pay_context = {
                    'to_pay_move_line_ids': (rec.open_move_line_ids.ids),
                    'default_company_id': rec.company_id.id,
                    'default_partner_type': partner_type,
                }

                payment_group = rec.env[
                    'account.payment.group'].with_context(
                        pay_context).create({
                            'payment_date': rec.date_invoice
                        })
                # el difference es positivo para facturas (de cliente o
                # proveedor) pero negativo para NC.
                # para factura de proveedor o NC de cliente es outbound
                # para factura de cliente o NC de proveedor es inbound
                # igualmente lo hacemos con el difference y no con el type
                # por las dudas de que facturas en negativo
                if (
                        partner_type == 'supplier' and
                        payment_group.payment_difference >= 0.0 or
                        partner_type == 'customer' and
                        payment_group.payment_difference < 0.0):
                    payment_type = 'outbound'
                    payment_methods = pay_journal.outbound_payment_method_ids
                else:
                    payment_type = 'inbound'
                    payment_methods = pay_journal.inbound_payment_method_ids

                payment_method = payment_methods.filtered(
                    lambda x: x.code == 'manual')
                if not payment_method:
                    raise ValidationError(_(
                        'Pay now journal must have manual method!'))

                payment_group.payment_ids.create({
                    'payment_group_id': payment_group.id,
                    'payment_type': payment_type,
                    'partner_type': partner_type,
                    'company_id': rec.company_id.id,
                    'partner_id': payment_group.partner_id.id,
                    'amount': abs(payment_group.payment_difference),
                    'journal_id': pay_journal.id,
                    'payment_method_id': payment_method.id,
                    'payment_date': rec.date_invoice,
                })
                # if validate_payment:
                payment_group.post()

    @api.multi
    def action_view_payment_groups(self):
        if self.type in ('in_invoice', 'in_refund'):
            action = self.env.ref(
                'account_payment_group.action_account_payments_group_payable')
        else:
            action = self.env.ref(
                'account_payment_group.action_account_payments_group')

        result = action.read()[0]

        if len(self.payment_group_ids) != 1:
            result['domain'] = [('id', 'in', self.payment_group_ids.ids)]
        elif len(self.payment_group_ids) == 1:
            res = self.env.ref(
                'account_payment_group.view_account_payment_group_form', False)
            result['views'] = [(res and res.id or False, 'form')]
            result['res_id'] = self.payment_group_ids.id
        return result

    @api.multi
    def pay_and_reconcile(self, pay_journal, pay_amount=None, date=None,
                          writeoff_acc=None):
        res = super(AccountInvoice, self.with_context(
            create_from_website=True)).pay_and_reconcile(
                pay_journal, pay_amount=pay_amount, date=date,
                writeoff_acc=writeoff_acc)
        return res

    @api.onchange('company_id')
    def _onchange_company_id(self):
        self.pay_now_journal_id = False

    @api.multi
    def action_cancel(self):
        self.filtered(lambda x: x.state != 'draft' and x.pay_now_journal_id).write({'pay_now_journal_id': False})
        return super(AccountInvoice, self).action_cancel()

1	# © 2016 ADHOC SA
2	# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
3
4	from odoo import models, api, fields, _	1✔
5	from odoo.exceptions import ValidationError	1✔
6
7
8	class AccountInvoice(models.Model):	1✔
9	_inherit = "account.invoice"	1✔
10
11	open_move_line_ids = fields.One2many(	1✔
12	'account.move.line',
13	compute='_compute_open_move_lines'
14	)
15	pay_now_journal_id = fields.Many2one(	1✔
16	'account.journal',
17	'Pay now Journal',
18	help='If you set a journal here, after invoice validation, the invoice'
19	' will be automatically paid with this journal. As manual payment'
20	'method is used, only journals with manual method are shown.',
21	readonly=True,
22	states={'draft': [('readonly', False)]},
23	)
24	payment_group_ids = fields.Many2many(	1✔
25	'account.payment.group',
26	compute='_compute_payment_groups',
27	string='Payment Groups',
28	)
29
30	@api.multi	1✔
31	@api.depends('payment_move_line_ids')	1✔
32	def _compute_payment_groups(self):
33	"""
34	El campo en invoices "payment_id" no lo seteamos con los payment groups
35	Por eso tenemos que calcular este campo
36	"""
37	for rec in self:	×
38	rec.payment_group_ids = rec.payment_move_line_ids.mapped(	×
39	'payment_id.payment_group_id')
40
41	@api.multi	1✔
42	def _get_tax_factor(self):
43	self.ensure_one()	×
44	return (self.amount_total and (	×
45	self.amount_untaxed / self.amount_total) or 1.0)
46
47	@api.multi	1✔
48	def _compute_open_move_lines(self):
49	for rec in self:	×
50	rec.open_move_line_ids = rec.move_id.line_ids.filtered(	×
51	lambda r: not r.reconciled and r.account_id.internal_type in (
52	'payable', 'receivable'))
53
54	@api.multi	1✔
55	def action_account_invoice_payment_group(self):
56	self.ensure_one()	×
57	if self.state != 'open':	×
58	raise ValidationError(_(	×
59	'You can only register payment if invoice is open'))
60	return {	×
61	'name': _('Register Payment'),
62	'view_type': 'form',
63	'view_mode': 'form',
64	'res_model': 'account.payment.group',
65	'view_id': False,
66	'target': 'current',
67	'type': 'ir.actions.act_window',
68	'context': {
69	# si bien el partner se puede adivinar desde los apuntes
70	# con el default de payment group, preferimos mandar por aca
71	# ya que puede ser un contacto y no el commercial partner (y
72	# en los apuntes solo hay commercial partner)
73	'default_partner_id': self.partner_id.id,
74	'to_pay_move_line_ids': self.open_move_line_ids.ids,
75	'pop_up': True,
76	# We set this because if became from other view and in the
77	# context has 'create=False' you can't crate payment lines
78	# (for ej: subscription)
79	'create': True,
80	'default_company_id': self.company_id.id,
81	},
82	}
83
84	@api.multi	1✔
85	def invoice_validate(self):
86	res = super(AccountInvoice, self).invoice_validate()	×
87	self.pay_now()	×
88	return res	×
89
90	@api.multi	1✔
91	def pay_now(self):
92	# validate_payment = not self._context.get('validate_payment')
93	for rec in self:	×
94	pay_journal = rec.pay_now_journal_id	×
95	if pay_journal and rec.state == 'open':	×
96	# si bien no hace falta mandar el partner_type al paygroup
97	# porque el defaults lo calcula solo en funcion al tipo de
98	# cuenta, es mas claro mandarlo y podria evitar error si
99	# estamos usando cuentas cruzadas (payable, receivable) con
100	# tipo de factura
101	if rec.type in ['in_invoice', 'in_refund']:	×
102	partner_type = 'supplier'	×
103	else:
104	partner_type = 'customer'	×
105
106	pay_context = {	×
107	'to_pay_move_line_ids': (rec.open_move_line_ids.ids),
108	'default_company_id': rec.company_id.id,
109	'default_partner_type': partner_type,
110	}
111
112	payment_group = rec.env[	×
113	'account.payment.group'].with_context(
114	pay_context).create({
115	'payment_date': rec.date_invoice
116	})
117	# el difference es positivo para facturas (de cliente o
118	# proveedor) pero negativo para NC.
119	# para factura de proveedor o NC de cliente es outbound
120	# para factura de cliente o NC de proveedor es inbound
121	# igualmente lo hacemos con el difference y no con el type
122	# por las dudas de que facturas en negativo
123	if (	×
124	partner_type == 'supplier' and
125	payment_group.payment_difference >= 0.0 or
126	partner_type == 'customer' and
127	payment_group.payment_difference < 0.0):
128	payment_type = 'outbound'	×
129	payment_methods = pay_journal.outbound_payment_method_ids	×
130	else:
131	payment_type = 'inbound'	×
132	payment_methods = pay_journal.inbound_payment_method_ids	×
133
134	payment_method = payment_methods.filtered(	×
135	lambda x: x.code == 'manual')
136	if not payment_method:	×
137	raise ValidationError(_(	×
138	'Pay now journal must have manual method!'))
139
140	payment_group.payment_ids.create({	×
141	'payment_group_id': payment_group.id,
142	'payment_type': payment_type,
143	'partner_type': partner_type,
144	'company_id': rec.company_id.id,
145	'partner_id': payment_group.partner_id.id,
146	'amount': abs(payment_group.payment_difference),
147	'journal_id': pay_journal.id,
148	'payment_method_id': payment_method.id,
149	'payment_date': rec.date_invoice,
150	})
151	# if validate_payment:
152	payment_group.post()	×
153
154	@api.multi	1✔
155	def action_view_payment_groups(self):
156	if self.type in ('in_invoice', 'in_refund'):	×
157	action = self.env.ref(	×
158	'account_payment_group.action_account_payments_group_payable')
159	else:
160	action = self.env.ref(	×
161	'account_payment_group.action_account_payments_group')
162
163	result = action.read()[0]	×
164
165	if len(self.payment_group_ids) != 1:	×
166	result['domain'] = [('id', 'in', self.payment_group_ids.ids)]	×
167	elif len(self.payment_group_ids) == 1:	×
168	res = self.env.ref(	×
169	'account_payment_group.view_account_payment_group_form', False)
170	result['views'] = [(res and res.id or False, 'form')]	×
171	result['res_id'] = self.payment_group_ids.id	×
172	return result	×
173
174	@api.multi	1✔
175	def pay_and_reconcile(self, pay_journal, pay_amount=None, date=None,	1✔
176	writeoff_acc=None):
177	res = super(AccountInvoice, self.with_context(	×
178	create_from_website=True)).pay_and_reconcile(
179	pay_journal, pay_amount=pay_amount, date=date,
180	writeoff_acc=writeoff_acc)
181	return res	×
182
183	@api.onchange('company_id')	1✔
184	def _onchange_company_id(self):
185	self.pay_now_journal_id = False	×
186
187	@api.multi	1✔
188	def action_cancel(self):
189	self.filtered(lambda x: x.state != 'draft' and x.pay_now_journal_id).write({'pay_now_journal_id': False})	×
190	return super(AccountInvoice, self).action_cancel()	×

ingadhoc / account-payment / 767

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous