Produits Entr'ouvert » Combo

# Generated by Django 1.11.12 on 2018-06-12 11:42

from django.db import migrations, models

from django.db import migrations, models

            asset = asset_object

            break

            try:

                asset = Asset.objects.get(key=asset_object).asset

                break

from .models import Asset

    def __init__(self, filepath):

        self.filepath = filepath

        self.name = os.path.basename(filepath)

        return ckeditor.views.is_image(self.src)

    def __init__(self, key=None, name=None, asset_type='image', asset=None):

        self.key = key

        self.name = name

    @classmethod

    def get_assets(cls):

        uniq_slots = {}

        uniq_slots.update(settings.COMBO_ASSET_SLOTS)

        cells = CellBase.get_cells(select_related={'__all__': ['page'], 'data_linkcell': ['link_page']})

        return files

    def get_context_data(self, **kwargs):

        context['query'] = self.request.GET.get('q') or ''

        return context

        ckeditor_upload_view = ckeditor.views.ImageUploadView()

        self.request.GET = {'CKEditorFuncNum': '-'}  # hack

        ckeditor_upload_view.post(self.request)

    def get_success_url(self):

        return Assets(request=self.request).get_anchored_url(name=self.request.FILES['upload'].name)

                self.request,

                _('You have to upload a file with the same extension (%(ext)s).') % {'ext': ext_orig},

            )

        default_storage.delete(img_orig)

        if getattr(settings, 'CKEDITOR_IMAGE_BACKEND', None):

        else:

            if backend.should_create_thumbnail(saved_path):

                backend.create_thumbnail(saved_path)

    def get_success_url(self):

        img_orig = self.request.GET['img']

    def get_assets(self, cell):

        asset_slots = cell.get_asset_slots()

        for key, value in asset_slots.items():

            yield SlotAsset(

                key,

            self.asset = Asset(key=self.kwargs['key'])

        self.asset.asset = self.request.FILES['upload']

        self.asset.save()

    def get_success_url(self):

        if self.request.GET.get('cell_reference'):

            import_assets(form.cleaned_data['assets_file'], overwrite)

        except tarfile.TarError:

            messages.error(self.request, _('The assets file is not valid.'))

        messages.success(self.request, _('The assets file has been imported.'))

assets_import = AssetsImport.as_view()

    template_name = 'combo/manager_assets_export_size.html'

    def get_context_data(self, **kwargs):

        media_prefix = default_storage.path('')

        computed_size = 0

        for basedir, dirnames, filenames in os.walk(media_prefix):

        )

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

        agenda_references = get_agendas()

        formdef_references = get_wcs_options('/api/formdefs/')

        self.fields['agenda_reference'].widget = forms.Select(choices=agenda_references)

class BookingForm(forms.Form):

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

        self.cell = kwargs.pop('cell')

        self.cleaned_data = {}

    def is_valid(self):

import datetime

from django.db import migrations, models

from django.db import migrations, models

        return settings.BOOKING_CALENDAR_CELL_ENABLED and is_chrono_enabled() and is_wcs_enabled()

    def is_visible(self, **kwargs):

    def get_cell_extra_context(self, context):

        if context.get('placeholder_search_mode'):

            return {}

        events_data = get_chrono_events(self.agenda_reference, not (context.get('synchronous')))

        extra_context.update(

            get_calendar_context_vars(context['request'], extra_context['cell'], events_data)

    return url

    def __init__(self, date_time, available, exist=True):

        self.date_time = localtime(make_aware(date_time))

        self.available = available

        return '%s' % self.date_time.isoformat()

    def __init__(self, date):

        self.date = date

        self.slots = []

        return max(self.slots, key=lambda x: x.date_time.time())

    def __init__(self, offset, days_displayed, min_duration):

        self.offset = offset

        self.days_displayed = days_displayed

        return day.get_slot(slot.time())

    def get_minimum_slot(self):

    def get_maximum_slot(self):

    template_name = 'calendar/booking_calendar_content.html'

    def get_context_data(self, **kwargs):

        context['cell'] = self.object

        events_data = get_chrono_events(self.object.agenda_reference, context.get('synchronous'))

        context.update(get_calendar_context_vars(self.request, self.object, events_data))

from django.conf import settings

from django.db import migrations, models

from django.db import migrations, models

            for x in ValidityInfo.objects.filter(invalid_since__lt=now() - datetime.timedelta(days=2))

        }

        context['tiles'] = [x for x in tiles if (x.cell_type_id, x.cell_pk) not in validity_info_dict]

