]> git.openstreetmap.org Git - osqa.git/blob - forum/forms/general.py
Adds the option to create static pages with several options to customize its behaviour.
[osqa.git] / forum / forms / general.py
1 from django import forms
2 import re
3 from django.utils.translation import ugettext as _
4 from django.utils.safestring import mark_safe
5 from forum import settings
6 from django.http import str_to_unicode
7 from forum.models import User
8 import urllib
9
10 DEFAULT_NEXT = '/' + getattr(settings, 'FORUM_SCRIPT_ALIAS')
11 def clean_next(next):
12     if next is None:
13         return DEFAULT_NEXT
14     next = str_to_unicode(urllib.unquote(next), 'utf-8')
15     next = next.strip()
16     if next.startswith('/'):
17         return next
18     return DEFAULT_NEXT
19
20 def get_next_url(request):
21     return clean_next(request.REQUEST.get('next'))
22
23 class StrippedNonEmptyCharField(forms.CharField):
24     def clean(self,value):
25         value = value.strip()
26         if self.required and value == '':
27             raise forms.ValidationError(_('this field is required'))
28         return value
29
30 class NextUrlField(forms.CharField):
31     def __init__(self):
32         super(NextUrlField,self).__init__(max_length = 255,widget = forms.HiddenInput(),required = False)
33     def clean(self,value):
34         return clean_next(value)
35
36 login_form_widget_attrs = { 'class': 'required login' }
37 username_re = re.compile(r'^[\w\s ]+$', re.UNICODE)
38
39 class UserNameField(StrippedNonEmptyCharField):
40     def __init__(self,db_model=User, db_field='username', must_exist=False,skip_clean=False,label=_('choose a username'),**kw):
41         self.must_exist = must_exist
42         self.skip_clean = skip_clean
43         self.db_model = db_model 
44         self.db_field = db_field
45         error_messages={'required':_('user name is required'),
46                         'taken':_('sorry, this name is taken, please choose another'),
47                         'forbidden':_('sorry, this name is not allowed, please choose another'),
48                         'missing':_('sorry, there is no user with this name'),
49                         'multiple-taken':_('sorry, we have a serious error - user name is taken by several users'),
50                         'invalid':_('user name can only consist of letters, empty space and underscore'),
51                         'toshort':_('user name is to short, please use at least %d characters') % settings.MIN_USERNAME_LENGTH
52                     }
53         if 'error_messages' in kw:
54             error_messages.update(kw['error_messages'])
55             del kw['error_messages']
56         super(UserNameField,self).__init__(max_length=30,
57                 widget=forms.TextInput(attrs=login_form_widget_attrs),
58                 label=label,
59                 error_messages=error_messages,
60                 **kw
61                 )
62
63     def clean(self,username):
64         """ validate username """
65         if self.skip_clean == True:
66             return username
67         if hasattr(self, 'user_instance') and isinstance(self.user_instance, User):
68             if username == self.user_instance.username:
69                 return username
70         try:
71             username = super(UserNameField, self).clean(username)
72         except forms.ValidationError:
73             raise forms.ValidationError(self.error_messages['required'])
74         if len(username) < settings.MIN_USERNAME_LENGTH:
75             raise forms.ValidationError(self.error_messages['toshort'])
76         if self.required and not username_re.match(username):
77             raise forms.ValidationError(self.error_messages['invalid'])
78         if username in settings.RESERVED_USERNAMES:
79             raise forms.ValidationError(self.error_messages['forbidden'])
80         try:
81             user = self.db_model.objects.get(
82                     **{'%s' % self.db_field : username}
83             )
84             if user:
85                 if self.must_exist:
86                     return username
87                 else:
88                     raise forms.ValidationError(self.error_messages['taken'])
89         except self.db_model.DoesNotExist:
90             if self.must_exist:
91                 raise forms.ValidationError(self.error_messages['missing'])
92             else:
93                 return username
94         except self.db_model.MultipleObjectsReturned:
95             raise forms.ValidationError(self.error_messages['multiple-taken'])
96
97 class UserEmailField(forms.EmailField):
98     def __init__(self,skip_clean=False,**kw):
99         self.skip_clean = skip_clean
100         super(UserEmailField,self).__init__(widget=forms.TextInput(attrs=dict(login_form_widget_attrs,
101             maxlength=200)), label=mark_safe(_('your email address')),
102             error_messages={'required':_('email address is required'),
103                             'invalid':_('please enter a valid email address'),
104                             'taken':_('this email is already used by someone else, please choose another'),
105                             },
106             **kw
107             )
108
109     def clean(self,email):
110         """ validate if email exist in database
111         from legacy register
112         return: raise error if it exist """
113         email = super(UserEmailField,self).clean(email.strip())
114         if self.skip_clean:
115             return email
116         if settings.EMAIL_UNIQUE == True:
117             try:
118                 user = User.objects.get(email = email)
119                 raise forms.ValidationError(self.error_messages['taken'])
120             except User.DoesNotExist:
121                 return email
122             except User.MultipleObjectsReturned:
123                 raise forms.ValidationError(self.error_messages['taken'])
124         else:
125             return email 
126
127 class SetPasswordForm(forms.Form):
128     password1 = forms.CharField(widget=forms.PasswordInput(attrs=login_form_widget_attrs),
129                                 label=_('choose password'),
130                                 error_messages={'required':_('password is required')},
131                                 )
132     password2 = forms.CharField(widget=forms.PasswordInput(attrs=login_form_widget_attrs),
133                                 label=mark_safe(_('retype password')),
134                                 error_messages={'required':_('please, retype your password'),
135                                                 'nomatch':_('sorry, entered passwords did not match, please try again')},
136                                 )
137
138     def __init__(self, data=None, user=None, *args, **kwargs):
139         super(SetPasswordForm, self).__init__(data, *args, **kwargs)
140
141     def clean_password2(self):
142         """
143         Validates that the two password inputs match.
144         
145         """
146         if 'password1' in self.cleaned_data:
147             if self.cleaned_data['password1'] == self.cleaned_data['password2']:
148                 self.password = self.cleaned_data['password2']
149                 self.cleaned_data['password'] = self.cleaned_data['password2']
150                 return self.cleaned_data['password2']
151             else:
152                 del self.cleaned_data['password2']
153                 raise forms.ValidationError(self.fields['password2'].error_messages['nomatch'])
154         else:
155             return self.cleaned_data['password2']
156