source: TI05-delivery/ows_framework/trunk/ows_server/ows_server/lib/base.py @ 4066

# Copyright (C) 2007 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
#
"""
 Base controller providing generic functionality and extended by most other controllers
"""
from pylons import c, g, cache, request, session, response
from pylons.controllers import WSGIController
from pylons.decorators import jsonify, validate
from pylons.templating import render
from pylons.controllers.util import abort, redirect_to, etag_cache
from pylons.i18n import N_, _, ungettext
from paste.request import construct_url
import ows_server.models as model
import ows_server.lib.helpers as h
from ows_common import exceptions as OWS_E
from ows_common.operations_metadata import OperationsMetadata, Operation, RequestMethod
from ows_common.get_capabilities import ServiceMetadata
import ows_common.xml

# NDG Security import enables Single Sign On capability but note this is not
# required for a standalone discovery service deployment
try:
    from ndg.security.client.ssoclient.ssoclient.lib.base import \
        BaseController as _BaseController
except ImportError, e:
    from warnings import warn
    warn('%s: ndg.security.client unavailable - ' % __name__ + \
         'Single Sign on functionality disabled: %s' % e,
         RuntimeWarning)

    # Extend BaseController from WSGIController instead
    _BaseController = WSGIController

 
try:
    from xml.etree import ElementTree as ET
except ImportError:
    from elementtree import ElementTree as ET

import logging
logger = logging.getLogger(__name__)

# Configure
EXCEPTION_TYPE = request.environ['ndgConfig'].get('OWS_SERVER', 'exception_type', 'ogc').lower()

class BaseController(_BaseController):
    
    def __call__(self, environ, start_response):        
        # Insert any code to be run per request here. The Routes match
        # is under environ['pylons.routes_dict'] should you want to check
        # the action or route vars here

        logger.debug("BaseController.__call__ ...")        
                
        #organise the information needed by pagetabs ... 
        # TODO avoid this for the server controllers ...
        c.pageTabs=[('Search',g.discoveryURL)]
        if 'results' in session: 
            c.pageTabs.append(('Results',session['results']))
            # make selections tab available once results are shown - to simplify associated business logic
            c.pageTabs.append(('Selections',h.url_for(controller='selectedItems',action='index')))
            
        if 'lastViewed' in session: c.pageTabs.append(('Details',session['lastViewed']))
        
        if 'viewItems' in session: c.pageTabs.append(('View', h.url_for(controller='viewItems',action='index')))
        
        return _BaseController.__call__(self, environ, start_response)
    
class OwsController(BaseController):
    def __call__(self, environ, start_response):

        # All OWS parameter names are case insensitive.
        req = request._current_obj()
        self.ows_params = {}
        for k in req.params:
            self.ows_params[k.lower()] = req.params[k]        

        # If the EXCEPTION_TYPE is 'pylons' let Pylons catch any exceptions.
        # Otherwise send an OGC exception report for any OWS_E.OwsError
        if 'pylons' in EXCEPTION_TYPE:
            self._fixOwsAction(environ)
            return super(OwsController, self).__call__(environ, start_response)
        else:
            try:
                self._fixOwsAction(environ)
                return super(OwsController, self).__call__(environ, start_response)
            except OWS_E.OwsError, e:
                logger.exception(e)
                start_response('400 Bad Request',[('Content-type','text/xml')])
#                response.headers['content-type'] = 'text/xml'
                return render('exception_report', report=e.report, format='xml')


    def _fixOwsAction(self, environ):
        # Override the Routes action from the request query parameter
        try:
            action = self.ows_params['request']
        except KeyError:
            raise OWS_E.MissingParameterValue('REQUEST parameter not specified', 'REQUEST')

        # Check action is a method in self
        if not getattr(self, action):
            raise OWS_E.InvalidParameterValue('request=%s not supported' % action, 'REQUEST')

        # override routes action with request
        environ['pylons.routes_dict']['action'] = action
        del self.ows_params['request']

    def _loadCapabilities(self):
        """
        creates an ows_common.get_capabilities.ServiceMetadata object
        by consulting the paste configuration and annotations in the
        controller definition.

        """
        # Deduce ows_endpoint from routes
        ows_endpoint = h.url_for(controller=request.environ['pylons.routes_dict']['controller'])
        
        #Deduce base_url from config
        base_url =request.environ['ndgConfig'].get('DEFAULT','server')

        
        # Get the server-level configuration data from an XML file
        config = request.environ['paste.config']
        sm_tree = ET.parse(config['ows_common_config'])
        sm = ows_common.xml.service_metadata(sm_tree.getroot())
        
        # Extract service-level parameters and constraint
        parameters = getattr(self, '_ows_parameters', {})
        constraints = getattr(self, '_ows_constraints', {})
        versions = getattr(self, '_ows_versions', [])
        
        # Extract operation-level parameters and constraints
        od = {}
        for attr in dir(self):
            op = getattr(self, attr)
            if hasattr(op, '_ows_name'):
                p = getattr(op, '_ows_parameters', {})
                c = getattr(op, '_ows_constraints', {})
                od[op._ows_name] = Operation(get=RequestMethod(href=base_url+ows_endpoint),
                                             post=None,
                                             parameters=p,
                                             constraints=c,
                                             name=op._ows_name)
        
        sm.operationsMetadata = OperationsMetadata(od, constraints, parameters)
        sm.serviceIdentification.serviceTypeVersions = versions
        return sm

    def _renderCapabilities(self, template='ows/get_capabilities'):
        """
        The standard way of returning a Capabilities document.

        Each subclass should implement self._load_capabilities() and call
        this method to return a response object.

        """
        c.service_metadata = self._loadCapabilities()        
        response.headers['content-type'] = 'text/xml'
        return render(template, format='xml')


# Include the '_' function in the public names
__all__ = [__name for __name in locals().keys() if not __name.startswith('_') \
           or __name == '_']