Produits Entr'ouvert » Combo

import re

from decimal import Decimal

from functools import reduce

import eopayment

from dateutil import parser

from django.utils import dateparse, timezone

from django.utils.encoding import force_bytes, python_2_unicode_compatible

from django.utils.formats import localize

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

from django.utils.translation import ugettext_lazy as _

from requests import RequestException

        payment_url = reverse('view-item', kwargs={'regie_id': self.id, 'item_crypto_id': invoice.crypto_id})

        ctx = settings.TEMPLATE_VARS.copy()

        ctx['invoice'] = invoice

        ctx['portal_url'] = settings.SITE_BASE_URL

        subject = render_to_string([subject_template], ctx).strip()

        text_body = render_to_string([text_body_template], ctx)

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

import re

import ratelimit.utils

from django.conf import settings

from django.core.exceptions import DisallowedRedirect, PermissionDenied

from django.http import HttpResponseBadRequest, HttpResponseRedirect, JsonResponse

from django.utils.http import urlquote

from django.utils.translation import ugettext_lazy as _

from django.views.decorators.csrf import csrf_exempt

from django.views.generic import View

        code = request.POST['code']

        next_url = request.POST.get('url') or '/'

        redirect_to_other_domain = bool(

        )

        if redirect_to_other_domain and not is_url_from_known_service(next_url):

import os

import re

import subprocess

import feedparser

import requests

from django.utils.encoding import force_text, python_2_unicode_compatible, smart_bytes

from django.utils.html import strip_tags

from django.utils.safestring import mark_safe

from django.utils.text import slugify

from django.utils.timezone import now

from django.utils.translation import ugettext_lazy as _

        else:

            extra_context['title'] = self.title or self.url

        url = self.get_url(context)

            # create full URL when used in a skeleton

            url = request.build_absolute_uri(url)

        extra_context['url'] = url

import json

import re

from itertools import chain

from django.conf import settings

from django.contrib import messages

from django.template.loader import TemplateDoesNotExist, get_template

from django.utils import lorem_ipsum, timezone

from django.utils.encoding import force_text

from django.utils.translation import ugettext as _

from django.views.decorators.csrf import csrf_exempt

from django.views.defaults import page_not_found

            if 'next' not in request.GET:

                return HttpResponseRedirect(resolve_url('mellon_login'))

            try:

            except KeyError:

                return HttpResponseBadRequest('invalid value for "next" parameter')

            return HttpResponseRedirect(resolve_url('mellon_login') + '?next=' + quoted_next_url)

        response.status_code = 200

        return response

    netloc = parsed_source.netloc

    if parsed_source.scheme == 'https' and netloc.endswith(':443'):

        # somme HTTP client (like Mozilla/1.1 (compatible; MSPIE 2.0; Windows

            if selected_page is None or len(redirect_url) >= len(selected_page.get_redirect_url()):

                selected_page = page

            same_domain_pages.append(page)

    if selected_page is None and same_domain_pages:

        for service_id in settings.KNOWN_SERVICES or {}:

            for service_key in settings.KNOWN_SERVICES[service_id]:

                service = settings.KNOWN_SERVICES[service_id][service_key]

                    selected_page = Page()

                    selected_page.id = '__root'

                    selected_page.template_name = 'standard'

def debug_show_toolbar(request):

    return dt_show_toolbar(request) and not request.path.startswith('/__skeleton__/')

urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

