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.
475 lines
19 KiB
475 lines
19 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 django.conf import settings
|
|
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(), required=False)
|
|
company = forms.ChoiceField(label='Компания',
|
|
choices=[(item.id, item.name) for item in Company.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(), required=False)
|
|
avatar = forms.ImageField(required=False)
|
|
# ---
|
|
skype = forms.CharField(required=False)
|
|
facebook = forms.URLField(required=False)
|
|
twitter = forms.URLField(required=False)
|
|
linkedin = forms.URLField(required=False)
|
|
vk = forms.URLField(required=False)
|
|
|
|
new_password = forms.CharField(required=False, min_length=6, max_length=60,
|
|
widget=forms.TextInput(attrs={'class': 'new_password'}))
|
|
|
|
class Meta:
|
|
model = User
|
|
exclude = ('organiser', 'username', 'email', 'last_login', 'password', 'is_admin', 'rating', 'is_superuser', 'is_staff'
|
|
'date_joined',
|
|
'date_registered', 'date_modified', 'is_active')
|
|
|
|
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')
|
|
profile.skype = data.get('skype', '')
|
|
profile.facebook = data.get('facebook', '')
|
|
profile.twitter = data.get('twitter', '')
|
|
profile.linkedin = data.get('linkedin', '')
|
|
profile.vk = data.get('vk', '')
|
|
profile.avatar = data.get('avatar')
|
|
|
|
if data['new_password']:
|
|
new_pass = data['new_password']
|
|
user.set_password(new_pass)
|
|
user.email_user('Reset password', 'Your new password: "%s" ' % new_pass, settings.DEFAULT_FROM_EMAIL, )
|
|
|
|
if commit:
|
|
user.save()
|
|
profile.save()
|
|
return user
|
|
|
|
#def clean_url(self):
|
|
# url = self.cleaned_data.get('url')
|
|
# if url:
|
|
# if User.objects.get(url=translit_with_separator(url)):
|
|
# raise forms.ValidationError('Такой урл уже занят')
|
|
# else:
|
|
# return url
|
|
|
|
#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.ModelChoiceField(label='Страна', queryset=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'url(обязательно)')}))
|
|
|
|
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_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 SocialRegistrationCompleteForm(RegistrationCompleteForm):
|
|
email = forms.EmailField(widget=forms.TextInput(attrs={'placeholder': _(u'Email')}), required=True)
|
|
|
|
class Meta:
|
|
model = User
|
|
fields = ['email', 'url']
|
|
|
|
def save(self, force_insert=False, force_update=False, commit=True):
|
|
email = self.cleaned_data['email']
|
|
if User.objects.filter(email=email).exists():
|
|
# pass to the view user, that had account before
|
|
user = User.objects.get(email=email)
|
|
# social = UserSocialAuth.objects.get(user=self.instance)
|
|
# social.user = user # that cause AuthAlreadyAssociated error!
|
|
else:
|
|
# create new user, with data from social auth
|
|
user = super(RegistrationCompleteForm, self).save(commit=False) # creating new user
|
|
user.username = email
|
|
|
|
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
|
|
|
|
|
|
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'Пользователь с таким емейлом не зарегестрирован'))
|
|
|
|
|
|
from django.db.models import Q
|
|
|
|
|
|
class UserFilterForm(forms.Form):
|
|
model = User
|
|
search_req = forms.CharField(label=_(u'Введите e-mail, имя или фамилию для запроса'), required=False)
|
|
|
|
def filter(self):
|
|
"""
|
|
|
|
return filtered queryset
|
|
form must be cleaned before calling this method
|
|
|
|
"""
|
|
data = self.cleaned_data
|
|
search_req = data['search_req']
|
|
words = search_req.split()
|
|
model = self.model
|
|
qs = model.objects.all()
|
|
if len(words) > 1:
|
|
qs = qs.filter(Q(first_name__contains=words[0]) & Q(last_name__contains=words[1]))
|
|
elif words:
|
|
qs = qs.filter(
|
|
Q(email__contains=search_req) | Q(first_name__contains=search_req) | Q(last_name__contains=search_req))
|
|
|
|
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.language().all()],
|
|
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.expo_countries()]
|
|
)
|
|
|
|
ci = forms.MultipleChoiceField(label=_(u'Город'), required=False, widget=forms.CheckboxSelectMultiple(),
|
|
choices=[(item.id, item.name) for item in City.used.expo_cities()]
|
|
)
|
|
|
|
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
|
|
|