expomap/functions/forms.py

# -*- coding: utf-8 -*-
from django import forms
from django.utils.translation import ugettext_lazy as _
from theme.models import Theme
from haystack.query import SearchQuerySet
from django.db.models import ObjectDoesNotExist

class AdminSearchForm(forms.Form):
    search_name = forms.CharField(required=False, max_length=50)


class ThemeSearch(forms.Form):
    event = forms.MultipleChoiceField(required=False,
                                      widget=forms.CheckboxSelectMultiple(attrs={'class': 'topicChecks'}),
                                      choices=[('exposition', _(u'выставки')),
                                               ('conference', _(u'конференции')),
                                               ('seminar', _(u'семинары')),
                                               ('webinar', _(u'вебинары'))])
    theme = forms.ModelMultipleChoiceField(required=False, queryset=[],
                                            widget=forms.CheckboxSelectMultiple)



from country.models import Area
class PlaceSearch(forms.Form):
    r = forms.ModelMultipleChoiceField(queryset=Area.objects.all(), required=False,
                                             widget=forms.CheckboxSelectMultiple())
    c = forms.CharField(widget=forms.CheckboxSelectMultiple(), required=False)
    t = forms.CharField(widget=forms.CheckboxSelectMultiple())


class AbstractSearch(forms.Form):
    q = forms.CharField(label=_(u'Поиск'), required=False)
    w = forms.CharField(label=_(u'Где'), required=False)
    model = None

    def search(self):
        if not self.is_valid():
            return []

        q = self.cleaned_data.get('q')
        w = self.cleaned_data.get('w')

        if not q and not w:
            return []

        sqs = SearchQuerySet().models(self.model)
        if q:
            sqs = sqs.auto_query(q)
        if w:
            sqs = sqs.filter(where__contains=w)

        return sqs


        #sqs = SearchQuerySet().models(self.model).auto_query(self.cleaned_data.get('q'))

        #return sqs

from place_exposition.models import PlaceExposition
from place_exposition.models import EXPOSITION_TYPE

class SearchPlaceExpositionForm(AbstractSearch):
    model = PlaceExposition
    type = forms.ChoiceField(choices=EXPOSITION_TYPE, required=False)


from django.conf import settings
from django.utils.translation import get_language
from django.forms.models import save_instance

class TranslatableModelForm(forms.ModelForm):

    translatable_fields = []

    def __init__(self, *args, **kwargs):
        inst = kwargs.get('instance')
        veto_fields= ['id', 'master', 'language_code']
        self.all_tr_field_names = [field.name for field in self._meta.model.translations.related.editable_fields() if field.name not in veto_fields]
        if inst:
            init_tr_data = self.fill_init_field(inst)
            if kwargs['initial']:
                kwargs['initial'].update(init_tr_data)
            else:
                kwargs.update({'initial':init_tr_data})
        super(TranslatableModelForm, self).__init__(*args, **kwargs)
        if not self.translatable_fields:
            self.translatable_fields = self.all_tr_field_names
        fkwargs = {field.name: field for field in self._meta.model.translations.related.editable_fields() if field.name not in veto_fields}
        for code, name in settings.LANGUAGES:
            for tr_field in self.translatable_fields:
                field = fkwargs[tr_field].formfield()
                field.required=False
                self.fields[tr_field+"_"+code] = field

    def clean(self):
        data = self.cleaned_data
        init_lang = get_language()[:2]
        data.update(self.data_by_lang[init_lang])
        return data

    def save(self, commit=True):
        init_lang = get_language()[:2]
        data = self.cleaned_data
        langs = [code for code, _ in settings.LANGUAGES]
        is_new = not self.instance.pk
        inst = super(TranslatableModelForm, self).save()

        if is_new:
            for lang in self.data_by_lang:
                if lang is not init_lang:
                    inst.translate(lang)
                    for key, value in self.data_by_lang[lang].items():
                        setattr(inst, key, value)
                inst.save_translations(inst)
        else:
            translations = {obj.language_code:obj for obj in list(inst.translations.all())}
            for lang in self.data_by_lang:
                if lang is not init_lang:
                    try:
                        tr = translations[lang]
                    except KeyError: # there are no available translation in db
                        tr = inst.translate(lang)
                    for key, value in self.data_by_lang[lang].iteritems(): #{en:{name:adf, descr:jkdl}, ru:{name:fjfj, descr:jfjf}}
                        setattr(tr, key, value)
                    tr.save()
        self.instance = inst.lazy_translation_getter(init_lang)
        return self.instance

    @property
    def data_by_lang(self):
        res = {}
        for lang in [code for code, _ in settings.LANGUAGES]:
            res[lang] = {key[:-3]:self.cleaned_data[key] for key in self.cleaned_data if key.endswith("_%s"%lang)and self.cleaned_data[key]}
        result = {k: v for k, v in res.iteritems() if v}
        return result

    def fill_init_field(self, inst):
        init_tr_data = {}
        for code in inst.get_available_languages():
            translation = inst.translations.get(language_code=code)
            for field in self.all_tr_field_names:
                init_tr_data[field+"_%s" % code] = getattr(translation,field)
        return init_tr_data