Produits Entr'ouvert » django-mellon

import logging

import uuid

from xml.etree import ElementTree as ET

                    response.raise_for_status()

                except requests.exceptions.RequestException as e:

                    self.logger.error(

                        idp['METADATA_URL'], e, i)

                    continue

                idp['METADATA'] = response.text

                if idp['METADATA'].startswith('/'):

                    idp['METADATA'] = open(idp['METADATA']).read()

            else:

                continue

            if 'ENTITY_ID' not in idp:

                try:

                    doc = ET.fromstring(idp['METADATA'])

                except (TypeError, ET.ParseError):

                    continue

                if doc.tag != '{%s}EntityDescriptor' % lasso.SAML2_METADATA_HREF:

                    continue

                if not 'entityID' in doc.attrib:

                    self.logger.error(

                    continue

                idp['ENTITY_ID'] = doc.attrib['entityID']

            yield idp

            username = force_text(username_template).format(

                realm=realm, attributes=saml_attributes, idp=idp)[:30]

        except ValueError:

        except (AttributeError, KeyError, IndexError) as e:

            self.logger.error(

        except Exception as e:

        else:

            return username

                    self.logger.debug('looking for users by attribute %r and user field %r with value %r: not found',

                                      saml_attribute, user_field, value)

                    continue

                                 saml_attribute, user_field, value, display_truncated_list(users_found))

                users.update(users_found)

        if len(users) == 1:

            user = list(users)[0]

                             lookup_by_attributes, user)

            return user

        elif len(users) > 1:

                                lookup_by_attributes, len(users))

        return None

            try:

                value = force_text(tpl).format(realm=realm, attributes=saml_attributes, idp=idp)

            except ValueError:

            except (AttributeError, KeyError, IndexError, ValueError) as e:

                self.logger.warning(

            else:

                model_field = user._meta.get_field(field)

                if hasattr(model_field, 'max_length'):

                    old_value = getattr(user, field)

                    setattr(user, field, value)

                    attribute_set = True

                                     user, value, old_value)

        if attribute_set:

            user.save()

                groups.append(group)

            for group in Group.objects.filter(pk__in=[g.pk for g in groups]).exclude(user=user):

                self.logger.info(

                User.groups.through.objects.get_or_create(group=group, user=user)

            qs = User.groups.through.objects.exclude(

                group__pk__in=[g.pk for g in groups]).filter(user=user)

            for rel in qs:

                                 rel.group.pk, rel.user, rel.user.pk)

            qs.delete()

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.contrib.auth.backends import ModelBackend

from . import utils

from django.utils.http import urlencode

from django.http import HttpResponseRedirect

from django.core.urlresolvers import reverse

from django.db import models

from django.utils.translation import ugettext_lazy as _

from django.conf import settings

from django.conf.urls import url

import django

import logging

import datetime

import importlib

            try:

                server.addProviderFromBuffer(lasso.PROVIDER_ROLE_IDP, idp['METADATA'])

            except lasso.Error as e:

                continue

        cache[root] = server

        settings._MELLON_SERVER_CACHE = cache

import logging

import requests

import lasso

    def show_message_status_is_not_success(self, profile, prefix):

        status_codes, idp_message = utils.get_status_codes_and_message(profile)

        if idp_message:

            args.append(idp_message)

        self.log.warning(*args)

        try:

            login.initRequest(message, method)

        except lasso.ProfileInvalidArtifactError:

        except lasso.ServerProviderNotFoundError:

            self.log.warning('no entity id found for artifact %s', artifact)

            return HttpResponseBadRequest(

                # lasso>2.5.1 introduced a better API

                if hasattr(authn_request.extensions, 'any'):

                    authn_request.extensions.any = (

                else:

                    authn_request.extensions.setOriginalXmlnode(

                                 xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"

                                 xmlns:eo="https://www.entrouvert.com/">

                               <eo:next_url>%s</eo:next_url>

                    )

            self.set_next_url(next_url)

            self.add_login_hints(idp, authn_request, request=request, next_url=next_url)

            self.log.warning('error validating logout request: %r' % e)

        issuer = request.session.get('mellon_session', {}).get('issuer')

        if issuer == logout.remoteProviderId:

            auth.logout(request)

        try:

            logout.buildResponseMsg()

                    # set next_url after local logout, as the session is wiped by auth.logout

                    if logout:

                        self.set_next_url(next_url)

        else:

            self.log.warning('logout refused referer %r is not of the same origin', referer)

        return HttpResponseRedirect(next_url)