Produits Entr'ouvert » Combo

from django.contrib import messages

from django.http import HttpResponseRedirect

from django.views.generic import DetailView, View

from django.views.generic.detail import SingleObjectMixin

        try:

            form.is_valid()

        except ValueError as exc:

            redirect_url = '%s?%s' % (cell.page.get_online_url(), request.GET.urlencode())

            return HttpResponseRedirect(redirect_url)

        data = form.cleaned_data

    HttpResponseRedirect,

)

from django.urls import reverse

from django.views.decorators.csrf import csrf_exempt

from django.views.generic import View

from rest_framework import permissions

        return HttpResponseNotAllowed(['post'])

    try:

    except json.JSONDecodeError:

        return HttpResponseBadRequest('bad json request: "%s"' % request.body)

from django.urls import reverse

from django.utils import timezone

from django.utils.dates import WEEKDAYS

from django.utils.functional import cached_property

from django.utils.translation import gettext

from django.utils.translation import gettext_lazy as _

                    value = hours_string

                else:

                    value = _('Less than an hour')

            return format_duration

        elif measure == 'percent':

from django.template.response import TemplateResponse

from django.urls import reverse

from django.utils import dateparse

from django.utils.http import urlencode

from django.utils.translation import gettext_lazy as _

from django.views.decorators.csrf import csrf_exempt

            return HttpResponseForbidden()

        try:

        except json.JSONDecodeError:

            return BadRequestJsonResponse('bad json request: "%s"' % request.body)

            return HttpResponseForbidden()

        try:

        except json.JSONDecodeError:

            return BadRequestJsonResponse('bad json request: "%s"' % request.body)

            )

        except eopayment.ResponseError as e:

            logger.error('failed in validation operation: %s', e)

        logger.info('bank validation result: %r', result)

        operation = TransactionOperation(

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

        except eopayment.ResponseError as e:

            logger.error('failed in cancel operation: %s', e)

        logger.info('bank cancellation result: %r', result)

        operation = TransactionOperation(

                    request.method,

                    backend_response,

                )

        logger.info('lingo: received synchronous payment notification for %s', transaction)

        return HttpResponse()

        return self.handle_callback(request, request.environ['QUERY_STRING'], **kwargs)

    def post(self, request, *args, **kwargs):

    @csrf_exempt

    def dispatch(self, *args, **kwargs):

    def post(self, request, *args, **kwargs):

        return self.handle_return(

        )

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

            else:

                msg = _('Sorry, no invoice were found with that number and amount.')

        if request.GET.get('ajax') == 'on':

        if url:

            return HttpResponseRedirect(url)

        messages.warning(request, msg)

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

from django import forms

from django.utils.text import slugify

from django.utils.translation import gettext_lazy as _

            # new widget for icon field

            self.fields['icon'].widget = IconRadioSelect()

        self.fields['icon'].choices = list(

        )

        if self.instance.kind == 'geojson':

            todelete_fields = ['tiles_template_url', 'tiles_attribution', 'tiles_default']

from django.contrib.auth.models import User

from django.db import transaction

from rest_framework import authentication, permissions, serializers, status

from rest_framework.generics import GenericAPIView

from rest_framework.response import Response

                    )

                    notification_ids.append(notification.public_id)

        except ValueError as e:

            return Response(response, status.HTTP_400_BAD_REQUEST)

        data = {}

from django.db import models

from django.db.models import Q

from django.db.models.query import QuerySet

from django.utils.timezone import now, timedelta

from django.utils.translation import gettext_lazy as _

        if id:

            try:

            except Exception as e:

                raise ValueError('id must be convertible to unicode', e)

            if not re.match(cls.ID_RE, id):

from django.core.files.base import ContentFile

from django.core.files.storage import default_storage

from django.db import models

from django.utils.translation import gettext_lazy as _

from py_vapid import Vapid

            vapid = Vapid()

            vapid.generate_keys()

            self.push_notifications_infos = {

            }

        elif not self.push_notifications:

            self.push_notifications_infos = {}

        serialized_settings = json.loads(serializers.serialize('json', [obj]))

        result = serialized_settings[0].get('fields')

        if obj.application_icon:

        return result

    @classmethod

            )

        )[0]

        if self.icon:

        del serialized_entry['model']

        del serialized_entry['pk']

        return serialized_entry

from django.conf import settings

