Produits Entr'ouvert » Corbo

import urllib

import json

from django.conf import settings

from django.core import signing

from django.utils import timezone

from django.core.urlresolvers import reverse

from django.views.generic import CreateView, UpdateView, DeleteView, \

    ListView, TemplateView, RedirectView, DetailView, FormView, RedirectView

from django.contrib.syndication.views import Feed

from django.shortcuts import resolve_url

from django.utils.encoding import force_text

from django.utils.feedgenerator import Atom1Feed as DjangoAtom1Feed

from django.http import HttpResponseRedirect, HttpResponse, Http404

from django.contrib.auth import logout as auth_logout

from django.contrib.auth import views as auth_views

from django.contrib import messages

from django.utils.translation import ugettext_lazy as _

from django.utils.translation import ngettext

import models

from .forms import AnnounceForm, CategoryForm, SubscriptionsImportForm, \

    SendTestEmailForm, SendTestSMSForm

from . import utils

try:

    from mellon.utils import get_idps

except ImportError:

    get_idps = lambda: []

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

    if any(get_idps()):

        if 'next' not in request.GET:

            return HttpResponseRedirect(resolve_url('mellon_login'))

        return HttpResponseRedirect(resolve_url('mellon_login') + '?next=' +

                                    urllib.quote(request.GET.get('next')))

    return auth_views.login(request, *args, **kwargs)

def logout(request, next_page=None):

    if any(get_idps()):

        return HttpResponseRedirect(resolve_url('mellon_logout'))

    auth_logout(request)

    if next_page is not None:

        next_page = resolve_url(next_page)

    else:

        next_page = '/'

    return HttpResponseRedirect(next_page)

class HomepageView(RedirectView):

    pattern_name = 'manage'

homepage = HomepageView.as_view()

class AnnounceCreateView(CreateView):

    form_class = AnnounceForm

    template_name = 'corbo/announce_form.html'

    def get_success_url(self):

        return reverse('view_category', kwargs={'slug': self.object.category.slug})

    def get_initial(self):

        initial = super(AnnounceCreateView, self).get_initial()

        initial['category'] = models.Category.objects.get(slug=self.kwargs['slug'])

        return initial

    def get_context_data(self, **kwargs):

        context = super(AnnounceCreateView, self).get_context_data(**kwargs)

        context['category'] = kwargs['form'].initial['category']

        return context

add_announce = AnnounceCreateView.as_view()

class AnnounceEditView(UpdateView):

    model = models.Announce

    form_class = AnnounceForm

    def get_context_data(self, **kwargs):

        context = super(AnnounceEditView, self).get_context_data(**kwargs)

        category_id = kwargs['form'].initial['category']

        context['category'] = models.Category.objects.get(pk=category_id)

        return context

    def get_success_url(self):

        return reverse('view_announce', kwargs={'pk': self.object.pk})

edit_announce = AnnounceEditView.as_view()

class AnnounceDeleteView(DeleteView):

    model = models.Announce

    def get_success_url(self):

        return reverse('view_category', kwargs={'slug': self.object.category.slug})

delete_announce = AnnounceDeleteView.as_view()

class CategoryCreateView(CreateView):

    form_class = CategoryForm

    template_name = 'corbo/category_form.html'

    def get_success_url(self):

        return reverse('manage')

    def form_valid(self, form):

        form.save()

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

add_category = CategoryCreateView.as_view()

class CategoryEditView(UpdateView):

    form_class = CategoryForm

    model = models.Category

    def get_success_url(self):

        return reverse('view_category', kwargs={'slug': self.object.slug})

edit_category = CategoryEditView.as_view()

class CategoryView(ListView):

    model = models.Announce

    paginate_by = settings.ANNOUNCES_PER_PAGE

    def get_queryset(self):

        qs = super(CategoryView, self).get_queryset()

        return qs.filter(category__slug=self.kwargs['slug'])

    def get_context_data(self, **kwargs):

        context = super(CategoryView, self).get_context_data(**kwargs)

        context['category'] = models.Category.objects.get(slug=self.kwargs['slug'])

        return context

view_category = CategoryView.as_view()

class CategoryDeleteView(DeleteView):

    model = models.Category

    def get_success_url(self):

        return reverse('manage')

delete_category = CategoryDeleteView.as_view()

class UnsubscribeView(DeleteView):

    model = models.Subscription

    def get_object(self, queryset=None):

        data = signing.loads(self.kwargs['unsubscription_token'])

        try:

            return models.Subscription.objects.get(category__pk=data['category'],

                                                   identifier=data['identifier'])

        except models.Subscription.DoesNotExist:

            raise Http404

    def get_success_url(self):

        return reverse('unsubscription_done')

unsubscribe = UnsubscribeView.as_view()

class UnsubscriptionDoneView(TemplateView):

    template_name = 'corbo/unsubscription_done.html'

