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.
431 lines
17 KiB
431 lines
17 KiB
# -*- coding: utf-8 -*-
|
|
import json
|
|
import ast
|
|
from django import forms
|
|
from django.contrib.auth.forms import ReadOnlyPasswordHashField
|
|
from django.forms.util import ErrorList
|
|
from django.utils.translation import ugettext as _
|
|
from models import User, Profile
|
|
from theme.models import Theme, Tag
|
|
from country.models import Area
|
|
from django.utils import translation
|
|
from country.models import Country
|
|
from city.models import City
|
|
from company.models import Company
|
|
from organiser.models import Organiser
|
|
#functions
|
|
from functions.form_check import translit_with_separator, is_latin
|
|
|
|
|
|
def clean_relation_field(inst, field_name, model):
|
|
id = inst.cleaned_data[field_name]
|
|
if id:
|
|
try:
|
|
return model.objects.get(id=id)
|
|
except model.DoesNotExist:
|
|
return None
|
|
return None
|
|
|
|
|
|
|
|
class UserCreationForm(forms.ModelForm):
|
|
password1 = forms.CharField(label='Пароль', widget=forms.PasswordInput(render_value=False))
|
|
password2 = forms.CharField(label='Повторите пароль', widget=forms.PasswordInput(render_value=False))
|
|
|
|
class Meta:
|
|
model = User
|
|
fields = ('email', 'first_name', 'last_name')
|
|
|
|
|
|
def clean_email(self):
|
|
"""
|
|
checking if user already exist
|
|
"""
|
|
email = self.cleaned_data.get('email')
|
|
try:
|
|
User.objects.get(email=email)
|
|
except User.DoesNotExist:
|
|
return email
|
|
raise forms.ValidationError('Пользователь с таким email уже существует')
|
|
|
|
def clean_password2(self):
|
|
password1 = self.cleaned_data.get('password1')
|
|
password2 = self.cleaned_data.get('password2')
|
|
|
|
if password1 and password2 and password1 != password2:
|
|
raise forms.ValidationError('Пароли не совпадают')
|
|
return password2
|
|
|
|
|
|
def save(self, commit=True):
|
|
user = super(UserCreationForm, self).save(commit=False)
|
|
user.set_password(self.cleaned_data['password2'])
|
|
|
|
if commit:
|
|
user.save()
|
|
|
|
return user
|
|
|
|
class UserChangeForm(forms.ModelForm):
|
|
password = ReadOnlyPasswordHashField()
|
|
|
|
class Meta:
|
|
model = User
|
|
|
|
def clean_password(self):
|
|
return self.initial['password']
|
|
|
|
|
|
|
|
class UserForm(forms.ModelForm):
|
|
#email = forms.EmailField(widget=forms.TextInput(attrs={'disabled' : True}), required=False)
|
|
country = forms.ChoiceField(label='Страна', choices=[(item.id, item.name) for item in Country.objects.all()], required=False)
|
|
city = forms.CharField(label='Город', widget=forms.HiddenInput())
|
|
company = forms.ChoiceField(label='Компания', choices=[(item.id, item.name) for item in Company.objects.language().all()], required=False)
|
|
organiser = forms.ChoiceField(label='Организатор', choices=[(item.id, item.name) for item in Organiser.objects.language().all()], required=False)
|
|
title = forms.CharField(widget=forms.TextInput(attrs={'style':'width: 550px'}), required=False)
|
|
descriptions = forms.CharField(widget=forms.TextInput(attrs={'style':'width: 550px'}), required=False)
|
|
keywords = forms.CharField(widget=forms.TextInput(attrs={'style':'width: 550px'}), required=False)
|
|
phone = forms.CharField(widget=forms.TextInput(attrs={'style':'width: 550px'}), required=False)
|
|
web_page = forms.URLField(required=False)
|
|
about = forms.CharField(widget=forms.Textarea())
|
|
|
|
class Meta:
|
|
model = User
|
|
exclude = ('username', 'email','last_login', 'password', 'is_active', 'is_admin', 'is_superuser', 'is_staff'
|
|
'date_joined', 'date_registered', 'date_modified')
|
|
|
|
def save(self, force_insert=False, force_update=False, commit=True):
|
|
|
|
user = super(UserForm, self).save(commit=False)
|
|
data = self.cleaned_data
|
|
profile = user.profile
|
|
profile.country = data.get('country')
|
|
profile.city = data.get('city')
|
|
profile.title = data.get('title', '')
|
|
profile.descriptions = data.get('descriptions', '')
|
|
profile.keywords = data.get('keywords', '')
|
|
profile.phone = data.get('phone')
|
|
profile.web_page = data.get('web_page')
|
|
profile.about = data.get('about')
|
|
|
|
if commit:
|
|
user.save()
|
|
profile.save()
|
|
return user
|
|
|
|
"""
|
|
def clean_url(self):
|
|
url = self.cleaned_data.get('url')
|
|
try:
|
|
user = User.objects.get(url=translit_with_separator(url))
|
|
if (user.url == translit_with_separator(url)):
|
|
return url
|
|
except:
|
|
return url
|
|
raise forms.ValidationError('Такой урл уже занят')
|
|
"""
|
|
|
|
def clean_organiser(self):
|
|
return clean_relation_field(self, 'organiser', Organiser)
|
|
|
|
|
|
def clean_company(self):
|
|
return clean_relation_field(self, 'company', Company)
|
|
|
|
def clean_country(self):
|
|
return clean_relation_field(self, 'country', Country)
|
|
|
|
def clean_city(self):
|
|
return clean_relation_field(self, 'city', City)
|
|
|
|
|
|
def clean_phone(self):
|
|
"""
|
|
phone code checking
|
|
"""
|
|
cleaned_data = super(UserForm, self).clean()
|
|
phone = cleaned_data.get('phone')
|
|
if not phone:
|
|
return
|
|
|
|
deduct = ('-','(',')','.',' ')
|
|
for elem in deduct:
|
|
phone = phone.replace(elem, '')
|
|
if phone.isdigit():
|
|
return phone
|
|
else:
|
|
raise forms.ValidationError('Введите правильный код страны')
|
|
"""
|
|
def clean_web_page(self):
|
|
cleaned_data = super(UserForm, self).clean()
|
|
web_page = cleaned_data.get('web_page')
|
|
if not web_page:
|
|
return web_page
|
|
|
|
import socket
|
|
try:
|
|
socket.getaddrinfo(web_page, 80)
|
|
return web_page
|
|
except:
|
|
return forms.ValidationError('Введите правильный адрес страници')
|
|
"""
|
|
|
|
class ChangePasswordForm(forms.Form):
|
|
"""
|
|
Form to change password
|
|
"""
|
|
old_password = forms.CharField(label=_(u'Old password'), required=True,
|
|
widget=forms.PasswordInput(render_value=False,
|
|
attrs={'placeholder': _(u'Введите старый пароль')}))
|
|
new_password = forms.CharField(label=_(u'New password'), required=True,
|
|
widget=forms.PasswordInput(render_value=False,
|
|
attrs={'placeholder': _(u'Придумайте новый пароль')}))
|
|
new_password_confirm = forms.CharField(label=_(u'Confirm password'), required=True,
|
|
widget=forms.PasswordInput(render_value=False,
|
|
attrs={'placeholder': _(u'Повторите новый пароль')}))
|
|
|
|
def clean(self):
|
|
data = super(ChangePasswordForm, self).clean()
|
|
password1 = data.get('new_password')
|
|
password2 = data.get('new_password_confirm')
|
|
if not password1 or not password2:
|
|
return data
|
|
# self._errors['new_password'] = ErrorList([_(u'Different passwords!')])
|
|
# return data
|
|
if password1 and password2 and password1 != password2:
|
|
# check if passwords exists and equal
|
|
self._errors['new_password'] = ErrorList([_(u'Пароли не совпадают!')])
|
|
self._errors['new_password_confirm'] = ErrorList([_(u'Пароли не совпадают!')])
|
|
del data['new_password_confirm']
|
|
del data['new_password']
|
|
return data
|
|
if not password1.isdigit() and any(char.isdigit() for char in password1) and len(password1)>5:
|
|
# password must contain digits and letters and length > 5
|
|
return data
|
|
else:
|
|
self._errors['new_password'] = ErrorList([_(u'Пароль должен содержать цифры и буквы')])
|
|
self._errors['new_password_confirm'] = ErrorList([_(u'Пароль должен содержать цифры и буквы')])
|
|
del data['new_password']
|
|
del data['new_password_confirm']
|
|
return data
|
|
|
|
class EmailAnnouncementForm(forms.Form):
|
|
data = [(1, _(u'Получать приглашения, сообщения и другую корреспонденцию от пользователей Expomap')),
|
|
(2, _(u'Получать обзор событий')),
|
|
(3, _(u'Получать новости'))]
|
|
announcement = forms.MultipleChoiceField(choices=data, widget=forms.CheckboxSelectMultiple())
|
|
|
|
|
|
class RegistrationCompleteForm(forms.ModelForm):
|
|
country = forms.ChoiceField(label='Страна', choices=[(c.id, c.name) for c in Country.objects.all()],
|
|
widget=forms.Select(attrs={'class': 'select2'}))
|
|
city = forms.CharField(label='Город', widget=forms.HiddenInput())
|
|
url = forms.CharField(widget=forms.TextInput(attrs={'placeholder': _(u'адрес страны(обязательно)')}))
|
|
|
|
code_country = forms.ChoiceField(label=_(u'код страны'), initial='70',
|
|
choices=[(str(c.phone_code), '+'+str(c.phone_code)) for c in Country.objects.all() if c.phone_code is not None],
|
|
widget=forms.Select(attrs={'class': 'select2'}))
|
|
code_city = forms.CharField(label=_(u'код города'))
|
|
phone = forms.CharField(label=_(u'ваш номер'))
|
|
class Meta:
|
|
model = User
|
|
fields = ('url',)
|
|
|
|
|
|
def save(self, force_insert=False, force_update=False, commit=True):
|
|
user = super(RegistrationCompleteForm, self).save(commit=False)
|
|
data = self.cleaned_data
|
|
phone = data['code_country']+data['code_city']+data['phone']
|
|
|
|
user.profile.phone = int(phone)
|
|
user.profile.country = data['country']
|
|
user.profile.city = data['city']
|
|
user.profile.save()
|
|
|
|
if commit:
|
|
user.save()
|
|
return user
|
|
|
|
def clean_city(self):
|
|
try:
|
|
return City.objects.get(id=self.cleaned_data['city'])
|
|
except City.DoesNotExist:
|
|
return None
|
|
|
|
|
|
def clean_country(self):
|
|
try:
|
|
return Country.objects.get(id=self.cleaned_data['country'])
|
|
except City.DoesNotExist:
|
|
return None
|
|
|
|
def clean_url(self):
|
|
url = self.cleaned_data['url']
|
|
if not is_latin(url):
|
|
raise forms.ValidationError(_(u'url должен состоять только из латинских букв'))
|
|
|
|
try:
|
|
User.objects.get(url=url)
|
|
raise forms.ValidationError(_(u'Пользователь с таким url уже существует'))
|
|
except User.DoesNotExist:
|
|
return url
|
|
|
|
|
|
|
|
|
|
class RecoveryForm(forms.Form):
|
|
email = forms.EmailField(widget=forms.TextInput(attrs={'placeholder': _(u'Email')}))
|
|
|
|
def get_user(self):
|
|
email = self.cleaned_data['email']
|
|
return User.objects.get(email=email)
|
|
|
|
def clean_email(self):
|
|
email = self.cleaned_data['email']
|
|
try:
|
|
return User.objects.get(email=email)
|
|
except User.DoesNotExist:
|
|
raise forms.ValidationError(_(u'Пользователь с таким емейлом не зарегестрирован'))
|
|
|
|
|
|
|
|
class UserFilterForm(forms.Form):
|
|
model = User
|
|
email = forms.CharField(label=_(u'Email'), required=False)
|
|
def filter(self):
|
|
"""
|
|
|
|
return filtered queryset
|
|
form must be cleaned before calling this method
|
|
|
|
"""
|
|
data = self.cleaned_data
|
|
email = data['email']
|
|
model = self.model
|
|
qs = model.objects.all()
|
|
if email:
|
|
qs = qs.filter(email__contains=email)
|
|
|
|
return qs
|
|
|
|
|
|
|
|
class FeedFilterForm(forms.Form):
|
|
data_with_parents = None
|
|
filter = None
|
|
th = forms.MultipleChoiceField(label=_(u'Тематика'), choices=[(item.id, item.name) for item in Theme.active.all()],
|
|
required=False, widget=forms.CheckboxSelectMultiple())
|
|
tg = forms.CharField(label=_(u'Теги'), required=False, widget=forms.CheckboxSelectMultiple())
|
|
area = forms.MultipleChoiceField(label=_(u'Регион'), choices=[(item.id, item.name) for item in Area.objects.all_sorted()],
|
|
required=False, widget=forms.CheckboxSelectMultiple())
|
|
co = forms.MultipleChoiceField(label=_(u'Страна'), required=False, widget=forms.CheckboxSelectMultiple(),
|
|
choices=[(item.id, item.name) for item in Country.objects.select_related('exposition_country')\
|
|
.filter(exposition_country__country__isnull=False, translations__language_code=translation.get_language())\
|
|
.order_by('translations__name').distinct()]
|
|
)
|
|
|
|
ci = forms.MultipleChoiceField(label=_(u'Город'), required=False, widget=forms.CheckboxSelectMultiple(),
|
|
choices=[(item.id, item.name) for item in City.objects.select_related('exposition_city')\
|
|
.filter(exposition_city__city__isnull=False, translations__language_code=translation.get_language())\
|
|
.order_by('translations__name').distinct()]
|
|
)
|
|
|
|
fr = forms.DateField(required=False,
|
|
widget=forms.DateInput(attrs={'class': 'date', 'id': 'dateFrom',
|
|
'placeholder': _(u'дд.мм.гггг')}))
|
|
to = forms.DateField(required=False,
|
|
widget=forms.DateInput(attrs={'class': 'date', 'id': 'dateTo',
|
|
'placeholder': _(u'дд.мм.гггг')}))
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
user = kwargs.get('user')
|
|
if 'user' in kwargs: del kwargs['user']
|
|
super(FeedFilterForm, self).__init__(*args, **kwargs)
|
|
filter = user.eventfilter
|
|
self.filter = filter
|
|
self.data_with_parents = self.get_form_data(filter)
|
|
|
|
|
|
def get_form_data(self, filter):
|
|
|
|
|
|
if filter.area.exists():
|
|
areas = [{'name':'area', 'id':item.id, 'parent':None, 'text':item.name} for item in filter.area.all()]
|
|
else:
|
|
areas = []
|
|
|
|
if filter.country.exists():
|
|
cos = []
|
|
for country in filter.country.all():
|
|
cos.append({'name':'area', 'id':country.area_id, 'text': country.area.name, 'children':{
|
|
'id': country.id, 'name':'co', 'text': country.name
|
|
}
|
|
})
|
|
else:
|
|
cos = []
|
|
|
|
if filter.city.exists():
|
|
cis = []
|
|
for city in filter.city.all():
|
|
cis.append({'name':'area', 'id': city.country.area_id, 'text': city.country.area.name, 'children':{
|
|
'id': city.country_id, 'name':'co', 'text': city.country.name, 'children':{
|
|
'name':'ci', 'id':city.id, 'text':city.name
|
|
}
|
|
}
|
|
})
|
|
else:
|
|
cis = []
|
|
|
|
if filter.theme.exists():
|
|
|
|
ths = [{'name':'th', 'id':item.id, 'parent':None, 'text':item.name} for item in filter.theme.all()]
|
|
else:
|
|
ths = []
|
|
|
|
if filter.tag.exists():
|
|
tgs = []
|
|
for tag in filter.tag.all():
|
|
|
|
|
|
tgs.append({'name':'th', 'id':tag.theme_id, 'text': tag.theme.name, 'children':{
|
|
'id': tag.id, 'name':'tg', 'text': tag.name
|
|
}
|
|
})
|
|
else:
|
|
tgs = []
|
|
|
|
finale_list = areas + cos + cis + ths + tgs
|
|
result = {'inputs': finale_list}
|
|
result = json.dumps(result)
|
|
return result
|
|
|
|
def filter_save(self):
|
|
theme = self.cleaned_data['th']
|
|
tag = self.cleaned_data['tg']
|
|
area = self.cleaned_data['area']
|
|
country = self.cleaned_data['co']
|
|
city = self.cleaned_data['ci']
|
|
filter = self.filter
|
|
|
|
filter.theme.clear()
|
|
filter.theme.add(*Theme.objects.filter(id__in=theme))
|
|
|
|
filter.tag.clear()
|
|
filter.tag.add(*Tag.objects.filter(id__in=tag))
|
|
|
|
filter.area.clear()
|
|
filter.area.add(*Area.objects.filter(id__in=area))
|
|
filter.country.clear()
|
|
filter.country.add(*Country.objects.filter(id__in=country))
|
|
|
|
filter.city.clear()
|
|
filter.city.add(*City.objects.filter(id__in=city))
|
|
|
|
def clean_tg(self):
|
|
|
|
tg = self.cleaned_data.get('tg')
|
|
if tg:
|
|
res = ast.literal_eval(tg)
|
|
return res
|
|
return tg |