from django.http import Http404, HttpResponse, HttpResponseBadRequest, HttpResponseForbidden, JsonResponse

from django.template.loader import TemplateDoesNotExist, get_template

from django.views.decorators.csrf import csrf_exempt

from django.views.generic import TemplateView

from py_vapid import Vapid

        if settings.PWA_VAPID_PUBLIK_KEY:  # legacy

            pwa_vapid_public_key = settings.PWA_VAPID_PUBLIK_KEY

        elif hasattr(serialization.Encoding, 'X962'):

                base64.urlsafe_b64encode(

                    Vapid.from_pem(pwa_settings.push_notifications_infos['private_key'].encode('ascii'))

                    .private_key.public_key()

        return HttpResponseForbidden()

    try:

    except json.JSONDecodeError:

        return HttpResponseBadRequest('bad json request: "%s"' % request.body)

from django.conf import settings

from django.core import validators

from django.forms.widgets import TextInput

class RichTextField(ckeditor.fields.RichTextField):

def templatable_url_validator(value):

    if '{{' in value or '{%' in value:

        # leave templates alone

        return

from django.test.client import RequestFactory

from django.urls import reverse

from django.utils import timezone

from django.utils.html import strip_tags

from django.utils.safestring import mark_safe

from django.utils.text import slugify

        label = self.get_verbose_name()

        additional_label = self.get_additional_label()

        if label and additional_label:

        else:

    @classmethod

    def get_verbose_name(cls):

                )

            except requests.RequestException as e:

                extra_context[data_key + '_status'] = -1

                extra_context[data_key + '_exception'] = e

                logger = logging.getLogger(__name__)

                if log_errors:

                else:

                continue

            extra_context[data_key + '_status'] = json_response.status_code

            if json_response.status_code // 100 == 2:

    parameters = JSONField(blank=True, default=dict)

    def __str__(self):

    @classmethod

    def get_cell_types(cls):

from django.shortcuts import get_object_or_404, redirect, render

from django.template import engines

from django.urls import reverse, reverse_lazy

from django.utils.formats import date_format

from django.utils.timezone import localtime

