Produits Entr'ouvert » Publik

    A2_REGISTRATION_COMPLETION_FORM_CLASS = Setting(default='authentic2.registration_backend.forms.RegistrationCompletionForm',

                definition='Default registration completion form'),

    A2_REGISTRATION_ID_NAME=Setting(default='registration_id', definition='Unique registration identifier name'),

from authentic2.registration_backend.views import RegistrationView

    return RegistrationView.as_view(request, success_url=next_url,

                                    form_class=functools.partial(forms.RegistrationForm,

                                    request=request))

from django.contrib.auth import views as auth_views

from authentic2.utils import get_form_class

from . import app_settings

SET_PASSWORD_FORM_CLASS = get_form_class(

        app_settings.A2_REGISTRATION_SET_PASSWORD_FORM_CLASS)

CHANGE_PASSWORD_FORM_CLASS = get_form_class(

        app_settings.A2_REGISTRATION_CHANGE_PASSWORD_FORM_CLASS)

    url(r'^password/change/$',

        auth_views.password_change,

        {'password_change_form': CHANGE_PASSWORD_FORM_CLASS},

        name='auth_password_change'),

    url(r'^password/change/done/$',

        auth_views.password_change_done,

        name='auth_password_change_done'),

    url(r'^password/reset/confirm/(?P<uidb36>[0-9A-Za-z]+)-(?P<token>.+)/$',

        auth_views.password_reset_confirm,

        {'set_password_form': SET_PASSWORD_FORM_CLASS},

        name='auth_password_reset_confirm'),

    url(r'^password/reset/$',

        auth_views.password_reset,

        name='auth_password_reset'),

    url(r'^password/reset/complete/$',

        auth_views.password_reset_complete,

        name='auth_password_reset_complete'),

    url(r'^password/reset/done/$',

        auth_views.password_reset_done,

        name='auth_password_reset_done'),

from uuid import uuid1

from django.conf import settings

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

from django.core.mail import send_mail

from django.core import signing

from django import get_version

from django.template.loader import render_to_string

from django.core.urlresolvers import reverse

from .. import app_settings, compat, forms, utils,\

    validators, widgets, fields, models

User = compat.get_user_model()

is_django_17 = get_version().startswith('1.7')

EXPIRATION = settings.ACCOUNT_ACTIVATION_DAYS

registration_id_name = app_settings.A2_REGISTRATION_ID_NAME

class RegistrationForm(Form):

    error_css_class = 'form-field-error'

    required_css_class = 'form-field-required'

    email = EmailField()

    def clean_email(self):

        """

        Verify if email is unique

        """

        User = compat.get_user_model()

        if app_settings.A2_REGISTRATION_EMAIL_IS_UNIQUE and \

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

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

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

        return self.cleaned_data['email']

    def save(self, request):

        data = self.cleaned_data

        registration_id = uuid1().hex

        data.update({'next_url': request.GET.get('next_url'),

                     registration_id_name: registration_id})

        registration_token = signing.dumps(data)

        ctx_dict = {'registration_url': request.build_absolute_uri(

            reverse('registration_activate',

            kwargs={'registration_token': registration_token})),

                    'expiration_days': EXPIRATION,

                    'email': data['email']}

        ctx_dict.update(self.cleaned_data)

        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)

        if is_django_17:

            html_message = render_to_string('registration/activation_email.html',

                                            ctx_dict)

            send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,

                      [data['email']], fail_silently=True,

                      html_message=message)

        else:

            send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,

                      [data['email']], fail_silently=True)