if settings.DEBUG and 'debug_toolbar' in settings.INSTALLED_APPS:

    urlpatterns = [

        url(r'^__debug__/', include(debug_toolbar.urls)),

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

import html

from django.conf import settings

from django.template.context import BaseContext

from django.utils.html import strip_tags

def ellipsize(text, length=50):

def is_url_from_known_service(url):

    if not netloc:

        return True

    for service_id in settings.KNOWN_SERVICES or {}:

        for service_key in settings.KNOWN_SERVICES[service_id]:

            service = settings.KNOWN_SERVICES[service_id][service_key]

                return True

    return False

import hashlib

import logging

from django.conf import settings

from django.core.cache import cache

from django.utils.encoding import smart_bytes

from django.utils.http import urlencode

from django.utils.six import BytesIO

from requests import Response

from requests import Session as RequestsSession

from requests.auth import AuthBase

        if remote_service == 'auto':

            remote_service = None

            for services in settings.KNOWN_SERVICES.values():

                for service in services.values():

                    remote_url = service.get('url')

                    if remote_scheme == scheme and remote_netloc == netloc:

                        remote_service = service

                        break

            if remote_service:

                # only keeps the path (URI) in url parameter, scheme and netloc are

                # in remote_service

            else:

                logging.warning('service not found in settings.KNOWN_SERVICES for %s', url)

                query_params['orig'] = remote_service.get('orig')

            remote_service_base_url = remote_service.get('url')

            query = urlencode(query_params)

            if '?' in url:

            else:

                path = url

        if method == 'GET' and cache_duration:

            # handle cache

import hashlib

import hmac

import random

from django.conf import settings

from django.utils.encoding import smart_bytes

from django.utils.http import quote, urlencode

# Simple signature scheme for query strings

def sign_url(url, key, algo='sha256', timestamp=None, nonce=None):

    new_query = sign_query(parsed.query, key, algo, timestamp, nonce)

def sign_query(query, key, algo='sha256', timestamp=None, nonce=None):

def check_query(query, keys, known_nonce=None, timedelta=30):

    if not ('signature' in parsed and 'algo' in parsed and 'timestamp' in parsed and 'nonce' in parsed):

        return False

    unsigned_query, signature_content = query.split('&signature=', 1)

@contextlib.contextmanager

def tenant_context(domain):

    tenant = TenantMiddleware.get_tenant_by_hostname(domain)

    with tenant_context(tenant):

    # initialize versions as soon as possible as it may be used in most

    # requests via the statics_hash template var and we prefer not to

    # load the information during a user request.

    VersionMiddleware.get_packages_version()

import datetime

import json

from unittest import mock

import pytest

from django.contrib.auth.models import User

from django.core.cache import cache

from django.urls import reverse

from combo.apps.calendar.models import BookingCalendar

from combo.apps.calendar.utils import get_calendar, get_chrono_service

    resp.form.set('slots', True, 1)

    resp.form.set('slots', True, 2)

    resp = resp.form.submit()

    assert parsed.path == '/test/'

    assert qs['session_var_booking_agenda_slug'] == ['test']

    assert qs['session_var_booking_start'] == ['2017-06-13T08:00:00+00:00']

    assert qs['session_var_booking_end'] == ['2017-06-13T09:30:00+00:00']

import json

import os

from unittest import mock

import pytest

from django.apps import apps

from django.contrib.auth.models import User

from django.test import override_settings

from django.urls import reverse

from combo.apps.dashboard.models import DashboardCell, Tile

from combo.data.models import Page, TextCell

    dashboard = DashboardCell.objects.all()[0]

    user = User.objects.all()[0]

    resp = app.get(reverse('combo-dashboard-add-tile', kwargs={'cell_reference': cell.get_reference()}))

    assert Tile.objects.count() == 1

    assert Tile.objects.all()[0].cell.id != cell.id

    assert Tile.objects.all()[0].cell.text == cell.text

from datetime import datetime, timedelta

from decimal import Decimal

from unittest import mock

import eopayment

import httmock

from django.test import override_settings

from django.urls import reverse

from django.utils import timezone

from django.utils.timezone import now, utc

from mellon.models import UserSAMLIdentifier

from requests.exceptions import ConnectionError

    if transaction_id:

        url, part = url.split('?')

        assert 'transaction-id' in query

        assert ':' not in query['transaction-id']

        assert signing_loads(query['transaction-id'][0]) == transaction_id

    assert resp.status_code == 302

    location = resp.location

    assert 'dummy-payment' in location

    # get return_url and transaction id from location

    args = {'transaction_id': qs['transaction_id'][0], 'signed': True, 'ok': True, 'reason': 'Paid'}

    # make sure return url is the user return URL

        '/lingo/return-payment-backend/%s/' % regie.payment_backend.id

    )

    # simulate successful call to callback URL

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

    # redirect to payment status

    assert resp.status_code == 302

    resp = resp.follow()

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

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

    assert resp.status_code == 200

    response = json.loads(resp.text)

    assert response['result'] == 'success'

    assert payment_url.path.startswith('/lingo/item/')

    assert payment_url.path.endswith('/pay')

    assert BasketItem.objects.filter(amount=Decimal('22.23')).exists()

    monkeypatch.setattr(eopayment.Payment, 'request', eopayment_mock)

    resp = resp.form.submit()

    assert resp.status_code == 302

    assert location.path == '/'

    assert location.hostname == 'dummy-payment.demo.entrouvert.com'

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

    resp = resp.form.submit()

    assert resp.status_code == 302

    resp = resp.follow()

    assert "Invalid grouping for basket items: different capture dates." in resp.text

    # make sure the redirection is done to the payment backend

    assert resp.location.startswith('http://dummy-payment.demo.entrouvert.com/')

    assert qs['amount'] == ['12.00']

    # simulate successful payment response from dummy backend

    data = {'transaction_id': qs['transaction_id'][0], 'ok': True, 'amount': qs['amount'][0], 'signed': True}

    # make sure the redirection is done to the payment backend

    assert resp.location.startswith('http://dummy-payment.demo.entrouvert.com/')

    assert qs['amount'] == ['12.00']

    # simulate successful payment response from dummy backend

    data = {'transaction_id': qs['transaction_id'][0], 'ok': True, 'amount': qs['amount'][0], 'signed': True}

    resp = login(app).get(page.get_online_url())

    resp = resp.forms[0].submit()

    assert resp.location.startswith('http://dummy-payment.demo.entrouvert.com/')

    assert qs['amount'] == ['234.46']

    resp = login(app).get(page.get_online_url())

    resp = resp.forms[1].submit()

    assert qs['amount'] == ['22.23']

    resp = resp.form.submit()

    assert resp.status_code == 302

    location = resp.location

    transaction_id = qs['transaction_id'][0]

    data = {'transaction_id': transaction_id, 'signed': True, 'amount': qs['amount'][0], 'ok': True}

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

    resp = resp.form.submit()

    assert resp.status_code == 302

    location = resp.location

    transaction_id = qs['transaction_id'][0]

    return_url = qs['return_url'][0]

    data = {'transaction_id': transaction_id, 'signed': True, 'amount': qs['amount'][0], 'ok': True}

    resp = resp.form.submit()

    assert resp.status_code == 302

    location = resp.location

    transaction_id = qs['transaction_id'][0]

    data = {'transaction_id': transaction_id, 'signed': True, 'amount': qs['amount'][0], 'ok': True}

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

    resp = resp.form.submit()

    assert resp.status_code == 302

    location = resp.location

    transaction_id = qs['transaction_id'][0]

    data = {'transaction_id': transaction_id, 'signed': True, 'amount': qs['amount'][0], 'ok': True}

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

    resp = resp.form.submit()

    assert resp.status_code == 302

    location = resp.location

    return_url = qs['return_url'][0]

    transaction_id = qs['transaction_id'][0]

    data = {'transaction_id': transaction_id, 'signed': True, 'amount': qs['amount'][0], 'ok': True}

    resp = resp.form.submit()

    assert resp.status_code == 302

    location = resp.location

    transaction_id = qs['transaction_id'][0]

    data = {'transaction_id': transaction_id, 'signed': True, 'amount': qs['amount'][0], 'waiting': True}

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

    resp = resp.form.submit()

    assert resp.status_code == 302

    location = resp.location

    transaction_id = qs['transaction_id'][0]

    data = {'transaction_id': transaction_id, 'amount': qs['amount'][0], 'ok': True}

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

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

            assert request.call_count == 0

        assert get_resp.status_code == 302

        assert Transaction.objects.get(order_id=transaction_id).status == 0  # not paid

    # call return with missing data

        assert url.startswith('http://example.org/testitem/jump/trigger/paid')

    # redirect to payment status

    assert get_resp.status_code == 302

    resp = get_resp.follow()

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

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

        resp = resp.form.submit()

    assert resp.status_code == 302

    location = resp.location

    transaction_id = qs['transaction_id'][0]

    data = {'transaction_id': transaction_id, 'signed': True, 'amount': qs['amount'][0], 'ok': True}

    assert data['amount'] == '44.00'

        resp = resp.form.submit()

    assert resp.status_code == 302

    location = resp.location

    transaction_id = qs['transaction_id'][0]

    data = {'transaction_id': transaction_id, 'signed': True, 'amount': qs['amount'][0], 'ok': True}

    assert data['amount'] == '45.00'

    resp = resp.form.submit()

    assert resp.status_code == 302

    location = resp.location

    transaction_id = qs['transaction_id'][0]

    data = {'transaction_id': transaction_id, 'signed': True, 'amount': qs['amount'][0], 'ok': True}

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

    item = BasketItem.objects.first()

    assert item.user is None

    assert item.amount == Decimal('10.00')

    start = '/lingo/item/'

    end = '/pay'

    assert path.startswith(start)

    item.save()

    resp = app.get(payment_url)

    assert resp.location.startswith('http://dummy-payment.demo.entrouvert.com/')

    assert qs['amount'] == ['10.00']

    if authenticated:

        assert qs['email'] == ['foo@example.com']

        },

    )

    assert resp.location.startswith('http://dummy-payment.demo.entrouvert.com/')

    assert qs['amount'] == ['10.00']

    if authenticated:

        assert qs['email'] == ['foo@example.com']

    # make sure the redirection is done to the payment backend

    assert resp.location.startswith('http://dummy-payment.demo.entrouvert.com/')

    assert qs['amount'] == ['12.00']

    # simulate successful payment response from dummy backend

    transaction_id = (qs['transaction_id'][0],)

    resp = resp.click('Pay', href=item.payment_url)

    # successful payment

    assert qs['subject'][0] == 'foo item', 'item.subject was not provided to eopayment'

    assert qs['orderid'][0] == 'form-3-23'

    args = {'transaction_id': qs['transaction_id'][0], 'signed': True, 'ok': True, 'reason': 'Paid'}

    )

    resp = login(app).get(item.payment_url)

    assert qs['subject'][0] == 'foo item', 'item.subject was not provided to eopayment'

    assert qs['info3'][0] == 'très fragile'

    mono_regie.payment_backend.save()

    resp = login(app).get(item.payment_url)

    assert qs['refdet'][0] == 'F20201030'

    assert qs['exer'][0] == '2020'

