#! /usr/bin/env python
# -*- coding: utf-8 -*-
#
# $Id$
#
# PyLasso - Python bindings for Lasso Library
#
# Copyright (C) 2003-2004 Easter-eggs, Valery Febvre
# http://lasso.entrouvert.org
#
# Author: Valery Febvre <vfebvre@easter-eggs.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

__docformat__ = "plaintext en"

import lassomod
from lasso_strings import *

_inited = False

class Error(Exception):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return repr(self.msg)
    
def init():
    """
    Init Lasso Library.
    """
    global _inited
    if _inited:
        raise Error('Lasso already inited')
    _inited = True
    return lassomod.init()

def shutdown():
    """
    Shutdown Lasso Library.
    """
    global _inited
    if not _inited:
        raise Error('Lasso not inited or already shotdown')
    _inited = False
    return lassomod.shutdown()


################################################################################
# xml : low level classes
################################################################################
# Export types
NodeExportTypeXml    = 1
NodeExportTypeBase64 = 2
NodeExportTypeQuery  = 3
NodeExportTypeSoap   = 4

class Node:
    """\brief The base class of the Lasso hierarchy.

    Node is the base class for all Lasso classes.
    """

    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        
    def destroy(self):
        """
        Destroys the node.
        """
        lassomod.node_destroy(self)

    def dump(self, encoding="utf8", format=0):
        """
        Dumps the node. All datas in object are dumped in an XML format.

        \param encoding the name of the encoding to use or None.
        \param format is formatting allowed?
        \return an XML dump of the node
        """
        return lassomod.node_dump(self, encoding, format)

    def export(self):
        """
        Exports the node.

        \return an XML dump of the node (UTF-8 encoded)
        """
        return lassomod.node_export(self)

    def export_to_base64(self):
        """
        Like export() method except that result is Base64 encoded.

        \return a Base64 encoded export of the node
        """
        return lassomod.node_export_to_base64(self)

    def export_to_query(self, sign_method=0, private_key_file=None):
        """
        URL-encodes and signes the node.
        If private_key_file is None, query won't be signed.

        \param sign_method the Signature transform method
        \param private_key_file a private key
        \return a query
        """
        return lassomod.node_export_to_query(self, sign_method, private_key_file)

    def export_to_soap(self):
        """
        Like export() method except that result is SOAP enveloped.

        \return a SOAP enveloped export of the node
        """
        return lassomod.node_export_to_soap(self)

    def get_attr_value(self, name):
        """
        Gets the value of an attribute associated to node.
        
        \param name an attribut name
        \return the attribut value or None if not found.
        """
        return lassomod.node_get_attr_value(self, name)

    def get_child(self, name, href=None):
        """
        Gets child of node having given \a name and namespace \a href.

        \param name the child name
        \param href the namespace
        \return a child node
        """
        obj = lassomod.node_get_child(self, name, href)
        if obj:
            return Node(_obj=obj)
        return None

    def get_content(self):
        """
        Read the value of node, this can be either the text carried directly by
        this node if it's a TEXT node or the aggregate string of the values carried
        by this node child's (TEXT and ENTITY_REF). Entity references are
        substituted.

        \return a string or None if no content is available.
        """
        return lassomod.node_get_content(self)

    def verify_signature(self, certificate_file):
        """
        Verifys the node signature.

        \param certificate_file a certificate
        \return 1 if signature is valid, 0 if invalid. -1 if an error occurs.
        """
        return lassomod.node_verify_signature(self, certificate_file)


