Produits Entr'ouvert » Combo

    url(r'^lingo/pay$', PayView.as_view(), name='lingo-pay'),

    url(r'^lingo/cancel/(?P<pk>\w+)/$', CancelItemView.as_view(), name='lingo-cancel-item'),

    url(r'^lingo/callback/(?P<regie_pk>\w+)/$', CallbackView.as_view(), name='lingo-callback'),

    url(r'^lingo/return/(?P<regie_pk>\w+)/$', ReturnView.as_view(), name='lingo-return'),

    url(r'^manage/lingo/', decorated_includes(manager_required,

        include(lingo_manager_urls))),

    url(r'^lingo/item/(?P<regie_id>[\w,-]+)/(?P<item_crypto_id>[\w,-]+)/pdf$',

from combo.profile.utils import get_user_from_name_id

from .models import (Regie, BasketItem, Transaction, TransactionOperation,

    options.update({

        'automatic_return_url': request.build_absolute_uri(

        'normal_return_url': request.build_absolute_uri(

    })

def get_basket_url():

                           request.GET['transaction_id'])

            raise Http404

        amount = request.GET['amount']

        logger.info(u'validating amount %s for transaction %s', amount, smart_text(transaction.id))

                           request.GET['transaction_id'])

            raise Http404

        amount = request.GET['amount']

        logger.info(u'cancelling amount %s for transaction %s', amount, smart_text(transaction.id))

        transaction.status = 0

        transaction.amount = total_amount

        kwargs = {

            'email': email, 'first_name': firstname, 'last_name': lastname

        }

class PaymentView(View):

    def handle_response(self, request, backend_response, **kwargs):

        logger = logging.getLogger(__name__)

        logger.info(u'received payment response: %r', backend_response)

        try:

                        transaction.status, payment_response.result))

        # check if transaction belongs to right regie

            raise PaymentException('Invalid payment regie')

        transaction.status = payment_response.result

            except:

                # ignore errors, it will be retried later on if it fails

                logger.exception('error in sync notification for basket item %s', item.id)

        if transaction.remote_items:

            transaction.first_notify_remote_items_of_payments()

from webtest import TestApp

from combo.data.models import Page

from combo.utils import sign_url

from .test_manager import login

pytestmark = pytest.mark.django_db

@contextmanager

def check_log(caplog, message):

    idx = len(caplog.records)

@pytest.fixture

def regie():

    try:

        regie = Regie.objects.get(slug='test')

    except Regie.DoesNotExist:

        regie.slug = 'test'

        regie.description = 'test'

        regie.payment_min_amount = Decimal(4.5)

        regie.save()

    return regie

        return settings.LINGO_API_SIGN_KEY