def test_email_from_basket(app, regie, remote_invoices_httmock):

    def parse_qs(url):

    user1 = User.objects.create(username='user1', email='user1@example.com')

    user2 = User.objects.create(username='user2', email='user2@example.com')

import json

from decimal import Decimal

from unittest import mock

import eopayment

import httmock

from django.test.client import RequestFactory

from django.urls import reverse

from django.utils.encoding import force_bytes, force_text

from django.utils.timezone import now, timedelta

from requests.exceptions import ConnectionError

from requests.models import Response

    # check if regie webservice has been correctly called

    assert mock_send.call_args[0][0].method == 'GET'

    url = mock_send.call_args[0][0].url

    assert scheme == 'http'

    assert netloc == 'example.org'

    assert path == '/regie/invoices/'

    assert query['NameID'][0] == 'r2d2'

    assert query['orig'][0] == 'combo'

    assert check_query(querystring, 'combo') is True

    # check if regie webservice has been correctly called

    assert mock_send.call_args[0][0].method == 'GET'

    url = mock_send.call_args[0][0].url

    assert scheme == 'http'

    assert netloc == 'example.org'

    assert path == '/regie/invoices/history/'

    assert query['NameID'][0] == 'r2d2'

    assert query['orig'][0] == 'combo'

    assert check_query(querystring, 'combo') is True

    assert resp.status_code == 302

    location = resp.location

    assert 'dummy-payment' in location

    # get return_url and transaction id from location

    args = {'transaction_id': qs['transaction_id'][0], 'signed': True, 'ok': True, 'reason': 'Paid'}

    # make sure return url is the user return URL

    return_url = qs['return_url'][0]

    # simulate successful return URL

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

    # redirect to payment status

    assert resp.status_code == 302

    resp = resp.follow()

    # simulate successful call to callback URL

    resp = app.get(reverse('lingo-callback', kwargs={'regie_pk': remote_regie.id}), params=args)

    trans = Transaction.objects.all()

    resp = form.submit()

    assert resp.status_code == 302

    assert path == '/lingo/item/%s/%s/' % (remote_regie.id, encrypt_id)

    resp.form['invoice-number'] = 'F201601'

    resp.form['invoice-amount'] = '123.45'

    resp = resp.form.submit()

    assert path.startswith('/lingo/item/%s/' % remote_regie.id)

    resp = resp.follow()

    assert resp.status_code == 302

    location = resp.location

    assert 'dummy-payment' in location

    # get return_url and transaction id from location

    args = {'transaction_id': qs['transaction_id'][0], 'signed': True, 'ok': True, 'reason': 'Paid'}

    # make sure return url is the user return URL

    return_url = qs['return_url'][0]

        '/lingo/return-payment-backend/%s/' % remote_regie.payment_backend.id

    )

    # simulate payment failure

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

    # redirect to payment status

    assert resp.status_code == 302

    resp = resp.follow()

    assert (

        == '/active-remote-invoices-page/'

    )

    assert resp.status_code == 302

    location = resp.location

    assert 'dummy-payment' in location

    # get return_url and transaction id from location

    if can_pay_only_one_basket_item:

        assert qs['orderid'] == ['order-id-1']

        assert qs['subject'] == ['invoice-one']

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

    # redirect to payment status

    assert resp.status_code == 302

    resp = resp.follow()

    assert (

        == '/active-remote-invoices-page/'

    )

