Produits Entr'ouvert » Authentic 2

import logging

import smtplib

from django.db import models

from django.contrib.auth import get_user_model

from django.core.exceptions import MultipleObjectsReturned

from rest_framework.routers import SimpleRouter

from rest_framework.generics import GenericAPIView

from rest_framework.response import Response

from rest_framework.exceptions import PermissionDenied, AuthenticationFailed

from rest_framework.fields import CreateOnlyDefault

from rest_framework.decorators import list_route, detail_route

from .a2_rbac.utils import get_default_ou

class HookMixin(object):

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

        serializer = super(HookMixin, self).get_serializer(*args, **kwargs)

class LDAPBackendPasswordLost(LDAPBackend):

        if not user:

            return

        config = self.get_config()

        from .. import models

        return bool(models.PasswordReset.filter(user=user).count())

        UserModel = get_user_model()

        if not username:

            return

        query = self.get_query(username=username, realm=realm, ou=ou)

class DummyModelBackend(ModelBackend):

        if user is not None:

            return user

from django.contrib.auth import forms as auth_forms

from django.utils import html

from authentic2.forms.fields import PasswordField

from ..a2_rbac.models import OrganizationalUnit as OU

        ou = self.cleaned_data.get('ou')

        if username is not None and password:

            if self.user_cache is None:

                raise forms.ValidationError(

                    self.error_messages['invalid_login'],

from django.core.exceptions import ImproperlyConfigured, PermissionDenied

from django.http.request import QueryDict

from django.contrib.auth import (REDIRECT_FIELD_NAME, login as auth_login, SESSION_KEY,

                                 get_user_model)

from django import forms

from django.forms.utils import ErrorList, to_current_timezone

        for key in (SESSION_KEY, BACKEND_SESSION_KEY, HASH_SESSION_KEY,

                    constants.LAST_LOGIN_SESSION_KEY):

            switched[key] = request.session[key]

        login(request, user, 'switch')

        request.session[constants.SWITCH_USER_SESSION_KEY] = switched

        if constants.LAST_LOGIN_SESSION_KEY not in request.session:

    if session is not None:

        return session.get(constants.AUTHENTICATION_EVENTS_SESSION_KEY, [])

    return []

from django.contrib.auth.decorators import login_required

from django.db.models.fields import FieldDoesNotExist

from django.db.models.query import Q

from django.http import Http404

from django.utils.http import urlsafe_base64_decode

from django.views.generic.edit import CreateView

        try:

            uid = urlsafe_base64_decode(uidb64)

            # use authenticate to eventually get an LDAPUser

        except (TypeError, ValueError, OverflowError,

                UserModel.DoesNotExist):

            validlink = False

import django

from django.views.generic import View, FormView

from django.http import HttpResponseRedirect, Http404

from django.contrib import messages

from django.shortcuts import resolve_url, render

from django.utils.translation import ugettext as _

        default_ou = get_default_ou()

        email_is_unique = a2_app_settings.A2_EMAIL_IS_UNIQUE or default_ou.email_is_unique

        if not user and self.user_info.get('email') and email_is_unique:

            email = self.user_info['email']

            User = get_user_model()

                            self.logger.info(u'fc link created sub %s user %s', self.sub, user)

                            hooks.call_hooks('event', name='fc-link', user=user, sub=self.sub,

                                             request=request)

                    else:

                        messages.warning(

                            request,

class OIDCBackend(ModelBackend):

        logger = logging.getLogger(__name__)

        if id_token is None:

            return

from django.core.urlresolvers import reverse

from django.utils.translation import get_language, ugettext as _

from django.contrib import messages

from django.conf import settings

from django.views.generic.base import View

from django.http import HttpResponseBadRequest

from authentic2.decorators import setting_enabled

from . import app_settings, models

from .utils import get_provider, get_provider_by_issuer

            return self.continue_to_next_url()

        logger.info(u'got token response %s', result)

        access_token = result.get('access_token')

        if user:

            # remember last tokens for logout

            tokens = request.session.setdefault('auth_oidc', {}).setdefault('tokens', [])

class SAMLBackend(SAMLBackend):

        if not app_settings.enable:

            return None

        return super(SAMLBackend, self).authenticate(saml_attributes=saml_attributes, request=request)

            user_editable=True,

            user_visible=True,

            kind='string')

                                          password='secret'))

        # get the edit page in order to check form's prefix

            user_visible=False,

            kind='string')

                                          password='secret'))

        response = self.client.get(reverse('profile_edit'))

        form = get_response_form(response)

    assert response.content == b'{}'

    # login

    response = client.get('/api/user/', HTTP_ORIGIN='http://testserver')

    data = json.loads(response.content)

    assert isinstance(data, dict)

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from authentic2.backends import is_user_authenticable

from ldap.dn import escape_dn_chars

from ldaptools.slapd import Slapd, has_slapd

from django.core.exceptions import ImproperlyConfigured

from django.core import management

from django.core import mail

from authentic2.a2_rbac.utils import get_default_ou

from django_rbac.utils import get_ou_model

from authentic2.backends import ldap_backend

from authentic2 import crypto, models

import utils

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# authentic2

from django.contrib.auth.middleware import AuthenticationMiddleware

from django.contrib.sessions.middleware import SessionMiddleware

from authentic2.utils import (good_next_url, same_origin, select_next_url,

                              user_can_change_password, login,

def test_good_next_url(db, rf, settings):