Changeset 5599


Ignore:
Timestamp:
11/08/09 14:01:42 (10 years ago)
Author:
pjkersha
Message:

Moved test_samlinterface unit test back into ndg.security.test.unit

Location:
TI12-security/trunk/python
Files:
7 edited
1 moved

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.saml/saml/__init__.py

    r5597 r5599  
    2727__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    2828__revision__ = "$Id$" 
    29  
    30 import logging 
    31 log = logging.getLogger(__name__) 
    32  
    33 # Time module for use with validity times 
    34 from time import strftime, strptime 
    35 from datetime import datetime 
    36     
    37 # TODO: remove ElementTree dependency - package should XML implementation 
    38 # independent 
    39 from saml.utils import TypedList 
    40 from saml.xml import QName 
    41 from saml.common.xml import SAMLConstants, XMLConstants 
    42 from saml.saml2.core import AttributeValue 
    43      
    44      
    45 class XSStringAttributeValue(AttributeValue): 
    46  
    47     # Local name of the XSI type 
    48     TYPE_LOCAL_NAME = "string" 
    49          
    50     # QName of the XSI type 
    51     TYPE_NAME = QName(XMLConstants.XSD_NS,  
    52                       TYPE_LOCAL_NAME,  
    53                       XMLConstants.XSD_PREFIX) 
    54    
    55     def __init__(self): 
    56         self.__value = None 
    57          
    58     def _getValue(self): 
    59         return self.__value 
    60          
    61     def _setValue(self, value): 
    62         if not isinstance(value, basestring): 
    63             raise TypeError("Input must be a basestring derived type, got %r" % 
    64                             value.__class__) 
    65              
    66         self.__value = value 
    67  
    68     value = property(fget=_getValue, fset=_setValue, doc="string value")   
    69      
    70  
    71 class XSGroupRoleAttributeValue(AttributeValue):  
    72     '''ESG Specific Group/Role attribute value.  ESG attribute permissions are 
    73     organised into group/role pairs 
    74     ''' 
    75     DEFAULT_NS = "http://www.esg.org" 
    76     DEFAULT_PREFIX = "esg" 
    77     TYPE_LOCAL_NAME = "groupRole" 
    78      
    79     GROUP_ATTRIB_NAME = "group" 
    80     ROLE_ATTRIB_NAME = "role" 
    81      
    82     # QName of the XSI type 
    83     TYPE_NAME = QName(DEFAULT_NS,  
    84                       TYPE_LOCAL_NAME,  
    85                       DEFAULT_PREFIX) 
    86       
    87     def __init__(self,  
    88                  namespaceURI=DEFAULT_NS,  
    89                  elementLocalName=TYPE_LOCAL_NAME,  
    90                  namespacePrefix=DEFAULT_PREFIX): 
    91         '''@param namespaceURI: the namespace the element is in 
    92         @param elementLocalName: the local name of the XML element this Object  
    93         represents 
    94         @param namespacePrefix: the prefix for the given namespace''' 
    95         self.__namespaceURI = namespaceURI 
    96         self.__elementLocalName = elementLocalName 
    97         self.__namespacePrefix = namespacePrefix 
    98         self.__group = None 
    99         self.__role = None         
    100  
    101     def _getNamespaceURI(self): 
    102         return self.__namespaceURI 
    103  
    104     def _setNamespaceURI(self, value): 
    105         if not isinstance(value, basestring): 
    106             raise TypeError("Expecting %r type for namespaceURI got %r" % 
    107                             (basestring, value.__class__)) 
    108         self.__namespaceURI = value 
    109  
    110     def _getElementLocalName(self): 
    111         return self.__elementLocalName 
    112  
    113     def _setElementLocalName(self, value): 
    114         if not isinstance(value, basestring): 
    115             raise TypeError("Expecting %r type for elementLocalName got %r" % 
    116                             (basestring, value.__class__)) 
    117         self.__elementLocalName = value 
    118  
    119     def _getNamespacePrefix(self): 
    120         return self.__namespacePrefix 
    121  
    122     def _setNamespacePrefix(self, value): 
    123         if not isinstance(value, basestring): 
    124             raise TypeError("Expecting %r type for namespacePrefix got %r" % 
    125                             (basestring, value.__class__)) 
    126         self.__namespacePrefix = value 
    127  
    128     namespaceURI = property(fget=_getNamespaceURI,  
    129                             fset=_setNamespaceURI,  
    130                             doc="the namespace the element is in") 
    131  
    132     elementLocalName = property(fget=_getElementLocalName,  
    133                                 fset=_setElementLocalName,  
    134                                 doc="the local name of the XML element this " 
    135                                     "Object represents") 
    136  
    137     namespacePrefix = property(fget=_getNamespacePrefix,  
    138                                fset=_setNamespacePrefix,  
    139                                doc="the prefix for the given namespace") 
    140  
    141     def _getGroup(self): 
    142         return self.__group 
    143       
    144     def _setGroup(self, group):  
    145         self.__group = group 
    146       
    147     group = property(fget=_getGroup, fset=_setGroup) 
    148       
    149     def _getRole(self): 
    150         return self.__role 
    151       
    152     def _setRole(self, role): 
    153         self.__role = role 
    154       
    155     role = property(fget=_getRole, fset=_setRole) 
    156  
    157     def getOrderedChildren(self): 
    158         # no children 
    159         return None 
  • TI12-security/trunk/python/ndg.security.saml/saml/common/xml.py

    r5597 r5599  
    2929__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    3030__revision__ = "$Id$" 
    31  
    32 class XMLConstants(object): 
    33     '''XML related constants.''' 
    34  
    35     # XML Tooling 
    36  
    37     # Configuration namespace 
    38     XMLTOOLING_CONFIG_NS = "http:#www.opensaml.org/xmltooling-config" 
    39  
    40     # Configuration namespace prefix 
    41     XMLTOOLING_CONFIG_PREFIX = "xt" 
    42      
    43     # Name of the object provider used for objects that don't have a registered 
    44     # object provider 
    45     XMLTOOLING_DEFAULT_OBJECT_PROVIDER = "DEFAULT" 
    46  
    47     # Core XML 
    48  
    49     # XML core namespace 
    50     XML_NS = "http:#www.w3.org/XML/1998/namespace" 
    51      
    52     # XML core prefix for xml attributes 
    53     XML_PREFIX = "xml" 
    54  
    55     # XML namespace for xmlns attributes 
    56     XMLNS_NS = "http://www.w3.org/2000/xmlns/" 
    57  
    58     # XML namespace prefix for xmlns attributes 
    59     XMLNS_PREFIX = "xmlns" 
    60  
    61     # XML Schema namespace 
    62     XSD_NS = "http://www.w3.org/2001/XMLSchema" 
    63  
    64     # XML Schema QName prefix 
    65     XSD_PREFIX = "xs" 
    66  
    67     # XML Schema Instance namespace 
    68     XSI_NS = "http://www.w3.org/2001/XMLSchema-instance" 
    69  
    70     # XML Schema Instance QName prefix 
    71     XSI_PREFIX = "xsi" 
    72  
    73     # XML XMLSecSignatureImpl namespace 
    74     XMLSIG_NS = "http://www.w3.org/2000/09/xmldsig#" 
    75  
    76     # XML XMLSecSignatureImpl QName prefix 
    77     XMLSIG_PREFIX = "ds" 
    78  
    79     # XML Encryption namespace 
    80     XMLENC_NS = "http://www.w3.org/2001/04/xmlenc#" 
    81  
    82     # XML Encryption QName prefix 
    83     XMLENC_PREFIX = "xenc" 
    84      
    85     # Local name of EncryptedData element 
    86     XMLENC_ENCDATA_LOCAL_NAME = "EncryptedData" 
    87      
    88     # Local name of EncryptedKey element 
    89     XMLENC_ENCKEY_LOCAL_NAME = "EncryptedKey" 
    90      
     31from saml.xml import XMLConstants     
    9132 
    9233class SAMLConstants(XMLConstants): 
  • TI12-security/trunk/python/ndg.security.saml/saml/saml2/core.py

    r5597 r5599  
    788788                                 DEFAULT_ELEMENT_LOCAL_NAME, 
    789789                                 SAMLConstants.SAML20_PREFIX) 
     790 
     791class XSStringAttributeValue(AttributeValue): 
     792 
     793    # Local name of the XSI type 
     794    TYPE_LOCAL_NAME = "string" 
     795         
     796    # QName of the XSI type 
     797    TYPE_NAME = QName(SAMLConstants.XSD_NS,  
     798                      TYPE_LOCAL_NAME,  
     799                      SAMLConstants.XSD_PREFIX) 
     800   
     801    def __init__(self): 
     802        self.__value = None 
     803         
     804    def _getValue(self): 
     805        return self.__value 
     806         
     807    def _setValue(self, value): 
     808        if not isinstance(value, basestring): 
     809            raise TypeError("Input must be a basestring derived type, got %r" % 
     810                            value.__class__) 
     811             
     812        self.__value = value 
     813 
     814    value = property(fget=_getValue, fset=_setValue, doc="string value")   
     815     
     816 
     817# TODO: Move this class out of the SAML package back into ndg.security.common 
     818class XSGroupRoleAttributeValue(AttributeValue):  
     819    '''ESG Specific Group/Role attribute value.  ESG attribute permissions are 
     820    organised into group/role pairs 
     821    ''' 
     822    DEFAULT_NS = "http://www.earthsystemgrid.org" 
     823    DEFAULT_PREFIX = "esg" 
     824    TYPE_LOCAL_NAME = "groupRole" 
     825     
     826    GROUP_ATTRIB_NAME = "group" 
     827    ROLE_ATTRIB_NAME = "role" 
     828     
     829    # QName of the XSI type 
     830    TYPE_NAME = QName(DEFAULT_NS,  
     831                      TYPE_LOCAL_NAME,  
     832                      DEFAULT_PREFIX) 
     833      
     834    def __init__(self,  
     835                 namespaceURI=DEFAULT_NS,  
     836                 elementLocalName=TYPE_LOCAL_NAME,  
     837                 namespacePrefix=DEFAULT_PREFIX): 
     838        '''@param namespaceURI: the namespace the element is in 
     839        @param elementLocalName: the local name of the XML element this Object  
     840        represents 
     841        @param namespacePrefix: the prefix for the given namespace''' 
     842        self.__namespaceURI = namespaceURI 
     843        self.__elementLocalName = elementLocalName 
     844        self.__namespacePrefix = namespacePrefix 
     845        self.__group = None 
     846        self.__role = None         
     847 
     848    def _getNamespaceURI(self): 
     849        return self.__namespaceURI 
     850 
     851    def _setNamespaceURI(self, value): 
     852        if not isinstance(value, basestring): 
     853            raise TypeError("Expecting %r type for namespaceURI got %r" % 
     854                            (basestring, value.__class__)) 
     855        self.__namespaceURI = value 
     856 
     857    def _getElementLocalName(self): 
     858        return self.__elementLocalName 
     859 
     860    def _setElementLocalName(self, value): 
     861        if not isinstance(value, basestring): 
     862            raise TypeError("Expecting %r type for elementLocalName got %r" % 
     863                            (basestring, value.__class__)) 
     864        self.__elementLocalName = value 
     865 
     866    def _getNamespacePrefix(self): 
     867        return self.__namespacePrefix 
     868 
     869    def _setNamespacePrefix(self, value): 
     870        if not isinstance(value, basestring): 
     871            raise TypeError("Expecting %r type for namespacePrefix got %r" % 
     872                            (basestring, value.__class__)) 
     873        self.__namespacePrefix = value 
     874 
     875    namespaceURI = property(fget=_getNamespaceURI,  
     876                            fset=_setNamespaceURI,  
     877                            doc="the namespace the element is in") 
     878 
     879    elementLocalName = property(fget=_getElementLocalName,  
     880                                fset=_setElementLocalName,  
     881                                doc="the local name of the XML element this " 
     882                                    "Object represents") 
     883 
     884    namespacePrefix = property(fget=_getNamespacePrefix,  
     885                               fset=_setNamespacePrefix,  
     886                               doc="the prefix for the given namespace") 
     887 
     888    def _getGroup(self): 
     889        return self.__group 
     890      
     891    def _setGroup(self, group):  
     892        self.__group = group 
     893      
     894    group = property(fget=_getGroup, fset=_setGroup) 
     895      
     896    def _getRole(self): 
     897        return self.__role 
     898      
     899    def _setRole(self, role): 
     900        self.__role = role 
     901      
     902    role = property(fget=_getRole, fset=_setRole) 
     903 
     904    def getOrderedChildren(self): 
     905        # no children 
     906        return None 
    790907 
    791908 
  • TI12-security/trunk/python/ndg.security.saml/saml/test/test_saml.py

    r5597 r5599  
    2020from xml.etree.ElementTree import iselement 
    2121from xml.etree import ElementTree 
    22 from saml.xml.etree import prettyPrint 
    23  
    24 from saml import XSStringAttributeValue, XSGroupRoleAttributeValue 
    25      
     22 
    2623from saml.saml2.core import SAMLVersion, Attribute, AttributeStatement, \ 
    2724    Assertion, AttributeValue, AttributeQuery, Response, Issuer, Subject, \ 
    28     NameID, StatusCode, Status, Conditions 
     25    NameID, StatusCode, Status, Conditions, XSStringAttributeValue, \ 
     26    XSGroupRoleAttributeValue 
    2927from saml.common.xml import SAMLConstants 
    30 from saml.xml.etree import AssertionElementTree, \ 
     28from saml.xml.etree import prettyPrint, AssertionElementTree, \ 
    3129    XSGroupRoleAttributeValueElementTree, AttributeQueryElementTree, \ 
    3230    ResponseElementTree, ConditionsElementTree 
  • TI12-security/trunk/python/ndg.security.saml/saml/utils.py

    r5596 r5599  
    1 """Utilities package for NDG Security SAML implementation 
     1"""Utilities module for NDG Security SAML implementation 
    22 
    33NERC DataGrid Project 
    44""" 
    55__author__ = "P J Kershaw" 
    6 __date__ = "02/04/09" 
    7 __copyright__ = "" 
     6__date__ = "10/08/09" 
     7__copyright__ = "(C) 2009 Science and Technology Facilities Council" 
    88__license__ = "BSD - see LICENSE file in top-level directory" 
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id: $' 
     11try: 
     12    from datetime import strptime 
     13except ImportError: 
     14    # Allow for Python < 2.5 
     15    from time import strptime as _strptime 
     16    strptime = lambda datetimeStr, format: datetime(*(_strptime(datetimeStr,  
     17                                                                format)[0:6])) 
     18from datetime import datetime 
     19         
     20         
     21class SAMLDateTime(object): 
     22    """Generic datetime formatting utility for SAML timestamps 
     23    """ 
     24    DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ" 
     25     
     26    @classmethod 
     27    def toString(cls, dtIssueInstant): 
     28        """Convert issue instant datetime to correct string type for output 
     29        @type dtIssueInstant: datetime.datetime 
     30        @param dtIssueInstant: issue instance as a datetime 
     31        @rtype: basestring 
     32        @return: issue instance as a string 
     33        """ 
     34        if not isinstance(dtIssueInstant, datetime): 
     35            raise TypeError("Expecting datetime type for string conversion, " 
     36                            "got %r" % dtIssueInstant) 
     37             
     38        return dtIssueInstant.strftime(cls.DATETIME_FORMAT) 
     39 
     40    @classmethod 
     41    def fromString(cls, issueInstant): 
     42        """Convert issue instant string to datetime type 
     43        @type issueInstant: basestring 
     44        @param issueInstant: issue instance as a string 
     45        @rtype: datetime.datetime 
     46        @return: issue instance as a datetime 
     47        """ 
     48        if not isinstance(issueInstant, basestring): 
     49            raise TypeError("Expecting basestring derived type for string " 
     50                            "conversion, got %r" % issueInstant) 
     51             
     52        return datetime.strptime(issueInstant, cls.DATETIME_FORMAT) 
     53 
    1154 
    1255class TypedList(list): 
  • TI12-security/trunk/python/ndg.security.saml/saml/xml/__init__.py

    r5597 r5599  
    2727__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    2828__revision__ = "$Id$" 
    29 try: 
    30     from datetime import strptime 
    31 except ImportError: 
    32     # Allow for Python < 2.5 
    33     from time import strptime as _strptime 
    34     strptime = lambda datetimeStr, format: datetime(*(_strptime(datetimeStr,  
    35                                                                 format)[0:6])) 
    36 from datetime import datetime 
     29import logging 
     30log = logging.getLogger(__name__) 
     31    
     32class XMLConstants(object): 
     33    '''XML related constants.''' 
     34 
     35    # XML Tooling 
     36 
     37    # Configuration namespace 
     38    XMLTOOLING_CONFIG_NS = "http:#www.opensaml.org/xmltooling-config" 
     39 
     40    # Configuration namespace prefix 
     41    XMLTOOLING_CONFIG_PREFIX = "xt" 
     42     
     43    # Name of the object provider used for objects that don't have a registered 
     44    # object provider 
     45    XMLTOOLING_DEFAULT_OBJECT_PROVIDER = "DEFAULT" 
     46 
     47    # Core XML 
     48 
     49    # XML core namespace 
     50    XML_NS = "http:#www.w3.org/XML/1998/namespace" 
     51     
     52    # XML core prefix for xml attributes 
     53    XML_PREFIX = "xml" 
     54 
     55    # XML namespace for xmlns attributes 
     56    XMLNS_NS = "http://www.w3.org/2000/xmlns/" 
     57 
     58    # XML namespace prefix for xmlns attributes 
     59    XMLNS_PREFIX = "xmlns" 
     60 
     61    # XML Schema namespace 
     62    XSD_NS = "http://www.w3.org/2001/XMLSchema" 
     63 
     64    # XML Schema QName prefix 
     65    XSD_PREFIX = "xs" 
     66 
     67    # XML Schema Instance namespace 
     68    XSI_NS = "http://www.w3.org/2001/XMLSchema-instance" 
     69 
     70    # XML Schema Instance QName prefix 
     71    XSI_PREFIX = "xsi" 
     72 
     73    # XML XMLSecSignatureImpl namespace 
     74    XMLSIG_NS = "http://www.w3.org/2000/09/xmldsig#" 
     75 
     76    # XML XMLSecSignatureImpl QName prefix 
     77    XMLSIG_PREFIX = "ds" 
     78 
     79    # XML Encryption namespace 
     80    XMLENC_NS = "http://www.w3.org/2001/04/xmlenc#" 
     81 
     82    # XML Encryption QName prefix 
     83    XMLENC_PREFIX = "xenc" 
     84     
     85    # Local name of EncryptedData element 
     86    XMLENC_ENCDATA_LOCAL_NAME = "EncryptedData" 
     87     
     88    # Local name of EncryptedKey element 
     89    XMLENC_ENCKEY_LOCAL_NAME = "EncryptedKey" 
     90 
    3791 
    3892class XMLObjectError(Exception): 
     
    4195class XMLObjectParseError(Exception): 
    4296    pass 
    43  
    44 class XMLObject(object): 
    45     """Abstract base class for XML representations of SAML objects""" 
    46      
    47     def create(self, samlObject): 
    48         """Create an XML representation from the input SAML object 
    49         @type samlObject: SAMLObject 
    50         param samlObject: SAML object to render into XML 
    51         """ 
    52         raise NotImplementedError() 
    53  
    54     def parse(self, elem): 
    55         """Parse into XML representation 
    56         @type elem: object 
    57         @param elem: XML object - type depends on XML class representation 
    58         @rtype: SAMLObject 
    59         @return: equivalent SAML object 
    60         @raise XMLObjectParsingError: error parsing content into SAML  
    61         representation 
    62         """ 
    63         raise NotImplementedError() 
    64      
    65     def serialize(self): 
    66         """Serialize the XML object into a string representation 
    67         """ 
    68         raise NotImplementedError() 
    69          
    70          
    71 class IssueInstantXMLObject(XMLObject): 
    72     """Specialisation to enable inclusion of datetime formatting for issue 
    73     instant 
    74     """ 
    75     issueInstantFmt = "%Y-%m-%dT%H:%M:%SZ" 
    76      
    77     @classmethod 
    78     def datetime2Str(cls, dtIssueInstant): 
    79         """Convert issue instant datetime to correct string type for output 
    80         @type dtIssueInstant: datetime.datetime 
    81         @param dtIssueInstant: issue instance as a datetime 
    82         @rtype: basestring 
    83         @return: issue instance as a string 
    84         """ 
    85         if not isinstance(dtIssueInstant, datetime): 
    86             raise TypeError("Expecting datetime type for string conversion, " 
    87                             "got %r" % dtIssueInstant) 
    88              
    89         return dtIssueInstant.strftime(IssueInstantXMLObject.issueInstantFmt) 
    90  
    91     @classmethod 
    92     def str2Datetime(cls, issueInstant): 
    93         """Convert issue instant string to datetime type 
    94         @type issueInstant: basestring 
    95         @param issueInstant: issue instance as a string 
    96         @rtype: datetime.datetime 
    97         @return: issue instance as a datetime 
    98         """ 
    99         if not isinstance(issueInstant, basestring): 
    100             raise TypeError("Expecting basestring derived type for string " 
    101                             "conversion, got %r" % issueInstant) 
    102              
    103         return datetime.strptime(issueInstant,  
    104                                  IssueInstantXMLObject.issueInstantFmt) 
    10597         
    10698     
     
    122114        self.__prefix = value 
    123115     
    124     prefix = property(_getPrefix, _setPrefix, None, "Prefix") 
     116    prefix = property(_getPrefix, _setPrefix, None, "Namespace Prefix") 
    125117 
    126118    def _getLocalPart(self): 
     
    145137   
    146138    namespaceURI = property(_getNamespaceURI, _setNamespaceURI, None,  
    147                             "Namespace URI'") 
     139                            "Namespace URI") 
  • TI12-security/trunk/python/ndg.security.saml/saml/xml/etree.py

    r5597 r5599  
    3838    import cElementTree, ElementTree 
    3939 
    40 from saml import XSStringAttributeValue, XSGroupRoleAttributeValue 
    41  
    4240from saml.saml2.core import SAMLObject, Attribute, AttributeStatement, \ 
    4341    Assertion, Conditions, AttributeValue, AttributeQuery, Subject, NameID, \ 
    44     Issuer, SAMLVersion, Response, Status, StatusCode 
     42    Issuer, SAMLVersion, Response, Status, StatusCode , \ 
     43    XSStringAttributeValue, XSGroupRoleAttributeValue 
    4544from saml.common.xml import SAMLConstants 
    46 from saml.xml import IssueInstantXMLObject, XMLObjectParseError 
     45from saml.xml import XMLObjectParseError 
     46from saml.utils import SAMLDateTime 
    4747from saml.xml import QName as GenericQName 
    4848 
    49 # Generic Helper classes 
     49 
     50# Generic ElementTree Helper classes 
    5051class QName(ElementTree.QName): 
    5152    """Extend ElementTree implementation for improved attribute access support 
     
    6061    getLocalPart = staticmethod(lambda tag: tag.rsplit('}',1)[-1]) 
    6162 
    62     def __init__(self, namespaceURI, tag=None, prefix=None): 
    63         ElementTree.QName.__init__(self, namespaceURI, tag=tag) 
     63    def __init__(self, input, tag=None, prefix=None): 
     64        """ 
     65        @type input: basestring 
     66        @param input: ElementTree style namespace URI + tag name - 
     67        {namespace URI}tag - OR if tag keyword is set, the namespace URI alone 
     68        @type tag: basestring / None 
     69        @param tag: element tag name.  If None, input must contain the  
     70        namespace URI and tag name in the ElementTree form {namespace URI}tag. 
     71        @type prefix: basestring / None 
     72        @param prefix: namespace prefix 
     73        """ 
     74         
     75        ElementTree.QName.__init__(self, input, tag=tag) 
    6476         
    6577        if tag: 
    66             self.namespaceURI = namespaceURI 
     78            self.namespaceURI = input 
    6779            self.localPart = tag 
    6880        else: 
    69             self.namespaceURI = QName.getNs(namespaceURI) 
    70             self.localPart = QName.getLocalPart(namespaceURI) 
     81            # No tag provided namespace and locatPart of QN must be parsed from 
     82            # the namespace 
     83            self.namespaceURI = QName.getNs(input) 
     84            self.localPart = QName.getLocalPart(input) 
    7185             
    7286        self.prefix = prefix 
     
    197211 
    198212# ElementTree SAML wrapper classes 
    199 class ConditionsElementTree(Conditions, IssueInstantXMLObject): 
     213class ConditionsElementTree(Conditions): 
    200214    """ElementTree based XML representation of Conditions class 
    201215    """ 
     
    209223                                                           conditions)) 
    210224         
    211         notBeforeStr = cls.datetime2Str(conditions.notBefore) 
    212         notOnOrAfterStr = cls.datetime2Str(conditions.notOnOrAfter) 
     225        notBeforeStr = SAMLDateTime.toString(conditions.notBefore) 
     226        notOnOrAfterStr = SAMLDateTime.toString(conditions.notOnOrAfter) 
    213227        attrib = { 
    214228            cls.NOT_BEFORE_ATTRIB_NAME: notBeforeStr, 
     
    228242        return elem 
    229243                
    230 class AssertionElementTree(Assertion, IssueInstantXMLObject): 
     244class AssertionElementTree(Assertion): 
    231245    """ElementTree based XML representation of Assertion class 
    232246    """ 
     
    241255            raise TypeError("Expecting %r type got: %r"%(Assertion, assertion)) 
    242256         
    243         issueInstant = cls.datetime2Str(assertion.issueInstant) 
     257        issueInstant = SAMLDateTime.toString(assertion.issueInstant) 
    244258        attrib = { 
    245259            cls.ID_ATTRIB_NAME: assertion.id, 
     
    869883     
    870884     
    871 class AttributeQueryElementTree(AttributeQuery, IssueInstantXMLObject): 
     885class AttributeQueryElementTree(AttributeQuery): 
    872886    """Represent a SAML Attribute Query in XML using ElementTree""" 
    873887         
     
    889903             
    890904         
    891         issueInstant = cls.datetime2Str(attributeQuery.issueInstant) 
     905        issueInstant = SAMLDateTime.toString(attributeQuery.issueInstant) 
    892906        attrib = { 
    893907            cls.ID_ATTRIB_NAME: attributeQuery.id, 
     
    959973                                       SAMLVersion(attributeQuery.version))) 
    960974             
    961         attributeQuery.issueInstant = cls.str2Datetime(attributeValues[1]) 
     975        attributeQuery.issueInstant = SAMLDateTime.fromString( 
     976                                                            attributeValues[1]) 
    962977        attributeQuery.id = attributeValues[2] 
    963978         
     
    982997         
    983998     
    984 class ResponseElementTree(Response, IssueInstantXMLObject): 
     999class ResponseElementTree(Response): 
    9851000    """Represent a SAML Response in XML using ElementTree""" 
    9861001         
     
    10021017             
    10031018         
    1004         issueInstant = cls.datetime2Str(response.issueInstant) 
     1019        issueInstant = SAMLDateTime.toString(response.issueInstant) 
    10051020        attrib = { 
    10061021            cls.ID_ATTRIB_NAME: response.id, 
     
    10741089                                       SAMLVersion(response.version))) 
    10751090             
    1076         response.issueInstant = cls.str2Datetime(attributeValues[1]) 
     1091        response.issueInstant = SAMLDateTime.fromString(attributeValues[1]) 
    10771092        response.id = attributeValues[2] 
    10781093        response.inResponseTo = attributeValues[3] 
Note: See TracChangeset for help on using the changeset viewer.