from django.utils.translation import gettext_lazy as _

        except tarfile.TarError:

            try:

                fd.seek(0)

            except ValueError:

                form.add_error('site_file', _('File is not in the expected TAR or JSON format.'))

                return self.form_invalid(form)

            else:

                pages = import_site_tar(fd, request=self.request)

        except ImportSiteError as e:

            return self.form_invalid(form)

        else:

            for page in pages:

    json_str = json.dumps(

        [

            {

                'slug': slug,

                'url': request.build_absolute_uri(reverse('combo-manager-homepage')),

            }

from django.forms.utils import flatatt

from django.template.loader import render_to_string

from django.urls import reverse

from django.utils.html import conditional_escape

from django.utils.safestring import mark_safe

from django.utils.translation import get_language

    # Force to text to evaluate possible lazy objects

    external_plugin_resources = [

    ]

    return mark_safe(

            'ckeditor/widget.html',

            {

                'final_attrs': flatatt(final_attrs),

                'id': final_attrs['id'],

                'config': ckeditor.widgets.json_encode(self.config),

                'external_plugin_resources': ckeditor.widgets.json_encode(external_plugin_resources),

from django.template import Template, TemplateSyntaxError, defaultfilters

from django.template.defaultfilters import stringfilter

from django.utils import dateparse

from django.utils.timezone import is_naive, make_aware

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

@register.filter

def split(string, separator=' '):

@register.filter

    if not string:

        return ''

    if chars:

    else:

@register.filter

def removeprefix(string, prefix):

    if not string:

        return ''

    if prefix and value.startswith(prefix):

        return value[len(prefix) :]

    return value

def removesuffix(string, suffix):

    if not string:

        return ''

    if suffix and value.endswith(suffix):

        return value[: -len(suffix)]

    return value

@register.filter

def startswith(string, substring):

@register.filter

def endswith(string, substring):

def parse_float(value):

from django.template import engines

from django.template.loader import TemplateDoesNotExist, get_template

from django.utils import lorem_ipsum, timezone

from django.utils.http import urlencode

from django.utils.translation import gettext as _

from django.views.decorators.csrf import csrf_exempt

        except PostException as e:

            exception = e

            if not request.is_ajax():

        if action_response:

            response = HttpResponse(

    response = render_cell(request, cell)

    if exception:

    return response

from Cryptodome import Random

from Cryptodome.Cipher import AES

from Cryptodome.Protocol.KDF import PBKDF2

class DecryptionError(Exception):

    aes_key = PBKDF2(key, iv)

    aes = AES.new(aes_key, AES.MODE_CFB, iv)

    crypted = aes.encrypt(data)

def aes_hex_decrypt(key, payload, raise_on_error=True):

        return None

    aes_key = PBKDF2(key, iv)

    aes = AES.new(aes_key, AES.MODE_CFB, iv)

from django.conf import settings

from django.template import Context, Template, TemplateSyntaxError, VariableDoesNotExist

from django.utils.http import quote

            return '['

        if varname not in template_vars:

            raise TemplateError('unknown variable %s' % varname)

    return re.sub(r'(\[.+?\])', repl, url)

from django.test.client import RequestFactory

from django.test.utils import CaptureQueriesContext

from django.urls import reverse

from django.utils.timezone import now

from combo.data.library import get_cell_classes

def mock_json_response(content, **kwargs):

    content = force_bytes(content)

    return mock.Mock(content=content, text=text, json=lambda: json.loads(text), **kwargs)

            app_label = 'data'

    cells = [TextCelleWithMedia() for i in range(3)]

def test_additional_label():

from django.core.files.storage import default_storage

from django.core.management import call_command

from django.core.management.base import CommandError

from combo.apps.assets.models import Asset

from combo.apps.assets.utils import clean_assets_files

    # check with a change in icon file content

    data = json.loads(output)

    import_site(data=data)

    assert PwaSettings.objects.get().application_icon.read() == b'TEST'

    # check with a change in icon file name

    data = json.loads(output)

    data['pwa']['settings']['application_icon'] = 'pwa/test2.png'

    import_site(data=data)

    assert os.path.basename(PwaSettings.objects.get().application_icon.file.name) == 'test2.png'

    # check with a change in icon file content

    data = json.loads(output)

    import_site(data=data)

    assert PwaNavigationEntry.objects.all().count() == 2

    assert PwaNavigationEntry.objects.get(order=1).icon.read() == b'TEST'

    # check with a change in icon file name

    data = json.loads(output)

    data['pwa']['navigation'][1]['fields']['icon'] = 'pwa/test2.png'

    import_site(data=data)

    assert PwaNavigationEntry.objects.all().count() == 2

    assert os.path.basename(PwaNavigationEntry.objects.get(order=1).icon.file.name) == 'test2.png'

from django.test import override_settings

from django.test.client import RequestFactory

from django.urls import reverse

from django.utils.timezone import now, timedelta

from requests.exceptions import ConnectionError

from requests.models import Response

    assert 'item' in form.fields

    assert form['item'].value == 'F201601'

    assert 'regie' in form.fields

    form['email'] = 'ghost@buster.com'

    assert 'item' in form.fields

    assert form['item'].value == 'F201601'

    assert 'regie' in form.fields

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

    resp = form.submit()

from django.test import Client

from django.test.client import RequestFactory

from django.urls import reverse

from django.utils.timezone import now

from mellon.models import UserSAMLIdentifier

    def notify(data, count, check_id=None):

        resp = client.post(reverse('api-notification-add'), json.dumps(data), content_type='application/json')

        assert resp.status_code == 200

        assert result['err'] == 0

        if 'id' in data:

            assert check_id is not None and result['data']['id'] == check_id

    resp = client.get(reverse('api-notification-count'))

    assert resp.status_code == 200

    resp = client.get(reverse('api-notification-ack', kwargs={'notification_id': '%s' % (notif_id - 5)}))

    resp = client.get(reverse('api-notification-count'))

    assert resp.status_code == 200

    resp = client.get(reverse('api-notification-forget', kwargs={'notification_id': '%s' % (notif_id - 5)}))

    resp = client.get(reverse('api-notification-count'))

    assert resp.status_code == 200

def test_notification_ws_badrequest(john_doe):

            content_type='application/json',

        )

        assert resp.status_code == 400

        assert result['err'] == 1

        assert message in list(result['err_desc'].values())[0][0]

    def notify(data):

        resp = client.post(reverse('api-notification-add'), json.dumps(data), content_type='application/json')

    result = notify({'summary': 'foo', 'id': '1'})

    assert result['err'] == 1