Changeset 4724


Ignore:
Timestamp:
05/01/09 09:51:50 (12 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.