Produits Entr'ouvert » Combo

            self.instance.eopayment.get_parameters(scope='transaction'),

            self.instance.eopayment.get_parameters(scope='transaction'), self.cleaned_data

            self.instance.eopayment.get_parameters(scope='global'), self.instance.service_options

            self.instance.eopayment.get_parameters(scope='global'), self.cleaned_data

# lingo - basket and payment system

# Copyright (C) 2021  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import datetime

import logging

from django.core.management.base import BaseCommand, CommandError

from combo.apps.lingo.models import PaymentBackend, PaymentException

logger = logging.getLogger('combo.apps.lingo')

class Command(BaseCommand):

    def add_arguments(self, parser):

        parser.add_argument('--backend', default=None, help='slug of the backend')

        parser.add_argument('--all-backends', default=False, action='store_true', help='target all backends')

        parser.add_argument(

            '--noinput',

            '--no-input',

            action='store_false',

            dest='interactive',

            help='Tells Django to NOT prompt the user for input of any kind.',

        )

        parser.add_argument(

            '--max-age-in-days', default=3, type=int, help='max age of the transaction in days'

        )

    def handle(

        self,

        *args,

        backend=None,

        all_backends=False,

        max_age_in_days=None,

        interactive=True,

        verbosity=1,

        **options,

    ):

        qs = PaymentBackend.objects.all()

        if backend and all_backends:

            raise CommandError('--backend and --all-baskends cannot be used together')

        elif backend:

            try:

                backend = qs.get(slug=backend)

            except PaymentBackend.DoesNotExist:

                raise CommandError('no backend with slug "%s".' % backend)

            else:

                if not backend.can_poll_backend():

                    raise CommandError('backend "%s" cannot be polled.' % backend)

                backends = [backend]

        else:

            backends = [backend for backend in qs if backend.can_poll_backend()]

            if not backends:

                raise CommandError('no backend found.')

            if not all_backends and interactive:

                print('Choose backend by slug:')

                while True:

                    for backend in backends:

                        print(' - %s: %s' % (backend.slug, backend))

                    print('> ', end=' ')

                    slug = input().strip()

                    if not slug:

                        continue

                    filtered_backends = qs.filter(slug__icontains=slug)

                    if filtered_backends:

                        backends = filtered_backends

                        break

        for backend in backends:

            if verbosity >= 1:

                print('Polling backend', backend, '... ', end='')

            try:

                backend.poll_backend(max_age=max_age_in_days and datetime.timedelta(days=max_age_in_days))

            except PaymentException:

                logger.exception('polling failed')

                if interactive:

                    # show error

                    raise

            if verbosity >= 1:

                print('DONE')

from django.core.exceptions import ObjectDoesNotExist, PermissionDenied

from django.db.transaction import atomic

