0001-lingo-check-real-payment-status-of-remote_item-when-.patch

Benjamin Dauvergne, 15 avril 2021 21:24

Voir les différences: en ligne côte à côte

Subject: [PATCH] lingo: check real payment status of remote_item when shown or
 paid (#53186)

Currently the remote_item.paid attribute comes from what the remote
regie is providing through a web service. But a remote_item can be
already paid if a transaction with a paid status (eopayment.PAID or
eopayment.ACCEPTED) already exist.

This patch add a RemoteItem.update_paid(regie, remote_items) which
update bunch of remote_item(s) by querying the correponding paid
transactions.

The methods Regie.get_invoices() and Regie.get_invoice() get a new
parameter update_paid=False, which is set to true in cells and views
which display or allow paying a remote item.

 combo/apps/lingo/models.py       | 53 +++++++++++++++++++++++++++---
 combo/apps/lingo/views.py        | 10 ++++--
 tests/test_lingo_remote_regie.py | 55 ++++++++++++++++++++++----------
 3 files changed, 93 insertions(+), 25 deletions(-)

     import logging
     import re
     from decimal import Decimal
     from functools import reduce
     import eopayment
     from dateutil import parser
-...
                 return self.text_on_success
             return _('Your payment has been succesfully registered.')
         def get_invoices(self, user, history=False):
         def get_invoices(self, user, history=False, update_paid=False):
             if not self.is_remote():
                 return []
             if user:
-...
                 if items.get('data'):
                     if not isinstance(items['data'], list):
                         raise RegieException(regie_exc_msg)
                     return [build_remote_item(item, self) for item in items['data']]
                     remote_items = [build_remote_item(item, self) for item in items['data']]
                     if not history and update_paid:
                         # update paid status using known transactions
                         RemoteItem.update_paid(self, remote_items)
                     return remote_items
                 return []
             return []
         def get_invoice(self, user, invoice_id, log_errors=True, raise_4xx=False):
         def get_invoice(self, user, invoice_id, log_errors=True, raise_4xx=False, update_paid=False):
             if not self.is_remote():
                 return self.basketitem_set.get(pk=invoice_id)
             url = self.webservice_url + '/invoice/%s/' % invoice_id
-...
                 raise RemoteInvoiceException()
             if response.json().get('data') is None:
                 raise ObjectDoesNotExist()
             return build_remote_item(response.json().get('data'), self)
             remote_item = build_remote_item(response.json().get('data'), self)
             if update_paid:
                 # update paid status using known transactions
                 RemoteItem.update_paid(self, [remote_item])
             return remote_item
         def get_invoice_pdf(self, user, invoice_id):
             """
-...
         def crypto_id(self):
             return aes_hex_encrypt(settings.SECRET_KEY, force_bytes(str(self.id)))
         @classmethod
         def update_paid(cls, regie, remote_items):
             remote_item_ids = [remote_item.id for remote_item in remote_items if not remote_item.paid]
             if not remote_item_ids:
                 return
             paid_items = {}
             # filter transactions by regie, status and contained remote_item id
             transaction_qs = Transaction.objects.filter(
                 regie=regie, status__in=[eopayment.PAID, eopayment.ACCEPTED]
+            )
             query = reduce(
                 models.Q.__or__,
                 (models.Q(remote_items__contains=remote_item_id) for remote_item_id in remote_item_ids),
+            )
             # accumulate in paid_items each remote_item earliest payment_date
             for transaction in transaction_qs.filter(query):
                 for remote_item in transaction.remote_items.split(','):
                     if remote_item not in paid_items:
                         paid_items[remote_item] = transaction.end_date
                     else:
                         paid_items[remote_item] = min(transaction.end_date, paid_items[remote_item])
             # update remote_item.paid using paid_items
             for remote_item in remote_items:
                 if remote_item.paid:
                     continue
                 if remote_item.id in paid_items:
                     remote_item.paid = True
                     remote_item.payment_date = paid_items[remote_item.id]
     class Transaction(models.Model):
         regie = models.ForeignKey(Regie, on_delete=models.CASCADE, null=True)
-...
             errors = []
             for r in self.get_regies():
                 try:
                     items.extend(r.get_invoices(user))
                     for remote_item in r.get_invoices(user, update_paid=True):
                         if not remote_item.paid:
                             items.append(remote_item)
                 except RegieException as e:
                     errors.append(e)
             return items, errors

                 messages.error(request, _('This regie allows to pay only one item.'))
                 return HttpResponseRedirect(next_url)
             if any(item.paid for item in remote_items):
                 messages.error(request, _('Some items are already paid.'))
                 return HttpResponseRedirect(next_url)
             total_amount = sum([x.amount for x in remote_items or items])
             if total_amount < regie.payment_min_amount:
-...
                     regie = Regie.objects.get(pk=regie_id)
                     # get all items data from regie webservice
                     for item_id in request.POST.getlist('item'):
                         remote_items.append(regie.get_invoice(user, item_id))
                         remote_items.append(regie.get_invoice(user, item_id, update_paid=True))
                 except (requests.exceptions.RequestException, RemoteInvoiceException):
                     messages.error(request, _(u'Technical error: impossible to retrieve invoices.'))
                     return HttpResponseRedirect(next_url)
-...
                 raise Http404()
             try:
                 item = regie.get_invoice(self.request.user, item_id)
                 item = regie.get_invoice(self.request.user, item_id, update_paid=True)
                 if self.request.GET.get('page'):
                     try:
                         ret['page'] = Page.objects.get(pk=self.request.GET['page'])
-...
             else:
                 for regie in obj.get_regies():
                     try:
                         invoice = regie.get_invoice(None, invoice_id, log_errors=False)
                         invoice = regie.get_invoice(None, invoice_id, log_errors=False, update_paid=True)
                     except ObjectDoesNotExist:
                         continue
                     if invoice.total_amount != invoice_amount:

     import json
     from decimal import Decimal
     import eopayment
     import mock
     import pytest
     from django.apps import apps
-...
             'has_pdf': True,
             'online_payment': True,
             'paid': False,
             'payment_date': '1970-01-01',
             'payment_date': None,
             'no_online_payment_reason': '',
             'reference_id': 'order-id-1',
         },
-...
             'has_pdf': True,
             'online_payment': True,
             'paid': False,
             'payment_date': '1970-01-01',
             'payment_date': None,
             'no_online_payment_reason': '',
             'reference_id': 'order-id-2',
         },
-...
         assert 'F-2016-Two' in content
         assert '543.21' in content
         # set the second one as paid
         Transaction.objects.create(
             regie=remote_regie, remote_items=INVOICES[1]['id'], status=eopayment.PAID, end_date=now()
+        )
         content = cell.render(context)
         assert 'F-2016-One' in content
         assert '123.45' in content
         assert 'F-2016-Two' not in content
         assert '543.21' not in content
         assert '?page=%s' % page.pk in content
         # check if regie webservice has been correctly called
         assert mock_send.call_args[0][0].method == 'GET'
-...
         assert 'Total amount: <span class="amount">123.45€</span>' in resp.text
         assert 'Amount to pay: <span class="amount">123.45€</span>' in resp.text
         assert 'Amount already paid>' not in resp.text
         assert '"buttons"' in resp
         form = resp.form
-...
         assert resp.status_code == 200
         # check invoice cannot be paid a second time
         resp = app.get('/lingo/item/%s/%s/' % (remote_regie.id, encrypt_id))
         assert '"buttons"' not in resp
         resp = form.submit()
         assert resp.location == '/'
         assert 'Some items are already paid' in app.session['_messages']
     @mock.patch('combo.apps.lingo.models.requests.get')
     def test_remote_item_failure(mock_get, app, remote_regie):
-...
         appconfig.update_transactions()
     @pytest.mark.parametrize('can_pay_only_one_basket_item', [False, True])
     @mock.patch('combo.apps.lingo.models.Regie.pay_invoice')
     @mock.patch('combo.apps.lingo.models.requests.get')
     def test_remote_invoice_successfull_payment_redirect(mock_get, mock_pay_invoice, app, remote_regie):
     def test_remote_invoice_successfull_payment_redirect(
         mock_get, mock_pay_invoice, can_pay_only_one_basket_item, app, remote_regie
     ):
         assert remote_regie.is_remote()
         assert remote_regie.can_pay_only_one_basket_item is False
         remote_regie.can_pay_only_one_basket_item = can_pay_only_one_basket_item
         remote_regie.save()
         page = Page(title='xxx', slug='active-remote-invoices-page', template_name='standard')
-...
         mock_get.return_value = mock_json
         mock_pay_invoice.return_value = mock.Mock(status_code=200)
         resp = app.get('/lingo/item/%s/%s/?page=%s' % (remote_regie.id, encrypt_id, page.pk))
         assert '"paid"' not in resp
         form = resp.form
         assert form['next_url'].value == '/active-remote-invoices-page/'
         form['email'] = 'test@example.net'
-...
         parsed = urlparse.urlparse(location)
         # get return_url and transaction id from location
         qs = urlparse.parse_qs(parsed.query)
         assert 'orderid' not in qs
         assert 'subject' not in qs
         if can_pay_only_one_basket_item:
             assert qs['orderid'] == ['order-id-1']
             assert qs['subject'] == ['invoice-one']
         else:
             assert 'orderid' not in qs
             assert 'subject' not in qs
         args = {'transaction_id': qs['transaction_id'][0], 'signed': True, 'ok': True, 'reason': 'Paid'}
         resp = app.get(qs['return_url'][0], params=args)
         # redirect to payment status
-...
             == '/active-remote-invoices-page/'
+        )
         # one item limitation: send orderid to eopayment
         remote_regie.can_pay_only_one_basket_item = True
         remote_regie.save()
         resp = form.submit()
         assert resp.status_code == 302
         location = resp.location
         assert 'dummy-payment' in location
         parsed = urlparse.urlparse(location)
         qs = urlparse.parse_qs(parsed.query)
         assert qs['orderid'] == ['order-id-1']
         assert qs['subject'] == ['invoice-one']
         # check true payment status is visible, even if the remote regie web-service still report the invoice as unpaid
         resp = app.get('/lingo/item/%s/%s/?page=%s' % (remote_regie.id, encrypt_id, page.pk))
         assert not INVOICES[0]['paid']
         assert '"paid"' in resp
     @mock.patch('combo.apps.lingo.models.UserSAMLIdentifier')
+    -

Projet

Général

Profil

Produits Entr'ouvert » Combo

0001-lingo-check-real-payment-status-of-remote_item-when-.patch