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

import urllib
from urlparse import urlsplit, urlunsplit
from base64 import urlsafe_b64encode
from pylons import Response, c, g, cache, request, session
from pylons.controllers import WSGIController
from pylons.decorators import jsonify, validate
from pylons.templating import render, render_response
from pylons.helpers 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_server.lib.security_util import setSecuritySession, LoginServiceQuery
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


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(WSGIController):
    
    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__ ...")
        
        # construct URL picking up setting of server name from config to 
        # avoid exposing absolute URL hidden behind mod_proxy see #857 
        # Also, avoid returning to getCredentials and potentially exposing
        # username/pass-phrase on URL.
        # TODO: rework getCredentials get-out for more modular solution
        pathInfo = urllib.quote(environ.get('PATH_INFO', '')) 
        if 'getCredentials' in pathInfo:
            logger.debug(\
                "Reverting request URL from getCredentials to discovery...")
            c.requestURL = g.server + '/discovery'       
        else:
            c.requestURL = g.server + pathInfo
            query='&'.join(["%s=%s"%item for item in request.params.items()])
            if query:
                c.requestURL += '?' + query
        
        # Base 64 encode to enable passing around in 'r' argument of query
        # string for use with login/logout
        c.b64encRequestURL = urlsafe_b64encode(c.requestURL)

        if 'h' in request.params:
            # 'h' corresponds to the setting of a session manager host i.e.
            # the request has come from a completed login from the login 
            # service
            logger.debug("Setting security session from URL query args ...")
            
            # Copy the query arguments into security session keys
            setSecuritySession()
            
            if 'panelView' not in session:
                session['panelView']='History'
            session.save()
            
            # Re-construct the URL removing the security related arguments
            qs = LoginServiceQuery.stripFromURI()

            logger.debug('Switching from https to http...')
            cc = g.server + urllib.quote(environ.get('PATH_INFO',''))
            if qs:
                cc += "?" + qs
                
            logger.debug('URL transport switched to http: "%s"' % cc)
            h.redirect_to(cc)

                
        #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']))
        if 'lastViewed' in session: c.pageTabs.append(('Display',session['lastViewed']))
        
        if 'selection' in session:
            c.pageTabs.append(('Selections',h.url_for(controller='selection',action='index')))
            c.pageTabs.append(('Visualise',h.url_for(controller='visualise', action='index')))
            c.pageTabs.append(('Download','Blah'))

        return WSGIController.__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)

                r=render_response('exception_report', report=e.report, format='xml')
                r.headers['content-type'] = 'text/xml'
                return r


    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()        
        r = render_response(template, format='xml')
        r.headers['content-type'] = 'text/xml'
        return r


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