[BACK]Return to documentViewer.py CVS log [TXT] [DIR] Up to [Repository] / documentViewer

Diff for /documentViewer/documentViewer.py between versions 1.2 and 1.69.2.1

version 1.2, 2005/12/23 14:01:29 version 1.69.2.1, 2010/06/14 10:49:48
Line 1 Line 1
   
 genericDigilib="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/"  
   
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   from Products.PythonScripts.standard import url_quote
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
   from AccessControl import getSecurityManager
 from Globals import package_home  from Globals import package_home
   
 from Ft.Xml.Domlette import NonvalidatingReader  from Ft.Xml.Domlette import NonvalidatingReader
 from Ft.Xml.Domlette import PrettyPrint, Print  from Ft.Xml.Domlette import PrettyPrint, Print
 from Ft.Xml import EMPTY_NAMESPACE  from Ft.Xml import EMPTY_NAMESPACE, Parse
   
 import Ft.Xml.XPath  from xml.dom.minidom import parse, parseString
   
   from extraFunction import *
   
   
   import Ft.Xml.XPath
   import cStringIO
   import xmlrpclib
 import os.path  import os.path
   import sys
 import cgi  import cgi
 import urllib  import urllib
   import logging
   import math
   
   import urlparse 
   from types import *
   
   def logger(txt,method,txt2):
       """logging"""
       logging.info(txt+ txt2)
       
       
   def getInt(number, default=0):
       """returns always an int (0 in case of problems)"""
       try:
           return int(number)
       except:
           return int(default)
   
 def getTextFromNode(nodename):  def getTextFromNode(nodename):
       """get the cdata content of a node"""
       if nodename is None:
           return ""
     nodelist=nodename.childNodes      nodelist=nodename.childNodes
     rc = ""      rc = ""
     for node in nodelist:      for node in nodelist:
