documentViewer/documentViewer.py - diff

Return to documentViewer.py CVS log

Up to [Repository] / documentViewer

Diff for /documentViewer/documentViewer.py between versions 1.3 and 1.175.2.24

-version 1.3, 2006/04/06 17:13:43
+version 1.175.2.24, 2011/08/12 14:41:39
  Line 1
- genericDigilib="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/"
  from OFS.Folder import Folder
  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
  from AccessControl import ClassSecurityInfo
+ from AccessControl import getSecurityManager
  from Globals import package_home
- from Ft.Xml.Domlette import NonvalidatingReader
+ #from Ft.Xml import EMPTY_NAMESPACE, Parse
- from Ft.Xml.Domlette import PrettyPrint, Print
+ #import Ft.Xml.Domlette
- from Ft.Xml import EMPTY_NAMESPACE
- import Ft.Xml.XPath
+ import xml.etree.ElementTree as ET
  import os.path
- import cgi
+ import sys
  import urllib
- import zLOG
+ import logging
+ import math
- def getTextFromNode(nodename):
+ import urlparse
-     nodelist=nodename.childNodes
+ import re
-     rc = ""
+ import string
-     for node in nodelist:
-         if node.nodeType == node.TEXT_NODE:
+ from SrvTxtUtils import getInt, getText, getHttpData
-            rc = rc + node.data
-     return rc
+ def logger(txt,method,txt2):
+     """logging"""
- import socket
+     logging.info(txt+ txt2)
- def urlopen(url):
-         """urlopen mit timeout"""
+ def serializeNode(node, encoding="utf-8"):
-         socket.setdefaulttimeout(2)
+     """returns a string containing node as XML"""
-         ret=urllib.urlopen(url)
+     s = ET.tostring(node)
-         socket.setdefaulttimeout(5)
-         return ret
+     # 4Suite:
+     #    stream = cStringIO.StringIO()
- def getParamFromDigilib(path,param):
+     #    Ft.Xml.Domlette.Print(node, stream=stream, encoding=encoding)
-     """gibt param von dlInfo aus"""
+     #    s = stream.getvalue()
-     imageUrl=genericDigilib+"/dirInfo-xml.jsp?mo=dir&fn="+path
+     #    stream.close()
+     return s
-     zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo (%s) from %s"%(param,imageUrl))
+ def browserCheck(self):
+     """check the browsers request to find out the browser type"""
+     bt = {}
+     ua = self.REQUEST.get_header("HTTP_USER_AGENT")
+     bt['ua'] = ua
+     bt['isIE'] = False
+     bt['isN4'] = False
+     bt['versFirefox']=""
+     bt['versIE']=""
+     bt['versSafariChrome']=""
+     bt['versOpera']=""
+     if string.find(ua, 'MSIE') > -1:
+         bt['isIE'] = True
+     else:
+         bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
+     # Safari oder Chrome identification
      try:
-         dom = NonvalidatingReader.parseUri(imageUrl)
+         nav = ua[string.find(ua, '('):]
-     except:
+         nav1=ua[string.find(ua,')'):]
-         return None
+         nav2=nav1[string.find(nav1,'('):]
+         nav3=nav2[string.find(nav2,')'):]
-     params=dom.xpath("//dir/%s"%param)
+         ie = string.split(nav, "; ")[1]
-     zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo:%s"%params)
+         ie1 =string.split(nav1, " ")[2]
+         ie2 =string.split(nav3, " ")[1]
-     if params:
+         ie3 =string.split(nav3, " ")[2]
-         return getTextFromNode(params[0])
+         if string.find(ie3, "Safari") >-1:
+             bt['versSafariChrome']=string.split(ie2, "/")[1]
+     except: pass
+     # IE identification
+     try:
+         nav = ua[string.find(ua, '('):]
+         ie = string.split(nav, "; ")[1]
+         if string.find(ie, "MSIE") > -1:
+             bt['versIE'] = string.split(ie, " ")[1]
+     except:pass
+     # Firefox identification
+     try:
+         nav = ua[string.find(ua, '('):]
+         nav1=ua[string.find(ua,')'):]
+         if string.find(ie1, "Firefox") >-1:
+             nav5= string.split(ie1, "/")[1]
+             logging.debug("FIREFOX: %s"%(nav5))
+             bt['versFirefox']=nav5[0:3]
+     except:pass
+     #Opera identification
+     try:
+         if string.find(ua,"Opera") >-1:
+             nav = ua[string.find(ua, '('):]
+             nav1=nav[string.find(nav,')'):]
+             bt['versOpera']=string.split(nav1,"/")[2]
+     except:pass
+     bt['isMac'] = string.find(ua, 'Macintosh') > -1
+     bt['isWin'] = string.find(ua, 'Windows') > -1
+     bt['isIEWin'] = bt['isIE'] and bt['isWin']
+     bt['isIEMac'] = bt['isIE'] and bt['isMac']
+     bt['staticHTML'] = False
+     return bt
+ def getParentPath(path, cnt=1):
+     """returns pathname shortened by cnt"""
+     # make sure path doesn't end with /
+     path = path.rstrip('/')
+     # split by /, shorten, and reassemble
+     return '/'.join(path.split('/')[0:-cnt])
  ##
