expomap/exposition/views.py

# -*- coding: utf-8 -*-
import datetime
import json

from accounts.models import User
from article.models import Article
from city.models import City
from country.models import Country
from django.conf import settings
from django.contrib.contenttypes.models import ContentType
from django.core.mail import EmailMessage
from django.http import (
    Http404,
    HttpResponse,
    HttpResponsePermanentRedirect,
    HttpResponseRedirect
)
from django.shortcuts import get_object_or_404
from django.utils.translation import ugettext as _
from django.utils import translation
from django.views.generic import DetailView
from django.views.generic.edit import FormMixin

from functions.cache_mixin import JitterCacheMixin
from functions.custom_views import ExpoSearchView, ListView, ReverseOrderMixin
from functions.search_forms import ExpositionSearchForm
from functions.views_help import get_side_items
from functions.utils import CachedSting

from meta.views import MetadataMixin
from models import Exposition
from note.models import Note
from service.models import Service
from service.order_forms import AdvertiseForm
from service.views import order_forms, get_userlog_data
# from stats_collector.models import SectionStats
from stats_collector.mixin import (
    ExpoSectionKindMixin,
    ExpoSectionMixin,
    ObjectStatMixin
)
from theme.models import Tag, Theme
from events.mixin import ExpoFilterMixin, SearchFilterMixin

description_templates = settings.DEFAULT_DESCRIPTION


class ExpositionBy(ExpoFilterMixin, ExpoSectionMixin, JitterCacheMixin, MetadataMixin, ListView):
    template_name = 'exposition/exposition_by.html'
    title1 = ''
    title2 = ''

    """
    abstact class
    """
    def get_context_data(self, **kwargs):
        context = super(ExpositionBy, self).get_context_data(**kwargs)
        context.update({'title1': self.title1, 'title2': self.title2, 'catalog': self.catalog})
        return context


class ExpositionByCountry(ExpositionBy):
    cache_range = [60*30, 60*60]
    model = Country
    title1 = _(u'По странам')
    title2 = _(u'Выставки мира по странам')
    catalog = 'country/'
    stat_kind = 'country'

    def get_context_data(self, **kwargs):
        context = super(ExpositionByCountry, self).get_context_data(**kwargs)
        context['can_filter'] = False
        context['side_popular'] = get_side_items('expo', Country)
        return context

    def get_queryset(self):
        return self.model.objects.expo_countries_with_count()
        #lang = translation.get_language()
        #return self.model.objects.select_related('exposition_country')\
        #    .filter(exposition_country__country__isnull=False, translations__language_code=lang)\
        #    .order_by('translations__name').distinct()


class ExpositionByTheme(ExpositionBy):
    cache_range = [60*30, 60*60]
    model = Theme
    title1 = _(u'По тематикам')
    title2 = _(u'Выставки мира по тематикам')
    catalog = 'theme/'
    stat_kind = 'theme'

    def get_queryset(self):
        return self.model.active.expo_themes_with_count()
        #lang = translation.get_language()
        #return self.model.objects.select_related('exposition_themes')\
        #    .filter(exposition_themes__theme__isnull=False, translations__language_code=lang)\
        #    .order_by('translations__name').distinct()


class ExpositionByTag(ExpositionBy):
    cache_range = [60*30, 60*60]
    model = Tag
    title1 = _(u'По тегам')
    title2 = _(u'Выставки мира по тегам')
    catalog = 'tag/'
    stat_kind = 'tag'

    def get_queryset(self):
        return self.model.active.expo_themes_with_count()


class ExpositionByCity(ExpositionBy):
    cache_range = [60*30, 60*60]
    model = City
    title1 = _(u'По городам')
    title2 = _(u'Выставки мира по городам')
    catalog = 'city/'
    stat_kind = 'city'

    def get_context_data(self, **kwargs):
        context = super(ExpositionByCity, self).get_context_data(**kwargs)
        context['can_filter'] = False
        context['side_popular'] = get_side_items('expo', City)
        return context

    def get_queryset(self):
        return self.model.used.expo_cities_with_count()
        #return self.model.used.expo_cities()
        #lang = translation.get_language()
        #return self.model.objects.select_related('exposition_city')\
        #    .filter(exposition_city__city__isnull=False, translations__language_code=lang)\
        #    .order_by('translations__name').distinct()