class Tile(models.Model):

def dashboard_reorder_tiles(request, *args, **kwargs):

    dashboard = DashboardCell.objects.filter(page__snapshot__isnull=True)[0]

    new_order = request.GET['order'].split(',')

    for i, tile_id in enumerate(new_order):

        tile = tiles.get(tile_id)

        if tile.user != request.user:

        fields = ('title', 'url')

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

        available_charts = []

        for site_key, site_dict in settings.KNOWN_SERVICES.get('bijoe').items():

            result = requests.get(

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

import datetime

from django.db import migrations, models

# Generated by Django 1.11.12 on 2019-03-28 07:57

from django.db import migrations

# Generated by Django 1.11.12 on 2019-06-17 10:14

from django.db import migrations, models

# Generated by Django 1.11.12 on 2019-03-28 10:11

import django.db.models.deletion

from django.contrib.postgres.fields import JSONField

# Generated by Django 1.11.18 on 2020-08-13 09:00

from django.db import migrations, models

# Generated by Django 1.11.29 on 2020-11-26 14:57

import django.db.models.deletion

from django.db import migrations, models

        ),

        migrations.AlterUniqueTogether(

            name='statistic',

        ),

        migrations.AddField(

            model_name='chartngcell',

# Generated by Django 1.11.29 on 2020-11-30 14:26

from django.conf import settings

from django.db import migrations

# Generated by Django 1.11.29 on 2020-11-30 14:34

from django.db import migrations

# Generated by Django 1.11.29 on 2020-12-02 13:24

from django.contrib.postgres.fields import JSONField

from django.db import migrations

# Generated by Django 1.11.29 on 2020-12-15 15:24

from django.db import migrations, models

        return ''

    def get_cell_extra_context(self, context):

        context['title'] = self.title

        context['url'] = self.url

        return context

        )

    def get_cell_extra_context(self, context):

        if self.chart_type == 'table' and self.statistic and self.statistic.url:

            try:

                chart = self.get_chart(raise_if_not_cached=not (context.get('synchronous')))

            tmp_items = sorted(zip(chart.x_labels, data), key=lambda x: (x[1] or 0))

        elif self.sort_order == 'desc':

            tmp_items = sorted(zip(chart.x_labels, data), key=lambda x: (x[1] or 0), reverse=True)

        chart.x_labels = list(x_labels)

        return list(sorted_data)

            return format_duration

        elif measure == 'percent':

            return percent_formatter

    def make_percent(self, series_data):

        for i, values in enumerate(zip(*series_data)):

            if sum_values == 0:

                continue

            # "W" and "o" are interpreted by Django's date filter and should be left as is. First W is

            # backslash escaped to prevent it from being interpreted, translators should refer to Django's

            # documentation in order to know if the new letter resulting of translation should be escaped or not.

            '_month': 'm-Y',

            '_year': 'Y',

            '_weekday': 'l',

import ckeditor.fields

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

import datetime

from django.db import migrations, models

            messages.error(self.request, error_message)

        else:

            messages.info(self.request, _('Your account was successfully linked.'))

class FamilyUnlinkView(TemplateView):

from django.db import migrations, models

from django.db import migrations, models

import datetime

from django.db import migrations, models

from django.db import migrations, models

        user = kwargs.get('user')

        if not user or user.is_anonymous:

            return False

    @classmethod

    def is_enabled(cls):

    def render(self, context):

        context.update(self.get_json('api/documents/recently-added/', context))

