expomap/apps/settings/forms.py

# -*- coding: utf-8 -*-
import os
import json
from itertools import chain

from django import forms
from django.core.exceptions import (
    MultipleObjectsReturned,
    ObjectDoesNotExist,
    ValidationError
)
from django.db.models import Q
from django.utils.encoding import force_text
# from django.utils.html import format_html
from django.utils.translation import ugettext as _
from django.conf import settings
from django.core.urlresolvers import reverse, reverse_lazy
from django.core.cache import cache

from functions.forms import (
    ExpoTranslatableModelForm,
    ExpoTranslatableModelForm_,
    ML_ModelMultipleChoiceField
)

from theme.models import Theme
from article.models import Article
from ckeditor.widgets import CKEditorWidget
from city.models import City
from country.models import Country

from .models import Html, LandingComment, ParticipationComment


class HtmlForm(ExpoTranslatableModelForm):
    class Meta:
        model = Html
        widgets = {
            'text': CKEditorWidget,
        }


class CommentForm(ExpoTranslatableModelForm_):
    class Meta:
        model = LandingComment

    @property
    def verbose(self):
        return _(u'Редактировать комментарий') if self.instance.pk else _(u'Создать комментарий')


class ParticipationCommentForm(CommentForm):
    class Meta:
        model = ParticipationComment


class OredredMixin(object):
    def clean(self, value):
        if self.required and not value:
            raise ValidationError(self.error_messages['required'])
        elif not self.required and not value:
            return self.queryset.none()
        if not isinstance(value, (list, tuple)):
            raise ValidationError(self.error_messages['list'])
        key = self.to_field_name or 'pk'
        values = []
        for pk in value:
            try:
                values.append(self.queryset.get(**{key: pk}))
            except (ValueError, MultipleObjectsReturned, ObjectDoesNotExist, ):
                raise ValidationError(self.error_messages['invalid_pk_value'] % pk)
        # qs = self.queryset.filter(**{'%s__in' % key: value})
        pks = set([force_text(getattr(o, key)) for o in values])
        for val in value:
            if force_text(val) not in pks:
                raise ValidationError(self.error_messages['invalid_choice'] % val)
        # Since this overrides the inherited ModelChoiceField.clean
        # we run custom validators here
        self.run_validators(value)
        return values


class OrderedModelMultipleChoiceField(OredredMixin, forms.ModelMultipleChoiceField):
    """A Ordered MultipleChoiceField whose choices are a model QuerySet."""
    pass


class OML_MMChoiceField(OredredMixin, ML_ModelMultipleChoiceField):
    pass


class MainPageThemes(forms.Form):
    exposition_themes = OrderedModelMultipleChoiceField(queryset=Theme.objects.filter(types=Theme.types.exposition),
                                                       required=False)
    conference_themes = OrderedModelMultipleChoiceField(queryset=Theme.objects.filter(types=Theme.types.conference),
                                                       required=False)

    def save(self):
        data = self.cleaned_data
        exposition_themes = data['exposition_themes']
        conference_themes = data['conference_themes']
        Theme.objects.filter(Q(main_page_expo__gt=0) | Q(main_page_conf__gt=0)).update(main_page_expo=0, main_page_conf=0)
        attributes = {'exposition_themes': 'main_page_expo', 'conference_themes': 'main_page_conf'}
        for obj_list in attributes.keys():
            for i, obj in enumerate(data[obj_list], 1):
                obj.__class__.objects.filter(pk=obj.pk).update(**{attributes[obj_list]: i})


class MainPageNews(forms.Form):
    main_page_news = forms.CharField(label=_(u'Новости'), widget=forms.HiddenInput(), required=False,)

    def save(self):
        data = self.cleaned_data
        news = data['main_page_news']
        Article.objects.news().exclude(id__in=[item.id for item in news]).update(main_page=0)
        news.update(main_page=1)

    def clean_main_page_news(self):
        news = self.cleaned_data['main_page_news']
        if news:
            news = news.split(',')
            qs = Article.objects.news().filter(id__in=news)
        else:
            qs = Article.objects.none()
        return qs


