Produits Entr'ouvert » Combo

from django.conf import settings

from django.db import models

from django.forms import models as model_forms, Select

from django.utils.translation import ugettext_lazy as _

from django.utils import timezone, dateparse, six

from django.core.mail import EmailMultiAlternatives

from django.urls import reverse

from django.core.exceptions import ObjectDoesNotExist, PermissionDenied, ValidationError

from django.utils.formats import localize

from django.utils.http import urlencode

from django.utils.six.moves.urllib import parse as urlparse

from django.utils.timezone import make_aware, utc

from django.contrib.auth.models import User

from django.template.loader import render_to_string

                   'autobilling': _('Autobilling has been set for this invoice.'),

                   'past-due-date': _('Due date is over.'),

                   }

        return settings.LINGO_NO_ONLINE_PAYMENT_REASONS.get(self.no_online_payment_reason,

                                reasons.get(self.no_online_payment_reason))

    @property

    def crypto_id(self):

class Transaction(models.Model):

    regie = models.ForeignKey(Regie, on_delete=models.CASCADE, null=True)

    items = models.ManyToManyField(BasketItem, blank=True)

    remote_items = models.CharField(max_length=512)

    to_be_paid_remote_items = models.CharField(max_length=512, null=True)

    start_date = models.DateTimeField(auto_now_add=True)

# 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 binascii

from django.utils import six

from django.utils.encoding import force_text

class DecryptionError(Exception):

    pass

        'XStatic_OpenSans',

        'XStatic_roboto-fontface>=0.5.0.0',

        'eopayment>=1.43',

        'python-dateutil',

        'djangorestframework>=3.3, <3.8',

        'django-ratelimit<3',

        'sorl-thumbnail',

        'Pillow',

        'pyproj',

        'pywebpush',

        'pygal',

        'lxml',

        ],

    zip_safe=False,

    cmdclass={

        'build': build,

from requests.exceptions import ConnectionError

from django.apps import apps

from django.test.client import RequestFactory

from django.test import override_settings

from django.urls import reverse

from django.conf import settings

from django.core.management import call_command

from django.utils.six.moves.urllib import parse as urlparse

from django.utils.timezone import timedelta, now

from django.contrib.auth.models import User

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,

                                     Transaction, BasketItem, PaymentBackend)

    content = cell.render(context)

    assert content.strip() == ''

@mock.patch('combo.apps.lingo.models.Regie.pay_invoice')

@mock.patch('combo.apps.lingo.models.requests.get')

def test_anonymous_successful_item_payment(mock_get, mock_pay_invoice, app, remote_regie):

    assert remote_regie.is_remote() == True

    # invoice with amount_paid

    invoices = copy.deepcopy(INVOICES)

    invoices[0]['amount'] = '100.00'

    invoices[0]['amount_paid'] = '23.45'

    mock_json = mock.Mock()

    mock_json.json.return_value = {'err': 0, 'data': invoices[0]}

    mock_get.return_value = mock_json

    mock_pay_invoice.return_value = mock.Mock(status_code=200)

    assert b_item.amount == Decimal(INVOICES[0]['amount'])

    assert b_item in trans.items.all()

    assert resp.status_code == 200

@mock.patch('combo.apps.lingo.models.requests.get')

def test_anonymous_item_payment_email_error(mock_get, app, remote_regie):

    assert remote_regie.is_remote() == True

    mock_json = mock.Mock()

    mock_json.json.return_value = {'err': 0, 'data': INVOICES[0]}

    mock_get.return_value = mock_json

    resp = app.get('/lingo/item/%s/%s/' % (remote_regie.id, encrypt_id))

    form = resp.form

    resp = form.submit()

    assert resp.status_code == 302

@mock.patch('combo.apps.lingo.models.Regie.pay_invoice')

@mock.patch('combo.apps.lingo.models.requests.get')

@mock.patch('combo.apps.lingo.models.requests.post')

def test_remote_item_payment_failure(mock_post, mock_get, mock_pay_invoice, app, remote_regie):

    page = Page(title='xxx', slug='active-remote-invoices-page', template_name='standard')

    page.save()

    assert remote_regie.is_remote()

    mock_json = mock.Mock()

    mock_json.json.return_value = {'err': 0, 'data': INVOICES[0]}

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

    form = resp.form

    assert 'email' in form.fields

@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):

    page = Page(title='xxx', slug='active-remote-invoices-page', template_name='standard')

    page.save()

    assert remote_regie.is_remote()

    mock_json = mock.Mock()

    mock_json.json.return_value = {'err': 0, 'data': INVOICES[0]}

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

    form = resp.form

    assert form['next_url'].value == '/active-remote-invoices-page/'

    form['email'] = 'test@example.net'

from combo.utils import (aes_hex_decrypt, aes_hex_encrypt, get_templated_url,

                         TemplateError)

from django.conf import settings

from django.test import override_settings

from django.template import Context, RequestContext

from django.test.client import RequestFactory

from django.contrib.auth.models import AnonymousUser

class MockUser(object):

    email = 'foo=3@example.net'

    is_authenticated = True

    def __init__(self, samlized=True):

        self.samlized = samlized

        if self.samlized:

            return 'r2&d2'

        return None

def test_crypto_url():

    invoice_id = '12-1234'

    key = settings.SECRET_KEY

def test_templated_url():

    assert get_templated_url('foobar') == 'foobar'

    assert get_templated_url('foo[]bar') == 'foo[]bar'

    assert get_templated_url('foo[bar') == 'foo[bar'

    assert get_templated_url('foo]bar') == 'foo]bar'

    assert get_templated_url('foo]bar[') == 'foo]bar['