Produits Entr'ouvert » Authentic 2

                if extra_attribute_config['loop_over_attribute'] not in attribute_map:

                    log.debug(

                        'loop_over_attribute %s not present (or empty) in retrieved user object attributes.'

                    )

                    continue

                if 'filter' not in extra_attribute_config and 'basedn' not in extra_attribute_config:

                    log.warning(

                        'Extra attribute %s not correctly configured : you need to defined at least one of'

                    )

                for item in attribute_map[extra_attribute_config['loop_over_attribute']]:

                    ldap_filter = extra_attribute_config.get('filter', 'objectClass=*').format(

                        results = conn.search_s(ldap_basedn, ldap_scope, ldap_filter, ldap_attributes_names)

                    except ldap.LDAPError:

                        log.exception(

                        )

                        continue

                    else:

                    item_value = {}

                    for dn, attrs in results:

                        log.debug(

                        )

                        for key in ldap_attributes_mapping:

                            item_value[key] = attrs.get(ldap_attributes_mapping[key].lower())

                            log.debug(

                            )

                            if not item_value[key]:

                                del item_value[key]

                                item_value[key] = item_value[key][0]

                    extra_attribute_values.append(item_value)

            else:

            extra_attribute_serialization = extra_attribute_config.get('serialization', None)

            if extra_attribute_serialization is None:

                attribute_map[extra_attribute_name] = extra_attribute_values

                attribute_map[extra_attribute_name] = json.dumps(extra_attribute_values)

            else:

                log.warning(

                )

        return attribute_map

                count += 1

                user = backend._return_user(dn, None, conn, block, attrs)

                if not user:

                    continue

                if user._changed or user._created:

                    log.info(

        if not is_known_idp(idp_selected):

            message = 'The idp is unknown.'

            save_key_values(request, entityID, _return, policy, returnIDParam, isPassive)

            return HttpResponseRedirect(reverse(idp_selection))

    def logout_list(self, request):

        all_sessions = models.LibertySession.objects.filter(django_session_key=request.session.session_key)

        provider_ids = {s.provider_id for s in all_sessions}

        result = []

        for provider_id in provider_ids:

            name = provider_id

    kwargs['entity_id'] = login.remoteProviderId

    kwargs['user'] = request.user

    logger.debug(

    )

    register_new_saml2_session(request, login)

    add_attributes(request, entity_id, assertion, provider, nid_format)

            logger.debug('processAuthnRequestMsg not successful')

            log_info_authn_request_details(login)

            provider_id = login.remoteProviderId

            provider_loaded = load_provider(request, provider_id, server=login.server, autoload=True)

            if not provider_loaded:

                add_url = reverse('admin:saml_libertyprovider_add_from_url')

    # We catch denied decisions i.e. dic['authz'] = False

    access_granted = True

    for decision in decisions:

        dic = decision[1]

        if dic and 'authz' in dic:

            logger.debug('decision is %s', dic['authz'])

            latest = x.latest('creation')

            result.append(latest)

    if lib_session1:

    return lib_session1, result, django_session_keys

            'format': nameIdPolicy.format,

            'spNameQualifier': nameIdPolicy.spNameQualifier,

        }

def check_destination(request, req_or_res):

    if not logger:

        logger = logging

    if warning:

    else:

    if back is None:

        referer = request.META.get('HTTP_REFERER')

        if referer:

            try:

                func(*args, **kwargs)

            except Exception:

            else:

    # pass arguments as pickles

    base_spooler = spool(pass_arguments=True)(spooler_func)

        targets.append(next_url)

        # Put redirection targets in session (after local logout)

        request.session['logout_redirections'] = targets

    # Full logout by redirections if any

    targets = request.session.pop('logout_redirections', None)

    if targets:

                error = None

                error_description = None

            logger.warning(

            )

            if error:

                messages.warning(

            return self.continue_to_next_url(request)

        except requests.RequestException as e:

            messages.warning(

                request,

                _('Provider %(name)s is down, report %(request_id)s to an administrator. ')

            result = response.json()

        except ValueError as e:

            logger.warning(

            )

            messages.warning(

                request,

            or 'id_token' not in result

        ):

            logger.warning(

            )

            messages.warning(

                request,