class MainPageArticle(forms.Form):
    article = forms.ModelMultipleChoiceField(queryset=Article.objects.blogs(), required=False,
                                             widget=forms.SelectMultiple(attrs={'style': 'width: 100%;'}))

    def save(self):
        data = self.cleaned_data
        articles = data['article']

        Article.objects.blogs().exclude(id__in=[item.id for item in articles]).update(main_page=0)
        articles.update(main_page=1)


class EventSectionSettingsForm(forms.Form):
    verbose = _(u'Блок "самые популярные"')
    expo_city = OML_MMChoiceField(label=_(u'Каталог городов (выставки)'),
        queryset=City.objects.all(), required=False)
    conf_city = OML_MMChoiceField(label=_(u'Каталог городов (конференции)'),
        queryset=City.objects.all(), required=False)
    expo_country = OML_MMChoiceField(label=_(u'Каталог стран (выставки)'),
        queryset=Country.objects.all(), required=False)
    conf_country = OML_MMChoiceField(label=_(u'Каталог стран (конференции)'),
        queryset=Country.objects.all(), required=False)

    def __init__(self, *args, **kwargs):
        super(EventSectionSettingsForm, self).__init__(*args, **kwargs)
        for name, field in self.fields.iteritems():
            model = field.queryset.model.__name__.lower()
            field.widget.attrs.update({
                'data-ajax-url': reverse('admin_{model}_search'.format(model=model)),
                'select2': 'true',
                })
            # if self.initial[name]:
            #     field.c_queryset = field.queryset.filter(pk__in=self.initial[name])
            #     field.widget.choices = field.choices

    def save(self):
        INI_CONFIG = settings.INI_CONFIG
        if not INI_CONFIG.has_section('sections'):
            INI_CONFIG.add_section('sections')
        for option in ['expo_city', 'conf_city', 'expo_country', 'conf_country']:
            INI_CONFIG.set('sections', option, json.dumps(map(lambda x: x.pk, self.cleaned_data.get(option))))
        with open(settings.INI_CONFIG_PATH, 'wb') as configfile:
            INI_CONFIG.write(configfile)
        for lang_code, name in settings.LANGUAGES:
            for key_attr in ['C_CITY_CATALOG_KEY', 'C_COUNTRY_CATALOG_KEY', 'E_CITY_CATALOG_KEY', 'E_COUNTRY_CATALOG_KEY']:
                cache.delete(getattr(settings, key_attr) + '_' + lang_code)


class EventDefaultDescriptionEditForm(forms.Form):
    e_description_ru = forms.CharField(label=_(u'Описание для выставки'), required=False, widget=CKEditorWidget)
    e_description_en = forms.CharField(label=_(u'Описание для выставки'), required=False, widget=CKEditorWidget)
    c_description_ru = forms.CharField(label=_(u'Описание для конференции'), required=False, widget=CKEditorWidget)
    c_description_en = forms.CharField(label=_(u'Описание для конференции'), required=False, widget=CKEditorWidget)

    def __init__(self, *args, **kwargs):
        super(EventDefaultDescriptionEditForm, self).__init__(*args, **kwargs)
        templates = settings.DEFAULT_DESCRIPTION
        for field_name, path in templates.iteritems():
            try:
                with open(os.path.join(settings.SITE_ROOT, 'templates', path), 'r') as f:
                    self.initial[field_name] = f.read()
            except Exception as e:
                print(e)

            # except:
                # pass

    def save(self):
        templates = settings.DEFAULT_DESCRIPTION
        for field_name, path in templates.iteritems():
            try:
                with open(os.path.join(settings.SITE_ROOT, 'templates', path), 'w+') as f:
                    f.write(self.cleaned_data.get(field_name).encode('utf-8'))
            except Exception as e:
                print(e)
                # pass