Produits Entr'ouvert » Combo

        self.include_labels = None

        if 'include_labels' in kwargs:

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

                if self.include_labels:

                    label = newsletter['text']

                else:

                    label = ''

                choices.append((transport['id'], label))

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

from __future__ import unicode_literals

from django.db import models, migrations

import combo.apps.newsletters.models

class Migration(migrations.Migration):

    dependencies = [

        ('auth', '0001_initial'),

        ('data', '0019_create_parent_cells'),

        ('newsletters', '0001_initial'),

    ]

    operations = [

        migrations.CreateModel(

            name='NewsletterSubscriptionCell',

            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=128, verbose_name='Title')),

                ('url', models.URLField(max_length=128, verbose_name='Newsletters service url')),

                ('newsletter', models.CharField(max_length=128, verbose_name='Newsletter')),

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

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

            ],

            options={

                'verbose_name': 'Newsletter subscription',

            },

            bases=(combo.apps.newsletters.models.NewslettersMixin, models.Model),

        ),

    ]

class NewslettersMixin(object):

    def is_relevant(self, context):

        return bool(context.get('user').is_authenticated())

    def get_newsletters(self, **kwargs):

        endpoint = self.url + 'newsletters/'

        url = get_signed_url(endpoint, self.url, **kwargs)

        response = requests.get(url, verify=False)

        if response.ok:

            json_response = response.json()

            return self.filter_data(json_response['data'])

        return []

    def simplify(self, name):

        return slugify(name.strip())

        return super(NewslettersMixin, self).render(context)

@register_cell_class

class NewslettersCell(NewslettersMixin, CellBase):

    title = models.CharField(verbose_name=_('Title'), max_length=128)

    url = models.URLField(verbose_name=_('Newsletters service url'),

                                     max_length=128)

    resources_restrictions = models.CharField(_('resources restrictions'),

                                              blank=True, max_length=1024,

                                              help_text=_('list of resources(themes) separated by commas'))

    transports_restrictions = models.CharField(_('transports restrictions'),

                                               blank=True, max_length=1024,

                                               help_text=_('list of transports separated by commas'))

    template_name = 'newsletters/newsletters.html'

    class Meta:

        verbose_name = _('Newsletters')

    def get_default_form_class(self):

        model_fields = ('title', 'url', 'resources_restrictions',

                        'transports_restrictions')

        return model_forms.modelform_factory(self.__class__, fields=model_fields)

    def get_resources_restrictions(self):

        return filter(None, map(self.simplify, self.resources_restrictions.strip().split(',')))

    def get_transports_restrictions(self):

        return filter(None, map(self.simplify, self.transports_restrictions.strip().split(',')))

    def filter_data(self, data):

        filtered = []

        for item in data:

            if not self.check_resource(item['text']):

                continue

            if not self.transports_restrictions:

                filtered.append(item)

            for t in item['transports']:

                if self.check_transport(t['id']):

                    filtered.append(item)

        return filtered

@register_cell_class

class NewsletterSubscriptionCell(NewslettersMixin, CellBase):

    title = models.CharField(verbose_name=_('Title'), max_length=128)

    url = models.URLField(verbose_name=_('Newsletters service url'),

                                     max_length=128)

    newsletter = models.CharField(_('Newsletter'), max_length=128)

    template_name = 'newsletters/newsletter_subscription.html'

    class Meta:

        verbose_name = _('Newsletter subscription')

    def filter_data(self, data):

        return [i for i in data if i['text'] == self.newsletter]

    def get_resources_restrictions(self):

        return [self.simplify(self.newsletter)]

    def get_transports_restrictions(self):

        return ['mailto']

    def set_subscription(self, subscription, **kwargs):

        pass

    def get_default_form_class(self):

        model_fields = ('title', 'url', 'newsletter')

        return model_forms.modelform_factory(self.__class__, fields=model_fields)

    def render(self, context):

        user = context.get('user')

        if user.is_authenticated():

            form = NewslettersManageForm(instance=self, user=user, include_labels=True)

            context['form'] = form

        return super(NewslettersMixin, self).render(context)

{% load i18n %}

<h2>{{ cell.title }}</h2>

{% if form %}

{% if form.non_field_errors %}

{{ form.non_field_errors }}

{% else %}

<form method="post" action={% url 'newsletter-subscription-update' pk=cell.pk %}>

  {% csrf_token %}

  {% for field in form %}

  {% for w in field %}

  {{ w }}

  {% endfor %}

  {% endfor %}

  <input type="submit" value="{% trans "Send" %}"/>

</form>

{% endif %}

{% endif %}

from .views import NewslettersView, NewsletterSubscriptionView

    url('^subscription/(?P<pk>\w+)/update$', login_required(NewsletterSubscriptionView.as_view()),

        name='newsletter-subscription-update'),

from .models import NewslettersCell, NewsletterSubscriptionCell, SubscriptionsSaveError

class NewslettersMixin(object):

    def get_success_url(self):

        return self.instance.page.get_online_url()

    def form_invalid(self, form):

        messages.error(self.request, _('An error occured while saving your subscriptions. Please try later.'))

        return HttpResponseRedirect(self.get_success_url())

class NewslettersView(NewslettersMixin, FormView):

class NewsletterSubscriptionView(NewslettersMixin, FormView):

    def form_valid(self, form):

        try:

            form.save()

            messages.info(self.request, _('Your subscription is successfully saved'))

        except SubscriptionsSaveError:

            messages.error(self.request, _('An error occured while saving your subscription. Please try later.'))

        return super(NewsletterSubscriptionView, self).form_valid(form)

    def get_form_kwargs(self):

        kwargs = super(NewsletterSubscriptionView, self).get_form_kwargs()

        self.instance = NewsletterSubscriptionCell.objects.get(pk=self.kwargs['pk'])

        kwargs.update({'user': self.request.user, 'instance': self.instance})

        return kwargs