Produits Entr'ouvert » Authentic 2

    A2_REGISTRATION_BACKEND = Setting(default='default',

                definition='Backend for user\'s registration'),

    A2_REGISTRATION_FORM_CLASS = Setting(default='authentic2.registration_backend.default.forms.RegistrationForm',

    A2_REGISTRATION_SET_PASSWORD_FORM_CLASS = Setting(default='authentic2.registration_backend.default.forms.SetPasswordForm',

    A2_REGISTRATION_CHANGE_PASSWORD_FORM_CLASS = Setting(default='authentic2.registration_backend.default.forms.PasswordChangeForm',

from django.core.exceptions import ValidationError

from django.utils.translation import ugettext_lazy as _

from django.utils.datastructures import SortedDict

from django.db.models import FieldDoesNotExist

from authentic2 import app_settings, compat, forms, utils, validators

from ..forms import RegistrationForm as BaseRegistrationForm, SetPasswordForm, PasswordChangeForm

class RegistrationForm(forms.UserAttributeFormMixin, BaseRegistrationForm):

    def __init__(self, *args, **kwargs):

        """

        Inject required fields in registration form

        """

        super(RegistrationForm, self).__init__(*args, **kwargs)

        User = compat.get_user_model()

        insert_idx = 0

        field_names = compat.get_registration_fields()

        required_fields = set(compat.get_required_fields())

        for field_name in field_names:

            if field_name not in self.fields:

                try:

                    model_field = User._meta.get_field(field_name)

                except FieldDoesNotExist:

                    pass

                else:

                    kwargs = {}

                    if hasattr(model_field, 'validators'):

                        kwargs['validators'] = model_field.validators

                    field = model_field.formfield(**kwargs)

                    self.fields.insert(insert_idx, field_name, field)

                    insert_idx += 1

        for field_name in self.fields:

            if field_name in required_fields:

                self.fields[field_name].required = True

        # reorder fields obeying A2_REGISTRATION_FIELDS

        new_fields = SortedDict()

        for field_name in utils.field_names(app_settings.A2_REGISTRATION_FIELDS):

            if field_name in self.fields:

                new_fields[field_name] = self.fields[field_name]

        for field_name in self.fields:

            if field_name not in new_fields:

                new_fields[field_name] = self.fields[field_name]

        # override titles

        for field in app_settings.A2_REGISTRATION_FIELDS:

            if isinstance(field, (list, tuple)):

                if len(field) > 1:

                    self.fields[field[0]].label = field[1]

        self.fields = new_fields

        if 'username' in self.fields:

            self.fields['username'].regex = app_settings.A2_REGISTRATION_FORM_USERNAME_REGEX

            self.fields['username'].help_text = app_settings.A2_REGISTRATION_FORM_USERNAME_HELP_TEXT

            self.fields['username'].label = app_settings.A2_REGISTRATION_FORM_USERNAME_LABEL

    def clean_username(self):

        """

        Validate that the username is alphanumeric and is not already

        in use.

        """

        User = compat.get_user_model()

        username = self.cleaned_data['username']

        if app_settings.A2_REGISTRATION_REALM:

            if '@' in username:

                raise ValidationError(_('The character @ is forbidden in usernames.'))

            username = u'{0}@{1}'.format(username, app_settings.A2_REGISTRATION_REALM)

            self.cleaned_data['username'] = username

        existing = User.objects.filter(username__iexact=self.cleaned_data['username'])

        if existing.exists():

            raise ValidationError(_("A user with that username already exists."))

        else:

            return self.cleaned_data['username']

    def clean_email(self):

        """

        Verify if email is unique

        """

        User = compat.get_user_model()

        if app_settings.A2_REGISTRATION_EMAIL_IS_UNIQUE:

            if User.objects.filter(email__iexact=self.cleaned_data['email']):

                raise ValidationError(_('This email address is already in '

                    'use. Please supply a different email address.'))

        return self.cleaned_data['email']

from django.utils.translation import ugettext_lazy as _

from django.contrib.sites.models import RequestSite

from django.contrib.sites.models import Site

from django.contrib.auth.models import BaseUserManager, Group

from django.db import models

from authentic2 import app_settings, compat, models as a2_models

from ..models import RegistrationProfile as BaseRegistrationProfile

from ..models import ACTIVATION_KEY_RE

User = compat.get_user_model()

class RegistrationProfile(BaseRegistrationProfile, models.Model):

    user = models.ForeignKey(User, unique=True, related_name='profile')

    activation_key = models.CharField(_(u'User\'s activation key'),

                                      max_length=64, db_index=True)

    def activate_user(self, activation_key):

        if ACTIVATION_KEY_RE.search(activation_key):

            try:

                self = RegistrationProfile.objects.get(activation_key=activation_key)

                if not self.activation_key_expired():

                    self.user.is_active = True

                    self.user.save()

                    self.activation_key = self.model.ACTIVATED

                    self.save()

                    return self.user

            except self.DoesNotExist:

                return False

        return False

    def create_profile(self, user, site):

        self.user = user

        self.activation_key = self.activation_token

        self.save()

        self.send_activation_email(site)

    def create_inactive_user(self, request, **cleaned_data):

        User = compat.get_user_model()

        if Site._meta.installed:

            site = Site.objects.get_current()

        else:

            site = RequestSite(request)

        user_fields = {}

        for field in compat.get_registration_fields():

            # save User model fields

            try:

                User._meta.get_field(field)

            except models.FieldDoesNotExist:

                continue

            if field.startswith('password'):

                continue

            user_fields[field] = cleaned_data[field]

            if field == 'email':

                user_fields[field] = BaseUserManager.normalize_email(user_fields[field])

        new_user = User(is_active=False, **user_fields)

        new_user.clean()

        new_user.set_password(cleaned_data['password1'])

        new_user.save()

        attributes = a2_models.Attribute.objects.filter(

            asked_on_registration=True)

        if attributes:

            for attribute in attributes:

                attribute.set_value(new_user, cleaned_data[attribute.name])

        if app_settings.A2_REGISTRATION_GROUPS:

            groups = []

            for name in app_settings.A2_REGISTRATION_GROUPS:

                group, created = Group.objects.get_or_create(name=name)

                groups.append(group)

            new_user.groups = groups

        return new_user, site

import logging

from django.shortcuts import redirect, render

from django.utils.translation import ugettext as _

from django.contrib import messages

from django.contrib.auth.decorators import login_required

from django.contrib.auth import views as auth_views

from django.conf import settings

from authentic2 import app_settings, models

from ..views import RegistrationView as BaseRegistrationView

from ..views import ActivationView as BaseActivationView

from .models import RegistrationProfile

from .forms import RegistrationForm

logger = logging.getLogger(__name__)

class RegistrationView(BaseRegistrationView):

    form_class = RegistrationForm

    def register(self, request, **cleaned_data):

        profile = RegistrationProfile()

        new_user = profile.create_user(request, **cleaned_data)

        return new_user

register = RegistrationView.as_view()

class ActivationView(BaseActivationView):

    def activate(self, request, activation_key):

        profile = RegistrationProfile()

        return profile.activate_user(activation_key)

activate = ActivationView.as_view()

@login_required

def delete(request, next_url='/'):

    next_url = request.build_absolute_uri(request.META.get('HTTP_REFERER') or next_url)

    if not app_settings.A2_REGISTRATION_CAN_DELETE_ACCOUNT:

        return redirect(next_url)

    if request.method == 'POST':

        if 'submit' in request.POST:

            models.DeletedUser.objects.delete_user(request.user)

            logger.info(u'deletion of account %s requested' % request.user)

            messages.info(request, _('Your account has been scheduled for deletion. You cannot use it anymore.'))

            return redirect('auth_logout')

        else:

            return redirect(next_url)

    return render(request, 'registration/delete_account.html')

password_change = auth_views.password_change

password_change_done = auth_views.password_change_done

password_reset = auth_views.password_reset

password_reset_confirm = auth_views.password_reset_confirm

password_reset_complete = auth_views.password_reset_complete

password_reset_done = auth_views.password_reset_done

from django.utils.translation import ugettext_lazy as _

from django.contrib.auth import forms

from authentic2 import validators

class RegistrationForm(Form):

        raise NotImplementedError

        raise NotImplementedError

class SetPasswordForm(forms.SetPasswordForm):

class PasswordChangeForm(forms.PasswordChangeForm):

import hashlib

import random

import re

from datetime import datetime, timedelta

from django.conf import settings

from django.template.loader import render_to_string

from django.core.mail import send_mail

ACTIVATION_KEY_RE = re.compile('^[a-f0-9]{40}$')

class RegistrationProfile(object):

    ACTIVATED = 'ACTIVATED'

    def __unicode__(self):

        return u"Registration information for %s" % self.user

    @property

    def activation_token(self):

        salt = hashlib.sha1(str(random.random())).hexdigest()[:5]

        now = datetime.now().isoformat()

        activation_key = hashlib.sha1(salt+now).hexdigest()

        return activation_key

    def create_profile(self, user, site):

        raise NotImplementedError

    def create_inactive_user(self, request, **cleaned_data):

        raise NotImplementedError

    def create_user(self, *args, **kwargs):

        user, site = self.create_inactive_user(*args, **kwargs)

        self.create_profile(user, site)

        return user

    def activate_user(self, activation_key):

        raise NotImplementedError

    def activation_key_expired(self):

        expiration_date = timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS)

        return self.activation_key == self.ACTIVATED or \

               (self.user.date_joined + expiration_date <= datetime.now())

    activation_key_expired.boolean = True

    def send_activation_email(self, site):

        ctx_dict = {'activation_key': self.activation_key,

                    'user': self.user,

                    'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS,

                    'site': site}

        subject = render_to_string('registration/activation_email_subject.txt',

                                   ctx_dict)

        subject = ''.join(subject.splitlines())

        message = render_to_string('registration/activation_email.txt',

                                   ctx_dict)

        send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,

                  [self.user.email], fail_silently=True)

from ..utils import get_form_class

REGISTRATION_BACKEND = app_settings.A2_REGISTRATION_BACKEND

urlpatterns = patterns('authentic2.registration_backend.%s.views' % REGISTRATION_BACKEND,

                           'activate',

                           'password_change',

                           {'password_change_form': CHANGE_PASSWORD_FORM_CLASS,

                            'post_change_redirect': 'done'},

                           'password_change_done',

                           'password_reset',

                           {'post_reset_redirect': 'done'},

                           'password_reset_confirm',

                           'password_reset_complete',

                           'password_reset_done',

from django.views.generic.edit import FormView

from django.views.generic.base import TemplateView

from django.shortcuts import redirect

from .. import models, app_settings, compat

logger = logging.getLogger(__name__)

class RegistrationView(FormView):

    disallowed_url = 'registration_disallowed'

    template_name = 'registration/registration_form.html'

    def dispatch(self, request, *args, **kwargs):

        if not self.registration_allowed(request):

            return redirect(self.disallowed_url)

        return super(RegistrationView, self).dispatch(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):

        form_class = self.get_form_class()

        form = self.get_form(form_class)

        if form.is_valid():

            return self.form_valid(request, form)

        else:

            return self.form_invalid(form)

        raise NotImplementedError

    def get_success_url(self):

        return ('registration_complete')

    def form_valid(self, request, form):

        self.register(request, **form.cleaned_data)

        return redirect(self.get_success_url())

class ActivationView(TemplateView):

    http_method_names = ['get']

    template_name = 'registration/activate.html'

    def get(self, request, *args, **kwargs):

        activated_user = self.activate(request, *args, **kwargs)

        if activated_user:

            return redirect(self.get_success_url())

    def activate(self, request, *args, **kwargs):

        raise NotImplementedError

    def get_success_url(self):

        return ('registration_activation_complete')

def get_form_class(form_class):

    module, form_class = form_class.rsplit('.', 1)

    module = import_module(module)

    return getattr(module, form_class)