Produits Entr'ouvert » Authentic 2

import logging

import random

import base64

import os

# code originaly copied from by now merely inspired by

from django.contrib.auth.models import Group

from django.utils.encoding import force_bytes, force_text

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

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.core.urlresolvers import reverse, NoReverseMatch

from django.utils.formats import localize

from django.contrib import messages

from django.utils.functional import empty, allow_lazy

from django.utils.http import urlsafe_base64_encode

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

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

import base64

import uuid

from jwcrypto.jwk import JWK, JWKSet, InvalidJWKValue

from jwcrypto.jwt import JWT

from django.core.exceptions import ImproperlyConfigured

from django.conf import settings

from django.utils.encoding import force_bytes, force_text

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

def clean_words(data):

    '''Clean and order a list of words'''

def url_domain(url):

def normalize_claim_values(values):

    values_list = []

        return values

    for value in values:

        if isinstance(value, bool):

from ldaptools import paged

from django.core.management.base import BaseCommand

from authentic2.attributes_ng.engine import get_attributes

from authentic2 import compat, utils

        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)):

from django.conf import settings

from django.contrib.contenttypes.models import ContentType

from django.db.models.query import Q

try:

    from django.core.exceptions import FieldDoesNotExist

            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 django.utils.six.moves.urllib import parse as urlparse

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(