source: MILK/trunk/milk_server/milk_server/controllers/atom_editor/atomeditorcontroller.py @ 4964

'''
 Class representing base pylons controller for the atom editor shared functions
  
 @author: C Byrom, Tessella Dec 2008
'''
import logging, xmlrpclib, cgi, traceback
from ndg.common.src.models.ndgObject import ndgObject
from ndg.common.src.models.Atom import Atom
from ndg.common.src.lib.utilities import escapeSpecialCharacters
from milk_server.lib.base import *
from milk_server.lib.ndgInterface import ndgInterface 
from milk_server.lib import Utilities
from editorconstants import *
from formencode import htmlfill
   
class AtomEditorController(BaseController):
    ''' 
    Provides the pylons controller for shared functions
    '''
    STANDARD_SAVE = 1
    ADD_ASSOCIATIONS = 3
    REMOVE_ASSOCIATIONS = 4

    def _setup(self, uri=None, loadAtom=True):
        ''' 
        Common setup stuff for all the actions on this controller 
        @keyword uri: uri of the atom to set up 
        @keyword loadAtom: if True, load the atom into c.atom, otherwise don't.
        Default is True. 
        '''
        logging.info("Setting up AtomEditorController")
        self.cf=request.environ['ndgConfig']
        self.inputs = self.__getTidyInputs()

        if uri:
            self.ndgObject = ndgObject(uri, config=self.cf)
            if loadAtom:
                self.__prepareDataModel(uri)

        logging.info("AtomEditorController set up")


    def __prepareDataModel(self, uri):
        '''
        Set up the underlying atom data model - loading the bulk from eXist
        then updating any input fields appropriately 
        '''
        logging.info("Preparing underlying data model")
        logging.info("Retrieving document to edit")
        # NB, don't use the cache as docs are likely to change
        # quite a lot during editing; ensure you've always got 
        # the latest updates loaded
        interface = ndgInterface()
        status,x = interface.GetXML(uri, useCache=False)

        if not status:
            code=400
            if x.startswith('<p> Access Denied'):
                code=401

            c.xml='%s'%x
            response.status_code = code
            raise SystemError('Problem experienced retrieving atom doc from eXist')

        # NB, passing in the inputs will overwrite any original values with the
        # user input ones
        if not self.inputs:
            self.inputs = self.__getTidyInputs()

        c.atom = Atom(xmlString=str(x), ndgObject = self.ndgObject, **dict(self.inputs))

        # lookup the atom publication state
        edc = Utilities.getExistClient(c.atom.ME.providerID)
        c.atom.state = edc.getAtomPublicationState(c.atom.datasetID, 
                                                   c.atom.ME.providerID)        
        # save the current atom - to avoid this needing be recreated by the 
        # asynch viewAssociatedData call
        session['currentAtom'] = c.atom
        session.save()
        logging.info("Data model set up")


    def __getTidyInputs(self):
        '''
        The inputs can be used generically to specify atom attributes - however
        some inputs should not be set against the Atom object since they use slots
        so cannot be pickled - which means saving the atom in the session with fail.
        This method clears out any unwanted inputs
        '''
        logging.debug("Getting pickleable input data")
        inputs = request.params
        tidyInputs = {}
        for key, val in inputs.items():
            if not isinstance(val, cgi.FieldStorage):
                tidyInputs[key] = val

        logging.debug("Pickleable data extracted")
        return tidyInputs


    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.debugAtomEditor == '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='atom_editor/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)


    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 (%s) - to keep track of atom editor state" \
                      %self.pathInfo)
        session['currentEditor'] = self.pathInfo
        session.save()
        logging.debug("Now rendering current template (%s)" %template)
        html = render("genshi", template)
        # 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)