Changeset 4535


Ignore:
Timestamp:
04/12/08 16:29:18 (11 years ago)
Author:
cbyrom
Message:

Generalise existing methods to allow data entities to be looked up with
the same code as associated deployments data + add new templates to
display the DEs + extend the javascript to allow multiple callbacks
to retrieve the info + various tidy ups and fixes.

Files:
1 added
12 edited

Legend:

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

    r4487 r4535  
    3131                controller = 'atom_editor/listatom', action='list', searchData='', \ 
    3232                associatedAtomID='', associatedAtomType='', associationType='') 
    33     map.connect('viewDeployments/:uri', controller = 'browse/retrieve', action='viewDeployments') 
     33    map.connect('viewAssociatedData/:type/:uri', controller = 'browse/retrieve', action='viewAssociatedData') 
    3434 
    3535    # routing for the browse/discovery server 
  • MILK/trunk/milk_server/milk_server/controllers/atom_editor/editatom.py

    r4523 r4535  
    189189        gran = granulite(fileContents, eXistClient = eXistClient, \ 
    190190                         cdmlFile = cdmlFile, csmlFile = csmlFile) 
     191        c.atom = gran.processGranulite() 
    191192         
    192193        logging.info("Finished processing granulite data") 
     
    303304         
    304305        # save the current atom - to avoid this needing be recreated by the  
    305         # asynch viewDeployments call 
     306        # asynch viewAssociatedData call 
    306307        session['currentAtom'] = c.atom 
    307308        session.save() 
     
    333334        c.saveAssoc = h.url_for(controller='atom_editor/editatom',action='saveAtom', \ 
    334335                                 saveLevel = self.REMOVE_ASSOCIATIONS) 
     336        c.deploymentsURL = h.url_for(controller='browse/retrieve', \ 
     337                                     action='viewAssociatedData', \ 
     338                                     type = VTD.DEPLOYMENT_TERM, \ 
     339                                     uri = c.atom.ndgURI) 
     340        c.dataEntitiesURL = h.url_for(controller='browse/retrieve', \ 
     341                                     action='viewAssociatedData', \ 
     342                                     type = VTD.DE_TERM, \ 
     343                                     uri = c.atom.ndgURI) 
    335344         
    336345        # adjust atom type to cope with activity deployment exception 
     
    559568                    link.title = title or "" 
    560569                    link.rel = rel or "" 
     570                     
     571                    # adjust href to point to the view, not the edit version 
     572                    link.href = link.href.replace('editAtom', 'view') 
    561573                     
    562574                    logging.debug("Extracted atom info (href:'%s', title:'%s', rel:'%s')" \ 
     
    653665        # set up the drop down content - NB, add special case, 'deployment activity' 
    654666        # - this is just a specialised activity - i.e. with subtype preset 
    655         deploymentActivity = g.vtd.TERM_DATA[g.vtd.ACTIVITY_DEPLOYMENT_TERM] 
    656667        c.atomTypes = utils.getVocabTermDataDropdown(g.vtd.getValidTypes(g.vtd.ATOM_CATEGORY), 
    657                                                defaultVal = deploymentActivity, \ 
    658668                                               selected = inputs.get('atomTypeID')) 
    659669        c.providerIDs = utils.getVocabTermDataDropdown( 
     
    672682        Create a new atom from a granulite file 
    673683        ''' 
    674         logging.info("Setting up create atom from granulite template") 
     684        logging.info("Setting up new atom from granulite template") 
    675685        c.title='Create new data granule atom - from a granulite file' 
    676686         
  • MILK/trunk/milk_server/milk_server/controllers/atom_editor/listatom.py

    r4497 r4535  
    77import logging, xmlrpclib 
    88from paste.request import parse_querystring 
    9 from xml.parsers.expat import ExpatError 
    10 from formencode import Schema, validators, Invalid 
    11 from genshi.filters import HTMLFormFiller 
    12 from genshi import HTML 
    139from ndgUtils import ndgObject 
    1410from ndgUtils.models.Atom import Atom 
     
    8480                atomTypeID = atomTypeID.split('--')[1] 
    8581                providerID = providerID.split('--')[1] 
     82                 
     83                # if we're dealing with activity deployments, substitute the typeID 
     84                # for the subType Deployments term 
     85                if atomTypeID == VTD.ACTIVITY_DEPLOYMENT_TERM: 
     86                    atomTypeID = VTD.DEPLOYMENT_TERM 
     87                     
    8688                c.results = self.searchAtoms(providerID, atomTypeID, inputs.get('title')) 
    8789                 
  • MILK/trunk/milk_server/milk_server/controllers/browse/retrieve.py

    r4487 r4535  
    6565            return render('error') 
    6666 
    67     def viewDeployments(self, uri): 
     67    def viewAssociatedData(self, type, uri): 
    6868        ''' 
    69         Get the deployments data associated with the uri 
     69        Get the specified data associated with the uri 
     70        @param type: type of associated data to lookup - currently VTD.DEPLOYMENT_TERM 
     71        or VTD.DE_TERM 
    7072        @param uri: valid ndg uri 
    7173        @return rendered genshi deployments template 
    7274        ''' 
    73         logging.info("Getting deployments data for '%s'" %uri) 
     75        logging.info("Getting %s data for '%s'" %(type, uri)) 
    7476        status=self.__setup(uri) 
    7577        if status: 
     
    9193            # the deployment links are available directly from the atom; if not we 
    9294            # need to look them up 
    93             lookupIndirectReferences = False 
    94             if c.atom.isDeployable(): 
    95                 lookupIndirectReferences = True 
     95            lookupIndirectReferences = True 
     96            if c.atom.isDE(): 
     97                lookupIndirectReferences = False 
    9698             
    9799            dr = DocumentRetrieve(self.cf.get('NDG_EXIST','local'), 
    98100                      pwfile=self.cf.get('NDG_EXIST','passwordFile')) 
    99             c.atom.lookupDeploymentsInfo(dr, lookupIndirectReferences = \ 
    100                                          lookupIndirectReferences) 
    101             logging.info("- deployments data retrieved - now rendering") 
    102             return render('genshi', 'atom_editor/deployments_data') 
     101             
     102            c.atom.lookupAssociatedData(type, dr, lookupIndirectReferences = \ 
     103                                             lookupIndirectReferences) 
     104 
     105            template = 'atom_editor/deployments_data' 
     106            if type == VTD.DE_TERM: 
     107                template = 'atom_editor/data_entities_data' 
     108 
     109            # store the atom to retain the looked up info 
     110            session['currentAtom'] = c.atom 
     111            session.save() 
     112                 
     113            logging.info("- %s data retrieved - now rendering" %type) 
     114            return render('genshi', template) 
    103115         
    104116        except ExpatError, e: 
     
    124136        out version of the document ''' 
    125137        c.doc=None 
     138        # NB, this sets up self.uri as an ndgObject 
    126139        status=self.__setup(uri) 
    127140        if status: 
     
    131144 
    132145        logging.info("Retrieving document to view") 
    133         status,x=interface.GetXML(uri,outputSchema=self.outputSchema) 
     146        useCache = True 
     147        viewFormat=self.uri.schema 
     148        # NB, don't use cache if we're looking up atoms as these can change quickly 
     149        # when using the atom editor 
     150        if viewFormat == ndgObject.ATOM_DOC_TYPE or \ 
     151            viewFormat ==  ndgObject.ATOM_BACKUP_DOC_TYPE: 
     152            useCache = False 
     153             
     154        status,x=interface.GetXML(uri,outputSchema=self.outputSchema, useCache=useCache) 
    134155        c.title='Viewing [%s]'%self.uri 
    135156         
     
    139160            logging.debug("Document retrieved ok - now processing results") 
    140161            #(the return object x is an xmlHandler object) 
    141             viewFormat=self.uri.schema 
    142162            if self.outputSchema!='':  
    143163                viewFormat=self.outputSchema 
     
    163183                c.atom = Atom(xmlString=str(x), ndgObject = self.uri) 
    164184                c.title = 'Viewing [%s]'%self.uri 
    165                 c.deploymentsURL = h.url_for(controller='retrieve', \ 
    166                                              action='viewDeployments', \ 
     185                c.deploymentsURL = h.url_for(controller='browse/retrieve', \ 
     186                                             action='viewAssociatedData', \ 
     187                                             type = VTD.DEPLOYMENT_TERM, \ 
     188                                             uri = self.uri) 
     189                c.dataEntitiesURL = h.url_for(controller='browse/retrieve', \ 
     190                                             action='viewAssociatedData', \ 
     191                                             type = VTD.DE_TERM, \ 
    167192                                             uri = self.uri) 
    168193                templateType = "genshi" 
    169194                # store the atom for easy re-use by asynch calls 
    170                 # - primarily for the viewDeployments() method here 
     195                # - primarily for the viewAssociatedData() method here 
    171196                session['currentAtom'] = c.atom 
    172197                session.save() 
  • MILK/trunk/milk_server/milk_server/lib/ndgInterface.py

    r4469 r4535  
    99from cache import Cache 
    1010from csml_cache import CSMLExtractCache 
    11 import os, tempfile, logging 
    12 import csml 
    13 try: 
    14     import cdms2 as cdms 
    15 except: 
    16     import cdms 
     11import os, logging 
    1712from ndgUtils import ndgRetrieve, ndgObject, xmlHandler2 
    18 from pylons import request,session 
     13from pylons import request, session 
    1914 
    2015from pylons import g # for handle to access control PEP interface 
  • MILK/trunk/milk_server/milk_server/public/js/queueDeployments.js

    r4445 r4535  
    22// incremental loading of the deployments data - so this can be loaded after 
    33// the rest of the atom data is displayed 
    4 YUI({combine: true, timeout: 10000}).use("anim", "queue",function (Y) { 
     4// NB, for the load of info to work, the user must set a placeholder element 
     5// in the page which contains the url to do the callback to.  Also, one must set 
     6// placeholderNames, dataTypes and urls as script array values (to allow multiple queues 
     7// to be invoked) before this script is called. 
     8// placeholderNames = array of div IDs whose content will be filled by the results of this 
     9// script 
     10// dataTypes = array of names of types of data to lookup - to display correct 'loading' message 
     11// urls = array of urls to use in the callbacks 
     12// - see implementation in atom_editor.html for example 
     13// 
     14// C Byrom, Tessella Dec 08 
     15// 
     16YUI().use("anim", "queue",function (Y) { 
    517 
    618var MyApp = { 
    7     NAME : 'Loading deployments info...', 
    819         
    920    q : new Y.Queue(), 
     
    1627    }, 
    1728 
    18     render : function (container) { 
    19         if (MyApp.nodes.root) { 
    20             MyApp.q.stop(); 
    21  
    22             MyApp.q.add( 
    23                 MyApp.destroy 
    24             ); 
    25         } 
    26  
    27         // artificial delays have been inserted to simulate _renderNav or 
    28         // _renderContent being process intensive and taking a while to complete 
     29    render : function (container, dataType, url) { 
     30        var root = MyApp.nodes.root = Y.get(container); 
    2931        MyApp.q.add( 
    3032            // pass the container param to the callback using Y.bind 
    31             Y.bind(MyApp._renderFramework, MyApp, container), 
    32             MyApp._loadDeployments).run(); 
    33     }, 
    34  
    35     destroy : function () { 
    36         var root = MyApp.nodes.root; 
    37  
    38         if (root) { 
    39             Y.Event.purgeElement(root,true); 
    40             root.set('innerHTML',''); 
    41         } 
     33            Y.bind(MyApp._renderFramework, MyApp, container, dataType), 
     34            Y.bind(MyApp._loadDeployments, MyApp, container, url)).run(); 
    4235    }, 
    4336 
     
    4841    }, 
    4942 
    50     _renderFramework : function (container) { 
     43    _renderFramework : function (container, dataType) { 
    5144        var root = MyApp.nodes.root = Y.get(container); 
    52  
    5345        root.set('innerHTML', 
    5446        '<div class="yui-module">'+ 
    5547            '<div class="linehead">'+ 
    56                 '<h4>'+MyApp.NAME+'</h4>'+ 
     48                '<h4>Loading ' + dataType + ' info...</h4>'+ 
    5749            '</div>'+ 
    5850            '<div class="yui-bd">'+ 
     
    7264    }, 
    7365 
    74         _loadDeployments : function () 
     66        _loadDeployments : function (container, url) 
    7567        { 
    76                 var setContent = function (xhr)  
     68                var setContent = function (xhr, container)  
    7769                { 
    78                 /** 
    79                 NB, could set the content here, but we want to replace the whole div element 
    80                 to load the new header titles 
    81         var content = MyApp.nodes.content; 
    82         content.appendChild(Y.Node.create(xhr.responseText)); 
    83                 MyApp.nodes.root.set('innerHTML',''); 
    84  
    85         new Y.Anim({ 
    86             node : content, 
    87             to :   { opacity : 1 }, 
    88             duration : .8 
    89         }).run(); 
    90         */ 
    91                 $('deploymentsPlaceholder').innerHTML = ''; 
     70                        var root = MyApp.nodes.root = Y.get(container); 
     71                         
     72                        root.set('innerHTML', ''); 
    9273                        var deploymentsHTML = xhr.responseText; 
    9374                        if (deploymentsHTML) 
    94                                 $('deploymentsPlaceholder').innerHTML = deploymentsHTML; 
     75                                root.set('innerHTML', deploymentsHTML); 
    9576                }; 
    96                 var id = $('datasetID').value; 
    97                 new Ajax.Request('/viewDeployments/' + id,  
     77                 
     78                new Ajax.Request(url, 
    9879                        {parameters: {}, 
    9980                method: "get", 
    100                 onSuccess: setContent.bindAsEventListener(this) 
     81                onSuccess: setContent.bindAsEventListener(this, container) 
    10182                        }); 
    10283        } 
     
    10485 
    10586window.onload = function (e) { 
    106     e.preventDefault(); 
    107     MyApp.render('#deploymentsPlaceholder'); 
     87    for (var i = 0; i < placeholderNames.size(); i++) 
     88    { 
     89            MyApp.render('#' + placeholderNames[i], dataTypes[i], urls[i]); 
     90    }; 
    10891}; 
    10992 
     
    11295 
    11396}); 
     97 
  • MILK/trunk/milk_server/milk_server/templates/atom_editor/atom_editor.html

    r4519 r4535  
    77        <head> 
    88        <title py:content="c.title">title</title> 
    9                 <script py:if="not c.atom.isDeployment() and not c.atom.isGranule()" type="text/javascript" src="$g.server/js/queueDeployments.js"/> 
     9        <span py:if="c.atom.isDeployable()"  py:strip=""> 
     10                <script type="text/javascript"> 
     11                                var placeholderNames = ['deploymentsPlaceholder']; 
     12                                var dataTypes = ['deployments']; 
     13                                var urls = ['$c.deploymentsURL']; 
     14                        </script> 
     15                </span> 
     16        <span py:if="c.atom.isDeployable() or c.atom.isGranule()"  py:strip=""> 
     17                <script type="text/javascript"> 
     18                        if (placeholderNames) 
     19                                var placeholderNames = [placeholderNames, 'dataEntitiesPlaceholder']; 
     20                            else 
     21                                    var placeholderNames = ['dataEntitiesPlaceholder']; 
     22                                if (dataTypes) 
     23                                        var dataTypes = [dataTypes, 'data entities']; 
     24                                else 
     25                                        var dataTypes = ['data entities']; 
     26                                if (urls) 
     27                                        var urls = [urls, '$c.dataEntitiesURL']; 
     28                                else 
     29                                        var urls = ['$c.dataEntitiesURL']; 
     30                        </script> 
     31                        <script type="text/javascript" src="$g.server/js/adddomloadevent.js"/> 
     32                        <script type="text/javascript" src="$g.server/js/queueDeployments.js"/> 
     33                </span> 
    1034    </head> 
    1135    <body> 
     
    1640                            <a py:if="c.saveLink" href="${h.url_for(controller='atom_editor/listatom',action='atomHome')}">Home</a> 
    1741                            <h3>  $c.title </h3> 
     42                                ${Markup(h.form(h.url_for(controller='atom_editor/editatom', action='edit', uri=c.atom.ndgURI)))} 
     43                                        <input py:if="not c.saveLink" name="Edit" type="submit" value="Edit" /> 
     44                                ${Markup(h.end_form())} 
    1845                        <div py:replace="displayErrors()"/> 
    1946                <table py:if="c.saveLink"> 
     
    3562                        <div py:if="c.atom.isDE()" py:replace="Associations('Associated Data Granules', c.atom.getLinksOfType(g.vtd.GRANULE_TERM), c.addGranuleLink, c.saveAssoc)"/> 
    3663                        <div py:if="c.atom.isDE()" py:replace="Associations('Associated Deployments', c.atom.getLinksOfType(g.vtd.DEPLOYMENT_TERM), c.addDeploymentLink, c.saveAssoc)"/> 
     64                        <div class="metadataSection" py:if="c.atom.isDeployable() or c.atom.isGranule()"> 
     65                                <div class="headingblock" id="dataEntitiesPlaceholder" /> 
     66                            </div> 
    3767                        <div class="metadataSection" py:if="c.atom.isDeployable()"> 
    3868                                <div class="headingblock" id="deploymentsPlaceholder" /> 
  • MILK/trunk/milk_server/milk_server/templates/atom_editor/atom_functions.html

    r4498 r4535  
    373373                </table> 
    374374        </div> 
     375     
     376    <div class="headingblock" py:def="DataEntities(des)"> 
     377        <table py:if="des"> 
     378        <tr><td class="headingblock" > 
     379            <table><tr><td><h3>Associated Data Entities - summary</h3></td> 
     380                        </tr></table> 
     381        </td></tr> 
     382        <tr> 
     383                <table class="subTable"> 
     384                                <tr><td class="cellhead">Title</td></tr> 
     385                                <tr py:for="de in des"> 
     386                                <td><a href="$de.href">${de.title or de.href}</a></td> 
     387                        </tr> 
     388                </table></tr> 
     389                </table> 
     390        </div> 
    375391         
    376392    <div py:def="FullDeployment(dep)" py:strip=""> 
     
    581597                        </table> 
    582598                </form> 
    583         <div class="headingblock" py:if="c.atom.isDE() and c.isDeployment and not editLink" id="deploymentsPlaceholder" /> 
    584                 <table py:if="not links"><tr><td> 
     599                <table py:if="not links"><tr><td> 
    585600                        No data specified at present 
    586601                </td></tr> 
  • MILK/trunk/milk_server/milk_server/templates/atom_editor/layout.html

    r4472 r4535  
    1010      </title> 
    1111                ${Markup(h.javascript_include_tag(builtins=True))} 
    12                 <script src="http://yui.yahooapis.com/3.0.0pr1/build/yui/yui-min.js" type="text/javascript"></script>  
    13         <script type="text/javascript" src="$g.server/js/toggleDiv.js"/> 
     12                <script type="text/javascript" src="$g.server/js/yui/build/yui/yui-min.js" ></script>  
     13            <script type="text/javascript" src="$g.server/js/toggleDiv.js"/> 
    1414        <script type="text/javascript" src="$g.server/js/ndgJavascript.js"/> 
    1515        <link media="all, screen" href="$g.server/layout/style/ndg2.css"  
     
    4444      <div py:replace="footer()"/> 
    4545    </div> 
    46     <input py:if="c.atom and c.atom.ME" type="hidden" id="datasetID" name="datasetID" value="${c.atom.ME.providerID}__ATOM__${c.atom.datasetID}" /> 
    4746    </body> 
    4847  </py:match> 
  • exist/trunk/python/ndgUtils/lib/utilities.py

    r4532 r4535  
    3030    logging.debug("Checking validity of uri, '%s'" %uri) 
    3131    # set the socket timeout period 
    32     socket.setdefaulttimeout(10) 
     32    socket.setdefaulttimeout(20) 
    3333     
    3434    try: 
  • exist/trunk/python/ndgUtils/models/Atom.py

    r4531 r4535  
    11661166        ''' 
    11671167        logging.info("Looking up %s info" %type) 
    1168         self.deployments = [] 
     1168         
    11691169        self.allActivities = [] 
    11701170        self.allObs = [] 
     
    11751175         
    11761176        # avoid duplicating lookup effort 
    1177         if type == VTD.DEPLOYMENT_TERM and self.deployments: 
     1177        if (type == VTD.DEPLOYMENT_TERM and self.deployments) or \ 
     1178            (type == VTD.DE_TERM and self.dataEntities): 
    11781179            logging.info("- this info has already been looked up - returning") 
    11791180            return 
     
    11811182        # firstly, collect all the references to the info required 
    11821183        if lookupIndirectReferences: 
     1184            logging.info("Looking up indirect references") 
    11831185             
    11841186            # if we're looking up DE data for deployments data, need to have the 
     
    11891191            logging.info("Looking up references to this atom from other %s" %type) 
    11901192             
     1193            # NB, if we're looking up deployments info, we only look up references 
     1194            # to this atom - if we're looking up DEs, we need to look up references 
     1195            # to the deployments referenced by this atom 
    11911196            urls = [self.atomBrowseURL] 
    11921197             
     
    12031208                tree = ET.fromstring(doc) 
    12041209                for atom in tree: 
    1205                     logging.debug("- found reference in deployment") 
     1210                    logging.debug("- found reference in %s" %type) 
    12061211                    links.append(ET.tostring(atom)) 
     1212                     
     1213            logging.info("Finished looking up indirect references") 
    12071214        else: 
    12081215            links = self.getLinksOfType(self.VTD.DEPLOYMENT_TERM) 
    12091216 
    1210         # now retrieve the refererences and extract the required data 
     1217        # now retrieve the references and extract the required data 
     1218        logging.info("Retrieving info from %s references" %type) 
    12111219        if type == VTD.DEPLOYMENT_TERM: 
     1220            self.deployments = [] 
    12121221            for link in links: 
    12131222                if lookupIndirectReferences: 
     
    12261235        else: 
    12271236            # for DE data, just store the title + link in a Link object 
    1228             deLinks = [] 
     1237            self.dataEntities = [] 
    12291238            for data in links: 
    12301239                atom = Atom(xmlString=str(data)) 
     
    12321241                link.title = atom.title 
    12331242                link.href = atom.atomBrowseURL 
    1234                 deLinks.append(link) 
    1235              
    1236             self.dataEntities = deLinks 
    1237          
     1243                 
     1244                # NB, different deployments may be used by the same DE - so  
     1245                # avoid duplication 
     1246                self.addUniqueLinks(self.dataEntities, link) 
     1247             
    12381248        logging.info("Finished looking up %s info" %type) 
    12391249 
  • exist/trunk/python/ndgUtils/models/Deployment.py

    r4531 r4535  
    2222        self.obs = [] 
    2323        self.dpts = [] 
    24         self.browseURL = None 
    2524         
    2625        # add the deployment info appropriately 
     
    3029        self.startDate = deploymentAtom.t1 
    3130        self.endDate = deploymentAtom.t2 
     31        self.browseURL = deploymentAtom.atomBrowseURL 
    3232        logging.debug("Deployment created") 
    3333 
     
    4848        elif deploymentLink.rel.startswith(VTD.TERM_DATA[VTD.DPT_TERM].vocabURL): 
    4949            deploymentType = self.dpts 
    50         elif deploymentLink.rel == "self": 
    51             logging.debug("Found self referencing link - extract href") 
    52             self.browseURL = deploymentLink.href 
    53             return 
    5450        else: 
    5551            logging.debug("Not a valid deployment type (%s) - ignoring" \ 
Note: See TracChangeset for help on using the changeset viewer.