source: MILK/trunk/milk_server/milk_server/controllers/atom_editor/listatom.py @ 4478

'''
 Class representing pylons controller for the listing and searching of atom
 data 
  
 @author: C Byrom, Tessella Sep 2008
'''
from milk_server.lib.base import *
from ndgUtils import ndgObject
from paste.request import parse_querystring
from milk_server.lib.ndgInterface import interface 
from xml.parsers.expat import ExpatError
import logging
from ndgUtils.models.Atom import Atom
from formencode import Schema, validators, Invalid
from genshi.filters import HTMLFormFiller
from genshi import HTML
from ndgUtils import DocumentRetrieve
from ndgUtils.eXistInterface import ndg_eXist
import ndgUtils.models.existdbclient as edc
from ndgUtils.models.MolesEntity import MolesEntity as ME
from ndgUtils.vocabtermdata import VocabTermData as VTD, VocabTermItem as VTI
import milk_server.lib.htmlUtilities as utils
from editatom import EditatomController as ec
from milk_server.lib.atomutilities import savePageAndRender


class ListatomController(BaseController):
    ''' 
    Provides the pylons controller for listing/searching NDG Atom documents.
    '''
    def __setup(self,uri=None):
        ''' Common setup stuff for all the actions on this controller '''
        logging.info("Setting up EditatomController")
        self.cf=request.environ['ndgConfig']
        
        if uri:
            try:
                self.ndgObject = ndgObject(uri, config=self.cf.config)
            except ValueError,e:
                return e

        self.inputs=dict(parse_querystring(request.environ))

        logging.info("EditatomController set up")
        return 0


    def atomHome(self):
        ''' 
        Render a simple home page for the atom editor
        '''
        logging.info("Rendering atom home page")
        c.title = "Atom Editor Home Page"
        return savePageAndRender(self.pathInfo, "atom_editor/atom_home")

    
    def list(self, searchData=None, associatedAtomID=None, \
             associatedAtomType=None, associationType=None):
        ''' 
        Provide a simple search interface to the atoms data 
        - display a filter + display any results + if an atomID is
        provided, allow atoms to be linked to this
        @keyword associatedAtomID: the ID of an atom to which other atoms
        should be linked - via deployments 
        @keyword associatedAtomType: type of atom that the data is being 
        associated with
        @keyword associationType: type of association to be done - NB, use
        the constants in htmlUtilities for these 
        '''
        try:
            inputs = request.params
            c.searchData = None
            if searchData and int(searchData) > 0:
                logging.info("Preparing atom search")
                c.searchData = searchData
                self.__setup()
                atomTypeID = inputs.get('atomTypeID')
                providerID = inputs.get('providerID')
                # NB, avoid page being reloaded in incorrect state - e.g. after
                # browser reload
                if not (atomTypeID and providerID):
                    return self.list()
                    
                atomTypeID = atomTypeID.split('--')[1]
                providerID = providerID.split('--')[1]
                c.results = self.searchAtoms(providerID, atomTypeID, inputs.get('title'))
                
            logging.info("Rendering atom listings page")
            c.errors = {}
            c.title='Browse atoms'
            c.assocAtomType = associatedAtomType
            c.associateLink = ""
            if associatedAtomID:
                c.associateLink = h.url_for(controller='atom_editor/editatom', action='saveAtom', \
                    uri = associatedAtomID, saveLevel = ec.ADD_ASSOCIATIONS)
            c.searchLink = h.url_for(controller = 'atom_editor/listatom', action='list', \
                                     searchData='1', associatedAtomID = associatedAtomID)
            
            c.searchTerm = inputs.get('title')
            
            # set up the drop down content
            # NB, if we are here whilst doing an association, restrict the filter
            # appropriately
            listVals = []
            defaultVal = None
            # set up a default 'all' value
            allVal = VTI(ndg_eXist.DEFAULT_ALL_VAL, ndg_eXist.DEFAULT_ALL_VAL)
            if associationType:
                val = int(associationType)
                if val == utils.GRANULE_ASSOCIATION:
                    c.title += ' - to create associations with granule data'
                    listVals = [g.vtd.TERM_DATA[g.vtd.GRANULE_TERM]]
                elif val == utils.DEPLOYMENT_ASSOCIATION:
                    c.title += ' - to create associations with deployment data'
                    listVals = [g.vtd.TERM_DATA[g.vtd.DEPLOYMENT_TERM]]
                elif val == utils.ENTITY_ASSOCIATION:
                    c.title += ' - to create associations with activity/data production tool/observation station data'
                    listVals = g.vtd.getValidTypes(g.vtd.DEPLOYABLE_ATOM_CATEGORY)
                    defaultVal = allVal
            else:
                listVals = g.vtd.getValidTypes(g.vtd.ATOM_CATEGORY)
                defaultVal = allVal
            
            c.atomTypes = utils.getVocabTermDataDropdown(listVals, \
                                                   defaultVal = defaultVal, \
                                                   selected = inputs.get('atomTypeID'))
            c.providerIDs = utils.getVocabTermDataDropdown(g.vtd.getValidTypes(g.vtd.PROVIDER_CATEGORY), 
                                                     defaultVal = allVal, \
                                                     selected = inputs.get('providerID'))

            return savePageAndRender(self.pathInfo, 'atom_editor/atom_list')

        except Exception, e:
            #we may be showing an xml document ... but it could go wrong if
            #we have crap content ...
            c.xml='Unexpected error loading page [%s]' %str(e)
            c.doc=''
            logging.error(c.xml)
        
        response.status_code = 400
        return render("genshi", 'atom_editor/error')
    
    
    def searchAtoms(self, providerID, atomTypeID, term):
        '''
        Search for atoms with specified filter info
        @param providerID: provider ID of atom or 'all' for all
        @param atomTypeID: type of atom or 'all' for all
        @param term: text to search for in atom
        @return array of dicts with info for each doc found in search
        '''
        logging.info("Search for atoms with the following filter: \
            \nProviderID: '%s'\nAtom Type: '%s'\nText in title: '%s'" \
            %(providerID, atomTypeID, term))
        
        dr = DocumentRetrieve(self.cf.get('NDG_EXIST','local'),
                              pwfile=self.cf.get('NDG_EXIST','passwordFile'))
    
        results = dr.search(term,
                            start=1,
                            howmany=10000, # NB, we want to get back everything!
                            target=ndg_eXist.ATOM_TARGET,
                            providerID = providerID, 
                            atomTypeID = atomTypeID)

        logging.info("Search completed")
        return results