Produits Entr'ouvert » Authentic 2

        is_verified = validated_data.pop('is_verified', {})

        self.check_perm('custom_user.add_user', validated_data.get('ou'))

        instance = super(BaseUserSerializer, self).create(validated_data)

            if is_verified.get(key):

                setattr(instance.verified_attributes, key, value)

            else:

        if 'ou' in validated_data:

            self.check_perm('custom_user.change_user', validated_data.get('ou'))

        super(BaseUserSerializer, self).update(instance, validated_data)

            if is_verified.get(key):

                setattr(instance.verified_attributes, key, value)

            else:

        pass

    def read_env(self, env):

            if isinstance(keys, six.string_types):

                keys = [keys]

            for key in keys:

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

        return d.__class__(map_text(x) for x in d)

    elif isinstance(d, dict):

    raise NotImplementedError

            return None

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

        # add mandatory attributes

            key = force_text(key)

            old = attribute_map.setdefault(key, [])

            new = set(old) | set(mandatory_values)

        if not block['url']:

            raise ImproperlyConfigured("block['url'] must contain at least one url")

        for url in map_text(block['url']):

                ldap.set_option(key, value)

            conn = LDAPObject(url)

            if block['timeout'] > 0:

                continue

            parts.append(unicode(arg))

            if kw not in self.kwargs:

                continue

            parts.append(u'%s-%s' % (unicode(kw), unicode(arg)))

    def get_format(self):

        format = get_format(self.format_name)[0]

            format = format.replace(py, js)

        return format

    if not login_url:

        login_url = settings.LOGIN_URL

    data = { redirect_field_name: next }

        data[k] = v

    return HttpResponseRedirect('%s?%s' % (login_url, urlencode(data)))

                    print 'info: invalid filter'

                    print

                    return

                    if ldap_attribute == m.group(1):

                        break

                else:

                qs = qs.filter(**{user_attribute: value.decode('utf-8')})

            for user in qs:

                o = {}

                    o[ldap_attribute] = [unicode(getattr(user, user_attribute)).encode('utf-8')]

                o['objectClass'] = ['inetOrgPerson']

                dn = 'uid=%s,%s' % (escape_dn_chars(o['uid'][0]), attrs['suffix'])

    def __init__(self, *args, **kwargs):

        super(LimitQuerysetFormMixin, self).__init__(*args, **kwargs)

        if self.request and not self.request.user.is_anonymous():

                qs = getattr(field, 'queryset', None)

                if not qs:

                    continue

def get_def_name_from_oid(oid):

        if value['oid'] == oid:

            return key

def get_definition_from_oid(oid):

        if value['oid'] == oid:

            return value

def get_full_definition(name):

        if key == name:

            return value

def get_definition_from_alias(alias):

        if 'alias' in value and alias in value['alias']:

            return value

def get_def_name_from_alias(alias):

        if 'alias' in value and alias in value['alias']:

            return key

}

NAME_ID_FORMATS_CHOICES = \

ACCEPTED_NAME_ID_FORMAT_LENGTH = \

        len(NAME_ID_FORMATS) - 1

def saml2_urn_to_nidformat(urn, accepted=()):

        if accepted and not x in accepted:

            continue

        if y['samlv2'] == urn:

if __name__ == '__main__':

    import sys

        print '-', key, ':'

        for value in values:

            print ' *', value

                <form method="post" action="{{ federation.url }}">

                  {% csrf_token %}

                  <span class="name">{{ federation.name }}</span>

                    <input type="hidden" name="{{ key }}" value="{{ value }}"/>

                  {% endfor %}

                  {% for button_name, button_label in federation.buttons %}

{% block content %}

  <div id="a2-login-forms">

      {% if not login_block.is_hidden %}

        <span id="css-tab{{ forloop.counter }}"></span>

      {% endif %}

    {% endfor %}

    {% if blocks|length != 1 %}

        {% if not login_block.is_hidden %}

          <a class="css-tab-link css-tab{{ forloop.counter }} {% if forloop.first %}css-tab-default{% endif %}" href="#css-tab{{ forloop.counter }}">

              {{ login_block.name }}

      {% endfor %}

    {% endif %}

      <div class="css-tab-content css-tab{{ forloop.counter }} {% if forloop.first %}css-tab-default{% endif %}">

        {{ login_block.content|safe }}

      </div>

    url_params = QueryDict(query_string=query_string, mutable=True)

    if keep_params:

        assert request is not None, 'missing request'

            if exclude and key in exclude:

                continue

            if include and key not in include:

                continue

            url_params.setlist(key, request.GET.getlist(key))

    if params:

            if value is None:

                url_params.pop(key, None)

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

            else:

                url_params[key] = value

    if append:

            if value is None:

                continue

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

def lower_keys(d):

    '''Convert all keys in dictionary d to lowercase'''

def to_dict_of_set(d):

    '''Convert a dictionary of sequence into a dictionary of sets'''

def switch_user(request, new_user):

def utf8_encode(v):

    if isinstance(v, dict):

    if isinstance(v, (list, tuple)):

        return type(v)(utf8_encode(a) for a in v)

    if isinstance(v, unicode):

                values[slug].update(normalized)

        if values:

            attributes_elt = ET.SubElement(success, ATTRIBUTES_ELT)

            for value in values:

                attribute_elt = ET.SubElement(attributes_elt, '{%s}%s' % (CAS_NAMESPACE, key))

                attribute_elt.text = unicode(value)

        fragments = []

        oidc_sessions = get_oidc_sessions(request)

            if 'frontchannel_logout_uri' not in value:

                continue

            ctx = {

                render_to_string(

                    'authentic2_idp_oidc/logout_fragment.html',

                    ctx))

                ctx['user'] = user

                ctx = get_attributes(ctx)

                ldap_attributes = {}

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

                        a2_attributes = [a2_attributes]

                    for a2_attribute in a2_attributes:

                        self.add_values(ldap_attributes, ldap_attribute, ctx.get(a2_attribute))

                    self.add_values(ldap_attributes, ldap_attribute, values)

                    for fmt_tpl in fmt_tpls:

                        self.add_values(ldap_attributes, ldap_attribute,

                                [fmt_tpl.format(**ctx)])

                    del ldap_users[dn]

                    continue

                existing_dn.add(dn)

                if dn in existing_dn:

                    modlist = []

                    for key, values in ldap_attributes:

        cache = self.get_permission_cache(user_obj)

        if perm_or_perms & cache.get('__all__', set()):

            return True

            if isinstance(value, bool):

                continue

            elif key == '__all__':

        if perm_or_perms & cache.get('__all__', set()):

            return True

        q = []

            if isinstance(value, bool):

                continue

            elif key == '__all__':

                  'national_number': 'xx20153566342yy'}

        if form.prefix:

            kwargs = dict(('%s-%s' % (form.prefix, k), v)

        response = self.client.post(reverse('profile_edit'), kwargs)

    response.form.set('ou', get_default_ou().pk)

    response.form.set('unauthorized_url', 'https://example.com/southpark/')

    response.form.set('redirect_uris', 'https://example.com/callbac%C3%A9')

        response.form.set(key, value)

    response = response.form.submit().follow()

    assert OIDCClient.objects.count() == 1

    location = urlparse.urlparse(response['Location'])

    query = location.fragment if fragment else location.query

    query = urlparse.parse_qs(query)

        if value is None:

            assert key in query

        elif isinstance(value, list):