Produits Entr'ouvert » w.c.s.

try:

    import lasso

except ImportError:

    lasso = None

    wsf_support = False

        if not lasso or not lasso.WSF_SUPPORT:

            self.wsf_support = False

    wsf_support = True

    wsf_support = False

                ('user', _('User Field')),

                ('wsf', _('WSF Expression'))]

        elif self.value.get('type') == 'wsf':

            self.add(StringWidget, 'value', value = value.get('value'))

            if attribute in ('in_listing', 'wsf_prefill_explicit'): continue

    wsf_prefill_explicit = False

        if False and self.wsf_support:

            form.add(CheckboxWidget, 'wsf_prefill_explicit',

                    title = _('Needs ID-WSF prefill explicit request'),

                    value = self.wsf_prefill_explicit)

                'extra_css_class', 'prefill',

                'wsf_prefill_explicit']

import qommon.idwsf as idwsf

    import lasso

except ImportError:

    lasso = None

import qommon.liberty as liberty

import StringIO as sio

try:

    def get_disco_epr(self):

        session=get_session()

        if not session.lasso_session_dump:

            return None

        lasso_session=lasso.Session.newFromDump(session.lasso_session_dump)

        if not lasso_session:

            return None

        assertions = lasso_session.assertions

        if not assertions or not assertions.values():

            return None

        assertion = assertions.values()[0]

        if not isinstance(assertion, lasso.Saml2Assertion):

            return None

        return assertion.idwsf2GetDiscoveryBootstrapEpr()

    def get_eprs(self, service_type):

        disco_epr = self.get_disco_epr()

        if not disco_epr:

            return []

        disco = idwsf.DiscoveryClient2(epr=disco_epr,

                        server=misc.get_lasso_server(protocol='saml2'))

        disco.setLogger(get_logger())

        eprs = disco.lookupService(service_type)

        return eprs

    def do_queries(self, epr, queries, namespaces, flatten=True):

        dst = idwsf.DSTClient2(epr=epr,

                server=misc.get_lasso_server(protocol='saml2'))

        dst.setLogger(get_logger())

        result = dst.query(queries, flatten = flatten, namespaces = namespaces)

        return result

    def get_namespaces(self):

        namespaces = {

            'pp': getattr(lasso, 'PP11_HREF', getattr(lasso, 'PP_HREF', None)), # support old lasso

            'ep': getattr(lasso, 'EP_HREF', ''),

            'eoa': 'urn:entrouvert:id-sis-adeline:2005-09', # eo schema for adeline

            'cafp': 'urn:entrouvert:id-sis-caf-profile:2005-09', # eo schema for caf

        }

        namespaces.update(get_cfg('misc', {}).get('namespaces', {}))

        return namespaces

    def get_queries(self, fields):

        queries = {}

        for field in fields:

            query = field.prefill.get('value')

            if query:

                queries['f%s' % field.id] = query

        return queries

    def prefill_form(self, form, results):

        for key, value in results.items():

            widget = form.get_widget(key)

            if widget and value:

                encoded = get_publisher().utf82sitecharset(value)

                widget.set_value(encoded)

    def wsf_prefill(self, form):

        service_types = self.get_namespaces()

        session = get_session()

        if not session.lasso_session_dump:

            return False

        if str('DiscoveryResourceOffering') in session.lasso_session_dump:

            idwsf = 1

        if str('urn:liberty:disco:2006-08:DiscoveryEPR') in session.lasso_session_dump:

            idwsf = 2

        request = get_request()

        prefill_fields = []

        if request.form.has_key('prefill') and type(request.form['prefill']) is list:

            prefill_fields = request.form['prefill']

        prefixes = {}

        for f in self.formdef.fields:

            if not f.prefill:

                continue

            if f.prefill.get('type') != 'wsf':

                continue

            if prefill_fields and not f.id in prefill_fields:

                continue

            if f.wsf_prefill_explicit and not f.id in prefill_fields:

                continue

            wsf_prefill_expression = f.prefill.get('value')

            m = re.search('/*(\w+):', wsf_prefill_expression)

            prefix = m.group(1)

            if not service_types.has_key(prefix):

                get_logger().warn('Unknown prefix: %r' % prefix)

                continue

            if not prefixes.has_key(prefix):

                prefixes[prefix] = []

            prefixes[prefix].append(f)

        has_prefilled = False

        if idwsf == 1:

            for prefix, fields in prefixes.items():

                if service_types[prefix] not in ('pp', 'ep'):

                    # needs lasso registration

                    lasso.registerDstService(prefix, service_types[prefix])

                disco = lasso.Discovery(misc.get_lasso_server())

                disco.setSessionFromDump(get_session().lasso_session_dump)

                disco.initQuery()

                disco.addRequestedServiceType(service_types[prefix])

                disco.buildRequestMsg()

                try:

                    soap_answer = liberty.soap_call(disco.msgUrl, disco.msgBody)

                except liberty.SOAPException:

                    continue

                disco.processQueryResponseMsg(soap_answer)

                service = disco.getService()

                if not service:

                    continue

                service.initQuery()

                for f in fields:

                    service.addQueryItem(f.prefill.get('value'), f.id)

                service.buildRequestMsg()

                try:

                    soap_answer = liberty.soap_call(service.msgUrl, service.msgBody)

                except liberty.SOAPException:

                    continue

                service.processQueryResponseMsg(soap_answer)

                for f in fields:

                    answer = service.getAnswerForItemId(f.id)

                    if not answer:

                        continue

                    answer = re.sub('<.*?>', '', answer)

                    form._names['f%s' % f.id].set_value(get_publisher().utf82sitecharset(answer))

                    has_prefilled = True

        if idwsf == 2:

            for prefix, fields in prefixes.items():

                try:

                    lasso.registerIdwsf2DstService(prefix, service_types[prefix])

                    eprs = self.get_eprs(service_types[prefix])

                    queries = self.get_queries(fields)

                    if eprs:

                        # FIXME: if more than one epr

                        results = self.do_queries(eprs[0], queries, service_types)

                        self.prefill_form(form, results)

                    has_prefilled = True

                except Exception, exception:

                    raise

                    get_logger().error("Got an exception when trying to prefill %s: %s " % (str(form), str(exception)))

        return has_prefilled

        if True or [x for x in displayed_fields if x.prefill and

                x.prefill.get('type') == 'wsf'] and (

                    session.lasso_session_dump and

                    ( str('DiscoveryResourceOffering') in session.lasso_session_dump or

                      str('urn:liberty:disco:2006-08:DiscoveryEPR') in session.lasso_session_dump)):

            form.add_submit('prefill', _('Prefill'))

            if form.get_submit() == 'prefill':

                form.clear_errors()

                if not self.wsf_prefill(form):

                    form.info = N_('No data found for prefilling')

                request = get_request()

                if request.form.has_key('prefill') and not type(request.form['prefill']) is list:

                    form.submit_widgets.remove(form._names['prefill'])

                    del form._names['prefill']

            if form._names.has_key('prefill') and not [x for x in displayed_fields if \

                    x.prefill and x.prefill.get('type') == 'wsf']:

                form.submit_widgets.remove(form._names['prefill'])

                del form._names['prefill']

        if not self.value and self.field and self.field.wsf_prefill_explicit and \

                get_session().lasso_session_dump:

            s += htmltext(

                    '<input class="prefill-button" type="submit" name="f%s-prefill" value="%s">') % (

                        self.field.id, _('Prefill'))

        if self.field and hasattr(self.field, 'prefill') and \

                self.field.prefill and self.field.prefill.get('type') == 'wsf':

            self.prefill = (request.get_field('f%s-prefill' % self.field.id) is not None)

            if self.prefill:

                if not request.form.has_key('prefill'):

                    request.form['prefill'] = []

                request.form['prefill'].append(self.field.id)

                self.error = 'MUST PREFILL...' # won't be displayed

        elif self.field and self.field.validation and self.value is not None:

    wsf_support = False

-