Produits Entr'ouvert » Authentic 2

from django.conf import settings

from django.contrib.auth.models import Group

from django.utils.encoding import force_bytes, force_text

from authentic2.a2_rbac.models import Role

        '''Obtain a Django role'''

        kwargs = {}

        slug = None

            slug = role_id

        elif isinstance(role_id, (tuple, list)):

            try:

import itertools

from django.db.migrations.operations.base import Operation

class CreatePartialIndexes(Operation):

                for clause in where:

                    if isinstance(clause, tuple):

                        clause, params = clause

                        assert isinstance(params, tuple)

                        clause = clause % tuple(schema_editor.quote_value(param) for param in

                                                 params)

                    clauses.append(clause)

                where_clause = ' AND '.join(clauses)

                # SQLite does not accept parameters in partial index creations, don't ask why :/

import datetime

import time

def filter_attribute_private_key(message):

        return re.sub(r' (\w+:)?(PrivateKey=")([&#;\w/ +-=])+(")', '', message)

    else:

        return message

def filter_element_private_key(message):

        return re.sub(r'(<saml)(p)?(:PrivateKeyFile>-----BEGIN RSA PRIVATE KEY-----)'

            '([&#;\w/+=\s])+'

            '(-----END RSA PRIVATE KEY-----</saml)(p)?(:PrivateKeyFile>)',

from django.utils.http import urlsafe_base64_encode

from django.utils.encoding import iri_to_uri, force_bytes, uri_to_iri

from django.shortcuts import render

try:

def normalize_attribute_values(values):

    '''Take a list of values or a single one and normalize it'''

    values_set = set()

        values = [values]

    for value in values:

        if isinstance(value, bool):

       - <template_name>_body.html for the HTML body

    '''

    from . import middleware

        template_names = [template_names]

    if hasattr(user_or_email, 'email'):

        user_or_email = user_or_email.email

from jwcrypto.jwk import JWK, JWKSet, InvalidJWKValue

from jwcrypto.jwt import JWT

from django.core.exceptions import ImproperlyConfigured

from django.conf import settings

def normalize_claim_values(values):

    values_list = []

        return values

    for value in values:

        if isinstance(value, bool):

except ImportError:

    ldap = None

from ldaptools import paged

from django.core.management.base import BaseCommand

        return dn2str(dn), ('&', [(a,b) for a, b, c in rdn])

    def format_filter(self, filters):

            return filters

        assert len(filters) == 2, 'filters %r' % (filters,)

        if isinstance(filters[1], (list, tuple)):

except ImportError:

    # Django < 1.8

    from django.db.models.fields import FieldDoesNotExist

from . import utils

            return False

        if user_obj.is_superuser:

            return True

            perm_or_perms = [perm_or_perms]

        perm_or_perms = set(perm_or_perms)

        cache = self.get_permission_cache(user_obj)

            return False

        if user_obj.is_superuser:

            return True

            perm_or_perms = [perm_or_perms]

        perm_or_perms = set(perm_or_perms)

        cache = self.get_permission_cache(user_obj)

from django.conf import settings

from django.utils.encoding import iri_to_uri

from django.shortcuts import resolve_url

from authentic2 import utils

        for xpath, content in constraints:

            nodes = doc.xpath(xpath, namespaces=namespaces)

            self.assertTrue(len(nodes) > 0, 'xpath %s not found' % xpath)

                for node in nodes:

                    if hasattr(node, 'text'):

                        self.assertEqual(