from django.utils.timezone import make_aware, now, utc

    @property

    def eopayment(self):

        return self.make_eopayment()

    def make_eopayment(self, *, request=None, automatic_return_url=None, normal_return_url=None, **kwargs):

        if request:

            if not automatic_return_url:

                automatic_return_url = reverse(

                    'lingo-callback-payment-backend', kwargs={'payment_backend_pk': self.id}

                )

            if automatic_return_url:

                automatic_return_url = request.build_absolute_uri(automatic_return_url)

            if normal_return_url:

                normal_return_url = request.build_absolute_uri(normal_return_url)

            options['automatic_return_url'] = automatic_return_url

            options['normal_return_url'] = normal_return_url

        else:

            assert (

                not automatic_return_url and not normal_return_url

            ), 'make_eopayment must be used with a request to set automatic_return_url or normal_return_url'

        options.update(**kwargs)

    def can_poll_backend(self):

        return self.eopayment.has_payment_status

    def poll_backend(self, min_age=None, max_age=None):

        if not self.can_poll_backend():

            return

        current_time = now()

        # poll transactions linked to the current backend

        # aged between 5 minutes and 3 hours, max_age can be overriden

        min_age = min_age or datetime.timedelta(minutes=5)

        not_after = current_time - min_age

        max_age = max_age or datetime.timedelta(hours=3)

        not_before = current_time - max_age

        transactions = Transaction.objects.filter(

            regie__payment_backend=self,

            start_date__lt=not_after,

            start_date__gt=not_before,

            status__in=Transaction.RUNNING_STATUSES,

        ).order_by('pk')

        last_pk = -1

        while True:

            # lock each transaction before trying to poll it

            with atomic():

                transaction = transactions.filter(pk__gt=last_pk).select_for_update(skip_locked=True).first()

                if not transaction:

                    break

                last_pk = transaction.pk

                transaction.poll_backend(ignore_errors=False)

    def can_poll_backend(self):

        return self.payment_backend.can_poll_backend()

    @property

    def eopayment(self):

        return self.make_eopayment()

    def make_eopayment(self, **kwargs):

        return self.payment_backend.make_eopayment(**kwargs)

        qs = cls.objects.filter(

        for transaction in Transaction.objects.filter(items__in=qs):

            if transaction.can_poll_backend():

                transaction.poll_backend()

        return qs

        self.waiting_date = None

    def transactions_for_remote_items(cls, queryset, remote_items):

        remote_item_ids = set(remote_item.id for remote_item in remote_items if not remote_item.paid)

            return Transaction.objects.none()

        for transaction in queryset.filter(query):

            for remote_item_id in transaction.remote_items.split(','):

                if remote_item_id in remote_item_ids:

                    yield transaction

                    break

    @classmethod

    def update_paid(cls, regie, remote_items):

        paid_items = {}

        waiting_items = {}

        transaction_qs = Transaction.objects.filter(regie=regie)

        can_poll_backend = regie.can_poll_backend()

        # accumulate in paid_items each remote_item earliest payment_date

        for transaction in cls.transactions_for_remote_items(transaction_qs, remote_items):

            if transaction.is_running() and can_poll_backend:

                transaction.poll_backend()

                if transaction.end_date and transaction.is_paid():

                    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])

                elif transaction.status == eopayment.WAITING and can_poll_backend:

                    waiting_items[remote_item] = transaction.start_date

            elif remote_item.id in waiting_items:

                remote_item.waiting_date = waiting_items[remote_item.id]

    RUNNING_STATUSES = [0, eopayment.WAITING, eopayment.RECEIVED]

    PAID_STATUSES = [eopayment.PAID, eopayment.ACCEPTED]

        return self.status in self.PAID_STATUSES

        return self.status in self.RUNNING_STATUSES

    @property

    def eopayment(self):

        return self.regie.eopayment

    def make_eopayment(self, **kwargs):

        normal_return_url = reverse(

            'lingo-return-payment-backend',

            kwargs={

                'payment_backend_pk': self.regie.payment_backend.id,

                'transaction_signature': signing_dumps(self.pk),

            },

        )

        return self.regie.make_eopayment(normal_return_url=normal_return_url, **kwargs)

    def can_poll_backend(self):

        return self.regie and self.regie.can_poll_backend()

    def poll_backend(self, ignore_errors=True):

        with atomic():

            # lock the transaction

            Transaction.objects.filter(pk=self.pk).select_for_update().first()

            try:

                response = self.eopayment.payment_status(self.order_id, transaction_date=self.start_date)

            except eopayment.PaymentException:

                if ignore_errors:

                    logger.warning(

                        'lingo: regie "%s" polling backend for transaction "%%s(%%s)" failed' % self.regie,

                        self.order_id,

                        self.id,

                        exc_info=True,

                    )

                    return

                raise PaymentException('polling failed')

            logger.debug(

                'lingo: regie "%s" polling backend for transaction "%%s(%%s)"' % self.regie,

                self.order_id,

                self.id,

            )

            if self.status != response.result:

                self.handle_backend_response(response)

        qs = Transaction.objects.filter(models.Q(user=user) | models.Q(items__user=user)).filter(

        for transaction in qs:

            if transaction.can_poll_backend() and transaction.is_running():

                transaction.poll_backend()

        return qs

        {% if item.waiting_date and not item.paid %}

        <div class="paid paid-info">{% trans "Waiting for payment." %}</div>

        {% endif %}

        {% if not item.paid and item.online_payment and item.amount >= regie.payment_min_amount and not item.waiting_date %}

          {% if item.online_payment and item.amount >= item.regie.payment_min_amount and not item.waiting_date %}{% trans "and pay" %}{% endif %}

    RemoteItem,

            result = transaction.make_eopayment(request=request).backend.validate(

                amount, transaction.bank_data

            )

            result = transaction.make_eopayment(request=request).backend.cancel(amount, transaction.bank_data)

        if (

            regie.payment_backend.can_poll_backend()

            and self.poll_for_newly_paid_or_still_running_transactions(regie, items, remote_items)

        ):

            messages.error(request, _('Some items are already paid or are being paid.'))

            return HttpResponseRedirect(next_url)

            (order_id, kind, data) = transaction.make_eopayment(request=request).request(

                total_amount, **kwargs

            )

    def poll_for_newly_paid_or_still_running_transactions(self, regie, items, remote_items):

        '''Verify if any open transaction is not already paid.'''

        qs = Transaction.objects.filter(regie=regie, status__in=Transaction.RUNNING_STATUSES)

        if items:

            transactions = qs.filter(items__in=items)

        else:

            transactions = RemoteItem.transactions_for_remote_items(qs, remote_items)

        newly_paid_or_still_running = False

        for transaction in transactions:

            transaction.poll_backend()

            newly_paid_or_still_running |= transaction.is_paid() or transaction.is_running()

        return newly_paid_or_still_running

        payment = payment_backend.make_eopayment(request=request)

*/10 * * * * combo /usr/bin/combo-manage tenant_command lingo-poll-backends --all-tenants -v0 --no-input

    PaymentBackend(service='dummy', service_options='xx').eopayment

    PaymentBackend(service='dummy', service_options='"xx"').eopayment

    PaymentBackend(service='dummy', service_options=None).eopayment

from django.core.management import CommandError, call_command

from django.db import transaction

from django.utils.timezone import now, utc

    LingoRecentTransactionsCell,

    PaymentException,

def payment_backend():

    return PaymentBackend.objects.create(

        label='test1', slug='test1', service='dummy', service_options={'siret': '1234'}

    )

@pytest.fixture

def regie(payment_backend):

    regie = Regie()

    regie.label = 'Test'

    regie.slug = 'test'

    regie.description = 'test'

    regie.can_pay_only_one_basket_item = False

    regie.payment_min_amount = Decimal(4.5)

    regie.payment_backend = payment_backend

    regie.save()

def remote_regie(payment_backend):

    regie = Regie()

    regie.label = 'Remote'

    regie.slug = 'remote'

    regie.description = 'remote'

    regie.payment_min_amount = Decimal(2.0)

    regie.payment_backend = payment_backend

    regie.webservice_url = 'http://example.org/regie'  # is_remote

    regie.save()

    with mock.patch('eopayment.Payment') as MockPayment:

        MockPayment.return_value.request.return_value = (9876, 3, {})

        resp = login(app).get('/test_basket_cell/')

        resp = resp.form.submit()

        assert MockPayment.return_value.request.call_args[1]['manual_validation'] is True

class TestPolling:

    @pytest.fixture

    def payment_backend(self, payment_backend):

        with mock.patch(

            'eopayment.payfip_ws.Payment.request', return_value=(1, eopayment.URL, 'https://payfip/')

        ):

            payment_backend.service = 'payfip_ws'

            payment_backend.save()

            yield payment_backend

    class TestPollBackendCommand:

        @pytest.fixture(autouse=True)

        def setup(self, regie, payment_backend):

            item = BasketItem.objects.create(amount=10, regie=regie)

            transaction = Transaction.objects.create(order_id='1234', status=0, amount=10, regie=regie)

            transaction.items.set([item])

        @pytest.fixture

        def payment_status(self):

            with mock.patch('eopayment.Payment.payment_status') as payment_status:

                payment_status.return_value = eopayment.common.PaymentResponse(

                    order_id='1234',

                    result=eopayment.PAID,

                    transaction_date=now(),

                    transaction_id='4567',

                    bank_data={'abcd': 'xyz'},

                    signed=True,

                )

                yield payment_status

        @pytest.mark.parametrize('cmd_options', [{'all_backends': True}, {'backend': 'test1'}])

        def test_ok(self, payment_status, freezer, cmd_options):

            # transactions are polled after 5 minutes.

            freezer.move_to(timedelta(minutes=4))

            call_command('lingo-poll-backend', **cmd_options)

            assert payment_status.call_count == 0

            freezer.move_to(timedelta(minutes=1, seconds=1))

            call_command('lingo-poll-backend', **cmd_options)

            transaction = Transaction.objects.get()

            payment_status.assert_called_once_with('1234', transaction_date=transaction.start_date)

            transaction.refresh_from_db()

            assert transaction.status == eopayment.PAID

            assert transaction.bank_transaction_date is not None

            assert transaction.bank_data == {'abcd': 'xyz'}

        def test_max_age(self, payment_status, freezer):

            # transaction older than 1 day are ignored

            freezer.move_to(timedelta(days=1, minutes=1))

            call_command('lingo-poll-backend', all_backends=True, max_age_in_days=1)

            assert payment_status.call_count == 0

            # default is 3 days

            freezer.move_to(timedelta(days=2))

            call_command('lingo-poll-backend', all_backends=True)

            assert payment_status.call_count == 0

        def test_payment_exception(self, payment_status, freezer):

            payment_status.side_effect = eopayment.PaymentException('boom!!')

            # transactions are polled after 5 minutes.

            freezer.move_to(timedelta(minutes=5, seconds=1))

            call_command('lingo-poll-backend', interactive=False, all_backends=True)

            assert payment_status.call_count == 1

            transaction = Transaction.objects.get()

            assert transaction.status != eopayment.PAID

            with pytest.raises(PaymentException):  # from combo.apps.lingo.models

                call_command('lingo-poll-backend', all_backends=True)

        def test_cli_ok(self):

            with mock.patch('combo.apps.lingo.models.PaymentBackend.poll_backend') as mock_poll_backend:

                call_command('lingo-poll-backend', backend='test1')

                assert mock_poll_backend.call_count == 1

            with mock.patch('combo.apps.lingo.models.PaymentBackend.poll_backend') as mock_poll_backend:

                with mock.patch(

                    'combo.apps.lingo.management.commands.lingo-poll-backend.input'

                ) as mock_input:

                    mock_input.return_value = 'test1'

                    call_command('lingo-poll-backend')

                assert mock_poll_backend.call_count == 1

        def test_cli_errors(self):

            call_command('lingo-poll-backend', backend='test1')

            with mock.patch('combo.apps.lingo.management.commands.lingo-poll-backend.input') as mock_input:

                mock_input.return_value = 'test1'

                call_command('lingo-poll-backend')

            with pytest.raises(CommandError):

                call_command('lingo-poll-backend', all_backends=True, backend='test1')

            with pytest.raises(CommandError):

                call_command('lingo-poll-backend', backend='coin')

            with transaction.atomic():

                PaymentBackend.objects.all().delete()

                with pytest.raises(CommandError):

                    call_command('lingo-poll-backend', all_backends=True)

    class TestRecentTransactionsCell:

        @pytest.fixture(autouse=True)

        def setup(self, app, user, basket_page, mono_regie):

            BasketItem.objects.create(

                user=user,

                regie=mono_regie,

                amount=42,

                subject='foo item',

                request_data={'refdet': 'F20201030', 'exer': '2020'},

            )

            cell = LingoRecentTransactionsCell(page=basket_page, placeholder='content', order=1)

            cell.save()

        @pytest.fixture

        def app(self, app, user):

            login(app)

            return app

        @mock.patch('eopayment.payfip_ws.Payment.payment_status')

        def test_refresh_status_through_polling(

            self,

            payment_status,

            app,

        ):

            # Try to pay

            pay_resp = app.get('/test_basket_cell/')

            assert 'foo item' in pay_resp

            assert 'Running' not in pay_resp

            resp = pay_resp.click('Pay')

            # we are redirect to payfip

            assert resp.location == 'https://payfip/'

            transaction = Transaction.objects.get()

            # Simulate still running status on polling

            payment_status.return_value = eopayment.common.PaymentResponse(

                signed=True,

                result=eopayment.WAITING,

                order_id=transaction.order_id,

            )

            # Try to pay again

            resp = app.get('/test_basket_cell/')

            assert 'foo item' not in resp

            assert 'Pay' not in resp

            assert 'Running' in resp

            resp = pay_resp.click('Pay').follow()

            assert 'Some items are already paid or' in resp

            assert 'foo item' not in resp

            assert 'Running' in resp

            # Simulate paid status on polling

            payment_status.return_value = eopayment.common.PaymentResponse(

                signed=True,

                result=eopayment.PAID,

                order_id=transaction.order_id,

            )

            # Try to pay again

            resp = app.get('/test_basket_cell/')

            assert 'foo item: 42.00' in resp

            assert 'Pay' not in resp

            assert 'Running' not in resp

        @mock.patch('eopayment.payfip_ws.Payment.payment_status')

        def test_exception_during_polling(

            self,

            payment_status,

            app,

            caplog,

        ):

            # Try to pay

            pay_resp = app.get('/test_basket_cell/')

            assert 'foo item' in pay_resp

            assert 'Running' not in pay_resp

            resp = pay_resp.click('Pay')

            # we are redirect to payfip

            assert resp.location == 'https://payfip/'

            # Simulate polling failure

            payment_status.side_effect = eopayment.PaymentException('boom!')

            # Try to pay again

            resp = app.get('/test_basket_cell/')

            assert 'foo item' in pay_resp

            assert 'Running' not in pay_resp

            last_record = caplog.records[-1]

            assert last_record.levelname == 'WARNING'

            assert 'polling backend for transaction' in last_record.message

import httmock

from .test_manager import login

@pytest.fixture

def remote_invoices_httmock():

    invoices = []

    invoice = {}

    netloc = 'remote.regie.example.com'

    @httmock.urlmatch(netloc=netloc, path='^/invoice/')

    def invoice_mock(url, request):

        return json.dumps({'err': 0, 'data': invoice})

    @httmock.urlmatch(netloc=netloc, path='^/invoices/')

    def invoices_mock(url, request):

        return json.dumps({'err': 0, 'data': invoices})

    context_manager = httmock.HTTMock(invoices_mock, invoice_mock)

    context_manager.url = 'https://%s/' % netloc

    context_manager.invoices = invoices

    context_manager.invoice = invoice

    with context_manager:

        yield context_manager

class TestPolling:

    @mock.patch('eopayment.payfip_ws.Payment.payment_status')

    @mock.patch('eopayment.payfip_ws.Payment.request', return_value=(1, eopayment.URL, 'https://payfip/'))

    def test_in_active_items_cell(

        self,

        payment_request,

        payment_status,

        app,

        remote_regie,

        settings,

        remote_invoices_httmock,

        synchronous_cells,

    ):

        remote_invoices_httmock.invoices.extend(INVOICES)

        remote_invoices_httmock.invoice.update(INVOICES[0])

        remote_regie.webservice_url = remote_invoices_httmock.url

        remote_regie.save()

        # use payfip

        remote_regie.payment_backend.service = 'payfip_ws'

        remote_regie.payment_backend.save()

        User.objects.create_user('admin', password='admin', email='foo@example.com')

        page = Page.objects.create(title='xxx', slug='test_basket_cell', template_name='standard')

        ActiveItems.objects.create(regie='remote', page=page, placeholder='content', order=0)

        login(app)

        assert Transaction.objects.count() == 0

        resp = app.get('/test_basket_cell/')

        assert 'F-2016-One' in resp

        resp = resp.click('pay', index=0)

        pay_resp = resp

        resp = resp.form.submit('Pay')

        transaction = Transaction.objects.get()

        assert transaction.status == 0

        payment_status.return_value = eopayment.common.PaymentResponse(

            signed=True,

            result=eopayment.WAITING,

            order_id=transaction.order_id,

        )

        assert payment_status.call_count == 0

        resp = app.get('/test_basket_cell/')

        assert 'F-2016-One' in resp

        assert payment_status.call_count == 1

        transaction.refresh_from_db()

        assert transaction.status == eopayment.WAITING

        resp = resp.click('pay', index=0)

        assert 'Waiting for payment' in resp

        assert 'button' not in resp

        resp = pay_resp.form.submit('Pay').follow()

        assert 'Some items are already paid' in resp

        payment_status.return_value = eopayment.common.PaymentResponse(

            signed=True,

            result=eopayment.PAID,

            order_id=transaction.order_id,

        )

        resp = app.get('/test_basket_cell/')

        assert 'F-2016-One' not in resp

        transaction.refresh_from_db()

        assert transaction.status == eopayment.PAID