Produits Entr'ouvert » Combo

from .models import Page, ParametersCell, MenuCell, LinkCell, LinkListCell, ConfigJsonCell

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'

                })

        }

@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 dictionaries with 3 keys: '

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

                                       'value must be a dictionary 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 dictionaries')

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

            return False, _('permitted keys in the dictionaries 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 False, ('value must be a dictionary')

        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'] = utils.get_templated_url(self.url)

        return ctx

    def get_default_form_class(self):

        from .forms import ParametersCellForm

        return ParametersCellForm

{% block cell-content %}

{% 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 %}

{% endblock %}

-