class ExpositionSearchView(ReverseOrderMixin, SearchFilterMixin, ExpoSearchView):
    #paginate_by = 10
    template_name = 'client/exposition/search.html'
    search_form = ExpositionSearchForm
    model = Exposition


def exposition_add_calendar(request, id):
    args = {'success': False}
    user = request.user

    if user.is_authenticated():
        exp = Exposition.objects.safe_get(id=id)
        if exp in user.calendar.get_expos():
            user.calendar.expositions.remove(exp)
            args['in'] = False
        else:
            user.calendar.expositions.add(exp)
            args['in'] = True
        args['success'] = True
    else:
        args['not_authorized'] = True
        args['success'] = True

    return HttpResponse(json.dumps(args), content_type='application/json')

# перенесено в events
# def exposition_visit(request, id):
#     args = {'success': False}
#     user = request.user
#     if  user.is_authenticated():
#         exp = Exposition.objects.safe_get(id=id)
#         if user in exp.users.all():
#             exp.users.remove(user)
#             args['in'] = False
#         else:
#             exp.users.add(user)
#             args['in'] = True
#
#         args['success'] = True
#     else:
#         args['not_authorized'] = True
#         args['success'] = True
#
#     return HttpResponse(json.dumps(args), content_type='application/json')


class ExpoDetail(ObjectStatMixin, JitterCacheMixin, MetadataMixin, DetailView):
    cache_range = [60*30, 60*60]
    model = Exposition
    slug_field = 'url'
    template_name = 'client/exposition/exposition_detail.html'
    queryset = Exposition.objects.language()\
        .select_related('place', 'city', 'country', 'paid_new')\
        .prefetch_related('theme', 'tag')
    descriptions = {
        'ru': CachedSting(settings.DEFAULT_DESCRIPTION.get('e_description_ru')),
        'en': CachedSting(settings.DEFAULT_DESCRIPTION.get('e_description_en')),
        }

    def get_context_data(self, **kwargs):
        lang = translation.get_language()
        context = super(ExpoDetail, self).get_context_data(**kwargs)
        context['advertising_form'] = AdvertiseForm()
        obj = self.object
        if not obj.description:
            context['default_description'] = unicode(self.descriptions[lang]).format(**obj.default_description_context())
        context['city'] = str(obj.city_id)
        context['country'] = str(obj.country_id)
        context['themes'] = [str(item.id) for item in obj.theme.all()]
        context['news'] = Article.objects.news()\
            .filter(publish_date__isnull=False, exposition=obj).order_by('-publish_date')[:3]
        return context


class ExpositionProgramme(JitterCacheMixin, MetadataMixin, DetailView):
    cache_range = [60*30, 60*60]
    model = Exposition
    slug_field = 'url'
    template_name = 'client/exposition/programm.html'
    queryset = Exposition.objects.language().select_related('place', 'city', 'country', 'paid_new')

    def get_context_data(self, **kwargs):
        context = super(ExpositionProgramme, self).get_context_data(**kwargs)
        obj = self.object
        context['city'] = str(obj.city_id)
        context['country'] = str(obj.country_id)
        context['themes'] = [str(item.id) for item in obj.theme.all()]

        return context


class ExpositionPrice(JitterCacheMixin, MetadataMixin, DetailView):
    cache_range = [60*30, 60*60]
    model = Exposition
    slug_field = 'url'
    template_name = 'client/exposition/price.html'
    queryset = Exposition.objects.language().select_related('place', 'city', 'country', 'paid_new')

    def get_context_data(self, **kwargs):
        context = super(ExpositionPrice, self).get_context_data(**kwargs)
        obj = self.object
        context['city'] = str(obj.city_id)
        context['country'] = str(obj.country_id)
        context['themes'] = [str(item.id) for item in obj.theme.all()]

        return context