def get_fargo_services():

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

        form.instance.gallery_id = self.kwargs.get('gallery_pk')

        other_images = form.instance.gallery.image_set.all()

        if other_images:

        else:

            form.instance.order = 0

    def get_success_url(self):

        return (

# Generated by Django 1.11.18 on 2020-01-31 15:40

import django.db.models.deletion

from django.db import migrations, models

# Generated by Django 1.11.17 on 2020-02-03 10:37

from django.db import migrations, models

        verbose_name = _('Latest Page Updates')

    def get_cell_extra_context(self, context):

        if self.root_page:

            pages = self.root_page.get_descendants_and_me()

        else:

        ]

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

        fields, initial = create_form_fields(

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

            self.instance.transaction_options,

        self.initial.update(initial)

    def save(self):

        instance.transaction_options = compute_json_field(

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

        )

        fields = ['label', 'slug', 'service']

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

        fields, initial = create_form_fields(

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

        )

            self.fields['service'].disabled = True

    def save(self):

        instance.service_options = compute_json_field(

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

        )

    )

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

        today = datetime.date.today()

        self.initial['start_date'] = today - datetime.timedelta(days=30)

        self.initial['end_date'] = today

#

# lingo - basket and payment system

# Copyright (C) 2018  Entr'ouvert

    paginate_by = 10

    def get_context_data(self, **kwargs):

        context['query'] = self.request.GET.get('q') or ''

        return context

    paginate_by = 10

    def get_context_data(self, **kwargs):

        context['query'] = self.request.GET.get('q') or ''

        return context

from django.conf import settings

from django.contrib.postgres.fields import JSONField

from django.db import migrations, models

from django.contrib.postgres.fields import JSONField

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.conf import settings

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

import ckeditor.fields

from django.db import migrations, models

from django.conf import settings

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

import ckeditor.fields

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.contrib.postgres.fields import JSONField

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

import ckeditor.fields

from django.db import migrations, models

from django.conf import settings

from django.db import migrations, models

from django.db import migrations, models

import datetime

from django.db import migrations, models

from django.db import migrations, models

import combo.data.fields

from django.contrib.postgres.fields import JSONField

from django.db import migrations, models

from django.db import migrations, models

# Generated by Django 1.11.8 on 2018-01-31 14:24

from django.db import migrations, models

# Generated by Django 1.11.15 on 2018-10-05 15:33

from django.db import migrations, models

from django.db import migrations, models

# Generated by Django 1.11.18 on 2019-04-26 09:59

import django.db.models.deletion

from django.contrib.postgres.fields import JSONField

# Generated by Django 1.11.18 on 2019-04-26 09:24

from django.db import migrations

# Generated by Django 1.11.18 on 2019-04-26 10:02

import django.db.models.deletion

from django.db import migrations, models

# Generated by Django 1.11.18 on 2019-05-14 12:02

from django.contrib.postgres.fields import JSONField

from django.db import migrations, models

# Generated by Django 1.11.18 on 2020-03-31 13:12

from django.db import migrations, models

# Generated by Django 1.11.29 on 2020-04-03 20:19

from django.db import migrations, models

# Generated by Django 1.11.18 on 2020-06-08 10:22

from django.db import migrations, models

# Generated by Django 1.11.18 on 2020-10-01 11:53

from django.db import migrations, models

#

# lingo - basket and payment system

# Copyright (C) 2015  Entr'ouvert

