Produits Entr'ouvert » Combo

from django import forms

from .models import ParametersCell

from jsonfield.widgets import JSONWidget

class ParametersForm(forms.Form):

    choice = forms.ChoiceField(choices=[])

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

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

        empty_label = kwargs.pop('empty_label')

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

        self.fields['choice'].choices = [('', empty_label)] + [(x['name'], x['name']) for x in self.parameters]

    def clean(self):

        choice = self.cleaned_data.get('choice')

        for parameter in self.parameters:

            if parameter['name'] == choice:

                self.cleaned_data['choice'] = parameter['value']

                break

        return self.cleaned_data

class ParametersCellForm(forms.ModelForm):

    class Meta:

        model = ParametersCell

        fields = ('title', 'url', 'empty_label', 'parameters',)

        widgets = {

            # XXX: replace with a more ergonomic widget

            'parameters': JSONWidget(

                attrs={

                    'rows': 30,

                    'cols': 100,

                    'style': 'resize: none'

                })

        }

# -*- coding: utf-8 -*-

from __future__ import unicode_literals

from django.db import models, migrations

import jsonfield.fields

class Migration(migrations.Migration):

    dependencies = [

        ('auth', '0001_initial'),

        ('data', '0012_auto_20151029_1535'),

    ]

    operations = [

        migrations.CreateModel(

            name='ParametersCell',

            fields=[

                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),

                ('placeholder', models.CharField(max_length=20)),

                ('order', models.PositiveIntegerField()),

                ('slug', models.SlugField(verbose_name='Slug', blank=True)),

                ('public', models.BooleanField(default=True, verbose_name='Public')),

                ('restricted_to_unlogged', models.BooleanField(default=False, verbose_name='Restrict to unlogged users')),

                ('title', models.CharField(max_length=150, verbose_name='Title', blank=True)),

                ('url', models.URLField(verbose_name='URL', blank=True)),

                ('empty_label', models.CharField(default=b'---', max_length=64, verbose_name='Empty label')),

                ('parameters', jsonfield.fields.JSONField(default=dict, help_text='Must be a JSON list, containing dictionnaries with 3 keys: name, value and optionnally roles; name must be a string, value must be a dictionnary and roles must a list of role names. Role names limit the visibility of the choice.', verbose_name='Parameters', blank=True)),

                ('groups', models.ManyToManyField(to='auth.Group', verbose_name='Groups', blank=True)),

                ('page', models.ForeignKey(to='data.Page')),

            ],

            options={

                'verbose_name': 'Parameters',

            },

            bases=(models.Model,),

        ),

    ]

from django.core.exceptions import ObjectDoesNotExist, ValidationError

from django.contrib.auth.models import Group

from jsonfield import JSONField

@register_cell_class