class ExpositionStatistic(JitterCacheMixin, MetadataMixin, DetailView):
    cache_range = [60*30, 60*60]
    model = Exposition
    slug_field = 'url'
    template_name = 'client/exposition/statistic.html'
    queryset = Exposition.objects.language().select_related('place', 'city', 'country', 'paid_new')

    def get_context_data(self, **kwargs):
        context = super(ExpositionStatistic, self).get_context_data(**kwargs)
        obj = self.object
        context['city'] = str(obj.city_id)
        context['country'] = str(obj.country_id)
        context['themes'] = [str(item.id) for item in obj.theme.all()]

        return context


class ExpositionThankView(JitterCacheMixin, MetadataMixin, DetailView):
    cache_range = [60*30, 60*60]
    model = Exposition
    slug_field = 'url'
    template_name = 'client/service/thank_u_page.html'

    def get_context_data(self, **kwargs):
        context = super(ExpositionThankView, self).get_context_data(**kwargs)
        obj = self.object
        context['city'] = str(obj.city_id)
        context['country'] = str(obj.country_id)
        context['themes'] = [str(item.id) for item in obj.theme.all()]

        return context


def visit_redirect(request, slug):
    obj = get_object_or_404(Exposition, url=slug)
    redirect = obj.get_permanent_url() + 'price/'
    return HttpResponsePermanentRedirect(redirect)