def test_default_regie():

    Regie.objects.all().delete()

    regie1.save()

    assert bool(regie1.is_default) is True

    regie2.save()

    assert bool(regie2.is_default) is False

    resp = resp.form.submit()

    assert resp.status_code == 302

    items = {'item1': {'amount': '10.5', 'source_url': 'http://example.org/item/1'},

             'item2': {'amount': '42', 'source_url': 'http://example.org/item/2'},

             'item3': {'amount': '100', 'source_url': 'http://example.org/item/3'},

            'ok': True, 'reason': 'Paid'}

    # make sure return url is the user return URL

    assert urlparse.urlparse(qs['return_url'][0]).path.startswith(

    # simulate successful call to callback URL

    with mock.patch('combo.utils.requests_wrapper.RequestsSession.request') as request:

    assert resp.status_code == 200

    # simulate successful return URL

    resp = app.get(qs['return_url'][0], params=args)

    assert 'Your payment has been succesfully registered.' in resp.text

def test_add_amount_to_basket(app, key, regie, user):

    other_regie.save()

    user_email = 'foo@example.com'

    app.get(reverse('lingo-cancel-item', kwargs={'pk': basket_item_id}), status=404)

    app.post(reverse('lingo-cancel-item', kwargs={'pk': basket_item_id}), status=403)

    page = Page(title='xxx', slug='index', template_name='standard')

    page.save()

    item = BasketItem.objects.create(user=user, regie=regie,

    assert data['amount'] == '10.50'

    # call callback with GET

    with mock.patch('combo.utils.requests_wrapper.RequestsSession.request') as request:

        get_resp = app.get(callback_url, params=data)

        url = request.call_args[0][1]

    assert Transaction.objects.get(order_id=transaction_id).status == 3

    # call return view

    assert get_resp.status_code == 302

    resp = app.get(get_resp['Location'])

    assert 'Your payment has been succesfully registered.' in resp.text

    item = BasketItem.objects.create(user=user, regie=regie,

                        subject='test_item', amount='10.5',

                        source_url='http://example.org/testitem/')

    assert data['amount'] == '10.50'

    # call callback with GET

    with mock.patch('combo.utils.requests_wrapper.RequestsSession.request') as request:

        get_resp = app.get(callback_url, params=data)

        url = request.call_args[0][1]

            'amount': qs['amount'][0], 'ok': True}

    assert data['amount'] == '11.50'

    app = login(app)

    data = {'transaction_id': 'unknown', 'signed': True,

            'amount': '23', 'ok': True}

    # call callback with GET

    app.get(callback_url, params=data, status=404)

    item = BasketItem.objects.create(user=user, regie=regie,

                        subject='test_item', amount='10.5',

                        source_url='http://example.org/testitem/')

    assert data['amount'] == '10.50'

    # callback with WAITING state

    resp = app.get(callback_url, params=data)

    assert resp.status_code == 200

    assert Transaction.objects.get(order_id=transaction_id).status == eopayment.WAITING

    assert BasketItem.objects.get(id=item.id).payment_date

    assert BasketItem.get_items_to_be_paid(user).count() == 0

    item = BasketItem.objects.create(user=user, regie=regie,

                        subject='test_item', amount='10.5',

                        source_url='http://example.org/testitem/')

    # call return with unsigned POST

    with check_log(caplog, 'received unsigned payment'):

        with mock.patch('combo.utils.requests_wrapper.RequestsSession.request') as request:

            get_resp = app.post(return_url, params=data)

            assert request.call_count == 0

    # call return with signed POST

    data['signed'] = True

    with mock.patch('combo.utils.requests_wrapper.RequestsSession.request') as request:

        get_resp = app.post(return_url, params=data)

        url = request.call_args[0][1]

    assert resp.status_code == 200

    assert Transaction.objects.get(order_id=transaction_id).status == 3

    item = BasketItem.objects.create(user=user, regie=regie,

                        subject='test_item', amount='10.5',

                        source_url='http://example.org/testitem/')

    assert data['amount'] == '10.50'

    # call callback with GET

    with mock.patch('combo.utils.requests_wrapper.RequestsSession.request') as request:

        mock_response = mock.Mock()

        def kaboom():

from combo.utils import check_query, aes_hex_encrypt

from combo.data.models import Page

from combo.apps.lingo.models import (Regie, ActiveItems, ItemsHistory, SelfDeclaredInvoicePayment,

pytestmark = pytest.mark.django_db

@pytest.fixture

def remote_regie():

    try:

        regie = Regie.objects.get(slug='remote')

    except Regie.DoesNotExist:

        regie.slug = 'remote'

        regie.description = 'remote'

        regie.payment_min_amount = Decimal(2.0)

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

        regie.save()

    return regie

            'ok': True, 'reason': 'Paid'}

    # make sure return url is the user return URL

    assert urlparse.urlparse(qs['return_url'][0]).path.startswith(

    # simulate successful return URL

    resp = app.get(qs['return_url'][0], params=args)

    assert resp.status_code == 302

            'ok': True, 'reason': 'Paid'}

    # make sure return url is the user return URL

    assert urlparse.urlparse(qs['return_url'][0]).path.startswith(

    # simulate payment failure

    mock_get.side_effect = ConnectionError('where is my hostname?')

    resp = app.get(qs['return_url'][0], params=args)