Changeset 5022 for MILK


Ignore:
Timestamp:
23/02/09 16:50:48 (11 years ago)
Author:
cbyrom
Message:

Create new data model, NDGDoc, to handle generic lookup of NDG Docs +
provide uniform info for use with the genshi templates. Implement
usage of this new class by retrieve - removing duplicated code and
simplifying the controller in the process.

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

Legend:

Unmodified
Added
Removed
  • MILK/trunk/milk_server/milk_server/controllers/browse/retrieve.py

    r4999 r5022  
    99from xml.parsers.expat import ExpatError 
    1010from milk_server.lib.base import * 
    11 from milk_server.lib import Utilities 
    12 from milk_server.lib.ndgInterface import ndgInterface  
     11from milk_server.models.ndgdoc import NDGDoc  
    1312from milk_server.controllers.trackback.trackback import TrackbackController 
    14 from ndg.common.src.lib.ETxmlView import et2html 
    15 from ndg.common.src.models import stubB, DIF, ndgObject 
    1613from ndg.common.src.models.ndgObject import ndgObject 
    17 from ndg.common.src.models.Atom import Atom 
    1814from ndg.common.src.models.vocabtermdata import VocabTermData as VTD 
    1915from ndg.common.src.clients.xmldb.eXist.searchclient import SearchClient 
     
    2723    ''' 
    2824     
    29     def __setup(self,uri): 
     25    def __setup(self, uri): 
    3026        ''' Common setup stuff for all the actions on this controller ''' 
    3127        logging.info("Setting up RetrieveController") 
    32         self.cf=request.environ['ndgConfig'] 
     28        self.cf = request.environ['ndgConfig'] 
    3329        try: 
    3430            self.uri=ndgObject(uri, config=self.cf) 
     
    4339        self.format='' 
    4440        if 'format' in self.inputs:  
    45             self.format=self.inputs['format'] 
    46         self.outputSchema='' 
     41            self.format = self.inputs['format'] 
     42        self.outputSchema = '' 
    4743        if 'outputSchema' in self.inputs:  
    48             self.outputSchema=self.inputs['outputSchema'] 
     44            self.outputSchema = self.inputs['outputSchema'] 
     45 
     46        self.ndgDoc = NDGDoc(ndgURI = uri, config = self.cf) 
    4947                               
    5048        logging.info("RetrieveController set up") 
     
    5351        
    5452    def index(self,uri): 
    55         ''' Returns the document unadorned in anyway, i.e. the raw xml''' 
     53        '''  
     54        Returns the document unadorned in anyway, i.e. the raw xml 
     55        ''' 
    5656        status=self.__setup(uri) 
    5757        if status: 
     
    6060            return render('error') 
    6161         
    62         interface = ndgInterface() 
    63         status,x = interface.GetXML(uri,outputSchema=self.outputSchema) 
    64         c.xml = x 
    65         if status: 
     62        self.ndgDoc.setupDocumentModel(outputSchema = self.outputSchema, 
     63                                       format = 'xml') 
     64 
     65        if self.ndgDoc.status: 
    6666            response.headers['Content-Type'] = 'application/xml' 
    67             response.write(c.xml) 
     67            response.write(self.ndgDoc.xmlString) 
    6868        else: 
    69             e = 404 
    70             if x.startswith('<p> Access'):  
    71                 e = 401 
    72             response.status_code = e 
    73             return render('error') 
     69            # the error templates should be set up already if there's an error 
     70            return self.__renderModel(self.ndgDoc) 
    7471 
    7572 
     
    9491            if atom: 
    9592                c.atom = atom 
     93                self.ndgDoc.templateType = "genshi" 
     94                self.ndgDoc.htmlCode = 200 
    9695            else: 
    97                 interface = ndgInterface() 
    98                 status,x=interface.GetXML(uri,outputSchema=self.outputSchema, useCache=False) 
    99                 c.xmlh=x 
    100                 c.atom = Atom(xmlString=str(x), ndgObject = self.uri) 
     96                 
     97                self.ndgDoc.setupDocumentModel(outputSchema = self.outputSchema, 
     98                                               format = self.format) 
     99                c.atom = self.ndgDoc.docModel 
    101100             
    102101            # NB, there are two routes through here - if we're viewing a data entity, 
     
    113112                                        lookupIndirectReferences = lookupIndirectReferences) 
    114113 
    115             template = 'atom_editor/deployments_data' 
     114            self.ndgDoc.renderTemplate = 'atom_editor/deployments_data' 
    116115            if type == VTD.DE_TERM: 
    117                 template = 'atom_editor/data_entities_data' 
     116                self.ndgDoc.renderTemplate = 'atom_editor/data_entities_data' 
    118117 
    119118            # store the atom to retain the looked up info 
     
    121120            session.save() 
    122121                 
    123             logging.info("- %s data retrieved - now rendering" %type) 
    124             return render('genshi', template) 
    125          
    126         except ExpatError, e: 
    127             c.xml='XML content is not well formed' 
    128             c.doc=str(x) 
    129             response.status_code = 400 
    130             logging.error("Error retrieving [%s] - XML content: %s" % (uri, e)) 
    131             return render('error') 
    132  
     122            logging.info("- %s data retdrieved - now rendering" %type) 
     123 
     124            return self.__renderModel(self.ndgDoc) 
    133125        except Exception, e: 
    134             #we may be showing an xml document ... but it could go wrong if 
    135             #we have crap content ... 
    136             c.xml='Unexpected error [%s] viewing [%s]'%(str(e), uri) 
    137             c.doc='' 
     126            c.xml = 'Unexpected error [%s] viewing [%s]'%(str(e), self.ndgDoc.ndgUri) 
     127            c.doc = '' 
    138128            response.status_code = 400 
    139129            logging.error(c.xml) 
    140130            return render('error') 
    141  
    142          
    143     def view(self,uri): 
    144         ''' Returns either an html marked up version of the xml, or a properly laid 
    145         out version of the document ''' 
     131             
     132 
     133    def view(self, uri): 
     134        '''  
     135        Returns either an html marked up version of the xml, or a properly laid 
     136        out version of the document  
     137        ''' 
    146138        c.doc=None 
    147139        # NB, this sets up self.uri as an ndgObject 
     
    151143            response.status_code = 400 
    152144            return render('error') 
    153  
    154         logging.info("Retrieving document to view") 
    155         useCache = True 
    156         viewFormat=self.uri.schema 
    157         # NB, don't use cache if we're looking up atoms as these can change quickly 
    158         # when using the atom editor 
    159         if viewFormat == ndgObject.ATOM_DOC_TYPE or \ 
    160             viewFormat ==  ndgObject.ATOM_BACKUP_DOC_TYPE: 
    161             useCache = False 
    162              
    163         interface = ndgInterface() 
    164         status,x = interface.GetXML(uri, outputSchema=self.outputSchema,  
    165                                     useCache=useCache) 
     145         
     146        c.tab = 'Details' 
    166147        c.title='Viewing [%s]'%self.uri 
    167148         
    168         # NB, legacy code uses kid templates - newer stuff should use genshi 
    169         templateType = "kid" 
    170         if status: 
    171             logging.debug("Document retrieved ok - now processing results") 
    172  
    173             if self.outputSchema!='':  
    174                 viewFormat=self.outputSchema 
    175  
    176             logging.debug("Doc format: %s, View format: %s" \ 
    177                            %(self.format, viewFormat)) 
    178  
    179             # get name to pass to trackback rdf - make more general, if possible 
    180             # once the doc has been retrieved 
    181             name=str(self.uri) 
    182             if self.format=='xml': 
    183                 c.xml = et2html(ET.fromstring(x)) 
    184                 renderTemplate = 'content' 
    185                 c.tab='Details' 
    186  
    187             elif self.format=='raw': 
    188                 c.xml = x 
    189                 response.headers['Content-Type'] = 'application/xml' 
    190                 return response.write(c.xml) 
     149        self.ndgDoc.setupDocumentModel(outputSchema = self.outputSchema, 
     150                                       format = self.format) 
     151 
     152        c.xml = self.ndgDoc.xmlString 
     153 
     154        if self.format=='raw': 
     155            response.headers['Content-Type'] = 'application/xml' 
     156            return response.write(c.xml) 
     157 
     158        c.name = self.ndgDoc.name 
     159        c.xmlh = self.ndgDoc.xmlh    # xml in object form - NB, only used by NumSim docs 
     160        c.doc = self.ndgDoc.docModel 
     161 
     162        if self.ndgDoc.isAtom: 
     163            c.atom = self.ndgDoc.docModel 
     164             
     165            # store the atom for easy re-use by asynch calls 
     166            # - primarily for the viewAssociatedData() method here 
     167            session['currentAtom'] = c.atom 
     168            session.save() 
    191169                 
    192             elif viewFormat == ndgObject.ATOM_DOC_TYPE or \ 
    193                 viewFormat ==  ndgObject.ATOM_BACKUP_DOC_TYPE: 
    194                 renderTemplate = 'atom_editor/atom_editor' 
    195                 c.xmlh = x 
    196                 c.atom = Atom(xmlString=x, ndgObject = self.uri) 
    197                  
    198                 # get the current publication state 
    199                 edc = Utilities.getExistClient(c.atom.ME.providerID) 
    200                 c.atom.state = edc.getAtomPublicationState(c.atom.datasetID,  
    201                                                            c.atom.ME.providerID) 
    202                  
    203                 c.title = 'Viewing [%s]'%self.uri 
    204                 c.deploymentsURL = h.url_for(controller='browse/retrieve', \ 
    205                                              action='viewAssociatedData', \ 
    206                                              type = VTD.DEPLOYMENT_TERM, \ 
    207                                              uri = self.uri) 
    208                 c.dataEntitiesURL = h.url_for(controller='browse/retrieve', \ 
    209                                              action='viewAssociatedData', \ 
    210                                              type = VTD.DE_TERM, \ 
    211                                              uri = self.uri) 
    212                 templateType = "genshi" 
    213                 # store the atom for easy re-use by asynch calls 
    214                 # - primarily for the viewAssociatedData() method here 
    215                 session['currentAtom'] = c.atom 
    216                 session.save() 
    217                 name = c.atom.title 
    218  
    219             elif viewFormat == ndgObject.MOLES_DOC_TYPE: 
    220                 renderTemplate = 'browse/stubB' 
    221                 c.doc=stubB.stubB(ET.fromstring(x), self.cf) 
    222                 name=c.doc.abbreviation 
    223                  
    224             elif viewFormat == ndgObject.NDGA0_DOC_TYPE: 
    225                 renderTemplate = 'content' 
    226                 name=self.uri.localID 
    227                 #for now we'll handle as pretty print xml 
    228                 c.xml = et2html(ET.fromstring(x)) 
    229                 c.tab='Details' 
    230                  
    231             elif viewFormat == ndgObject.DIF_DOC_TYPE or viewFormat == ndgObject.BROWSE_DIF_DOC_TYPE: 
    232                 renderTemplate = 'browse/dif' 
    233                 c.doc=DIF.DIF(x, ndgObj=self.uri) 
    234                 name=c.doc.name 
    235                  
    236             elif viewFormat == ndgObject.NUMSIM_DOC_TYPE: 
    237                 renderTemplate = 'browse/numsim' 
    238                 c.xmlh=ET.fromstring(x) 
    239                 name= c.xmlh.findtext('NS_Name') 
    240                 c.name=name 
    241                  
    242             else: 
    243                 c.xml = et2html(ET.fromstring(x)) 
    244                 renderTemplate = 'content' 
    245  
    246             # set up trackback rdf tag 
    247             c.tbinfo = TrackbackController().getTrackBackInfo(self.uri, name) 
    248  
    249             needed=0 
    250             if 'lastViewed' not in session:  
    251                 needed=1 
    252                  
    253             session['lastViewed']=h.current_url() 
    254             if needed:  
    255                 c.pageTabs.append(('Details',session['lastViewed'])) 
    256              
    257             session.save() 
    258             code=200 
    259         else: 
    260             renderTemplate = 'error' 
    261             if x.startswith('<p> Access Denied'): 
    262                 code=401 
    263             else: code=400 
    264             c.xml='%s'%x 
    265             logging.error(x) 
    266              
    267         response.status_code = code 
     170        # set up trackback rdf tag 
     171        c.tbinfo = TrackbackController().getTrackBackInfo(uri, self.ndgDoc.name) 
     172 
     173        needed=0 
     174        if 'lastViewed' not in session:  
     175            needed=1 
     176             
     177        session['lastViewed']=h.current_url() 
     178        session.save() 
     179 
     180        # only add the details tab data to the panel tab, if it is not already there 
     181        if needed:  
     182            c.pageTabs.append(('Details',session['lastViewed'])) 
     183 
     184        return self.__renderModel(self.ndgDoc) 
     185 
     186 
     187    def __renderModel(self, model): 
     188        ''' 
     189        Render the requested document model - or handle errors appropriately 
     190        @param model: doc model - of type NDGDoc 
     191        ''' 
     192        response.status_code = model.htmlCode 
    268193        try: 
    269             return render(templateType, renderTemplate) 
     194            logging.debug("Rendering output from data model") 
     195            out = render(model.templateType, model.renderTemplate) 
     196            logging.debug("- returning rendered data model") 
     197            return out 
    270198         
    271199        except ExpatError, e: 
    272             c.xml='XML content is not well formed' 
    273             c.doc=str(x) 
    274             response.status_code = 400 
    275             logging.error("Error retrieving [%s] - XML content: %s" % (uri, e)) 
     200            c.xml = 'XML content is not well formed' 
     201            c.doc = model.xmlString 
     202            response.status_code = 400 
     203            logging.error("Error retrieving [%s]: %s" % (model.ndgUri, e)) 
    276204            return render('error') 
    277205 
    278206        except Exception, e: 
    279             #we may be showing an xml document ... but it could go wrong if 
    280             #we have crap content ... 
    281             c.xml='Unexpected error [%s] viewing [%s]'%(str(e), uri) 
    282             c.doc='' 
     207            c.xml = 'Unexpected error [%s] viewing [%s]'%(str(e), model.ndgUri) 
     208            c.doc = '' 
    283209            response.status_code = 400 
    284210            logging.error(c.xml) 
    285211            return render('error') 
     212         
     213 
Note: See TracChangeset for help on using the changeset viewer.