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 datetime
|
|
import json
|
|
|
|
from django.conf import settings
|
|
from django.contrib import messages
|
|
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 import translation
|
|
from django.utils.translation import ugettext as _
|
|
from django.views.generic import DetailView
|
|
from django.views.generic.edit import FormMixin
|
|
|
|
from functions.cache_mixin import CacheMixin, JitterCacheMixin
|
|
from functions.custom_views import ListView, ReverseOrderMixin
|
|
from functions.views_help import get_side_items
|
|
from functions.utils import CachedSting
|
|
|
|
from accounts.models import User
|
|
from article.models import Article
|
|
from city.models import City
|
|
from country.models import Country
|
|
from meta.views import MetadataMixin
|
|
from models import Conference
|
|
from note.models import Note
|
|
from service.models import Service
|
|
from service.order_forms import AdvertiseForm
|
|
from service.views import order_forms
|
|
from stats_collector.mixin import (
|
|
ConfSectionKindMixin,
|
|
ConfSectionMixin,
|
|
ObjectStatMixin
|
|
)
|
|
from theme.models import Tag, Theme
|
|
from events.mixin import ConfFilterMixin
|
|
|
|
MONTHES = settings.MONTHES
|
|
description_templates = settings.DEFAULT_DESCRIPTION
|
|
|
|
|
|
class ConferenceBy(ConfFilterMixin, ConfSectionMixin, JitterCacheMixin, MetadataMixin, ListView):
|
|
cache_range = settings.CACHE_RANGE
|
|
template_name = 'client/conference/conference_by.html'
|
|
title1 = ''
|
|
title2 = ''
|
|
|
|
"""
|
|
abstact class
|
|
"""
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ConferenceBy, self).get_context_data(**kwargs)
|
|
context.update({'title1': self.title1, 'title2': self.title2, 'catalog': self.catalog})
|
|
|
|
return context
|
|
|
|
|
|
class ConferenceByCountry(ConferenceBy):
|
|
model = Country
|
|
title1 = _(u'По странам')
|
|
title2 = _(u'Коференции мира по странам')
|
|
catalog = 'country/'
|
|
stat_kind = 'country'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ConferenceByCountry, self).get_context_data(**kwargs)
|
|
context['can_filter'] = False
|
|
context['side_popular'] = get_side_items('conf', Country)
|
|
return context
|
|
|
|
def get_queryset(self):
|
|
return self.model.objects.conference_countries_with_count()
|
|
#lang = translation.get_language()
|
|
#return self.model.objects.select_related('conference_country')\
|
|
# .filter(conference_country__country__isnull=False, translations__language_code=lang)\
|
|
# .order_by('translations__name').distinct()
|
|
|
|
|
|
class ConferenceByTag(ConferenceBy):
|
|
model = Tag
|
|
title1 = _(u'По тегам')
|
|
title2 = _(u'Коференции мира по тегам')
|
|
catalog = 'tag/'
|
|
stat_kind = 'tag'
|
|
|
|
def get_queryset(self):
|
|
return self.model.active.conference_themes_with_count()
|
|
|
|
|
|
class ConferenceByTheme(ConferenceBy):
|
|
model = Theme
|
|
title1 = _(u'По тематикам')
|
|
title2 = _(u'Коференции мира по тематикам')
|
|
catalog = 'theme/'
|
|
stat_kind = 'theme'
|
|
|
|
def get_queryset(self):
|
|
return self.model.active.conference_themes_with_count()
|
|
#lang = translation.get_language()
|
|
#return self.model.objects.select_related('conference_themes')\
|
|
# .filter(conference_themes__theme__isnull=False, translations__language_code=lang)\
|
|
# .order_by('translations__name').distinct()
|
|
|
|
|
|
class ConferenceByCity(ConferenceBy):
|
|
model = City
|
|
title1 = _(u'По городам')
|
|
title2 = _(u'Коференции мира по городам')
|
|
catalog = 'city/'
|
|
stat_kind = 'city'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ConferenceByCity, self).get_context_data(**kwargs)
|
|
context['can_filter'] = False
|
|
context['side_popular'] = get_side_items('conf', City)
|
|
return context
|
|
|
|
def get_queryset(self):
|
|
return self.model.used.conference_cities_with_count()
|
|
#lang = translation.get_language()
|
|
#return self.model.objects.select_related('conference_city')\
|
|
# .filter(conference_city__city__isnull=False, translations__language_code=lang)\
|
|
# .order_by('translations__name').distinct()
|
|
|
|
|
|
class ConferenceCatalog_(ConfFilterMixin, ConfSectionKindMixin, JitterCacheMixin, MetadataMixin, ListView):
|
|
cache_range = settings.CACHE_RANGE
|
|
model = Conference
|
|
paginate_by = settings.CLIENT_PAGINATION
|
|
template_name = 'client/conference/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),
|
|
'slug': self.kwargs.get('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),
|
|
'slug': self.kwargs.get('month')
|
|
}
|
|
else:
|
|
self.month = {
|
|
'text': monthes[month]['name'],
|
|
'link': '%s%s/%s/%s/'%(self.catalog_url, self.filter_object.url, year, month),
|
|
'slug': self.kwargs.get('month')
|
|
}
|
|
|
|
return qs.order_by('data_begin')
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ConferenceCatalog_, 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
|
|
return context
|
|
|
|
class ConferenceCatalog(ReverseOrderMixin, ConferenceCatalog_):
|
|
pass
|
|
|
|
|
|
class ConferenceCountryCatalog(ConferenceCatalog):
|
|
catalog_url = '/conference/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(ConferenceCountryCatalog, self).get_context_data(**kwargs)
|
|
context['country'] = [str(self.kwargs['country'].id)]
|
|
return context
|
|
|
|
|
|
class ConferenceCityCatalog(ConferenceCatalog):
|
|
catalog_url = '/conference/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(ConferenceCityCatalog, self).get_context_data(**kwargs)
|
|
context['city'] = [str(self.kwargs['city'].id)]
|
|
return context
|
|
|
|
|
|
class ConferenceThemeCatalog(ConferenceCatalog):
|
|
template_name = 'conference/catalog_theme.html'
|
|
catalog_url = '/conference/theme/'
|
|
country = None
|
|
city = None
|
|
stat_kind = 'theme'
|
|
|
|
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
|
|
qs = qs.filter(country=country)
|
|
|
|
if city_slug:
|
|
city = get_object_or_404(City, url=city_slug)
|
|
self.city = city
|
|
qs = qs.filter(city=city)
|
|
|
|
self.filter_object = theme
|
|
return qs
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ConferenceThemeCatalog, 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 ConferenceTagCatalog(ConferenceCatalog):
|
|
catalog_url = '/conference/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(ConferenceTagCatalog, 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 ConferenceVisitors(MetadataMixin, ListView):
|
|
paginate_by = settings.CLIENT_PAGINATION
|
|
model = Conference
|
|
template_name = 'client/conference/visitors.html'
|
|
obj = None
|
|
|
|
def get_queryset(self):
|
|
slug = self.kwargs.get('slug')
|
|
conference = get_object_or_404(self.model, url=slug)
|
|
self.obj = conference
|
|
return conference.users.all()
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ConferenceVisitors, 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 ConferenceMembers(MetadataMixin, ListView):
|
|
paginate_by = settings.CLIENT_PAGINATION
|
|
model = Conference
|
|
template_name = 'client/conference/members.html'
|
|
obj = None
|
|
|
|
def get_queryset(self):
|
|
slug = self.kwargs.get('slug')
|
|
conference = get_object_or_404(self.model, url=slug)
|
|
self.obj = conference
|
|
return conference.company.all()
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ConferenceMembers, 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 ConferenceThankView(MetadataMixin, DetailView):
|
|
model = Conference
|
|
slug_field = 'url'
|
|
template_name = 'client/service/thank_u_page.html'
|
|
|
|
def visit_redirect(request, slug):
|
|
obj = get_object_or_404(Conference, url=slug)
|
|
redirect = obj.get_permanent_url()
|
|
return HttpResponsePermanentRedirect(redirect)
|
|
|
|
|
|
class ConferenceServiceView(FormMixin, DetailView):
|
|
model = Conference
|
|
slug_field = 'url'
|
|
service = None
|
|
success_url = '/service/thanks/'
|
|
|
|
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):
|
|
context = super(ConferenceServiceView, self).get_context_data(**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
|
|
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'] = 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.conference = self.object
|
|
order.save()
|
|
messages.success(self.request, _(u'Ваш запрос был успешно отправлен'))
|
|
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 ConferenceDetail(ObjectStatMixin, JitterCacheMixin, MetadataMixin, DetailView):
|
|
cache_range = settings.CACHE_RANGE
|
|
model = Conference
|
|
slug_field = 'url'
|
|
template_name = 'client/conference/conference_detail.html'
|
|
descriptions = {
|
|
'ru': CachedSting(settings.DEFAULT_DESCRIPTION.get('c_description_ru')),
|
|
'en': CachedSting(settings.DEFAULT_DESCRIPTION.get('c_description_en')),
|
|
}
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
|
|
slug = self.kwargs.get(self.slug_url_kwarg, None)
|
|
try:
|
|
city = City.objects.get(old_url=slug)
|
|
# return HttpResponseRedirect('/conference/city/%s/'%city.url)
|
|
# except City.DoesNotExist:
|
|
# return super(ConferenceDetail, self).dispatch(request, *args, **kwargs)
|
|
if city:
|
|
return HttpResponseRedirect('/conference/city/%s/'%city.url)
|
|
except Exception:
|
|
try:
|
|
return super(ConferenceDetail, self).dispatch(request, *args, **kwargs)
|
|
except:
|
|
raise Http404('NotFound')
|
|
|
|
def get_context_data(self, **kwargs):
|
|
lang = translation.get_language()
|
|
context = super(ConferenceDetail, 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, conference=obj).order_by('-publish_date')[:3]
|
|
return context
|
|
|
|
|
|
class ConferenceList(ReverseOrderMixin, ConfFilterMixin, ConfSectionMixin, MetadataMixin, JitterCacheMixin, ListView):
|
|
cache_range = settings.CACHE_RANGE
|
|
model = Conference
|
|
paginate_by = settings.CLIENT_PAGINATION
|
|
template_name = 'client/conference/conference_list.html'
|
|
catalog_url = '/conference/'
|
|
year = None
|
|
month = None
|
|
|
|
def get_queryset(self):
|
|
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')
|
|
}
|
|
if not qs.exists():
|
|
qs = self.get_reversed_qs(qs)
|
|
return qs
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ConferenceList, self).get_context_data(**kwargs)
|
|
context['catalog_url'] = self.catalog_url
|
|
context['year'] = self.year
|
|
context['month'] = self.month
|
|
return context
|
|
|
|
|
|
class ConferencePhotoView(MetadataMixin, ListView):
|
|
template_name = 'client/conference/photo.html'
|
|
obj = None
|
|
paginate_by = settings.CLIENT_PAGINATION
|
|
|
|
def get_queryset(self):
|
|
slug = self.kwargs.get('slug')
|
|
conf = get_object_or_404(Conference, url=slug)
|
|
self.object = conf
|
|
if conf.photogallery:
|
|
return conf.photogallery.photos.all()
|
|
else:
|
|
raise Http404()
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ConferencePhotoView, 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 conference_add_calendar(request, id):
|
|
args = {'success': False}
|
|
user = request.user
|
|
|
|
if user.is_authenticated():
|
|
conf = Conference.objects.safe_get(id=id)
|
|
if conf in user.calendar.get_confs():
|
|
user.calendar.conferences.remove(conf)
|
|
args['in'] = False
|
|
else:
|
|
user.calendar.conferences.add(conf)
|
|
args['in'] = True
|
|
args['success'] = True
|
|
else:
|
|
args['not_authorized'] = True
|
|
args['success'] = True
|
|
|
|
return HttpResponse(json.dumps(args), content_type='application/json')
|
|
|
|
|
|
def conference_visit(request, id):
|
|
args = {'success': False}
|
|
user = request.user
|
|
if user.is_authenticated():
|
|
conf = Conference.objects.safe_get(id=id)
|
|
if user in conf.users.all():
|
|
conf.users.remove(user)
|
|
args['in'] = False
|
|
else:
|
|
conf.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')
|
|
|
|
def add_note(request, slug):
|
|
args = {'success': False}
|
|
|
|
if request.user.is_authenticated():
|
|
|
|
if request.GET:
|
|
text = request.GET['note_text']
|
|
try:
|
|
conf = Conference.objects.get(url=slug)
|
|
except Conference.DoesNotExist:
|
|
raise Http404
|
|
|
|
ct = ContentType.objects.get_for_model(conf)
|
|
object_id = conf.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.conferences.add(conf)
|
|
|
|
|
|
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(Conference, 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', '')
|
|
data = {'expo_name': exposition.name, 'name': name, 'email': email,
|
|
'phone': phone, 'question': 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')
|
|
|