text: from django.conf import settings
  try:
      from django.contrib.sites.shortcuts import get_current_site
  except ImportError:
      from django.contrib.sites.models import get_current_site
  
  from ... import signals
  from ...models import RegistrationProfile
  from ...views import ActivationView as BaseActivationView
  from ...views import RegistrationView as BaseRegistrationView
  from ...compat import RequestSite, is_app_installed
  from ...users import UserModel
  
  
  class RegistrationView(BaseRegistrationView):
      """
      A registration backend which follows a simple workflow:
  
      1. User signs up, inactive account is created.
  
      2. Email is sent to user with activation link.
  
      3. User clicks activation link, account is now active.
  
      Using this backend requires that
  
      * ``registration`` be listed in the ``INSTALLED_APPS`` setting
        (since this backend makes use of models defined in this
        application).
  
      * The setting ``ACCOUNT_ACTIVATION_DAYS`` be supplied, specifying
        (as an integer) the number of days from registration during
        which a user may activate their account (after that period
        expires, activation will be disallowed).
  
      * The creation of the templates
        ``registration/activation_email_subject.txt`` and
        ``registration/activation_email.txt``, which will be used for
        the activation email. See the notes for this backends
        ``register`` method for details regarding these templates.
  
      When subclassing this view, you can set the ``SEND_ACTIVATION_EMAIL``
      class variable to False to skip sending the new user a confirmation
      email or set ``SEND_ACTIVATION_EMAIL`` to ``False``. Doing so implies
      that you will have to activate the user manually from the admin site or
      send an activation by some other method. For example, by listening for
      the ``user_registered`` signal.
  
      Additionally, registration can be temporarily closed by adding the
      setting ``REGISTRATION_OPEN`` and setting it to
      ``False``. Omitting this setting, or setting it to ``True``, will
      be interpreted as meaning that registration is currently open and
      permitted.
  
      Internally, this is accomplished via storing an activation key in
      an instance of ``registration.models.RegistrationProfile``. See
      that model and its custom manager for full documentation of its
      fields and supported operations.
  
      """
      SEND_ACTIVATION_EMAIL = getattr(settings, 'SEND_ACTIVATION_EMAIL', True)
      success_url = 'registration_complete'
  
      def register(self, request, form):
          """
          Given a username, email address and password, register a new
          user account, which will initially be inactive.
  
          Along with the new ``User`` object, a new
          ``registration.models.RegistrationProfile`` will be created,
          tied to that ``User``, containing the activation key which
          will be used for this account.
  
          An email will be sent to the supplied email address; this
          email should contain an activation link. The email will be
          rendered using two templates. See the documentation for
          ``RegistrationProfile.send_activation_email()`` for
          information about these templates and the contexts provided to
          them.
  
          After the ``User`` and ``RegistrationProfile`` are created and
          the activation email is sent, the signal
          ``registration.signals.user_registered`` will be sent, with
          the new ``User`` as the keyword argument ``user`` and the
          class of this backend as the sender.
  
          """
          site = get_current_site(request)
  
          if hasattr(form, 'save'):
              new_user_instance = form.save()
          else:
              new_user_instance = (UserModel().objects
                                   .create_user(**form.cleaned_data))
  
          new_user = RegistrationProfile.objects.create_inactive_user(
              new_user=new_user_instance,
              site=site,
              send_email=self.SEND_ACTIVATION_EMAIL,
              request=request,
          )
          signals.user_registered.send(sender=self.__class__,
                                       user=new_user,
                                       request=request)
          return new_user
  
      def registration_allowed(self, request):
          """
          Indicate whether account registration is currently permitted,
          based on the value of the setting ``REGISTRATION_OPEN``. This
          is determined as follows:
  
          * If ``REGISTRATION_OPEN`` is not specified in settings, or is
            set to ``True``, registration is permitted.
  
          * If ``REGISTRATION_OPEN`` is both specified and set to
            ``False``, registration is not permitted.
  
          """
          return getattr(settings, 'REGISTRATION_OPEN', True)
  
  
  class ActivationView(BaseActivationView):
      def activate(self, request, activation_key):
          """
          Given an an activation key, look up and activate the user
          account corresponding to that key (if possible).
  
          After successful activation, the signal
          ``registration.signals.user_activated`` will be sent, with the
          newly activated ``User`` as the keyword argument ``user`` and
          the class of this backend as the sender.
  
          """
          activated_user = (RegistrationProfile.objects
                            .activate_user(activation_key))
          if activated_user:
              signals.user_activated.send(sender=self.__class__,
                                          user=activated_user,
                                          request=request)
          return activated_user
  
      def get_success_url(self, request, user):
          return ('registration_activation_complete', (), {})
  