source: exist/trunk/python/ndgUtils/ndgObject.py @ 4430

import ndgRetrieve, xmlHandler2, logging

class ndgObject:
    ''' This class instantiates an ndgObject which describes the various ways 
        of obtaining itself, primarily
                (1) a downloadable xml representation from a repository,
                (2) a printable xml representation '''

    # The various different document types:
    MOLES_DOC_TYPE = 'NDG-B1'
    DIF_DOC_TYPE = 'DIF'
    DC_DOC_TYPE = 'DC'
    ISO_DOC_TYPE = 'ISO19139'
    NDGB1_DOC_TYPE = 'NDG-B1'
    NDGB0_DOC_TYPE = 'NDG-B0'
    MDIP_DOC_TYPE = 'MDIP'
    NDGA0_DOC_TYPE = 'NDG-A0'
    NUMSIM_DOC_TYPE = 'NumSim'
    ATOM_DOC_TYPE = 'ATOM'
    ATOM_BACKUP_DOC_TYPE = 'ATOM-BACKUP'

        # various namespaces used in the docs
    ATOM_NS = 'http://www.w3.org/2005/Atom'
    DIF_NS = 'http://gcmd.gsfc.nasa.gov/Aboutus/xml/dif/'
    MOLES_NS = 'http://ndg.nerc.ac.uk/schema/moles2beta'
    GEOSS_NS = 'http://www.georss.org/georss/10'
    GML_NS = 'http://www.opengis.net/gml'
        
    # Group the doc types according to the source they should be retrieved from
    DISCOVERY_SCHEMES = [DIF_DOC_TYPE, DC_DOC_TYPE, \
                         MDIP_DOC_TYPE, ISO_DOC_TYPE, 'ISO']
    BROWSE_SCHEMES = [MOLES_DOC_TYPE, NDGB1_DOC_TYPE, \
                      NUMSIM_DOC_TYPE, ATOM_DOC_TYPE, \
                      ATOM_BACKUP_DOC_TYPE]
    
    def __init__(self,uri,config=None):
        ''' Parse the uri and prepare for obtaining the actual content'''
        logging.debug("Initialising ndgObject with uri: '%s'" %uri)
        #Dom had problem with unicode coming in here ... dunno why @@@@
        uri=str(uri) 
        
        # a priori, assume we can't get content for this object
        self.gettable=-1  
        
        # handle all the known ways of doing an NDG URI ...
        bits=uri.split(':')
        bits2=uri.split('__')
        ok=1
        if len(bits)==3:
            repository,schema,localID=bits
            self.uri=uri.replace(':','__')
        elif len(bits2)==3:
            repository,schema,localID=bits2
            self.uri=uri
        elif len(bits2)>3:
            repository,schema,localID=bits2[0],bits2[1],'__'.join(bits2[2:])
            self.uri=uri
        else:
            bits=uri.split('/')
            if len(bits)==2:
                schema='NDG-B0'
                repository,localID=bits
                self.uri=None  # 
                ok=0  # I reckon we shouldn't ever see any of these again ...
                # but if we do, the uri will need fixing too ...
            else: ok=0
        
        if not ok:
            # after all that, we don't think it's an NDG URI ...
            raise ValueError,'The identifier [%s] is not a valid NDG style URI'%uri

        # yes, it is an NDG URI ...
        self.repository,self.schema,self.localID=repository,schema,localID
        logging.debug("Extracted valid NDG values from URI: repository: '%s', schema: '%s', localID: '%s'" \
                      %(repository, schema, localID))
        self.setConfig(config)

    def setDefaultProperties(self):
        '''
        Set default properties for object
        '''
        self.discoveryURL,self.baseURL,self.xmlURL,\
            self.printableURL =None,None,None,None
        self.useDiscoveryService = 1
        self.BURL=None

        
    def setConfig(self, config):
        ''' 
        Set up the configuration for retrieving this document 
        '''
        logging.debug("Setting up configuration for retrieving document")
        self.config=config
        if config is None:
            self.setDefaultProperties()
            return

        self.server=self.config.get('DISCOVERY','default')
        server=self.server
        qs=None
        # This NDG object may itself be a discovery record, which makes life easy, but
        # it might not be, in which case we have to build up all the possible views upon it.
        # But remember only data entity b records have discovery records ...
        self.viewService='%s/view/'%server
        discoveryBASE='%s%s__%s__%s'%(self.viewService,self.repository,self.schema,self.localID)

        # set default return format - if not set, just return in original format
        fmt=''
        if self.config.has_option('DISCOVERY','formatDefault'):
            fmt=self.config.get('DISCOVERY','formatDefault')
            logging.info("Default discovery format set to: %s" %fmt)
            
        self.BURL=None
        # We'll build the following even if it can't be used (as would be the case for
        # a non data entity B record or an A record) because it's a useful template.
        if self.schema!=fmt: 
            qs=('outputSchema',fmt)
        self.discoveryURL=self.__buildURL(discoveryBASE,[qs])

        # config file should have details on the service to use for the repository
        # - if not, default to 'unknown'
        servicehost = 'unknown'
        if self.config.has_option('NDG_B_SERVICE',self.repository):
            servicehost=self.config.get('NDG_B_SERVICE',self.repository)
            
        # If this record is itself a discovery record, then we don't have much more to do
        if self.schema in self.DISCOVERY_SCHEMES:
            self.xmlURL=self.__buildURL(
                discoveryBASE.replace('/view/','/retrieve/'),[qs,('format','raw')])
            self.printableURL=self.__buildURL(discoveryBASE,[qs,('format','xml')])
            self.URL=self.discoveryURL
            if servicehost!='unknown':self.gettable=1
        elif self.schema in self.BROWSE_SCHEMES:
            # One day we'll use a service binding to get this
            # This is a mapping from the ndg repository id to an actual repository id
            # understood by the ndg exist interface
            blank=self.config.get('NDG_B_SERVICE','instance')
            url=blank.replace('SERVICEHOST',servicehost)
            url=url.replace('URI',self.uri)
            self.URL=url
            self.xmlURL=url.replace('/view/','/retrieve/')+'?format=raw'
            self.printableURL=url+'?format=xml'
            if servicehost!='unknown': self.gettable=0
            self.useDiscoveryService = 0
        else:
            #currently we don't know how to get this one
            self.URL='unknown'
            self.setDefaultProperties()

        logging.debug("Set up URL: '%s', discoveryURL: '%s'" %(self.URL, self.discoveryURL))
            
        #now, we'll build a stub-B url as well, in case that comes in handy 
        if self.schema!='NumSim' and self.gettable<>-1:
            if self.schema:
                self.BURL=discoveryBASE.replace(self.schema,'NDG-B1')
            if server:
                self.BURL=self.BURL.replace(server,servicehost)
            logging.debug("Set up stub-B url: '%s'" %self.BURL)


    def __buildURL(self,base,queryStuff):
        ss=''
        for i in queryStuff: 
            if i!=None:ss+='&%s=%s'%(i[0],i[1])
        if ss!='':ss='?'+ss[1:]
        return base+ss
            
    def get(self,securityCredentials=None):
        ''' Actually retrieve an ORIGINAL xml record corresponding to an ndg URI
        NB, not sure if this method is actually used anywhere - since get is 
        usually done via ndgRetrieve 
        '''
        if self.config is None: return None
        status,xmlh=ndgRetrieve.ndgRetrieve(self,self.config, \
                                            discovery = self.useDiscoveryService)
        if status:
            x=xmlHandler2.xmlHandler(xmlh,string=1)
            return x.xmls
        else:
            return status
        
    def __str__(self):
        return self.uri