unsubscription_done = UnsubscriptionDoneView.as_view()

class ManageView(ListView):

    template_name = 'corbo/manage.html'

    model = models.Category

    paginate_by = settings.CATEGORIES_PER_PAGE

manage = ManageView.as_view()

class Atom1Feed(DjangoAtom1Feed):

    def root_attributes(self):

        attrs = super(Atom1Feed, self).root_attributes()

        attrs.update({'xml:base': self.feed['link']})

        return attrs

class AtomView(Feed):

    title = settings.RSS_TITLE

    description = settings.RSS_DESCRIPTION

    link = settings.RSS_LINK

    feed_item_link_template = settings.RSS_LINK_TEMPLATE

    feed_type = Atom1Feed

    def __init__(self, **kwargs):

        self.__dict__.update(kwargs)

    def items(self):

        limit = settings.RSS_ITEMS_LIMIT

        return models.Announce.objects.filter(publication_time__lte=timezone.now()).exclude(

            expiration_time__lt=timezone.now()).order_by('-publication_time')[:limit]

    def item_title(self, item):

        return item.title

    def item_description(self, item):

        return item.text

    def item_link(self, item):

        return self.feed_item_link_template.format(item.pk)

    def item_pubdate(self, item):

        return item.publication_time or item.mtime

atom = AtomView()

class SubscriptionsImportView(FormView):

    form_class = SubscriptionsImportForm

    template_name = 'corbo/subscriptions_import_form.html'

    def get_context_data(self, **kwargs):

        context = super(SubscriptionsImportView, self).get_context_data(**kwargs)

        context['category'] = models.Category.objects.get(slug=self.kwargs['slug'])

        return context

    def get_success_url(self):

        category = models.Category.objects.get(slug=self.kwargs['slug'])

        return reverse('view_category', kwargs={'slug': category.slug})

    def form_valid(self, form):

        new = 0

        c = models.Category.objects.get(slug=self.kwargs['slug'])

        for email in form.cleaned_data['subscribers']:

            obj, created = models.Subscription.objects.get_or_create(category=c, identifier='mailto:%s' % email)

            if created:

               new += 1

        messages.info(self.request, ngettext('%(new)d subscriber added', '%(new)d subscribers added', new) % {'new': new})

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

subscriptions_import = SubscriptionsImportView.as_view()

class AnnounceView(DetailView):

    model = models.Announce

    template_name = 'corbo/announce_view.html'

    def get_context_data(self, **kwargs):

        context = super(AnnounceView, self).get_context_data(**kwargs)

        context['category'] = self.object.category

        context['broadcasts'] = self.object.broadcast_set.filter(deliver_time__isnull=False)

        context['sms_enabled'] = settings.SMS_GATEWAY_URL

        return context

view_announce = AnnounceView.as_view()

class SendAnnounceView(FormView):

    def get_initial(self):

        return {'email': self.request.user.email,

                'mobile': self.request.session.get('mellon_session', {}).get('mobile', '')}

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

        return reverse('view_announce', kwargs={'pk': self.kwargs['pk']})

    def get_context_data(self, **kwargs):

        context = super(SendAnnounceView, self).get_context_data(**kwargs)

        context['object'] = models.Announce.objects.get(pk=self.kwargs['pk'])

        return context

class EmailAnnounceView(SendAnnounceView):

    form_class = SendTestEmailForm

    template_name = 'corbo/email_test_announce_form.html'

    def form_valid(self, form):

        email = form.cleaned_data['email']

        announce = models.Announce.objects.get(pk=self.kwargs['pk'])

        utils.send_email(announce.title, announce.text, [email], announce.category.pk)

        messages.info(self.request, _('Email successfully sent'))

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

email_announce = EmailAnnounceView.as_view()

class SMSAnnounceView(SendAnnounceView):

    form_class = SendTestSMSForm

    template_name = 'corbo/sms_test_announce_form.html'

    def form_valid(self, form):

        mobile = form.cleaned_data['mobile']

        announce = models.Announce.objects.get(pk=self.kwargs['pk'])

        sms_sent = utils.send_sms(announce.text, [mobile])

        if sms_sent == 1:

            messages.info(self.request, _('SMS successfully sent'))

        else:

            messages.error(self.request, _('Error occured while sending SMS'))

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

sms_announce = SMSAnnounceView.as_view()

def menu_json(request):

    label = _('Announces')

    json_str = json.dumps([{'label': force_text(label),

                          'slug': 'announces',

                           'url': request.build_absolute_uri(reverse('manage'))}])

    for variable in ('jsonpCallback', 'callback'):

        if variable in request.GET:

            response = HttpResponse(content_type='application/javascript')

            json_str = '%s(%s);' % (request.GET[variable], json_str)

            break

    else:

        response = HttpResponse(content_type='application/json')

    response.write(json_str)

    return response