expomap/functions/models_methods.py

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 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):
        lang = translation.get_language()
        key = 'expo_main_page_key_%s'%lang
        result = cache.get(key)
        if not result:
            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



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):
        lang = translation.get_language()
        key = 'used_expo_cities_%s'%lang
        cached_cities = cache.get(key)
        if cached_cities:
            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):
        lang = translation.get_language()
        key = 'used_expo_cities_count_%s'%lang
        cached_cities = cache.get(key)
        if cached_cities:
            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 conference_cities_with_count(self):
        lang = translation.get_language()
        key = 'used_conference_cities_count_%s'%lang
        cached_cities = cache.get(key)
        if cached_cities:
            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):
        lang = translation.get_language()
        key = 'used_conference_cities_%s'%lang
        cached_cities = cache.get(key)
        if cached_cities:
            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):
        """
        not finished
        """
        lang = translation.get_language()
        key = 'used_cities_%s'%lang
        cached_cities = cache.get(key)
        if cached_cities:
            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 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