import re

import shutil

from unittest import mock

import pytest

from django.conf import settings

from django.utils.encoding import force_bytes, force_str

from django.utils.http import urlencode

from django.utils.six import BytesIO

from django.utils.timezone import now

from webtest import Upload

    assert '/admin/logout/' in resp.text

    resp = resp.click(href='/admin/logout/')

    resp = resp.follow()  # -> /logout/

def test_json_cell_syntax_validation(app, admin_user):

import os

import re

from unittest import mock

import pytest

from django.conf import settings

from django.urls import reverse

from django.utils.http import quote

from django.utils.six import StringIO

try:

    import mellon  # pylint: disable=unused-import

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

    page.save()

    resp = app.get('/index', status=301)

    resp = app.get('/', status=200)

    # check {% now %} inside a skeleton_extra_placeholder is interpreted

    with mock.patch('combo.public.views.get_idps') as get_idps:

        get_idps.return_value = ['xxx']

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

        resp = app.get('/login/?next=whatever')

def test_page_contents_group_presence(app, normal_user):

    ParentContentCell(page=page, placeholder='footer', order=0).save()

    TextCell(page=page, placeholder='footer', text='BAR2FOO', order=1).save()

    resp = app.get('/second', status=301)

    with CaptureQueriesContext(connection) as ctx:

        resp = app.get('/second/', status=200)

        assert resp.text.count('BARFOO') == 1

    assert 'Grand child of home' in resp.text

    assert (

        == '/child-home/grand-child-home/'

    )

    app.get('/grand-child-home/', status=404)

        # first visit

        app = login(app)

        resp = app.get('/', status=302)

        # visit again

        resp = app.get('/', status=200)

    with override_settings(COMBO_WELCOME_PAGE_PATH='/welcome/'):

        app.cookiejar.clear()

        resp = app.get('/', status=302)

        resp = app.get('/', status=200)

        app.cookiejar.clear()

        resp = app.get('/', status=302)

        app.cookiejar.clear()

        app = login(app)

                assert requests_post.call_args[0][0] == 'POST'

                assert requests_post.call_args[0][1] == 'http://test-post-cell/slug/create/'

                assert requests_post.call_args[1]['json'] == {'value': 'plop', 'items': ['1']}

            # check ajax call

            with mock.patch('combo.utils.requests.request') as requests_post:

            with mock.patch('combo.utils.requests.request') as requests_post:

                requests_post.return_value = mock.Mock(content=json.dumps({'err': 0}), status_code=400)

                resp2 = resp.form.submit()

                resp2 = resp2.follow()

                assert 'Error sending data.' in resp2.text

                    'error-message'

                ] = 'Failed to create stuff.'

                resp2 = resp.form.submit()

                resp2 = resp2.follow()

                assert 'Failed to create stuff.' in resp2.text

                assert requests_patch.call_args[0][0] == 'PATCH'

                assert requests_patch.call_args[0][1] == 'http://test-post-cell/slug/update/'

                assert requests_patch.call_args[1]['json'] == {'value': 'plop', 'items': ['1']}

            # check raw result

            with mock.patch('combo.utils.requests.request') as requests_search:

    redirect = Redirect(old_url='/whatever/', page=page3)

    redirect.save()

    # check the most recent redirect is called

    redirect = Redirect(old_url='/whatever/', page=page2)

    redirect.save()

    # rename page

    page3.slug = 'third2'

    page3.save()

    assert app.get('/second/third2/', status=200)

    page2.slug = 'second2'

    page2.save()

    # change parent

    page3.parent = None

    page3.save()

