source: cows/trunk/cows/pylons/wfs_controller.py @ 4298

"""
WFS controller for OGC Web Services (OWS).

@author: Dominic Lowe
"""

import re
from cStringIO import StringIO
from sets import Set
from matplotlib.cm import get_cmap
from pylons import request, response, c, config
import ConfigParser

import logging
log = logging.getLogger(__name__)

import Image

from cows.model.wfs import WfsFeatureSummary
from cows.model.filterencoding import FEQuery, FEQueryProcessor
from cows.model import PossibleValues, WGS84BoundingBox, BoundingBox, Contents
from cows.pylons import ows_controller
from cows.exceptions import *
from cows import bbox_util

class WFSController(ows_controller.OWSController):
    """
    Subclass this controller in a pylons application and set the layerMapper
    class attribute to implement a WFS. Each layer can be mapped to a Feature for the WFS.

    @cvar layerMapper: an cows.service.wxs_iface.ILayerMapper object. 
    

    """
    layerMapper = None
    _layerSlabCache = {}

    #-------------------------------------------------------------------------
    # Attributes required by OWSController

    service = 'WFS'
    owsOperations = (ows_controller.OWSController.owsOperations + ['DescribeFeatureType', 'GetFeature'])
    validVersions = ['1.1.0']

    #-------------------------------------------------------------------------

    def __before__(self, **kwargs):
        """
        This default implementation of __before__() will pass all routes
        arguments to the layer mapper to retrieve a list of layers for
        this WFS.

        It will be called automatically by pylons before each action method.


        """
        log.debug('loading layers')
        self.layers, self.featureset = self.layerMapper.map(**kwargs)
        log.debug('Feature instances %s'%self.featureset.featureinstances)
    
        #-------------------------------------------------------------------------
        # Methods implementing stubs in OWSController

    def _renderCapabilities(self, version, format):
        """
        Renders capabilities document.
        """
        if version == '1.1.0':
            t = ows_controller.templateLoader.load('wfs_capabilities_1_1_0.xml')
        else:
            # We should never get here!  The framework should raise an exception before now.
            raise RuntimeError("Version %s not supported" % version)
        
        return t.generate(c=c).render()

    def _loadCapabilities(self):
        """
        @note: Assumes self.layers has already been created by __before__().
        Builds capabilities document.

        """
        log.info('Loading WFS Capabilites')
        
        ows_controller.addOperation('GetFeature')
        ows_controller.addOperation('DescribeFeature')
        
        
        featureInfoFormats = Set()

        log.debug('Loading capabilities contents')
        c.capabilities.contents = Contents()
        
        
        ftlist={}
        #        
        
        for layerName, layer in self.layers.items():
            log.info('Loading layer %s' % layerName)
#            log.info('feature type %s'%layer._feature)

            wgs84BBox = WGS84BoundingBox(layer.wgs84BBox[:2],
                                         layer.wgs84BBox[2:])
            
            ds = WfsFeatureSummary(keywords=layer.keywords, 
                                   outputformats=layer.outputformats, 
                                   identifier=layerName,
                                   titles=[layer.title],
                                   abstracts=[layer.abstract],                                   
                                   wgs84BoundingBoxes=[wgs84BBox])

            c.capabilities.contents.datasetSummaries.append(ds)

    def _getSchema(self, typename):
        namespace = typename.split(':')[0]
        schemalocation = conf
        
    def _parsetypename(self, typename):
        """ parse feature type name into schema and name"""       
        if typename not in self.layers.keys():
            raise InvalidParameterValue('Invalid typename parameter: %s. Typename must consist of namespace and featuretype separated with a colon, as displayed in the GetCapabilities response.'%typename, 'typename')
    
        namespace, ft = typename.split(':')
        wfsconfiglocation=config['wfsconfig']
        wfscfg = ConfigParser.ConfigParser()
        wfscfg.read(wfsconfiglocation)      
        xmlschema=open(wfscfg.get('application_schemas', namespace)).read()      
        log.debug('location of application schema %s' %(xmlschema))
        return xmlschema

                
    def DescribeFeatureType(self):
        """ DescribeFeatureType """
        version = self.getOwsParam('version', default=self.validVersions[0])
        if version not in self.validVersions:
            raise InvalidParameterValue('Version %s not supported' % version,
                                        'version')
        typename=self.getOwsParam('typename')
        ftschema =self._parsetypename(typename)
        log.debug(self.layers.items())       
               
        outputformat=self.getOwsParam('outputformat', default='text/xml')
        
        #temporarily returns entire schema
        #TODO: return single featuretype definition
        msg  = ftschema
        response.headers['content-type'] = 'text/xml'
        return msg
  
    def GetFeature(self):
        """ GetFeature request
        """
        #TODO QUERY model
        version = self.getOwsParam('version', default=self.validVersions[0])
        if version not in self.validVersions:
            raise InvalidParameterValue('Version %s not supported' % version,
                                        'version')

        #Parse the query to analyse the filters it contains
        query=FEQuery(self.getOwsParam('query'))
        filters=query.getFilters()
        
        #now apply the filters to the featureset
        qp=FEQueryProcessor(self.featureset, filters)
        #TODO: Group resultset together in a wfs feature collection (use template)
#        return qp.resultset
        c.resultset=qp.resultset
        response.headers['content-type'] = 'text/xml'
        t = ows_controller.templateLoader.load('wfs_featurecollection.xml')
        return t.generate(c=c).render()            


#        featureid=self.getOwsParam('featureid')
#        #TODO populate self.featureinstances!
#        feature=self.featureset.featureinstances[featureid]    
#        response.headers['content-type'] = 'text/xml'
#        return feature.toGML()
#