Changeset 4724


Ignore:
Timestamp:
05/01/09 09:51:50 (11 years ago)
Author:
cbyrom
Message:

Restructure atom editor controllers - pulling out parent superclass
to allow re-use of shared code + use new routes names + add new method
to handle drop down setting up.

Location:
MILK/trunk/milk_server/milk_server
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed
  • MILK/trunk/milk_server/milk_server/config/milkMiddleware.py

    r4625 r4724  
    161161        # extend the granulite example link - to add a valid location 
    162162        g.example_granulite = g.example_granulite.replace('HREF', \ 
    163             h.url_for(controller = 'atom_editor/listatom', \ 
    164                       action='showExampleGranulite')) 
     163            h.url_for('example')) 
    165164         
    166165         
  • MILK/trunk/milk_server/milk_server/controllers/atom_editor/editatom.py

    r4697 r4724  
    55 @author: C Byrom, Tessella Sep 2008 
    66''' 
    7 import logging, traceback, sys, cgi, xmlrpclib 
    8 from paste.request import parse_querystring 
     7import logging, traceback, sys, cgi 
    98from xml.parsers.expat import ExpatError 
    109from formencode import Invalid 
     
    1413from milk_server.models.form import * 
    1514from milk_server.lib import mailer 
    16 from milk_server.lib.ndgInterface import ndgInterface  
    1715import milk_server.lib.htmlUtilities as utils 
    18 from milk_server.lib.atomutilities import savePageAndRender 
    19 from ndgUtils import ndgObject 
    2016from ndgUtils.models.Atom import Atom, Person, Link, Category 
    21 from ndgUtils.eXistConnector import eXistConnector 
    2217from ndgUtils.lib.atomvalidator import ValidationError 
    2318import ndgUtils.lib.existdbclient as edc 
     
    2722from ndgUtils.lib.granulite import granulite 
    2823from editorconstants import * 
    29  
    30 class EditatomController(BaseController): 
     24from atomeditorcontroller import AtomEditorController 
     25 
     26class EditatomController(AtomEditorController): 
    3127    '''  
    3228    Provides the pylons controller for editing NDG Atom documents. 
    3329    ''' 
    34     ADD_ASSOCIATIONS = 3 
    35     REMOVE_ASSOCIATIONS = 4 
    36      
    37     def __setup(self,uri=None): 
    38         ''' Common setup stuff for all the actions on this controller ''' 
    39         logging.info("Setting up EditatomController") 
    40         self.cf=request.environ['ndgConfig'] 
    41  
    42         if uri: 
    43             try: 
    44                 self.ndgObject = ndgObject(uri, config=self.cf) 
    45             except ValueError,e: 
    46                 return e 
    47  
    48         self.inputs=dict(parse_querystring(request.environ)) 
    49  
    50         logging.info("EditatomController set up") 
    51         return 0 
    52  
    53  
    54     def __unpackErrors(self, e): 
    55         ''' 
    56         Add exception errors to the common error structures - for use 
    57         in templates 
    58         @param e: Exception to add 
    59         ''' 
    60         errorMessage = e.message 
    61         if g.debugAtomEditor: 
    62             errorMessage = traceback.format_exc() 
    63  
    64         c.xml = escapeSpecialCharacters('Unexpected error loading page [%s]' \ 
    65                                         %str(errorMessage)) 
    66         c.doc = '' 
    67          
    68         # unpack errors, if possible - NB, the c.errors value is used by the template 
    69         # function, displayErrors, which is used by most of the editor templates 
    70         if isinstance(e, xmlrpclib.Fault): 
    71             # strip out the exception type - NB, this is usually native library code 
    72             # and is of no real interest - and will just confuse viewers 
    73             c.errors['Unexpected error'] = e.faultString.split(':')[-1]  
    74         if hasattr(e, 'unpack_errors'): 
    75             c.errors.update(e.unpack_errors()) 
    76              
    77         else: 
    78             c.errors['Unexpected error'] = [c.xml] 
    79  
    80         # tidy up errors - escaping any xml tags, if necessary 
    81         for key, errors in c.errors.items(): 
    82             newErrors = [] 
    83             for error in errors: 
    84                 for err in error.split('<br/>'): 
    85                     newErrors.append(escapeSpecialCharacters(err)) 
    86             c.errors[key] = newErrors 
    87  
    88  
    89     def __handleError(self, e, template='atom_editor/error'): 
    90         ''' 
    91         Handle exceptions thrown; if debug mode on, display full stack trace 
    92         in output, otherwise just show basic error message in error template 
    93         @param e: Exception to process 
    94         @keyword template: template to render - 'error' is the default - NB, if 
    95         an alternative is specified it should have a div with class set to 'error' 
    96         containing the variable, c.xml to display properly  
    97         ''' 
    98         self.__unpackErrors(e) 
    99         logging.error(c.xml) 
    100         response.status_code = 400 
    101         return render("genshi", template) 
    102  
    103      
    10430    def upload(self, uri): 
    10531        ''' 
     
    11036        ''' 
    11137        logging.info("Uploading file...") 
    112         self.__setup(uri=uri) 
    113         inputs = self.__getTidyInputs() 
     38        self._setup(uri=uri) 
    11439         
    11540        granFile = request.POST.get('upload_granulite') 
     
    11742         
    11843        # check whether we can replace existing atoms 
    119         replaceAtom = inputs.get('replaceAtom') 
     44        replaceAtom = self.inputs.get('replaceAtom') 
    12045         
    12146        # NB, need to turn from string to boolean - there doesn't seem a reliable 
     
    14671            logging.info("Validating inputs") 
    14772            validator = LoadGranuliteFormSchema() 
    148             validator.to_python(inputs) 
     73            validator.to_python(self.inputs) 
    14974            logging.info("- inputs valid") 
    15075             
    15176            useCSMLID = True 
    152             c.atom = None 
    15377            if uri: 
    154                 self.prepareDataModel(uri) 
    15578                useCSMLID = False 
    15679 
     
    17194                # data or just the CSML/CDML data 
    17295                # NB, we'll be creating the atom in the default local eXist 
    173                 eXistClient = self.__getExistClient('local') 
     96                eXistClient = self._getExistClient('local') 
    17497                gran = granulite(fileContents, granuleAtom = c.atom, \ 
    17598                                 eXistClient = eXistClient, \ 
    17699                                 csmlOrCdmlFile = csmlOrCdmlFile, \ 
    177                                  timeAxis = inputs.get('timeAxis'), \ 
    178                                  datasetID = inputs.get('datasetID'), \ 
     100                                 timeAxis = self.inputs.get('timeAxis'), \ 
     101                                 datasetID = self.inputs.get('datasetID'), \ 
    179102                                 useCSMLID = useCSMLID, \ 
    180103                                 replaceAtom = replaceAtom) 
     
    192115 
    193116                        # Now set up the ndgObject with the created atom's vals 
    194                         self.__setup(uri=c.atom.ndgURI) 
     117                        self._setup(uri=c.atom.ndgURI, loadAtom = False) 
    195118                        c.atom.ndgObject = self.ndgObject 
    196119                    except edc.DuplicateError, e: 
     
    227150        except Exception, e: 
    228151            c.errors['WARNING'] = ['Error loading data: the displayed data will not be saved - please fix problem and retry'] 
    229             self.__unpackErrors(e) 
     152            self._unpackErrors(e) 
    230153        except SystemExit, ee: 
    231154            # NB, some of the CSML libraries just sys.exit on problems - catch errors here 
    232155            c.errors['ERROR'] = ['Problem encountered whilst transforming the CDML data into CSML'] 
    233             self.__unpackErrors(ee) 
     156            self._unpackErrors(ee) 
    234157 
    235158        if c.atom and hasattr(c.atom, 'ndgURI'): 
    236159            self.pathInfo = self.pathInfo.replace('upload', 'editAtom') 
    237             return self.edit(c.atom.ndgURI) 
     160 
     161            h.redirect_to(h.url_for('edit', uri = c.atom.ndgURI))             
    238162        elif uri: 
    239163            # something has gone wrong here... 
    240164            return render("genshi", 'atom_editor/error') 
    241165        else: 
    242             return self.createGranule(**inputs) 
    243  
    244  
    245     def __getTidyInputs(self): 
    246         ''' 
    247         The inputs can be used generically to specify atom attributes - however 
    248         some inputs should not be set against the Atom object since they use slots 
    249         so cannot be pickled - which means saving the atom in the session with fail. 
    250         This method clears out any unwanted inputs 
    251         ''' 
    252         logging.debug("Getting pickleable input data") 
    253         inputs = request.params 
    254         tidyInputs = {} 
    255         for key, val in inputs.items(): 
    256             if not isinstance(val, cgi.FieldStorage): 
    257                 tidyInputs[key] = val 
    258         logging.debug("Pickleable data extracted") 
    259         return tidyInputs 
     166            return self.createGranule(**self.inputs) 
    260167 
    261168     
     
    269176        c.errors = {} 
    270177        try: 
    271             self.prepareDataModel(uri) 
    272         except SystemError, e: 
    273             return self.__handleError(e) 
    274          
    275         inputs = request.params 
    276  
     178            self._setup(uri) 
     179        except Exception, e: 
     180            return self._handleError(e) 
     181         
    277182        # save atom association changes 
    278183        if int(saveLevel) == self.ADD_ASSOCIATIONS: 
    279             atomLinks = self.extractAtomAssociations(inputs) 
     184            atomLinks = self.extractAtomAssociations(self.inputs) 
    280185            c.atom.addUniqueRelatedLinks(atomLinks) 
    281186        elif int(saveLevel) == self.REMOVE_ASSOCIATIONS: 
    282             atomLinks = self.extractAtomAssociations(inputs) 
     187            atomLinks = self.extractAtomAssociations(self.inputs) 
    283188            c.atom.removeRelatedLinks(atomLinks) 
    284189        else: 
    285             authors = self.extractAuthorDetails(inputs) 
     190            authors = self.extractAuthorDetails(self.inputs) 
    286191            c.atom.addAuthors(authors) 
    287192     
    288             onlineRefs = self.extractOnlineReferenceDetails(inputs) 
     193            onlineRefs = self.extractOnlineReferenceDetails(self.inputs) 
    289194            c.atom.addOnlineReferences(onlineRefs) 
    290195 
    291             params = self.extractParameterDetails(inputs) 
     196            params = self.extractParameterDetails(self.inputs) 
    292197            # NB, the atom type and subtype are added to the categories when the 
    293198            # atom is exported to XML - so don't need to worry about overwriting 
     
    295200            c.atom.parameters = params 
    296201             
    297             if inputs.get('subtype'): 
     202            if self.inputs.get('subtype'): 
    298203                c.atom.subtype = self.getLatestTermURLFromDropDownInput( \ 
    299                         inputs.get('subtype')) 
     204                        self.inputs.get('subtype')) 
    300205                c.atom.subtypeID = c.atom.subtype.split('/')[-1] 
    301206 
     
    308213            self.saveAtomToExist(c.atom) 
    309214        except Exception, e: 
    310             self.__unpackErrors(e) 
     215            self._unpackErrors(e) 
    311216            logging.info("- input invalid") 
    312217            return self.edit(uri) 
     
    314219        # now do redirection - NB, this ensures that current atom contents are 
    315220        # reloaded and displayed 
    316         h.redirect_to(controller = 'atom_editor/editatom', action='edit', \ 
    317                         uri = c.atom.ndgURI) 
    318  
    319  
    320     def prepareDataModel(self, uri): 
    321         ''' 
    322         Set up the underlying atom data model - loading the bulk from eXist 
    323         then updating any input fields appropriately  
    324         ''' 
    325         logging.info("Preparing underlying data model") 
    326         status=self.__setup(uri=uri) 
    327         if status: 
    328             c.xml='<p>%s</p>'%status  
    329             response.status_code = 400 
    330             raise SystemError('Problem experienced setting up data model') 
    331  
    332         logging.info("Retrieving document to edit") 
    333         # NB, don't use the cache as docs are likely to change 
    334         # quite a lot during editing; ensure you've always got  
    335         # the latest updates loaded 
    336         interface = ndgInterface() 
    337         status,x = interface.GetXML(uri, useCache=False) 
    338  
    339         if not status: 
    340             code=400 
    341             if x.startswith('<p> Access Denied'): 
    342                 code=401 
    343  
    344             c.xml='%s'%x 
    345             response.status_code = code 
    346             raise SystemError('Problem experienced retrieving atom doc from eXist') 
    347  
    348         # NB, passing in the inputs will overwrite any original values with the 
    349         # user input ones 
    350         inputs = self.__getTidyInputs() 
    351          
    352         c.atom = Atom(xmlString=str(x), ndgObject = self.ndgObject, **dict(inputs)) 
    353          
    354         # save the current atom - to avoid this needing be recreated by the  
    355         # asynch viewAssociatedData call 
    356         session['currentAtom'] = c.atom 
    357         session.save() 
    358         logging.info("Data model set up") 
     221        h.redirect_to(h.url_for(controller = 'atom_editor/editatom', action='edit', \ 
     222                        uri = c.atom.ndgURI)) 
    359223 
    360224 
     
    370234        # - in this case keep original data 
    371235        if not c.atom: 
    372             self.prepareDataModel(uri) 
     236            self._setup(uri) 
    373237             
    374238        c.title= EDIT_TITLE %c.atom.ndgURI 
    375239        c.uri = c.atom.ndgURI 
    376240         
    377         c.saveLink = h.url_for(controller='atom_editor/editatom',action='saveAtom', \ 
    378                                saveLevel='1',  uri = c.atom.ndgURI) 
    379         c.saveLink2 = h.url_for(controller='atom_editor/editatom',action='saveAtom', saveLevel='2') 
    380         c.saveAssoc = h.url_for(controller='atom_editor/editatom',action='saveAtom', \ 
    381                                  saveLevel = self.REMOVE_ASSOCIATIONS) 
    382         c.deploymentsURL = h.url_for(controller='browse/retrieve', \ 
    383                                      action='viewAssociatedData', \ 
    384                                      type = VTD.DEPLOYMENT_TERM, \ 
     241        c.saveLink = h.url_for('save', saveLevel = self.STANDARD_SAVE, uri = c.atom.ndgURI) 
     242        c.saveAssoc = h.url_for('save', saveLevel = self.REMOVE_ASSOCIATIONS, uri = c.atom.ndgURI) 
     243        c.deploymentsURL = h.url_for('view', type = VTD.DEPLOYMENT_TERM, \ 
    385244                                     uri = c.atom.ndgURI) 
    386         c.dataEntitiesURL = h.url_for(controller='browse/retrieve', \ 
    387                                      action='viewAssociatedData', \ 
    388                                      type = VTD.DE_TERM, \ 
     245        c.dataEntitiesURL = h.url_for('view', type = VTD.DE_TERM, \ 
    389246                                     uri = c.atom.ndgURI) 
    390247         
     
    395252            atomType = g.vtd.DEPLOYMENT_TERM 
    396253         
    397         c.addEntityLink = h.url_for(controller='atom_editor/listatom',action='list', searchData = '0', \ 
     254        c.addEntityLink = h.url_for('list', searchData = '0', \ 
    398255                               associatedAtomID = c.atom.ndgURI, \ 
    399256                               associatedAtomType = atomType,  
    400257                               associationType = utils.ENTITY_ASSOCIATION) 
    401258             
    402         c.addGranuleLink = h.url_for(controller='atom_editor/listatom',action='list', searchData = '0', \ 
     259        c.addGranuleLink = h.url_for('list', searchData = '0', \ 
    403260                               associatedAtomID = c.atom.ndgURI, \ 
    404261                               associatedAtomType = atomType,  
    405262                               associationType = utils.GRANULE_ASSOCIATION) 
    406263             
    407         c.addDeploymentLink = h.url_for(controller='atom_editor/listatom',action='list', searchData = '0', \ 
     264        c.addDeploymentLink = h.url_for('list', searchData = '0', \ 
    408265                               associatedAtomID = c.atom.ndgURI, \ 
    409266                               associatedAtomType = atomType,  
     
    417274        c.subTypes = utils.getVocabTermDataDropdown(listVals, \ 
    418275                                        selected=c.atom.subtype) 
    419          
     276        self.__setDropDownSelectVal('subtype', c.atom.subtype, listVals) 
    420277        self.addRelatedLinksDropDowns() 
     278 
     279 
     280    def __setDropDownSelectVal(self, name, val, vtds): 
     281        ''' 
     282        Given a list of vocab terms, with the name of a 'select' tag and the selected 
     283        value, set the proper value in the inputs dict to allow htmlfill to correctly 
     284        display the list 
     285        @param name: name of select element to set the select value of 
     286        @param val: value of the selected item - NB, this need not be the current vocab 
     287        term url - but should start with the main stem and end with the termID 
     288        @param vtds: list of vocab term definition objects 
     289        ''' 
     290        if not val: 
     291            return 
     292        for vtd in vtds: 
     293            if val.endswith(vtd.termID) and \ 
     294                val.startswith(vtd.vocabURL): 
     295                self.inputs[name] = utils.getVocabTermDataSelectValue(vtd) 
     296                return 
     297             
    421298 
    422299 
     
    430307            try: 
    431308                logging.info("Deleting atom, '%s'" %uri) 
    432                 self.prepareDataModel(uri) 
    433                 eXistClient = self.__getExistClient('local') 
     309                self._setup(uri) 
     310                eXistClient = self._getExistClient('local') 
    434311                gran = granulite(None, granuleAtom = c.atom, \ 
    435312                                 eXistClient = eXistClient, \ 
     
    437314     
    438315                gran.deleteGranuleAndDEReferences() 
    439                 raise Exception('blah') 
    440316                c.deleteResult = "Atom deleted successfully." 
    441317                logging.info("- atom deleted") 
     
    451327    def edit(self, uri): 
    452328        '''  
    453         Edit the specified uri 
     329        Edit the atom with the specified ndg uri 
    454330        ''' 
    455331        logging.info("Setting up atom edit template") 
    456332        try: 
    457333            self.prepareEditForm(uri) 
    458             return savePageAndRender(self.pathInfo, "atom_editor/atom_editor") 
     334             
     335            # NB, there appears to be a bug in htmlfill which automagically 
     336            # clears out content from textarea - so need to set the content  
     337            # explicitly for htmlfill to use 
     338            self.inputs['Content'] = c.atom.Content 
     339            self.inputs['Summary'] = c.atom.Summary 
     340            return self.savePageAndRender("atom_editor/atom_editor", **self.inputs) 
    459341         
    460342        except ExpatError, e: 
     
    463345            logging.error("Error retrieving [%s] - XML content: %s" % (uri, e)) 
    464346        except SystemError, e: 
    465             return self.__handleError(e) 
     347            return self._handleError(e) 
    466348        except Exception, e: 
    467349            errorMessage = traceback.format_exc() 
     
    481363        # values 
    482364        logging.debug("Setting up drop down lists for related links") 
    483         c.relatedLinkTerms = utils.getVocabTermDataDropdown(\ 
    484                 g.vtd.getValidTypes(g.vtd.ONLINE_REF_CATEGORY)) 
    485          
    486         c.relatedLinkSelectedLists = {} 
    487         for link in c.atom.relatedLinks: 
     365        vtds = g.vtd.getValidTypes(g.vtd.ONLINE_REF_CATEGORY) 
     366        c.relatedLinkTerms = utils.getVocabTermDataDropdown(vtds) 
     367 
     368        # ensure we have set up the correct inputs to allow htmlfill to show 
     369        # the correct selected value 
     370        for i, link in enumerate(c.atom.relatedLinks): 
    488371            logging.debug("Adding dropdown for related link, '%s'" %(str(link))) 
    489             c.relatedLinkSelectedLists[str(link)] = \ 
    490                 utils.getVocabTermDataDropdown(g.vtd.getValidTypes(g.vtd.ONLINE_REF_CATEGORY), \ 
    491                                                      selected=link.rel) 
     372            refLabel = Atom.ONLINE_REF_LABEL + "." + str(i) + '.rel' 
     373             
     374            # get the value of the selected list 
     375            self.__setDropDownSelectVal(refLabel, link.rel, vtds) 
    492376 
    493377        logging.debug("Finished setting up drop down lists") 
     
    673557        ''' 
    674558        logging.info("Saving changes to eXist") 
    675         eXist = self.__getExistClient(atom.ME.providerID) 
     559        eXist = self._getExistClient(atom.ME.providerID) 
    676560        createdAtom = eXist.createAtomInExist(atom) 
    677561        logging.info("Changes successfully saved to eXist") 
    678562        return createdAtom 
    679  
    680  
    681     def __getExistClient(self, providerID): 
    682         ''' 
    683         Use the config data to set up and return an eXist client 
    684         ''' 
    685         logging.info("Setting up eXist client to provider, '%s'" %providerID) 
    686         # firstly check if there is a current connection available 
    687         eXistClient = g.eXistDBCons.get(providerID) 
    688         if eXistClient: 
    689             logging.info("- found existing client to provider - returning this") 
    690             return eXistClient 
    691          
    692         # lookup the eXist DB to use according to the provider ID for the  
    693         # data - NB, this is specified in the milk.config file 
    694         existHost = self.cf.get('NDG_EXIST', providerID) 
    695         configFile = self.cf.get('NDG_EXIST','passwordFile') 
    696         eXistClient = edc.eXistDBClient(eXistDBHostname = existHost, \ 
    697                                        configFile = configFile) 
    698         # add the client to the global variables for re-use 
    699         g.eXistDBCons[providerID] = eXistClient 
    700         logging.info("Returning eXist client") 
    701         return eXistClient 
    702563 
    703564     
     
    706567        Create a new atom 
    707568        ''' 
     569        self._setup() 
    708570        if saveData: 
    709571            logging.info("Validating input") 
    710572            try: 
    711                 inputs = self.__getTidyInputs() 
    712573                validator = CreateAtomFormSchema() 
    713                 validator.to_python(inputs) 
     574                validator.to_python(self.inputs) 
    714575                logging.info("- input valid") 
    715576                 
    716577                logging.info("Creating basic atom") 
    717                 self.__setup() 
    718                 atomTypeID = inputs.get('atomTypeID').split('--')[1] 
    719                 inputs['atomTypeID'] = atomTypeID 
     578                atomTypeID = self.inputs.get('atomTypeID').split('--')[1] 
     579                self.inputs['atomTypeID'] = atomTypeID 
    720580    
    721581                # activity deployments should have subtype deployment specified automatically 
    722582                if atomTypeID == g.vtd.ACTIVITY_DEPLOYMENT_TERM: 
    723                     inputs['subtypeID'] = g.vtd.DEPLOYMENT_TERM 
    724                     inputs['atomTypeID'] = g.vtd.ACTIVITY_TERM 
    725                      
    726                 inputs['providerID'] = inputs.get('providerID').split('--')[1] 
    727                 atom = self.saveAtomToExist(Atom(**dict(inputs))) 
    728                  
    729                 h.redirect_to(controller = 'atom_editor/editatom', action='edit', 
    730                                uri = atom.ndgURI) 
     583                    self.inputs['subtypeID'] = g.vtd.DEPLOYMENT_TERM 
     584                    self.inputs['atomTypeID'] = g.vtd.ACTIVITY_TERM 
     585                     
     586                self.inputs['providerID'] = self.inputs.get('providerID').split('--')[1] 
     587                atom = self.saveAtomToExist(Atom(**dict(self.inputs))) 
     588                url = h.url_for('edit', uri = atom.ndgURI, saveData=None) 
     589                 
     590                # NB, the redirect throws an exception, so be careful not to catch it 
     591                h.redirect_to(url) 
    731592            except Invalid, e: 
    732593                c.errors = e.unpack_errors() 
     
    738599        # set up the drop down content - NB, add special case, 'deployment activity' 
    739600        # - this is just a specialised activity - i.e. with subtype preset 
    740         c.atomTypes = utils.getVocabTermDataDropdown(g.vtd.getValidTypes(g.vtd.ATOM_CATEGORY), 
    741                                                selected = inputs.get('atomTypeID')) 
    742         c.providerIDs = utils.getVocabTermDataDropdown( 
    743                             g.vtd.getValidTypes(g.vtd.PROVIDER_CATEGORY),  
    744                             selected = inputs.get('providerID')) 
     601        c.atomTypes = utils.getVocabTermDataDropdown(g.vtd.getValidTypes(g.vtd.ATOM_CATEGORY)) 
     602        c.providerIDs = utils.getVocabTermDataDropdown(g.vtd.getValidTypes(g.vtd.PROVIDER_CATEGORY)) 
    745603 
    746604        try: 
    747             return savePageAndRender(self.pathInfo, 'atom_editor/atom_creator', **inputs) 
     605            return self.savePageAndRender('atom_editor/atom_creator', **self.inputs) 
    748606 
    749607        except Exception, e: 
    750             return self.__handleError(e) 
     608            return self._handleError(e) 
    751609 
    752610     
     
    759617        c.errors = {} 
    760618        try: 
    761             return savePageAndRender(self.pathInfo, 'atom_editor/atom_granulator', **inputs) 
     619            return self.savePageAndRender('atom_editor/atom_granulator', **inputs) 
    762620 
    763621        except Exception, e: 
    764             return self.__handleError(e) 
     622            return self._handleError(e) 
  • MILK/trunk/milk_server/milk_server/controllers/atom_editor/editorconstants.py

    r4678 r4724  
    1212DEPLOYMENTS_ASSOCIATION_TITLE = ' - to create associations with deployment data' 
    1313DEPLOYMENTS_DATA_ASSOCIATION_TITLE = ' - to create associations with activity/data production tool/observation station data' 
     14HELP_PAGE_TITLE = 'Atom Editor Help Page' 
     15 
    1416NO_SEARCH_RESULTS = 'No data found for search selections' 
    1517EDIT_TITLE = 'Editing [%s]' 
  • MILK/trunk/milk_server/milk_server/controllers/atom_editor/listatom.py

    r4668 r4724  
    66''' 
    77import logging, xmlrpclib 
    8 from paste.request import parse_querystring 
    9 from ndgUtils import ndgObject 
    108from ndgUtils.models.Atom import Atom 
    119from ndgUtils import DocumentRetrieve 
    1210from ndgUtils.eXistInterface import ndg_eXist 
    13 import ndgUtils.lib.existdbclient as edc 
    14 from ndgUtils.models.MolesEntity import MolesEntity as ME 
    1511from ndgUtils.models.vocabtermdata import VocabTermData as VTD, VocabTermItem as VTI 
    1612from milk_server.lib.base import * 
    1713from editorconstants import * 
    1814import milk_server.lib.htmlUtilities as utils 
    19 from milk_server.lib.atomutilities import savePageAndRender 
    20 from editatom import EditatomController as ec 
    21  
     15from atomeditorcontroller import AtomEditorController 
    2216    
    23 class ListatomController(BaseController): 
     17class ListatomController(AtomEditorController): 
    2418    '''  
    2519    Provides the pylons controller for listing/searching NDG Atom documents. 
    2620    ''' 
    27     def __setup(self,uri=None): 
    28         ''' Common setup stuff for all the actions on this controller ''' 
    29         logging.info("Setting up EditatomController") 
    30         self.cf=request.environ['ndgConfig'] 
    31          
    32         if uri: 
    33             try: 
    34                 self.ndgObject = ndgObject(uri, config=self.cf) 
    35             except ValueError,e: 
    36                 return e 
    3721 
    38         self.inputs=dict(parse_querystring(request.environ)) 
    39  
    40         logging.info("EditatomController set up") 
    41         return 0 
    42  
    43  
     22     
    4423    def atomHome(self): 
    4524        '''  
     
    4827        logging.info("Rendering atom home page") 
    4928        c.title = ATOM_HOME_TITLE 
    50         return savePageAndRender(self.pathInfo, "atom_editor/atom_home") 
     29        return self.savePageAndRender("atom_editor/atom_home") 
    5130 
    5231 
     
    5736        logging.info("Rendering example granulite file page") 
    5837        c.title = EXAMPLE_GRANULITE_TITLE 
    59         return savePageAndRender(self.pathInfo, "atom_editor/granulite_example") 
     38        return self.savePageAndRender("atom_editor/granulite_example") 
     39 
     40 
     41    def showAtomHelp(self): 
     42        ''' 
     43        Show the help page 
     44        ''' 
     45        logging.info("Rendering help page") 
     46        c.title = HELP_PAGE_TITLE 
     47        return self.savePageAndRender("atom_editor/atom_help") 
    6048     
    6149     
     
    7563        ''' 
    7664        try: 
    77             inputs = request.params 
    7865            c.searchData = None 
     66            self._setup() 
    7967            if searchData and int(searchData) > 0: 
    8068                logging.info("Preparing atom search") 
    8169                c.searchData = searchData 
    82                 self.__setup() 
    83                 atomTypeID = inputs.get('atomTypeID') 
    84                 providerID = inputs.get('providerID') 
     70                atomTypeID = self.inputs.get('atomTypeID') 
     71                providerID = self.inputs.get('providerID') 
    8572                # NB, avoid page being reloaded in incorrect state - e.g. after 
    8673                # browser reload 
     
    9683                    atomTypeID = VTD.DEPLOYMENT_TERM 
    9784                     
    98                 c.results = self.searchAtoms(providerID, atomTypeID, inputs.get('title')) 
     85                c.results = self.searchAtoms(providerID, atomTypeID, self.inputs.get('title')) 
    9986                 
    10087            logging.info("Rendering atom listings page") 
     
    10491            c.associateLink = "" 
    10592            if associatedAtomID: 
    106                 c.associateLink = h.url_for(controller='atom_editor/editatom', action='saveAtom', \ 
    107                     uri = associatedAtomID, saveLevel = ec.ADD_ASSOCIATIONS) 
    108             c.searchLink = h.url_for(controller = 'atom_editor/listatom', action='list', \ 
    109                                      searchData='1', associatedAtomID = associatedAtomID) 
    110              
    111             c.searchTerm = inputs.get('title') 
     93                c.associateLink = h.url_for('save', uri = associatedAtomID, \ 
     94                                            saveLevel = self.ADD_ASSOCIATIONS) 
     95            c.searchLink = h.url_for('list', searchData='1',  
     96                                     associatedAtomID = associatedAtomID, \ 
     97                                     associatedAtomType = associatedAtomType, \ 
     98                                     associationType = associationType) 
    11299             
    113100            # set up the drop down content 
     
    136123            c.atomTypes = utils.getVocabTermDataDropdown(listVals, \ 
    137124                                                   defaultVal = defaultVal, \ 
    138                                                    selected = inputs.get('atomTypeID')) 
     125                                                   selected = self.inputs.get('atomTypeID')) 
    139126            c.providerIDs = utils.getVocabTermDataDropdown(g.vtd.getValidTypes(g.vtd.PROVIDER_CATEGORY),  
    140127                                                     defaultVal = allVal, \ 
    141                                                      selected = inputs.get('providerID')) 
     128                                                     selected = self.inputs.get('providerID')) 
    142129 
    143             return savePageAndRender(self.pathInfo, 'atom_editor/atom_list') 
     130            return self.savePageAndRender('atom_editor/atom_list', **self.inputs) 
    144131 
    145132        except Exception, e: 
Note: See TracChangeset for help on using the changeset viewer.