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

#!/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 BeautifulSoup import BeautifulSoup
from AccessControl import AccessControl
from geoUtilities import Bounding
from People import *
from ndgObject import ndgObject
from ows_server.models import Utilities

#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
            self.bbox=Bounding(self.elem,helper,entity='moles')
            self.timeCoverage=temporal(self.elem,helper)
            self.parameters=helper.getText(elem,'dgGranuleSummary/dgParameterSummary/ParameterName',multiple=1)
           
class SelectedItem:
    ''' A simple object representing key info on selected items '''
    def __init__(self,entryID,title,kmlURL,wmcURL):
            self.entryID = entryID
            self.title = title
            self.kmlURL = kmlURL
            self.wmcURL = wmcURL
            self.kmlList = Utilities.recreateListFromUnicode(kmlURL)
            self.wmcList = Utilities.recreateListFromUnicode(wmcURL)
            
class ObservationStation:
    def __init__(self,h,e):
        self.e=e  
        self.hdg='Observation Station'
        if e is None: return
class DataProductionTool:
    def __init__(self,h,e):
        self.e=e
        i=h.find(e,'dgInstrument')
        if i is not None: 
            self.hdg='Instrument'
        else:
            self.hdg='Model'
        if e is None: return
class Activity:
    def __init__(self,h,e):
        self.e=e
        self.hdg='Activity'
        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','dataEntityList':'dataentity'}
    names={'dptList':'Data Production Tools','activityList':'Activities','obsStnList':'Observation Stations','dataEntityList':'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
            
def temporal(elem,helper):
    ''' Parse for time coverage attributes '''
    timeElems=helper.findall(elem,'*//dgTemporalCoverage')
    tc=[]
    for e in timeElems:
        t=e.find('DateRange')
        if t is not None:
            c=[helper.getText(t,'DateRangeStart'),]
            c.append(helper.getText(t,'DateRangeEnd'))
        else:
            c=[helper.getText(e,'DateSingle'),'']
        c.append(helper.getText(elem,'*/dgDatasetStatus/dgDatasetClosure'))
        tc.append(c)
    return tc
            
def parseParameters(plist,helper):
    ''' Takes a list of ET Parameter Summary elements, and parses them into a 
    sensible pythonic structure. In particular, given:
    <dgParameterSummary> 
        <IsOutput>true</IsOutput>
        <dgStdParameterMeasured> 
            <dgValidTerm>BAROCLINIC V_VELOCITY (OCEAN) CM/S</dgValidTerm>
            <dgValidTermID> 
                <ParentListID>COAPEC_500YrRun_wholerun_decadal_ocean</ParentListID>
                <TermID>null</TermID>
            </dgValidTermID>
        </dgStdParameterMeasured>
        <ParameterName>BAROCLINIC V_VELOCITY (OCEAN) CM/S</ParameterName>
    </dgParameterSummary>
    we take the parameter name and the parentlistID and use them to build up a 
    parameter dictionary '''
    ptypes={}
    for p in plist:
        ptype=helper.getText(p,'dgStdParameterMeasured/dgValidTermID/ParentListID')
        if ptype not in ptypes: ptypes[ptype]=[]
        ptypes[ptype].append(helper.getText(p,'ParameterName'))
    gcmd='http://vocab.ndg.nerc.ac.uk/term/P111'
    if gcmd in ptypes: 
        dif=collapse2(ptypes[gcmd],split='/')
        del ptypes[gcmd]
    return dif,ptypes
            
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,helper,entity='moles')
        self.timeCoverage=temporal(self.elem,self.helper)
        #parameters
        pelem=self.helper.findall(self.elem,'dgDataSummary/dgParameterSummary')
        self.parameters,self.extraParameters=parseParameters(pelem,self.helper)
        self.hdg='Data Entity'
        
    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))

class dgMetadataDescription:
    
    def __init__(self,helper,elem,viewService):
        ''' Initialise a Metadata Description '''
        n=idconvert(helper,elem)
        self.uri=n.uri
        self.logo=None
        self.abstract=helper.getText(elem,'abstract/abstractText')
        self.texts=[]
        self.onlineRefs=[]
        for e in helper.findall(elem,'descriptionSection'):
            textElem=helper.find(e,'dgDescriptionText')
            if textElem is not None:
                text=(textElem.text or '')
                tail=''
                for i in textElem: 
                    text+=ET.tostring(i)
                    tail=(i.tail or '')
                text+=tail
                ctype=helper.getText(e,'contentType')
                if ctype in ['','text/html']:
                    soup=BeautifulSoup(text)
                    text=soup.prettify()
                self.texts.append((text,ctype))
        online=helper.findall(elem,'descriptionSection/descriptionOnlineReference/dgSimpleLink')
        for o in online:
            rtype=helper.getText(o,'name')
            #url and uri supported in 1.4 moles, but no one has implemented that yet ...
            uri,url=helper.getText(o,'URI'),helper.getText(o,'URL')
            if rtype=='Logo':
                self.logo=uri
            else:
                try:
                    value=help
                    self.onlineRefs.append((rtype,{'NumSim':'%s/%s'%(viewService,uri)}[rtype]))
                except KeyError:
                    self.onlineRefs.append((rtype,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={}
                self.extraParameters={}
                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
                self.viewService=self.ndgObject.viewService
                
                #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.viewService)
                if self.description.logo is not None:
                    self.logos.append((('Logo',self.description.logo)))
                    print 'LOGOS',self.logos
                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
    from ndgRetrieve import ndgRetrieve
        
    
    class TestCase(unittest.TestCase):
    
            def testDE(self):
                ''' Test rendering a DataEntity stubB '''
                doc='badc.nerc.ac.uk__NDG-B1__dataent_COAPEC'
                xml=self.getit(doc)     
                self.doit(xml.tree)
                
            def getit(self,doc):
                self.c=myConfig('../../ndgDiscovery.config')
                uri=ndgObject(doc)
                status,xml=ndgRetrieve(uri,self.c)
                self.assertEqual(status,1)
                return xml
          
            def doit(self,xml):
                layoutdir=self.c.get('layout','layoutdir')
                x=stubB(xml,self.c)
                
         
    unittest.main()