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.
213 lines
8.4 KiB
213 lines
8.4 KiB
# -*- coding: utf-8 -*-
|
|
import datetime
|
|
|
|
from django.utils.translation import get_language
|
|
from django.db.models import Q
|
|
from django.core.cache import cache
|
|
from django.utils import translation
|
|
from django.conf import settings
|
|
|
|
from hvad.models import TranslationManager
|
|
|
|
class ExpoManager(TranslationManager):
|
|
|
|
def upcoming(self):
|
|
return self.language().select_related('country', 'city', 'place').filter(data_begin__gte=datetime.datetime.now().date()).order_by('data_begin')
|
|
|
|
"""
|
|
def all(self, lang=None):
|
|
if lang:
|
|
return super(ExpoManager, self).language(lang).all().order_by('name')
|
|
else:
|
|
return super(ExpoManager, self).language(get_language()).all().order_by('name')
|
|
"""
|
|
def safe_get(self, **kwargs):
|
|
model = self.model
|
|
try:
|
|
return model.objects.get(**kwargs)
|
|
except:
|
|
return None
|
|
|
|
def expo_main(self, cached=True):
|
|
lang = translation.get_language()
|
|
key = 'expo_main_page_key_%s'%lang
|
|
if cached and key in cache:
|
|
result = cache.get(key)
|
|
else:
|
|
result = list(self.language(lang).
|
|
select_related('country', 'city', 'place', 'main').
|
|
prefetch_related('tag').
|
|
filter(main__isnull=False).
|
|
filter(main__public=True))
|
|
cache.set(key, result, 45)
|
|
|
|
return result
|
|
|
|
def conf_main(self, cached=True):
|
|
lang = translation.get_language()
|
|
key = 'conf_main_page_key_%s'%lang
|
|
if cached and key in cache:
|
|
result = cache.get(key)
|
|
else:
|
|
result = list(self.language(lang).
|
|
select_related('country', 'city', 'place', 'main').
|
|
prefetch_related('tag').
|
|
filter(main__isnull=False).
|
|
filter(main__public=True))
|
|
cache.set(key, result, 50)
|
|
|
|
return result
|
|
|
|
|
|
class CityManager(TranslationManager):
|
|
cache_time = 600
|
|
def all(self):
|
|
lang = get_language()
|
|
qs = super(CityManager, self).select_related('exposition_city', 'conference_city')
|
|
qs = qs.filter(Q(exposition_city__city__isnull=False) | Q(conference_city__city__isnull=False))\
|
|
.order_by('translations__name').distinct()
|
|
|
|
return qs
|
|
|
|
def active_qs(self):
|
|
from exposition.models import Exposition
|
|
cities_id = [item['city_id'] for item in Exposition.objects.values('city_id').distinct()]
|
|
return self.language().filter(id__in=cities_id)
|
|
|
|
def expo_cities(self, cached=True):
|
|
lang = translation.get_language()
|
|
key = 'used_expo_cities_%s' % lang
|
|
if cached and key in cache:
|
|
cached_cities = cache.get(key)
|
|
return cached_cities
|
|
else:
|
|
from exposition.models import Exposition
|
|
cities_id = [item['city_id'] for item in Exposition.objects.values('city_id').distinct()]
|
|
cities = list(self.language().filter(id__in=cities_id))
|
|
cache.set(key, cities, self.cache_time)
|
|
return cities
|
|
|
|
def expo_cities_with_count(self, cached=True):
|
|
lang = translation.get_language()
|
|
key = 'used_expo_cities_count_%s' % lang
|
|
if cached and key in cache:
|
|
cached_cities = cache.get(key)
|
|
return cached_cities
|
|
else:
|
|
from exposition.models import Exposition
|
|
sql = {'expo_count':
|
|
"""SELECT COUNT(*)
|
|
FROM exposition_exposition
|
|
WHERE exposition_exposition.city_id = city_city.id
|
|
AND exposition_exposition.data_end >= CURDATE()
|
|
AND exposition_exposition.is_published = 1"""}
|
|
now = datetime.datetime.now().date()
|
|
# id of unique cities
|
|
cities_id = [item['city_id'] for item in Exposition.objects.filter(is_published=True, data_end__gte=now).values('city_id').distinct()]
|
|
cities = set(list(self.language().filter(id__in=cities_id).extra(select=sql)))
|
|
cities = sorted(cities, key=lambda x: x.name)
|
|
cache.set(key, cities, self.cache_time)
|
|
return cities
|
|
|
|
def place_cities_with_count(self, cached=True):
|
|
lang = translation.get_language()
|
|
key = 'used_place_cities_count_%s' % lang
|
|
if cached and key in cache:
|
|
cached_cities = cache.get(key)
|
|
return cached_cities
|
|
else:
|
|
from place_exposition.models import PlaceExposition
|
|
sql = {'place_count':
|
|
"""SELECT COUNT(*)
|
|
FROM place_exposition_placeexposition
|
|
WHERE place_exposition_placeexposition.city_id = city_city.id
|
|
AND place_exposition_placeexposition.is_published = 1"""}
|
|
now = datetime.datetime.now().date()
|
|
# id of unique countries
|
|
cities_id = set(
|
|
PlaceExposition.objects\
|
|
.filter(is_published=True)\
|
|
.values_list('city_id', flat=True)
|
|
)
|
|
cities = set(list(self.language().filter(id__in=cities_id).extra(select=sql)))
|
|
cities = sorted(cities, key=lambda x: x.name)
|
|
cache.set(key, cities, self.cache_time)
|
|
return cities
|
|
|
|
def conference_cities_with_count(self, cached=True):
|
|
lang = translation.get_language()
|
|
key = 'used_conference_cities_count_%s' % lang
|
|
if cached and key in cache:
|
|
cached_cities = cache.get(key)
|
|
return cached_cities
|
|
else:
|
|
|
|
from conference.models import Conference
|
|
sql = {'conference_count':
|
|
"""SELECT COUNT(*)
|
|
FROM conference_conference
|
|
WHERE conference_conference.city_id = city_city.id
|
|
AND conference_conference.data_end >= CURDATE()
|
|
AND conference_conference.is_published = 1"""}
|
|
now = datetime.datetime.now().date()
|
|
# id of unique countries
|
|
cities_id = [item['city_id'] for item in Conference.objects.filter(is_published=True, data_end__gte=now).values('city_id').distinct()]
|
|
cities = set(list(self.language().filter(id__in=cities_id).extra(select=sql)))
|
|
cities = sorted(cities, key=lambda x: x.name)
|
|
cache.set(key, cities, self.cache_time)
|
|
return cities
|
|
|
|
def conference_cities(self, cached=True):
|
|
lang = translation.get_language()
|
|
key = 'used_conference_cities_%s'%lang
|
|
if cached and key in cache:
|
|
cached_cities = cache.get(key)
|
|
return cached_cities
|
|
else:
|
|
from conference.models import Conference
|
|
cities_id = [item['city_id'] for item in Conference.objects.values('city_id').distinct()]
|
|
cities = list(self.language().filter(id__in=cities_id))
|
|
cache.set(key, cities, self.cache_time)
|
|
return cities
|
|
|
|
def cities(self, cached=True):
|
|
"""
|
|
not finished
|
|
"""
|
|
lang = translation.get_language()
|
|
key = 'used_cities_%s'%lang
|
|
if cached and key in cache:
|
|
cached_cities = cache.get(key)
|
|
return cached_cities
|
|
else:
|
|
from exposition.models import Exposition
|
|
cities_id = [item['city_id'] for item in Exposition.objects.values('city_id').distinct()]
|
|
cities = list(self.language().filter(id__in=cities_id))
|
|
cache.set(key, cities, self.cache_time)
|
|
return cities
|
|
|
|
def russia(self, cached=True):
|
|
lang = translation.get_language()
|
|
key = 'russia_cities_%s' % lang
|
|
if cached and key in cache:
|
|
cities = cache.get(key)
|
|
else:
|
|
cities = list(
|
|
self.language(lang).filter(
|
|
country__url='russia', exposition_city__isnull=False,
|
|
conference_city__isnull=False
|
|
).exclude(pk=settings.MOSCOW_PK).distinct().order_by('name').values_list('pk', 'name')
|
|
)
|
|
cache.set(key, cities, self.cache_time)
|
|
return cities
|
|
|
|
|
|
def hvad_to_dict(object):
|
|
"""
|
|
|
|
"""
|
|
value = object.__dict__
|
|
lang = get_language()
|
|
bad_fields = ['master_id', 'id', 'language_code']
|
|
value.update({key:value for key, value in object.translations.filter(language_code=lang).values()[0].iteritems() if key not in bad_fields})
|
|
return value
|
|
|