source: TI05-delivery/ows_framework/trunk/ows_server/ows_server/models/stubB.py @ 2834

#!/usr/bin/env python
#
# This python code (will) handle all forms of stub-B and provide HTML
# methods to the extent required by the NDG browse functionality.
# NB, It would be cleaner to use Dom's way of doing things but we'd
# need a schema for that ...
# BNL April 2006
# 

from Utilities import *
from AccessControl import AccessControl
from geoUtilities import Bounding
from People import *
from ndgObject import ndgObject
#from DeploymentHandling import *
try: #python 2.5
    from xml.etree import ElementTree as ET
except ImportError:
    try:
        # if you've installed it yourself it comes this way
        import ElementTree as ET
    except ImportError:
        # if you've egged it this is the way it comes
        from elementtree import ElementTree as ET


def collapse2(keywords,split='>'):
    ''' Take the last element of a DIF parameter tree entry, and put them in a dictionary
    under the DIF category '''
    d={}
    for item in keywords:
        line=item.split(split)
        category=line[0]
        if category not in d: d[category]=[]
        while line<>[]:
            c=line.pop()
            if c<>'': 
                if c<>category:
                    d[category].append(c)
                line=[]
    return d


def idconvert(helper,elem,config=None,idelem='dgMetadataID'):
    ''' Given an elementTree element for a dgMetadataID, create
    a standard ndg URI, and produce an ndgObject '''
    id=helper.find(elem,idelem)
    entryID='%s__%s__%s'%(helper.getText(id,'repositoryIdentifier'),
                            helper.getText(id,'schemeIdentifier'),
                            helper.getText(id,'localIdentifier'))
    uri=ndgObject(entryID,config)
    return uri

class ndgLink:
    ''' This is a holder for an ndgObject which has a name (and possibly abbreviation) '''
    def __init__(self,name,abbrev,ndgO,label='',image=None):
        self.ndgObject=ndgO
        self.name=name
        self.abbrev=abbrev
        self.image=image
        self.label=label
        self.URL=ndgO.BURL
    def toHTML(self):
        ### needs to be finished
        return self.ndgObject.URL

class dataGranule:
        ''' Provides support for data granule structures '''
        def __init__(self,helper,elem,config,name=''):
            self.elem=elem
            self.constraints=AccessControl(helper.find(elem,'accessControlPolicy'))
            self.name=name
            self.uri=idconvert(helper,elem,config,idelem='dataModelID')
            self.entryID=self.uri.uri

class ObservationStation:
    def __init__(self,h,e):
        self.e=e
        if e is None: return
class DataProductionTool:
    def __init__(self,h,e):
        self.e=e
        if e is None: return
class Activity:
    def __init__(self,h,e):
        self.e=e
        if e is None: return
       
def Deployments(elem,helper,config):
    ''' This is the late June 2007 version '''
    if elem is None: return None
    types={'dptList':'dataproductiontool','activityList':'activity','obsStnList':'observationstation','deList':''}
    names={'dptList':'Data Production Tools','activityList':'Activities','obsStnList':'Observation Stations','deList':'Data Entities'}
    result={}
    for alist in types:
        blist=helper.find(elem,alist)
        collection=[]
        if blist is not None:
            for object in blist:
                uri=idconvert(helper,object,config=config)
                name=helper.getText(object,'name')
                shortName=helper.getText(object,'abbreviation')
                collection.append((uri,name,shortName))
            result[names[alist]]=collection
    return result
            
class DataEntity:
    def __init__(self,helper,element):
        ''' Attempt to instantiate this stubB as a data entity'''
        self.elem=element
        self.helper=helper
        #just one curator
        self.curator=dgContact(self.elem.find('dgDataRoles/dgDataCurator'),ctype='organisation')
        #possibly multiple creators
        self.creators=[dgContact(i) for i in self.elem.findall('dgDataRoles/dgDataCreator')]
        host,service = '','' # dummy for now
        #possibly multiple granules
        self.getGranules()
        #bounding box, handled as a class because this is going to be difficult ...
        self.bbox=Bounding(self.elem,entity='stubB')
        self.temporal()
        #parameters
        plist=wrapGetText(self.elem,'dgDataSummary/dgParameterSummary/ParameterName',multiple=1)
        self.parameters=collapse2(plist,split='/')
        
        
    def getGranules(self):
        ''' Load up the granule content within the entity '''
        granList=self.elem.findall('dgDataGranule')
        self.granules=[]
        i=0
        for item in granList:
            i+=1
            #following needs to be refactored when granule definition includes a proper name ...
            name=wrapGetText(item,'dgGranuleSummary/dgGranuleName')
            if name=='': name='Granule %s'%i
            self.granules.append(dataGranule(self.helper,item,self.config,name=name))
                
    def temporal(self):
        '''Instantiate the timeCoverage attribute by parsing for temporal coverage '''
        t=self.elem.find('dgDataSummary/dgDataCoverage/dgTemporalCoverage/DateRange')
        if t is not None:
           try:
                self.timeCoverage=(float(i.text) for i in t)
           except:
                self.timeCoverage=('',)
                                
        else:
           t=self.elem.find('dgDataSummary/dgDataCoverage/dgTemporalCoverage/DateSingle')
           try:
                self.timeCoverage=(t.text,)
           except:
                self.timeCoverage=('',)

