Changeset 4315 for TI05-delivery


Ignore:
Timestamp:
09/10/08 11:37:44 (11 years ago)
Author:
cbyrom
Message:

Add new template and controller code for adding and editing parameters +
fix data entities so they can properly associate granules and deployments with
them + add new form module to handle all the form validations and implement
basics for the create atom form.

Location:
TI05-delivery/ows_framework/trunk/ows_server/ows_server
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/controllers/editatom.py

    r4302 r4315  
    66''' 
    77from ows_server.lib.base import * 
     8from ows_server.models.form import * 
    89from ows_server.models import Utilities 
    910from ndgUtils import ndgObject 
     
    1314from xml.parsers.expat import ExpatError 
    1415import logging 
    15 from ndgUtils.models.Atom import Atom, Person, Link 
    16 from formencode import Schema, validators, Invalid 
     16from ndgUtils.models.Atom import Atom, Person, Link, Category 
     17from formencode import Invalid 
    1718from genshi.filters import HTMLFormFiller 
    1819from genshi import HTML 
    1920import ndgUtils.models.existdbclient as edc 
    2021from ndgUtils.models.MolesEntity import MolesEntity as ME 
     22from ndgUtils.models.utilities import escapeSpecialCharacters 
    2123from ndgUtils.vocabtermdata import VocabTermData as VTD 
    2224import ows_server.templates.htmlUtilities as utils 
    23  
    24 class AtomFormSchema(Schema): 
    25     def __init__(self): 
    26         logging.debug("Setting up AtomFormSchema") 
    27          
    28     filter_extra_fields = True 
    29     allow_extra_fields = True 
    30     #subtype = validators.UnicodeString(not_empty=True)#URL(not_empty=True, add_http=True, check_exists=False) 
    31     title = validators.UnicodeString(not_empty=True) 
    32  
    33 class CreateAtomFormSchema(Schema): 
    34     def __init__(self): 
    35         logging.debug("Setting up CreateAtomFormSchema") 
    36          
    37     filter_extra_fields = True 
    38     allow_extra_fields = True 
    39     title = validators.UnicodeString(not_empty=True) 
    40     providerID = validators.UnicodeString(not_empty=True) 
    41     atomTypeID = validators.UnicodeString(not_empty=True) 
    42  
    4325 
    4426class EditatomController(BaseController): 
     
    4628    Provides the pylons controller for editing NDG Atom documents. 
    4729    ''' 
    48     VTD = VTD() 
    49      
    5030    ADD_ASSOCIATIONS = 3 
    5131    REMOVE_ASSOCIATIONS = 4 
     
    5535        logging.info("Setting up EditatomController") 
    5636        self.cf=request.environ['ndgConfig'] 
     37 
     38        if not c.vtd: 
     39            c.vtd = VTD() 
    5740         
    5841        if uri: 
     
    6346 
    6447        self.inputs=dict(parse_querystring(request.environ)) 
    65  
    66         c.vtd = VTD() 
    6748 
    6849        logging.info("EditatomController set up") 
     
    9071        if int(saveLevel) == self.ADD_ASSOCIATIONS: 
    9172            atomLinks = self.extractAtomAssociations(inputs) 
    92             c.atom.addUniqueRelatedlinks(atomLinks) 
     73            c.atom.addUniqueRelatedLinks(atomLinks) 
    9374        elif int(saveLevel) == self.REMOVE_ASSOCIATIONS: 
    9475            atomLinks = self.extractAtomAssociations(inputs) 
    95             c.atom.relatedLinks = atomLinks 
     76            c.atom.removeRelatedLinks(atomLinks) 
    9677        else: 
    9778            authors = self.extractAuthorDetails(inputs) 
     
    10081     
    10182            onlineRefs = self.extractOnlineReferenceDetails(inputs) 
    102             c.atom.relatedLinks = onlineRefs 
    103      
     83            c.atom.addOnlineReferences(onlineRefs) 
     84 
     85            params = self.extractParameterDetails(inputs) 
     86            # NB, the atom type and subtype are added to the categories when the 
     87            # atom is exported to XML - so don't need to worry about overwriting 
     88            # them now 
     89            c.atom.parameters = params 
     90             
    10491            if inputs.get('subtype'): 
    10592                c.atom.subtype = self.getLatestTermURLFromDropDownInput( \ 
     
    175162        c.isDE = False 
    176163        c.isGranule = False 
    177         if atomType == VTD.ACTIVITY_TERM and \ 
    178             c.atom.subtypeID == VTD.DEPLOYMENT_TERM: 
    179             atomType = VTD.DEPLOYMENT_TERM 
    180          
    181         elif atomType == VTD.DE_TERM: 
     164        if atomType == c.vtd.ACTIVITY_TERM and \ 
     165            c.atom.subtypeID == c.vtd.DEPLOYMENT_TERM: 
     166            atomType = c.vtd.DEPLOYMENT_TERM 
     167         
     168        elif atomType == c.vtd.DE_TERM: 
    182169            c.isDE = True 
    183         elif atomType == VTD.GRANULE_TERM: 
     170        elif atomType == c.vtd.GRANULE_TERM: 
    184171            c.isGranule = True 
    185172             
     
    201188        # account for special case where we're dealing with deployments 
    202189        c.notDeployment = True 
    203         listVals = self.VTD.getValidSubTypes(c.atom.atomTypeID) 
     190        listVals = c.vtd.getValidSubTypes(c.atom.atomTypeID) 
    204191        if c.atom.subtype: 
    205             subtypeTermID = self.VTD.getTermItemfromFullVocabURI(c.atom.subtype).termID 
    206             if subtypeTermID == self.VTD.getVTI(self.VTD.DEPLOYMENT_TERM).termID: 
    207                 listVals = [self.VTD.TERM_DATA[self.VTD.DEPLOYMENT_TERM]] 
     192            subtypeTermID = c.vtd.getTermItemfromFullVocabURI(c.atom.subtype).termID 
     193            if subtypeTermID == c.vtd.getVTI(c.vtd.DEPLOYMENT_TERM).termID: 
     194                listVals = [c.vtd.TERM_DATA[c.vtd.DEPLOYMENT_TERM]] 
    208195                c.notDeployment = False 
    209196        c.subTypes = utils.getVocabTermDataDropdown(listVals, \ 
     
    240227        logging.debug("Setting up drop down lists for related links") 
    241228        c.relatedLinkTerms = utils.getVocabTermDataDropdown(\ 
    242                 self.VTD.getValidTypes(self.VTD.ONLINE_REF_CATEGORY)) 
     229                c.vtd.getValidTypes(c.vtd.ONLINE_REF_CATEGORY)) 
    243230         
    244231        c.relatedLinkSelectedLists = {} 
     
    246233            logging.debug("Adding dropdown for related link, '%s'" %(str(link))) 
    247234            c.relatedLinkSelectedLists[str(link)] = \ 
    248                 utils.getVocabTermDataDropdown(self.VTD.getValidTypes(self.VTD.ONLINE_REF_CATEGORY), \ 
     235                utils.getVocabTermDataDropdown(c.vtd.getValidTypes(c.vtd.ONLINE_REF_CATEGORY), \ 
    249236                                                     selected=link.rel) 
    250237 
     
    301288        Retrieve online reference data from inputs and set appropriately on Atom, if any 
    302289        found 
    303         @return: list of Link objects with the related links data 
     290        @return: list of Link objects containing the extracted data 
    304291        ''' 
    305292        logging.info("Extracting related links data from inputs") 
    306293        processedLinks = [] 
    307294        links = [] 
     295 
    308296        for key in inputs: 
    309297            keyBits = key.split('.') 
     
    313301                    link = Link() 
    314302                    keyStem = ".".join(keyBits[0:2]) 
    315                     # NB, adding an empty object here is valid as it will clear out 
    316                     # existing entries, potentially 
    317                     link.href = inputs.get(keyStem + '.href') or "" 
    318                     link.title = inputs.get(keyStem + '.title') or "" 
    319303                     
    320304                    if inputs.get(keyStem + ".remove"): 
     
    324308                        # processing 
    325309                        link.rel = self.getLatestTermURLFromDropDownInput(inputs.get(keyStem + '.rel')) 
     310                        link.href = inputs.get(keyStem + '.href') or "" 
     311                        link.title = inputs.get(keyStem + '.title') or "" 
    326312                             
    327313                        logging.info("Adding new online reference info") 
     
    329315                                      %(link.href, link.title, link.rel)) 
    330316                        links.append(link) 
     317 
    331318                    processedLinks.append(keyBits[1]) 
    332319                else: 
     
    337324 
    338325 
     326    def extractParameterDetails(self, inputs): 
     327        ''' 
     328        Retrieve parameters data from inputs and set appropriately on Atom, if any 
     329        found 
     330        @return: list of Category objects containing the extracted data 
     331        ''' 
     332        logging.info("Extracting parameters data from inputs") 
     333        processedParameters = [] 
     334        parameters = [] 
     335 
     336        for key in inputs: 
     337            keyBits = key.split('.') 
     338            if len(keyBits) == 3 and keyBits[1] not in processedParameters: 
     339                 
     340                if key.lower().startswith(Atom.PARAMETER_LABEL): 
     341                    parameter = Category() 
     342                    keyStem = ".".join(keyBits[0:2]) 
     343                     
     344                    if inputs.get(keyStem + ".remove"): 
     345                        logging.info("Removing parameters data") 
     346                    else: 
     347                        parameter.term = inputs.get(keyStem + '.term') or "" 
     348                        parameter.scheme = inputs.get(keyStem + '.scheme') or "" 
     349                        parameter.label = inputs.get(keyStem + '.label') or "" 
     350                             
     351                        logging.info("Adding new parameter info") 
     352                        logging.debug("Extracted parameter (vocabURL:'%s', label:'%s', term:'%s')" \ 
     353                                      %(parameter.scheme, parameter.label, parameter.term)) 
     354                        parameters.append(parameter) 
     355 
     356                    processedParameters.append(keyBits[1]) 
     357                else: 
     358                    continue 
     359 
     360        logging.info("Finished extracting parameters data") 
     361        return parameters 
     362 
     363 
    339364    def extractAtomAssociations(self, inputs): 
    340365        ''' 
     
    349374        for key in inputs: 
    350375            if key.lower().startswith(Atom.ATOM_REF_LABEL): 
    351                 (x, href, title, subtype) = key.split(Atom.DELIMITER) 
     376                (x, href, title, rel) = key.split(Atom.DELIMITER) 
    352377                # NB, we handle removes by effectively ignoring them later on 
    353                 if href not in processedAtoms and not subtype.endswith(Atom.REMOVE_LABEL): 
     378                if href not in processedAtoms: 
    354379                    processedAtoms.append(href) 
    355                      
     380 
    356381                    link = Link() 
    357                     # NB, adding an empty object here is valid as it will clear out 
    358                     # existing entries, potentially 
    359382                    link.href = href or "" 
    360383                    link.title = title or "" 
    361                     link.rel = subtype or "" 
    362                      
    363                     if inputs.get(key + Atom.REMOVE_LABEL): 
    364                         logging.info("Removing atom association") 
    365                     else: 
    366                         logging.info("Adding atom association") 
    367                         logging.debug("Extracted atom info (href:'%s', title:'%s', rel:'%s')" \ 
    368                                       %(link.href, link.title, link.rel)) 
    369                         atoms.append(link) 
     384                    link.rel = rel or "" 
     385                     
     386                    logging.debug("Extracted atom info (href:'%s', title:'%s', rel:'%s')" \ 
     387                                  %(link.href, link.title, link.rel)) 
     388                    atoms.append(link) 
    370389            else: 
    371390                continue 
     
    382401        ''' 
    383402        termData = inputVal.split('--') 
    384         return self.VTD.getCurrentVocabURI(termData[0]) + \ 
     403        return c.vtd.getCurrentVocabURI(termData[0]) + \ 
    385404                        "/" + termData[1] 
    386405 
     
    404423         
    405424     
    406     @validate(schema=CreateAtomFormSchema(), form='create') 
    407425    def create(self, saveData = None, **inputs): 
    408426        '''  
     
    410428        ''' 
    411429        if saveData: 
    412             logging.info("Creating basic atom") 
    413             self.__setup() 
    414             inputs = request.params 
    415             atomTypeID = inputs.get('atomTypeID').split('--')[1] 
    416             inputs['atomTypeID'] = atomTypeID 
    417  
    418             # activity deployments should have subtype deployment specified automatically 
    419             if atomTypeID == VTD.ACTIVITY_DEPLOYMENT_TERM: 
    420                 inputs['subtypeID'] = VTD.DEPLOYMENT_TERM 
    421                 inputs['atomTypeID'] = VTD.ACTIVITY_TERM 
    422                  
    423             inputs['providerID'] = inputs.get('providerID').split('--')[1] 
    424             atom = self.saveAtomToExist(Atom(**dict(inputs))) 
    425              
    426             h.redirect_to (controller = 'editatom', action='edit', 
    427                            uri = atom.ndgURI) 
     430            logging.info("Validating input") 
     431            try: 
     432                inputs = request.params 
     433                validator = CreateAtomFormSchema() 
     434                validator.to_python(inputs) 
     435                logging.info("- input valid") 
     436                 
     437                logging.info("Creating basic atom") 
     438                self.__setup() 
     439                atomTypeID = inputs.get('atomTypeID').split('--')[1] 
     440                inputs['atomTypeID'] = atomTypeID 
     441     
     442                # activity deployments should have subtype deployment specified automatically 
     443                if atomTypeID == c.vtd.ACTIVITY_DEPLOYMENT_TERM: 
     444                    inputs['subtypeID'] = c.vtd.DEPLOYMENT_TERM 
     445                    inputs['atomTypeID'] = c.vtd.ACTIVITY_TERM 
     446                     
     447                inputs['providerID'] = inputs.get('providerID').split('--')[1] 
     448                atom = self.saveAtomToExist(Atom(**dict(inputs))) 
     449                 
     450                h.redirect_to (controller = 'editatom', action='edit', 
     451                               uri = atom.ndgURI) 
     452            except Invalid, e: 
     453                c.errors = e.unpack_errors() 
     454                 
    428455             
    429456        logging.info("Setting up atom create template") 
    430         c.errors = {} 
    431457        c.title='Create new atom' 
    432458         
    433459        # set up the drop down content - NB, add special case, 'deployment activity' 
    434460        # - this is just a specialised activity - i.e. with subtype preset 
    435         deploymentActivity = self.VTD.TERM_DATA[self.VTD.ACTIVITY_DEPLOYMENT_TERM] 
    436         c.atomTypes = utils.getVocabTermDataDropdown(self.VTD.getValidTypes(self.VTD.ATOM_CATEGORY), 
    437                                                defaultVal = deploymentActivity) 
    438         c.providerIDs = utils.getVocabTermDataDropdown(self.VTD.getValidTypes(self.VTD.PROVIDER_CATEGORY)) 
     461        if not c.vtd: 
     462            c.vtd = VTD() 
     463        deploymentActivity = c.vtd.TERM_DATA[c.vtd.ACTIVITY_DEPLOYMENT_TERM] 
     464        c.atomTypes = utils.getVocabTermDataDropdown(c.vtd.getValidTypes(c.vtd.ATOM_CATEGORY), 
     465                                               defaultVal = deploymentActivity, \ 
     466                                               selected = inputs.get('atomTypeID')) 
     467        c.providerIDs = utils.getVocabTermDataDropdown( 
     468                            c.vtd.getValidTypes(c.vtd.PROVIDER_CATEGORY),  
     469                            selected = inputs.get('providerID')) 
    439470 
    440471        try: 
     
    442473 
    443474        except Exception, e: 
    444             #we may be showing an xml document ... but it could go wrong if 
    445             #we have crap content ... 
    446475            c.xml='Unexpected error loading page [%s]' %str(e) 
    447476            c.doc='' 
     
    450479        response.status_code = 400 
    451480        return render('error') 
    452  
    453  
    454  
    455      
    456     def askCorrect(self,uri): 
    457         ''' Provide a form (ajaxaciously) so that a user can correct a metadata record''' 
    458         status=self.__setup(uri) 
    459         c.uri=self.ndgObject 
    460         if status: return response.write(status) 
    461         return render('correct',fragment=True) 
    462  
    463      
    464     def correct(self,uri): 
    465         ''' Receive a correction form to update a record and post it to the holder ''' 
    466         status=self.__setup(uri) 
    467         if 'ndgSec' not in session: 
    468             return response.write('Not Logged In') 
    469         body='Metadata Change Request for %s'%uri 
    470         payload='<Change><uri>%s</uri><from>%s</from><Contents>%s</Contents></Change>'%( 
    471             self.inputs['Identifier'],self.inputs['Submitter'],self.inputs['Comment']) 
    472         name='ChangeRequestFor_%s.xml'%uri 
    473         status,message=mailer.mailHandler([self.cf.get('DEFAULT','metadataMaintainer'),], 
    474                        body,body,xmlAttachments=[(payload,name),], 
    475                        server=self.cf.get('DEFAULT','mailserver')) 
    476         if status: 
    477             c.xml='<p>Success: Mail sent to metadata maintainer</p>' 
    478         else: 
    479             c.xml=message 
    480         return render('content') 
    481          
    482  
    483     def __mytb(self,name): 
    484         ''' Get the trackback info for this page  
    485         (can't do it in Kid because it doesn't do substitutions in comments) ''' 
    486         s='''<!-- 
    487         <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
    488              xmlns:dc="http://purl.org/dc/elements/1.1/" 
    489              xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/"> 
    490         <rdf:Description 
    491             rdf:about="%s" 
    492             dc:identifier="%s" 
    493             dc:title="%s" 
    494             trackback:ping="%s" /> 
    495         </rdf:RDF> 
    496         -->'''%(self.ndgObject,g.server+h.url_for(),name,g.server+h.url_for(controller="trackback")) 
    497         return s 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/controllers/listatom.py

    r4302 r4315  
    6969        ''' 
    7070        try: 
    71             c.vtd = VTD() 
     71            if not c.vtd: 
     72                c.vtd = VTD() 
    7273     
    7374            inputs = request.params 
     
    8586            c.title='Browse atoms' 
    8687            c.assocAtomType = associatedAtomType 
    87             c.associateLink = h.url_for(controller='editatom', action='saveAtom', \ 
     88            c.associateLink = "" 
     89            if associatedAtomID: 
     90                c.associateLink = h.url_for(controller='editatom', action='saveAtom', \ 
    8891                    saveLevel = ec.ADD_ASSOCIATIONS, uri = associatedAtomID) 
    8992            c.searchLink = h.url_for(controller = 'listatom', action='list', \ 
     
    110113                    c.title += ' - to create associations with activity/data production tool/observation station data' 
    111114                    listVals = c.vtd.getValidTypes(c.vtd.DEPLOYABLE_ATOM_CATEGORY) 
     115                    defaultVal = allVal 
    112116            else: 
    113117                listVals = c.vtd.getValidTypes(c.vtd.ATOM_CATEGORY) 
    114118                defaultVal = allVal 
    115119             
    116                  
    117             #self.VTD.getTermItemfromFullVocabURI(c.atom.subtype) 
    118120            c.atomTypes = utils.getVocabTermDataDropdown(listVals, \ 
    119121                                                   defaultVal = defaultVal, \ 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/controllers/retrieve.py

    r4283 r4315  
    1010import logging 
    1111from ndgUtils.models.Atom import Atom 
     12from ndgUtils.vocabtermdata import VocabTermData as VTD 
    1213 
    1314class RetrieveController(BaseController): 
     
    146147                c.atom = Atom(xmlString=str(x), ndgObject = self.uri) 
    147148                c.r = info = self.__mytb('') 
     149                if not c.vtd: 
     150                    c.vtd = VTD() 
    148151                c.deploymentsURL = h.url_for(controller='retrieve', \ 
    149152                                             action='viewDeployments', \ 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/templates/atom.html

    r4283 r4315  
    3333                        <div py:replace="People('Author', [c.atom.author], None)"/> 
    3434                        <div py:replace="People('Contributors', c.atom.contributors, None)"/> 
    35                         <div py:replace="FullParameterList(c.atom.parameters)"/> 
     35                        <div py:replace="FullParameterList(c.atom.parameters, None, 'hidden')"/> 
    3636                        <div py:replace="SummaryParameterList(c.atom.parameters)"/> 
    3737                        <div py:replace="Coverage(None)"/> 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/templates/atom_editor.html

    r4302 r4315  
    6060                        <div py:replace="People('Author', [c.atom.author], c.saveLink)"/> 
    6161                        <div py:if="c.notDeployment" py:replace="People('Contributors', c.atom.contributors, c.saveLink)"/> 
    62                         <div py:if="c.notDeployment and not c.isGranule" py:replace="OnlineReferences(c.atom.relatedLinks, c.saveLink)"/> 
     62                        <div py:if="c.notDeployment and not c.isGranule" py:replace="OnlineReferences(c.atom.getLinksOfType(c.atom.ONLINE_REF_LABEL), c.saveLink)"/> 
    6363                        <div py:if="not c.notDeployment" py:replace="Associations('Associated Data', c.atom.relatedLinks, c.addEntityLink, c.saveAssoc)"/> 
    6464                        <div py:if="c.isDE" py:replace="Associations('Associated Data Granules', c.atom.getLinksOfType(c.vtd.GRANULE_TERM), c.addGranuleLink, c.saveAssoc)"/> 
    65                         <div py:if="c.isDE" py:replace="Associations('Associated Deployments', c.atom.getLinksOfType(c.vtd.DEPLOYMENT_TERM), c.addDeploymentLink, c.saveAssoc)"/> 
    66                         <div py:if="c.notDeployment" py:replace="FullParameterList(c.atom.parameters)"/> 
     65                        <div py:if="c.isDE" py:replace="Associations('Associated Deployments', c.atom.getLinksOfType(c.vtd.ACTIVITY_TERM), c.addDeploymentLink, c.saveAssoc)"/> 
     66                        <div py:if="c.notDeployment" py:replace="FullParameterList(c.atom.parameters, c.saveLink, '')"/> 
    6767                        <div py:replace="FullDeployments(c.atom.ME.deployments)"/> 
    6868                        <div py:replace="Coverage(c.saveLink)"/> 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/templates/atom_functions.html

    r4302 r4315  
    268268            <tr><td> 
    269269                <div id = "$divID"> 
    270                             <ul> 
    271                                 <li py:for="link in links"> 
    272                                     <?python 
    273                                 # get the default display value 
    274                                 displayVal = link.title  
    275                                 if not displayVal: 
    276                                                         vti = c.vtd.getTermItemfromFullVocabURI(link.rel) 
    277                                                         displayVal = vti.title 
    278                                 if not displayVal: 
    279                                                         displayVal = link.href or link.rel 
    280                                     ?> 
    281                                 <a href="$link.href">${displayVal}</a> 
    282                                 </li> 
    283                         </ul> 
    284                         <span py:if="not links">No data specified at present</span> 
     270                                <div py:if="links" py:replace="OnlineRefEditTable(links, None)"/> 
     271                        <span py:if="not links" py:strip="">No data specified at present</span> 
    285272                        </div> 
    286273                        </td></tr> 
     
    294281        </table> 
    295282    </div> 
     283 
     284 
     285        <div py:def="OnlineRefEditTable(links, editLink)"> 
     286                <form action="${editLink}" method="post"> 
     287                        <?python 
     288                                from ndgUtils.models.Atom import Atom as a 
     289                                refLabel = a.ONLINE_REF_LABEL + "." 
     290                                remLabel = "." + a.REMOVE_LABEL 
     291                                extraRows = 3 
     292                        ?> 
     293            <table> 
     294                <tr> 
     295                                <th align="left">Relation</th> 
     296                        <th py:if="editLink" align="left">URI</th> 
     297                        <th align="left">Title</th> 
     298                        <th py:if="links and editLink" align="center">Remove</th> 
     299                </tr> 
     300                    <tr py:for="i, link in enumerate(links)"> 
     301                            <?python 
     302                        # get the default display value type 
     303                        try: 
     304                                vti = c.vtd.getTermItemfromFullVocabURI(link.rel) 
     305                                displayType = vti.title or link.rel 
     306                        except: 
     307                                displayType = link.rel 
     308                            ?> 
     309                        <td> 
     310                                                <span py:if="editLink" py:strip=""> 
     311                                        ${Markup(h.select(refLabel + str(i) + '.rel', option_tags=c.relatedLinkSelectedLists[str(link)]))} 
     312                                                </span> 
     313                                        <span py:if="not editLink" py:strip=""> 
     314                                        ${displayType} 
     315                                                </span> 
     316                        </td> 
     317                        <td py:if="editLink"> 
     318                                    ${Markup(h.text_field(refLabel + str(i) + '.href', link.href))} 
     319                                        </td> 
     320                        <td> 
     321                                                <span py:if="editLink" py:strip=""> 
     322                                            ${Markup(h.text_field(refLabel + str(i) + '.title', link.title))} 
     323                                                </span> 
     324                                        <span py:if="not editLink" py:strip=""> 
     325                                                <a href="${link.href}">${link.title or link.href}</a> 
     326                                                </span> 
     327                        </td> 
     328                        <td py:if="editLink" align="center"> 
     329                                ${Markup(h.check_box(refLabel + str(i) + remLabel))} 
     330                        </td> 
     331                                </tr> 
     332                    <tr py:if="editLink" py:for="i in range(len(links), len(links) + extraRows)"> 
     333                        <td> 
     334                                        ${Markup(h.select(refLabel + str(i) + '.rel', option_tags=c.relatedLinkTerms))} 
     335                        </td> 
     336                        <td> 
     337                                    ${Markup(h.text_field(refLabel + str(i) + '.href'))} 
     338                        </td> 
     339                        <td> 
     340                                    ${Markup(h.text_field(refLabel + str(i) + '.title'))} 
     341                        </td> 
     342                        <td py:if="links" /> 
     343                                </tr> 
     344                        <tr py:if="editLink"><td> 
     345                    ${Markup(h.submit(value="Update"))} 
     346                </td></tr> 
     347                        </table> 
     348                </form> 
     349        </div> 
     350     
    296351 
    297352    <div class="metadataSection" py:def="Associations(sectionName, links, addLink, editLink)"> 
     
    358413                            <td><a href="$link.href">${displayVal}</a></td> 
    359414                        <td py:if="editLink and links" align="center"> 
    360                                 ${Markup(h.hidden_field(inputLabel))} 
    361                                 ${Markup(h.check_box(inputLabel + a.REMOVE_LABEL))} 
     415                                ${Markup(h.check_box(inputLabel))} 
    362416                        </td> 
    363417                                </tr> 
     
    374428 
    375429 
    376         <div py:def="OnlineRefEditTable(links, editLink)"> 
     430    <div py:def="FullParameterList(params, editLink, visibility)"> 
     431            <div class="metadataSection ${visibility}" id="fullParams"> 
     432        <?python         
     433                                divID = 'parametersDiv' 
     434                                edID = divID+'ed'  
     435                ?> 
     436        <table py:if="params or editLink"> 
     437            <tr><td class="linehead"> 
     438            <table> 
     439                    <tr><td>Parameters - details</td> 
     440                <td align="right"> 
     441                <a py:if="editLink" href="javascript:;" title="Toggle Form"  
     442                             onclick="swapLayers('$divID', '$edID'); return false;"> 
     443                        Add/Edit</a> 
     444                    <span py:if="not editLink" py:replace="expandHideSection('fullParams','summaryParams',g.navMinus)" strip=""/> 
     445            </td></tr></table></td></tr> 
     446            <tr><td> 
     447                <div id = "$divID"> 
     448                            <div py:replace="ParametersTable(params, None)"/> 
     449                        </div> 
     450                        </td></tr> 
     451                <tr py:if="editLink"><td> 
     452                        <div id="$edID" class="hidden"> 
     453                            <div py:replace="ParametersTable(params, editLink)"/> 
     454                        </div> 
     455                        </td></tr> 
     456 
     457        </table> 
     458        </div> 
     459    </div> 
     460 
     461 
     462    <div class="metadataSection" py:def="ParametersTable(params, editLink)" id="fullParams"> 
    377463                <form action="${editLink}" method="post"> 
    378464                        <?python 
    379465                                from ndgUtils.models.Atom import Atom as a 
    380                                 refLabel = a.ONLINE_REF_LABEL + "." 
     466                                refLabel = a.PARAMETER_LABEL + "." 
     467                                remLabel = "." + a.REMOVE_LABEL 
    381468                                extraRows = 3 
    382469                        ?> 
    383             <table> 
    384                 <tr> 
    385                                 <th align="left">Relation</th> 
    386                         <th align="left">URI</th> 
    387                         <th align="left">Title</th> 
    388                         <th py:if="links" align="center">Remove</th> 
     470                <table class="subTable"> 
     471                <tr py:if="params or editLink" class="cellhead"> 
     472                                <th align="left">Label</th> 
     473                                <th align="left">Vocab Term URL</th> 
     474                        <th align="left">Vocab Term ID</th> 
     475                                <th py:if="params and editLink" align="center">Remove</th> 
     476                        </tr> 
     477                                <tr py:if="not editLink and not params"> 
     478                                <td colspan="3">No data specified at present</td> 
    389479                </tr> 
    390                     <tr py:for="i, link in enumerate(links)"> 
     480                    <tr py:for="i, param in enumerate(params)"> 
    391481                        <td> 
    392                                         ${Markup(h.select(refLabel + str(i) + '.rel', option_tags=c.relatedLinkSelectedLists[str(link)]))} 
     482                                                <span py:if="editLink" py:strip=""> 
     483                                            ${Markup(h.text_field(refLabel + str(i) + '.label', param.label, class_="fullWidth"))} 
     484                                                </span> 
     485                                        <span py:if="not editLink" py:strip=""> 
     486                                                ${param.label} 
     487                                                </span> 
    393488                        </td> 
    394489                        <td> 
    395                                     ${Markup(h.text_field(refLabel + str(i) + '.href', link.href))} 
     490                                                <span py:if="editLink" py:strip=""> 
     491                                            ${Markup(h.text_field(refLabel + str(i) + '.scheme', param.scheme, class_="fullWidth"))} 
     492                                                </span> 
     493                                        <span py:if="not editLink" py:strip=""> 
     494                                                ${param.scheme} 
     495                                                </span> 
    396496                                        </td> 
    397497                        <td> 
    398                                     ${Markup(h.text_field(refLabel + str(i) + '.title', link.title))} 
    399                         </td> 
    400                         <td align="center"> 
    401                                 ${Markup(h.check_box(refLabel + str(i) + '.remove'))} 
     498                                                <span py:if="editLink" py:strip=""> 
     499                                            ${Markup(h.text_field(refLabel + str(i) + '.term', param.term, class_="fullWidth"))} 
     500                                                </span> 
     501                                        <span py:if="not editLink" py:strip=""> 
     502                                                ${param.term} 
     503                                                </span> 
     504                        </td> 
     505                        <td py:if="editLink" align="center"> 
     506                                ${Markup(h.check_box(refLabel + str(i) + remLabel))} 
    402507                        </td> 
    403508                                </tr> 
    404                     <tr py:for="i in range(len(links), len(links) + extraRows)"> 
     509                    <tr py:if="editLink" py:for="i in range(len(params), len(params) + extraRows)"> 
    405510                        <td> 
    406                                         ${Markup(h.select(refLabel + str(i) + '.rel', option_tags=c.relatedLinkTerms))} 
     511                                        ${Markup(h.text_field(refLabel + str(i) + '.label', class_="fullWidth"))} 
    407512                        </td> 
    408513                        <td> 
    409                                     ${Markup(h.text_field(refLabel + str(i) + '.href'))} 
     514                                    ${Markup(h.text_field(refLabel + str(i) + '.scheme', class_="fullWidth"))} 
    410515                        </td> 
    411516                        <td> 
    412                                     ${Markup(h.text_field(refLabel + str(i) + '.title'))} 
    413                         </td> 
    414                         <td py:if="links" /> 
     517                                    ${Markup(h.text_field(refLabel + str(i) + '.term', class_="fullWidth"))} 
     518                        </td> 
     519                        <td py:if="params" /> 
    415520                                </tr> 
    416                         <tr><td> 
     521                        <tr py:if="editLink"><td> 
    417522                    ${Markup(h.submit(value="Update"))} 
    418523                </td></tr> 
    419524                        </table> 
    420525                </form> 
    421         </div> 
    422  
    423  
    424     <div class="metadataSection hidden" py:def="FullParameterList(params)" id="fullParams"> 
    425         <table py:if="params"> 
    426             <tr><td class="linehead"> 
    427             <table> 
    428             <tr><td>Parameters - details</td> 
    429             <td align="right"> 
    430             <span py:replace="expandHideSection('fullParams','summaryParams',g.navMinus)" strip=""/> 
    431             </td></tr></table></td></tr> 
    432             <tr> 
    433             <table class="subTable"> 
    434                 <tr class="cellhead"><td>Label</td><td>Vocab term definition</td></tr> 
    435                         <tr py:for="param in params"> 
    436                                 <td>$param.label</td> 
    437                                 <td><a href="$param.scheme">$param.term</a></td> 
    438                         </tr> 
    439             </table> 
    440             </tr> 
    441         </table> 
    442526    </div> 
    443527 
     
    460544                                 <span py:if="not index%colNumber" py:strip=""> 
    461545                                 <span py:for="i in range(colNumber)" py:strip=""> 
    462                                         <td py:if="index &lt; fullLength - i">${params[index + i].label}</td> 
     546                                        <td py:if="index &lt; fullLength - i">${params[index + i].label or params[index + i].term or params[index + i].scheme}</td> 
    463547                                 </span> 
    464548                                 </span> 
     
    524608 
    525609    <div py:def="Temporal(editLink)" py:strip=""> 
    526                 <table><tr><td colspan="2" class="cellhead">Temporal coverage</td></tr> 
     610                <table><tr><td class="cellhead">Temporal coverage</td> 
     611                        <td py:if="editLink">(e.g. 1975-04-28)</td></tr> 
    527612            <span py:if="c.atom.t1 or c.atom.t2 or editLink" py:strip=""> 
    528613                                <tr><td>Start Date:</td> 
     
    596681         
    597682    <div py:def="Services()" id="ServiceList"> 
    598         <table cellspacing="0" cellpadding="3" width=" 100%" border="0"><tbody> 
     683        <table cellspacing="0" cellpadding="3" width="100%" border="0"><tbody> 
    599684            <tr><td class="linehead" colspan="3"><span class="headingO">Links and Services</span></td></tr> 
    600685            <tr py:if="c.atom.ndgObject is not None"> 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/templates/atom_list.html

    r4302 r4315  
    6262                                </tr> 
    6363                                <?python  
    64                                                 from ndgUtils.vocabtermdata import VocabTermData as VTD 
    6564                                        from ndgUtils.models.Atom import Atom as a 
    6665                                        delim = a.DELIMITER 
     
    106105                                </td> 
    107106                                <td py:if="allowAdd" align="center"> 
    108                                 ${Markup(h.check_box(refLabel + atom.href + delim + (atom.name or "") + delim + (atom.subtype or "")))} 
     107                                ${Markup(h.check_box(refLabel + atom.href + delim + (atom.name or "") + delim + (atom.type)))} 
    109108                                </td> 
    110109                                </tr> 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/templates/utils.html

    r4283 r4315  
    5050        </span> 
    5151    </span> 
    52      
    53                   
    54     <div py:def="txtBlkEd(key,default,divID,link)" class="txtBlk"> 
    55         <?python edID=divID+'ed'  
    56         ?> 
    57         <div id="$divID"> 
    58             <div class="txtBlkcon"> ${Markup(default)}  
    59             &nbsp;<span class="txtBlktog"> 
    60                 <a href="javascript:;" title="Toggle Form"  
    61                  onclick="toggleDiv(1,'$edID','shown','hidden','div'); return false;"> 
    62                 Edit</a> 
    63             </span></div> 
    64             <div id="$edID" class="hidden"> 
    65                 <div class="txtBlked"> 
    66                 ${Markup(h.form_remote_tag(url=link,update=divID) +  
    67                       h.hidden_field("divID",value=divID) + 
    68                       h.hidden_field("key",value=key) +  
    69                       h.text_area(key,default,size="172x10"))} 
    70                       <center> ${Markup(h.submit(value="Update"))}</center> 
    71                       ${Markup(h.end_form())} 
    72                  </div> 
    73             </div> 
    74         </div> 
    75    </div> 
    76    <div py:if='c.blkfrag' py:replace="txtBlkEd(c.key,c.default,c.divID,c.link)"/> 
    77      
    7852</html> 
Note: See TracChangeset for help on using the changeset viewer.