Produits Entr'ouvert » Authentic 2

from authentic2.a2_rbac.models import OrganizationalUnit as OU, Role

from authentic2.custom_user.models import User

from .utils.views import csrf_token_check

from .forms import authentication as authentication_forms

from .utils.evaluate import evaluate_condition

    def name(self):

        return ugettext_lazy('Password')

        if not roles:

            return []

        service_ou_ids = []

            return []

        return OU.objects.filter(pk__in=service_ou_ids)

        preferred_ous_cookie = utils.get_remember_cookie(request, 'preferred-ous')

        preferred_ous = []

        if preferred_ous_cookie:

            preferred_ous.extend(OU.objects.filter(pk__in=preferred_ous_cookie))

        # for the special case of services open to only one OU, pre-select it

        return preferred_ous

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

        context = kwargs.get('context', {})

        is_post = request.method == 'POST' and self.submit_name in request.POST

        data = request.POST if is_post else None

        # Special handling when the form contains an OU selector

        if app_settings.A2_LOGIN_FORM_OU_SELECTOR:

            if preferred_ous:

                initial['ou'] = preferred_ous[0]

                if form.cleaned_data.get('remember_me'):

                    request.session['remember_me'] = True

                    request.session.set_expiry(app_settings.A2_USER_REMEMBER_ME)

                if 'ou' in form.fields:

                    utils.prepend_remember_cookie(request, response, 'preferred-ous', form.cleaned_data['ou'].pk)

    filter_element_private_key

from .. import plugins, app_settings, constants, crypto

class CleanLogMessage(logging.Filter):

    return None

    '''Login a user model, record the authentication event and redirect to next

       URL or settings.LOGIN_REDIRECT_URL.'''

    from .. import hooks

    from .views import check_cookie_works

    check_cookie_works(request)

    last_login = user.last_login

    auth_login(request, user)

def login_require(request, next_url=None, login_url='auth_login', service=None, login_hint=(), **kwargs):

    '''Require a login and come back to current URL'''

    next_url = next_url or request.get_full_path()

    params = kwargs.setdefault('params', {})

    params[REDIRECT_FIELD_NAME] = next_url

    if service:

    if login_hint:

        request.session['login-hint'] = list(login_hint)

    elif 'login-hint' in request.session:

        return field.related_model

    next_url = select_next_url(request, settings.LOGIN_REDIRECT_URL)

    next_url = make_url(next_url, request=request, keep_params=True,

                        include=(constants.NONCE_FIELD_NAME,), resolve=False)

    params = {REDIRECT_FIELD_NAME: next_url}

    return make_url('registration_register', params=params)

def simulate_authentication(request, user, method,

                            backend='authentic2.backends.models_backend.ModelBackend',

    '''Simulate a normal login by forcing a backend attribute on the user instance'''

    # do not modify the passed user

    user = copy.deepcopy(user)

    user.backend = backend

def get_manager_login_url():

from authentic2.custom_user.models import iter_attributes

from . import (utils, app_settings, decorators, constants,

               models, cbv, hooks, validators, attribute_kinds)

from .utils import switch_user

from .a2_rbac.utils import get_default_ou

from .a2_rbac.models import OrganizationalUnit as OU

    redirect_to = request.GET.get(redirect_field_name)

    if not redirect_to or ' ' in redirect_to:

        redirect_to = settings.LOGIN_REDIRECT_URL

    # Heavier security check -- redirects to http://example.com should

    blocks = []

    context = {

        'cancel': nonce is not None,

            parameters = {'request': request,

                          'context': context}

            remote_addr = request.META.get('REMOTE_ADDR')

            login_hint = set(request.session.get('login-hint', []))

            show_ctx = dict(remote_addr=remote_addr, login_hint=login_hint)

            # check if the authenticator has multiple instances

            if hasattr(authenticator, 'instances'):

                for instance_id, instance in authenticator.instances(**parameters):

            self.token[field] = form.cleaned_data[field]

        # propagate service to the registration completion view

        self.token.pop(REDIRECT_FIELD_NAME, None)

        self.token.pop('email', None)

            self.email_is_unique |= self.ou.email_is_unique

        self.init_fields_labels_and_help_texts()

        # if registration is done during an SSO add the service to the registration event

        return super(RegistrationCompletionView, self) \

            .dispatch(request, *args, **kwargs)

            utils.simulate_authentication(

                request, self.users[0],

                method=self.authentication_method,

            return utils.redirect(request, self.get_success_url())

        confirm_data = self.token.get('confirm_data', False)

                    utils.simulate_authentication(

                        request, user,

                        method=self.authentication_method,

                    return utils.redirect(request, self.get_success_url())

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

    def registration_success(self, request, user, form):

        hooks.call_hooks('event', name='registration', user=user, form=form, view=self,

                         authentication_method=self.authentication_method,

        self.token_obj.delete()

        utils.simulate_authentication(

            request, user,

            method=self.authentication_method,

        message_template = loader.get_template('authentic2/registration_success_message.html')

        messages.info(self.request, message_template.render(request=request))

        self.send_registration_success_email(user)

from authentic2.a2_rbac.utils import get_default_ou

from authentic2.forms.passwords import SetPasswordForm

from authentic2.utils import views as views_utils

from . import app_settings, models, utils

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

        registration = True if 'registration' in request.GET else False

        '''Request an access grant code and associate it to the current user'''

        if request.user.is_authenticated:

            # Prevent to add a link with an FC account already linked with another user.

            try:

                        return self.redirect(request)

        if user:

            views_utils.check_cookie_works(request)

            # set session expiration policy to EXPIRE_AT_BROWSER_CLOSE

            request.session.set_expiry(0)

            self.fc_account = models.FcAccount.objects.get(sub=self.sub, user=user)

            return self.redirect(request)

        else:

            params = {}

            if registration:

                return self.redirect_and_come_back(request,

                                                   a2_utils.make_url('fc-registration',

        params = {

            REDIRECT_FIELD_NAME: redirect_to,

        }

        if self.get_in_popup():

            params['popup'] = ''

        redirect_to = a2_utils.make_url('fc-login-or-link', params=params)

        data['valid_email'] = False

        data['franceconnect'] = True

        data['authentication_method'] = 'france-connect'

        activation_url = a2_utils.build_activation_url(request,

                                                       next_url=redirect_to,

                                                       **data)

from django.utils.six.moves.urllib import parse as urlparse

from django.utils.timezone import now

from authentic2_auth_fc import models

from authentic2_auth_fc.utils import requests_retry_session

User = get_user_model()

def path(url):

    return urlparse.urlparse(url).path

    location = urlparse.urlparse(response['Location'])

    query = urlparse.parse_qs(location.query)

    response = response.follow().click('Register')

    location = urlparse.urlparse(response.request.url)

    query = urlparse.parse_qs(location.query)

    response.form.set('email', 'john.doe@example.com')

    response = response.form.submit()

            reverse('auth_login'),

            **{

                'nonce': '*',

                REDIRECT_FIELD_NAME: make_url(

                    'a2-idp-saml-continue',

                    params={NONCE_FIELD_NAME: request_id}),