class SamlAssertion(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.saml_assertion_new()
        if _obj is None: raise Error('lasso_saml_assertion_new() failed')
        Node.__init__(self, _obj=_obj)

    def add_authenticationStatement(self, authenticationStatement):
        """
        bla bla
        """
        lassomod.saml_assertion_add_authenticationStatement(self,
                                                            authenticationStatement)

    def set_signature(self, sign_method, private_key_file, certificate_file):
        lassomod.saml_assertion_set_signature(self, sign_method,
                                              private_key_file, certificate_file)


class SamlAuthenticationStatement(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.saml_authentication_statement_new()
        if _obj is None: raise Error('lasso_saml_authentication_statement_new() failed')
        Node.__init__(self, _obj=_obj)


class SamlNameIdentifier(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.saml_name_identifier_new()
        if _obj is None: raise Error('lasso_saml_name_identifier_new() failed')
        Node.__init__(self, _obj=_obj)

    def set_format(self, format):
        lassomod.saml_name_identifier_set_format(self, format)
    
    def set_nameQualifier(self, nameQualifier):
        lassomod.saml_name_identifier_set_nameQualifier(self, nameQualifier)


class SamlpResponse(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.samlp_response_new()
        if _obj is None: raise Error('lasso_samlp_response_new() failed')
        Node.__init__(self, _obj=_obj)

    def add_assertion(self, assertion):
        lassomod.samlp_response_add_assertion(self, assertion)


class LibAuthenticationStatement(SamlAuthenticationStatement):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.lib_authentication_statement_new()
        if _obj is None: raise Error('lasso_saml_authentication_statement_new() failed')
        SamlAuthenticationStatement.__init__(self, _obj=_obj)
    def set_sessionIndex(self, sessionIndex):
        lassomod.lib_authentication_statement_set_sessionIndex(self, sessionIndex)


class LibAuthnRequest(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.lib_authn_request_new()
        if _obj is None: raise Error('lasso_lib_authn_request_new() failed')
        Node.__init__(self, _obj=_obj)
        
    def set_consent(self, consent):
        lassomod.lib_authn_request_set_consent(self, consent)

    def set_forceAuthn(self, forceAuthn):
        lassomod.lib_authn_request_set_forceAuthn(self, forceAuthn)

    def set_isPassive(self, isPassive):
        lassomod.lib_authn_request_set_isPassive(self, isPassive)

    def set_nameIDPolicy(self, nameIDPolicy):
        lassomod.lib_authn_request_set_nameIDPolicy(self, nameIDPolicy)

    def set_protocolProfile(self, protocolProfile):
        lassomod.lib_authn_request_set_protocolProfile(self, protocolProfile)

    def set_relayState(self, relayState):
        lassomod.lib_authn_request_set_relayState(self, relayState)


class LibFederationTerminationNotification(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.lib_federation_termination_notification_new()
        if _obj is None:
            raise Error('lasso_lib_federation_termination_notification_new() failed')
        Node.__init__(self, _obj=_obj)

    def set_consent(self, consent):
        lassomod.lib_federation_termination_notification_set_consent(self, consent)


class LibLogoutRequest(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.lib_logout_request_new()
        if _obj is None: raise Error('lasso_lib_logout_request_new() failed')
        Node.__init__(self, _obj=_obj)

    def set_consent(self, consent):
        lassomod.lib_logout_request_set_consent(self, consent)

    def set_nameIdentifier(self, nameIdentifier):
        lassomod.lib_logout_request_set_nameIdentifier(self, nameIdentifier)

    def set_providerID(self, providerID):
        lassomod.lib_logout_request_set_providerID(self, providerID)

    def set_relayState(self, relayState):
        lassomod.lib_logout_request_set_relayState(self, relayState)

    def set_sessionIndex(self, sessionIndex):
        lassomod.lib_logout_request_set_sessionIndex(self, sessionIndex)


class LibLogoutResponse(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj = None):
        if _obj!=None:
            self._o = _obj
            return

        _obj = lassomod.lib_logout_response_new()
        if _obj is None: raise Error('lasso_lib_logout_response_new() failed')
        Node.__init__(self, _obj = _obj)
        

class LibNameIdentifierMappingRequest(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.lib_name_identifier_mapping_request_new()
        if _obj is None:
            raise Error('lasso_lib_name_identifier_mapping_request_new() failed')
        Node.__init__(self, _obj=_obj)

    def set_consent(self, consent):
        lassomod.lib_name_identifier_mapping_request_set_consent(self, consent)


class LibNameIdentifierMappingResponse(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj = None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.lib_name_identifier_mapping_response_new()
        if _obj is None:
            raise Error('lasso_lib_name_identifier_mapping_response_new() failed')
        Node.__init__(self, _obj=_obj)


class LibRegisterNameIdentifierRequest(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.lib_register_name_identifier_request_new()
        if _obj is None:
            raise Error('lasso_lib_register_name_identifier_request_new() failed')
        Node.__init__(self, _obj=_obj)


class LibRegisterNameIdentifierResponse(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj = None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.lib_register_name_identifier_response_new()
        if _obj is None:
            raise Error('lasso_lib_register_name_identifier_response_new() failed')
        Node.__init__(self, _obj=_obj)

################################################################################
# protocols : middle level classes
################################################################################

def authn_request_get_protocolProfile(query):
    return lassomod.authn_request_get_protocolProfile(query)
class AuthnRequest(LibAuthnRequest):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, providerID, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.authn_request_new(providerID)
        if _obj is None: raise Error('lasso_authn_request_new() failed')
        LibAuthnRequest.__init__(self, _obj=_obj)
    
    def set_requestAuthnContext(self, authnContextClassRefs=None,
                                authnContextStatementRefs=None,
                                authnContextComparison=None):
        lassomod.authn_request_set_requestAuthnContext(self,
                                                       authnContextClassRefs,
                                                       authnContextStatementRefs,
                                                       authnContextComparison)

    def set_scoping(self, proxyCount):
        lassomod.authn_request_set_scoping(self, proxyCount)


class AuthnResponse(SamlpResponse):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj
        SamlpResponse.__init__(self, _obj=_obj)

    def new_from_export(cls, buffer, type=0):
        obj = lassomod.authn_response_new_from_export(buffer, type)
        return AuthnResponse(obj)
    new_from_export = classmethod(new_from_export)


class FederationTerminationNotification(LibFederationTerminationNotification):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, obj):
        """
        The constructor
        """
        self._o = obj
        LibFederationTerminationNotification.__init__(self, _obj=self._o)

    def new(cls, providerID, nameIdentifier, nameQualifier, format):
        obj = lassomod.federation_termination_notification_new(providerID, nameIdentifier, nameQualifier, format)
        return FederationTerminationNotification(obj)
    new = classmethod(new)

    def new_from_export(cls, buffer, export_type = 0):
        obj = lassomod.federation_termination_notification(buffer, export_type)
        return LogoutRequest(obj)
    new_from_export = classmethod(new_from_export)

class LogoutRequest(LibLogoutRequest):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj
        LibLogoutRequest.__init__(self, _obj = self._o)
        
    def new(cls, providerID, nameIdentifier, nameQualifier, format):
        obj = lassomod.logout_request_new(providerID, nameIdentifier, nameQualifier, format)
        return LogoutRequest(obj)
    new = classmethod(new)

    def new_from_export(cls, buffer, export_type = 0):
        obj = lassomod.logout_request_new_from_export(buffer, export_type)
        return LogoutRequest(obj)
    new_from_export = classmethod(new_from_export)


class LogoutResponse(LibLogoutResponse):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj
        LibLogoutResponse.__init__(self, _obj = self._o)

    def new_from_export(cls, buffer, export_type = 0):
        obj = lassomod.logout_response_new_from_export(buffer, export_type)
        return LogoutResponse(obj)
    new_from_export = classmethod(new_from_export)

    def new_from_request_export(cls, buffer, export_type, providerID, statusCodeValue):
        obj = lassomod.logout_response_new_from_request_export(buffer, export_type, providerID, statusCodeValue)
        return LogoutResponse(obj)
    new_from_export = classmethod(new_from_request_export)


class NameIdentifierMappingRequest(LibNameIdentifierMappingRequest):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj
        LibNameIdentifierMappingRequest.__init__(self, _obj = self._o)

    def new(cls, providerID, nameIdentifier, nameQualifier, format):
        obj = lassomod.name_identifier_mapping_request_new(providerID, nameIdentifier, nameQualifier, format)
        return NameIdentifierMappingRequest(obj)
    new = classmethod(new)

    def new_from_soap(cls, envelope):
        obj = lassomod.name_identifier_mapping_request_new_from_soap(envelope)
        return NameIdentifierMappingRequest(obj)
    new_from_soap = classmethod(new_from_soap)

    def new_from_query(cls, query):
        obj = lassomod.name_identifier_mapping_request_new_from_query(query)
        return NameIdentifierMappingRequest(obj)
    new_from_query = classmethod(new_from_query)


class NameIdentifierMappingResponse(LibNameIdentifierMappingResponse):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj
        LibNameIdentifierMappingResponse.__init__(self, _obj = self._o)

    def new_from_request_soap(cls, envelope, providerID, status_code_value):
        obj = lassomod.name_identifier_mapping_response_new_from_request_soap(envelope, providerID, status_code_value)
        return NameIdentifierMappingResponse(obj)
    new_from_request_soap = classmethod(new_from_request_soap)

    def new_from_soap(cls, envelope):
        obj = lassomod.name_identifier_mapping_response_new_from_soap(envelope)
        return NameIdentifierMappingResponse(obj)
    new_from_soap = classmethod(new_from_soap)

    def new_from_dump(cls, dump):
        obj = lassomod.name_identifier_mapping_response_new_from_dump(dump)
        return NameIdentifierMappingResponse(obj)
    new_from_dump = classmethod(new_from_dump)

    def new_from_request_query(cls, query, providerID, status_code_value):
        obj = lassomod.name_identifier_mapping_response_new_from_request_query(query, providerID, status_code_value)
        return NameIdentifierMappingResponse(obj);
    new_from_request_query = classmethod(new_from_request_query)

    def new_from_query(cls, query):
        obj = lassomod.name_identifier_mapping_response_new_from_query(query)
        return NameIdentifierMappingResponse(obj);
    new_from_query = classmethod(new_from_query)


class RegisterNameIdentifierRequest(LibRegisterNameIdentifierRequest):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj
        LibRegisterNameIdentifierRequest.__init__(self, _obj = self._o)

    def new(cls, providerID,
            idpNameIdentifier, idpNameQualifier, idpFormat,
            spNameIdentifier, spNameQualifier, spFormat,
            oldNameIdentifier, oldNameQualifier, oldFormat):
        obj = lassomod.register_name_identifier_request_new(providerID,
                                                            idpNameIdentifier, idpNameQualifier, idpFormat,
                                                            spNameIdentifier, spNameQualifier, spFormat,
                                                            oldNameIdentifier, oldNameQualifier, oldFormat)
        return RegisterNameIdentifierRequest(obj)
    new = classmethod(new)

    def new_from_export(cls, buffer, export_type = 0):
        obj = lassomod.register_name_identifier_request_new_from_export(buffer, export_type)
        return RegisterNameIdentifierRequest(obj)
    new_from_export = classmethod(new_from_export)

    def rename_attributes_for_encoded_query(self):
        lassomod.register_name_identifier_request_rename_attributes_for_query(self)


class RegisterNameIdentifierResponse(LibRegisterNameIdentifierResponse):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj
        LibRegisterNameIdentifierResponse.__init__(self, _obj = self._o)

    def new_from_export(cls, buffer, export_type = 0):
        obj = lassomod.register_name_identifier_response_new_from_export(buffer, export_type)
        return RegisterNameIdentifierResponse(obj)
    new_from_export = classmethod(new_from_export)

    def new_from_request_export(cls, buffer, export_type, providerID, statusCodeValue):
        obj = lassomod.register_name_identifier_response_new_from_request_export(buffer, export_type, providerID, statusCodeValue)
        return RegisterNameIdentifierResponse(obj)
    new_from_export = classmethod(new_from_request_export)    


################################################################################
# elements
################################################################################

class Assertion(SamlAssertion):
    """\brief Blabla

    Bla bla
    """
    def __init__(self, issuer, requestID, _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.assertion_new(issuer, requestID)
        if _obj is None: raise Error('lasso_assertion_new() failed')
        SamlAssertion.__init__(self, _obj=_obj)


class AuthenticationStatement(Node):
    """\brief Blabla

    Bla bla
    """
    def __init__(self,
                 authenticationMethod,
                 reauthenticateOnOrAfter,
                 nameIdentifier,
                 nameQualifier,
                 format,
                 idp_nameIdentifier,
                 idp_nameQualifier,
                 idp_format,
                 _obj=None):
        """
        The constructor
        """
        if _obj != None:
            self._o = _obj
            return
        _obj = lassomod.authentication_statement_new(authenticationMethod,
                                                     reauthenticateOnOrAfter,
                                                     nameIdentifier,
                                                     nameQualifier,
                                                     format,
                                                     idp_nameIdentifier,
                                                     idp_nameQualifier,
                                                     idp_format)
        if _obj is None:
            raise Error('lasso_authentication_statement_new() failed')
        Node.__init__(self, _obj=_obj)

################################################################################
# environs : high level classes
################################################################################
signatureMethodRsaSha1 = 1
signatureMethodDsaSha1 = 2

httpMethodGet      = 1
httpMethodPost     = 2
httpMethodRedirect = 3
httpMethodSoap     = 4

messageTypeNone          = 0
messageTypeAuthnRequest  = 1
messageTypeAuthnResponse = 2
messageTypeRequest       = 3
messageTypeResponse      = 4
messageTypeArtifact      = 5

class Server:
    """\brief Short desc

    Long desc
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj

    def new(cls, metadata, public_key, private_key, certificate, signature_method):
        obj = lassomod.server_new(metadata, public_key, private_key,
                                  certificate, signature_method)
        return Server(obj)
    new = classmethod(new)

    def new_from_dump(cls, dump):
        obj = lassomod.server_new_from_dump(dump)
        return Server(obj)
    new_from_dump = classmethod(new_from_dump)

    def add_provider(self, metadata, public_key=None, certificate=None):
        lassomod.server_add_provider(self, metadata,
                                     public_key, certificate)

    def dump(self):
        return lassomod.server_dump(self)

    def destroy(self):
        lassomod.server_destroy(self)

class Identity:
    """
    """

    def __init__(self, _obj):
        """
        """
        self._o = _obj

    def new(cls):
        obj = lassmod.identity_new()
        return Identity(obj)
    new = classmethod(new)

    def new_from_dump(cls, dump):
        obj = lassomod.identity_new_from_dump(dump)
        return Identity(obj)
    new_from_dump = classmethod(new_from_dump)

    def dump(self):
        return lassomod.identity_dump(self)

class Session:
    """
    """

    def __init__(self, _obj):
        """
        """
        self._o = _obj

    def __isprivate(self, name):
        return name == '_o'

    def __getattr__(self, name):
        if self.__isprivate(name):
            return self.__dict__[name]
        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
            raise AttributeError, name
        ret = lassomod.session_getattr(self, name)
        if ret is None:
            raise AttributeError, name
        return ret

    def new(cls):
        obj = lassmod.session_new()
        return Session(obj)
    new = classmethod(new)

    def new_from_dump(cls, dump):
        obj = lassomod.session_new_from_dump(dump)
        return Session(obj)
    new_from_dump = classmethod(new_from_dump)

    def add_assertion(self, remote_providerID, assertion):
        lassomod.session_add_assertion(self, remote_providerID, assertion)

    def dump(self):
        return lassomod.session_dump(self)

    def destroy(self):
        lassomod.session_destroy(self)

    def get_assertion(self, remote_providerID):
        return Node(lassomod.session_get_assertion(self, remote_providerID))

    def get_authentication_method(self, remote_providerID = None):
        return lassomod.session_get_authentication_method(self, remote_providerID)

    def get_next_assertion_remote_providerID(self):
        return lassomod.session_get_next_assertion_remote_providerID(self)

    def remove_assertion(self, remote_providerID):
        lassomod.session_remove_assertion(self, remote_providerID)

## Profile
# Request types
requestTypeLogin                  = 1
requestTypeLogout                 = 2
requestTypeFederationTermination  = 3
requestTypeRegisterNameIdentifier = 4
requestTypeNameIdentifierMapping  = 5

def get_request_type_from_soap_msg(soap_buffer):
    return lassomod.profile_get_request_type_from_soap_msg(soap_buffer);

class Profile:
    """\brief Short desc

    Long desc
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj

    def new(cls, server, identity=None, session=None):
        obj = lassomod.profile_new(server, identity, session)
        return Profile(obj)
    new = classmethod(new)

    def get_identity(self):
        obj = lassomod.profile_get_identity(self)
        if obj != None:
            return Identity(_obj=obj)
        else:
            return None

    def get_session(self):
        obj = lassomod.profile_get_session(self)
        if obj != None:
            return Session(_obj=obj)
        else:
            return None
    
    def is_identity_dirty(self):
        return lassomod.profile_is_identity_dirty(self)

    def is_session_dirty(self):
        return lassomod.profile_is_session_dirty(self)

    def set_identity(self, identity):
        return lassomod.profile_set_identity(self, identity)

    def set_identity_from_dump(self, dump):
        return lassomod.profile_set_identity_from_dump(self, dump)

    def set_session(self, session):
        return lassomod.profile_set_session(self, session)

    def set_session_from_dump(self, dump):
        return lassomod.profile_set_session_from_dump(self, dump)

## login
loginProtocolProfileBrwsArt  = 1
loginProtocolProfileBrwsPost = 2

class Login(Profile):
    """\brief Short desc

    Long desc
    """

    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj
        Profile.__init__(self, _obj=_obj)
        
    def __isprivate(self, name):
        return name == '_o'

    def __getattr__(self, name):
        if self.__isprivate(name):
            return self.__dict__[name]
        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
            raise AttributeError, name
        ret = lassomod.login_getattr(self, name)
        if ret is None:
            raise AttributeError, name
        elif name == "request":
            if lassomod.login_getattr(self, "request_type") == messageTypeAuthnRequest:
                ret = AuthnRequest(None, _obj=ret)
            elif lassomod.login_getattr(self, "request_type") == messageTypeRequest:
                ret = Node(_obj=ret)
                # FIXME ret = Request(_obj=ret)
        elif name == "response":
            if lassomod.login_getattr(self, "response_type") == messageTypeAuthnResponse:
                ret = AuthnResponse(None, _obj=ret)
            elif lassomod.login_getattr(self, "response_type") == messageTypeResponse:
                ret = SamlpResponse(_obj=ret)
                # FIXME ret = Response(_obj=ret)
            elif lassomod.login_getattr(self, "response_type") == messageTypeArtifact:
                ret = Node(_obj=ret)
        return ret

    def new(cls, server):
        obj = lassomod.login_new(server)
        return Login(obj)
    new = classmethod(new)

    def new_from_dump(cls, server, identity, dump):
        obj = lassomod.login_new_from_dump(server, identity, dump)
        return Login(obj)
    new_from_dump = classmethod(new_from_dump)

    def accept_sso(self):
        return lassomod.login_accept_sso(self)

    def build_artifact_msg(self, authentication_result, authenticationMethod,
                           reauthenticateOnOrAfter, method):
        return lassomod.login_build_artifact_msg(self, authentication_result,
                                                 authenticationMethod,
                                                 reauthenticateOnOrAfter,
                                                 method)

    def build_authn_request_msg(self):
        return lassomod.login_build_authn_request_msg(self)

    def build_authn_response_msg(self, authentication_result, authenticationMethod,
                                 reauthenticateOnOrAfter):
        return lassomod.login_build_authn_response_msg(self, authentication_result,
                                                       authenticationMethod,
                                                       reauthenticateOnOrAfter)

    def build_request_msg(self):
        return lassomod.login_build_request_msg(self)

    def dump(self):
        return lassomod.login_dump(self)

    def init_authn_request(self, remote_providerID):
        return lassomod.login_init_authn_request(self, remote_providerID)

    def init_from_authn_request_msg(self, authn_request_msg, authn_request_method):
        return lassomod.login_init_from_authn_request_msg(self, authn_request_msg,
                                                          authn_request_method)

    def init_request(self, response_msg, response_method):
        return lassomod.login_init_request(self, response_msg, response_method)

    def must_authenticate(self):
        return lassomod.login_must_authenticate(self)

    def process_authn_response_msg(self, authn_response_msg):
        return lassomod.login_process_authn_response_msg(self, authn_response_msg)

    def process_request_msg(self, request_msg):
        return lassomod.login_process_request_msg(self, request_msg)

    def process_response_msg(self, response_msg):
        return lassomod.login_process_response_msg(self, response_msg)


providerTypeNone = 0
providerTypeSp   = 1
providerTypeIdp  = 2

class Logout(Profile):
    """\brief Short desc

    Long desc
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj
        Profile.__init__(self, _obj=_obj)

    def __isprivate(self, name):
        return name == '_o'

    def __getattr__(self, name):
        if self.__isprivate(name):
            return self.__dict__[name]
        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
            raise AttributeError, name
        ret = lassomod.logout_getattr(self, name)
        if ret is None:
            return None
        elif name == "request":
            ret = LogoutRequest(_obj=ret)
        elif name == "response":
            ret = LogoutResponse(_obj=ret)
        return ret

    def new(cls, server, provider_type):
        obj = lassomod.logout_new(server, provider_type)
        return Logout(obj)
    new = classmethod(new)

    def build_request_msg(self):
        return lassomod.logout_build_request_msg(self)

    def build_response_msg(self):
        return lassomod.logout_build_response_msg(self)

    def destroy(self):
        lassomod.logout_destroy(self);

    def get_next_providerID(self):
        return lassomod.logout_get_next_providerID(self);

    def init_request(self, remote_providerID = None):
        return lassomod.logout_init_request(self, remote_providerID);

    def load_request_msg(self, request_msg, request_method):
        return lassomod.logout_load_request_msg(self, request_msg, request_method);

    def process_request(self):
        return lassomod.logout_process_request(self);

    def process_response_msg(self, response_msg, response_method):
        return lassomod.logout_process_response_msg(self, response_msg, response_method);

class FederationTermination(Profile):
    """\brief Short desc

    Long desc
    """
    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj
        Profile.__init__(self, _obj=_obj)

    def __isprivate(self, name):
        return name == '_o'

    def __getattr__(self, name):
        if self.__isprivate(name):
            return self.__dict__[name]
        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
            raise AttributeError, name
        ret = lassomod.federation_termination_getattr(self, name)
        if ret:
            if name == "identity":
                ret= Identity(_obj=ret)
            elif name == "session":
                ret= Session(_obj=ret)
        return ret

    def new(cls, server, provider_type):
        obj = lassomod.federation_termination_new(server, provider_type)
        return FederationTermination(obj)
    new = classmethod(new)

    def build_notification_msg(self):
        return lassomod.federation_termination_build_notification_msg(self)

    def destroy(self):
        lassomod.federation_termination_destroy(self)

    def init_notification(self, remote_providerID = None):
        return lassomod.federation_termination_init_notification(self, remote_providerID)

    def load_notification_msg(self, notification_msg, notification_method):
        return lassomod.federation_termination_load_notification_msg(self, notification_msg, notification_method)

    def process_notification(self):
        return lassomod.federation_termination_process_notification(self)


class RegisterNameIdentifier:
    """\brief Short desc

    Long desc
    """

    def __isprivate(self, name):
        return name == '_o'

    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj

    def __getattr__(self, name):
        if self.__isprivate(name):
            return self.__dict__[name]
        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
            raise AttributeError, name
        ret = lassomod.register_name_identifier_getattr(self, name)
        return ret

    def new(cls, server, identity, provider_type):
        obj = lassomod.register_name_identifier_new(server, identity, provider_type)
        return RegisterNameIdentifier(obj)
    new = classmethod(new)

    def build_request_msg(self):
        return lassomod.register_name_identifier_build_request_msg(self)

    def build_response_msg(self):
        return lassomod.register_name_identifier_build_response_msg(self)

    def destroy(self):
        pass

    def init_request(self, remote_providerID):
        return lassomod.register_name_identifier_init_request(self, remote_providerID);

    def process_request(self):
        return lassomod.register_name_identifier_process_request(self)

    def process_response_msg(self, response_msg, response_method):
        return lassomod.register_name_identifier_process_response_msg(self, response_msg, response_method);

class Lecp:
    """\brief Short desc

    Long desc
    """

    def __isprivate(self, name):
        return name == '_o'

    def __init__(self, _obj):
        """
        The constructor
        """
        self._o = _obj

    def __getattr__(self, name):
        if self.__isprivate(name):
            return self.__dict__[name]
        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
            raise AttributeError, name
        ret = lassomod.lecp_getattr(self, name)
        if ret is None:
            return None
        return ret

    def new(cls):
        obj = lassomod.lecp_new()
        return Lecp(obj)
    new = classmethod(new)

    def build_authn_request_msg(self):
        return lassomod.lecp_build_authn_request_msg(self)

    def build_authn_request_envelope_msg(self):
        return lassomod.lecp_build_authn_request_envelope_msg(self);

    def build_authn_response_msg(self):
        return lassomod.lecp_build_authn_response_msg(self)

    def build_authn_response_envelope_msg(self):
        return lassomod.lecp_build_authn_response_envelope_msg(self)

    def destroy(self):
        lassomod.lecp_destroy(self)

    def init_authn_request_envelope(self, server, authnRequest):
        return lassomod.lecp_init_authn_request_envelope(self, server, authnRequest)

    def init_authn_response_envelope(self, server, authnRequest, authnResponse):
        return lassomod.lecp_init_authn_response_envelope(self, server, authnRequest, authnResponse)

    def process_authn_request_envelope_msg(self, request_msg):
        return lassomod.lecp_process_authn_request_envelope_msg(self, request_msg)

    def process_authn_response_envelope_msg(self, response_msg):
        return lassomod.lecp_process_authn_response_envelope_msg(self, response_msg)


if not _inited:
    init()