class RegistrationCompletionForm(forms.UserAttributeFormMixin, Form):

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

                        continue

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

        user_fields = {}

        for field in compat.get_registration_fields():

            # save User model fields

            try:

                User._meta.get_field(field)

            except FieldDoesNotExist:

                continue

            if field.startswith('password'):

                continue

            user_fields[field] = kwargs[field]

            if field == 'email':

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

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

        new_user.clean()

        new_user.set_password(kwargs['password1'])

        new_user.save()

        registration_id, created = models.Attribute.objects.get_or_create(label=registration_id_name,

                                                                          name=registration_id_name,

                                                                          kind='string',

                                                                          asked_on_registration=False,

                                                                          user_visible=False)

        registration_id.set_value(new_user, kwargs[registration_id_name])

        attributes = models.Attribute.objects.filter(

                asked_on_registration=True)

        if attributes:

            for attribute in attributes:

                attribute.set_value(new_user, kwargs[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, kwargs['next_url']

from django.contrib.auth.decorators import login_required

from .views import RegistrationView, RegistrationCompletionView, DeleteView,\

    LoginView

urlpatterns = patterns('',

    url(r'^activate/expired/$',

        TemplateView.as_view(template_name='registration/activation_expired.html'),

        name='registration_activation_expired'),

    url(r'^activate/(?P<registration_token>[\w:-]+)/$',

        RegistrationCompletionView.as_view(),

        name='registration_activate'),

    url(r'^activate/(?P<registration_token>[\w:-]+)/(?P<username>\w+)$',

        LoginView.as_view(),

        name='registration_login'),

    url(r'^register/$',

        RegistrationView.as_view(),

        name='registration_register'),

    url(r'^register/complete/$',

        TemplateView.as_view(template_name='registration/registration_complete.html'),

        name='registration_complete'),

    url(r'^register/closed/$',

        TemplateView.as_view(template_name='registration/registration_closed.html'),

        name='registration_disallowed'),

    url(r'^delete/$',

        login_required(DeleteView.as_view()),

        name='delete_account'),

)

from datetime import datetime

from django.conf import settings

from django.contrib.auth import authenticate, login as django_login, logout

from django.db import IntegrityError

from django.template.loader import render_to_string

from django.core import signing

from django.views.generic.edit import FormView

from django.views.generic.base import TemplateView, View

from authentic2.utils import get_form_class

from .forms import EXPIRATION, registration_id_name

User = compat.get_user_model()

def valid_token(method):

    def f(obj, *args, **kwargs):

        try:

            registration_kwargs = signing.loads(kwargs['registration_token'],

                                                max_age=EXPIRATION*3600*24)

            params = kwargs.copy()

            params.update(registration_kwargs)

        except signing.SignatureExpired:

            return redirect('registration_activation_expired')

        return method(obj, *args, **params)

    return f

def login(request, user, redirect_url='auth_homepage'):

    user.backend = settings.AUTHENTICATION_BACKENDS[1]

    django_login(request, user)

    return redirect(redirect_url)

class LoginView(View):

    redirect_url = 'auth_homepage'

    @valid_token

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

        try:

            user = User.objects.get(email=kwargs['email'], username=kwargs['username'])

            return login(request, user)

        except User.DoesNotExist:

            return redirect(self.redirect_url)

class RegistrationView(FormView):

    form_class = get_form_class(app_settings.A2_REGISTRATION_FORM_CLASS)

    template_name = 'registration/registration_form.html'

    def form_valid(self, form):

        form.save(self.request)

        return redirect('registration_complete')

class RegistrationCompletionView(FormView):

    form_class = get_form_class(app_settings.A2_REGISTRATION_COMPLETION_FORM_CLASS)

    http_method_names = ['get', 'post']

    template_name = 'registration/registration_completion_form.html'

    @valid_token

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

        if app_settings.A2_REGISTRATION_EMAIL_IS_UNIQUE:

            print "UNIQUE???"

                user = User.objects.get(email__iexact=kwargs['email'])

            except User.DoesNotExist:

                return super(RegistrationCompletionView, self).get(request, *args, **kwargs)

            return login(request, user)

        else:

            user_accounts = User.objects.filter(email__iexact=kwargs['email'])

            if user_accounts:

                has_active_account = False

                for user in user_accounts:

                    registration_id = kwargs[registration_id_name]

                    if models.AttributeValue.objects.with_owner(user).filter(attribute__label=registration_id_name,

                                                                             content='"%s"' % registration_id).exists():

                        has_active_account = True

                if has_active_account:

                    logout(request)

                    context = kwargs.copy()

                    context.update({'accounts': user_accounts})

                    self.template_name = 'registration/login_choices.html'

                    return self.render_to_response(context)

                else:

                    return super(RegistrationCompletionView, self).get(request, *args, **kwargs)

            else:

                return super(RegistrationCompletionView, self).get(request, *args, **kwargs)

    @valid_token

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

        form = self.get_form(self.form_class)

        if form.is_valid():

            params = form.cleaned_data.copy()

            params.update(kwargs)

            user, next_url = form.save(**params)

            if next_url:

                return login(request, user, next_url)

            return login(request, user)

        else:

            return self.form_invalid(form)

class DeleteView(TemplateView):

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

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

                                              or request.GET.get('next_url'))

        if not app_settings.A2_REGISTRATION_CAN_DELETE_ACCOUNT:

            return redirect(next_url)

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

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

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

                                              or request.GET.get('next_url'))

  <p>→ {% trans "Not a member?" %} <a href="{% url 'registration_register' %}?{{ request.GET.urlencode }}">{% trans "Register!" %}</a></p>

