source: TI02-CSML/trunk/csml/API/ops_Dataset.py @ 2907

''' ops_Dataset  contains operations for root Dataset class'''
import codecs
import csml.csmllibs.xmlEncoding
import csml.parser_extra
import csml.API.existDB
import csml.API.csmlbbox

try: #python 2.5
    from xml.etree import cElementTree as ET
except ImportError:
    try:
        # if you've installed it yourself it comes this way
        import cElementTree as ET
    except ImportError:
        # if you've egged it this is the way it comes
        from elementtree import cElementTree as ET

def testmethod(self):
    print 'testmethod for dataset'
    return 'testmethod dataset'

def parse(self, csmlfile, xmldb=None, collection='/db/ndg_A_metadata', id_field = 'id', nslong='http://ndg.nerc.ac.uk/csml', nsshort='csml', passwords=None):
    """must be provided with csmlfile   parses the csmlfile into self """
    if xmldb is not None:      
        #use xml db (exist)
        COLLECTION=collection
        DOC_ID=csmlfile
        ID_FIELD=id_field
        NSLONG=nslong
        NSSHORT=nsshort
        if passwords is not None:
            existDB = csml.API.existDB.ndg_eXist(db=xmldb, passwordFile=passwords)  
        else:
            existDB = csml.API.existDB.ndg_eXist(db=xmldb)  
        csmlfile=existDB.getXMLRecord(COLLECTION,ID_FIELD,DOC_ID,att=1,namespaceLong=NSLONG, namespaceShort=NSSHORT)
        elem=ET.fromstring(csmlfile)
        tree=ET.ElementTree(element=elem)
    else:
        #use filesystem
        #determine encoding
        f = open(csmlfile)
        startoffile=f.readline()
        encoding=csml.csmllibs.xmlEncoding.autoDetectXMLEncoding(startoffile)
        f.close()
        #parse with correct encoding
        tree = csml.parser_extra.encodingParser(csmlfile,encoding)
    self.fromXML(tree.getroot())
    self =csml.parser_extra.ParserPostProcessor(self).resolveReferences()
    
def parseElemTree(self, elemtree):
    ''''alternative parsing method, supply with elementtree instance instead of file/uri'''
    self.fromXML(elemtree)
    self =csml.parser_extra.ParserPostProcessor(self).resolveReferences()
    
def _checkChildren(self, parent):
    ''' method used by iterate '''
    if hasattr(parent, 'CHILDREN'):
        for o in parent.CHILDREN:
            child=None
            try:
                child=getattr(parent,o)
            except:
                pass              
            if child is not None:
                if type(child) is list:
                    for item in child:
                        self.allobjects.append(item)
                        self._checkChildren(item)
                else:
                    self.allobjects.append(child)
                    self._checkChildren(child)
                    
def iterate(self):
    ''' returns an iterable list of all objects in the dataset. No order or hierarchy is preserved. Useful for searching quickly for something'''
    self.allobjects=[]
    self._checkChildren(self)
    return self.allobjects
    
def getSecurity(self):
    """ returns a dictonary containing attributeAuthority: role"""
    security=[]
    if hasattr(self, 'accessControlPolicy'):
        if hasattr(self.accessControlPolicy,'dgSecurityConditions'):
            for condition in self.accessControlPolicy.dgSecurityConditions:
                #need to test for these but ok for alpha.
                cond=[]
                cond.append(condition.effect)
                cond.append(condition.simpleCondition.dgAttributeAuthority)
                cond.append(condition.simpleCondition.attrauthRole)
                cond.append(condition.conditionExplanationText)
                security.append(cond)
    return security

def getFeatureList(self):
    #returns a list of feature ids for the dataset
    self.featureList = []
    for member in csml.csmllibs.csmlextra.listify(self.featureCollection.featureMembers):
            self.featureList.append(member.id)
    return self.featureList
    
def getFeature(self, featureID):
    """ returns a single feature object """
    for member in csml.csmllibs.csmlextra.listify(self.featureCollection.featureMembers):
            if member.id == featureID:
                return member    

def getFileExtract(self,extractID):
        for extract in csml.csmllibs.csmlextra.listify(self.dataset.arrayDescriptors):
            if  extract.id==extractID:
                return extract 

def getCSMLBoundingBox(self):
    #returns a complete boundingBox object including temporal domain and crs
    if hasattr(self.featureCollection, 'boundedBy'):
        return csml.API.csmlbbox.CSMLBoundingBox(self.featureCollection.boundedBy)
    else:
        return None


def getBoundingBox(self):
    ''' get boundingBox, returns the boundingBox of the CSMLFeatureCollection (assumes there is only one...)'''
    try:
        lower1=eval(self.featureCollection.boundedBy.lowerCorner.CONTENT.split()[0])
        lower2=eval(self.featureCollection.boundedBy.lowerCorner.CONTENT.split()[1])
        upper1=eval(self.featureCollection.boundedBy.upperCorner.CONTENT.split()[0])
        upper2=eval(self.featureCollection.boundedBy.upperCorner.CONTENT.split()[1])
        return [lower1,lower2,upper1,upper2]
    except:
        return []