Produits Entr'ouvert » Chrono

    pricings = models.ManyToManyField(

        'pricing.Pricing',

        related_name='agendas',

        through='pricing.AgendaPricing',

    )

            agenda['pricings'] = [x.export_json() for x in self.agendapricing_set.all()]

            pricings = data.pop('pricings', None) or []

        if data['kind'] == 'events' and pricings:

            from chrono.pricing.models import Pricing

            for pricing_data in pricings:

                try:

                    pricing_data['pricing'] = Pricing.objects.get(slug=pricing_data['pricing'])

                except Pricing.DoesNotExist:

                    raise AgendaImportError(_('Missing "%s" pricing model') % pricing_data['pricing'])

                agenda.agendapricing_set.all().delete()

            for pricing_data in pricings:

                from chrono.pricing.models import AgendaPricing

                pricing_data['agenda'] = agenda

                AgendaPricing.import_json(pricing_data)

    pricing = models.DecimalField(

        _('Pricing'), max_digits=5, decimal_places=2, help_text=_('Fixed pricing'), blank=True, null=True

    )

    pricing_rate = models.PositiveIntegerField(

        _('Pricing rate'), help_text=_('Percentage rate'), blank=True, null=True

    )

class NewCheckTypeForm(forms.ModelForm):

        fields = ['label', 'kind', 'pricing', 'pricing_rate']

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

        super().__init__(*args, **kwargs)

        if not settings.CHRONO_ENABLE_PRICING:

            del self.fields['pricing']

            del self.fields['pricing_rate']

    def clean(self):

        super().clean()

        if self.cleaned_data.get('pricing') is not None and self.cleaned_data.get('pricing_rate') is not None:

            raise ValidationError(_('Please choose between pricing and pricing rate.'))

class CheckTypeForm(NewCheckTypeForm):

    class Meta:

        model = CheckType

        fields = ['label', 'slug', 'pricing', 'pricing_rate', 'disabled']

    pricing_categories = forms.BooleanField(

        label=_('Pricing criteria categories'), required=False, initial=True

    )

    pricing_models = forms.BooleanField(label=_('Pricing models'), required=False, initial=True)

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

        super().__init__(*args, **kwargs)

        if not settings.CHRONO_ENABLE_PRICING:

            del self.fields['pricing_categories']

            del self.fields['pricing_models']

div.paragraph {

	background: white;

	box-sizing: border-box;

	border: 1px solid #386ede;

	border-radius: 3px;

	max-width: 100%;

	padding: 5px 15px;

	margin-bottom: 1rem;

	h4 {

		margin-top: 5px;

		border-bottom: none;

	}

}

.sortable {

	span.handle {

		cursor: move;

		display: inline-block;

		padding: 0.5ex;

		text-align: center;

		width: 2em;

		height: 100%;

		box-sizing: border-box;

        font-weight: normal;

	}

}

ul.objects-list.sortable {

	li {

		position: relative;

		& > a {

			display: inline-block;

		}

	}

}

  $(document).on('click', '#add-pricing-variable-form', function() {

    if (typeof property_forms === "undefined") {var property_forms = $('.pricing-variable-form');}

    if (typeof total_forms === "undefined") {var total_form = $('#id_form-TOTAL_FORMS');}

    if (typeof form_num === "undefined") {var form_num = property_forms.length - 1;}

    var new_form = $(property_forms[0]).clone();

    var form_regex = RegExp(`form-(\\d){1}-`,'g');

    form_num++;

    new_form.html(new_form.html().replace(form_regex, `form-${form_num}-`));

    new_form.appendTo('#pricing-variable-forms tbody');

    $('#id_form-' + form_num + '-key').val('');

    $('#id_form-' + form_num + '-value').val('');

    total_form.val(form_num + 1);

  })

  $('.sortable').sortable({

    handle: '.handle',

    items: '.sortable-item',

    update : function(event, ui) {

      var new_order = '';

      $(this).find('.sortable-item').each(function(i, x) {

        var item_id = $(x).data('item-id');

        if (new_order) {

          new_order += ',';

        }

        new_order += item_id;

      });

      $.ajax({

        url: $(this).data('order-url'),

        data: {'new-order': new_order}

      });

    }

  });

  {% if pricing_enabled %}

  <a rel="popup" href="{% url 'chrono-manager-agenda-pricing-add' pk=object.id %}">{% trans 'New pricing' %}</a>

  {% endif %}

{% if pricing_enabled %}

<div class="section">

<h3>{% trans "Pricing" context 'pricing' %}</h3>

<div>

  {% if agenda_pricings %}

  <ul class="objects-list single-links">

  {% for agenda_pricing in agenda_pricings %}

    <li><a href="{% url 'chrono-manager-agenda-pricing-detail' agenda.pk agenda_pricing.pk %}">{{ agenda_pricing.pricing }} ({{ agenda_pricing.date_start|date:'d/m/Y' }} - {{ agenda_pricing.date_end|date:'d/m/Y' }})</a></li>

  {% endfor %}

  </ul>

  {% else %}

  <div class="big-msg-info">

    {% blocktrans %}

    This agenda doesn't have any pricing defined yet. Click on the "New pricing" button in

    the top right of the page to add a first one.

    {% endblocktrans %}

  </div>

  {% endif %}

