source: MILK/trunk/milk_server/milk_server/controllers/home.py @ 5314

'''
 Base controller for MILK controllers, providing common functionality - including
 fall back index method, to render a home page for the service depending on what
 mode it is running in - NB, if multiple modes are enabled, the order of preference,
 from highest to lowest, is editor, discovery, browser 
 
 @author: C Byrom, Tessella Apr 2009
'''
import logging, traceback, xmlrpclib
from formencode import htmlfill
from milk_server.lib.base import *
from ndg.common.src.lib.utilities import escapeSpecialCharacters
from ndg.common.src.models.vocabtermdata import VocabTermData as VTD

class HomeController(BaseController):
    ''' 
    Sets up appropriate home page for fall through urls
    '''
    def index(self):
        '''
        Redirect to the appropriate home page - or display error
        '''
        if g.atomEditorEnabled:
            h.redirect_to(h.url_for('atomHome'))
        elif g.discoveryEnabled:
            h.redirect_to(h.url_for('discovery'))
        elif g.browseEnabled:
            h.redirect_to(h.url_for('browseHome'))
        else:
            c.title = "No service enabled"
            c.xml = "The server should be configured to provide one or more of the followings client services: editor, discovery or browse."
            return render("genshi", 'error')
            

    def savePageAndRender(self, template, **inputs):
        '''
        Save the current path info - to provide a memory function when changing
        tabs + render the given template with the specified inputs filled in
        automatically
        @param template: name of template to render
        @param inputs: dict of inputs with keynames matching input names in template
        form  
        '''
        logging.debug("Saving current page url - to keep track of atom editor state")
        if hasattr(self, 'pathInfo'):
            logging.debug(" - page: %s" %self.pathInfo)
            session['currentEditor'] = self.pathInfo
            session.save()
            
        logging.debug("Now rendering current template (%s)" %template)
        try:
            html = render("genshi", template)
            # replace any browse links with to links to editor
            html = html.replace(VTD.BROWSE_SERVER_URL, g.server)

            # NB, need html in unicode for for htmlfill.render
            html = unicode(html, 'utf-8', 'xmlcharrefreplace')
            for key, val in inputs.items():
                inputs[key] = str(val)
    
            return htmlfill.render(html, inputs, errors = c.errors)

        except Exception, e:
            c.xml = 'Unexpected error [%s] whilst rendering page' %str(e)
            if str(e).find('malformed start tag') >-1:
                c.xml += " - NB, this is probably due to illegal HTML being entered"
            c.doc = ''
            response.status_code = 400
            logging.error(c.xml)
            return render('error')


    def _unpackErrors(self, e):
        '''
        Add exception errors to the common error structures - for use
        in templates
        @param e: Exception to add
        @return errors: dict of errors
        '''
        if not c.errors:
            c.errors = {}

        errorMessage = e.message
        if g.debugModeOn == 'True':
            errorMessage = traceback.format_exc()

        c.xml = escapeSpecialCharacters('Unexpected error loading page [%s]' \
                                        %str(errorMessage))
        c.doc = ''
        
        # unpack errors, if possible - NB, the c.errors value is used by the template
        # function, displayErrors, which is used by most of the editor templates
        if isinstance(e, xmlrpclib.Fault):
            # strip out the exception type - NB, this is usually native library code
            # and is of no real interest - and will just confuse viewers
            c.errors['Unexpected error'] = e.faultString.split(':')[-1] 

        if hasattr(e, 'unpack_errors'):
            c.errors.update(e.unpack_errors())
            
        else:
            c.errors['Unexpected error'] = [c.xml]

        # tidy up errors - escaping any xml tags, if necessary
        for key, errors in c.errors.items():
            newErrors = []
            for error in errors:
                for err in error.split('<br/>'):
                    newErrors.append(escapeSpecialCharacters(err))
            c.errors[key] = newErrors
        
        return c.errors


    def _handleError(self, e, template='error'):
        '''
        Handle exceptions thrown; if debug mode on, display full stack trace
        in output, otherwise just show basic error message in error template
        @param e: Exception to process
        @keyword template: template to render - 'error' is the default - NB, if
        an alternative is specified it should have a div with class set to 'error'
        containing the variable, c.xml to display properly 
        '''
        self._unpackErrors(e)
        logging.error(c.xml)
        response.status_code = 400
        return render("genshi", template)