Produits Entr'ouvert » Authentic 2

            try:

                if block['user_dn_template']:

                    escaped_username = escape_dn_chars(utf8_username)

                    authz_ids.append(template.format(username=escaped_username))

                else:

    def create_username(self, block, attributes):

        '''Build a username using the configured template'''

        try:

            return username_template.format(realm=block['realm'], **attributes)

        except KeyError as e:

        if member_of_attribute:

            group_dns.update(attributes.get(member_of_attribute, []))

        if group_filter:

            params = attributes.copy()

            params['user_dn'] = dn

            query = FilterFormatter().format(group_filter, **params)

        ou_slug = block['ou_slug']

        OU = get_ou_model()

        if ou_slug:

            try:

                ou = OU.objects.get(slug=ou_slug)

            except OU.DoesNotExist:

        attribute_map = cls.normalize_ldap_results(results[0][1])

        # add mandatory attributes

        for key, mandatory_values in mandatory_attributes_values.iteritems():

            old = attribute_map.setdefault(key, [])

            new = set(old) | set(mandatory_values)

            attribute_map[key] = list(new)

        # apply mappings

        for from_attribute, to_attribute in attribute_mappings:

            if from_attribute not in attribute_map:

                continue

            old = attribute_map.setdefault(to_attribute, [])

            new = set(old) | set(attribute_map[from_attribute])

            attribute_map[to_attribute] = list(new)

        new_attributes = {}

        for key in attributes:

            try:

            except UnicodeDecodeError:

                log.debug('unable to decode attribute %r as UTF-8, converting to base64', key)

                new_attributes[key.lower()] = map(base64.b64encode, attributes[key])

                        raise ImproperlyConfigured(

                            'LDAP_AUTH_SETTINGS: attribute %r must be a string' % d)

                    try:

                    except UnicodeEncodeError:

                        raise ImproperlyConfigured(

                            'LDAP_AUTH_SETTINGS: attribute %r must be a string' % d)

                if isinstance(cls._DEFAULTS[d], bool) and not isinstance(block[d], bool):

                    raise ImproperlyConfigured(

                        'LDAP_AUTH_SETTINGS: attribute %r must be a boolean' % d)

                    raise ImproperlyConfigured(

                        'LDAP_AUTH_SETTINGS: attribute %r must be a list or a tuple' % d)

                if isinstance(cls._DEFAULTS[d], dict) and not isinstance(block[d], dict):

            # we handle strings, list of strings and list of list or tuple whose first element is a

            # string

            if isinstance(block[key], six.string_types):

            elif isinstance(block[key], (list, tuple)):

                new_seq = []

                for elt in block[key]:

                    if isinstance(elt, six.string_types):

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

                        elt = list(elt)

                        elt = tuple(elt)

                    new_seq.append(elt)

                block[key] = tuple(new_seq)

            elif isinstance(block[key], dict):

                newdict = {}

                for subkey in block[key]:

                block[key] = newdict

            else:

                raise NotImplementedError(

        for user_external_id in user.userexternalid_set.all():

            external_id = user_external_id.external_id

            for block in config:

                    continue

                for external_id_tuple in block['external_id_tuples']:

                    conn = self.ldap_backend.get_connection(block)