def test_sub_slug(app, john_doe, jane_doe):

def test_missing_trailing_slashes(app):

    # redirect to path with slash

    # don't be tricked by double slashes

def test_cell_asset_css_classes(settings, app, admin_user):

from unittest import mock

import pytest

from django.contrib.auth.models import AnonymousUser

from combo.utils import NothingInCacheException, check_query, requests

        requests.get('/foo/bar/', remote_service=remote_service)

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        assert query['orig'][0] == 'myself'

        assert query['email'][0] == ''

        assert query['NameID'][0] == ''

        requests.get('/foo/bar/', remote_service=remote_service, without_user=True)

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        assert query['orig'][0] == 'myself'

        assert 'email' not in query

        assert 'NameID' not in query

        requests.get('http://example.org/foo/bar/', remote_service='auto')

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        assert query['orig'][0] == 'combo'

        assert check_query(querystring, 'combo') is True

        requests.get('/foo/bar/', remote_service=remote_service, user=user)

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        assert query['NameID'][0] == 'r2d2'

        assert 'email' not in query

        assert query['orig'][0] == 'myself'

        requests.get('/foo/bar/', remote_service=remote_service, user=user, federation_key='email')

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        assert query['email'][0] == 'foo@example.net'

        assert 'NameID' not in query

        assert query['orig'][0] == 'myself'

        requests.get('/foo/bar/', remote_service=remote_service, user=user)

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        assert 'NameID' not in query

        assert query['email'][0] == 'foo@example.net'

        assert query['orig'][0] == 'myself'

        requests.get('/foo/bar/', remote_service=remote_service, user=user)

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        assert query['NameID'][0] == ''

        assert query['email'][0] == ''

        assert query['orig'][0] == 'myself'

import json

import re

from unittest import mock

import pytest

from django.apps import apps

from django.test.client import RequestFactory

from django.test.utils import CaptureQueriesContext

from django.urls import reverse

from pyquery import PyQuery

from requests.exceptions import ConnectionError

from requests.models import Response

def mocked_requests_send(request, **kwargs):

    data = copy.deepcopy(get_data_from_url(request_url.path))

    if not isinstance(data, list):