class dgMetadataDescription:
    
    def __init__(self,helper,elem):
        ''' Initialise a Metadata Description '''
        n=idconvert(helper,elem)
        self.uri=n.uri
        self.abstract=helper.getText(elem,'abstract/abstractText')
        self.texts=[]
        self.onlineRefs=[]
        for e in helper.findall(elem,'descriptionSection'):
            self.texts.append((helper.getText(e,'dgDescriptionText'),helper.getText(e,'contentType')))
        online=helper.findall(elem,'descriptionSection/descriptionOnlineReference/dgSimpleLink')
        for o in online:
            self.onlineRefs.append((helper.getText(o,'name'),helper.getText(o,'URI')))


class stubB(DataEntity,ObservationStation,DataProductionTool,Activity):
        
        ''' Holds the stub-b document and provides methods which get and manipulate it '''
        
        def __init__(self,elem,config):
                
                '''Instantiate with an element tree elem '''
                
                self.tree=elem
                self.metadataType='NDG-B1'
                self.services=[]
                self.config=config
                self.citation=''
                self.personnel=[] # for DIF compatiability for the moment.
                self.parameters=None
                self.granules=[]
                self.logos=[]
                
                
                try:
                        helper=nsdumb(self.tree)
                        self.name=helper.getText(self.tree,'name')
                except Exception,e:
                        raise ValueError('Error instantiating stubB [%s]'%e)

                self.ndgObject=idconvert(helper,self.tree,self.config)
                self.entryID=self.ndgObject.uri
                
                #Note that the root of the ElementTree instance is dgMetadataRecord
                #so we don't need (or want) that in our xpath expressions.
                
                self.constraints=AccessControl(helper.find(self.tree,'dgMetadataSecurity'))
                self.abbreviation=helper.getText(self.tree,'abbreviation')
                if self.abbreviation=='': self.abbreviation=self.name[0:min(15,len(self.name))]
                logos=helper.findall(self.tree,'dgMetadata/dgMetadatdataRecord/logos/logoURI')
                for l in logos:
                    self.logos.append((helper.find(l,'dgSimpleLink/name'),
                                       helper.find(l,'dgSimpleLink/URI')))
                
                for i in ('dgDataEntity','dgActivity','dgDataProductionTool','dgObservationStation'):
                    elem=helper.find(self.tree,i)
                    if elem is not None: break
                if elem is None:
                    raise ValueError('StubB record does not contain an Activity, DE, DPT, ObsStn')
                elif elem.tag=='dgDataEntity':
                        DataEntity.__init__(self,helper,elem)
                elif elem.tag=='dgActivity':
                        Activity.__init__(self,helper,elem)
                elif elem.tag=='dgDataProductionTool':
                        DataProductionTool.__init__(self,helper,elem)
                elif elem.tag=='dgObservationStation':
                        ObservationStation.__init__(self,helper,elem)

                self.description=dgMetadataDescription(helper,helper.find(self.tree,'dgMetadataDescription'))
                self.abstract=self.description.abstract
                self.stubBtype=elem.tag
              
                # now go get all the related links
                
                self.related=Deployments(helper.find(elem,'DeploymentSummary'),helper,self.config)


if __name__=="__main__":
    import unittest
    import os.path
    
    de='examples/badc.nerc.ac.uk__NDG-B1__dataent_chablis.xml'
    dpt='examples/badc.nerc.ac.uk__NDG-B1__dpt_11634276941110630.xml'
    
    class TestCase(unittest.TestCase):
    
            def testDE(self):
                ''' Test rendering a DataEntity stubB '''
                fname=de
                self.doit(fname)
                
            def testDPT(self):
                ''' Test rendering a Data Production Tool stubB '''
                fname=dpt
                self.doit(fname)
                
                
            def doit(self,fname):
                xml=open(fname,'r').read()
                config=myConfig('ndgDiscovery.config')
                layoutdir=config.get('layout','layoutdir')
                x=stubB(xml,config)
                y='''<?xml version="1.0" encoding="UTF-8"?>
                    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
                    <html xmlsns="http://www.w3.org/1999/xhtml" xml:lang="en">
                            <head>
                                    <META http-equiv="Content-Type" content="text/xhtml; charset=iso-8859-1"/>
                                    <title>stubB</title>
                                    <LINK media="all, screen" href="%s/layout/ndg.css" type="text/css" rel="stylesheet"/>
                            </head> '''%layoutdir+x.toHTML(config)
                ff=fname+'-output.html'
                f=file(ff,'w')
                f.write(y)
                
    
    unittest.main()