class ClassicRegisterForm(SetPasswordForm):
""" legacy registration form """
next = NextUrlField()
username = UserNameField(widget_attrs={'tabindex': 0})
email = UserEmailField()
login_provider = PasswordLoginProviderField()
class EmailPasswordForm(forms.Form):
""" send new password form """
username = UserNameField(
skip_clean=True,
label=mark_safe(ugettext_lazy('Your user name (<i>required</i>)')))
def __init__(self,
data=None,
files=None,
auto_id='id_%s',
prefix=None,
initial=None):
super(EmailPasswordForm, self).__init__(data, files, auto_id, prefix,
initial)
self.user_cache = None
def clean_username(self):
""" get user for this username """
if 'username' in self.cleaned_data:
try:
self.user_cache = User.objects.get(
username=self.cleaned_data['username'])
except:
raise forms.ValidationError(
_("sorry, there is no such user name"))
return self.cleaned_data['username']
class OpenidRegisterForm(forms.Form):
""" openid signin form """
next = NextUrlField()
username = UserNameField(widget_attrs={'tabindex': 0})
email = UserEmailField()
def __init__(self, *args, **kwargs):
super(OpenidRegisterForm, self).__init__(*args, **kwargs)
if askbot_settings.TERMS_CONSENT_REQUIRED:
self.fields['terms_accepted'] = ConsentField()
class ClassicRegisterForm(SetPasswordForm):
""" legacy registration form """
next = NextUrlField()
username = UserNameField(widget_attrs={'tabindex': 0})
email = UserEmailField()
#fields password1 and password2 are inherited
def __init__(self, *args, **kwargs):
super(ClassicRegisterForm, self).__init__(*args, **kwargs)
if askbot_settings.TERMS_CONSENT_REQUIRED:
self.fields['terms_accepted'] = ConsentField()
class ClassicRegisterForm(SetPasswordForm):
""" legacy registration form """
next = NextUrlField()
username = UserNameField(widget_attrs={'tabindex': 0})
#fields password1 and password2 are inherited
def __init__(self, *args, **kwargs):
super(ClassicRegisterForm, self).__init__(*args, **kwargs)
email_required = not askbot_settings.BLANK_EMAIL_ALLOWED
self.fields['email'] = UserEmailField(required=email_required)
if askbot_settings.TERMS_CONSENT_REQUIRED:
self.fields['terms_accepted'] = ConsentField()
def clean(self):
if askbot_settings.NEW_REGISTRATIONS_DISABLED:
raise forms.ValidationError(askbot_settings.NEW_REGISTRATIONS_DISABLED_MESSAGE)
data = super(ClassicRegisterForm, self).clean()
return data
class RegistrationForm(forms.Form):
""" openid signin form """
next = NextUrlField()
username = UserNameField(widget_attrs={'tabindex': 0})
def __init__(self, *args, **kwargs):
self.request = kwargs.pop('request', None)
super(RegistrationForm, self).__init__(*args, **kwargs)
email_required = not askbot_settings.BLANK_EMAIL_ALLOWED
self.fields['email'] = UserEmailField(required=email_required)
if askbot_settings.TERMS_CONSENT_REQUIRED:
self.fields['terms_accepted'] = ConsentField()
if askbot_settings.USE_RECAPTCHA:
self.fields['recaptcha'] = AskbotReCaptchaField()
def clean(self):
if askbot_settings.NEW_REGISTRATIONS_DISABLED:
raise forms.ValidationError(askbot_settings.NEW_REGISTRATIONS_DISABLED_MESSAGE)
return super(RegistrationForm, self).clean()
def __init__(self, user, *args, **kwargs):
super(EditUserForm, self).__init__(*args, **kwargs)
logging.debug('initializing the form')
if askbot_settings.EDITABLE_SCREEN_NAME:
self.fields['username'] = UserNameField(label=_('Screen name'))
self.fields['username'].initial = user.username
self.fields['username'].user_instance = user
self.fields['email'].initial = user.email
self.fields['realname'].initial = user.real_name
self.fields['website'].initial = user.website
self.fields['city'].initial = user.location
if user.country == None:
country = 'unknown'
else:
country = user.country
self.fields['country'].initial = country
self.fields['show_country'].initial = user.show_country
if user.date_of_birth is not None:
self.fields['birthday'].initial = user.date_of_birth
self.fields['about'].initial = user.about
self.user = user
class OpenidRegisterForm(forms.Form):
""" openid signin form """
next = NextUrlField()
username = UserNameField(widget_attrs={'tabindex': 0})
email = UserEmailField()
class LoginForm(forms.Form):
"""All-inclusive login form.
handles the following:
* password login
* change of password
* openid login (of all types - direct, usename, generic url-based)
* oauth login
* facebook login (javascript-based facebook's sdk)
"""
next = NextUrlField()
login_provider_name = LoginProviderField()
openid_login_token = forms.CharField(
max_length=256,
required=False,
)
username = UserNameField(required=False, skip_clean=True)
password = forms.CharField(
max_length=128,
widget=forms.widgets.PasswordInput(attrs={'class': 'required login'}),
required=False)
password_action = forms.CharField(max_length=32,
required=False,
widget=forms.widgets.HiddenInput())
new_password = forms.CharField(
max_length=128,
widget=forms.widgets.PasswordInput(attrs={'class': 'required login'}),
required=False)
new_password_retyped = forms.CharField(
max_length=128,
widget=forms.widgets.PasswordInput(attrs={'class': 'required login'}),
required=False)
def set_error_if_missing(self, field_name, error_message):
"""set's error message on a field
if the field is not present in the cleaned_data dictionary
"""
if field_name not in self.cleaned_data:
self._errors[field_name] = self.error_class([error_message])
def set_password_login_error(self):
"""sets a parameter flagging that login with
password had failed
"""
#add monkey-patch parameter
#this is used in the signin.html template
self.password_login_failed = True
def set_password_change_error(self):
"""sets a parameter flagging that
password change failed
"""
#add monkey-patch parameter
#this is used in the signin.html template
self.password_change_failed = True
def clean(self):
"""besides input data takes data from the
login provider settings
and stores final digested data into
the cleaned_data
the idea is that cleaned data can be used directly
to enact the signin action, without post-processing
of the data
contents of cleaned_data depends on the type
of login
"""
providers = util.get_enabled_login_providers()
if 'login_provider_name' in self.cleaned_data:
provider_name = self.cleaned_data['login_provider_name']
else:
raise forms.ValidationError('no login provider specified')
provider_data = providers[provider_name]
provider_type = provider_data['type']
if provider_type == 'password':
self.do_clean_password_fields()
self.cleaned_data['login_type'] = 'password'
elif provider_type.startswith('openid'):
self.do_clean_openid_fields(provider_data)
self.cleaned_data['login_type'] = 'openid'
elif provider_type == 'oauth':
self.cleaned_data['login_type'] = 'oauth'
elif provider_type == 'oauth2':
self.cleaned_data['login_type'] = 'oauth2'
elif provider_type == 'facebook':
self.cleaned_data['login_type'] = 'facebook'
#self.do_clean_oauth_fields()
elif provider_type == 'wordpress_site':
self.cleaned_data['login_type'] = 'wordpress_site'
return self.cleaned_data
def do_clean_openid_fields(self, provider_data):
"""returns fake openid_url value
created based on provider_type (subtype of openid)
and the
"""
openid_endpoint = provider_data['openid_endpoint']
openid_type = provider_data['type']
if openid_type == 'openid-direct':
openid_url = openid_endpoint
else:
error_message = _('Please enter your %(username_token)s') % \
{'username_token': provider_data['extra_token_name']}
self.set_error_if_missing('openid_login_token', error_message)
if 'openid_login_token' in self.cleaned_data:
openid_login_token = self.cleaned_data['openid_login_token']
if openid_type == 'openid-username':
openid_url = openid_endpoint % {
'username': openid_login_token
}
elif openid_type == 'openid-generic':
openid_url = openid_login_token
else:
raise ValueError('unknown openid type %s' % openid_type)
self.cleaned_data['openid_url'] = openid_url
def do_clean_password_fields(self):
"""cleans password fields appropriate for
the selected password_action, which can be either
"login" or "change_password"
new password is checked for minimum length and match to initial entry
"""
password_action = self.cleaned_data.get('password_action', None)
if password_action == 'login':
#if it's login with password - password and user name are required
self.set_error_if_missing('username',
_('Please, enter your user name'))
self.set_error_if_missing('password',
_('Please, enter your password'))
elif password_action == 'change_password':
#if it's change password - new_password and new_password_retyped
self.set_error_if_missing('new_password',
_('Please, enter your new password'))
self.set_error_if_missing('new_password_retyped',
_('Please, enter your new password'))
field_set = set(('new_password', 'new_password_retyped'))
if field_set.issubset(self.cleaned_data.keys()):
new_password = self.cleaned_data['new_password'].strip()
new_password_retyped = self.cleaned_data[
'new_password_retyped'].strip()
if new_password != new_password_retyped:
error_message = _('Passwords did not match')
error = self.error_class([error_message])
self._errors['new_password_retyped'] = error
self.set_password_change_error()
del self.cleaned_data['new_password']
del self.cleaned_data['new_password_retyped']
else:
#validate password
if len(new_password) < askbot_const.PASSWORD_MIN_LENGTH:
del self.cleaned_data['new_password']
del self.cleaned_data['new_password_retyped']
error_message = _(
'choose password > %(len)s characters') % {
'len': askbot_const.PASSWORD_MIN_LENGTH
}
error = self.error_class([error_message])
self._errors['new_password'] = error
self.set_password_change_error()
else:
error_message = 'unknown password action'
logging.critical(error_message)
self._errors['password_action'] = self.error_class([error_message])
raise forms.ValidationError(error_message)
class OpenidRegisterForm(forms.Form):
""" openid signin form """
next = NextUrlField()
username = UserNameField()
email = UserEmailField()
