You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
626 lines
22 KiB
626 lines
22 KiB
# -*- coding: utf-8 -*-
|
|
import json
|
|
import datetime
|
|
from django.http import HttpResponseRedirect, HttpResponse, HttpResponsePermanentRedirect
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.conf import settings
|
|
from django.views.generic import DetailView
|
|
from functions.custom_views import ListView
|
|
from django.utils.translation import ugettext as _
|
|
from django.shortcuts import get_object_or_404
|
|
from django.http import Http404
|
|
from django.views.generic.edit import FormMixin
|
|
from django.core.mail import EmailMessage
|
|
#models
|
|
from accounts.models import User
|
|
from models import Exposition
|
|
from service.views import order_forms
|
|
from service.models import Service
|
|
from country.models import Country
|
|
from city.models import City
|
|
from theme.models import Theme, Tag
|
|
from note.models import Note
|
|
from service.order_forms import AdvertiseForm
|
|
from functions.search_forms import ExpositionSearchForm
|
|
from functions.custom_views import ExpoSearchView
|
|
from meta.views import MetadataMixin
|
|
from functions.cache_mixin import JitterCacheMixin
|
|
|
|
|
|
class ExpositionBy(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/'
|
|
|
|
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/'
|
|
|
|
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/'
|
|
|
|
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/'
|
|
|
|
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(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')
|
|
|
|
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(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')
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ExpoDetail, self).get_context_data(**kwargs)
|
|
context['advertising_form'] = AdvertiseForm()
|
|
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 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):
|
|
order = form.save(commit=False)
|
|
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(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)}
|
|
return qs
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ExpoList, self).get_context_data(**kwargs)
|
|
context['month'] = self.month
|
|
context['catalog_url'] = self.catalog_url
|
|
context['year'] = self.year
|
|
context['month'] = self.month
|
|
return context
|
|
|
|
|
|
|
|
class ExpoCatalog(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'])
|
|
if self.country:
|
|
self.month = {'text': monthes[month]['name'], 'link': '%s%s/country/%s/%s/%s/'%
|
|
(self.catalog_url, self.filter_object.url, self.country.url, year, month)}
|
|
elif self.city:
|
|
self.month = {'text': monthes[month]['name'], 'link': '%s%s/city/%s/%s/%s/'%
|
|
(self.catalog_url, self.filter_object.url, self.city.url, year, month)}
|
|
else:
|
|
self.month = {'text': monthes[month]['name'], '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 ExpoCountryCatalog(ExpoCatalog):
|
|
catalog_url = '/expo/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/'
|
|
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/'
|
|
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/'
|
|
|
|
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'
|
|
name = request.POST.get('person_inf')
|
|
email = request.POST.get('person')
|
|
phone = request.POST.get('phone', '')
|
|
question = request.POST.get('question', '')
|
|
text = u"выставка: %s\n Контактное лицо:%s\nEmail: %s\nтелефон:%s\n вопрос:%s"%(exposition.name, name, email,
|
|
phone, question)
|
|
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') |