{% load i18n %}

<h3>{% trans "Account creation" %}</h3>

<p>

{% blocktrans %}

To continue your account creation on {{ site }} please <a href="{{ site }}{{ registration_token }}">click here</a>

{% endblocktrans %}

</p>

<p>{% blocktrans %}This link is valid for {{ expiration_days }} days.{% endblocktrans %}</p>

{% trans "Activate account" %}:

{{ registration_url }}

{% load i18n %}{% trans "Account activation on" %} {{ site }}

{% extends "base.html" %}

{% load i18n %}

{% block title %}

{% trans "Account activation expired" %}

{% endblock %}

{% block content %}

<h2>{% trans "Account activation" %}</h2>

<p>{% trans "Your activation key is expired" %}</p>

{% endblock %}

{% extends "base.html" %}

{% load breadcrumbs i18n %}

{% block title %}

{% trans "Login" %}

{% endblock %}

{% block breadcrumbs %}

{{ block.super }}

{% breadcrumb_url 'Register' %}

{% endblock %}

{% block content %}

<h2>{% trans "Login" %}</h2>

<p>{% trans "Multiple accounts are associated to this email." %}

{% trans "Please choose the account you want to log in with:" %}

</p>

<ul>

  {% for account in accounts %}

  <li><a href="{% url "registration_login" registration_token account.username %}">{{ account }}</a></li>

  {% endfor %}

</ul>

{% endblock %}

<p>{% trans "Thank you for registering. Activation email sent." %}</p>

{% extends "base.html" %}

{% load i18n %}

{% block title %}

{% trans "Registration" %}

{% endblock %}

{% load breadcrumbs %}

{% block breadcrumbs %}

{{ block.super }}

{% breadcrumb_url 'Register' %}

{% endblock %}

{% block content %}

<h2>{% trans "Registration" %}</h2>

<p>{% trans "Please fill the formm to complete your registration" %}</p>

<form method="post">

  {% csrf_token %}

  {{ form.as_p }}

  <input type="submit" value="{% trans 'Submit' %}" />

</form>

{% endblock %}

<form method="post">

import re

from django.core import mail

from django.core.urlresolvers import reverse

from django.test import TestCase

from django.test.client import Client

from django.test.utils import override_settings

from django.conf import settings

class RegistrationTests(TestCase):

    def setUp(self):

        self.client = Client()

    def test_registration(self):

        response = self.client.post(reverse('registration_register'),

                                    {'email': 'testbot@entrouvert.com'})

        self.assertRedirects(response, reverse('registration_complete'))

        self.assertEqual(len(mail.outbox), 1)

        links = re.findall('http[s]://.*/', mail.outbox[0].body)

        self.assertIsInstance(links, list) and self.assertIsNot(links, [])

        link = links[0]

        completion = self.client.get(link)

        self.assertEqual(completion.status_code, 200)

        self.bad_password_test(link)

        self.good_password_test(link)

        mail.outbox = []

    def bad_password_test(self, url):

        """

        test short filled password

        """

        completion = self.client.post(url, {'username': 'toto',

                                            'password1': 'toto',

                                            'password2': 'toto'})

        self.assertEqual(completion.status_code, 200)

    def good_password_test(self, url):

        completion = self.client.post(url, {'username': 'toto',

                                            'password1': 'T0toto',

                                            'password2': 'T0toto'})

        self.assertEqual(completion.status_code, 302)

def get_form_class(form_class):

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

    module = import_module(module)

    return getattr(module, form_class)