philo/contrib/waldo/models.py

   1 """
   2 Waldo provides abstract :class:`.MultiView`\ s to handle several levels of common authentication:
   3
   4 * :class:`LoginMultiView` handles the case where users only need to be able to log in and out.
   5 * :class:`PasswordMultiView` handles the case where users will also need to change their password.
   6 * :class:`RegistrationMultiView` builds on top of :class:`PasswordMultiView` to handle user registration, as well.
   7 * :class:`AccountMultiView` adds account-handling functionality to the :class:`RegistrationMultiView`.
   8
   9 """
  10
  11 import urlparse
  12
  13 from django import forms
  14 from django.conf.urls.defaults import url, patterns, include
  15 from django.contrib import messages
  16 from django.contrib.auth import authenticate, login, views as auth_views
  17 from django.contrib.auth.forms import PasswordResetForm, SetPasswordForm, PasswordChangeForm
  18 from django.contrib.auth.models import User
  19 from django.contrib.auth.tokens import default_token_generator as password_token_generator
  20 from django.contrib.sites.models import Site
  21 from django.core.mail import EmailMultiAlternatives, send_mail
  22 from django.db import models
  23 from django.http import Http404, HttpResponseRedirect
  24 from django.shortcuts import render_to_response, get_object_or_404
  25 from django.template.defaultfilters import striptags
  26 from django.utils.http import int_to_base36, base36_to_int
  27 from django.utils.translation import ugettext as _
  28 from django.views.decorators.cache import never_cache
  29 from django.views.decorators.csrf import csrf_protect
  30
  31 from philo.models import MultiView, Page
  32 from philo.contrib.waldo.forms import WaldoAuthenticationForm, RegistrationForm, UserAccountForm
  33 from philo.contrib.waldo.tokens import registration_token_generator, email_token_generator
  34
  35
  36 class LoginMultiView(MultiView):
  37         """Handles exclusively methods and views related to logging users in and out."""
  38         #: A :class:`ForeignKey` to the :class:`.Page` which will be used to render the login form.
  39         login_page = models.ForeignKey(Page, related_name='%(app_label)s_%(class)s_login_related')
  40         #: A django form class which will be used for the authentication process. Default: :class:`.WaldoAuthenticationForm`.
  41         login_form = WaldoAuthenticationForm
  42
  43         @property
  44         def urlpatterns(self):
  45                 return patterns('',
  46                         url(r'^login$', self.login, name='login'),
  47                         url(r'^logout$', self.logout, name='logout'),
  48                 )
  49
  50         def set_requirement_redirect(self, request, redirect=None):
  51                 """Figures out and stores where a user should end up after landing on a page (like the login page) because they have not fulfilled some kind of requirement."""
  52                 if redirect is not None:
  53                         pass
  54                 elif 'requirement_redirect' in request.session:
  55                         return
  56                 else:
  57                         referrer = request.META.get('HTTP_REFERER', None)
  58
  59                         if referrer is not None:
  60                                 referrer = urlparse.urlparse(referrer)
  61                                 host = referrer[1]
  62                                 if host != request.get_host():
  63                                         referrer = None
  64                                 else:
  65                                         redirect = '%s?%s' % (referrer[2], referrer[4])
  66
  67                         path = request.get_full_path()
  68                         if referrer is None or redirect == path:
  69                                 # Default to the index page if we can't find a referrer or
  70                                 # if we'd otherwise redirect to where we already are.
  71                                 redirect = request.node.get_absolute_url()
  72
  73                 request.session['requirement_redirect'] = redirect
  74
  75         def get_requirement_redirect(self, request, default=None):
  76                 """Returns the location which a user should be redirected to after fulfilling a requirement (like logging in)."""
  77                 redirect = request.session.pop('requirement_redirect', None)
  78                 # Security checks a la django.contrib.auth.views.login
  79                 if not redirect or ' ' in redirect:
  80                         redirect = default
  81                 else:
  82                         netloc = urlparse.urlparse(redirect)[1]
  83                         if netloc and netloc != request.get_host():
  84                                 redirect = default
  85                 if redirect is None:
  86                         redirect = request.node.get_absolute_url()
  87                 return redirect
  88
  89         @never_cache
  90         def login(self, request, extra_context=None):
  91                 """Renders the :attr:`login_page` with an instance of the :attr:`login_form` for the given :class:`HttpRequest`."""
  92                 self.set_requirement_redirect(request)
  93
  94                 # Redirect already-authenticated users to the index page.
  95                 if request.user.is_authenticated():
  96                         messages.add_message(request, messages.INFO, "You are already authenticated. Please log out if you wish to log in as a different user.")
  97                         return HttpResponseRedirect(self.get_requirement_redirect(request))
  98
  99                 if request.method == 'POST':
 100                         form = self.login_form(request=request, data=request.POST)
 101                         if form.is_valid():
 102                                 redirect = self.get_requirement_redirect(request)
 103                                 login(request, form.get_user())
 104
 105                                 if request.session.test_cookie_worked():
 106                                         request.session.delete_test_cookie()
 107
 108                                 return HttpResponseRedirect(redirect)
 109                 else:
 110                         form = self.login_form(request)
 111
 112                 request.session.set_test_cookie()
 113
 114                 context = self.get_context()
 115                 context.update(extra_context or {})
 116                 context.update({
 117                         'form': form
 118                 })
 119                 return self.login_page.render_to_response(request, extra_context=context)
 120
 121         @never_cache
 122         def logout(self, request, extra_context=None):
 123                 """Logs the given :class:`HttpRequest` out, redirecting the user to the page they just left or to the :meth:`~.Node.get_absolute_url` for the ``request.node``."""
 124                 return auth_views.logout(request, request.META.get('HTTP_REFERER', request.node.get_absolute_url()))
 125
 126         def login_required(self, view):
 127                 """Wraps a view function to require that the user be logged in."""
 128                 def inner(request, *args, **kwargs):
 129                         if not request.user.is_authenticated():
 130                                 self.set_requirement_redirect(request, redirect=request.path)
 131                                 if request.POST:
 132                                         messages.add_message(request, messages.ERROR, "Please log in again, because your session has expired.")
 133                                 return HttpResponseRedirect(self.reverse('login', node=request.node))
 134                         return view(request, *args, **kwargs)
 135
 136                 return inner
 137
 138         class Meta:
 139                 abstract = True
 140
 141
 142 class PasswordMultiView(LoginMultiView):
 143         """
 144         Adds support for password setting, resetting, and changing to the :class:`LoginMultiView`. Password reset support includes handling of a confirmation email.
 145
 146         """
 147         #: A :class:`ForeignKey` to the :class:`.Page` which will be used to render the password reset request form.
 148         password_reset_page = models.ForeignKey(Page, related_name='%(app_label)s_%(class)s_password_reset_related', blank=True, null=True)
 149         #: A :class:`ForeignKey` to the :class:`.Page` which will be used to render the password reset confirmation email.
 150         password_reset_confirmation_email = models.ForeignKey(Page, related_name='%(app_label)s_%(class)s_password_reset_confirmation_email_related', blank=True, null=True)
 151         #: A :class:`ForeignKey` to the :class:`.Page` which will be used to render the password setting form (i.e. the page that users will see after confirming a password reset).
 152         password_set_page = models.ForeignKey(Page, related_name='%(app_label)s_%(class)s_password_set_related', blank=True, null=True)
 153         #: A :class:`ForeignKey` to the :class:`.Page` which will be used to render the password change form.
 154         password_change_page = models.ForeignKey(Page, related_name='%(app_label)s_%(class)s_password_change_related', blank=True, null=True)
 155
 156         #: The password change form class. Default: :class:`django.contrib.auth.forms.PasswordChangeForm`.
 157         password_change_form = PasswordChangeForm
 158         #: The password set form class. Default: :class:`django.contrib.auth.forms.SetPasswordForm`.
 159         password_set_form = SetPasswordForm
 160         #: The password reset request form class. Default: :class:`django.contrib.auth.forms.PasswordResetForm`.
 161         password_reset_form = PasswordResetForm
 162
 163         @property
 164         def urlpatterns(self):
 165                 urlpatterns = super(PasswordMultiView, self).urlpatterns
 166
 167                 if self.password_reset_page_id and self.password_reset_confirmation_email_id and self.password_set_page_id:
 168                         urlpatterns += patterns('',
 169                                 url(r'^password/reset$', csrf_protect(self.password_reset), name='password_reset'),
 170                                 url(r'^password/reset/(?P<uidb36>\w+)/(?P<token>[^/]+)$', self.password_reset_confirm, name='password_reset_confirm'),
 171                         )
 172
 173                 if self.password_change_page_id:
 174                         urlpatterns += patterns('',
 175                                 url(r'^password/change$', csrf_protect(self.login_required(self.password_change)), name='password_change'),
 176                         )
 177                 return urlpatterns
 178
 179         def make_confirmation_link(self, confirmation_view, token_generator, user, node, token_args=None, reverse_kwargs=None, secure=False):
 180                 """
 181                 Generates a confirmation link for an arbitrary action, such as a password reset.
 182
 183                 :param confirmation_view: The view function which needs to be linked to.
 184                 :param token_generator: Generates a confirmable token for the action.
 185                 :param user: The user who is trying to take the action.
 186                 :param node: The node which is providing the basis for the confirmation URL.
 187                 :param token_args: A list of additional arguments (i.e. besides the user) to be used for token creation.
 188                 :param reverse_kwargs: A dictionary of any additional keyword arguments necessary for correctly reversing the view.
 189                 :param secure: Whether the link should use the https:// or http://.
 190
 191                 """
 192                 token = token_generator.make_token(user, *(token_args or []))
 193                 kwargs = {
 194                         'uidb36': int_to_base36(user.id),
 195                         'token': token
 196                 }
 197                 kwargs.update(reverse_kwargs or {})
 198                 return node.construct_url(subpath=self.reverse(confirmation_view, kwargs=kwargs), with_domain=True, secure=secure)
 199
 200         def send_confirmation_email(self, subject, email, page, extra_context):
 201                 """
 202                 Sends a confirmation email for an arbitrary action, such as a password reset. If the ``page``'s :class:`.Template` has a mimetype of ``text/html``, then the email will be sent with an HTML alternative version.
 203
 204                 :param subject: The subject line of the email.
 205                 :param email: The recipient's address.
 206                 :param page: The page which will be used to render the email body.
 207                 :param extra_context: The context for rendering the ``page``.
 208
 209                 """
 210                 text_content = page.render_to_string(extra_context=extra_context)
 211                 from_email = 'noreply@%s' % Site.objects.get_current().domain
 212
 213                 if page.template.mimetype == 'text/html':
 214                         msg = EmailMultiAlternatives(subject, striptags(text_content), from_email, [email])
 215                         msg.attach_alternative(text_content, 'text/html')
 216                         msg.send()
 217                 else:
 218                         send_mail(subject, text_content, from_email, [email])
 219
 220         def password_reset(self, request, extra_context=None, token_generator=password_token_generator):
 221                 """
 222                 Handles the process by which users request a password reset, and generates the context for the confirmation email. That context will contain:
 223
 224                 link
 225                         The confirmation link for the password reset.
 226                 user
 227                         The user requesting the reset.
 228                 site
 229                         The current :class:`Site`.
 230                 request
 231                         The current :class:`HttpRequest` instance.
 232
 233                 :param token_generator: The token generator to use for the confirmation link.
 234
 235                 """
 236                 if request.user.is_authenticated():
 237                         return HttpResponseRedirect(request.node.get_absolute_url())
 238
 239                 if request.method == 'POST':
 240                         form = self.password_reset_form(request.POST)
 241                         if form.is_valid():
 242                                 current_site = Site.objects.get_current()
 243                                 for user in form.users_cache:
 244                                         context = {
 245                                                 'link': self.make_confirmation_link('password_reset_confirm', token_generator, user, request.node, secure=request.is_secure()),
 246                                                 'user': user,
 247                                                 'site': current_site,
 248                                                 'request': request
 249                                         }
 250                                         self.send_confirmation_email('Confirm password reset for account at %s' % current_site.domain, user.email, self.password_reset_confirmation_email, context)
 251                                         messages.add_message(request, messages.SUCCESS, "An email has been sent to the address you provided with details on resetting your password.", fail_silently=True)
 252                                 return HttpResponseRedirect('')
 253                 else:
 254                         form = self.password_reset_form()
 255
 256                 context = self.get_context()
 257                 context.update(extra_context or {})
 258                 context.update({
 259                         'form': form
 260                 })
 261                 return self.password_reset_page.render_to_response(request, extra_context=context)
 262
 263         def password_reset_confirm(self, request, extra_context=None, uidb36=None, token=None, token_generator=password_token_generator):
 264                 """
 265                 Checks that ``token``` is valid, and if so, renders an instance of :attr:`password_set_form` with :attr:`password_set_page`.
 266
 267                 :param token_generator: The token generator used to check the ``token``.
 268
 269                 """
 270                 assert uidb36 is not None and token is not None
 271                 try:
 272                         uid_int = base36_to_int(uidb36)
 273                 except:
 274                         raise Http404
 275
 276                 user = get_object_or_404(User, id=uid_int)
 277
 278                 if token_generator.check_token(user, token):
 279                         if request.method == 'POST':
 280                                 form = self.password_set_form(user, request.POST)
 281
 282                                 if form.is_valid():
 283                                         form.save()
 284                                         messages.add_message(request, messages.SUCCESS, "Password reset successful.")
 285                                         return HttpResponseRedirect(self.reverse('login', node=request.node))
 286                         else:
 287                                 form = self.password_set_form(user)
 288
 289                         context = self.get_context()
 290                         context.update(extra_context or {})
 291                         context.update({
 292                                 'form': form
 293                         })
 294                         return self.password_set_page.render_to_response(request, extra_context=context)
 295
 296                 raise Http404
 297
 298         def password_change(self, request, extra_context=None):
 299                 """Renders an instance of :attr:`password_change_form` with :attr:`password_change_page`."""
 300                 if request.method == 'POST':
 301                         form = self.password_change_form(request.user, request.POST)
 302                         if form.is_valid():
 303                                 form.save()
 304                                 messages.add_message(request, messages.SUCCESS, 'Password changed successfully.', fail_silently=True)
 305                                 return HttpResponseRedirect('')
 306                 else:
 307                         form = self.password_change_form(request.user)
 308
 309                 context = self.get_context()
 310                 context.update(extra_context or {})
 311                 context.update({
 312                         'form': form
 313                 })
 314                 return self.password_change_page.render_to_response(request, extra_context=context)
 315
 316         class Meta:
 317                 abstract = True
 318
 319
 320 class RegistrationMultiView(PasswordMultiView):
 321         """Adds support for user registration to the :class:`PasswordMultiView`."""
 322         #: A :class:`ForeignKey` to the :class:`.Page` which will be used to display the registration form.
 323         register_page = models.ForeignKey(Page, related_name='%(app_label)s_%(class)s_register_related', blank=True, null=True)
 324         #: A :class:`ForeignKey` to the :class:`.Page` which will be used to render the registration confirmation email.
 325         register_confirmation_email = models.ForeignKey(Page, related_name='%(app_label)s_%(class)s_register_confirmation_email_related', blank=True, null=True)
 326         #: The registration form class. Default: :class:`.RegistrationForm`.
 327         registration_form = RegistrationForm
 328
 329         @property
 330         def urlpatterns(self):
 331                 urlpatterns = super(RegistrationMultiView, self).urlpatterns
 332                 if self.register_page_id and self.register_confirmation_email_id:
 333                         urlpatterns += patterns('',
 334                                 url(r'^register$', csrf_protect(self.register), name='register'),
 335                                 url(r'^register/(?P<uidb36>\w+)/(?P<token>[^/]+)$', self.register_confirm, name='register_confirm')
 336                         )
 337                 return urlpatterns
 338
 339         def register(self, request, extra_context=None, token_generator=registration_token_generator):
 340                 """
 341                 Renders the :attr:`register_page` with an instance of :attr:`registration_form` in the context as ``form``. If the form has been submitted, sends a confirmation email using :attr:`register_confirmation_email` and the same context as :meth:`PasswordMultiView.password_reset`.
 342
 343                 :param token_generator: The token generator to use for the confirmation link.
 344
 345                 """
 346                 if request.user.is_authenticated():
 347                         return HttpResponseRedirect(request.node.get_absolute_url())
 348
 349                 if request.method == 'POST':
 350                         form = self.registration_form(request.POST)
 351                         if form.is_valid():
 352                                 user = form.save()
 353                                 current_site = Site.objects.get_current()
 354                                 context = {
 355                                         'link': self.make_confirmation_link('register_confirm', token_generator, user, request.node, secure=request.is_secure()),
 356                                         'user': user,
 357                                         'site': current_site,
 358                                         'request': request
 359                                 }
 360                                 self.send_confirmation_email('Confirm account creation at %s' % current_site.name, user.email, self.register_confirmation_email, context)
 361                                 messages.add_message(request, messages.SUCCESS, 'An email has been sent to %s with details on activating your account.' % user.email, fail_silently=True)
 362                                 return HttpResponseRedirect(request.node.get_absolute_url())
 363                 else:
 364                         form = self.registration_form()
 365
 366                 context = self.get_context()
 367                 context.update(extra_context or {})
 368                 context.update({
 369                         'form': form
 370                 })
 371                 return self.register_page.render_to_response(request, extra_context=context)
 372
 373         def register_confirm(self, request, extra_context=None, uidb36=None, token=None, token_generator=registration_token_generator):
 374                 """
 375                 Checks that ``token`` is valid, and if so, logs the user in and redirects them to :meth:`post_register_confirm_redirect`.
 376
 377                 :param token_generator: The token generator used to check the ``token``.
 378                 """
 379                 assert uidb36 is not None and token is not None
 380                 try:
 381                         uid_int = base36_to_int(uidb36)
 382                 except:
 383                         raise Http404
 384
 385                 user = get_object_or_404(User, id=uid_int)
 386                 if token_generator.check_token(user, token):
 387                         user.is_active = True
 388                         true_password = user.password
 389                         temp_password = token_generator.make_token(user)
 390                         try:
 391                                 user.set_password(temp_password)
 392                                 user.save()
 393                                 authenticated_user = authenticate(username=user.username, password=temp_password)
 394                                 login(request, authenticated_user)
 395                         finally:
 396                                 # if anything goes wrong, do our best make sure that the true password is restored.
 397                                 user.password = true_password
 398                                 user.save()
 399                         return self.post_register_confirm_redirect(request)
 400
 401                 raise Http404
 402
 403         def post_register_confirm_redirect(self, request):
 404                 """Returns an :class:`HttpResponseRedirect` for post-registration-confirmation. Default: :meth:`Node.get_absolute_url` for ``request.node``."""
 405                 return HttpResponseRedirect(request.node.get_absolute_url())
 406
 407         class Meta:
 408                 abstract = True
 409
 410
 411 class AccountMultiView(RegistrationMultiView):
 412         """Adds support for user accounts on top of the :class:`RegistrationMultiView`. By default, the account consists of the first_name, last_name, and email fields of the User model. Using a different account model is as simple as replacing :attr:`account_form` with any form class that takes an :class:`auth.User` instance as the first argument."""
 413         #: A :class:`ForeignKey` to the :class:`Page` which will be used to render the account management form.
 414         manage_account_page = models.ForeignKey(Page, related_name='%(app_label)s_%(class)s_manage_account_related', blank=True, null=True)
 415         #: A :class:`ForeignKey` to a :class:`Page` which will be used to render an email change confirmation email. This is optional; if it is left blank, then email changes will be performed without confirmation.
 416         email_change_confirmation_email = models.ForeignKey(Page, related_name='%(app_label)s_%(class)s_email_change_confirmation_email_related', blank=True, null=True, help_text="If this is left blank, email changes will be performed without confirmation.")
 417
 418         #: A django form class which will be used to manage the user's account. Default: :class:`.UserAccountForm`
 419         account_form = UserAccountForm
 420
 421         @property
 422         def urlpatterns(self):
 423                 urlpatterns = super(AccountMultiView, self).urlpatterns
 424                 if self.manage_account_page_id:
 425                         urlpatterns += patterns('',
 426                                 url(r'^account$', self.login_required(self.account_view), name='account'),
 427                         )
 428                 if self.email_change_confirmation_email_id:
 429                         urlpatterns += patterns('',
 430                                 url(r'^account/email/(?P<uidb36>\w+)/(?P<email>[\w.]+[+][\w.]+)/(?P<token>[^/]+)$', self.email_change_confirm, name='email_change_confirm')
 431                         )
 432                 return urlpatterns
 433
 434         def account_view(self, request, extra_context=None, token_generator=email_token_generator, *args, **kwargs):
 435                 """
 436                 Renders the :attr:`manage_account_page` with an instance of :attr:`account_form` in the context as ``form``. If the form has been posted, the user's email was changed, and :attr:`email_change_confirmation_email` is not ``None``, sends a confirmation email to the new email to make sure it exists before making the change. The email will have the same context as :meth:`PasswordMultiView.password_reset`.
 437
 438                 :param token_generator: The token generator to use for the confirmation link.
 439
 440                 """
 441                 if request.method == 'POST':
 442                         form = self.account_form(request.user, request.POST, request.FILES)
 443
 444                         if form.is_valid():
 445                                 message = "Account information saved."
 446                                 redirect = self.get_requirement_redirect(request, default='')
 447                                 if form.email_changed() and self.email_change_confirmation_email:
 448                                         email = form.reset_email()
 449
 450                                         current_site = Site.objects.get_current()
 451
 452                                         context = {
 453                                                 'link': self.make_confirmation_link('email_change_confirm', token_generator, request.user, request.node, token_args=[email], reverse_kwargs={'email': email.replace('@', '+')}, secure=request.is_secure()),
 454                                                 'user': request.user,
 455                                                 'site': current_site,
 456                                                 'request': request
 457                                         }
 458                                         self.send_confirmation_email('Confirm account email change at %s' % current_site.domain, email, self.email_change_confirmation_email, context)
 459
 460                                         message = "An email has be sent to %s to confirm the email%s." % (email, " change" if bool(request.user.email) else "")
 461                                         if not request.user.email:
 462                                                 message += " You will need to confirm the email before accessing pages that require a valid account."
 463                                                 redirect = ''
 464
 465                                 form.save()
 466
 467                                 if redirect != '':
 468                                         message += " Here you go!"
 469
 470                                 messages.add_message(request, messages.SUCCESS, message, fail_silently=True)
 471                                 return HttpResponseRedirect(redirect)
 472                 else:
 473                         form = self.account_form(request.user)
 474
 475                 context = self.get_context()
 476                 context.update(extra_context or {})
 477                 context.update({
 478                         'form': form
 479                 })
 480                 return self.manage_account_page.render_to_response(request, extra_context=context)
 481
 482         def has_valid_account(self, user):
 483                 """Returns ``True`` if the ``user`` has a valid account and ``False`` otherwise."""
 484                 form = self.account_form(user, {})
 485                 form.data = form.initial
 486                 return form.is_valid()
 487
 488         def account_required(self, view):
 489                 """Wraps a view function to allow access only to users with valid accounts and otherwise redirect them to the :meth:`account_view`."""
 490                 def inner(request, *args, **kwargs):
 491                         if not self.has_valid_account(request.user):
 492                                 messages.add_message(request, messages.ERROR, "You need to add some account information before you can access that page.", fail_silently=True)
 493                                 if self.manage_account_page:
 494                                         self.set_requirement_redirect(request, redirect=request.path)
 495                                         redirect = self.reverse('account', node=request.node)
 496                                 else:
 497                                         redirect = request.node.get_absolute_url()
 498                                 return HttpResponseRedirect(redirect)
 499                         return view(request, *args, **kwargs)
 500
 501                 inner = self.login_required(inner)
 502                 return inner
 503
 504         def post_register_confirm_redirect(self, request):
 505                 """Automatically redirects users to the :meth:`account_view` after registration."""
 506                 if self.manage_account_page:
 507                         messages.add_message(request, messages.INFO, 'Welcome! Please fill in some more information.', fail_silently=True)
 508                         return HttpResponseRedirect(self.reverse('account', node=request.node))
 509                 return super(AccountMultiView, self).post_register_confirm_redirect(request)
 510
 511         def email_change_confirm(self, request, extra_context=None, uidb36=None, token=None, email=None, token_generator=email_token_generator):
 512                 """
 513                 Checks that ``token`` is valid, and if so, changes the user's email.
 514
 515                 :param token_generator: The token generator used to check the ``token``.
 516
 517                 """
 518                 assert uidb36 is not None and token is not None and email is not None
 519
 520                 try:
 521                         uid_int = base36_to_int(uidb36)
 522                 except:
 523                         raise Http404
 524
 525                 user = get_object_or_404(User, id=uid_int)
 526
 527                 email = '@'.join(email.rsplit('+', 1))
 528
 529                 if email == user.email:
 530                         # Then short-circuit.
 531                         raise Http404
 532
 533                 if token_generator.check_token(user, email, token):
 534                         self.account_form.set_email(user, email)
 535                         messages.add_message(request, messages.SUCCESS, 'Email changed successfully.')
 536                         if self.manage_account_page:
 537                                 redirect = self.reverse('account', node=request.node)
 538                         else:
 539                                 redirect = request.node.get_absolute_url()
 540                         return HttpResponseRedirect(redirect)
 541
 542                 raise Http404
 543
 544         class Meta:
 545                 abstract = True