Merge branch '0.8.x' into 0.9.x

askbot/deps/django_authopenid/backends.py

@@ -33,17 +33,18 @@ def __init__(self, *args, **kwargs):
         self.login_providers = util.get_enabled_login_providers()
         super(AuthBackend, self).__init__(*args, **kwargs)
 
-    def authenticate(self, method=None, provider_name=None, **kwargs):
+    def authenticate(self, method=None, provider_name=None, request=None, **kwargs):
         """this authentication function supports many login methods"""
         if method == 'password':
             return self.auth_by_password(
                                 provider_name,
                                 kwargs['username'],
-                                kwargs['password']
+                                kwargs['password'],
+                                request
                             )
 
         elif method == 'ldap':
-            return self.auth_by_ldap(kwargs['username'], kwargs['password'])
+            return self.auth_by_ldap(kwargs['username'], kwargs['password'], request)
 
         elif method == 'identifier':
             #methods supporting this are: openid, mozilla-persona, oauth1, oauth2,
@@ -72,11 +73,12 @@ def get_user(self, user_id):
         except User.DoesNotExist:
             return None
 
-    def auth_by_password(self, provider_name, username, password):
+    def auth_by_password(self, provider_name, username, password, request):
         if provider_name == 'local':
             return self.auth_by_local_password(username, password)
         else:
-            user = self.auth_by_external_password(provider_name, username, password)
+            user = self.auth_by_external_password(provider_name, username,
+                                                  password, request)
 
         try:
             assoc = UserAssociation.objects.get(
@@ -115,7 +117,7 @@ def auth_by_local_password(self, username, password):
         return None
 
 
-    def auth_by_external_password(self, provider_name, username, password):
+    def auth_by_external_password(self, provider_name, username, password, request):
         """authenticates by external password
         auto-creates local user account.
         """
@@ -137,13 +139,13 @@ def auth_by_external_password(self, provider_name, username, password):
             if created:
                 user.set_password(password)
                 user.save()
-                user_registered.send(None, user=user)
+                user_registered.send(None, user=user, request=request)
             else:
                 #have username collision - so make up a more unique user name
                 #bug: - if user already exists with the new username - we are in trouble
                 new_username = '%s@%s' % (username, provider_name)
                 user = User.objects.create_user(new_username, '', password)
-                user_registered.send(None, user=user)
+                user_registered.send(None, user=user, request=request)
                 message = _(
                     'Welcome! Please set email address (important!) in your '
                     'profile and adjust screen name, if necessary.'
@@ -196,7 +198,7 @@ def auth_by_identifier(cls, provider_name, identifier):
             )
             return None
 
-    def auth_by_ldap(self, username, password):
+    def auth_by_ldap(self, username, password, request):
         user_info = ldap_authenticate(username, password)
         if user_info['success'] == False:
             return self.auth_by_local_password(username, password)
@@ -214,7 +216,7 @@ def auth_by_ldap(self, username, password):
         except UserAssociation.DoesNotExist:
             #email address is required
             if 'email' in user_info and askbot_settings.LDAP_AUTOCREATE_USERS:
-                assoc = ldap_create_user(user_info)
+                assoc = ldap_create_user(user_info, request)
                 return assoc.user
             else:
                 return None

askbot/deps/django_authopenid/forms.py

@@ -50,12 +50,6 @@
 
 from askbot.deps.django_authopenid import util
 
-__all__ = [
-    'OpenidSigninForm','OpenidRegisterForm',
-    'ClassicRegisterForm', 'ChangePasswordForm',
-    'ChangeEmailForm', 'EmailPasswordForm', 'DeleteForm',
-]
-
 class ConsentField(forms.BooleanField):
     def __init__(self, *args, **kwargs):
         super(ConsentField, self).__init__(*args, **kwargs)
@@ -299,56 +293,31 @@ def do_clean_password_fields(self):
             raise forms.ValidationError(error_message)
 
 
-class OpenidRegisterForm(forms.Form):
+class RegistrationForm(forms.Form):
     """ openid signin form """
     next = NextUrlField()
     username = UserNameField(widget_attrs={'tabindex': 0})
 
     def __init__(self, *args, **kwargs):
-        super(OpenidRegisterForm, self).__init__(*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()
 
 
-class SafeOpenidRegisterForm(OpenidRegisterForm):
-    """this form uses recaptcha in addition
-    to the base register form
-    """
-    def __init__(self, *args, **kwargs):
-        super(SafeOpenidRegisterForm, self).__init__(*args, **kwargs)
-        self.fields['recaptcha'] = AskbotReCaptchaField()
-
-
-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
+        return super(RegistrationForm, self).clean()
 
 
-class SafeClassicRegisterForm(ClassicRegisterForm):
-    """this form uses recaptcha in addition
-    to the base register form
-    """
-    def __init__(self, *args, **kwargs):
-        super(SafeClassicRegisterForm, self).__init__(*args, **kwargs)
-        self.fields['recaptcha'] = AskbotReCaptchaField()
+class PasswordRegistrationForm(RegistrationForm, SetPasswordForm):
+    """Password registration form.
+    Fields are inherited from the parent classes"""
 
 
 class ChangePasswordForm(forms.Form):
@@ -493,14 +462,20 @@ def clean_username(self):
                 raise forms.ValidationError(_("sorry, there is no such user name"))
         return self.cleaned_data['username']
 
-def get_registration_form_class():
+def get_federated_registration_form_class():
+    """returns class for the user registration form
+    user has a chance to specify the form via setting `FEDERATED_REGISTRATION_FORM`
+    """
+    custom_class = getattr(django_settings, 'FEDERATED_REGISTRATION_FORM', None)
+    if custom_class:
+        return load_module(custom_class)
+    return RegistrationForm
+
+def get_password_registration_form_class():
     """returns class for the user registration form
-    user has a chance to specify the form via setting `REGISTRATION_FORM`
+    user has a chance to specify the form via setting `PASSWORD_REGISTRATION_FORM`
     """
-    custom_class = getattr(django_settings, 'REGISTRATION_FORM', None)
+    custom_class = getattr(django_settings, 'PASSWORD_REGISTRATION_FORM', None)
     if custom_class:
         return load_module(custom_class)
-    elif askbot_settings.USE_RECAPTCHA:
-        return SafeOpenidRegisterForm
-    else:
-        return OpenidRegisterForm
+    return PasswordRegistrationForm

askbot/deps/django_authopenid/ldap_auth.py

@@ -170,7 +170,7 @@ def ldap_authenticate_default(username, password):
     return user_info
 
 
-def ldap_create_user_default(user_info):
+def ldap_create_user_default(user_info, request):
     """takes the result returned by the :func:`ldap_authenticate`
 
     and returns a :class:`UserAssociation` object
@@ -186,7 +186,7 @@ def ldap_create_user_default(user_info):
     user.is_superuser = False
     user.is_active = True
     user.save()
-    user_registered.send(None, user = user)
+    user_registered.send(None, user=user, request=request)
     LOG.info('Created New User : [{0}]'.format(user_info['ldap_username']))
 
     assoc = UserAssociation()

askbot/deps/django_authopenid/views.py

@@ -60,6 +60,7 @@
 from askbot.deps.django_authopenid.ldap_auth import ldap_create_user
 from askbot.deps.django_authopenid.ldap_auth import ldap_authenticate
 from askbot.deps.django_authopenid.exceptions import OAuthError
+from askbot.middleware.anon_user import connect_messages_to_anon_user
 from askbot.utils.loading import load_module
 from sanction.client import Client as OAuth2Client
 from urlparse import urlparse
@@ -100,14 +101,15 @@ def get_next_url_from_session(session):
 
 def create_authenticated_user_account(
     username=None, email=None, password=None,
-    user_identifier=None, login_provider_name=None
+    user_identifier=None, login_provider_name=None,
+    request=None
 ):
     """creates a user account, user association with
     the login method and the the default email subscriptions
     """
 
     user = User.objects.create_user(username, email)
-    user_registered.send(None, user=user)
+    user_registered.send(None, user=user, request=request)
 
     logging.debug('creating new openid user association for %s', username)
 
@@ -177,6 +179,7 @@ def login(request, user):
 def logout(request):
     from django.contrib.auth import logout as _logout#for login I've added wrapper below - called login
     _logout(request)
+    connect_messages_to_anon_user(request)
 
 def logout_page(request):
     data = {
@@ -499,9 +502,10 @@ def signin(request, template_name='authopenid/signin.html'):
                     password = login_form.cleaned_data['password']
 
                     user = authenticate(
-                                    method = 'ldap',
+                                    method='ldap',
                                     username=username,
                                     password=password,
+                                    request=request
                                 )
 
                     if user:
@@ -514,7 +518,7 @@ def signin(request, template_name='authopenid/signin.html'):
                             if askbot_settings.LDAP_AUTOCREATE_USERS:
                                 #create new user or
                                 user = ldap_create_user(user_info).user
-                                user = authenticate(method='force', user_id=user.id)
+                                user = authenticate(method='force', user_id=user.pk)
                                 assert(user is not None)
                                 login(request, user)
                                 return HttpResponseRedirect(next_url)
@@ -1135,6 +1139,7 @@ def username_is_acceptable(username):
                             email=email,
                             user_identifier=user_identifier,
                             login_provider_name=login_provider_name,
+                            request=request
                         )
                 login(request, user)
                 cleanup_post_register_session(request)
@@ -1144,8 +1149,9 @@ def username_is_acceptable(username):
     user = None
     logging.debug('request method is %s' % request.method)
 
-    form_class = forms.get_registration_form_class()
+    form_class = forms.get_federated_registration_form_class()
     register_form = form_class(
+                request=request,
                 initial={
                     'next': next_url,
                     'username': request.session.get('username', ''),
@@ -1176,8 +1182,8 @@ def username_is_acceptable(username):
         login_provider_name = request.session['login_provider_name']
 
         logging.debug('trying to create new account associated with openid')
-        form_class = forms.get_registration_form_class()
-        register_form = form_class(request.POST)
+        form_class = forms.get_federated_registration_form_class()
+        register_form = form_class(request.POST, request=request)
         if not register_form.is_valid():
             logging.debug('registration form is INVALID')
         else:
@@ -1204,6 +1210,7 @@ def username_is_acceptable(username):
                             email=email,
                             user_identifier=user_identifier,
                             login_provider_name=login_provider_name,
+                            request=request
                         )
                 login(request, user)
                 cleanup_post_register_session(request)
@@ -1281,13 +1288,15 @@ def verify_email_and_register(request):
                     username=username,
                     email=email,
                     password=password,
+                    request=request
                 )
             elif user_identifier and login_provider_name:
                 user = create_authenticated_user_account(
                     username=username,
                     email=email,
                     user_identifier=user_identifier,
                     login_provider_name=login_provider_name,
+                    request=request
                 )
             else:
                 raise NotImplementedError()
@@ -1320,14 +1329,11 @@ def signup_with_password(request):
     login_form = forms.LoginForm(initial = {'next': get_next_url(request)})
     #this is safe because second decorator cleans this field
 
-    if askbot_settings.USE_RECAPTCHA:
-        RegisterForm = forms.SafeClassicRegisterForm
-    else:
-        RegisterForm = forms.ClassicRegisterForm
+    RegisterForm = forms.get_password_registration_form_class()
 
     logging.debug('request method was %s' % request.method)
     if request.method == 'POST':
-        form = RegisterForm(request.POST)
+        form = RegisterForm(request.POST, request=request)
 
         if form.is_valid():
             username = form.cleaned_data['username']
@@ -1339,6 +1345,7 @@ def signup_with_password(request):
                     username=username,
                     email=email,
                     password=password,
+                    request=request
                 )
                 login(request, user)
                 cleanup_post_register_session(request)
@@ -1358,7 +1365,7 @@ def signup_with_password(request):
                 return HttpResponseRedirect(redirect_url)
     else:
         #todo: here we have duplication of get_password_login_provider...
-        form = RegisterForm(initial={'next': get_next_url(request)})
+        form = RegisterForm(initial={'next': get_next_url(request)}, request=request)
 
     major_login_providers = util.get_enabled_major_login_providers()
     minor_login_providers = util.get_enabled_minor_login_providers()

askbot/middleware/anon_user.py

@@ -33,6 +33,14 @@ def dummy_deepcopy(*arg):
     """
     return None
 
+
+def connect_messages_to_anon_user(request):
+    request.user.__deepcopy__ = dummy_deepcopy
+    request.user.message_set = AnonymousMessageManager(request)
+    request.user.get_and_delete_messages = \
+                    request.user.message_set.get_and_delete
+
+
 class ConnectToSessionMessagesMiddleware(object):
     """Middleware that attaches messages to anonymous users, and
     makes sure that anonymous user greeting is shown just once.
@@ -50,11 +58,7 @@ def process_request(self, request):
         if request.user.is_anonymous():
             #1) Attach the ability to receive messages
             #plug on deepcopy which may be called by django db "driver"
-            request.user.__deepcopy__ = dummy_deepcopy
-            #here request is linked to anon user
-            request.user.message_set = AnonymousMessageManager(request)
-            request.user.get_and_delete_messages = \
-                            request.user.message_set.get_and_delete
+            connect_messages_to_anon_user(request)
 
             #2) set the first greeting one time per session only
             if 'greeting_set' not in request.session and \