</div>

</div>

{% endif %}

    {% if pricing_enabled %}

    <li><a href="{% url 'chrono-manager-pricing-list' %}">{% trans 'Pricing' context 'pricing' %}</a></li>

    {% endif %}

from chrono.pricing.models import CriteriaCategory, Pricing

    pricing_categories=True,

    pricing_models=True,

    if pricing_models:

        data['pricing_models'] = [x.export_json() for x in Pricing.objects.all()]

    if pricing_categories:

        data['pricing_categories'] = [x.export_json() for x in CriteriaCategory.objects.all()]

        or CriteriaCategory.objects.exists()

        or Pricing.objects.exists()

        CriteriaCategory.objects.all().delete()

        Pricing.objects.all().delete()

            'pricing_categories',

            'pricing_models',

            (CriteriaCategory, 'pricing_categories'),

            (Pricing, 'pricing_models'),

from django.conf import settings

from chrono.pricing.models import AgendaPricing

    NewCheckTypeForm,

        context['pricing_enabled'] = settings.CHRONO_ENABLE_PRICING

    form_class = NewCheckTypeForm

            'pricing_categories': {

                'create_noop': _('No pricing criteria category created.'),

                'create': lambda x: ungettext(

                    'A pricing criteria category has been created.',

                    '%(count)d pricing criteria categories have been created.',

                    x,

                ),

                'update_noop': _('No pricing criteria category updated.'),

                'update': lambda x: ungettext(

                    'A pricing criteria category has been updated.',

                    '%(count)d pricing criteria categories have been updated.',

                    x,

                ),

            },

            'pricing_models': {

                'create_noop': _('No pricing model created.'),

                'create': lambda x: ungettext(

                    'A pricing model has been created.',

                    '%(count)d pricing models have been created.',

                    x,

                ),

                'update_noop': _('No pricing model updated.'),

                'update': lambda x: ungettext(

                    'A pricing model has been updated.',

                    '%(count)d pricing models have been updated.',

                    x,

                ),

            },

        a_count, uc_count, arg_count, pc_count, pm_count = (

            len(results['pricing_categories']['all']),

            len(results['pricing_models']['all']),

        if (a_count, uc_count, arg_count, pc_count, pm_count) == (1, 0, 0, 0, 0):

        if (a_count, uc_count, arg_count, pc_count, pm_count) == (0, 1, 0, 0, 0):

        if (a_count, uc_count, arg_count, pc_count, pm_count) == (0, 0, 1, 0, 0):

        if (a_count, uc_count, arg_count, pc_count, pm_count) == (0, 0, 0, 1, 0):

            # only one criteria category imported, redirect to criteria page

            return HttpResponseRedirect(reverse('chrono-manager-pricing-criteria-list'))

        if (a_count, uc_count, arg_count, pc_count, pm_count) == (0, 0, 0, 0, 1):

            # only one pricing imported, redirect to pricing page

            return HttpResponseRedirect(

                reverse(

                    'chrono-manager-pricing-detail',

                    kwargs={'pk': results['pricing_models']['all'][0].pk},

                )

            )

            messages.info(self.request, results['pricing_categories']['messages'])

            messages.info(self.request, results['pricing_models']['messages'])

            context['pricing_enabled'] = settings.CHRONO_ENABLE_PRICING

            context['agenda_pricings'] = (

                AgendaPricing.objects.filter(agenda=self.agenda)

                .select_related('pricing')

                .order_by('date_start', 'date_end')

            )

# chrono - agendas system

# Copyright (C) 2022  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# 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/>.

from django import forms

from django.forms import ValidationError

from django.template import Template, TemplateSyntaxError

from django.utils.translation import ugettext_lazy as _

from chrono.pricing.models import AgendaPricing, Criteria, CriteriaCategory

class NewCriteriaForm(forms.ModelForm):

    class Meta:

        model = Criteria

        fields = ['label', 'condition']

    def clean_condition(self):

        condition = self.cleaned_data['condition']

        try:

            Template('{%% if %s %%}OK{%% endif %%}' % condition)

        except TemplateSyntaxError:

            raise ValidationError(_('Invalid syntax.'))

        return condition

class CriteriaForm(NewCriteriaForm):

    class Meta:

        model = Criteria

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

    def clean_slug(self):

        slug = self.cleaned_data['slug']

        if self.instance.category.criterias.filter(slug=slug).exclude(pk=self.instance.pk).exists():

            raise ValidationError(_('Another criteria exists with the same identifier.'))

        return slug

class PricingDuplicateForm(forms.Form):

    label = forms.CharField(label=_('New label'), max_length=150, required=False)

class PricingVariableForm(forms.Form):

    key = forms.CharField(label=_('Variable name'), required=False)

    value = forms.CharField(

        label=_('Value template'), widget=forms.TextInput(attrs={'size': 60}), required=False

    )

PricingVariableFormSet = forms.formset_factory(PricingVariableForm)

class PricingCriteriaCategoryAddForm(forms.Form):

    category = forms.ModelChoiceField(

        label=_('Criteria category to add'), queryset=CriteriaCategory.objects.none(), required=True

    )

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

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

        super().__init__(*args, **kwargs)

        self.fields['category'].queryset = CriteriaCategory.objects.exclude(pricings=self.pricing)

class PricingCriteriaCategoryEditForm(forms.Form):

    criterias = forms.ModelMultipleChoiceField(

        label=_('Criterias'),

        queryset=Criteria.objects.none(),

        required=True,

        widget=forms.CheckboxSelectMultiple(),

    )

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

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

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

        super().__init__(*args, **kwargs)

        self.fields['criterias'].queryset = self.category.criterias.all()

        self.initial['criterias'] = self.pricing.criterias.filter(category=self.category)

class AgendaPricingForm(forms.ModelForm):

    class Meta:

        model = AgendaPricing

        fields = ['pricing', 'date_start', 'date_end']

        widgets = {

            'date_start': forms.DateInput(attrs={'type': 'date'}, format='%Y-%m-%d'),

            'date_end': forms.DateInput(attrs={'type': 'date'}, format='%Y-%m-%d'),

        }

    def clean(self):

        cleaned_data = super().clean()

        if 'date_start' in cleaned_data and 'date_end' in cleaned_data:

            if cleaned_data['date_end'] <= cleaned_data['date_start']:

                self.add_error('date_end', _('End date must be greater than start date.'))

            else:

                overlapping_qs = AgendaPricing.objects.filter(agenda=self.instance.agenda,).extra(

                    where=["(date_start, date_end) OVERLAPS (%s, %s)"],

                    params=[cleaned_data['date_start'], cleaned_data['date_end']],

                )

                if self.instance.pk:

                    overlapping_qs = overlapping_qs.exclude(pk=self.instance.pk)

                if overlapping_qs.exists():

                    raise forms.ValidationError(_('Pricing overlaps existing pricings.'))

        return cleaned_data

class PricingMatrixForm(forms.Form):

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

        matrix = kwargs.pop('matrix')

        super().__init__(*args, **kwargs)

        for i in range(len(matrix.rows[0].cells)):

            self.fields['crit_%i' % i] = forms.DecimalField(required=True, max_digits=5, decimal_places=2)

# chrono - agendas system

# Copyright (C) 2022  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

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

import dataclasses

import decimal

from typing import List

from django.contrib.postgres.fields import JSONField

from django.db import models

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

from django.utils.text import slugify

from django.utils.translation import ugettext_lazy as _

from chrono.agendas.models import Agenda, Booking, Subscription

from chrono.utils.misc import AgendaImportError, clean_import_data, generate_slug

class PricingError(Exception):

    def __init__(self, details=None):

        self.details = details or {}

        super().__init__()

class AgendaPricingNotFound(PricingError):

    pass

class CriteriaConditionNotFound(PricingError):

    pass

class PricingDataError(PricingError):

    pass

class PricingDataFormatError(PricingError):

    pass

class PricingEventNotCheckedError(PricingError):

    pass

class PricingBookingNotCheckedError(PricingError):

    pass

class PricingSubscriptionError(PricingError):

    pass

class PricingMultipleBookingError(PricingError):

    pass

class PricingBookingCheckTypeError(PricingError):

    pass

class CriteriaCategory(models.Model):

    label = models.CharField(_('Label'), max_length=150)

    slug = models.SlugField(_('Identifier'), max_length=160, unique=True)

    class Meta:

        ordering = ['label']

    def __str__(self):

        return self.label

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

        if not self.slug:

            self.slug = generate_slug(self)

        super().save(*args, **kwargs)

    @property

    def base_slug(self):

        return slugify(self.label)

    @classmethod

    def import_json(cls, data, overwrite=False):

        criterias = data.pop('criterias', [])

        data = clean_import_data(cls, data)

        category, created = cls.objects.update_or_create(slug=data['slug'], defaults=data)

        if overwrite:

            Criteria.objects.filter(category=category).delete()

        for criteria in criterias:

            criteria['category'] = category

            Criteria.import_json(criteria)

        return created, category

    def export_json(self):

        return {

            'label': self.label,

            'slug': self.slug,

            'criterias': [a.export_json() for a in self.criterias.all()],

        }

class Criteria(models.Model):

    category = models.ForeignKey(

        CriteriaCategory, verbose_name=_('Category'), on_delete=models.CASCADE, related_name='criterias'

    )

    label = models.CharField(_('Label'), max_length=150)

    slug = models.SlugField(_('Identifier'), max_length=160)

    condition = models.CharField(_('Condition'), max_length=1000)

    order = models.PositiveIntegerField()

    class Meta:

        ordering = ['order']

        unique_together = ['category', 'slug']

    def __str__(self):

        return self.label

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

        if self.order is None:

            max_order = (

                Criteria.objects.filter(category=self.category)

                .aggregate(models.Max('order'))

                .get('order__max')

                or 0

            )

            self.order = max_order + 1

        if not self.slug:

            self.slug = generate_slug(self, category=self.category)

        super().save(*args, **kwargs)

    @property

    def base_slug(self):

        return slugify(self.label)

    @classmethod

    def import_json(cls, data):

        data = clean_import_data(cls, data)

        cls.objects.update_or_create(slug=data['slug'], category=data['category'], defaults=data)

    def export_json(self):

        return {

            'label': self.label,

            'slug': self.slug,

            'condition': self.condition,

            'order': self.order,

        }

    @property

    def identifier(self):

        return '%s:%s' % (self.category.slug, self.slug)

    def compute_condition(self, context):

        try:

            template = Template('{%% if %s %%}OK{%% endif %%}' % self.condition)

        except TemplateSyntaxError:

            return False

        return template.render(Context(context)) == 'OK'

class Pricing(models.Model):

    label = models.CharField(_('Label'), max_length=150)

    slug = models.SlugField(_('Identifier'), max_length=160, unique=True)

    categories = models.ManyToManyField(

        CriteriaCategory,

        related_name='pricings',

        through='PricingCriteriaCategory',

    )

    criterias = models.ManyToManyField(Criteria)

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

    class Meta:

        ordering = ['label']

    def __str__(self):

        return self.label

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

        if not self.slug:

            self.slug = generate_slug(self)

        super().save(*args, **kwargs)

    @property

    def base_slug(self):

        return slugify(self.label)

    def get_extra_variables(self, request, original_context):

        result = {}

        context = RequestContext(request)

        context.push(original_context)

        for key, tplt in (self.extra_variables or {}).items():

            try:

                template = Template(tplt)

            except TemplateSyntaxError:

                continue

            result[key] = template.render(context)

        return result

    def get_extra_variables_keys(self):

        return sorted((self.extra_variables or {}).keys())

    @classmethod

    def import_json(cls, data, overwrite=False):

        data = data.copy()

        categories = data.pop('categories', [])

        categories_by_slug = {c.slug: c for c in CriteriaCategory.objects.all()}

        criterias_by_categories_and_slug = {

            (crit.category.slug, crit.slug): crit

            for crit in Criteria.objects.select_related('category').all()

        }

        for category_data in categories:

            category_slug = category_data['category']

            if category_data['category'] not in categories_by_slug:

                raise AgendaImportError(_('Missing "%s" pricing category') % category_data['category'])

            for criteria_slug in category_data['criterias']:

                if (category_slug, criteria_slug) not in criterias_by_categories_and_slug:

                    raise AgendaImportError(

                        _('Missing "%s" pricing criteria for "%s" category') % (criteria_slug, category_slug)

                    )

        data = clean_import_data(cls, data)

        pricing, created = cls.objects.update_or_create(slug=data['slug'], defaults=data)

        PricingCriteriaCategory.objects.filter(pricing=pricing).delete()

        criterias = []

        for category_data in categories:

            pricing.categories.add(

                categories_by_slug[category_data['category']],

                through_defaults={'order': category_data['order']},

            )

            for criteria_slug in category_data['criterias']:

                criterias.append(criterias_by_categories_and_slug[(category_data['category'], criteria_slug)])

        pricing.criterias.set(criterias)

        return created, pricing

    def export_json(self):

        return {

            'label': self.label,

            'slug': self.slug,

            'extra_variables': self.extra_variables,

            'categories': [pcc.export_json() for pcc in PricingCriteriaCategory.objects.filter(pricing=self)],

        }

    def duplicate(self, label=None):

        # clone current pricing

        new_pricing = copy.deepcopy(self)

        new_pricing.pk = None

        new_pricing.label = label or _('Copy of %s') % self.label

        # reset slug

        new_pricing.slug = None

        new_pricing.save()

        # set criterias

        new_pricing.criterias.set(self.criterias.all())

        # set categories

        for pcc in PricingCriteriaCategory.objects.filter(pricing=self):

            pcc.duplicate(pricing_target=new_pricing)

        return new_pricing

class PricingCriteriaCategory(models.Model):

    pricing = models.ForeignKey(Pricing, on_delete=models.CASCADE)

    category = models.ForeignKey(CriteriaCategory, on_delete=models.CASCADE)

    order = models.PositiveIntegerField()

    class Meta:

        ordering = ['order']

        unique_together = ['pricing', 'category']

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

        if self.order is None:

            max_order = (

                PricingCriteriaCategory.objects.filter(pricing=self.pricing)

                .aggregate(models.Max('order'))

                .get('order__max')

                or 0

            )

            self.order = max_order + 1

        super().save(*args, **kwargs)

    def export_json(self):

        return {

            'category': self.category.slug,

            'order': self.order,

            'criterias': [c.slug for c in self.pricing.criterias.all() if c.category == self.category],

        }

    def duplicate(self, pricing_target):

        new_pcc = copy.deepcopy(self)

        new_pcc.pk = None

        new_pcc.pricing = pricing_target

        new_pcc.save()

        return new_pcc

@dataclasses.dataclass

class PricingMatrixCell:

    criteria: Criteria

    value: decimal.Decimal

@dataclasses.dataclass

class PricingMatrixRow:

    criteria: Criteria

    cells: List[PricingMatrixCell]

@dataclasses.dataclass

class PricingMatrix:

    criteria: Criteria

    rows: List[PricingMatrixRow]

class AgendaPricing(models.Model):

    agenda = models.ForeignKey(Agenda, on_delete=models.CASCADE)

    pricing = models.ForeignKey(Pricing, on_delete=models.CASCADE)

    date_start = models.DateField()

    date_end = models.DateField()

    pricing_data = JSONField(null=True)

    @classmethod

    def import_json(cls, data):

        data = clean_import_data(cls, data)

        cls.objects.update_or_create(

            agenda=data['agenda'],

            pricing=data['pricing'],

            date_start=data['date_start'],

            date_end=data['date_end'],

            defaults=data,

        )

    def export_json(self):

        return {

            'pricing': self.pricing.slug,

            'date_start': self.date_start.strftime('%Y-%m-%d'),

            'date_end': self.date_end.strftime('%Y-%m-%d'),

            'pricing_data': self.pricing_data,

        }

    @staticmethod

    def get_pricing_data(request, event, user_external_id, adult_external_id):

        agenda_pricing = AgendaPricing.get_agenda_pricing(event)

        context = agenda_pricing.get_pricing_context(request, user_external_id, adult_external_id)

        pricing, criterias = agenda_pricing.compute_pricing(context)

        modifier = agenda_pricing.get_booking_modifier(event, user_external_id)

        return agenda_pricing.aggregate_pricing_data(pricing, criterias, context, modifier)

    def aggregate_pricing_data(self, pricing, criterias, context, modifier):

        if modifier['modifier_type'] == 'fixed':

            pricing_amount = modifier['modifier_fixed']

        else:

            pricing_amount = pricing * modifier['modifier_rate'] / 100

        return {

            'pricing': pricing_amount,

            'calculation_details': {

                'pricing': pricing,

                'criterias': criterias,

                'context': context,

            },

            'booking_details': modifier,

        }

    @staticmethod

    def get_agenda_pricing(event):

        agenda = event.agenda

        try:

            return agenda.agendapricing_set.get(

                date_start__lte=event.start_datetime,

                date_end__gt=event.start_datetime,

            )

        except (AgendaPricing.DoesNotExist, AgendaPricing.MultipleObjectsReturned):

            raise AgendaPricingNotFound

    def get_subscription(self, event, user_external_id):

        try:

            return self.agenda.subscriptions.get(

                user_external_id=user_external_id,

                date_start__lte=event.start_datetime,

                date_end__gt=event.start_datetime,

            )

        except (Subscription.DoesNotExist, Subscription.MultipleObjectsReturned):

            raise PricingSubscriptionError

    def get_pricing_context(self, request, user_external_id, adult_external_id):

        context = {'user_external_id': user_external_id, 'adult_external_id': adult_external_id}

        if ':' in user_external_id:

            context['user_external_raw_id'] = user_external_id.split(':')[1]

        if ':' in adult_external_id:

            context['adult_external_raw_id'] = adult_external_id.split(':')[1]

        return self.pricing.get_extra_variables(request, context)

    def compute_pricing(self, context):

        criterias = {}

        categories = []

        # for each category (ordered)

        for category in self.pricing.categories.all().order_by('pricingcriteriacategory__order'):

            criterias[category.slug] = None

            categories.append(category.slug)

            # find the first matching criteria (criterias are ordered)

            for criteria in self.pricing.criterias.filter(category=category):

                condition = criteria.compute_condition(context)

                if condition:

                    criterias[category.slug] = criteria.slug

                    break

        # now search for pricing values matching found criterias

        pricing_data = self.pricing_data

        # for each category (ordered)

        for category in categories:

            criteria = criterias[category]

            if criteria is None:

                raise CriteriaConditionNotFound(details={'category': category})

            if not isinstance(pricing_data, dict):

                raise PricingDataFormatError(

                    details={'category': category, 'pricing': pricing_data, 'wanted': 'dict'}

                )

            key = '%s:%s' % (category, criteria)

            if key not in pricing_data:

                raise PricingDataError(details={'category': category, 'criteria': criteria})

            pricing_data = pricing_data[key]

        try:

            pricing = decimal.Decimal(pricing_data)

        except (decimal.InvalidOperation, ValueError, TypeError):

            raise PricingDataFormatError(details={'pricing': pricing_data, 'wanted': 'decimal'})

        return pricing, criterias

    def get_booking_modifier(self, event, user_external_id):

        # event must be checked

        if event.checked is False:

            raise PricingEventNotCheckedError

        # search for an available subscription

        self.get_subscription(event, user_external_id)

        # search for a booking

        try:

            booking = event.booking_set.get(user_external_id=user_external_id)

        except Booking.DoesNotExist:

            # no booking

            return {

                'status': 'not-booked',

                'modifier_type': 'rate',

                'modifier_rate': 0,

            }

        except Booking.MultipleObjectsReturned:

            raise PricingMultipleBookingError

        # booking cancelled

        if booking.cancellation_datetime is not None:

            return {

                'status': 'cancelled',

                'modifier_type': 'rate',

                'modifier_rate': 0,

            }

        # booking not cancelled, is must be checked

        if booking.user_was_present is None:

            raise PricingBookingNotCheckedError

        status = 'presence' if booking.user_was_present else 'absence'

        # no check_type, default rates

        if booking.user_check_type is None:

            return {

                'status': status,

                'check_type_group': None,

                'check_type': None,

                'modifier_type': 'rate',

                'modifier_rate': 100 if booking.user_was_present else 0,

            }

        check_type = booking.user_check_type

        kind_mapping = {'presence': True, 'absence': False}

        # check_type kind and user_was_present mismatch

        if kind_mapping[check_type.kind] != booking.user_was_present:

            raise PricingBookingCheckTypeError(

                details={

                    'check_type_group': check_type.group.slug,

                    'check_type': check_type.slug,

                    'reason': 'wrong-kind',

                }

            )

        # get pricing modifier

        if check_type.pricing is not None:

            return {

                'status': status,

                'check_type_group': check_type.group.slug,

                'check_type': check_type.slug,

                'modifier_type': 'fixed',

                'modifier_fixed': check_type.pricing,

            }

        if check_type.pricing_rate is not None:

            return {

                'status': status,

                'check_type_group': check_type.group.slug,

                'check_type': check_type.slug,

                'modifier_type': 'rate',

                'modifier_rate': check_type.pricing_rate,

            }

        # pricing not found

        raise PricingBookingCheckTypeError(

            details={

                'check_type_group': check_type.group.slug,

                'check_type': check_type.slug,

                'reason': 'not-configured',

            }

        )

    def iter_pricing_matrix(self):

        categories = self.pricing.categories.all().order_by('pricingcriteriacategory__order')[:3]

        pricing_data = self.pricing_data or {}

        if not categories:

            return

        if len(categories) < 3:

            yield self.get_pricing_matrix(

                main_criteria=None, categories=categories, pricing_data=pricing_data

            )

            return

        # criterias are ordered

        for criteria in self.pricing.criterias.all():

            if criteria.category != categories[0]:

                continue

            yield self.get_pricing_matrix(

                main_criteria=criteria,

                categories=categories[1:],

                pricing_data=pricing_data.get(criteria.identifier) or {},

            )

    def get_pricing_matrix(self, main_criteria, categories, pricing_data):

        matrix = PricingMatrix(

            criteria=main_criteria,

            rows=[],

        )

        def get_pricing_matrix_cell(criteria_2, criteria_3, _pricing_data):

            try:

                value = decimal.Decimal(str(_pricing_data.get(criteria_3.identifier)))

            except (decimal.InvalidOperation, ValueError, TypeError):

                value = None

            return PricingMatrixCell(criteria=criteria_2, value=value)

        if len(categories) < 2:

            rows = [

                PricingMatrixRow(

                    criteria=criteria,

                    cells=[get_pricing_matrix_cell(None, criteria, pricing_data)],

                )

                for criteria in self.pricing.criterias.all()

                if criteria.category == categories[0]

            ]

            matrix.rows = rows

        else:

            criterias_2 = [c for c in self.pricing.criterias.all() if c.category == categories[0]]

            criterias_3 = [c for c in self.pricing.criterias.all() if c.category == categories[1]]

            rows = [

                PricingMatrixRow(

                    criteria=criteria_3,

                    cells=[

                        get_pricing_matrix_cell(

                            criteria_2,

                            criteria_3,

                            pricing_data.get(criteria_2.identifier) or {},

                        )

                        for criteria_2 in criterias_2

                    ],

                )

                for criteria_3 in criterias_3

            ]

            matrix.rows = rows

        return matrix

{% extends "chrono/manager_agenda_settings.html" %}

{% load i18n %}

{% block breadcrumb %}

{{ block.super }}

<a href="{% url 'chrono-manager-agenda-pricing-detail' agenda.pk object.pk %}">{{ object.pricing }}</a>

{% endblock %}

{% block appbar %}

<h2>

    {{ object.pricing }} ({{ object.date_start|date:'d/m/Y' }} - {{ object.date_end|date:'d/m/Y' }})

</h2>

{% if user_can_manage %}

<span class="actions">

  <a class="extra-actions-menu-opener"></a>

  <ul class="extra-actions-menu">

    <li><a rel="popup" href="{% url 'chrono-manager-agenda-pricing-edit' agenda.pk object.pk %}">{% trans 'Options' %}</a></li>

    <li><a rel="popup" href="{% url 'chrono-manager-agenda-pricing-delete' agenda.pk object.pk %}">{% trans 'Delete' %}</a></li>

  </ul>

</span>

{% endif %}

{% endblock %}

{% block content %}

{% for matrix in object.iter_pricing_matrix %}

<div class="section">

  {% if matrix.criteria %}<h3>{{ matrix.criteria.label }}</h3>{% endif %}

<div>

  <table class="main pricing-matrix-{{ matrix.criteria.slug }}">

    {% if matrix.rows.0.cells.0.criteria %}

    <thead>

      <tr>

        <th></th>

        {% for cell in matrix.rows.0.cells %}<th scope="col">{{ cell.criteria.label }}</th>{% endfor %}

      </tr>

    </thead>

    {% endif %}

    <tbody>

      {% for row in matrix.rows %}

        <tr class="pricing-row-{{ row.criteria.slug }}">

          <th scope="row">{{ row.criteria.label }}</th>

          {% for cell in row.cells %}<td class="pricing-cell-{{ cell.criteria.slug }}">{{ cell.value|floatformat:"2"|default_if_none:"" }}</td>{% endfor %}

        </tr>

      {% endfor %}

    </tbody>

  </table>

  {% if user_can_manage %}

  <p>

  <a class="pk-button" href="{% if matrix.criteria %}{% url 'chrono-manager-agenda-pricing-matrix-slug-edit' agenda.pk object.pk matrix.criteria.slug %}{% else %}{% url 'chrono-manager-agenda-pricing-matrix-edit' agenda.pk object.pk %}{% endif %}">{% trans "Edit pricing" %}</a>

  </p>

  {% endif %}

</div>

</div>

{% empty %}

<div class="big-msg-info">

  {% blocktrans %}

  This pricing model is misconfigured.

  {% endblocktrans %}

</div>

{% endfor %}

{% endblock %}

{% extends "chrono/manager_agenda_settings.html" %}

{% load i18n %}

{% block breadcrumb %}

{{ block.super }}

{% if form.instance.pk %}

<a href="{% url 'chrono-manager-agenda-pricing-detail' agenda.pk object.pk %}">{{ object.pricing }}</a>

<a href="{% url 'chrono-manager-agenda-pricing-edit' agenda.pk object.pk %}">{% trans "Edit" %}</a>

{% else %}

<a href="{% url 'chrono-manager-agenda-pricing-add' agenda.pk %}">{% trans "New pricing" %}</a>

{% endif %}

{% endblock %}

{% block appbar %}

{% if object.pk %}

<h2>{% trans "Edit pricing" %}</h2>

{% else %}

<h2>{% trans "New pricing" %}</h2>

{% endif %}

{% endblock %}

{% block content %}

<form method="post" enctype="multipart/form-data">

  {% csrf_token %}

  {{ form.as_p }}

  <div class="buttons">

    <button class="submit-button">{% trans "Save" %}</button>

    {% if object.pk %}

    <a class="cancel" href="{% url 'chrono-manager-agenda-pricing-detail' agenda.pk object.pk %}">{% trans 'Cancel' %}</a>

    {% else %}

    <a class="cancel" href="{% url 'chrono-manager-agenda-settings' agenda.pk %}">{% trans 'Cancel' %}</a>

    {% endif %}

  </div>

</form>

{% endblock %}

{% extends "chrono/pricing/manager_agenda_pricing_detail.html" %}

{% load i18n %}

{% block breadcrumb %}

{{ block.super }}

{% if matrix.criteria %}

<a href="{% url 'chrono-manager-agenda-pricing-matrix-slug-edit' agenda.pk object.pk matrix.criteria.slug %}">{% trans "Edit pricing" %}</a>

{% else %}

<a href="{% url 'chrono-manager-agenda-pricing-matrix-edit' agenda.pk object.pk %}">{% trans "Edit pricing" %}</a>

{% endif %}

{% endblock %}

{% block appbar %}

<h2>{% trans "Edit pricing" %}</h2>

{% endblock %}

{% block content %}

<div class="section">

  {% if matrix.criteria %}<h3>{{ matrix.criteria.label }}</h3>{% endif %}

<div>

<form method="post" enctype="multipart/form-data">

  {% csrf_token %}

  {{ form.management_form }}

  <table class="main">

    {% if matrix.rows.0.cells.0.criteria %}

    <thead>

      <tr>

        <th></th>

        {% for cell in matrix.rows.0.cells %}

        <th>{{ cell.criteria.label }}</th>

        {% endfor %}

      </tr>

    </thead>

    {% endif %}

    <tbody>

    {% for sub_form in form %}

    {% with row=matrix.rows|get:forloop.counter0 %}

    <tr>

      <th>{{ row.criteria.label }}</th>

      {% for field in sub_form %}

      <td>

        {{ field.errors.as_ul }}

        {{ field }}

      </td>

      {% endfor %}

    </tr>

    {% endwith %}

    {% endfor %}

    </tbody>

  </table>

  <div class="buttons">

    <button class="submit-button">{% trans "Save" %}</button>

    <a class="cancel" href="{% url 'chrono-manager-agenda-pricing-detail' agenda.pk object.pk %}">{% trans 'Cancel' %}</a>

  </div>

</form>

</div>

</div>

{% endblock %}

{% extends "chrono/pricing/manager_criteria_list.html" %}

{% load i18n %}

{% block breadcrumb %}

{{ block.super }}

{% if object.pk %}

<a href="{% url 'chrono-manager-pricing-criteria-category-edit' object.pk %}">{{ object }}</a>

{% else %}

<a href="{% url 'chrono-manager-pricing-criteria-category-add' %}">{% trans "New category" %}</a>

{% endif %}

{% endblock %}

{% block appbar %}

{% if object.pk %}

<h2>{% trans "Edit category" %}</h2>

{% else %}

<h2>{% trans "New category" %}</h2>

{% endif %}

{% endblock %}

{% block content %}

<form method="post" enctype="multipart/form-data">

  {% csrf_token %}

  {{ form.as_p }}

  <div class="buttons">

    <button class="submit-button">{% trans "Save" %}</button>

    <a class="cancel" href="{% url 'chrono-manager-pricing-criteria-list' %}">{% trans 'Cancel' %}</a>

  </div>

</form>

{% endblock %}

{% extends "chrono/pricing/manager_criteria_list.html" %}

{% load i18n %}

{% block breadcrumb %}

{{ block.super }}

{% if form.instance.pk %}

<a href="{% url 'chrono-manager-pricing-criteria-edit' form.instance.category_id form.instance.pk %}">{{ form.instance }}</a>

{% else %}

<a href="{% url 'chrono-manager-pricing-criteria-add' form.instance.category_id %}">{% trans "New criteria" %}</a>

{% endif %}

{% endblock %}

{% block appbar %}

{% if form.instance.pk %}

<h2>{{ form.instance.category }} - {% trans "Edit criteria" %}</h2>

{% else %}

<h2>{{ form.instance.category }} - {% trans "New criteria" %}</h2>

{% endif %}

{% endblock %}

{% block content %}

<form method="post" enctype="multipart/form-data">

  {% csrf_token %}

  {{ form.as_p }}

  <div class="buttons">

    <button class="submit-button">{% trans "Save" %}</button>

    <a class="cancel" href="{% url 'chrono-manager-pricing-criteria-list' %}">{% trans 'Cancel' %}</a>

  </div>

</form>

{% endblock %}

{% extends "chrono/pricing/manager_pricing_list.html" %}

{% load i18n %}

{% block breadcrumb %}

{{ block.super }}

<a href="{% url 'chrono-manager-pricing-criteria-list' %}">{% trans "Criterias" %}</a>

{% endblock %}

{% block appbar %}

<h2>{% trans 'Criterias' %}</h2>

<span class="actions">

<a rel="popup" href="{% url 'chrono-manager-pricing-criteria-category-add' %}">{% trans 'New category' %}</a>

</span>

{% endblock %}

{% block content %}

<div class="pk-information">

<p>{% trans "Define here pricing criterias used in pricing models." %}</p>

</div>

{% if object_list %}

<p class="hint">

{% blocktrans %}

Use drag and drop with the ⣿ handles to reorder criterias inside a category.

{% endblocktrans %}

</p>

{% endif %}

{% for object in object_list %}

<div class="section criteria-category">

  <h3>

    <a rel="popup" href="{% url 'chrono-manager-pricing-criteria-category-edit' object.pk %}">{{ object }} [{{ object.slug }}]</a>

    <span>

    <a class="button" href="{% url 'chrono-manager-pricing-criteria-category-export' object.pk %}">{% trans "Export"%}</a>

    <a class="button" rel="popup" href="{% url 'chrono-manager-pricing-criteria-category-delete' object.pk %}">{% trans "Delete"%}</a>

    </span>

  </h3>

  <div>

  <ul class="objects-list single-links sortable" data-order-url="{% url 'chrono-manager-pricing-criteria-order' object.pk %}">

    {% for criteria in object.criterias.all %}

    <li class="sortable-item" data-item-id="{{ criteria.pk }}">

        <span class="handle">⣿</span>

        <a rel="popup" href="{% url 'chrono-manager-pricing-criteria-edit' object.pk criteria.pk %}">{{ criteria }}</a>

        <a class="delete" rel="popup" href="{% url 'chrono-manager-pricing-criteria-delete' object.pk criteria.pk %}">{% trans "delete"%}</a>

    </li>

    {% endfor %}

    <li><a class="add" rel="popup" href="{% url 'chrono-manager-pricing-criteria-add' object.pk %}">{% trans "Add a criteria" %}</a></li>

  </ul>

  </div>

</div>

{% empty %}

<div class="big-msg-info">

  {% blocktrans %}

  This site doesn't have any pricing category yet. Click on the "New category" button in the top

  right of the page to add a first one.

  {% endblocktrans %}

</div>

{% endfor %}

{% endblock %}

{% extends "chrono/pricing/manager_pricing_list.html" %}

{% load i18n %}

{% block breadcrumb %}

{{ block.super }}

<a href="{% url 'chrono-manager-pricing-detail' object.pk %}">{{ object }}</a>

{% if category %}

<a href="{% url 'chrono-manager-pricing-criteria-category-edit' object.pk category.pk %}">{% trans "Select criterias" %}</a>

{% else %}

<a href="{% url 'chrono-manager-pricing-criteria-category-add' object.pk %}">{% trans "Add a category" %}</a>

{% endif %}

{% endblock %}

{% block appbar %}

{% if category %}

<h2>{% trans "Select criterias" %}</h2>

{% else %}

<h2>{% trans "Add a category" %}</h2>

{% endif %}

{% endblock %}

{% block content %}

<form method="post" enctype="multipart/form-data">

  {% csrf_token %}

  {{ form.as_p }}

  <div class="buttons">

    <button class="submit-button">{% trans "Save" %}</button>

    <a class="cancel" href="{% url 'chrono-manager-pricing-detail' object.pk %}">{% trans 'Cancel' %}</a>

  </div>

</form>

{% endblock %}

{% extends "chrono/pricing/manager_pricing_list.html" %}

{% load i18n %}

{% block breadcrumb %}

{{ block.super }}

<a href="{% url 'chrono-manager-pricing-detail' object.pk %}">{{ object }}</a>

{% endblock %}

{% block appbar %}

<h2>

    {{ object }}

    <span class="identifier">[{% trans "identifier:" %} {{ object.slug }}]</span>