class UnsignedPaymentException(PaymentException):

    def __init__(self, transaction, *args, **kwargs):

        self.transaction = transaction

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

        options = self.service_options or {}

            # backward compatibility when used againt postgresql < 9.4 and

            # service_options is received as a string.

            try:

            qs.update(is_default=False)

        elif not self.__class__.objects.filter(is_default=True).exists():

            self.is_default = True

    def natural_key(self):

        return (self.slug,)

        return reverse('basket-item-pay-view', kwargs={'item_signature': signature})

    payment_date = None

    def __init__(

    @classmethod

    def transactions_for_remote_items(cls, queryset, remote_items):

        if not remote_item_ids:

            return Transaction.objects.none()

                    'unable to notify payment for remote item %s from transaction %s', item_id, self

                )

            else:

                subject = _('Invoice #%s') % remote_item.display_id

                local_item = BasketItem.objects.create(

                    user=self.user,

        items = BasketItem.get_items_to_be_paid(context['request'].user)

        if not items:

            return

        if total == int(total):

            total = int(total)

    def render(self, context):

        basket_template = template.loader.get_template('lingo/combo/basket.html')

            regies[item.regie_id]['items'].append(item)

        for items in regies.values():

        context['regies'] = sorted(regies.values(), key=lambda x: x['regie'].label)

        return basket_template.render(context)

            return ''

        basket_template = template.loader.get_template('lingo/combo/basket_link.html')

        context['items'] = BasketItem.get_items_to_be_paid(user=context['request'].user)

        return basket_template.render(context)

        return [], []

    def get_cell_extra_context(self, context):

        if context.get('placeholder_search_mode'):

            # don't call webservices when we're just looking for placeholders

            return ctx

        self.context = context

        if not context.get('synchronous'):

            raise NothingInCacheException()

@register_cell_class

    def render(self, context):

        context['synchronous'] = True

        context['page_path'] = context['request'].path

TIPI_CONTROL_PROCOTOLS = (

        return getattr(settings, 'LINGO_TIPI_CELL_PAYMENT_URL', 'https://www.payfip.gouv.fr/tpa/paiement.web')

    def get_cell_extra_context(self, context):

        form_fields = self.get_default_form_class().base_fields

        field_definitions = (

            {'protocol': 'any', 'fields': ['exer']},

# lingo - basket and payment system

# Copyright (C) 2020  Entr'ouvert

#

class LocaleDecimal(Decimal):

    # accept , instead of . for French users comfort

    def __new__(cls, value="0", *args, **kwargs):

            value = value.replace(',', '.')

class RegiesApiView(ListView):

    @csrf_exempt

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

    def get_amount(self, amount):

        if isinstance(amount, list):

        else:

            d = LocaleDecimal(amount)

        return d.quantize(Decimal('0.01'), ROUND_HALF_UP)

    @csrf_exempt

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

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

        if not lingo_check_request_signature(request):

    @csrf_exempt

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

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

        if not lingo_check_request_signature(request):

            transaction = Transaction.objects.get(id=request.GET['transaction_id'])

        except Transaction.DoesNotExist:

            logger.warning(

            )

            raise Http404

        amount = LocaleDecimal(request.GET['amount'])

        try:

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

                amount, transaction.bank_data

            )

        except eopayment.ResponseError as e:

            return JsonResponse({'err': 1, 'e': force_text(e)})

        operation = TransactionOperation(

            transaction=transaction, kind='validation', amount=amount, bank_result=result

        )

    @csrf_exempt

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

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

        if not lingo_check_request_signature(request):

            transaction = Transaction.objects.get(id=request.GET['transaction_id'])

        except Transaction.DoesNotExist:

            logger.warning(

            )

            raise Http404

        amount = LocaleDecimal(request.GET['amount'])

        try:

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

        except eopayment.ResponseError as e:

            return JsonResponse({'err': 1, 'e': force_text(e)})

        operation = TransactionOperation(

            transaction=transaction, kind='cancellation', amount=amount, bank_result=result

        )

        return JsonResponse({'err': 0, 'extra': result})

    @atomic

    def handle_payment(

        self, request, regie, items, remote_items, next_url='/', email='', firstname='', lastname=''

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

            return HttpResponseRedirect(next_url)

        if total_amount < regie.payment_min_amount:

            return HttpResponseRedirect(

                get_payment_status_view(next_url=next_url if remote_items else items[0].source_url)

            )

        for item in items:

            if item.regie != regie:

                return HttpResponseRedirect(next_url)

        user = request.user if request.user.is_authenticated else None

        transaction = Transaction()

            messages.error(request, _('Failed to initiate payment request'))

            return HttpResponseRedirect(get_payment_status_view(next_url=next_url))

        logger.info(

            smart_text(order_id),

            extra={'eopayment_order_id': smart_text(order_id), 'eopayment_data': repr(data)},

        )

                for item_id in request.POST.getlist('item'):

                    remote_items.append(regie.get_invoice(user, item_id, update_paid=True))

            except (requests.exceptions.RequestException, RemoteInvoiceException):

                return HttpResponseRedirect(next_url)

            except ObjectDoesNotExist:

                return HttpResponseRedirect(next_url)

        else:

            if user is None:

                return HttpResponseRedirect(next_url)

            if not regie_id:

                regie_id = items[0].regie_id

                for item in items:

                    if item.regie_id != regie_id:

                        return HttpResponseRedirect(next_url)

            regie = Regie.objects.get(id=regie_id)

            capture_date = items[0].capture_date

            for item in items:

                if item.capture_date != capture_date:

                    return HttpResponseRedirect(next_url)

        if user:

            # user is not authenticated, it comes from ItemCell where an email

            # can be given in the payment form.

            if not request.POST.get('email'):

                return HttpResponseRedirect(request.POST.get('item_url'))

            email = request.POST.get('email')

            raise Http404("A payment backend or regie primary key or slug must be specified")

        payment = payment_backend.make_eopayment(request=request)

        try:

            eopayment_response_kwargs = {'redirect': not callback}

            if transaction is not None:

            payment_response = payment.response(backend_response, **eopayment_response_kwargs)

        except eopayment.PaymentException as e:

            logger.error(

                e,

                extra={'eopayment_raw_response': repr(backend_response)},

            )

    @csrf_exempt

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

class ReturnView(PaymentView):

    @csrf_exempt

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

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

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

class ItemDownloadView(View):

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

        try:

class ItemView(TemplateView):

    def get_context_data(self, **kwargs):

        ret = {'item_url': self.request.get_full_path()}

    template_name = 'lingo/combo/cancel-item.html'

    def get_context_data(self, **kwargs):

        context['basket_url'] = get_basket_url()

        return context

    @csrf_exempt

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

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

        try:

        next_url = request.session.get('lingo_next_url', {}).get(str(transaction_id))

        if not next_url:

            next_url = get_basket_url()

                next_url = transaction.items.first().source_url

        next_url = request.build_absolute_uri(next_url)

        }

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

        if self.instance.pk is None:

            # new instance, delete some fields

            del self.fields['slug']

                del self.fields[field]

    def clean(self):

        if self.instance.kind == 'tiles' and cleaned_data.get('tiles_default') is True:

            if MapLayer.objects.filter(kind='tiles', tiles_default=True).exclude(pk=self.instance.pk):

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

        self.kind = kwargs.pop('kind')

        # if edition, no possibility to change the layer

        if self.instance.pk:

            del self.fields['map_layer']

from .models import Map, MapLayer, MapLayerOptions

    model = MapLayer

    success_url = reverse_lazy('maps-manager-homepage')

    ordering = ['kind', 'label']

    def get_context_data(self, **kwargs):

        context['map_list'] = Map.objects.all()

        return context

    template_name = 'maps/map_layer_form.html'

    def get_form_kwargs(self):

        kwargs['instance'] = self.model(kind=self.kwargs['kind'])

        return kwargs

            self.cell = CellBase.get_cell(kwargs['cell_reference'], page=kwargs['page_pk'])

        except Map.DoesNotExist:

            raise Http404

    def get_form_kwargs(self):

        kwargs['instance'] = MapLayerOptions(map_cell=self.cell)

        kwargs['kind'] = self.kwargs['kind']

        return kwargs

            comment=_('added layer "%(layer)s" to cell "%(cell)s"')

            % {'layer': form.instance.map_layer, 'cell': self.cell},

        )

    def get_success_url(self):

        return '%s#cell-%s' % (

        except Map.DoesNotExist:

            raise Http404

        self.object = get_object_or_404(MapLayerOptions, pk=kwargs['layeroptions_pk'], map_cell=self.cell)

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

        return self.object

    def get_form_kwargs(self):

        kwargs['kind'] = self.object.map_layer.kind

        return kwargs

            comment=_('changed options of layer "%(layer)s" in cell "%(cell)s"')

            % {'layer': form.instance.map_layer, 'cell': self.cell},

        )

    def get_success_url(self):

        return '%s#cell-%s' % (

        except Map.DoesNotExist:

            raise Http404

        self.object = get_object_or_404(MapLayerOptions, pk=kwargs['layeroptions_pk'], map_cell=self.cell)

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

        return self.object

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

        PageSnapshot.take(

            self.cell.page,

            request=self.request,

from django.db import migrations, models

from combo.apps.maps.models import ICONS

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

# Generated by Django 1.11.12 on 2018-07-06 11:45

from django.db import migrations, models

import django.db.models.deletion

from django.db import migrations, models

                ),

                migrations.AlterUniqueTogether(

                    name='maplayeroptions',

                ),

            ],

            database_operations=[],

# Generated by Django 1.11.18 on 2020-02-07 09:00

from django.db import migrations, models

import django.core.validators

from django.db import migrations, models

from django.db import migrations