source: cows/trunk/cows/model/filterencoding.py @ 4311

# Copyright (C) 2008 STFC & NERC (Science and Technology Facilities Council).
# This software may be distributed under the terms of the
# Q Public License, version 1.0 or later.
# http://ndg.nerc.ac.uk/public_docs/QPublic_license.txt

""" Classes to handle filter encoding queries as used in WFS """


from xml.etree import ElementTree as etree
import logging
log = logging.getLogger(__name__)

""" utility functions to save writing out fully qualified names """
nsOGC = 'http://www.opengis.net/ogc'
def OGC(tag):
    return "{"+nsOGC+"}"+tag

nsGML = 'http://www.opengis.net/gml'
def GML(tag):
    return "{"+nsGML+"}"+tag
        
class FEQuery(object):
    """ Represents a WFS Query string which can contain feature type names and a variety of filters """
    
    def __init__(self, querystring):
        self.querystring=str(querystring) #may be unicode, so convert to string
        self.elem=etree.fromstring(self.querystring)
        log.debug("Query String: %s"%self.querystring)
        log.debug("Query Element: %s"%self.elem)
        
    def getTypeName(self):
        typename=self.elem.get('typeName')   
        log.debug('TypeName = %s'%typename)
        return typename   
    
    def getFilters(self):
        """returns parts of query as individual filters which can then be translated into
        method calls on the wfs_iface. Examples of filters include, getByGMLid, getByBBox, getByTimeRange"""
        queryfilters=[]
        for child in self.elem.getchildren():
            if child.tag==OGC('Filter'):
                #break <ogc:Filter> down into single filters.
                fp=FilterParser(child)
                for filter in fp.filters:
                    queryfilters.append(filter)
        return queryfilters     

class FilterParser(object):
    """ Handles an OGC Filter object which in reality can contain several 'sub-filters'. Breaks this down into individual 'Filters' """
    def __init__(self, filterelem):
        self.filters=[]
        for elem in filterelem.getchildren():
            if elem.tag == OGC('GmlObjectId'):
                value=elem.get(GML('id'))
                f=Filter('GmlObjectId', value)
                self.filters.append(f)
            elif elem.tag==OGC('BBOX'):
                value=(1,2,3,4)
                srsname='WGS84'
                f=BBoxFilter(srsname, 'BBOX', value)
                self.filters.append(f)
                
        
class Filter(object):
    """represents an individual WFS filter (i.e. a filter containing 'And' will be modelled as 2 filters).
    @ivar filtertype: Type of filter (e.g. 'getByBBox')
    @ivar fitlervalue: Appropriate value on which to filter (e.g. Bounding box tuple)
    """
    def __init__(self, filtertype, filtervalue):
        self.filtertype = filtertype
        self.filtervalue = filtervalue

class BBoxFilter(Filter):
    """ As Filter, but with additional srsname attribute """
    def __init__(self, srsname, *args):
        super(BBoxFilter, self).__init__(*args)
        self.srsname=srsname
        
class FEQueryProcessor(object):
    """ Given a Featureset and a list of of Filters, applies the filters 
    to the Featureset and creates a resultset 
    Assumptions:
        1) GmlObjectId is only used as a filter alone or with other GmlObjectId filters, not with other filter types.
        2) Other filter types, such as bounding box or temporal range filters only appear once. 
    
    """
    
    def __init__(self, featureset, filters):
        self.featureset=featureset
        self.resultset=[]              
        temporalrangeresults=[]
        bboxresults=[]
        temporalflag=False
        bboxflag = False
        for filter in filters:
            log.debug('Filtertype %s'%filter.filtertype)
            if filter.filtertype=='GmlObjectId':           
                feature=self.featureset.getFeatureByGMLid(filter.filtervalue)
                if feature:
                    self.resultset.append(feature)    
            else:
                #handle other filtertypes, bbox & temporal for now:
                if filter.filtertype=='BBOX':
                    bboxflag=True
                    bboxresults=self.featureset.getFeaturesByBBox(filter.filtervalue, filter.srsname)                    
                elif filter.filtertype=='TemporalRange':
                    temporalflag=True
                    temporalrangeresults=self.featureset.getFeaturesByTemporalRange(filter.filtervalue)           
        
        #Now work out what the overlapping (if appropriate) resultset is.
        log.debug('bboxflag %s'%bboxflag)
        if temporalflag and bboxflag: #both filters applied
            log.debug('results from temporal & bbox filter %s'%self.resultset)
            self.resultset=self._combineresults([set(temporalrangeresults), set(bboxresults)])
        elif temporalflag: #only temporal filter
            self.resultset=temporalrangeresults
            log.debug('results from temporal only filter %s'%self.resultset)
        elif bboxflag: #only bbox filter            
            self.resultset=bboxresults
            log.debug('results from bbox only filter %s'%self.resultset)
            
        log.debug('results from gml filter %s'%self.resultset)
        #TODO, handle null filter                         
            
                
    def _combineresults(self, results):      
        """ combine (AND operation) results from two or more filters """
        baseset=[]
        for set in results:
            if baseset == []:
                baseset = set
            else:
                baseset=baseset.intersection(set)                        
        return baseset