class ExpositionServiceView(JitterCacheMixin, MetadataMixin, FormMixin, DetailView):
    cache_range = [60*30, 60*60]
    model = Exposition
    slug_field = 'url'
    service = None
    success_url = '/service/thanks/'

    def dispatch(self, request, *args, **kwargs):
        service_url = self.kwargs.get('service_url')
        service = get_object_or_404(Service, url=service_url)
        self.service = service
        self.template_name = service.template
        return super(ExpositionServiceView, self).dispatch(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()
        service_url = self.kwargs.get('service_url')
        service = get_object_or_404(Service, url=service_url)
        service_form = order_forms.get(service_url)
        self.form_class = service_form
        form = self.get_form(service_form)

        if form.is_valid():
            return self.form_valid(form)
        else:
            return self.form_invalid(form)

    def get_context_data(self, **kwargs):
        kwargs.update({'meta_id': getattr(self.service, 'meta_id','')})

        context = super(ExpositionServiceView, self).get_context_data(**kwargs)
        service_url = self.kwargs.get('service_url')
        form = order_forms.get(service_url)
        self.form_class = form
        if not form:
            raise Http404
        context['form'] = self.get_form(self.form_class)
        context['service'] = self.service
        obj = self.get_object()
        context['object'] = obj
        context['city'] = str(obj.city_id)
        context['country'] = str(obj.country_id)
        context['themes'] = [str(item.id) for item in obj.theme.all()]

        return context

    def form_valid(self, form):
        userlog = get_userlog_data(self.request)
        order = form.save(commit=False, userlog=userlog)
        order.exposition = self.object
        order.save()
        return HttpResponseRedirect(self.object.get_permanent_url()+'service/thanks/')

    def get_initial(self):
        """
        Returns the initial data to use for forms on this view.
        """
        if self.request.user.is_authenticated():
            user = self.request.user

            initial = {'person_inf': user.get_full_name(),
                       'person': user.email,
                       'country': user.profile.country.name if user.profile.country else '',
                       'city':user.profile.city.name if user.profile.city else '',
                       'phone': user.profile.phone if user.profile.phone else ''}

            return initial
        else:
            return self.initial.copy()


class ExpoList_(ExpoFilterMixin, ExpoSectionMixin, MetadataMixin, JitterCacheMixin, ListView):
    cache_range = [60*30, 60*60]
    model = Exposition
    paginate_by = settings.CLIENT_PAGINATION
    template_name = 'client/exposition/exposition_list.html'
    catalog_url = '/expo/'
    year = None
    month = None

    def get_queryset(self):
        MONTHES = settings.MONTHES
        if self.request.user.is_staff:
            qs = self.model.objects.upcoming()
        else:
            qs = self.model.enable.upcoming()
        year = self.kwargs.get('year')
        if year:
            qs = self.model.enable.filter(data_end__year=year)
            # info for breadscrumbs
            self.year = {'text': year, 'link': '%s%s/'%(self.catalog_url, year)}

        month = self.kwargs.get('month')
        if month and MONTHES.get(month):
            qs = qs.filter(data_begin__month=MONTHES[month]['value'])
            self.month = {
                'text': MONTHES[month]['name'],
                'link': '%s%s/%s/'%(self.catalog_url, year, month),
                'slug': self.kwargs.get('month')
            }
        return qs

    def get_context_data(self, **kwargs):
        context = super(ExpoList_, self).get_context_data(**kwargs)
        context['catalog_url'] = self.catalog_url
        context['year'] = self.year
        context['month'] = self.month
        return context

class ExpoList(ReverseOrderMixin, ExpoList_):
    pass


class ExpoCatalog_(ExpoFilterMixin, ExpoSectionKindMixin, JitterCacheMixin, MetadataMixin, ListView):
    model = Exposition
    paginate_by = settings.CLIENT_PAGINATION
    template_name = 'client/exposition/catalog.html'
    filter_object = None
    year = None
    month = None
    country = None
    city = None

    def get_filtered_qs(self):
        # diferent for views
        pass

    def get_queryset(self):
        qs = self.get_filtered_qs()

        year = self.kwargs.get('year')
        if year:
            qs = self.model.enable.filter(data_end__year=year)
            filter_object = self.filter_object
            if isinstance(filter_object, Country):
                qs = qs.filter(country=filter_object)
            elif isinstance(filter_object, City):
                qs = qs.filter(city=filter_object)
            elif isinstance(filter_object, Theme):
                qs = qs.filter(theme=filter_object)
                if self.kwargs.get('country'):
                    qs = qs.filter(country=self.kwargs.get('country'))
                if self.kwargs.get('city'):
                    qs = qs.filter(city=self.kwargs.get('city'))
            elif isinstance(filter_object, Tag):
                qs = qs.filter(tag=filter_object)

            # info for breadscrumbs
            self.year = {'text': year, 'link': '%s%s/%s/'%(self.catalog_url, self.filter_object.url, year)}

        month = self.kwargs.get('month')
        monthes = {'jan': {'value': 1, 'name': _(u'Январь')}, 'feb': {'value': 2, 'name': _(u'Февраль')},
                   'mar': {'value': 3, 'name': _(u'Март')}, 'apr': {'value': 4, 'name': _(u'Апрель')},
                   'may': {'value': 5, 'name': _(u'Май')}, 'jun': {'value': 6, 'name': _(u'Июнь')},
                   'jul': {'value': 7, 'name': _(u'Июль')}, 'aug': {'value': 8, 'name': _(u'Август')},
                   'sep': {'value': 9, 'name': _(u'Сентябрь')}, 'oct': {'value': 10, 'name': _(u'Октябрь')},
                   'nov': {'value': 11, 'name': _(u'Ноябрь')}, 'dec': {'value': 12, 'name': _(u'Декабрь')}}
        if month and monthes.get(month):
            qs = qs.filter(data_begin__month=monthes[month]['value'])
            self.month = {
                'text': monthes[month]['name'],
                'slug': '{m}/{y}'.format(m=monthes[month]['value'], y=year)
                }
            if self.country:
                self.month['link'] = '%s%s/country/%s/%s/%s/' %\
                    (self.catalog_url, self.filter_object.url, self.country.url, year, month)
            elif self.city:
                self.month['link'] = '%s%s/city/%s/%s/%s/' %\
                    (self.catalog_url, self.filter_object.url, self.city.url, year, month)
            else:
                self.month['link'] = '%s%s/%s/%s/' %\
                    (self.catalog_url, self.filter_object.url, year, month)

        return qs.order_by('data_begin')

    def get_context_data(self, **kwargs):
        context = super(ExpoCatalog_, self).get_context_data(**kwargs)
        context['filter_object'] = self.filter_object
        context['year'] = self.year
        context['month'] = self.month
        context['catalog_url'] = self.catalog_url
        if self.kwargs.get('tag'):
            context['tag_for_filter'] = self.kwargs['tag']
        return context

class ExpoCatalog(ReverseOrderMixin, ExpoCatalog_):
    pass


class ExpoCountryCatalog(ExpoCatalog):
    catalog_url = '/expo/country/'
    stat_kind = 'country'
    def get_filtered_qs(self):
        #this method used in parent get_queryset
        slug = self.kwargs.get('slug')
        country = get_object_or_404(Country, url=slug)
        self.kwargs['country'] = country
        self.filter_object = country
        qs = self.model.enable.upcoming().filter(country=country)
        return qs

    def get_context_data(self, **kwargs):
        context = super(ExpoCountryCatalog, self).get_context_data(**kwargs)
        context['country'] = [str(self.kwargs['country'].id)]
        return context


class ExpoCityCatalog(ExpoCatalog):
    catalog_url = '/expo/city/'
    stat_kind = 'city'
    def get_filtered_qs(self):
        #this method used in parent get_queryset
        slug = self.kwargs.get('slug')
        city = get_object_or_404(City, url=slug)
        self.kwargs['city'] = city
        qs = self.model.enable.upcoming().filter(city=city)
        self.filter_object = city
        return qs

    def get_context_data(self, **kwargs):
        context = super(ExpoCityCatalog, self).get_context_data(**kwargs)
        city = self.kwargs['city']
        context['country'] = [str(city.country_id)]
        context['city'] = [str(city.id)]
        return context


class ExpoThemeCatalog(ExpoCatalog):
    template_name = 'client/exposition/catalog_theme.html'
    catalog_url = '/expo/theme/'
    stat_kind = 'theme'
    country = None
    city = None

    def get_filtered_qs(self):
        #this method used in parent get_queryset
        slug = self.kwargs.get('slug')
        country_slug = self.kwargs.get('country_slug')
        city_slug = self.kwargs.get('city_slug')
        theme = get_object_or_404(Theme, url=slug)
        self.kwargs['theme'] = theme
        qs = self.model.enable.upcoming().filter(theme=theme)

        if country_slug:
            country = get_object_or_404(Country, url=country_slug)
            self.country = country
            self.kwargs['country'] = country
            qs = qs.filter(country=country)

        if city_slug:
            city = get_object_or_404(City, url=city_slug)
            self.city = city
            self.kwargs['city'] = city
            qs = qs.filter(city=city)

        self.filter_object = theme
        return qs

    def get_context_data(self, **kwargs):
        context = super(ExpoThemeCatalog, self).get_context_data(**kwargs)
        if self.country:
            context['country'] = self.country
        if self.city:
            context['city'] = self.city
        context['theme_for_filter'] = self.kwargs['theme']
        context['themes'] = [str(self.kwargs['theme'].id)]
        return context


class ExpoTagCatalog(ExpoCatalog):
    catalog_url = '/expo/tag/'
    stat_kind = 'tag'

    def get_filtered_qs(self):
        #this method used in parent get_queryset
        slug = self.kwargs.get('slug')
        tag = get_object_or_404(Tag, url=slug)
        self.kwargs['tag'] = tag
        qs = self.model.enable.upcoming().filter(tag=tag)
        self.filter_object = tag
        return qs

    def get_context_data(self, **kwargs):
        context = super(ExpoTagCatalog, self).get_context_data(**kwargs)
        tag = self.kwargs['tag']
        context['theme_for_filter'] = tag.theme
        context['themes'] = [str(tag.theme.id)]
        context['tag'] = [str(self.kwargs['tag'].id)]
        return context


class ExpoVisitors(MetadataMixin, ListView):
    paginate_by = settings.CLIENT_PAGINATION
    model = Exposition
    template_name = 'client/exposition/visitors.html'
    obj = None

    def get_queryset(self):
        slug = self.kwargs.get('slug')
        exposition = get_object_or_404(self.model, url=slug)
        self.obj = exposition
        self.object = self.obj
        return exposition.users.all()

    def get_context_data(self, **kwargs):
        context = super(ExpoVisitors, self).get_context_data(**kwargs)
        obj = self.obj
        context['object'] = obj
        context['city'] = str(obj.city_id)
        context['country'] = str(obj.country_id)
        context['themes'] = [str(item.id) for item in obj.theme.all()]
        return context


class ExpoMembers(MetadataMixin, ListView):
    paginate_by = settings.CLIENT_PAGINATION
    model = Exposition
    template_name = 'client/exposition/members.html'
    obj = None

    def get_queryset(self):
        slug = self.kwargs.get('slug')
        exposition = get_object_or_404(self.model, url=slug)
        self.obj = exposition
        self.object = self.obj
        return exposition.company.all()

    def get_context_data(self, **kwargs):
        context = super(ExpoMembers, self).get_context_data(**kwargs)
        obj = self.obj
        context['object'] = obj
        context['city'] = str(obj.city_id)
        context['country'] = str(obj.country_id)
        context['themes'] = [str(item.id) for item in obj.theme.all()]
        return context


class ExpoPhotoView(MetadataMixin, ListView):
    template_name = 'client/exposition/photo.html'
    obj = None
    paginate_by = settings.CLIENT_PAGINATION

    def get_queryset(self):
        slug = self.kwargs.get('slug')
        expo = get_object_or_404(Exposition, url=slug)
        self.object = expo
        if expo.photogallery:
            return expo.photogallery.photos.all()
        else:
            raise Http404()

    def get_context_data(self, **kwargs):
        context = super(ExpoPhotoView, self).get_context_data(**kwargs)
        obj = self.object
        context['object'] = obj
        context['city'] = str(obj.city_id)
        context['country'] = str(obj.country_id)
        context['themes'] = [str(item.id) for item in obj.theme.all()]
        return context


def add_note(request, slug):
    args = {'success': False}

    if request.user.is_authenticated():

        if request.GET:
            text = request.GET['note_text']
            try:
                e = Exposition.objects.get(url=slug)
            except Exposition.DoesNotExist:
                raise Http404

            ct = ContentType.objects.get_for_model(e)
            object_id = e.id
            user = User.objects.get(id=request.user.id)
            if Note.objects.filter(user=user, content_type=ct, object_id=object_id).exists():
                Note.objects.filter(user=user, content_type=ct, object_id=object_id).update(text=text)
            else:
                Note.objects.create(content_type=ct, object_id=object_id, user=user, text=text)

            user.calendar.expositions.add(e)


            args['success'] = True
            args['text'] = text

    else:
        args['not_authorized'] = True
        args['success'] = True

    return HttpResponse(json.dumps(args), content_type='application/json')

def send_to_organiser(request, slug):
    exposition = get_object_or_404(Exposition, url=slug)
    mail_send = 'evm@expomap.ru'
    data = {
        'expo_name': exposition.name,
        'name': request.POST.get('person_inf'),
        'email': request.POST.get('person'),
        'phone': request.POST.get('phone', ''),
        'question': request.POST.get('question', ''),
    }
    text = _(u"выставка: %(expo_name)s\n Контактное лицо:%(name)s\nEmail: %(email)s\nтелефон:%(phone)s\n вопрос:%(question)s") % data
    msg = EmailMessage(_(u'Проплаченная выставка'), text, settings.DEFAULT_FROM_EMAIL, [mail_send])
    msg.content_subtype = "html"
    msg.send()
    redirect_to = '%sservice/thanks/'%exposition.get_permanent_url()

    return HttpResponse(json.dumps({'success':True, 'redirect_to': redirect_to}), content_type='application/json')