Produits Entr'ouvert » Authentic 2

import sys

from django.core.exceptions import ImproperlyConfigured

class Setting(object):

    def has_default(self):

        return self.default != self.SENTINEL

class AppSettings(object):

    def __init__(self, defaults):

        self.defaults = defaults

        realms = {}

        if self.A2_REGISTRATION_REALM:

            realms[self.A2_REGISTRATION_REALM] = self.A2_REGISTRATION_REALM

        def add_realms(new_realms):

            for realm in new_realms:

                if not isinstance(realm, (tuple, list)):

                    realms[realm] = realm

                else:

                    realms[realm[0]] = realm[1]

        from django.contrib.auth import get_backends

        for backend in get_backends():

            if hasattr(backend, 'get_realms'):

        if self.defaults[key].has_default():

            return self.defaults[key].default

        raise ImproperlyConfigured('missing setting %s(%s) is mandatory' %

# Registration

default_settings = dict(

        names=('A2_ATTRIBUTE_BACKENDS',),

        default=('authentic2.attributes_ng.sources.format',

                 'authentic2.attributes_ng.sources.function',

                 'authentic2.attributes_ng.sources.ldap',

                 'authentic2.attributes_ng.sources.computed_targeted_id',

                 'authentic2.attributes_ng.sources.service_roles',

        definition='List of attribute backend classes or modules',

    ),

    A2_REGISTRATION_FORM_USERNAME_REGEX=Setting(default=r'^[\w.@+-]+$', definition='Regex to validate usernames'),

    A2_REGISTRATION_FORM_USERNAME_HELP_TEXT=Setting(default=_('Required. At most '

    A2_REGISTRATION_FORM_USERNAME_LABEL=Setting(default=_('Username')),

    A2_REGISTRATION_REALM=Setting(default=None, definition='Default realm to assign to self-registrated users'),

    A2_REGISTRATION_GROUPS=Setting(default=(), definition='Default groups for self-registered users'),

    A2_PROFILE_FIELDS=Setting(default=(), definition='Fields to show to the user in the profile page'),

    A2_REQUIRED_FIELDS=Setting(default=(), definition='User fields that are required'),

    A2_PRE_REGISTRATION_FIELDS=Setting(default=(), definition='User fields to ask with email'),

    A2_REALMS=Setting(default=(), definition='List of realms to search user accounts'),

    A2_USERNAME_REGEX=Setting(default=None, definition='Regex that username must validate'),

    A2_USERNAME_LABEL=Setting(default=None, definition='Alternate username label for the login'

    A2_USERNAME_HELP_TEXT=Setting(default=None, definition='Help text to explain validation rules of usernames'),

    A2_USERNAME_IS_UNIQUE=Setting(default=True, definition='Check username uniqueness'),

    A2_REGISTRATION_USERNAME_IS_UNIQUE=Setting(default=True, definition='Check username uniqueness on registration'),

    A2_ATTRIBUTE_KINDS=Setting(default=(), definition='List of other attribute kinds'),

    A2_VALIDATE_EMAIL=Setting(default=False, definition='Validate user email server by doing an RCPT command'),

    A2_VALIDATE_EMAIL_DOMAIN=Setting(default=True, definition='Validate user email domain'),

    A2_PASSWORD_POLICY_MIN_LENGTH=Setting(default=8, definition='Minimum number of characters in a password'),

    A2_PASSWORD_POLICY_REGEX=Setting(default=None, definition='Regular expression for validating passwords'),

    A2_PASSWORD_POLICY_CLASS=Setting(

        default='authentic2.passwords.DefaultPasswordChecker',

        definition='path of a class to validate passwords'),

    A2_PASSWORD_POLICY_SHOW_LAST_CHAR=Setting(default=False, definition='Show last character in password fields'),

    PUSH_PROFILE_UPDATES=Setting(default=False, definition='Push profile update to linked services'),

    TEMPLATE_VARS=Setting(default={}, definition='Variable to pass to templates'),

    A2_LOGIN_EXPONENTIAL_RETRY_TIMEOUT_FACTOR=Setting(default=1.8,

    A2_VERIFY_SSL=Setting(default=True, definition='Verify SSL certificate in HTTP requests'),

    A2_ATTRIBUTE_KIND_TITLE_CHOICES=Setting(default=(), definition='Choices for the title attribute kind'),

    A2_CORS_WHITELIST=Setting(default=(), definition='List of origin URL to whitelist, must be scheme://netloc[:port]'),

    A2_EMAIL_CHANGE_TOKEN_LIFETIME=Setting(default=7200, definition='Lifetime in seconds of the '

    A2_REDIRECT_WHITELIST=Setting(

        default=(),

        definition='List of origins which are authorized to ask for redirection.'),

    A2_USER_REMEMBER_ME=Setting(

        default=None,

        definition='Session duration as seconds when using the remember me '

    A2_LOGIN_REDIRECT_AUTHENTICATED_USERS_TO_HOMEPAGE=Setting(

        default=False,

        definition='Redirect authenticated users to homepage'),

import logging.config

# Load default from Django

from django.conf import global_settings

from gadjo.templatetags.gadjo import xstatic

from . import plugins, logger

CACHES = global_settings.CACHES

BASE_DIR = os.path.dirname(__file__)

# See https://docs.djangoproject.com/en/dev/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!

    }

}

# Hey Entr'ouvert is in France !!

    },

]

MIDDLEWARE_CLASSES = (

    'authentic2.middleware.StoreRequestMiddleware',

    'authentic2.middleware.RequestIdMiddleware',

STATICFILES_FINDERS = list(global_settings.STATICFILES_FINDERS) + ['gadjo.finders.XStaticFinder']

INSTALLED_APPS = (

    'django.contrib.staticfiles',

    'django_rbac.backends.DjangoRBACBackend',

)

AUTHENTICATION_BACKENDS = plugins.register_plugins_authentication_backends(

CSRF_FAILURE_VIEW = 'authentic2.views.csrf_failure_view'

LOGIN_REDIRECT_URL = '/'

LOGIN_URL = '/login/'

LOGOUT_URL = '/logout/'

# Can be none, sp, idp or both

PASSWORD_HASHERS = list(global_settings.PASSWORD_HASHERS) + [

]

# Admin tools

# Serialization module to support natural keys in generic foreign keys

SERIALIZATION_MODULES = {

}

LOGGING_CONFIG = None

    'disable_existing_loggers': True,

    'filters': {

        'cleaning': {

        },

        'request_context': {

        },

        'force_debug': {

            '()': 'authentic2.log_filters.ForceDebugFilter',

    'handlers': {

        'console': {

            'level': 'DEBUG',

            'formatter': 'verbose',

            'filters': ['cleaning', 'request_context'],

        },

        'console_db': {

            'level': 'DEBUG',

            'formatter': 'verbose_db',

            'filters': ['cleaning'],

        },

        # even when debugging seeing SQL queries is too much, activate it

        # explicitly using DEBUG_DB

        'django.db': {

        },

        'django': {

        },

        # django_select2 outputs debug message at level INFO

        'django_select2': {

        },

        # lasso has the bad habit of logging everything as errors

        'Lasso': {

            'filters': ['force_debug'],

        },

        '': {

        },

    },

}

MIGRATION_MODULES = {

}

MIGRATION_MODULES['auth'] = 'authentic2.auth_migrations_18'

    'PAGE_SIZE': 100,

}

# Authentic2 Auth SAML

MELLON_ADAPTER = ('authentic2_auth_saml.adapters.AuthenticAdapter',)

from django.conf import settings

from django.contrib import admin

from django.contrib.staticfiles.views import serve

    url(r'^api/', include('authentic2.api_urls'))

]

urlpatterns += not_homepage_patterns

try:

if settings.DEBUG and 'debug_toolbar' in settings.INSTALLED_APPS:

    import debug_toolbar

    urlpatterns = [

urlpatterns = plugins.register_plugins_urls(urlpatterns)

import logging

import re

from django import http, shortcuts

from django.contrib import messages

from django.contrib.auth import REDIRECT_FIELD_NAME

from django.contrib.auth.decorators import login_required

from django.db.models.fields import FieldDoesNotExist

from django.db.models.query import Q

# FIXME: this decorator has nothing to do with an idp, should be moved in the

# a2 package

# FIXME: this constant should be moved in the a2 package

logger = logging.getLogger(__name__)

    if not next.startswith('http'):

        next = '/%s%s' % (request.get_host(), next)

    logging.info('Redirect to %r' % next)

def server_error(request, template_name='500.html'):

        else:

            default_fields = list(attributes.values_list('name', flat=True))

        fields, labels = utils.get_fields_and_labels(

        if scopes:

            # restrict fields to those in the scopes

            fields = [field for field in fields if field in default_fields]

        hooks.call_hooks('event', name='edit-profile', user=self.request.user, form=form)

        return response

edit_profile = decorators.setting_enabled('A2_PROFILE_CAN_EDIT_PROFILE')(

    login_required(EditProfile.as_view()))

        logging.getLogger(__name__).info('email change request')

        return super(EmailChangeView, self).form_valid(form)

email_change = decorators.setting_enabled('A2_PROFILE_CAN_CHANGE_EMAIL')(

    login_required(EmailChangeView.as_view()))

                user.email_verified = True

                user.save()

                messages.info(request, _('your request for changing your email for {0} '

                logging.getLogger(__name__).info('user %s changed its email '

                                                 'from %s to %s', user,

                                                 old_email, email)

                hooks.call_hooks('event', name='change-email-confirm', user=user, email=email)

            except signing.SignatureExpired:

                messages.error(request, _('your request for changing your email is too '

            except signing.BadSignature:

                messages.error(request, _('your request for changing your email is '

            except ValueError:

                messages.error(request, _('your request for changing your email was not '

            except User.DoesNotExist:

                messages.error(request, _('your request for changing your email is for '

            except ValidationError as e:

                messages.error(request, e.message)

            else:

    # should be allowed. This regex checks if there is a '//' *before* a

    # question mark.

    elif '//' in redirect_to and re.match(r'[^\?]*//', redirect_to):

    nonce = request.GET.get(constants.NONCE_FIELD_NAME)

    frontends = utils.get_backends('AUTH_FRONTENDS')

            form_class = frontend.form()

            submit_name = 'submit-%s' % fid

            block = {

            }

            if request.method == 'POST' and submit_name in request.POST:

                form = form_class(data=request.POST)

            else:

                block['form'] = form_class()

            blocks.append(block)

            parameters = {'request': request,

                          'context': context}

            block = utils.get_backend_method(frontend, 'login', parameters)

        else:

            blocks[-1]['is_hidden'] = False

    # Old frontends API

    for block in blocks:

        fid = block['id']

            continue

        frontend = block['frontend']

        context.update({

        })

        if hasattr(frontend, 'get_context'):

            context.update(frontend.get_context())

        sub_template_name = frontend.template()

        block['content'] = render_to_string(

    request.session.set_test_cookie()

        ctx['authorized_services'] = service_list(self.request)

        return ctx

homepage = Homepage.as_view()

            for field_name in getattr(request.user, 'USER_PROFILE', []):

                if field_name not in field_names:

                    field_names.append(field_name)

            qs = qs.values_list('name', flat=True)

            for field_name in qs:

                if field_name not in field_names:

        parameters = {'request': request,

                      'context': context}

        profiles = [utils.get_backend_method(frontend, 'profile', parameters)

        # Old frontends data structure for templates

        blocks = [block['content'] for block in profiles if block]

        # New frontends data structure for templates

        hooks.call_hooks('modify_context_data', self, context)

        return context

profile = login_required(ProfileView.as_view())

def logout_list(request):

    '''Return logout links from idp backends'''

    return utils.accumulate_from_backends(request, 'logout_list')

def redirect_logout_list(request):

    '''Return redirect logout links from idp backends'''

    return utils.accumulate_from_backends(request, 'redirect_logout_list')

def logout(request, next_url=None, default_next_url='auth_homepage',

    '''Logout first check if a logout request is authorized, i.e.

       that logout was done using a POST with CSRF token or with a GET

       from the same site.

    logger = logging.getLogger(__name__)

    default_next_url = utils.make_url(default_next_url)

    next_url = next_url or request.GET.get(redirect_field_name,

    ctx = {}

    ctx['next_url'] = next_url

    ctx['redir_timeout'] = 60

        content = u'{0}({1})'.format(callback, int(request.user.is_authenticated()))

        return HttpResponse(content, content_type='application/json')

logged_in = never_cache(LoggedInView.as_view())

def csrf_failure_view(request, reason=""):

    messages.warning(request, _('The page is out of date, it was reloaded for you'))

    return HttpResponseRedirect(request.get_full_path())

def test_redirect(request):

    next_url = request.GET.get(REDIRECT_FIELD_NAME, settings.LOGIN_REDIRECT_URL)

    messages.info(request, 'Une info')