Changeset 22:b139f9937e97 in documentViewer


Ignore:
Timestamp:
Apr 6, 2006, 5:13:43 PM (18 years ago)
Author:
casties
Branch:
default
Message:

preliminary version 0.2

  • lots of stuff rewritten
  • new template system
  • still no access control
Files:
3 added
2 deleted
1 edited

Legend:

Unmodified
Added
Removed

  • documentViewer.py

    r20 r22  
    1717import cgi
    1818import urllib
     19import zLOG
    1920
    2021def getTextFromNode(nodename):
    … …  
    3738def getParamFromDigilib(path,param):
    3839    """gibt param von dlInfo aus"""
    39     imageUrl=genericDigilib+"/dlInfo-xml.jsp?fn="+path
    40 
     40    imageUrl=genericDigilib+"/dirInfo-xml.jsp?mo=dir&fn="+path
     41
     42    zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo (%s) from %s"%(param,imageUrl))
     43   
    4144    try:
    4245        dom = NonvalidatingReader.parseUri(imageUrl)
    … …  
    4447        return None
    4548   
    46    
    47     params=dom.xpath("//document-parameters/parameter[@name='%s']/@value"%param)
     49    params=dom.xpath("//dir/%s"%param)
     50    zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo:%s"%params)
    4851   
    4952    if params:
    50         return params[0].value
    51    
    52 def parseUrlTextTool(url):
    53    """parse index meta"""
    54    
    55    try:
    56        dom = NonvalidatingReader.parseUri(url)
    57    except:
    58        zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])
    59        return (None,None,None)
    60    
    61    archivePaths=dom.xpath("//resource/archive-path")
    62    
    63    if archivePaths and (len(archivePaths)>0):
    64        archivePath=getTextFromNode(archivePaths[0])
    65    else:
    66        archivePath=None
    67    
    68    
    69    images=dom.xpath("//texttool/image")
    70    
    71    if images and (len(images)>0):
    72        image=getTextFromNode(images[0])
    73    else:
    74        image=None
    75        
    76    if image and archivePath:
    77        image=os.path.join(archivePath,image)
    78        image=image.replace("/mpiwg/online",'')
    79        pt=getParamFromDigilib(image,'pt')
    80 
    81    else:
    82        image=None
    83        
    84    viewerUrls=dom.xpath("//texttool/digiliburlprefix")
    85    
    86    if viewerUrls and (len(viewerUrls)>0):
    87        viewerUrl=getTextFromNode(viewerUrls[0])
    88    else:
    89        viewerUrl=None
    90    
    91    
    92    textUrls=dom.xpath("//texttool/text")
    93    
    94    if textUrls and (len(textUrls)>0):
    95        textUrl=getTextFromNode(textUrls[0])
    96    else:
    97        textUrl=None
    98    return viewerUrl,(image,pt),textUrl
    99 
    100 
    101 class documentViewer(ZopePageTemplate):
     53        return getTextFromNode(params[0])
     54
     55   
     56
     57
     58##
     59## documentViewer class
     60##
     61class documentViewer(Folder):
    10262    """document viewer"""
    10363
    … …  
    10565   
    10666    security=ClassSecurityInfo()
    107     manage_options=ZopePageTemplate.manage_options+(
     67    manage_options=Folder.manage_options+(
    10868        {'label':'main config','action':'changeDocumentViewerForm'},
    10969        )
    11070
    111     _default_content_fn = os.path.join(package_home(globals()),'zpt','documentViewer_template.zpt')
    112    
    113     def __init__(self,id,imageViewerUrl,title=""):
     71    # templates and forms
     72    viewer_main = PageTemplateFile('zpt/viewer_main', globals())
     73    thumbs_main = PageTemplateFile('zpt/thumbs_main', globals())
     74    image_main = PageTemplateFile('zpt/image_main', globals())
     75    head_main = PageTemplateFile('zpt/head_main', globals())
     76    docuviewer_css = PageTemplateFile('css/docuviewer.css', globals())
     77
     78    security.declareProtected('View management screens','changeDocumentViewerForm')   
     79    changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
     80
     81   
     82    def __init__(self,id,imageViewerUrl,title="",digilibBaseUrl=None):
    11483        """init document viewer"""
    11584        self.id=id
    11685        self.title=title
    11786        self.imageViewerUrl=imageViewerUrl
    118        
    119     security.declareProtected('View management screens','changeDocumentViewerForm')   
    120     def changeDocumentViewerForm(self):
    121         """change it"""
    122         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeDocumentViewer.zpt')).__of__(self)
    123         return pt()
     87        self.digilibBaseUrl = digilibBaseUrl
     88        if not self.digilibBaseUrl:
     89            self.digilibBaseUrl = self.findDigilibUrl()
     90        # add template folder so we can always use template.something
     91        self.manage_addFolder('template')
     92
     93
     94    security.declareProtected('View','index_html')
     95    def index_html(self,mode,url,start=0,pn=1):
     96        '''
     97        view it
     98        @param mode: defines which type of document is behind url
     99        @param url: url which contains display information
     100        '''
     101       
     102        zLOG.LOG("documentViewer (index)", zLOG.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
     103        print "dlbaseurl:", self.digilibBaseUrl
     104       
     105        if not hasattr(self, 'template'):
     106            # create template folder if it doesn't exist
     107            print "no template folder -- creating"
     108            self.manage_addFolder('template')
     109           
     110        if not self.digilibBaseUrl:
     111            self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
     112           
     113        print "dlbaseurl:", self.digilibBaseUrl
     114
     115        docinfo = self.getDocinfo(mode=mode, url=url)
     116        pageinfo = self.getPageinfo(start=start,current=pn)
     117        pt = getattr(self.template, 'viewer_main')
     118        return pt(docinfo=docinfo,pageinfo=pageinfo)
    124119 
    125120 
    126     def changeDocumentViewer(self,imageViewerUrl,title="",RESPONSE=None):
    127         """init document viewer"""
    128         self.title=title
    129         self.imageViewerUrl=imageViewerUrl
    130        
    131         if RESPONSE is not None:
    132             RESPONSE.redirect('manage_main')
    133    
    134    
    135121    def imageLink(self,nr):
    136122        """link hinter den images"""
    … …  
    144130        return newUrl
    145131       
    146        
     132    def getStyle(self, idx, selected, style=""):
     133        """returns a string with the given style + 'sel' if path == selected."""
     134        #zLOG.LOG("documentViewer (getstyle)", zLOG.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
     135        if idx == selected:
     136            return style + 'sel'
     137        else:
     138            return style   
     139
     140           
    147141    def thumbruler(self,cols,rows,start,maximum):
    148142        """ruler for thumbs"""
    … …  
    163157
    164158
    165         ret+="""<select onChange="location.href='%s&start='+this.options[this.selectedIndex].value" """%newUrlSelect
     159        ret+="""<select onChange="location.href='%s&start='+this.options[this.selectedIndex].value">"""%newUrlSelect
    166160        nr,rest=divmod(maximum,cols*rows)
    167161        if rest > 0:
    … …  
    183177       
    184178        return ret
    185        
    186     def textToolThumb(self,url,start=0):
    187         """understands the texttool format
    188         @param url: url to index.meta with texttool tag
    189         """
    190         (viewerUrl,imagepath,textpath)=parseUrlTextTool(url)
    191        
    192         imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%imagepath[0]
    193        
    194         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)
    195         return pt(imageUrl=imageUrl,pt=imagepath[1],start=start)
    196    
    197     def imagePathThumb(self,path,start=0):
    198         """path ist the path to the images it is assumes that the index.meta file is one level higher."""
    199        
    200         path=path.replace("/mpiwg/online","")
    201         pt=getParamFromDigilib(path,'pt')
    202         imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%path
    203        
    204         pageT=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)
    205         return pageT(imageUrl=imageUrl,pt=pt,start=start)
    206    
    207     def headerFromIndexMeta(self,path):
    208         """gibt header from index meta out"""
    209        
     179   
     180       
     181       
     182    def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None):
     183        """gets bibliographical info from the index.meta file at url or given by dom"""
     184        zLOG.LOG("documentViewer (getbibinfofromindexmeta)", zLOG.INFO,"path: %s"%(path))
     185       
     186        if docinfo is None:
     187            docinfo = {}
     188           
    210189        metaData=self.metadata.main.meta.bib
    211         server="http://foxridge.mpiwg-berlin.mpg.de"
    212         path="/".join(path.split("/")[0:-1])
    213         metaUrl=server+path+"/index.meta"
    214        
    215         dom = NonvalidatingReader.parseUri(metaUrl)
     190        if dom is None:
     191            server="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn="
     192            path="/".join(path.split("/")[0:-1])
     193            metaUrl=server+path+"/index.meta"
     194            try:
     195                dom = NonvalidatingReader.parseUri(metaUrl)
     196            except:
     197                return docinfo
     198       
    216199        type=dom.xpath("//bib/@type")
    217200        if type and (len(type)>0):
    … …  
    221204        type=type.replace("-"," ")# wrong typesiin index meta "-" instead of " "
    222205        hash=metaData.generateMappingForType(type)
    223    
    224         author=getTextFromNode(dom.xpath("//bib/%s"%hash['author'][0])[0])
    225         title=getTextFromNode(dom.xpath("//bib/%s"%hash['title'][0])[0])
    226         year=getTextFromNode(dom.xpath("//bib/%s"%hash['year'][0])[0])
    227        
    228         return author,title,year
    229        
     206
     207        docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%hash['author'][0])[0])
     208        docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%hash['title'][0])[0])
     209        docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%hash['year'][0])[0])
     210       
     211        return docinfo
     212
     213       
     214    def getDocinfoFromTextTool(self,url,docinfo=None):
     215       """parse texttool tag in index meta"""
     216       zLOG.LOG("documentViewer (getdocinfofromtexttool)", zLOG.INFO,"url: %s"%(url))
     217       if docinfo is None:
     218           docinfo = {}
     219           
     220       try:
     221           dom = NonvalidatingReader.parseUri(url)
     222       except:
     223           zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])
     224           return docinfo
     225       
     226       archivePaths=dom.xpath("//resource/archive-path")
     227       
     228       if archivePaths and (len(archivePaths)>0):
     229           archivePath=getTextFromNode(archivePaths[0])
     230       else:
     231           archivePath=None
     232       
     233       images=dom.xpath("//texttool/image")
     234       
     235       if images and (len(images)>0):
     236           image=getTextFromNode(images[0])
     237       else:
     238           image=None
     239           
     240       if image and archivePath:
     241           image=os.path.join(archivePath,image)
     242           image=image.replace("/mpiwg/online",'')
     243           pt=getParamFromDigilib(image,'size')
     244           docinfo['imagePath'] = image
     245           docinfo['numberOfPages'] = pt
     246           
     247       viewerUrls=dom.xpath("//texttool/digiliburlprefix")
     248       
     249       if viewerUrls and (len(viewerUrls)>0):
     250           viewerUrl=getTextFromNode(viewerUrls[0])
     251           docinfo['imageURL'] = viewerURL
     252                 
     253       textUrls=dom.xpath("//texttool/text")
     254       
     255       if textUrls and (len(textUrls)>0):
     256           textUrl=getTextFromNode(textUrls[0])
     257           docinfo['textURL'] = textURL
     258                     
     259       docinfo = self.getBibinfoFromIndexMeta(url,docinfo=docinfo,dom=dom)
     260       return docinfo
     261   
     262
     263    def getDocinfoFromImagePath(self,path,docinfo=None):
     264        """path ist the path to the images it assumes that the index.meta file is one level higher."""
     265        zLOG.LOG("documentViewer (getdocinfofromimagepath)", zLOG.INFO,"path: %s"%(path))
     266        if docinfo is None:
     267            docinfo = {}
     268        docinfo['imagePath'] = path
     269        path=path.replace("/mpiwg/online","")
     270        pt=getParamFromDigilib(path,'size')
     271        docinfo['numberOfPages'] = pt
     272        imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%path
     273        docinfo['imageURL'] = imageUrl
     274       
     275        docinfo = self.getBibinfoFromIndexMeta(path,docinfo=docinfo)
     276        return docinfo
     277   
     278   
     279    def getDocinfo(self, mode, url):
     280        """returns docinfo depending on mode"""
     281        zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"mode: %s, url: %s"%(mode,url))
     282        # look for cached docinfo in session
     283        if self.REQUEST.SESSION.has_key('docinfo'):
     284            docinfo = self.REQUEST.SESSION['docinfo']
     285            # check if its still current
     286            if docinfo is not None and docinfo.get('mode') == mode and docinfo.get('url') == url:
     287                zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo in session: %s"%docinfo)
     288                return docinfo
     289        # new docinfo
     290        docinfo = {'mode': mode, 'url': url}
     291        if mode=="texttool": #index.meta with texttool information
     292            docinfo = self.getDocinfoFromTextTool(url, docinfo=docinfo)
     293        elif mode=="imagepath":
     294            docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo)
     295        else:
     296            zLOG.LOG("documentViewer (getdocinfo)", zLOG.ERROR,"unknown mode!")
     297        zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo: %s"%docinfo)
     298        self.REQUEST.SESSION['docinfo'] = docinfo
     299        return docinfo
     300       
     301       
     302    def getPageinfo(self, start, current):
     303        """returns pageinfo with the given parameters"""
     304        pageinfo = {}
     305        pageinfo['start'] = start
     306        pageinfo['current'] = current
     307        return pageinfo
     308               
    230309    def text(self,mode,url,pn):
    231310        """give text"""
    … …  
    280359#
    281360#        return list
    282 #   
     361#
     362
    283363    def image(self,mode,url,pn):
    284364        """give image out"""
    … …  
    297377           
    298378       
    299     def thumbs(self,mode,url,start):
    300         """give thumbs out"""
    301         if mode=="texttool": #index.meta with texttool information
    302             return self.textToolThumb(url,int(start))
    303         elif mode=="imagepath":
    304             return self.imagePathThumb(url,int(start))
    305        
    306     security.declareProtected('View','index_html')
    307    
    308    
    309     def index_html(self,mode,url,start=0,pn=1):
    310         '''
    311         view it
    312         @param mode: defines which type of document is behind url
    313         @param url: url which contains display information
    314         '''
    315        
    316    
    317         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','documentViewer_template.zpt')).__of__(self)
    318         return pt(mode=mode,url=url,start=start,pn=pn)
    319        
     379    def findDigilibUrl(self):
     380        """try to get the digilib URL from zogilib"""
     381        url = self.imageViewerUrl[:-1] + "/getScalerUrl"
     382        try:
     383            scaler = urlopen(url).read()
     384            return scaler.replace("/servlet/Scaler?", "")
     385        except:
     386            return None
     387   
     388    def changeDocumentViewer(self,imageViewerUrl,title="",digilibBaseUrl=None,RESPONSE=None):
     389        """init document viewer"""
     390        self.title=title
     391        self.imageViewerUrl=imageViewerUrl
     392        self.digilibBaseUrl = digilibBaseUrl
     393       
     394        if RESPONSE is not None:
     395            RESPONSE.redirect('manage_main')
     396   
     397   
    320398       
    321399       
    … …  
    324402def manage_AddDocumentViewerForm(self):
    325403    """add the viewer form"""
    326     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addDocumentViewer.zpt')).__of__(self)
     404    pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
    327405    return pt()
    328406 
    … …  
    334412    if RESPONSE is not None:
    335413        RESPONSE.redirect('manage_main')
    336    
     414
     415
     416##
     417## DocumentViewerTemplate class
     418##
     419class DocumentViewerTemplate(ZopePageTemplate):
     420    """Template for document viewer"""
     421    meta_type="DocumentViewer Template"
     422
     423
     424def manage_addDocumentViewerTemplateForm(self):
     425    """Form for adding"""
     426    pt=PageTemplateFile('zpt/addDocumentViewerTemplate', globals()).__of__(self)
     427    return pt()
     428
     429def manage_addDocumentViewerTemplate(self, id='viewer_main', title=None, text=None,
     430                           REQUEST=None, submit=None):
     431    "Add a Page Template with optional file content."
     432
     433    self._setObject(id, DocumentViewerTemplate(id))
     434    ob = getattr(self, id)
     435    ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/viewer_main.zpt')).read(),None)
     436    if title:
     437        ob.pt_setTitle(title)
     438    try:
     439        u = self.DestinationURL()
     440    except AttributeError:
     441        u = REQUEST['URL1']
     442       
     443    u = "%s/%s" % (u, urllib.quote(id))
     444    REQUEST.RESPONSE.redirect(u+'/manage_main')
     445    return ''
     446
     447
     448   
Note: See TracChangeset for help on using the changeset viewer.