class ParametersCell(CellBase):

    title = models.CharField(_('Title'), max_length=150, blank=True)

    url = models.URLField(_('URL'), blank=True)

    empty_label = models.CharField(_('Empty label'), max_length=64, default='---')

    parameters = JSONField(_('Parameters'), blank=True,

                           help_text=_('Must be a JSON list, containing dictionnaries with 3 keys: '

                                       'name, value and optionnally roles; name must be a string, '

                                       'value must be a dictionnary and roles must a list of role '

                                       'names. Role names limit the visibility of the choice.'))

    template_name = 'combo/parameters-cell.html'

    class Meta:

        verbose_name = _('Parameters')

    def get_additional_label(self):

        return self.title

    def is_visible(self, user=None):

        return bool(self.parameters) and super(ParametersCell, self).is_visible(user=user)

    def validate_schema(self, value):

        if not isinstance(value, list):

            return False, _('it must be a list')

        if not all(isinstance(x, dict) for x in value):

            return False, _('it must be a list of dictionnaries')

        if not all(set(x.keys()) <= set(['roles', 'name', 'value']) for x in value):

            return False, _('permitted keys in the dictionnaries are name, roles and value')

        for x in value:

            if 'roles' not in x:

                continue

            if not isinstance(x['roles'], list):

                return False, _('roles must be a list')

            if not all(isinstance(y, unicode) for y in x['roles']):

                return False, _('roles must be a list of strings')

            if len(set(x['roles'])) != len(x['roles']):

                return False, _('role\'s names must be unique in a list of roles')

            existing = Group.objects.filter(name__in=x['roles']).values_list('name', flat=True)

            if len(existing) != len(x['roles']):

                l = u', '.join(set(x['roles']) - set(existing))

                return False, _('role(s) %s do(es) not exist') % l

        if not all(isinstance(x['name'], unicode) for x in value):

            return False, _('name must be a string')

        if not all(isinstance(x['value'], dict) for x in value):

            return Falsea, ('value must be a dictionnary')

        if not len(set(x['name'] for x in value)) == len(value):

            return False, _('names must be unique')

        return True, ''

    def clean(self):

        validated, msg = self.validate_schema(self.parameters)

        if not validated:

            raise ValidationError(_('Parameters does not validate the expected schema: %s') % msg)

    def get_form(self, request):

        from .forms import ParametersForm

        if not request.user.is_anonymous():

            groups = set(request.user.groups.values_list('name', flat=True))

        else:

            groups = set()

        parameters = [param for param in self.parameters

                      if not param.get('roles') or set(param['roles']) & groups]

        return ParametersForm(request.GET, parameters=parameters,

                              empty_label=self.empty_label,

                              prefix='parameters-cells-' + str(self.pk))

    def modify_global_context(self, context, request):

        if not bool(self.parameters):

            return

        # Store form for later use by get_cell_extra_context

        self._form = self.get_form(request)

        if self._form.is_valid():

            parameters = context['parameters'] if 'parameters' in context else {}

            context['parameters'] = parameters

            parameters.update(self._form.cleaned_data['choice'])

    def get_cell_extra_context(self, context):

        ctx = super(ParametersCell, self).get_cell_extra_context(context)

        if hasattr(self, '_form'):

            ctx['form'] = self._form

        ctx['title'] = self.title

        ctx['url'] = self.url

        return ctx

    def get_default_form_class(self):

        from .forms import ParametersCellForm

        return ParametersCellForm

              $(elem).parent().parent().addClass('ajax-loaded');

function combo_modify_query_string(name, value) {

    var search = window.location.search.substring(1);

    var parts = search.split('&');

    var newparts = [];

    var modified = 0;

    value = encodeURIComponent(value);

    for (var i = 0; i < parts.length; i++) {

        if (! parts[i]) {

            continue;

        }

        var pair = parts[i].split('=');

        if (pair[0] == name) {

            if (value) {

                newparts.push(name + '=' + value);

            }

            modified = 1;

        } else {

            newparts.push(parts[i]);

        }

    }

    if (! modified && value) {

        newparts.push(name + '=' + value);

    }

    if (newparts) {

        search = '?' + newparts.join('&');

    } else {

        search = '';

    }

    return search;

}

  /* reload cells when parameters changes */

  function combo_refresh_ajax_cells() {

    $('[data-ajax-cell-url]').each(function(idx, elem) {

      var $elem = $(elem);

      var $div = $elem.find('> div');

      $div.empty();

      var msg = $(elem).data('ajax-cell-loading-message');

      $div.append($('<span class="loading-message">' + msg + '</span>'));

      combo_load_cell($div.find('span'), $elem.data('ajax-cell-url'));

    });

  }

  if (window.history.pushState) {

      /* set initial state */

      window.history.pushState("reload", "", window.location.href);

      $(window).on('popstate', function (event) {

        if (event.originalEvent.state == "reload") {

          combo_refresh_ajax_cells();

        }

      });

  }

  $(document).on('change', '.combo-parameters-cell-form select', function (e) {

    var $target = $(e.target);

    var value = $target.val();

    var name = $target[0].name;

    var new_qs = combo_modify_query_string(name, value);

    if (window.history.pushState) {

        window.history.pushState("reload", "", window.location.pathname + new_qs);

        combo_refresh_ajax_cells();

    } else {

        window.location.search = new_qs;

    }

  });

{% if form %}

    {% if title %}

    <h2>{% if url %}<a href="{{url}}">{% endif %}{{title}}{% if url %}</a>{% endif %}</h2>

    {% endif %}

    <form class="combo-parameters-cell-form" method="get">

      {{ form.choice }}

    </form>

    <!--

      Parameters: {{ parameters|pprint }}

      Choice: {{ form.cleaned_data.choice|pprint }}

    -->

{% endif %}

{% load combo i18n %}

     data-ajax-cell-loading-message="{% trans "Loading..." %}"