1. offline
  2. django-publicauth

Source

django-publicauth / publicauth / backends / __init__.py

Diff from to

File publicauth/backends/__init__.py

-from django.shortcuts import render_to_response, redirect
 from django.conf import settings as global_settings
-from django.utils.translation import ugettext as _
-from django.contrib.auth.models import User
-from django.template import RequestContext
 from django.contrib import messages
 from django.contrib import auth
-from django.http import Http404
 
 from annoying.exceptions import Redirect
 
 class BaseBackend(object):
 
     PROFILE_MAPPING = property(lambda self: getattr(global_settings, "%s_PROFILE_MAPPING" % self.provider.upper(), {}))
-    EXTRA_FORM = property(lambda self: getattr(global_settings, "%s_EXTRA_FORM" % self.provider.upper(), 'publicauth.forms.ExtraForm'))
 
     def __init__(self, provider):
         self.provider = provider
-        self._identity = None
-
-    def set_identity(self, identity):
-        self._identity = identity
-
-    def get_identity(self):
-        return self._identity
+        self.identity = None
 
     def begin(self, request, data):
         raise NotImplementedError
 
-    def complete(self, request):
-        """
-        Login user if its identity already exists,
-        Create new user in case that no extra fields are required
-        and user with such identity doesnt exists.
-        Merge accounts if user already logged in and identity is new.
-        """
+    def complete(self, request, response):
+        raise NotImplementedError
+
+    def validate(self, request, data):
+        raise NotImplementedError
+
+    def get_extra_data(self, response):
         raise NotImplementedError
     
-    def attach_account(self, request, user):
+    def merge_accounts(self, request):
         """
         Attach PublicID account to regular django 
-        account and then login user.
+        account and then redirect user. In this situation
+        user dont have to fill extra fields because he filled
+        them when first account (request.user) was created.
+
+        Note that self.indentity must be already set in this stage by
+        validate_response function. 
         """
-        PublicID.objects.create(user=user, identity=self.get_identity(), provider=self.provider)
+        # create new public ID record in database
+        # and attach it to request.user account.
+        publicid = PublicID()
+        publicid.user = request.user 
+        publicid.identity = self.identity 
+        publicid.provider = self.provider
+        publicid.save()
+
+        # show nice message to user.
         messages.add_message(request, messages.SUCCESS, lang.ACCOUNTS_MERGED)
-        auth.authenticate(identity=self.get_identity(), provider=self.provider)
-        auth.login(request, user)
+        # redirect user.
         raise Redirect(global_settings.LOGIN_REDIRECT_URL)
 
     def login_user(self, request):
-        if settings.PUBLICID_ACTIVATION_REQUIRED and not request.user.is_active:
+        """
+        Try to login user by public identity.
+        Do nothing in case of failure.
+        """
+        # only actavted users can login if activation required.
+        if settings.PUBLICAUTH_ACTIVATION_REQUIRED and not request.user.is_active:
             messages.add_message(request, messages.ERROR, lang.NOT_ACTIVATED)
-            raise Redirect("/")
+            raise Redirect(global_settings.LOGIN_REDIRECT_URL)
 
-        user = auth.authenticate(identity=self.get_identity(), provider=self.provider)
+        # authenticate and redirect user.
+        user = auth.authenticate(identity=self.identity, provider=self.provider)
         if user:
             messages.add_message(request, messages.SUCCESS, lang.SUCCESSFULLY_AUTHENTICATED)
             auth.login(request, user)
-            raise Redirect(global_settings.LOGIN_REDIRECT_URL)
 
-    def set_profile_fields(self, request, extra):
+            try:
+                redirect_url = request.session['next_url']
+                del request.session['next_url']
+            except KeyError:
+                redirect_url = global_settings.LOGIN_REDIRECT_URL
+            raise Redirect(redirect_url)
+
+    def fill_extra_fields(self, request, extra):
         """
         Try to fetch extra data from provider, if this data is enough
-        to validate EXTRA_FORM then call save method of form class and 
-        login user.
+        to validate settings.EXTRA_FORM then call save method of form 
+        class and login the user.
+
+        The extra parameter can be some complex object
+        this is why we use method function 'extra_data' to
+        extract data from this object.
+
+        Also we need to create a dictionary with remapped 
+        keys from profile mapping settings.
         """
         data = {}
-
         for field in self.PROFILE_MAPPING:
             data.update(self.extract_data(extra, field))
 
-        form = str_to_class(self.EXTRA_FORM)(data, fields=self.PROFILE_MAPPING)
+        form = str_to_class(settings.EXTRA_FORM)(data, fields=self.PROFILE_MAPPING)
         if form.is_valid():
-            form.save(self.get_identity(), self.provider)
-            user = auth.authenticate(identity=self.get_identity(), provider=self.provider)
-            if user:
-                auth.login(request, user)
-                try:
-                    redirect_url = request.session['next_url']
-                    del request.session['next_url']
-                except KeyError:
-                    redirect_url = global_settings.LOGIN_REDIRECT_URL
-                raise Redirect(redirect_url)
+            form.save(self.identity, self.provider)
+            self.login_user(request)
         else:
             return data
 
-    def extract_data(self, data, field):
+    def extract_data(self, extra, field):
+        """
+        If extra isnt standart python dictionary
+        you need to implement this method to retrive
+        values from this object.
+        """
         try:
-            return {self.PROFILE_MAPPING[field][0]: data.get(field, '')}
+            return {self.PROFILE_MAPPING[field][0]: extra.get(field, '')}
         except AttributeError:
             return {self.PROFILE_MAPPING[field][0]: ''}
 
-    def validate_response(self, request):
-        pass
 
-
-    def extra(self, request):
-        """
-        Handle registration of new user with extra data for profile
-        """
-        try:
-            identity = request.session['identity']
-        except KeyError:
-            raise Http404
-
-        if request.method == "POST":
-            form = str_to_class(self.EXTRA_FORM)(request.POST)
-            if form.is_valid():
-                user = form.save(identity, self.provider)
-                del request.session['identity']
-                user = auth.authenticate(identity=identity, provider=self.provider)
-                if user:
-                    auth.login(request, user)
-                    next_url = request.session['next_url']
-                    del request.session['next_url']
-                    return redirect(next_url)
-        else:
-            initial = request.session['extra']
-            form = str_to_class(self.EXTRA_FORM)(initial=initial)
-
-        return render_to_response(     
-                                    "publicauth/extra.html", 
-                                    {'form': form}, 
-                                    context_instance=RequestContext(request)
-                                )
-