source: TI07-MOLES/trunk/PythonCode/wsgi/renderDiscoverySet.py @ 2392

from DiscoveryState import DiscoveryState
from ndgSearch import ndgSearch
from DIF import DIF
from htmlUtilities import *
from renderService import *
debug=1

def CalculateStride(start,stride,total):
    ''' Work out the previous and next chunks, returns a list of lists, the first of which
    is the start and offset of the next chunk, the second of which is the staft and offset 
    of the previous chunk '''
    result=[]
    defStride=10
    if start+stride<total:
        #there are more to look at
        r=[start+stride,stride]
        if r[0]+r[1]-1>total: r[1]=total+1-r[0]
        result.append(r)
    else:result.append([])
    if start>1:
        #there are previous records
        b=max(stride,defStride)
        r=[start-b,b]
        if r[0]<1: r[0]=1
        if r[1]>total: r[1]=total
        result.append(r)
    else: result.append([])
    return result
    
def htmlStride(state):
    ''' Given the previous and next list from CalculateStride, and the
    current state class (which provides a method for the fundamental URL,
    return a previous next piece of html '''
    html='<p>Results %s to %s of %s'%(state.offset,state.offset+state.stride-1,state.hits)
    r=CalculateStride(state.offset,state.stride,state.hits)
    if r[0]<>[]:
        s1='Next %s'%r[0][1]
        nexturl=state.geturl(offset=r[0][0],stride=r[0][1])
        html+=', %s'%hyperlink(s1,nexturl)
    if r[1]<>[]:
        l1='Previous %s'%r[1][1]
        lasturl=state.geturl(offset=r[1][0],stride=r[1][1])
        html+=', %s'%hyperlink(l1,lasturl)
    html+='.</p>'
    return html
    
        
def renderDiscoverySet(difSet,state,config,summary=0,services=0,spatial=0,temporal=0,
    linkto='NDG_B_SERVICE',selector=None):
    '''Takes a set of xml DIFS from a discovery search (difSet) and renders a 
    list of responses as a table, with layout depending on a set of keywords:
            summary (boolean) - show the abstract,
            services (boolean) - show the service list,
            spatial (boolean) - show the bounding box,
            temporal (boolean) - show the date range,
            linkto (string) - clicking on the select widget should add the url for
                              this service to the selected list
     Note that state is a DiscoveryState instance containing the sessionID from the search,
     and the offset, stride, and total number of results ...selector is a class for adding
     particular datasets to a selection dataset (and cookie).
     '''
            
    #
    # List of methods which deal with the actual row content ...
    #   
    
    def row(rowList,bgcolor='rbgWhite'):
        h='<tr class="%s">'%bgcolor
        for item in rowList:
            if type(item)==type((1,2)):
                h+='<td colspan="%s">%s</td>'%(item[1],item[0])
            else:h+='<td>%s</td>'%item
        h+='</tr>'
        return h#span(h,bgcolor)

    def spatialBox(elem):
        return elem.bbox.toHTMLbox()
     
    def temporalRange(elem):
        return ''
   
    def serviceList(d):
        ll=span(' Links: ','ndgem')
        ndg=0
        serviceRenderer=renderService(config)
        if d.binding is not None: ll+=serviceRenderer.get(d.binding)[0]
        for i in d.services: print i.url
        for item in d.services:
            ll+=', '
            #s=0
            if item.contentType == 'NDG_A_SERVICE': 
                ndg+=1
            elif item.contentType == 'NDG_B_SERVICE':
                ndg+=1
            print 'starting services',item.url
            ll+=serviceRenderer.get(item)[0]
            print 'finishing services',item.url
        if ndg<2: ndg=0
        return ndg,ll

    
    # ##################################
    # Actual html production follows
    # ##################################
    
    # depending on keyword options, provide column headings
    #
    
    columns=['Dataset',]   
    if spatial: columns.append('Location')
    if temporal: 
        #two columns for temporal but put a column header across both columns
        header='''<table><tbody><tr><td colspan="2" align="center">Time&nbsp;Coverage</td></tr><tr>
        <td align="center">Start</td><td align="center"> End</td></tr></tbody></table>'''
        columns.append((header,2))
    html='<div class="ListOfResults"><table><tbody>'+row(columns,bgcolor="rbgBeige")
    
    # ok, now let's cycle through the hits
    i=1
    for item in difSet:
        #print item.entryID
        d=item # we used to do the diffing here ... but we don't anymore
        bgc={1:'rbgWhite',-1:'rbgGrey'}[i]
        i=-1*i
        if debug: print 'Rendering ',d.entryID
        if d.tree is None:
            html+='<tr class="%s"><td colspan="%s"> Unparseable record </td></tr>'%(bgc,len(columns))
        else:
            ndg,slist=serviceList(d)
            rlist=['',]
            if summary:
                if d.briefCitation <>'':
                    rlist[0]='%s: %s'%(span('Citation','ndgem'),d.briefCitation)
                else:
                    rlist[0]='%s: %s'%(span('Title','ndgem'),abbreviate(d.name,60))
                rlist[0]+='<br/>%s: %s'%(span('Summary','ndgem'),abbreviate(d.abstract,200))
                if d.binding is not None: rlist[0]+=' '+hyperlink('(more)',d.binding.url)
            rlist[0]+='<br/>%s: %s.'%(span('Repository','ndgem'),d.centre.url())
            if not summary and d.binding is not None:
                rlist[0]+=' '+hyperlink('(more)',d.binding.url)
            if services:rlist[0]+=slist
            if ndg and selector !=None: 
                rlist[0]+=',&nbsp;'+selector.target(d.entryID,name=d.abbreviation)
            if spatial: rlist.append(spatialBox(d))
            if temporal: 
                rlist.append(htmlTime(d.timeCoverage[0]))
                rlist.append(htmlTime(d.timeCoverage[1]))
            html+=row(rlist,bgcolor=bgc)
        print 'Completed rendering ',d.entryID

    html+='</tbody></table>'
    html+=htmlStride(state)+'</div>'
    return html

import unittest

class TestCase(unittest.TestCase):

    def testStrideself(self):
        ''' Test striding through a dataset '''
        res=CalculateStride(1,10,15)
        self.assertEqual([[11,5],[]],res)
        res=CalculateStride(11,5,15)
        self.assertEqual([[],[1,10]],res)
        res=CalculateStride(11,10,50)
        self.assertEqual([[21,10],[1,10]],res)
  
    def testHtmlStride(self):
        ''' Test the html striding part '''
        DummyEnviron={'QUERY_STRING':'start=10&howmany=10','HTTP_HOST':'example.ndg',
                      'PATH_INFO':'/discovery','wsgi.url_scheme':'http','SERVER_PORT':'80'}
        d=DiscoveryState('123',DummyEnviron,12)
        html=htmlStride(d)
        print html
        
if __name__=="__main__":
    unittest.main()