Line 25  def getTextFromNode(nodename): Line 52  def getTextFromNode(nodename):
            rc = rc + node.data             rc = rc + node.data
     return rc      return rc
   
   def serializeNode(node, encoding='utf-8'):
       """returns a string containing node as XML"""
       buf = cStringIO.StringIO()
       Print(node, stream=buf, encoding=encoding)
       s = buf.getvalue()
       buf.close()
       return s
   
           
   def getParentDir(path):
       """returns pathname shortened by one"""
       return '/'.join(path.split('/')[0:-1])
           
   
 import socket  import socket
   
 def urlopen(url):  def urlopen(url,timeout=2):
         """urlopen mit timeout"""          """urlopen mit timeout"""
         socket.setdefaulttimeout(2)          socket.setdefaulttimeout(timeout)
         ret=urllib.urlopen(url)          ret=urllib.urlopen(url)
         socket.setdefaulttimeout(5)          socket.setdefaulttimeout(5)
         return ret          return ret
           
 def getParamFromDigilib(path,param):  
     """gibt param von dlInfo aus"""  
     imageUrl=genericDigilib+"/dlInfo-xml.jsp?fn="+path  
   
     try:  ##
         dom = NonvalidatingReader.parseUri(imageUrl)  ## documentViewer class
     except:  ##
         return None  class documentViewer(Folder, extraFunction):
       """document viewer"""
       #textViewerUrl="http://127.0.0.1:8080/HFQP/testXSLT/getPage?"
           
       meta_type="Document viewer"
       
       security=ClassSecurityInfo()
       manage_options=Folder.manage_options+(
           {'label':'main config','action':'changeDocumentViewerForm'},
           )
   
       # templates and forms
       viewer_main = PageTemplateFile('zpt/viewer_main', globals())
       toc_thumbs = PageTemplateFile('zpt/toc_thumbs', globals())
       toc_text = PageTemplateFile('zpt/toc_text', globals())
       toc_figures = PageTemplateFile('zpt/toc_figures', globals())
       page_main_images = PageTemplateFile('zpt/page_main_images', globals())
       page_main_text = PageTemplateFile('zpt/page_main_text', globals())
       page_main_text_dict = PageTemplateFile('zpt/page_main_text_dict', globals())
       page_main_xml = PageTemplateFile('zpt/page_main_xml', globals())
       head_main = PageTemplateFile('zpt/head_main', globals())
       docuviewer_css = PageTemplateFile('css/docuviewer.css', globals())
       info_xml = PageTemplateFile('zpt/info_xml', globals())
           
     params=dom.xpath("//document-parameters/parameter[@name='%s']/@value"%param)  
           
     if params:      thumbs_main_rss = PageTemplateFile('zpt/thumbs_main_rss', globals())
         return params[0].value      security.declareProtected('View management screens','changeDocumentViewerForm')    
       changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
           
 def parseUrlTextTool(url):  
    """parse index meta"""  
           
       def __init__(self,id,imageScalerUrl=None,textServerName=None,title="",digilibBaseUrl=None,thumbcols=2,thumbrows=5,authgroups="mpiwg"):
           """init document viewer"""
           self.id=id
           self.title=title
           self.thumbcols = thumbcols
           self.thumbrows = thumbrows
           # authgroups is list of authorized groups (delimited by ,)
           self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
           # create template folder so we can always use template.something
           
           templateFolder = Folder('template')
           #self['template'] = templateFolder # Zope-2.12 style
           self._setObject('template',templateFolder) # old style
    try:     try:
        dom = NonvalidatingReader.parseUri(url)              from Products.XMLRpcTools.XMLRpcTools import XMLRpcServerProxy
    except:              xmlRpcClient = XMLRpcServerProxy(id='fulltextclient', serverUrl=textServerName, use_xmlrpc=False)
        zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])              #templateFolder['fulltextclient'] = xmlRpcClient
        return (None,None,None)              templateFolder._setObject('fulltextclient',xmlRpcClient)
           except Exception, e:
               logging.error("Unable to create XMLRpcTools for fulltextclient: "+str(e))
           try:
               from Products.zogiLib.zogiLib import zogiLib
               zogilib = zogiLib(id="zogilib", title="zogilib for docuviewer", dlServerURL=imageScalerUrl, layout="book")
               #templateFolder['zogilib'] = zogilib
               templateFolder._setObject('zogilib',zogilib)
           except Exception, e:
               logging.error("Unable to create zogiLib for zogilib: "+str(e))
         
    archivePaths=dom.xpath("//resource/archive-path")  
         
    if archivePaths and (len(archivePaths)>0):      security.declareProtected('View','thumbs_rss')
        archivePath=getTextFromNode(archivePaths[0])      def thumbs_rss(self,mode,url,viewMode="auto",start=None,pn=1):
           '''
           view it
           @param mode: defines how to access the document behind url 
           @param url: url which contains display information
           @param viewMode: if images display images, if text display text, default is images (text,images or auto)
           
           '''
           logging.debug("HHHHHHHHHHHHHH:load the rss")
           logger("documentViewer (index)", logging.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
           
           if not hasattr(self, 'template'):
               # create template folder if it doesn't exist
               self.manage_addFolder('template')
               
           if not self.digilibBaseUrl:
               self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
               
           docinfo = self.getDocinfo(mode=mode,url=url)
           pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)
           pt = getattr(self.template, 'thumbs_main_rss')
           
           if viewMode=="auto": # automodus gewaehlt
               if docinfo.get("textURL",'') and self.textViewerUrl: #texturl gesetzt und textViewer konfiguriert
                   viewMode="text"
    else:     else:
        archivePath=None                  viewMode="images"
                  
           return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode)
     
       security.declareProtected('View','index_html')
       def index_html(self,url,mode="texttool",viewMode="auto",tocMode="thumbs",start=None,pn=1,mk=None, query=None, querySearch=None):
           '''
           view it
           @param mode: defines how to access the document behind url 
           @param url: url which contains display information
           @param viewMode: if images display images, if text display text, default is auto (text,images or auto)
           @param tocMode: type of 'table of contents' for navigation (thumbs, text, figures, none)
           @param querySearch: type of different search modes (fulltext, fulltextMorph, xpath, xquery, ftIndex, ftIndexMorph, fulltextMorphLemma)
           '''
           
           logging.debug("documentViewer (index) mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
         
           if not hasattr(self, 'template'):
               # this won't work
               logging.error("template folder missing!")
               return "ERROR: template folder missing!"
           
    images=dom.xpath("//texttool/image")          if not getattr(self, 'digilibBaseUrl', None):
               self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
         
    if images and (len(images)>0):          docinfo = self.getDocinfo(mode=mode,url=url)
        image=getTextFromNode(images[0])          
           
           if tocMode != "thumbs":
               # get table of contents
               docinfo = self.getToc(mode=tocMode, docinfo=docinfo)
               
           if viewMode=="auto": # automodus gewaehlt
               if docinfo.get("textURL",''): #texturl gesetzt und textViewer konfiguriert
                   viewMode="text_dict"
    else:     else:
        image=None                  viewMode="images"
                   
           pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo,viewMode=viewMode,tocMode=tocMode)
           
           pt = getattr(self.template, 'viewer_main')               
           return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode,mk=self.generateMarks(mk))
     
       def generateMarks(self,mk):
           ret=""
           if mk is None:
               return ""
           if type(mk) is not ListType:
               mk=[mk]
           for m in mk:
               ret+="mk=%s"%m
           return ret
                 
    if image and archivePath:  
        image=os.path.join(archivePath,image)  
        image=image.replace("/mpiwg/online",'')  
        pt=getParamFromDigilib(image,'pt')  
   
       def findDigilibUrl(self):
           """try to get the digilib URL from zogilib"""
           url = self.template.zogilib.getDLBaseUrl()
           return url
   
       def getDocumentViewerURL(self):
           """returns the URL of this instance"""
           return self.absolute_url()
       
       def getStyle(self, idx, selected, style=""):
           """returns a string with the given style and append 'sel' if path == selected."""
           #logger("documentViewer (getstyle)", logging.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
           if idx == selected:
               return style + 'sel'
    else:     else:
        image=None              return style
                 
    viewerUrls=dom.xpath("//texttool/digiliburlprefix")      def getLink(self,param=None,val=None):
           """link to documentviewer with parameter param set to val"""
           params=self.REQUEST.form.copy()
           if param is not None:
               if val is None:
                   if params.has_key(param):
                       del params[param]
               else:
                   params[param] = str(val)
         
    if viewerUrls and (len(viewerUrls)>0):          if params.get("mode", None) == "filepath": #wenn beim erst Aufruf filepath gesetzt wurde aendere das nun zu imagepath
        viewerUrl=getTextFromNode(viewerUrls[0])                  params["mode"] = "imagepath"
                   params["url"] = getParentDir(params["url"])
                   
           # quote values and assemble into query string
           ps = "&".join(["%s=%s"%(k,urllib.quote(v)) for (k, v) in params.items()])
           url=self.REQUEST['URL1']+"?"+ps
           return url
   
       def getLinkAmp(self,param=None,val=None):
           """link to documentviewer with parameter param set to val"""
           params=self.REQUEST.form.copy()
           if param is not None:
               if val is None:
                   if params.has_key(param):
                       del params[param]
    else:     else:
        viewerUrl=None                  params[param] = str(val)
         
           # quote values and assemble into query string
           logging.info("XYXXXXX: %s"%repr(params.items()))
           ps = "&".join(["%s=%s"%(k,urllib.quote(v)) for (k, v) in params.items()])
           url=self.REQUEST['URL1']+"?"+ps
           return url
         
    textUrls=dom.xpath("//texttool/text")      def getInfo_xml(self,url,mode):
           """returns info about the document as XML"""
         
    if textUrls and (len(textUrls)>0):          if not self.digilibBaseUrl:
        textUrl=getTextFromNode(textUrls[0])              self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
           
           docinfo = self.getDocinfo(mode=mode,url=url)
           pt = getattr(self.template, 'info_xml')
           return pt(docinfo=docinfo)
   
       
       def isAccessible(self, docinfo):
           """returns if access to the resource is granted"""
           access = docinfo.get('accessType', None)
           logger("documentViewer (accessOK)", logging.INFO, "access type %s"%access)
           if access is not None and access == 'free':
               logger("documentViewer (accessOK)", logging.INFO, "access is free")
               return True
           elif access is None or access in self.authgroups:
               # only local access -- only logged in users
               user = getSecurityManager().getUser()
               if user is not None:
                   #print "user: ", user
                   return (user.getUserName() != "Anonymous User")
    else:     else:
        textUrl=None                  return False
    return viewerUrl,(image,pt),textUrl  
   
           logger("documentViewer (accessOK)", logging.INFO, "unknown access type %s"%access)
           return False
   
 class documentViewer(ZopePageTemplate):  
     """document viewer"""  
   
     meta_type="Document viewer"      def getDirinfoFromDigilib(self,path,docinfo=None,cut=0):
           """gibt param von dlInfo aus"""
           num_retries = 3
           if docinfo is None:
               docinfo = {}
           
     security=ClassSecurityInfo()          for x in range(cut):
     manage_options=ZopePageTemplate.manage_options+(  
         {'label':'main config','action':'changeDocumentViewerForm'},  
         )  
   
     _default_content_fn = os.path.join(package_home(globals()),'zpt','documentViewer_template.zpt')                  path=getParentDir(path)
           
     def __init__(self,id,imageViewerUrl,title=""):          infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path
         """init document viewer"""  
         self.id=id  
         self.title=title  
         self.imageViewerUrl=imageViewerUrl  
                   
     security.declareProtected('View management screens','changeDocumentViewerForm')              logger("documentViewer (getparamfromdigilib)", logging.INFO, "dirInfo from %s"%(infoUrl))
     def changeDocumentViewerForm(self):  
         """change it"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeDocumentViewer.zpt')).__of__(self)  
         return pt()  
       
           for cnt in range(num_retries):
               try:
                   # dom = NonvalidatingReader.parseUri(imageUrl)
                   txt=urllib.urlopen(infoUrl).read()
                   dom = Parse(txt)
                   break
               except:
                   logger("documentViewer (getdirinfofromdigilib)", logging.ERROR, "error reading %s (try %d)"%(infoUrl,cnt))
           else:
               raise IOError("Unable to get dir-info from %s"%(infoUrl))
       
     def changeDocumentViewer(self,imageViewerUrl,title="",RESPONSE=None):          sizes=dom.xpath("//dir/size")
         """init document viewer"""          logger("documentViewer (getparamfromdigilib)", logging.INFO, "dirInfo:size"%sizes)
         self.title=title  
         self.imageViewerUrl=imageViewerUrl  
                   
         if RESPONSE is not None:          if sizes:
             RESPONSE.redirect('manage_main')              docinfo['numPages'] = int(getTextFromNode(sizes[0]))
           else:
               docinfo['numPages'] = 0
           
           # TODO: produce and keep list of image names and numbers
           
     def imageLink(self,nr):          return docinfo
         """link hinter den images"""  
         paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING'])  
         params={}  
         for x in paramsTmp.iteritems():  
                 params[x[0]]=x[1][0]  
       
         params['pn']=nr  
         newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)  
         return newUrl  
                   
                   
     def thumbruler(self,cols,rows,start,maximum):      def getIndexMeta(self, url):
         """ruler for thumbs"""          """returns dom of index.meta document at url"""
         ret=""          num_retries = 3
         paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING'])          dom = None
         params={}          metaUrl = None
         for x in paramsTmp.iteritems():          if url.startswith("http://"):
               # real URL
             if not x[0]=="start":              metaUrl = url
                 params[x[0]]=x[1][0]          else:
               # online path
         newUrlSelect=self.REQUEST['URL']+"?"+urllib.urlencode(params)                  server=self.digilibBaseUrl+"/servlet/Texter?fn="
         if start>0:              metaUrl=server+url.replace("/mpiwg/online","")
             newStart=max(start-cols*rows,0)              if not metaUrl.endswith("index.meta"):
             params['start']=newStart                  metaUrl += "/index.meta"
             newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)          logging.debug("METAURL: %s"%metaUrl)
             ret+="""<a href="%s">prev</a>"""%newUrl          for cnt in range(num_retries):
               try:
                   # patch dirk encoding fehler treten dann nicht mehr auf
         ret+="""<select onChange="location.href='%s&start='+this.options[this.selectedIndex].value" """%newUrlSelect                  # dom = NonvalidatingReader.parseUri(metaUrl)
         nr,rest=divmod(maximum,cols*rows)                  txt=urllib.urlopen(metaUrl).read()
         if rest > 0:                  dom = Parse(txt)
             nr+=1                  break
         for i in range(nr):              except:
             nr=i*cols*rows                  logger("ERROR documentViewer (getIndexMeta)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
              
             if (start >= nr) and (start < nr+cols*rows):    
                 ret+="""<option value="%s" selected>%s</option>"""%(nr,nr)  
             else:  
                 ret+="""<option value="%s">%s</option>"""%(nr,nr)  
         ret+="</select>"  
           
         if start<maximum:  
             newStart=min(start+cols*rows,maximum)  
             params['start']=newStart  
             newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)  
             ret+="""<a href="%s">next</a>"""%newUrl  
                   
         return ret          if dom is None:
               raise IOError("Unable to read index meta from %s"%(url))
                   
     def textToolThumb(self,url,start=0):          return dom
         """understands the texttool format  
         @param url: url to index.meta with texttool tag  
         """  
         (viewerUrl,imagepath,textpath)=parseUrlTextTool(url)  
                   
         imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%imagepath[0]      def getPresentationInfoXML(self, url):
           """returns dom of info.xml document at url"""
           num_retries = 3
           dom = None
           metaUrl = None
           if url.startswith("http://"):
               # real URL
               metaUrl = url
           else:
               # online path
               server=self.digilibBaseUrl+"/servlet/Texter?fn="
               metaUrl=server+url.replace("/mpiwg/online","")
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)          for cnt in range(num_retries):
         return pt(imageUrl=imageUrl,pt=imagepath[1],start=start)              try:
                   # patch dirk encoding fehler treten dann nicht mehr auf
                   # dom = NonvalidatingReader.parseUri(metaUrl)
                   txt=urllib.urlopen(metaUrl).read()
                   dom = Parse(txt)
                   break
               except:
                   logger("ERROR documentViewer (getPresentationInfoXML)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
           
     def imagePathThumb(self,path,start=0):          if dom is None:
         """path ist the path to the images it is assumes that the index.meta file is one level higher."""              raise IOError("Unable to read infoXMLfrom %s"%(url))
                   
         path=path.replace("/mpiwg/online","")          return dom
         pt=getParamFromDigilib(path,'pt')  
         imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%path  
                   
         pageT=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)  
         return pageT(imageUrl=imageUrl,pt=pt,start=start)  
           
     def headerFromIndexMeta(self,path):      def getAuthinfoFromIndexMeta(self,path,docinfo=None,dom=None,cut=0):
         """gibt header from index meta out"""          """gets authorization info from the index.meta file at path or given by dom"""
           logger("documentViewer (getauthinfofromindexmeta)", logging.INFO,"path: %s"%(path))
                   
         metaData=self.metadata.main.meta.bib          access = None
         server="http://foxridge.mpiwg-berlin.mpg.de"  
         path="/".join(path.split("/")[0:-1])  
         metaUrl=server+path+"/index.meta"  
           
         dom = NonvalidatingReader.parseUri(metaUrl)  
         type=dom.xpath("//bib/@type")  
         if type and (len(type)>0):  
             type=type[0].value  
         else:  
             type="generic"  
         type=type.replace("-"," ")# wrong typesiin index meta "-" instead of " "  
         hash=metaData.generateMappingForType(type)  
       
         author=getTextFromNode(dom.xpath("//bib/%s"%hash['author'][0])[0])  
         title=getTextFromNode(dom.xpath("//bib/%s"%hash['title'][0])[0])  
         year=getTextFromNode(dom.xpath("//bib/%s"%hash['year'][0])[0])  
                   
         return author,title,year          if docinfo is None:
               docinfo = {}
                   
     def text(self,mode,url,pn):          if dom is None:
         """give text"""              for x in range(cut):
         if mode=="texttool": #index.meta with texttool information                  path=getParentDir(path)
             (viewerUrl,imagepath,textpath)=parseUrlTextTool(url)              dom = self.getIndexMeta(path)
                   
         print textpath          acctype = dom.xpath("//access-conditions/access/@type")
         try:          if acctype and (len(acctype)>0):
             dom = NonvalidatingReader.parseUri(textpath)              access=acctype[0].value
         except:              if access in ['group', 'institution']:
             return None                  access = getTextFromNode(dom.xpath("//access-conditions/access/name")[0]).lower()
           
         list=[]          docinfo['accessType'] = access
         nodes=dom.xpath("//pb")          return docinfo
   
         node=nodes[int(pn)-1]  
                   
         p=node      def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None,cut=0):
           """gets bibliographical info from the index.meta file at path or given by dom"""
           logging.debug("documentViewer (getbibinfofromindexmeta) path: %s"%(path))
                   
         while p.tagName!="p":          if docinfo is None:
             p=p.parentNode              docinfo = {}
                   
           if dom is None:
               for x in range(cut):
                   path=getParentDir(path)
               dom = self.getIndexMeta(path)
                   
         endNode=nodes[int(pn)]          logging.debug("documentViewer (getbibinfofromindexmeta cutted) path: %s"%(path))
           # put in all raw bib fields as dict "bib"
           bib = dom.xpath("//bib/*")
           if bib and len(bib)>0:
               bibinfo = {}
               for e in bib:
                   bibinfo[e.localName] = getTextFromNode(e)
               docinfo['bib'] = bibinfo
                   
           # extract some fields (author, title, year) according to their mapping
           metaData=self.metadata.main.meta.bib
           bibtype=dom.xpath("//bib/@type")
           if bibtype and (len(bibtype)>0):
               bibtype=bibtype[0].value
           else:
               bibtype="generic"
                   
         e=endNode          bibtype=bibtype.replace("-"," ") # wrong typesiin index meta "-" instead of " " (not wrong! ROC)
           docinfo['bib_type'] = bibtype
           bibmap=metaData.generateMappingForType(bibtype)
           # if there is no mapping bibmap is empty (mapping sometimes has empty fields)
           if len(bibmap) > 0 and len(bibmap['author'][0]) > 0:
               try:
                   docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['author'][0])[0])
               except: pass
               try:
                   docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['title'][0])[0])
               except: pass
               try:
                   docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['year'][0])[0])
               except: pass
               logging.debug("documentViewer (getbibinfofromindexmeta) using mapping for %s"%bibtype)
               try:
                   docinfo['lang']=getTextFromNode(dom.xpath("//bib/lang")[0])
               except:
                   docinfo['lang']=''
                   
         while e.tagName!="p":          return docinfo
             e=e.parentNode  
                   
                   
         next=node.parentNode      def getDocinfoFromTextTool(self, url, dom=None, docinfo=None):
           """parse texttool tag in index meta"""
           logger("documentViewer (getdocinfofromtexttool)", logging.INFO, "url: %s" % (url))
           if docinfo is None:
              docinfo = {}
           if docinfo.get('lang', None) is None:
               docinfo['lang'] = '' # default keine Sprache gesetzt
           if dom is None:
               dom = self.getIndexMeta(url)
                   
         #sammle s          archivePath = None
         while next and (next!=endNode.parentNode):          archiveName = None
             list.append(next)      
             next=next.nextSibling      
         list.append(endNode.parentNode)  
                   
         if p==e:# beide im selben paragraphen          archiveNames = dom.xpath("//resource/name")
             pass          if archiveNames and (len(archiveNames) > 0):
 #    else:              archiveName = getTextFromNode(archiveNames[0])
 #            next=p          else:
 #            while next!=e:              logger("documentViewer (getdocinfofromtexttool)", logging.WARNING, "resource/name missing in: %s" % (url))
 #                print next,e  
 #                list.append(next)  
 #                next=next.nextSibling  
 #              
 #        for x in list:  
 #            PrettyPrint(x)  
 #  
 #        return list  
 #      
     def image(self,mode,url,pn):  
         """give image out"""  
         if mode=="texttool": #index.meta with texttool information  
             (viewerUrl,imagepath,textpath)=parseUrlTextTool(url)  
             if not viewerUrl:  
                 viewerUrl=self.imageViewerUrl  
             url=viewerUrl+"pn=%s&fn=%s"%(pn,imagepath[0])  
             ret="""<iframe height="100%%" width="100%%" src="%s"/>"""%url  
             return url  
         elif mode=="imagepath":  
             url=url.replace("/mpiwg/online","")  
             url=self.imageViewerUrl+"pn=%s&fn=%s"%(pn,url)  
             ret="""<iframe height="100%%" width="100%%" src="%s"/>"""%url  
             return url  
                           
           archivePaths = dom.xpath("//resource/archive-path")
           if archivePaths and (len(archivePaths) > 0):
               archivePath = getTextFromNode(archivePaths[0])
               # clean up archive path
               if archivePath[0] != '/':
                   archivePath = '/' + archivePath
               if archiveName and (not archivePath.endswith(archiveName)):
                   archivePath += "/" + archiveName
           else:
               # try to get archive-path from url
               logger("documentViewer (getdocinfofromtexttool)", logging.WARNING, "resource/archive-path missing in: %s" % (url))
               if (not url.startswith('http')):
                   archivePath = url.replace('index.meta', '')
                   
           if archivePath is None:
               # we balk without archive-path
               raise IOError("Missing archive-path (for text-tool) in %s" % (url))
           
           imageDirs = dom.xpath("//texttool/image")
           if imageDirs and (len(imageDirs) > 0):
               imageDir = getTextFromNode(imageDirs[0])
                   
     def thumbs(self,mode,url,start):          else:
         """give thumbs out"""              # we balk with no image tag / not necessary anymore because textmode is now standard
         if mode=="texttool": #index.meta with texttool information              #raise IOError("No text-tool info in %s"%(url))
             return self.textToolThumb(url,int(start))              imageDir = ""
         elif mode=="imagepath":              #xquery="//pb"  
             return self.imagePathThumb(url,int(start))              docinfo['imagePath'] = "" # keine Bilder
               docinfo['imageURL'] = ""
               
           if imageDir and archivePath:
               #print "image: ", imageDir, " archivepath: ", archivePath
               imageDir = os.path.join(archivePath, imageDir)
               imageDir = imageDir.replace("/mpiwg/online", '')
               docinfo = self.getDirinfoFromDigilib(imageDir, docinfo=docinfo)
               docinfo['imagePath'] = imageDir
                   
     security.declareProtected('View','index_html')              docinfo['imageURL'] = self.digilibBaseUrl + "/servlet/Scaler?fn=" + imageDir
           
           viewerUrls = dom.xpath("//texttool/digiliburlprefix")
           if viewerUrls and (len(viewerUrls) > 0):
               viewerUrl = getTextFromNode(viewerUrls[0])
               docinfo['viewerURL'] = viewerUrl
           
     def index_html(self,mode,url,start=0,pn=1):          textUrls = dom.xpath("//texttool/text")
         '''          if textUrls and (len(textUrls) > 0):
         view it              textUrl = getTextFromNode(textUrls[0])
         @param mode: defines which type of document is behind url              if urlparse.urlparse(textUrl)[0] == "": #keine url
         @param url: url which contains display information                  textUrl = os.path.join(archivePath, textUrl) 
         '''              # fix URLs starting with /mpiwg/online
               if textUrl.startswith("/mpiwg/online"):
                   textUrl = textUrl.replace("/mpiwg/online", '', 1)
               
               docinfo['textURL'] = textUrl
       
           textUrls = dom.xpath("//texttool/text-url-path")
           if textUrls and (len(textUrls) > 0):
               textUrl = getTextFromNode(textUrls[0])
               docinfo['textURLPath'] = textUrl
               if not docinfo['imagePath']:
                   # text-only, no page images
                   docinfo = self.getNumPages(docinfo) #im moment einfach auf eins setzen, navigation ueber die thumbs geht natuerlich nicht    
            
           presentationUrls = dom.xpath("//texttool/presentation")
           docinfo = self.getBibinfoFromIndexMeta(url, docinfo=docinfo, dom=dom)   # get info von bib tag
           
           if presentationUrls and (len(presentationUrls) > 0): # ueberschreibe diese durch presentation informationen 
                # presentation url ergiebt sich ersetzen von index.meta in der url der fuer die Metadaten
                # durch den relativen Pfad auf die presentation infos
               presentationPath = getTextFromNode(presentationUrls[0])
               if url.endswith("index.meta"): 
                   presentationUrl = url.replace('index.meta', presentationPath)
               else:
                   presentationUrl = url + "/" + presentationPath
                   
               docinfo = self.getBibinfoFromTextToolPresentation(presentationUrl, docinfo=docinfo, dom=dom)
       
           docinfo = self.getAuthinfoFromIndexMeta(url, docinfo=docinfo, dom=dom)   # get access info
           
           return docinfo
      
      
       def getBibinfoFromTextToolPresentation(self,url,docinfo=None,dom=None):
           """gets the bibliographical information from the preseantion entry in texttools
           """
           dom=self.getPresentationInfoXML(url)
           try:
               docinfo['author']=getTextFromNode(dom.xpath("//author")[0])
           except:
               pass
           try:
               docinfo['title']=getTextFromNode(dom.xpath("//title")[0])
           except:
               pass
           try:
               docinfo['year']=getTextFromNode(dom.xpath("//date")[0])
           except:
               pass
           return docinfo
           
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','documentViewer_template.zpt')).__of__(self)      def getDocinfoFromImagePath(self,path,docinfo=None,cut=0):
         return pt(mode=mode,url=url,start=start,pn=pn)          """path ist the path to the images it assumes that the index.meta file is one level higher."""
           logger("documentViewer (getdocinfofromimagepath)", logging.INFO,"path: %s"%(path))
           if docinfo is None:
               docinfo = {}
           path=path.replace("/mpiwg/online","")
           docinfo['imagePath'] = path
           docinfo=self.getDirinfoFromDigilib(path,docinfo=docinfo,cut=cut)
                   
           pathorig=path
           for x in range(cut):       
                   path=getParentDir(path)
           logging.error("PATH:"+path)
           imageUrl=self.digilibBaseUrl+"/servlet/Scaler?fn="+path
           docinfo['imageURL'] = imageUrl
           
           #path ist the path to the images it assumes that the index.meta file is one level higher.
           docinfo = self.getBibinfoFromIndexMeta(pathorig,docinfo=docinfo,cut=cut+1)
           docinfo = self.getAuthinfoFromIndexMeta(pathorig,docinfo=docinfo,cut=cut+1)
           return docinfo
       
       
       def getDocinfo(self, mode, url):
           """returns docinfo depending on mode"""
           logger("documentViewer (getdocinfo)", logging.INFO,"mode: %s, url: %s"%(mode,url))
           # look for cached docinfo in session
           if self.REQUEST.SESSION.has_key('docinfo'):
               docinfo = self.REQUEST.SESSION['docinfo']
               # check if its still current
               if docinfo is not None and docinfo.get('mode') == mode and docinfo.get('url') == url:
                   logger("documentViewer (getdocinfo)", logging.INFO,"docinfo in session: %s"%docinfo)
                   return docinfo
           # new docinfo
           docinfo = {'mode': mode, 'url': url}
           if mode=="texttool": #index.meta with texttool information
               docinfo = self.getDocinfoFromTextTool(url, docinfo=docinfo)
           elif mode=="imagepath":
               docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo)
           elif mode=="filepath":
               docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo,cut=1)
           else:
               logger("documentViewer (getdocinfo)", logging.ERROR,"unknown mode!")
               raise ValueError("Unknown mode %s! Has to be one of 'texttool','imagepath','filepath'."%(mode))
                   
           logger("documentViewer (getdocinfo)", logging.INFO,"docinfo: %s"%docinfo)
           self.REQUEST.SESSION['docinfo'] = docinfo
           return docinfo
                  
       def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None, viewMode=None, tocMode=None):
           """returns pageinfo with the given parameters"""
           pageinfo = {}
           current = getInt(current)
           pageinfo['current'] = current
           rows = int(rows or self.thumbrows)
           pageinfo['rows'] = rows
           cols = int(cols or self.thumbcols)
           pageinfo['cols'] = cols
           grpsize = cols * rows
           pageinfo['groupsize'] = grpsize
           start = getInt(start, default=(math.ceil(float(current)/float(grpsize))*grpsize-(grpsize-1)))
           # int(current / grpsize) * grpsize +1))
           pageinfo['start'] = start
           pageinfo['end'] = start + grpsize
           if (docinfo is not None) and ('numPages' in docinfo):
               np = int(docinfo['numPages'])
               pageinfo['end'] = min(pageinfo['end'], np)
               pageinfo['numgroups'] = int(np / grpsize)
               if np % grpsize > 0:
                   pageinfo['numgroups'] += 1        
           pageinfo['viewMode'] = viewMode
           pageinfo['tocMode'] = tocMode
           pageinfo['query'] = self.REQUEST.get('query',' ')
           pageinfo['queryType'] = self.REQUEST.get('queryType',' ')
           pageinfo['querySearch'] =self.REQUEST.get('querySearch', 'fulltext')
           pageinfo['textPN'] = self.REQUEST.get('textPN','1')
           pageinfo['highlightQuery'] = self.REQUEST.get('highlightQuery','')
           pageinfo['tocPageSize'] = self.REQUEST.get('tocPageSize', '30')
           pageinfo['queryPageSize'] =self.REQUEST.get('queryPageSize', '10')
           pageinfo['tocPN'] = self.REQUEST.get('tocPN', '1')
           toc = int (pageinfo['tocPN'])
           pageinfo['textPages'] =int (toc)
           
           if 'tocSize_%s'%tocMode in docinfo:
               tocSize = int(docinfo['tocSize_%s'%tocMode])
               tocPageSize = int(pageinfo['tocPageSize'])
               # cached toc           
               if tocSize%tocPageSize>0:
                   tocPages=tocSize/tocPageSize+1
               else:
                   tocPages=tocSize/tocPageSize
               pageinfo['tocPN'] = min (tocPages,toc)                    
           pageinfo['searchPN'] =self.REQUEST.get('searchPN','1')
           pageinfo['sn'] =self.REQUEST.get('sn','')
           return pageinfo
                   
 #    security.declareProtected('View management screens','renameImageForm')  def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None):
           """init document viewer"""
           self.title=title
           self.digilibBaseUrl = digilibBaseUrl
           self.thumbrows = thumbrows
           self.thumbcols = thumbcols
           self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
 def manage_AddDocumentViewerForm(self):  def manage_AddDocumentViewerForm(self):
     """add the viewer form"""      """add the viewer form"""
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addDocumentViewer.zpt')).__of__(self)      pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
     return pt()      return pt()
       
 def manage_AddDocumentViewer(self,id,imageViewerUrl="",title="",RESPONSE=None):  def manage_AddDocumentViewer(self,id,imageScalerUrl="",textServerName="",title="",RESPONSE=None):
     """add the viewer"""      """add the viewer"""
     newObj=documentViewer(id,imageViewerUrl,title)      newObj=documentViewer(id,imageScalerUrl=imageScalerUrl,title=title,textServerName=textServerName)
     self._setObject(id,newObj)      self._setObject(id,newObj)
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
   
   ## DocumentViewerTemplate class
   class DocumentViewerTemplate(ZopePageTemplate):
       """Template for document viewer"""
       meta_type="DocumentViewer Template"
   
   
   def manage_addDocumentViewerTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile('zpt/addDocumentViewerTemplate', globals()).__of__(self)
       return pt()
   
   def manage_addDocumentViewerTemplate(self, id='viewer_main', title=None, text=None,
                              REQUEST=None, submit=None):
       "Add a Page Template with optional file content."
   
       self._setObject(id, DocumentViewerTemplate(id))
       ob = getattr(self, id)
       txt=file(os.path.join(package_home(globals()),'zpt/viewer_main.zpt'),'r').read()
       logging.info("txt %s:"%txt)
       ob.pt_edit(txt,"text/html")
       if title:
           ob.pt_setTitle(title)
       try:
           u = self.DestinationURL()
       except AttributeError:
           u = REQUEST['URL1']
           
       u = "%s/%s" % (u, urllib.quote(id))
       REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
   
       
Removed from v.1.2  
changed lines
  Added in v.1.69.2.1

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>