source: MILK/trunk/milk_server/milk_server/models/DiscoveryState.py @ 5485

from paste.request import parse_querystring
from milk_server.lib.Utilities import getURLConstraints
import cgi,urllib

    
def getURLFormattedConstraints(environ, **kw):
    ''' 
    Get the constraints in a url friendly string - modified by the keyword arguments 
    offset and stride which are to be part of the querystring
    @param environ: wsgi environ object
    @return constraints in a url friendly string 
    '''
    args = dict(parse_querystring(environ))

    constrained = kw.get('constrained')
    if not constrained:
        offset, stride = kw.get('offset'), kw.get('stride')
        if offset:
            args['start'] = offset
        if stride:
            args['howmany'] = stride

    q = ''
    for i in args:
        # NB, the constraints may already be encoded as a hidden variable
        if i != 'constraints':
            q+='%s=%s&'%(i,args[i])

    # add constraints last to avoid duplicate params - NB, constraint params
    # can be overridden by direct inputs to the page
    if 'constraints' in args:
        constraints = getURLConstraints(args['constraints'])
        for key, val in constraints.items():
            if key not in args:
                q+='%s=%s&'%(key, val)

    return q[0:-1]


def getURL(environ, **kw):
    ''' 
    Get a url from the wsgi environment
    @param environ: wsgi environ object
    @return url with constraints added from wsgi environ
    '''
    constraints = getURLFormattedConstraints(environ, **kw)
    return urllib.quote(environ.get('SCRIPT_NAME','')) + \
        urllib.quote(environ.get('PATH_INFO','')) + '?' + constraints


class constraints:
    ''' 
    A container object for constraints on a search 
    '''
    def __init__(self, **kw):
        self.values={}
        keys=['dateRange','bbox','scope','textTarget','searchString','geoSearchType']
        for key in keys:
            self.values[key]=None
        for k in kw: 
            self[k]=kw[k]
            
            
    def __setitem__(self, key, value):
        if key in self.values:
            self.values[key]=value
        else:
            raise ValueError('Unknown key [%s] in constraints')

    
    def __getitem__(self,key):
        if key in self.values: 
            return self.values[key]
        else:
            raise ValueError('Unknown key [%s] in constraints'%key)

    
    def __str__(self):
        c=''
        if self.values['dateRange'] is not None:
            dr = self.values['dateRange'] 
            c += 'Date range: %s to %s'%('%s/%s/%s'%dr[0],'%s/%s/%s'%dr[1])
        bbox=self.values['bbox']
        if c:
            c += ', '

        c += 'Bounding box: '
        
        #Need to put workaround for browsers that dont let map window global search = 180 etc..
        #if bbox is None or bbox==['90.0','-180.0','180.0','-90.0']:
        
        if bbox is None or ((float(bbox[0]) >= 89) & (float(bbox[1]) <= -179) & (float(bbox[2]) >= 179) & (float(bbox[3]) <= 89)):
            
            c+='Global'
            
        else:
            overlaps = self.values['geoSearchType'] or 'overlaps'
            c+='%s latitude %s to %sN and longitude %s to %sE' \
                %(overlaps,bbox[3],bbox[0],bbox[1],bbox[2])
                
                
           # c+='Global' # fudge sjd
        if self.values['scope']:
            if c:
                c += ', ' 
            c += 'Scope: %s'%self.values['scope']
        if self.values['textTarget']:
            if c:
                c += ', ' 
            c += 'Target: %s'%self.values['textTarget']
        return c


class PagerState:
    '''
    Object to hold the current page state of the displayed results - e.g. which
    page number and how many records, before and after those displayed, are available
    '''
    
    def __init__(self, hits, environ, offset=1, stride=10, defaultStride = 10):
        '''
        Initialise PagerState object
        @param hits: total number of records available to view
        @param environ: wsgi environ object    
        @keyword offset: offset being used in the currently displayed record set
        - i.e. the array number of the topmost record displayed. Default = 1
        @keyword stride: Number of records currently visible.  Default = 10
        @keyword defaultStride: Standard number of records to display on a page.
        Default = 10 
        '''
        self.hits = hits
        self.offset = offset
        self.stride = stride

        self.previousPageURL = None
        self.previousNumber = None
        self.startPageURL = None
        self.nextPageURL = None
        self.nextNumber = None
        self.lastPageURL = None
        
        self.defaultStride = defaultStride
        
        n, p = self.getNext()
        start, end = "", ""
        if p:
            self.previousPageURL = getURL(environ, offset = p[0], stride = p[1])
            self.previousNumber = p[1]
            self.startPageURL = getURL(environ, offset = 1, stride = self.defaultStride)
        if n:
            self.nextPageURL = getURL(environ, offset = n[0], stride = n[1])
            self.nextNumber = n[1]
            off = self.hits - self.defaultStride + 1
            if off < 1:
                off = 1
            self.lastPageURL = getURL(environ, offset = off, stride = self.defaultStride)
            
        self.upperRange = self.offset + self.stride - 1
        self.lowerRange = self.offset
        
    
    def getNext(self):
        ''' 
        Get info on what number of records are available on current page
        @return result - list with format [[offSetForNextPage, numberOfRecordsOnNextPage],
                                           [offSetForLastPage, numberOfRecordsOnLastPage]]
        '''
        result=[]
        if self.offset+self.stride < self.hits:
            #there are more to look at
            r = [self.offset+self.stride, self.stride]
            if r[0]+r[1]-1 > self.hits: 
                r[1] = self.hits+1-r[0]
            result.append(r)
        else:
            result.append([])
            
        if self.offset > 1:
            #there are previous records
            b = max(self.stride, self.defaultStride)
            r = [self.offset-b,b]
            if r[0] < 1: 
                r[0] = 1
            if r[1] > self.hits: 
                r[1] = self.hits
            result.append(r)
        else: 
            result.append([])
        return result
        
    

class DiscoveryState:
    ''' This class holds the state associated with a search (including presenting multiple slices
    of a large result set) '''
    def __init__(self,sessionID,searchString,environ,hits,constraints,offset=1,stride=10):
        ''' On instantiation, provide
                the backend sessionID
                the application URL that produced this query
                the stride through the result set '''
        self.environ=environ # the wsgi environment
        self.constraintsInstance=constraints
        self.constraints=str(constraints) # some text to show constraints on search
        self.urlformattedconstraints = getURLFormattedConstraints(self.environ)
        self.sessID=sessionID
        self.hits=hits

        self.searchString=searchString
        self.alternatives=None
        self.constrainedurl = getURL(self.environ, constrained=1)+'&constrained'
        self.pager = PagerState(hits, self.environ, offset=offset, stride=stride)
        
    def __str__(self):
        return ''' 
___ Discovery State ___
searchString: %s
constraints: %s
sessionID: %s
hits: %s
offset,stride: %s,%s
environment: %s
========================
'''%(self.searchString,self.constraints,self.sessID,self.hits,self.offset,self.stride,self.environ)