- Line 60  def getParamFromDigilib(path,param):
+ Line 111  def getParamFromDigilib(path,param):
  ##
  class documentViewer(Folder):
      """document viewer"""
      meta_type="Document viewer"
      security=ClassSecurityInfo()
- Line 68  class documentViewer(Folder):
+ Line 118  class documentViewer(Folder):
          {'label':'main config','action':'changeDocumentViewerForm'},
          )
+     metadataService = None
+     """MetaDataFolder instance"""
      # templates and forms
      viewer_main = PageTemplateFile('zpt/viewer_main', globals())
-     thumbs_main = PageTemplateFile('zpt/thumbs_main', globals())
+     toc_thumbs = PageTemplateFile('zpt/toc_thumbs', globals())
-     image_main = PageTemplateFile('zpt/image_main', 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_double = PageTemplateFile('zpt/page_main_double', globals())
+     page_main_text = PageTemplateFile('zpt/page_main_text', globals())
+     page_main_text_dict = PageTemplateFile('zpt/page_main_text_dict', globals())
+     page_main_gis =PageTemplateFile ('zpt/page_main_gis', globals())
+     page_main_xml = PageTemplateFile('zpt/page_main_xml', globals())
+     page_main_pureXml = PageTemplateFile('zpt/page_main_pureXml', globals())
      head_main = PageTemplateFile('zpt/head_main', globals())
      docuviewer_css = PageTemplateFile('css/docuviewer.css', globals())
+     info_xml = PageTemplateFile('zpt/info_xml', globals())
-     security.declareProtected('View management screens','changeDocumentViewerForm')
-     changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
+     thumbs_main_rss = PageTemplateFile('zpt/thumbs_main_rss', globals())
-     def __init__(self,id,imageViewerUrl,title="",digilibBaseUrl=None):
+     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.imageViewerUrl=imageViewerUrl
+         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:
+             import MpdlXmlTextServer
+             textServer = MpdlXmlTextServer.MpdlXmlTextServer(id='fulltextclient',serverName=textServerName)
+             #templateFolder['fulltextclient'] = xmlRpcClient
+             templateFolder._setObject('fulltextclient',textServer)
+         except Exception, e:
+             logging.error("Unable to create MpdlXmlTextServer 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))
+         try:
+             # assume MetaDataFolder instance is called metadata
+             self.metadataService = getattr(self, 'metadata')
+         except Exception, e:
+             logging.error("Unable to find MetaDataFolder 'metadata': "+str(e))
+         if digilibBaseUrl is not None:
          self.digilibBaseUrl = digilibBaseUrl
-         if not self.digilibBaseUrl:
-             self.digilibBaseUrl = self.findDigilibUrl()
-         # add template folder so we can always use template.something
-         self.manage_addFolder('template')
-     security.declareProtected('View','index_html')
+     # proxy text server methods to fulltextclient
-     def index_html(self,mode,url,start=0,pn=1):
+     def getTextPage(self, **args):
+         """get page"""
+         return self.template.fulltextclient.getTextPage(**args)
+     def getOrigPages(self, **args):
+         """get page"""
+         return self.template.fulltextclient.getOrigPages(**args)
+     def getOrigPagesNorm(self, **args):
+         """get page"""
+         return self.template.fulltextclient.getOrigPagesNorm(**args)
+     def getQuery(self, **args):
+         """get query in search"""
+         return self.template.fulltextclient.getQuery(**args)
+     def getSearch(self, **args):
+         """get search"""
+         return self.template.fulltextclient.getSearch(**args)
+     def getGisPlaces(self, **args):
+         """get gis places"""
+         return self.template.fulltextclient.getGisPlaces(**args)
+     def getAllGisPlaces(self, **args):
+         """get all gis places """
+         return self.template.fulltextclient.getAllGisPlaces(**args)
+     def getWordInfo(self, **args):
+         """get translate"""
+         return self.template.fulltextclient.getWordInfo(**args)
+     def getLemma(self, **args):
+         """get lemma"""
+         return self.template.fulltextclient.getLemma(**args)
+     def getLemmaQuery(self, **args):
+         """get query"""
+         return self.template.fulltextclient.getLemmaQuery(**args)
+     def getLex(self, **args):
+         """get lex"""
+         return self.template.fulltextclient.getLex(**args)
+     def getToc(self, **args):
+         """get toc"""
+         return self.template.fulltextclient.getToc(**args)
+     def getTocPage(self, **args):
+         """get tocpage"""
+         return self.template.fulltextclient.getTocPage(**args)
+     security.declareProtected('View','thumbs_rss')
+     def thumbs_rss(self,mode,url,viewMode="auto",start=None,pn=1):
          '''
          view it
-         @param mode: defines which type of document is behind url
+         @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)
-         zLOG.LOG("documentViewer (index)", zLOG.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
+         '''
-         print "dlbaseurl:", self.digilibBaseUrl
+         logging.debug("HHHHHHHHHHHHHH:load the rss")
+         logging.debug("documentViewer (index) 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
-             print "no template folder -- creating"
              self.manage_addFolder('template')
          if not self.digilibBaseUrl:
              self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
-         print "dlbaseurl:", self.digilibBaseUrl
          docinfo = self.getDocinfo(mode=mode, url=url)
-         pageinfo = self.getPageinfo(start=start,current=pn)
+         #pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)
-         pt = getattr(self.template, 'viewer_main')
+         pageinfo = self.getPageinfo(start=start,current=pn, docinfo=docinfo)
-         return pt(docinfo=docinfo,pageinfo=pageinfo)
+         ''' ZDES '''
+         pt = getattr(self.template, 'thumbs_main_rss')
+         if viewMode=="auto": # automodus gewaehlt
+             if docinfo.has_key("textURL") or docinfo.get('textURLPath',None): #texturl gesetzt und textViewer konfiguriert
+                 viewMode="text"
+             else:
+                 viewMode="images"
+         return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode)
-     def imageLink(self,nr):
-         """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 getStyle(self, idx, selected, style=""):
+     security.declareProtected('View','index_html')
-         """returns a string with the given style + 'sel' if path == selected."""
+     def index_html(self,url,mode="texttool",viewMode="auto",viewType=None,tocMode="thumbs",start=1,pn=1):
-         #zLOG.LOG("documentViewer (getstyle)", zLOG.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
+         """
-         if idx == selected:
+         view page
-             return style + 'sel'
+         @param url: url which contains display information
-         else:
+         @param mode: defines how to access the document behind url
-             return style
+         @param viewMode: 'images': display images, 'text': display text, default is 'auto'
+         @param viewType: sub-type of viewMode, e.g. 'dict' for viewMode='text'
+         @param tocMode: type of 'table of contents' for navigation (thumbs, text, figures, none)
+         """
+         logging.debug("documentViewer(index_html) mode=%s url=%s viewMode=%s viewType=%s start=%s pn=%s"%(mode,url,viewMode,viewType,start,pn))
-     def thumbruler(self,cols,rows,start,maximum):
+         if not hasattr(self, 'template'):
-         """ruler for thumbs"""
+             # this won't work
-         ret=""
+             logging.error("template folder missing!")
-         paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING'])
+             return "ERROR: template folder missing!"
-         params={}
-         for x in paramsTmp.iteritems():
-             if not x[0]=="start":
-                 params[x[0]]=x[1][0]
-         newUrlSelect=self.REQUEST['URL']+"?"+urllib.urlencode(params)
-         if start>0:
-             newStart=max(start-cols*rows,0)
-             params['start']=newStart
-             newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)
-             ret+="""<a href="%s">prev</a>"""%newUrl
-         ret+="""<select onChange="location.href='%s&start='+this.options[this.selectedIndex].value">"""%newUrlSelect
-         nr,rest=divmod(maximum,cols*rows)
-         if rest > 0:
-             nr+=1
-         for i in range(nr):
-             nr=i*cols*rows
-             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 not getattr(self, 'digilibBaseUrl', None):
+             self.digilibBaseUrl = self.findDigilibUrl() or "http://digilib.mpiwg-berlin.mpg.de/digitallibrary"
+         docinfo = self.getDocinfo(mode=mode,url=url)
+         if tocMode != "thumbs":
+             # get table of contents
+             docinfo = self.getToc(mode=tocMode, docinfo=docinfo)
+         # auto viewMode: text if there is a text else images
+         if viewMode=="auto":
+             if docinfo.get('textURL', None) or docinfo.get('textURLPath', None):
+                 viewMode = "text"
+                 viewType = "dict"
+             else:
+                 viewMode = "images"
-     def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None):
+         elif viewMode == "text_dict":
-         """gets bibliographical info from the index.meta file at url or given by dom"""
+             # legacy fix
-         zLOG.LOG("documentViewer (getbibinfofromindexmeta)", zLOG.INFO,"path: %s"%(path))
+             viewMode = "text"
+             viewType = "dict"
-         if docinfo is None:
-             docinfo = {}
+         # stringify viewType
+         if isinstance(viewType, list):
-         metaData=self.metadata.main.meta.bib
+             logging.debug("index_html: viewType is list:%s"%viewType)
-         if dom is None:
+             viewType = ','.join([t for t in viewType if t])
-             server="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn="
-             path="/".join(path.split("/")[0:-1])
+         pageinfo = self.getPageinfo(start=start, current=pn, docinfo=docinfo, viewMode=viewMode, viewType=viewType, tocMode=tocMode)
-             metaUrl=server+path+"/index.meta"
-             try:
+         # get template /template/viewer_$viewMode
-                 dom = NonvalidatingReader.parseUri(metaUrl)
+         pt = getattr(self.template, 'viewer_%s'%viewMode, None)
-             except:
+         if pt is None:
-                 return docinfo
+             logging.error("No template for viewMode=%s!"%viewMode)
+             # TODO: error page?
+             return "No template for viewMode=%s!"%viewMode
-         type=dom.xpath("//bib/@type")
+         # and execute with parameters
-         if type and (len(type)>0):
+         return pt(docinfo=docinfo, pageinfo=pageinfo)
-             type=type[0].value
-         else:
+     def generateMarks(self,mk):
-             type="generic"
+         ret=""
-         type=type.replace("-"," ")# wrong typesiin index meta "-" instead of " "
+         if mk is None:
-         hash=metaData.generateMappingForType(type)
+             return ""
+         if not isinstance(mk, list):
+             mk=[mk]
+         for m in mk:
+             ret+="mk=%s"%m
+         return ret
-         docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%hash['author'][0])[0])
-         docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%hash['title'][0])[0])
-         docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%hash['year'][0])[0])
-         return docinfo
+     def getBrowser(self):
+         """getBrowser the version of browser """
+         bt = browserCheck(self)
+         logging.debug("BROWSER VERSION: %s"%(bt))
+         return bt
+     def findDigilibUrl(self):
+         """try to get the digilib URL from zogilib"""
+         url = self.template.zogilib.getDLBaseUrl()
+         return url
-     def getDocinfoFromTextTool(self,url,docinfo=None):
+     def getDocumentViewerURL(self):
-        """parse texttool tag in index meta"""
+         """returns the URL of this instance"""
-        zLOG.LOG("documentViewer (getdocinfofromtexttool)", zLOG.INFO,"url: %s"%(url))
+         return self.absolute_url()
-        if docinfo is None:
-            docinfo = {}
-        try:
+     def getStyle(self, idx, selected, style=""):
-            dom = NonvalidatingReader.parseUri(url)
+         """returns a string with the given style and append 'sel' if path == selected."""
-        except:
+         #logger("documentViewer (getstyle)", logging.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
-            zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])
+         if idx == selected:
-            return docinfo
+             return style + 'sel'
+         else:
+             return style
-        archivePaths=dom.xpath("//resource/archive-path")
+     def getParams(self, param=None, val=None, params=None, duplicates=None):
+         """returns dict with URL parameters.
-        if archivePaths and (len(archivePaths)>0):
+         Takes URL parameters and additionally param=val or dict params.
-            archivePath=getTextFromNode(archivePaths[0])
+         Deletes key if value is None."""
+         # copy existing request params
+         newParams=self.REQUEST.form.copy()
+         # change single param
+         if param is not None:
+             if val is None:
+                 if newParams.has_key(param):
+                     del newParams[param]
         else:
-            archivePath=None
+                 newParams[param] = str(val)
-        images=dom.xpath("//texttool/image")
+         # change more params
+         if params is not None:
+             for (k, v) in params.items():
+                 if v is None:
+                     # val=None removes param
+                     if newParams.has_key(k):
+                         del newParams[k]
-        if images and (len(images)>0):
-            image=getTextFromNode(images[0])
         else:
-            image=None
+                     newParams[k] = v
-        if image and archivePath:
+         if duplicates:
-            image=os.path.join(archivePath,image)
+             # eliminate lists (coming from duplicate keys)
-            image=image.replace("/mpiwg/online",'')
+             for (k,v) in newParams.items():
-            pt=getParamFromDigilib(image,'size')
+                 if isinstance(v, list):
-            docinfo['imagePath'] = image
+                     if duplicates == 'comma':
-            docinfo['numberOfPages'] = pt
+                         # make comma-separated list of non-empty entries
+                         newParams[k] = ','.join([t for t in v if t])
+                     elif duplicates == 'first':
+                         # take first non-empty entry
+                         newParams[k] = [t for t in v if t][0]
+         return newParams
+     def getLink(self, param=None, val=None, params=None, baseUrl=None, paramSep='&', duplicates='comma'):
+         """returns URL to documentviewer with parameter param set to val or from dict params"""
+         urlParams = self.getParams(param=param, val=val, params=params, duplicates=duplicates)
+         # quote values and assemble into query string (not escaping '/')
+         ps = paramSep.join(["%s=%s"%(k,urllib.quote_plus(unicode(v),'/')) for (k, v) in urlParams.items()])
+         if baseUrl is None:
+             baseUrl = self.getDocumentViewerURL()
-        viewerUrls=dom.xpath("//texttool/digiliburlprefix")
+         url = "%s?%s"%(baseUrl, ps)
+         return url
-        if viewerUrls and (len(viewerUrls)>0):
+     def getLinkAmp(self, param=None, val=None, params=None, baseUrl=None, duplicates='comma'):
-            viewerUrl=getTextFromNode(viewerUrls[0])
+         """link to documentviewer with parameter param set to val"""
-            docinfo['imageURL'] = viewerURL
+         return self.getLink(param=param, val=val, params=params, baseUrl=baseUrl, paramSep='&amp;', duplicates=duplicates)
-        textUrls=dom.xpath("//texttool/text")
-        if textUrls and (len(textUrls)>0):
+     def getInfo_xml(self,url,mode):
-            textUrl=getTextFromNode(textUrls[0])
+         """returns info about the document as XML"""
-            docinfo['textURL'] = textURL
+         if not self.digilibBaseUrl:
+             self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
-        docinfo = self.getBibinfoFromIndexMeta(url,docinfo=docinfo,dom=dom)
+         docinfo = self.getDocinfo(mode=mode,url=url)
-        return docinfo
+         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)
+         logging.debug("documentViewer (accessOK) access type %s"%access)
+         if access == 'free':
+             logging.debug("documentViewer (accessOK) access is free")
+             return True
+         elif access is None or access in self.authgroups:
+             # only local access -- only logged in users
+             user = getSecurityManager().getUser()
+             logging.debug("documentViewer (accessOK) user=%s ip=%s"%(user,self.REQUEST.getClientAddr()))
+             if user is not None:
+                 #print "user: ", user
+                 return (user.getUserName() != "Anonymous User")
+             else:
+                 return False
-     def getDocinfoFromImagePath(self,path,docinfo=None):
+         logging.error("documentViewer (accessOK) unknown access type %s"%access)
-         """path ist the path to the images it assumes that the index.meta file is one level higher."""
+         return False
-         zLOG.LOG("documentViewer (getdocinfofromimagepath)", zLOG.INFO,"path: %s"%(path))
-         if docinfo is None:
-             docinfo = {}
-         docinfo['imagePath'] = path
-         path=path.replace("/mpiwg/online","")
-         pt=getParamFromDigilib(path,'size')
-         docinfo['numberOfPages'] = pt
-         imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%path
-         docinfo['imageURL'] = imageUrl
-         docinfo = self.getBibinfoFromIndexMeta(path,docinfo=docinfo)
-         return docinfo
      def getDocinfo(self, mode, url):
          """returns docinfo depending on mode"""
-         zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"mode: %s, url: %s"%(mode,url))
+         logging.debug("getDocinfo: 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:
+             if docinfo is not None and docinfo.get('mode', None) == mode and docinfo.get('url', None) == url:
-                 zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo in session: %s"%docinfo)
+                 logging.debug("getDocinfo: docinfo in session. keys=%s"%docinfo.keys())
                  return docinfo
          # new docinfo
          docinfo = {'mode': mode, 'url': url}
-         if mode=="texttool": #index.meta with texttool information
+         # add self url
-             docinfo = self.getDocinfoFromTextTool(url, docinfo=docinfo)
+         docinfo['viewerUrl'] = self.getDocumentViewerURL()
+         docinfo['digilibBaseUrl'] = self.digilibBaseUrl
+         # get index.meta DOM
+         docUrl = None
+         metaDom = None
+         if mode=="texttool":
+             # url points to document dir or index.meta
+             metaDom = self.metadataService.getDomFromPathOrUrl(url)
+             docUrl = url.replace('/index.meta', '')
+             if metaDom is None:
+                 raise IOError("Unable to find index.meta for mode=texttool!")
          elif mode=="imagepath":
-             docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo)
+             # url points to folder with images, index.meta optional
+             # asssume index.meta in parent dir
+             docUrl = getParentPath(url)
+             metaDom = self.metadataService.getDomFromPathOrUrl(docUrl)
+         elif mode=="filepath":
+             # url points to image file, index.meta optional
+             # asssume index.meta is two path segments up
+             docUrl = getParentPath(url, 2)
+             metaDom = self.metadataService.getDomFromPathOrUrl(docUrl)
          else:
-             zLOG.LOG("documentViewer (getdocinfo)", zLOG.ERROR,"unknown mode!")
+             logging.error("documentViewer (getdocinfo) unknown mode: %s!"%mode)
-         zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo: %s"%docinfo)
+             raise ValueError("Unknown mode %s! Has to be one of 'texttool','imagepath','filepath'."%(mode))
+         docinfo['documentUrl'] = docUrl
+         # process index.meta contents
+         if metaDom is not None and metaDom.tag == 'resource':
+             # document directory name and path
+             resource = self.metadataService.getResourceData(dom=metaDom)
+             if resource:
+                 docinfo = self.getDocinfoFromResource(docinfo, resource)
+             # texttool info
+             texttool = self.metadataService.getTexttoolData(dom=metaDom)
+             if texttool:
+                 docinfo = self.getDocinfoFromTexttool(docinfo, texttool)
+             # bib info
+             bib = self.metadataService.getBibData(dom=metaDom)
+             if bib:
+                 docinfo = self.getDocinfoFromBib(docinfo, bib)
+             else:
+                 # no bib - try info.xml
+                 docinfo = self.getDocinfoFromPresentationInfoXml(docinfo)
+             # auth info
+             access = self.metadataService.getAccessData(dom=metaDom)
+             if access:
+                 docinfo = self.getDocinfoFromAccess(docinfo, access)
+             # attribution info
+             attribution = self.metadataService.getAttributionData(dom=metaDom)
+             if attribution:
+                 logging.debug("getDocinfo: attribution=%s"%repr(attribution))
+                 docinfo['attribution'] = attribution
+                 #docinfo = self.getDocinfoFromAccess(docinfo, access)
+             # copyright info
+             copyright = self.metadataService.getCopyrightData(dom=metaDom)
+             if copyright:
+                 logging.debug("getDocinfo: copyright=%s"%repr(copyright))
+                 docinfo['copyright'] = copyright
+                 #docinfo = self.getDocinfoFromAccess(docinfo, access)
+         # image path
+         if mode != 'texttool':
+             # override image path from texttool with url
+             docinfo['imagePath'] = url.replace('/mpiwg/online/', '', 1)
+         # number of images from digilib
+         if docinfo.get('imagePath', None):
+             docinfo['imageURL'] = self.digilibBaseUrl + "/servlet/Scaler?fn=" + docinfo['imagePath']
+             docinfo = self.getDocinfoFromDigilib(docinfo, docinfo['imagePath'])
+         logging.debug("documentViewer (getdocinfo) docinfo: keys=%s"%docinfo.keys())
+         #logging.debug("documentViewer (getdocinfo) docinfo: %s"%docinfo)
+         # store in session
          self.REQUEST.SESSION['docinfo'] = docinfo
          return docinfo
+     def getDocinfoFromResource(self, docinfo, resource):
+         """reads contents of resource element into docinfo"""
+         docName = resource.get('name', None)
+         docinfo['documentName'] = docName
+         docPath = resource.get('archive-path', None)
+         if docPath:
+             # clean up document path
+             if docPath[0] != '/':
+                 docPath = '/' + docPath
-     def getPageinfo(self, start, current):
+             if docName and (not docPath.endswith(docName)):
-         """returns pageinfo with the given parameters"""
+                 docPath += "/" + docName
-         pageinfo = {}
-         pageinfo['start'] = start
+         else:
-         pageinfo['current'] = current
+             # use docUrl as docPath
-         return pageinfo
+             docUrl = docinfo['documentURL']
+             if not docUrl.startswith('http:'):
+                 docPath = docUrl
+         if docPath:
+             # fix URLs starting with /mpiwg/online
+             docPath = docPath.replace('/mpiwg/online', '', 1)
-     def text(self,mode,url,pn):
+         docinfo['documentPath'] = docPath
-         """give text"""
+         return docinfo
-         if mode=="texttool": #index.meta with texttool information
-             (viewerUrl,imagepath,textpath)=parseUrlTextTool(url)
+     def getDocinfoFromTexttool(self, docinfo, texttool):
+         """reads contents of texttool element into docinfo"""
+         # image dir
+         imageDir = texttool.get('image', None)
+         docPath = docinfo.get('documentPath', None)
+         if imageDir and docPath:
+             #print "image: ", imageDir, " archivepath: ", archivePath
+             imageDir = os.path.join(docPath, imageDir)
+             imageDir = imageDir.replace('/mpiwg/online', '', 1)
+             docinfo['imagePath'] = imageDir
+         # old style text URL
+         textUrl = texttool.get('text', None)
+         if textUrl and docPath:
+             if urlparse.urlparse(textUrl)[0] == "": #keine url
+                 textUrl = os.path.join(docPath, textUrl)
+             docinfo['textURL'] = textUrl
+         # new style text-url-path
+         textUrl = texttool.get('text-url-path', None)
+         if textUrl:
+             docinfo['textURLPath'] = textUrl
+         # page flow
+         docinfo['pageFlow'] = texttool.get('page-flow', 'ltr')
+         # odd pages are left
+         docinfo['oddPage'] = texttool.get('odd-scan-position', 'left')
+         # number of title page (0: not defined)
+         docinfo['titlePage'] = texttool.get('title-scan-no', 0)
+         # old presentation stuff
+         presentation = texttool.get('presentation', None)
+         if presentation and docPath:
+             if presentation.startswith('http:'):
+                 docinfo['presentationUrl'] = presentation
+             else:
+                 docinfo['presentationUrl'] = os.path.join(docPath, presentation)
-         print textpath
+         return docinfo
+     def getDocinfoFromBib(self, docinfo, bib):
+         """reads contents of bib element into docinfo"""
+         logging.debug("getDocinfoFromBib bib=%s"%repr(bib))
+         # put all raw bib fields in dict "bib"
+         docinfo['bib'] = bib
+         bibtype = bib.get('@type', None)
+         docinfo['bibType'] = bibtype
+         # also store DC metadata for convenience
+         dc = self.metadataService.getDCMappedData(bib)
+         docinfo['creator'] = dc.get('creator',None)
+         docinfo['title'] = dc.get('title',None)
+         docinfo['date'] = dc.get('date',None)
+         return docinfo
+     def getDocinfoFromAccess(self, docinfo, acc):
+         """reads contents of access element into docinfo"""
+         #TODO: also read resource type
+         logging.debug("getDocinfoFromAccess acc=%s"%repr(acc))
          try:
-             dom = NonvalidatingReader.parseUri(textpath)
+             acctype = acc['@attr']['type']
+             if acctype:
+                 access=acctype
+                 if access in ['group', 'institution']:
+                     access = acc['name'].lower()
+                 docinfo['accessType'] = access
          except:
-             return None
+             pass
+         return docinfo
+     def getDocinfoFromDigilib(self, docinfo, path):
+         infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path
+         # fetch data
+         txt = getHttpData(infoUrl)
+         if not txt:
+             logging.error("Unable to get dir-info from %s"%(infoUrl))
+             return docinfo
+         dom = ET.fromstring(txt)
+         size = getText(dom.find("size"))
+         logging.debug("getDocinfoFromDigilib: size=%s"%size)
+         if size:
+             docinfo['numPages'] = int(size)
+         else:
+             docinfo['numPages'] = 0
+         # TODO: produce and keep list of image names and numbers
+         return docinfo
-         list=[]
-         nodes=dom.xpath("//pb")
-         node=nodes[int(pn)-1]
+     def getDocinfoFromPresentationInfoXml(self,docinfo):
+         """gets DC-like bibliographical information from the presentation entry in texttools"""
+         url = docinfo.get('presentationUrl', None)
+         if not url:
+             logging.error("getDocinfoFromPresentation: no URL!")
+             return docinfo
-         p=node
+         dom = None
+         metaUrl = None
+         if url.startswith("http://"):
+             # real URL
+             metaUrl = url
+         else:
+             # online path
-         while p.tagName!="p":
+             server=self.digilibBaseUrl+"/servlet/Texter?fn="
-             p=p.parentNode
+             metaUrl=server+url
+         txt=getHttpData(metaUrl)
+         if txt is None:
+             logging.error("Unable to read info.xml from %s"%(url))
+             return docinfo
-         endNode=nodes[int(pn)]
+         dom = ET.fromstring(txt)
+         docinfo['creator']=getText(dom.find(".//author"))
+         docinfo['title']=getText(dom.find(".//title"))
+         docinfo['date']=getText(dom.find(".//date"))
+         return docinfo
-         e=endNode
+     def getPageinfo(self, current=None, start=None, rows=None, cols=None, docinfo=None, viewMode=None, viewType=None, tocMode=None):
+         """returns pageinfo with the given parameters"""
+         logging.debug("getPageInfo(current=%s, start=%s, rows=%s, cols=%s, viewMode=%s, viewType=%s, tocMode=%s)"%(current,start,rows,cols,viewMode,viewType,tocMode))
+         pageinfo = {}
+         pageinfo['viewMode'] = viewMode
+         pageinfo['viewType'] = viewType
+         pageinfo['tocMode'] = tocMode
-         while e.tagName!="p":
+         current = getInt(current)
-             e=e.parentNode
+         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
+         # is start is empty use one around current
+         start = getInt(start, default=(math.ceil(float(current)/float(grpsize))*grpsize-(grpsize-1)))
+         # int(current / grpsize) * grpsize +1))
+         pageinfo['start'] = start
+         pn = self.REQUEST.get('pn','1')
+         pageinfo['pn'] = pn
+         np = int(docinfo.get('numPages', 0))
+         if np == 0:
+             # numPages unknown - maybe we can get it from text page
+             if docinfo.get('textURLPath', None):
+                 # cache text page as well
+                 pageinfo['textPage'] = self.getTextPage(mode=viewType, pn=pn, docinfo=docinfo, pageinfo=pageinfo)
+                 np = int(docinfo.get('numPages', 0))
+         pageinfo['numgroups'] = int(np / grpsize)
+         if np % grpsize > 0:
+             pageinfo['numgroups'] += 1
+         pageFlowLtr = docinfo.get('pageFlow', 'ltr') != 'rtl'
+         oddScanLeft = docinfo.get('oddPage', 'left') != 'right'
+         # add zeroth page for two columns
+         pageZero = (cols == 2 and (pageFlowLtr != oddScanLeft))
+         pageinfo['pageZero'] = pageZero
+         pageinfo['pageList'] = self.getPageList(start=start, rows=rows, cols=cols, pageFlowLtr=pageFlowLtr, pageZero=pageZero, minIdx=1, maxIdx=np)
+         pageinfo['characterNormalization'] = self.REQUEST.get('characterNormalization','reg')
+         pageinfo['query'] = self.REQUEST.get('query','')
+         pageinfo['queryType'] = self.REQUEST.get('queryType','')
+         pageinfo['querySearch'] =self.REQUEST.get('querySearch', 'fulltext')
+         pageinfo['highlightQuery'] = self.REQUEST.get('highlightQuery','')
+         pageinfo['tocPageSize'] = getInt(self.REQUEST.get('tocPageSize', 30))
+         pageinfo['queryPageSize'] = getInt(self.REQUEST.get('queryPageSize', 10))
+         pageinfo['tocPN'] = getInt(self.REQUEST.get('tocPN', '1'))
+         pageinfo['searchPN'] = getInt(self.REQUEST.get('searchPN','1'))
+         # limit tocPN
+         if 'tocSize_%s'%tocMode in docinfo:
+             tocSize = docinfo['tocSize_%s'%tocMode]
+             tocPageSize = pageinfo['tocPageSize']
+             # cached toc
+             if tocSize%tocPageSize>0:
+                 tocPages=tocSize/tocPageSize+1
+             else:
+                 tocPages=tocSize/tocPageSize
+             pageinfo['tocPN'] = min(tocPages,pageinfo['tocPN'])
-         next=node.parentNode
+         return pageinfo
-         #sammle s
-         while next and (next!=endNode.parentNode):
-             list.append(next)
-             next=next.nextSibling
-         list.append(endNode.parentNode)
-         if p==e:# beide im selben paragraphen
+     def getPageList(self, start=None, rows=None, cols=None, pageFlowLtr=True, pageZero=False, minIdx=1, maxIdx=0):
-             pass
+         """returns array of page informations for one screenfull of thumbnails"""
- #    else:
+         if maxIdx == 0:
- #            next=p
+             maxIdx = start + rows * cols
- #            while next!=e:
- #                print next,e
+         pages = []
- #                list.append(next)
+         if pageZero and start == 1:
- #                next=next.nextSibling
+             # correct beginning
- #
+             idx = 0
- #        for x in list:
+         else:
- #            PrettyPrint(x)
+             idx = start
- #
- #        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
+         for r in range(rows):
+             row = []
+             for c in range(cols):
+                 if idx < minIdx or idx > maxIdx:
+                     page = {'idx':None}
+                 else:
+                     page = {'idx':idx}
-     def findDigilibUrl(self):
+                 idx += 1
-         """try to get the digilib URL from zogilib"""
+                 if pageFlowLtr:
-         url = self.imageViewerUrl[:-1] + "/getScalerUrl"
+                     row.append(page)
-         try:
+                 else:
-             scaler = urlopen(url).read()
+                     row.insert(0, page)
-             return scaler.replace("/servlet/Scaler?", "")
-         except:
+             pages.append(row)
-             return None
+         logging.debug("getPageList returns=%s"%(pages))
+         return pages
+     security.declareProtected('View management screens','changeDocumentViewerForm')
+     changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
-     def changeDocumentViewer(self,imageViewerUrl,title="",digilibBaseUrl=None,RESPONSE=None):
+     def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None):
          """init document viewer"""
          self.title=title
-         self.imageViewerUrl=imageViewerUrl
          self.digilibBaseUrl = digilibBaseUrl
+         self.thumbrows = thumbrows
+         self.thumbcols = thumbcols
+         self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
+         try:
+             # assume MetaDataFolder instance is called metadata
+             self.metadataService = getattr(self, 'metadata')
+         except Exception, e:
+             logging.error("Unable to find MetaDataFolder 'metadata': "+str(e))
          if RESPONSE is not None:
              RESPONSE.redirect('manage_main')
- #    security.declareProtected('View management screens','renameImageForm')
  def manage_AddDocumentViewerForm(self):
      """add the viewer form"""
      pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
      return pt()
- def manage_AddDocumentViewer(self,id,imageViewerUrl="",title="",RESPONSE=None):
+ def manage_AddDocumentViewer(self,id,imageScalerUrl="",textServerName="",title="",RESPONSE=None):
      """add the viewer"""
-     newObj=documentViewer(id,imageViewerUrl,title)
+     newObj=documentViewer(id,imageScalerUrl=imageScalerUrl,title=title,textServerName=textServerName)
      self._setObject(id,newObj)
      if RESPONSE is not None:
          RESPONSE.redirect('manage_main')
- ##
  ## DocumentViewerTemplate class
- ##
  class DocumentViewerTemplate(ZopePageTemplate):
      """Template for document viewer"""
      meta_type="DocumentViewer Template"
- Line 432  def manage_addDocumentViewerTemplate(sel
+ Line 844  def manage_addDocumentViewerTemplate(sel
      self._setObject(id, DocumentViewerTemplate(id))
      ob = getattr(self, id)
-     ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/viewer_main.zpt')).read(),None)
+     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:

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

Removed from v.1.3
changed lines
	Added in v.1.175.2.24