expomap/events/views.py

# -*- coding: utf-8 -*-
from django.core.exceptions import ObjectDoesNotExist
from django.db.models import Q
from django.http import Http404
from django.http import HttpResponseForbidden
from django.http import HttpResponseNotFound
from django.views.generic.edit import FormMixin, FormView
from django.conf import settings
from django.template.loader import render_to_string
from django.template import RequestContext

from haystack.query import SearchQuerySet

from emencia.django.newsletter.forms import ContactForm
from emencia.django.newsletter.models import Contact
from functions.custom_views import ContextMixin
from functions.custom_views import ReverseOrderMixin
from functions.custom_views import ListView
from functions.http import JsonResponse

from exposition.models import Exposition
from conference.models import Conference

from .forms import FilterForm


class FilterListView_(ContextMixin, FormMixin, ListView):
    initial_ctx = {'filtering': True}
    form_class = FilterForm
    paginate_by = settings.CLIENT_PAGINATION
    template_name = 'events/filter_listview.html'
    _ajax_results_template_name = 'events/filter_listview_ajax.html'
    _ajax_form_template_name = 'includes/events/filter_form.html'

    def get_form_kwargs(self):
        kwargs = super(FilterListView_, self).get_form_kwargs()
        kwargs.update({'data': self.request.GET})
        return kwargs

    def get_queryset(self):
        if self.form.is_valid():
            qs = self.form.filter()
            # import pdb; pdb.set_trace()
        else:
            qs = self.form.default_filter()
        if self.kwargs.get('with_form', True):
            self.form.recalculate_choices()
        # print(self.form.data, self.form.cleaned_data, self.form.get_date_begin_periods())
        # import pdb; pdb.set_trace()
        return qs

    def get(self, request, *args, **kwargs):
        self.form = self.get_form(self.get_form_class())
        self.extra_ctx['form'] = self.form

        # ajax
        if request.is_ajax():
            ctx = RequestContext(request, self.get_context_data(object_list=self.get_queryset()))
            data = {'success': True}
            if kwargs.get('with_results', True):
                data.update({
                    'results': render_to_string(self._ajax_results_template_name, ctx),
                })
            if kwargs.get('with_form', True):
                data.update({
                    'form': render_to_string(self._ajax_form_template_name, ctx),
                    })

            return JsonResponse(data)
        # usual get
        return super(FilterListView_, self).get(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(FilterListView_, self).get_context_data(**kwargs)
        # get params for paginator
        get = self.form.data.copy()
        if 'page' in get:
            del get['page']
        context['GETparams'] = get.urlencode() if hasattr(get, 'urlencode') else ''

        return context

class FilterListView(ReverseOrderMixin, FilterListView_):
    pass


class SubscribeView(FormView):
    form_class = ContactForm
    template_name = None
    models = {'expo': (Exposition, 'expositions'), 'conf': (Conference, 'conferences')}
    defaults = {
        'activated': True,
        'from_events': True,
        'subscriber': False,
    }

    def get_event(self):
        model, self.attr = self.models.get(self.kwargs.get('model'))
        slug = self.kwargs.get('slug')
        return model.objects.get(url=slug)

    def set_event(self):
        attr = getattr(self.contact, self.attr)
        attr.add(self.event)

    def get_contact(self):
        user = self.request.user
        defaults = {
            'first_name': user.first_name,
            'last_name': user.last_name,
            'email': user.email,
            'user': user,
        }
        defaults.update(self.defaults)
        try:
            contact = Contact.objects.filter(Q(user=user) | Q(email=user.email))[0]
        except (Contact.DoesNotExist, IndexError):
            contact = Contact(defaults)
            contact.save()
        return contact

    def dispatch(self, request, *args, **kwargs):
        if not request.is_ajax():
            return HttpResponseForbidden()
        self.attr = None
        self.contact = None
        try:
            self.event = self.get_event()
        except ObjectDoesNotExist:
            return HttpResponseNotFound()
        return super(SubscribeView, self).dispatch(request, *args, **kwargs)

    def form_invalid(self, form):
        return JsonResponse(form.errors, status=400)

    def form_valid(self, form):
        contact = form.save(commit=False)

        contact.send_activation()
        return self.success_responce()

    def success_responce(self):
        self.set_event()
        return JsonResponse({'success': True})

    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated():
            self.contact = self.get_contact()
            return self.success_responce()
        return super(SubscribeView, self).post(request, *args, **kwargs)