Produits Entr'ouvert » Larpe

import os

import lasso

from quixote import get_publisher, get_response, get_session, redirect, get_session_manager

from quixote.directory import Directory

from quixote.util import StaticDirectory

import admin

import liberty_root

import saml2

import errors

import logger

import misc

import template

from form import *

from users import User

import httplib

from quixote.form import Form, StringWidget, PasswordWidget, \

     RadiobuttonsWidget, SingleSelectWidget, MultipleSelectWidget, \

     CheckboxWidget, FileWidget

class RootDirectory(Directory):

    _q_exports = ['', 'admin', 'login', 'logout', 'liberty', 'token', 'saml']

    def _q_index (self):

        return 'Nothing to see here yet'

    def login [html] (self):

        logger.info('login')

        idps = misc.cfg.get('idp', {})

        if len(idps) == 0:

            return template.error_page(_('SSO support is not yet configured'))

        if len(idps) == 1 or len([x for x in idps.values() if not x.get('hide', False)]) == 1:

            # if there is only one visible IdP, perform login automatically on

            # this one.

            server = misc.get_lasso_server('liberty')

            for x in server.providerIds:

                key_provider_id = x.replace(str('://'), str('-')).replace(str('/'), str('-'))

                if not idps.get(key_provider_id, {}).get('hide', False):

                    return self.liberty.perform_login(x)

            server = misc.get_lasso_server('saml2')

            for x in server.providerIds:

                key_provider_id = x.replace(str('://'), str('-')).replace(str('/'), str('-'))

                if not idps.get(key_provider_id, {}).get('hide', False):

                    return self.saml.perform_login(x)

        form = Form(enctype='multipart/form-data')

        options = []

        # XXX: use intro cookie to get preferred value

        value = None

        providers = {}

        for kidp, idp in misc.cfg.get('idp', {}).items():

            if idp.get('hide'):

                continue

            p = lasso.Provider(lasso.PROVIDER_ROLE_IDP,

                    misc.get_abs_path(idp['metadata']),

                    misc.get_abs_path(idp['publickey']), None)

            providers[p.providerId] = p

        include_protocol = True

        if len([x for x in providers.values() if 

                x.getProtocolConformance() == lasso.PROTOCOL_SAML_2_0]) in (0, len(providers)):

            include_protocol = False

        for p in providers.values():

            label = misc.get_provider_label(p)

            if include_protocol:

                if p.getProtocolConformance() == lasso.PROTOCOL_SAML_2_0:

                    label = '%s (SAML 2.0)' % label

                else:

                    label = '%s (Liberty ID-FF 1.2)' % label

            options.append((p.providerId, label))

            if not value:

                value = p.providerId

        form.add(RadiobuttonsWidget, 'idp', value = value, options = options, delim = '<br/>')

        form.add_submit('submit', _('Submit'))

        if form.is_submitted() and not form.has_errors():

            idp = form.get_widget('idp').parse()

            p = providers[form.get_widget('idp').parse()]

            if p.getProtocolConformance() == lasso.PROTOCOL_SAML_2_0:

                return self.saml.perform_login(idp)

            else:

                return self.liberty.perform_login(idp)

        template.html_top(_('Login'))

        '<p>%s</p>' % _('Select the identity provider you want to use.')

        form.render()

    def logout(self):

        logger.info('logout')

        session = get_session()

        if not session:

            return redirect('/')

        # add settings to disable single logout?

        #   (and to set it as none/get/soap?)

        return self.liberty.singleLogout()

    def token [html] (self):

        if not get_request().user:

            raise errors.AccessUnauthorizedError()

        form = Form(enctype='multipart/form-data')

        form.add(StringWidget, 'token', title = _('Identification Token'),

                required = True, size = 30)

        form.add_submit('submit', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_widget('cancel').parse():

            return redirect('.')

        if not form.is_submitted() or form.has_errors():

            template.html_top(_('Identification Token'))

            '<p>' # XXX: include explanation (?)

            _('Please enter your identification token.')

            '</p>'

            form.render()

        else:

            session = get_session()

            if get_request().user:

                lasso_dump = get_request().user.lasso_dump

            else:

                return template.error_page('No Lasso Identity Dump (???)')

            token = form.get_widget('token').parse()

            users_with_token = list(User.select(lambda x: x.identification_token == token))

            if len(users_with_token) == 0:

                return template.error_page(_('Unknown Token'))

            user = users_with_token[0]

            user.name_identifiers.append(session.name_identifier)

            user.lasso_dump = str(lasso_dump)

            user.identification_token = None

            user.store()

            old_name = session.user

            session.set_user(user.id)

            return redirect('.')

    def _q_traverse(self, path):

        session = get_session()

        if session:

            get_request().user = session.get_user()

        else:

            get_request().user = None

        response = get_response()

        response.filter = {}

        if not hasattr(response, 'breadcrumb'):

            response.breadcrumb = [ ('', _('Home')) ]

        try:

            return Directory._q_traverse(self, path)

        except errors.TraversalError:

            pass

#        return self._q_index()

        return forms.root.RootDirectory()._q_traverse(path)

    def _q_lookup(self, component):

#        return SiteUI(component)

#        if component == 'themes':

#            dirname = os.path.join(get_publisher().data_dir, 'themes')

#            return StaticDirectory(dirname, follow_symlinks = True)

        # is this a category ?

#        try:

#            category = Category.get_by_urlname(component)

#        except KeyError:

#            pass

#        else:

#            return forms.root.RootDirectory(category)

        # or a form ?

#        return forms.root.RootDirectory()._q_lookup(component)

		return self._q_index()

    admin = admin.RootDirectory()

    saml = saml2.RootDirectory()

    liberty = liberty_root.LibertyRootDirectory()