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

Diff for /documentViewer/documentViewer.py between versions 1.46 and 1.178

version 1.46, 2010/04/21 13:50:59 version 1.178, 2012/01/04 07:38:17
Line 5  from Products.PageTemplates.PageTemplate Line 5  from Products.PageTemplates.PageTemplate
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
 from AccessControl import getSecurityManager  from AccessControl import getSecurityManager
 from Globals import package_home  from Globals import package_home
   from Products.zogiLib.zogiLib import browserCheck
   
 from Ft.Xml.Domlette import NonvalidatingReader  
 from Ft.Xml.Domlette import PrettyPrint, Print  
 from Ft.Xml import EMPTY_NAMESPACE, Parse  from Ft.Xml import EMPTY_NAMESPACE, Parse
   import Ft.Xml.Domlette
   
 import Ft.Xml.XPath  
 import cStringIO  
 import xmlrpclib  
 import os.path  import os.path
 import sys  import sys
 import cgi  
 import urllib  import urllib
   import urllib2
 import logging  import logging
 import math  import math
   
 import urlparse   import urlparse 
 from types import *  import cStringIO
   import re
   import string
   
 def logger(txt,method,txt2):  def logger(txt,method,txt2):
     """logging"""      """logging"""
Line 47  def getTextFromNode(nodename): Line 43  def getTextFromNode(nodename):
            rc = rc + node.data             rc = rc + node.data
     return rc      return rc
   
 def serializeNode(node, encoding='utf-8'):  def serializeNode(node, encoding="utf-8"):
     """returns a string containing node as XML"""      """returns a string containing node as XML"""
     buf = cStringIO.StringIO()      stream = cStringIO.StringIO()
     Print(node, stream=buf, encoding=encoding)      #logging.debug("BUF: %s"%(stream))
     s = buf.getvalue()      Ft.Xml.Domlette.Print(node, stream=stream, encoding=encoding)
     buf.close()      s = stream.getvalue()
       #logging.debug("BUF: %s"%(s))
       stream.close()
     return s      return s
   
   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:
           nav = ua[string.find(ua, '('):]
           nav1=ua[string.find(ua,')'):]
           nav2=nav1[string.find(nav1,'('):]
           nav3=nav2[string.find(nav2,')'):]
           ie = string.split(nav, "; ")[1]
           ie1 =string.split(nav1, " ")[2]
           ie2 =string.split(nav3, " ")[1]
           ie3 =string.split(nav3, " ")[2]
           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 getParentDir(path):  def getParentDir(path):
     """returns pathname shortened by one"""      """returns pathname shortened by one"""
     return '/'.join(path.split('/')[0:-1])      return '/'.join(path.split('/')[0:-1])
                   
   
   def getHttpData(url, data=None, num_tries=3, timeout=10):
       """returns result from url+data HTTP request"""
       # we do GET (by appending data to url)
       if isinstance(data, str) or isinstance(data, unicode):
           # if data is string then append
           url = "%s?%s"%(url,data)
       elif isinstance(data, dict) or isinstance(data, list) or isinstance(data, tuple):
           # urlencode
           url = "%s?%s"%(url,urllib.urlencode(data))
       
       response = None
       errmsg = None
       for cnt in range(num_tries):
           try:
               logging.debug("getHttpData(#%s %ss) url=%s"%(cnt+1,timeout,url))
               if sys.version_info < (2, 6):
                   # set timeout on socket -- ugly :-(
 import socket  import socket
                   socket.setdefaulttimeout(float(timeout))
                   response = urllib2.urlopen(url)
               else:
                   response = urllib2.urlopen(url,timeout=float(timeout))
               # check result?
               break
           except urllib2.HTTPError, e:
               logging.error("getHttpData: HTTP error(%s): %s"%(e.code,e))
               errmsg = str(e)
               # stop trying
               break
           except urllib2.URLError, e:
               logging.error("getHttpData: URLLIB error(%s): %s"%(e.reason,e))
               errmsg = str(e)
               # stop trying
               #break
   
       if response is not None:
           data = response.read()
           response.close()
           return data
   
 def urlopen(url,timeout=2):      raise IOError("ERROR fetching HTTP data from %s: %s"%(url,errmsg))
         """urlopen mit timeout"""      #return None
         socket.setdefaulttimeout(timeout)  
         ret=urllib.urlopen(url)  
         socket.setdefaulttimeout(5)  
         return ret  
   
   
 ##  ##
 ## documentViewer class  ## documentViewer class
 ##  ##
 class documentViewer(Folder):  class documentViewer(Folder):
     """document viewer"""      """document viewer"""
     #textViewerUrl="http://127.0.0.1:8080/HFQP/testXSLT/getPage?"  
       
     meta_type="Document viewer"      meta_type="Document viewer"
           
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
Line 91  class documentViewer(Folder): Line 181  class documentViewer(Folder):
     toc_text = PageTemplateFile('zpt/toc_text', globals())      toc_text = PageTemplateFile('zpt/toc_text', globals())
     toc_figures = PageTemplateFile('zpt/toc_figures', globals())      toc_figures = PageTemplateFile('zpt/toc_figures', globals())
     page_main_images = PageTemplateFile('zpt/page_main_images', 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 = PageTemplateFile('zpt/page_main_text', globals())
     page_main_text_dict = PageTemplateFile('zpt/page_main_text_dict', 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())      head_main = PageTemplateFile('zpt/head_main', globals())
     docuviewer_css = PageTemplateFile('css/docuviewer.css', globals())      docuviewer_css = PageTemplateFile('css/docuviewer.css', globals())
     info_xml = PageTemplateFile('zpt/info_xml', globals())      info_xml = PageTemplateFile('zpt/info_xml', globals())
   
       
     thumbs_main_rss = PageTemplateFile('zpt/thumbs_main_rss', globals())      thumbs_main_rss = PageTemplateFile('zpt/thumbs_main_rss', globals())
     security.declareProtected('View management screens','changeDocumentViewerForm')          security.declareProtected('View management screens','changeDocumentViewerForm')    
     changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())      changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
Line 116  class documentViewer(Folder): Line 211  class documentViewer(Folder):
         #self['template'] = templateFolder # Zope-2.12 style          #self['template'] = templateFolder # Zope-2.12 style
         self._setObject('template',templateFolder) # old style          self._setObject('template',templateFolder) # old style
         try:          try:
             from Products.XMLRpcTools.XMLRpcTools import XMLRpcServerProxy              import MpdlXmlTextServer
             xmlRpcClient = XMLRpcServerProxy(id='fulltextclient', serverUrl=textServerName, use_xmlrpc=False)              textServer = MpdlXmlTextServer.MpdlXmlTextServer(id='fulltextclient',serverName=textServerName)
             #templateFolder['fulltextclient'] = xmlRpcClient              #templateFolder['fulltextclient'] = xmlRpcClient
             templateFolder._setObject('fulltextclient',xmlRpcClient)              templateFolder._setObject('fulltextclient',textServer)
         except Exception, e:          except Exception, e:
             logging.error("Unable to create XMLRpcTools for fulltextclient: "+str(e))              logging.error("Unable to create MpdlXmlTextServer for fulltextclient: "+str(e))
         try:          try:
             from Products.zogiLib.zogiLib import zogiLib              from Products.zogiLib.zogiLib import zogiLib
             zogilib = zogiLib(id="zogilib", title="zogilib for docuviewer", dlServerURL=imageScalerUrl, layout="book")              zogilib = zogiLib(id="zogilib", title="zogilib for docuviewer", dlServerURL=imageScalerUrl, layout="book")
Line 131  class documentViewer(Folder): Line 226  class documentViewer(Folder):
             logging.error("Unable to create zogiLib for zogilib: "+str(e))              logging.error("Unable to create zogiLib for zogilib: "+str(e))
                   
   
       # proxy text server methods to fulltextclient
       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 getTranslate(self, **args):
           """get translate"""
           return self.template.fulltextclient.getTranslate(**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')      security.declareProtected('View','thumbs_rss')
     def thumbs_rss(self,mode,url,viewMode="auto",start=None,pn=1):      def thumbs_rss(self,mode,url,viewMode="auto",start=None,pn=1):
         '''          '''
Line 151  class documentViewer(Folder): Line 300  class documentViewer(Folder):
             self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"              self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
                           
         docinfo = self.getDocinfo(mode=mode,url=url)          docinfo = self.getDocinfo(mode=mode,url=url)
           #pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)
         pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)          pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)
           ''' ZDES '''
         pt = getattr(self.template, 'thumbs_main_rss')          pt = getattr(self.template, 'thumbs_main_rss')
                   
         if viewMode=="auto": # automodus gewaehlt          if viewMode=="auto": # automodus gewaehlt
             if docinfo.get("textURL",'') and self.textViewerUrl: #texturl gesetzt und textViewer konfiguriert              if docinfo.has_key("textURL") or docinfo.get('textURLPath',None): #texturl gesetzt und textViewer konfiguriert
                 viewMode="text"                  viewMode="text"
             else:              else:
                 viewMode="images"                  viewMode="images"
Line 163  class documentViewer(Folder): Line 314  class documentViewer(Folder):
         return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode)          return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode)
       
     security.declareProtected('View','index_html')      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):      def index_html(self,url,mode="texttool",viewMode="auto",tocMode="thumbs",start=None,pn=1,mk=None):
         '''          '''
         view it          view it
         @param mode: defines how to access the document behind url           @param mode: defines how to access the document behind url 
         @param url: url which contains display information          @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 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, search)          @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)          @param characterNormalization type of text display (reg, norm, 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))          logging.debug("documentViewer (index) mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
Line 181  class documentViewer(Folder): Line 333  class documentViewer(Folder):
             return "ERROR: template folder missing!"              return "ERROR: template folder missing!"
                           
         if not getattr(self, 'digilibBaseUrl', None):          if not getattr(self, 'digilibBaseUrl', None):
             self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"              self.digilibBaseUrl = self.findDigilibUrl() or "http://digilib.mpiwg-berlin.mpg.de/digitallibrary"
                           
         docinfo = self.getDocinfo(mode=mode,url=url)          docinfo = self.getDocinfo(mode=mode,url=url)
         pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo,viewMode=viewMode,tocMode=tocMode)          
         if tocMode != "thumbs":          if tocMode != "thumbs":
             # get table of contents              # get table of contents
             docinfo = self.getToc(mode=tocMode, docinfo=docinfo)              docinfo = self.getToc(mode=tocMode, docinfo=docinfo)
   
         if viewMode=="auto": # automodus gewaehlt          if viewMode=="auto": # automodus gewaehlt
             if docinfo.get("textURL",''): #texturl gesetzt und textViewer konfiguriert              if docinfo.has_key('textURL') or docinfo.get('textURLPath',None): #texturl gesetzt und textViewer konfiguriert
                 viewMode="text"                  viewMode="text_dict"
             else:              else:
                 viewMode="images"                  viewMode="images"
                                   
         pt = getattr(self.template, 'viewer_main')                         pageinfo = self.getPageinfo(start=start,current=pn, docinfo=docinfo,viewMode=viewMode,tocMode=tocMode)
           
           if (docinfo.get('textURLPath',None)):
               page = self.getTextPage(docinfo=docinfo, pageinfo=pageinfo)
               pageinfo['textPage'] = page
           tt = getattr(self, 'template')   
           pt = getattr(tt, 'viewer_main')               
         return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode,mk=self.generateMarks(mk))          return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode,mk=self.generateMarks(mk))
       
     def generateMarks(self,mk):      def generateMarks(self,mk):
         ret=""          ret=""
         if mk is None:          if mk is None:
             return ""              return ""
         if type(mk) is not ListType:          if not isinstance(mk, list):
             mk=[mk]              mk=[mk]
         for m in mk:          for m in mk:
             ret+="mk=%s"%m              ret+="mk=%s"%m
         return ret          return ret
   
   
       def getBrowser(self):
           """getBrowser the version of browser """
           bt = browserCheck(self)
           logging.debug("BROWSER VERSION: %s"%(bt))
           return bt
           
     def findDigilibUrl(self):      def findDigilibUrl(self):
         """try to get the digilib URL from zogilib"""          """try to get the digilib URL from zogilib"""
         url = self.template.zogilib.getDLBaseUrl()          url = self.template.zogilib.getDLBaseUrl()
         return url          return url
           
       def getDocumentViewerURL(self):
           """returns the URL of this instance"""
           return self.absolute_url()
       
     def getStyle(self, idx, selected, style=""):      def getStyle(self, idx, selected, style=""):
         """returns a string with the given style and append 'sel' if path == selected."""          """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))          #logger("documentViewer (getstyle)", logging.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
Line 222  class documentViewer(Folder): Line 390  class documentViewer(Folder):
         else:          else:
             return style              return style
           
     def getLink(self,param=None,val=None):      def getLink(self, param=None, val=None, params=None, baseUrl=None, paramSep='&'):
         """link to documentviewer with parameter param set to val"""          """returns URL to documentviewer with parameter param set to val or from dict params"""
         params=self.REQUEST.form.copy()          # copy existing request params
           urlParams=self.REQUEST.form.copy()
           # change single param
         if param is not None:          if param is not None:
             if val is None:              if val is None:
                 if params.has_key(param):                  if urlParams.has_key(param):
                     del params[param]                      del urlParams[param]
             else:              else:
                 params[param] = str(val)                  urlParams[param] = str(val)
                                   
         if params.get("mode", None) == "filepath": #wenn beim erst Aufruf filepath gesetzt wurde aendere das nun zu imagepath          # change more params
                 params["mode"] = "imagepath"          if params is not None:
                 params["url"] = getParentDir(params["url"])              for k in params.keys():
                                   v = params[k]
         # quote values and assemble into query string                  if v is None:
         ps = "&".join(["%s=%s"%(k,urllib.quote(v)) for (k, v) in params.items()])                      # val=None removes param
         url=self.REQUEST['URL1']+"?"+ps                      if urlParams.has_key(k):
                           del urlParams[k]
                           
                   else:
                       urlParams[k] = v
   
           # FIXME: does this belong here?
           if urlParams.get("mode", None) == "filepath": #wenn beim erst Aufruf filepath gesetzt wurde aendere das nun zu imagepath
                   urlParams["mode"] = "imagepath"
                   urlParams["url"] = getParentDir(urlParams["url"])
                   
           # quote values and assemble into query string (not escaping '/')
           ps = paramSep.join(["%s=%s"%(k,urllib.quote_plus(v,'/')) for (k, v) in urlParams.items()])
           #ps = urllib.urlencode(urlParams)
           if baseUrl is None:
               baseUrl = self.REQUEST['URL1']
               
           url = "%s?%s"%(baseUrl, ps)
         return url          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:  
                 params[param] = str(val)  
                                   
         # quote values and assemble into query string      def getLinkAmp(self, param=None, val=None, params=None, baseUrl=None):
         logging.info("XYXXXXX: %s"%repr(params.items()))          """link to documentviewer with parameter param set to val"""
         ps = "&amp;".join(["%s=%s"%(k,urllib.quote(v)) for (k, v) in params.items()])          return self.getLink(param, val, params, baseUrl, '&amp;')
         url=self.REQUEST['URL1']+"?"+ps  
         return url  
           
     def getInfo_xml(self,url,mode):      def getInfo_xml(self,url,mode):
         """returns info about the document as XML"""          """returns info about the document as XML"""
Line 267  class documentViewer(Folder): Line 443  class documentViewer(Folder):
         pt = getattr(self.template, 'info_xml')          pt = getattr(self.template, 'info_xml')
         return pt(docinfo=docinfo)          return pt(docinfo=docinfo)
   
       def getOptionToggle(self, newState=None, optionName='text_options_open', initialState=True):
           """returns new option state"""
           if not self.REQUEST.SESSION.has_key(optionName):
               # not in session -- initial
               opt = {'lastState': newState, 'state': initialState}
           else:
               opt = self.REQUEST.SESSION.get(optionName)
               if opt['lastState'] != newState:
                   # state in session has changed -- toggle
                   opt['state'] = not opt['state']
                   opt['lastState'] = newState
           
           self.REQUEST.SESSION[optionName] = opt
           return opt['state']
           
     def isAccessible(self, docinfo):      def isAccessible(self, docinfo):
         """returns if access to the resource is granted"""          """returns if access to the resource is granted"""
         access = docinfo.get('accessType', None)          access = docinfo.get('accessType', None)
         logger("documentViewer (accessOK)", logging.INFO, "access type %s"%access)          logging.debug("documentViewer (accessOK) access type %s"%access)
         if access is not None and access == 'free':          if access is not None and access == 'free':
             logger("documentViewer (accessOK)", logging.INFO, "access is free")              logging.debug("documentViewer (accessOK) access is free")
             return True              return True
         elif access is None or access in self.authgroups:          elif access is None or access in self.authgroups:
             # only local access -- only logged in users              # only local access -- only logged in users
             user = getSecurityManager().getUser()              user = getSecurityManager().getUser()
               logging.debug("documentViewer (accessOK) user=%s ip=%s"%(user,self.REQUEST.getClientAddr()))
             if user is not None:              if user is not None:
                 #print "user: ", user                  #print "user: ", user
                 return (user.getUserName() != "Anonymous User")                  return (user.getUserName() != "Anonymous User")
             else:              else:
                 return False                  return False
                   
         logger("documentViewer (accessOK)", logging.INFO, "unknown access type %s"%access)          logging.error("documentViewer (accessOK) unknown access type %s"%access)
         return False          return False
           
                                   
     def getDirinfoFromDigilib(self,path,docinfo=None,cut=0):      def getDirinfoFromDigilib(self,path,docinfo=None,cut=0):
         """gibt param von dlInfo aus"""          """gibt param von dlInfo aus"""
         num_retries = 3  
         if docinfo is None:          if docinfo is None:
             docinfo = {}              docinfo = {}
                   
Line 300  class documentViewer(Folder): Line 490  class documentViewer(Folder):
                 
         infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path          infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path
           
         logger("documentViewer (getparamfromdigilib)", logging.INFO, "dirInfo from %s"%(infoUrl))          logging.debug("documentViewer (getparamfromdigilib) dirInfo from %s"%(infoUrl))
                   
         for cnt in range(num_retries):          txt = getHttpData(infoUrl)
             try:          if txt is None:
                 # 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))              raise IOError("Unable to get dir-info from %s"%(infoUrl))
                   
           dom = Parse(txt)
         sizes=dom.xpath("//dir/size")          sizes=dom.xpath("//dir/size")
         logger("documentViewer (getparamfromdigilib)", logging.INFO, "dirInfo:size"%sizes)          logging.debug("documentViewer (getparamfromdigilib) dirInfo:size"%sizes)
                   
         if sizes:          if sizes:
             docinfo['numPages'] = int(getTextFromNode(sizes[0]))              docinfo['numPages'] = int(getTextFromNode(sizes[0]))
Line 325  class documentViewer(Folder): Line 509  class documentViewer(Folder):
                                                   
         return docinfo          return docinfo
           
       def getIndexMetaPath(self,url):
           """gib nur den Pfad zurueck"""
           regexp = re.compile(r".*(experimental|permanent)/(.*)")
           regpath = regexp.match(url)
           if (regpath==None):
               return ""
           logging.debug("(getDomFromIndexMeta): URLXAXA: %s"%regpath.group(2))            
           return ("/mpiwg/online/"+regpath.group(1)+"/"+regpath.group(2))
        
       
       
       def getIndexMetaUrl(self,url):
           """returns utr  of index.meta document at url"""
                           
     def getIndexMeta(self, url):  
         """returns dom of index.meta document at url"""  
         num_retries = 3  
         dom = None  
         metaUrl = None          metaUrl = None
         if url.startswith("http://"):          if url.startswith("http://"):
             # real URL              # real URL
Line 340  class documentViewer(Folder): Line 533  class documentViewer(Folder):
             metaUrl=server+url.replace("/mpiwg/online","")              metaUrl=server+url.replace("/mpiwg/online","")
             if not metaUrl.endswith("index.meta"):              if not metaUrl.endswith("index.meta"):
                 metaUrl += "/index.meta"                  metaUrl += "/index.meta"
         logging.debug("METAURL: %s"%metaUrl)  
         for cnt in range(num_retries):  
             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 (getIndexMeta)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])  
                                   
         if dom is None:          return metaUrl
       
       def getDomFromIndexMeta(self, url):
           """get dom from index meta"""
           dom = None
           metaUrl = self.getIndexMetaUrl(url)
                   
           logging.debug("(getDomFromIndexMeta): METAURL: %s"%metaUrl)
           txt=getHttpData(metaUrl)
           if txt is None:
             raise IOError("Unable to read index meta from %s"%(url))              raise IOError("Unable to read index meta from %s"%(url))
                                     
           dom = Parse(txt)
         return dom          return dom
           
     def getPresentationInfoXML(self, url):      def getPresentationInfoXML(self, url):
         """returns dom of info.xml document at url"""          """returns dom of info.xml document at url"""
         num_retries = 3  
         dom = None          dom = None
         metaUrl = None          metaUrl = None
         if url.startswith("http://"):          if url.startswith("http://"):
Line 369  class documentViewer(Folder): Line 561  class documentViewer(Folder):
             server=self.digilibBaseUrl+"/servlet/Texter?fn="              server=self.digilibBaseUrl+"/servlet/Texter?fn="
             metaUrl=server+url.replace("/mpiwg/online","")              metaUrl=server+url.replace("/mpiwg/online","")
                   
         for cnt in range(num_retries):          txt=getHttpData(metaUrl)
             try:          if txt is None:
                 # 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])  
                   
         if dom is None:  
             raise IOError("Unable to read infoXMLfrom %s"%(url))              raise IOError("Unable to read infoXMLfrom %s"%(url))
                                     
           dom = Parse(txt)
         return dom          return dom
                                                   
                   
     def getAuthinfoFromIndexMeta(self,path,docinfo=None,dom=None,cut=0):      def getAuthinfoFromIndexMeta(self,path,docinfo=None,dom=None,cut=0):
         """gets authorization info from the index.meta file at path or given by dom"""          """gets authorization info from the index.meta file at path or given by dom"""
         logger("documentViewer (getauthinfofromindexmeta)", logging.INFO,"path: %s"%(path))          logging.debug("documentViewer (getauthinfofromindexmeta) path: %s"%(path))
                   
         access = None          access = None
                   
Line 397  class documentViewer(Folder): Line 581  class documentViewer(Folder):
         if dom is None:          if dom is None:
             for x in range(cut):              for x in range(cut):
                 path=getParentDir(path)                  path=getParentDir(path)
             dom = self.getIndexMeta(path)              dom = self.getDomFromIndexMeta(path)
                 
         acctype = dom.xpath("//access-conditions/access/@type")          acctype = dom.xpath("//access-conditions/access/@type")
         if acctype and (len(acctype)>0):          if acctype and (len(acctype)>0):
Line 411  class documentViewer(Folder): Line 595  class documentViewer(Folder):
                   
     def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None,cut=0):      def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None,cut=0):
         """gets bibliographical info from the index.meta file at path or given by dom"""          """gets bibliographical info from the index.meta file at path or given by dom"""
         logging.debug("documentViewer (getbibinfofromindexmeta) path: %s"%(path))          #logging.debug("documentViewer (getbibinfofromindexmeta) path: %s"%(path))
                   
         if docinfo is None:          if docinfo is None:
             docinfo = {}              docinfo = {}
Line 419  class documentViewer(Folder): Line 603  class documentViewer(Folder):
         if dom is None:          if dom is None:
             for x in range(cut):              for x in range(cut):
                 path=getParentDir(path)                  path=getParentDir(path)
             dom = self.getIndexMeta(path)              dom = self.getDomFromIndexMeta(path)
           
           docinfo['indexMetaPath']=self.getIndexMetaPath(path);
                   
         logging.debug("documentViewer (getbibinfofromindexmeta cutted) path: %s"%(path))          #logging.debug("documentViewer (getbibinfofromindexmeta cutted) path: %s"%(path))
         # put in all raw bib fields as dict "bib"          # put in all raw bib fields as dict "bib"
         bib = dom.xpath("//bib/*")          bib = dom.xpath("//bib/*")
         if bib and len(bib)>0:          if bib and len(bib)>0:
Line 441  class documentViewer(Folder): Line 627  class documentViewer(Folder):
         bibtype=bibtype.replace("-"," ") # wrong typesiin index meta "-" instead of " " (not wrong! ROC)          bibtype=bibtype.replace("-"," ") # wrong typesiin index meta "-" instead of " " (not wrong! ROC)
         docinfo['bib_type'] = bibtype          docinfo['bib_type'] = bibtype
         bibmap=metaData.generateMappingForType(bibtype)          bibmap=metaData.generateMappingForType(bibtype)
           #logging.debug("documentViewer (getbibinfofromindexmeta) bibmap:"+repr(bibmap))
           #logging.debug("documentViewer (getbibinfofromindexmeta) bibtype:"+repr(bibtype))
         # if there is no mapping bibmap is empty (mapping sometimes has empty fields)          # if there is no mapping bibmap is empty (mapping sometimes has empty fields)
         if len(bibmap) > 0 and len(bibmap['author'][0]) > 0:          if len(bibmap) > 0 and len(bibmap['author'][0]) > 0:
             try:              try:
Line 452  class documentViewer(Folder): Line 640  class documentViewer(Folder):
             try:              try:
                 docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['year'][0])[0])                  docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['year'][0])[0])
             except: pass              except: pass
             logging.debug("documentViewer (getbibinfofromindexmeta) using mapping for %s"%bibtype)              #logging.debug("documentViewer (getbibinfofromindexmeta) using mapping for %s"%bibtype)
             try:              try:
                 docinfo['lang']=getTextFromNode(dom.xpath("//bib/lang")[0])                  docinfo['lang']=getTextFromNode(dom.xpath("//bib/lang")[0])
             except:              except:
                 docinfo['lang']=''                  docinfo['lang']=''
               try:
                   docinfo['city']=getTextFromNode(dom.xpath("//bib/city")[0])
               except:
                   docinfo['city']=''
               try:
                   docinfo['number_of_pages']=getTextFromNode(dom.xpath("//bib/number_of_pages")[0])
               except:
                   docinfo['number_of_pages']=''
               try:
                   docinfo['series_volume']=getTextFromNode(dom.xpath("//bib/series_volume")[0])
               except:
                   docinfo['series_volume']=''
               try:
                   docinfo['number_of_volumes']=getTextFromNode(dom.xpath("//bib/number_of_volumes")[0])
               except:
                   docinfo['number_of_volumes']=''
               try:
                   docinfo['translator']=getTextFromNode(dom.xpath("//bib/translator")[0])
               except:
                   docinfo['translator']=''
               try:
                   docinfo['edition']=getTextFromNode(dom.xpath("//bib/edition")[0])
               except:
                   docinfo['edition']=''
               try:
                   docinfo['series_author']=getTextFromNode(dom.xpath("//bib/series_author")[0])
               except:
                   docinfo['series_author']=''
               try:
                   docinfo['publisher']=getTextFromNode(dom.xpath("//bib/publisher")[0])
               except:
                   docinfo['publisher']=''
               try:
                   docinfo['series_title']=getTextFromNode(dom.xpath("//bib/series_title")[0])
               except:
                   docinfo['series_title']=''
               try:
                   docinfo['isbn_issn']=getTextFromNode(dom.xpath("//bib/isbn_issn")[0])
               except:
                   docinfo['isbn_issn']=''           
           #logging.debug("I NEED BIBTEX %s"%docinfo)
         return docinfo          return docinfo
           
           
       def getNameFromIndexMeta(self,path,docinfo=None,dom=None,cut=0):
           """gets name info from the index.meta file at path or given by dom"""
           if docinfo is None:
               docinfo = {}
           
           if dom is None:
               for x in range(cut):
                   path=getParentDir(path)
               dom = self.getDomFromIndexMeta(path)
   
           docinfo['name']=getTextFromNode(dom.xpath("/resource/name")[0])
           logging.debug("documentViewer docinfo[name] %s"%docinfo['name'])
           return docinfo
       
     def getDocinfoFromTextTool(self, url, dom=None, docinfo=None):      def getDocinfoFromTextTool(self, url, dom=None, docinfo=None):
         """parse texttool tag in index meta"""          """parse texttool tag in index meta"""
         logger("documentViewer (getdocinfofromtexttool)", logging.INFO, "url: %s" % (url))          logging.debug("documentViewer (getdocinfofromtexttool) url: %s" % (url))
         if docinfo is None:          if docinfo is None:
            docinfo = {}             docinfo = {}
         if docinfo.get('lang', None) is None:          if docinfo.get('lang', None) is None:
             docinfo['lang'] = '' # default keine Sprache gesetzt              docinfo['lang'] = '' # default keine Sprache gesetzt
         if dom is None:          if dom is None:
             dom = self.getIndexMeta(url)              dom = self.getDomFromIndexMeta(url)
                   
         archivePath = None          archivePath = None
         archiveName = None          archiveName = None
Line 478  class documentViewer(Folder): Line 720  class documentViewer(Folder):
         if archiveNames and (len(archiveNames) > 0):          if archiveNames and (len(archiveNames) > 0):
             archiveName = getTextFromNode(archiveNames[0])              archiveName = getTextFromNode(archiveNames[0])
         else:          else:
             logger("documentViewer (getdocinfofromtexttool)", logging.WARNING, "resource/name missing in: %s" % (url))              logging.warning("documentViewer (getdocinfofromtexttool) resource/name missing in: %s" % (url))
                   
         archivePaths = dom.xpath("//resource/archive-path")          archivePaths = dom.xpath("//resource/archive-path")
         if archivePaths and (len(archivePaths) > 0):          if archivePaths and (len(archivePaths) > 0):
Line 490  class documentViewer(Folder): Line 732  class documentViewer(Folder):
                 archivePath += "/" + archiveName                  archivePath += "/" + archiveName
         else:          else:
             # try to get archive-path from url              # try to get archive-path from url
             logger("documentViewer (getdocinfofromtexttool)", logging.WARNING, "resource/archive-path missing in: %s" % (url))              logging.warning("documentViewer (getdocinfofromtexttool) resource/archive-path missing in: %s" % (url))
             if (not url.startswith('http')):              if (not url.startswith('http')):
                 archivePath = url.replace('index.meta', '')                  archivePath = url.replace('index.meta', '')
                                   
Line 524  class documentViewer(Folder): Line 766  class documentViewer(Folder):
             viewerUrl = getTextFromNode(viewerUrls[0])              viewerUrl = getTextFromNode(viewerUrls[0])
             docinfo['viewerURL'] = viewerUrl              docinfo['viewerURL'] = viewerUrl
                                         
           # old style text URL
         textUrls = dom.xpath("//texttool/text")          textUrls = dom.xpath("//texttool/text")
         if textUrls and (len(textUrls) > 0):          if textUrls and (len(textUrls) > 0):
             textUrl = getTextFromNode(textUrls[0])              textUrl = getTextFromNode(textUrls[0])
Line 535  class documentViewer(Folder): Line 778  class documentViewer(Folder):
                           
             docinfo['textURL'] = textUrl              docinfo['textURL'] = textUrl
           
   
               #TODO: hack-DW for annalen
               if (textUrl is not None) and (textUrl.startswith("/permanent/einstein/annalen")):
                   textUrl=textUrl.replace("/permanent/einstein/annalen/","/diverse/de/") 
                   splitted=textUrl.split("/fulltext")
                   textUrl=splitted[0]+".xml"
                   textUrlkurz = string.split(textUrl, ".")[0]
                   docinfo['textURLPathkurz'] = textUrlkurz
                   docinfo['textURLPath'] = textUrl
                   logging.debug("hack")
                   logging.debug(textUrl)
               
               
           # new style text-url-path
         textUrls = dom.xpath("//texttool/text-url-path")          textUrls = dom.xpath("//texttool/text-url-path")
         if textUrls and (len(textUrls) > 0):          if textUrls and (len(textUrls) > 0):
             textUrl = getTextFromNode(textUrls[0])              textUrl = getTextFromNode(textUrls[0])
             docinfo['textURLPath'] = textUrl                 docinfo['textURLPath'] = textUrl   
               textUrlkurz = string.split(textUrl, ".")[0]
               docinfo['textURLPathkurz'] = textUrlkurz
               #if not docinfo['imagePath']:
                   # text-only, no page images
                   #docinfo = self.getNumTextPages(docinfo)
                     
                     
         presentationUrls = dom.xpath("//texttool/presentation")          presentationUrls = dom.xpath("//texttool/presentation")
         docinfo = self.getBibinfoFromIndexMeta(url, docinfo=docinfo, dom=dom)   # get info von bib tag          docinfo = self.getBibinfoFromIndexMeta(url, docinfo=docinfo, dom=dom)   # get info von bib tag
           #docinfo = self.getDownloadfromDocinfoToBibtex(url, docinfo=docinfo, dom=dom)
           docinfo = self.getNameFromIndexMeta(url, docinfo=docinfo, dom=dom)
           
                   
         if presentationUrls and (len(presentationUrls) > 0): # ueberschreibe diese durch presentation informationen           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               # presentation url ergiebt sich ersetzen von index.meta in der url der fuer die Metadaten
Line 551  class documentViewer(Folder): Line 817  class documentViewer(Folder):
                 presentationUrl = url.replace('index.meta', presentationPath)                  presentationUrl = url.replace('index.meta', presentationPath)
             else:              else:
                 presentationUrl = url + "/" + presentationPath                  presentationUrl = url + "/" + presentationPath
             docinfo = self.getNumPages(docinfo) #im moment einfach auf eins setzen, navigation ueber die thumbs geht natuerlich nicht                      
             docinfo = self.getBibinfoFromTextToolPresentation(presentationUrl, docinfo=docinfo, dom=dom)              docinfo = self.getBibinfoFromTextToolPresentation(presentationUrl, docinfo=docinfo, dom=dom)
           
         docinfo = self.getAuthinfoFromIndexMeta(url, docinfo=docinfo, dom=dom)   # get access info          docinfo = self.getAuthinfoFromIndexMeta(url, docinfo=docinfo, dom=dom)   # get access info
Line 579  class documentViewer(Folder): Line 845  class documentViewer(Folder):
           
     def getDocinfoFromImagePath(self,path,docinfo=None,cut=0):      def getDocinfoFromImagePath(self,path,docinfo=None,cut=0):
         """path ist the path to the images it assumes that the index.meta file is one level higher."""          """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))          logging.debug("documentViewer (getdocinfofromimagepath) path: %s"%(path))
         if docinfo is None:          if docinfo is None:
             docinfo = {}              docinfo = {}
         path=path.replace("/mpiwg/online","")          path=path.replace("/mpiwg/online","")
Line 589  class documentViewer(Folder): Line 855  class documentViewer(Folder):
         pathorig=path          pathorig=path
         for x in range(cut):                 for x in range(cut):       
                 path=getParentDir(path)                  path=getParentDir(path)
         logging.error("PATH:"+path)          logging.debug("documentViewer (getdocinfofromimagepath) PATH:"+path)
         imageUrl=self.digilibBaseUrl+"/servlet/Scaler?fn="+path          imageUrl=self.digilibBaseUrl+"/servlet/Scaler?fn="+path
         docinfo['imageURL'] = imageUrl          docinfo['imageURL'] = imageUrl
                   
         #path ist the path to the images it assumes that the index.meta file is one level higher.          #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.getBibinfoFromIndexMeta(pathorig,docinfo=docinfo,cut=cut+1)
           #docinfo = self.getDownloadfromDocinfoToBibtex(pathorig,docinfo=docinfo,cut=cut+1)
         docinfo = self.getAuthinfoFromIndexMeta(pathorig,docinfo=docinfo,cut=cut+1)          docinfo = self.getAuthinfoFromIndexMeta(pathorig,docinfo=docinfo,cut=cut+1)
         return docinfo          return docinfo
           
           
     def getDocinfo(self, mode, url):      def getDocinfo(self, mode, url):
         """returns docinfo depending on mode"""          """returns docinfo depending on mode"""
         logger("documentViewer (getdocinfo)", logging.INFO,"mode: %s, url: %s"%(mode,url))          logging.debug("documentViewer (getdocinfo) mode: %s, url: %s"%(mode,url))
         # look for cached docinfo in session          # look for cached docinfo in session
         if self.REQUEST.SESSION.has_key('docinfo'):          if self.REQUEST.SESSION.has_key('docinfo'):
             docinfo = self.REQUEST.SESSION['docinfo']              docinfo = self.REQUEST.SESSION['docinfo']
             # check if its still current              # 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') == mode and docinfo.get('url') == url:
                 logger("documentViewer (getdocinfo)", logging.INFO,"docinfo in session: %s"%docinfo)                  logging.debug("documentViewer (getdocinfo) docinfo in session: %s"%docinfo)
                 return docinfo                  return docinfo
         # new docinfo          # new docinfo
         docinfo = {'mode': mode, 'url': url}          docinfo = {'mode': mode, 'url': url}
Line 618  class documentViewer(Folder): Line 885  class documentViewer(Folder):
         elif mode=="filepath":          elif mode=="filepath":
             docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo,cut=1)              docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo,cut=1)
         else:          else:
             logger("documentViewer (getdocinfo)", logging.ERROR,"unknown mode!")              logging.error("documentViewer (getdocinfo) unknown mode: %s!"%mode)
             raise ValueError("Unknown mode %s! Has to be one of 'texttool','imagepath','filepath'."%(mode))              raise ValueError("Unknown mode %s! Has to be one of 'texttool','imagepath','filepath'."%(mode))
                                                   
         logger("documentViewer (getdocinfo)", logging.INFO,"docinfo: %s"%docinfo)          # FIXME: fake texturlpath 
           if not docinfo.has_key('textURLPath'):
               docinfo['textURLPath'] = None
           
           logging.debug("documentViewer (getdocinfo) docinfo: %s"%docinfo)
           #logging.debug("documentViewer (getdocinfo) docinfo: %s"%)
         self.REQUEST.SESSION['docinfo'] = docinfo          self.REQUEST.SESSION['docinfo'] = docinfo
         return docinfo          return docinfo
                   
           
     def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None, viewMode=None, tocMode=None):      def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None, viewMode=None, tocMode=None):
         """returns pageinfo with the given parameters"""          """returns pageinfo with the given parameters"""
         pageinfo = {}          pageinfo = {}
         current = getInt(current)          current = getInt(current)
       
         pageinfo['current'] = current          pageinfo['current'] = current
         rows = int(rows or self.thumbrows)          rows = int(rows or self.thumbrows)
         pageinfo['rows'] = rows          pageinfo['rows'] = rows
Line 647  class documentViewer(Folder): Line 919  class documentViewer(Folder):
             pageinfo['numgroups'] = int(np / grpsize)              pageinfo['numgroups'] = int(np / grpsize)
             if np % grpsize > 0:              if np % grpsize > 0:
                 pageinfo['numgroups'] += 1                  pageinfo['numgroups'] += 1
                   
         pageinfo['viewMode'] = viewMode          pageinfo['viewMode'] = viewMode
         pageinfo['tocMode'] = tocMode          pageinfo['tocMode'] = tocMode
           pageinfo['characterNormalization'] = self.REQUEST.get('characterNormalization','reg')
           #pageinfo['optionToggle'] = self.REQUEST.get('optionToggle','1')
         pageinfo['query'] = self.REQUEST.get('query',' ')          pageinfo['query'] = self.REQUEST.get('query',' ')
         pageinfo['queryType'] = self.REQUEST.get('queryType',' ')          pageinfo['queryType'] = self.REQUEST.get('queryType',' ')
         pageinfo['querySearch'] =self.REQUEST.get('querySearch', 'fulltext')          pageinfo['querySearch'] =self.REQUEST.get('querySearch', 'fulltext')
         pageinfo['tocPageSize'] = self.REQUEST.get('tocPageSize', '30')          pageinfo['textPN'] = self.REQUEST.get('textPN','1')
         pageinfo['queryPageSize'] =self.REQUEST.get('queryPageSize', '20')          pageinfo['highlightQuery'] = self.REQUEST.get('highlightQuery','')
         pageinfo['tocPN'] = self.REQUEST.get('tocPN', '1')  
         pageinfo['searchPN'] =self.REQUEST.get('searchPN','1')  
         pageinfo['sn'] =self.REQUEST.get('sn','1')  
   
         return pageinfo          pageinfo ['highlightElementPos'] = self.REQUEST.get('highlightElementPos','')
           pageinfo ['highlightElement'] = self.REQUEST.get('highlightElement','')
                                   
     def getSearch(self, pn=1, pageinfo=None,  docinfo=None, query=None, queryType=None):          pageinfo ['xpointer'] = self.REQUEST.get('xpointer','')
         """get search list"""  
         docpath = docinfo['textURLPath']   
         pagesize = pageinfo['queryPageSize']  
         pn = pageinfo['searchPN']  
         sn = pageinfo['sn']  
         query =pageinfo['query']  
         queryType =pageinfo['queryType']  
         viewMode=  pageinfo['viewMode']  
         tocMode = pageinfo['tocMode']  
         tocPN = pageinfo['tocPN']  
         pagexml=self.template.fulltextclient.eval("/mpdl/interface/doc-query.xql","document=%s&mode=%s&queryType=%s&query=%s&queryResultPageSize=%s&queryResultPN=%s&sn=%s"%(docpath, 'text', queryType, query, pagesize, pn, sn) ,outputUnicode=False)             
         pagedom = Parse(pagexml)  
         #pagedivs = pagedom.xpath("//div[@class='queryResultPage']")  
         selfurl = self.absolute_url()  
         page = pagexml.replace('page-fragment.xql?document=/echo/la/Benedetti_1585.xml','%s?url=/mpiwg/online/permanent/library/163127KK&viewMode=%s&tocMode=%s&tocPN=%s&query=%s&queryType=%s'%(selfurl, viewMode, tocMode, tocPN, query, queryType))  
         text =page.replace('mode=text','mode=texttool')  
         return text  
         #if len(pagedivs) > 0:  
         #    pagenode = pagedom[0]  
         #    return serializeNode(pagenode)  
         #else:  
         #    return "xaxa"  
   
     def getNumPages(self,docinfo=None):  
         """get list of pages from fulltext and put in docinfo"""  
         xquery = '//pb'  
         text = self.template.fulltextclient.eval("/mpdl/interface/xquery.xql", "document=%s&xquery=%s"%(docinfo['textURLPath'],xquery))  
         # TODO: better processing of the page list. do we need the info somewhere else also?  
         docinfo['numPages'] = text.count("<pb ")  
         return docinfo  
                 
     def getTextPage(self, mode="text", pn=1, docinfo=None, pageinfo=None,):          pageinfo['tocPageSize'] = self.REQUEST.get('tocPageSize', '30')
         """returns single page from fulltext"""          pageinfo['queryPageSize'] =self.REQUEST.get('queryPageSize', '10')
         docpath = docinfo['textURLPath']          pageinfo['tocPN'] = self.REQUEST.get('tocPN', '1')     
         if mode == "text_dict":          toc = int (pageinfo['tocPN'])
             textmode = "textPollux"          pageinfo['textPages'] =int (toc)
         else:  
             textmode = mode  
               
         #selfurl = self.absolute_url()    
         #viewMode=  pageinfo['viewMode']  
         #tocMode = pageinfo['tocMode']  
         #tocPN = pageinfo['tocPN']  
     
         pagexml=self.template.fulltextclient.eval("/mpdl/interface/page-fragment.xql", "document=%s&mode=%s&pn=%s"%(docpath,textmode,pn), outputUnicode=False)  
         #######  
         #page = pagexml.replace('page-fragment.xql?document=/echo/la/Benedetti_1585.xml','%s?url=/mpiwg/online/permanent/library/163127KK&viewMode=%s&tocMode=%s&tocPN=%s'%(selfurl, viewMode, tocMode, tocPN))  
         #text =page.replace('mode=text','mode=texttool')  
         #######  
         # post-processing downloaded xml  
         pagedom = Parse(pagexml)  
         # plain text mode  
         if mode == "text":  
             # first div contains text  
             pagedivs = pagedom.xpath("/div")  
             #queryResultPage  
             if len(pagedivs) > 0:  
                 pagenode = pagedivs[0]  
                 return serializeNode(pagenode)  
   
         # text-with-links mode  
         if mode == "text_dict":  
             # first div contains text  
             pagedivs = pagedom.xpath("/div")  
             if len(pagedivs) > 0:  
                 pagenode = pagedivs[0]  
                 # check all a-tags  
                 links = pagenode.xpath("//a")  
                 for l in links:  
                     hrefNode = l.getAttributeNodeNS(None, u"href")  
                     if hrefNode:  
                         # is link with href  
                         href = hrefNode.nodeValue  
                         if href.startswith('lt/lex.xql'):  
                             # is pollux link  
                             selfurl = self.absolute_url()  
                             # change href  
                             hrefNode.nodeValue = href.replace('lt/lex.xql','%s/template/head_main_voc'%selfurl)  
                             # add target  
                             l.setAttributeNS(None, 'target', '_blank')  
                               
                         if href.startswith('lt/lemma.xql'):      
                             selfurl = self.absolute_url()  
                             hrefNode.nodeValue = href.replace('lt/lemma.xql','%s/template/head_main_lemma'%selfurl)  
                             l.setAttributeNS(None, 'target', '_blank')  
                 return serializeNode(pagenode)  
           
         return "no text here"  
   
     def getTranslate(self, query=None, language=None):  
         """translate into another languages"""  
         pagexml=self.template.fulltextclient.eval("/mpdl/interface/lt/lex.xql","query=%s&language=%s"%(query,language),outputUnicode=False)  
         return pagexml  
       
     def getLemma(self):  
         """lemma"""  
         pagexml=self.template.fulltextclient.eval("/mpdl/interface/lt/lemma.xql","query=%s&language=%s"%(query,language),outputUnicode=False)  
         return pagexml  
   
     def getToc(self, mode="text", docinfo=None):  
         """loads table of contents and stores in docinfo"""  
         logging.debug("documentViewer (gettoc) mode: %s"%(mode))  
         if 'tocSize_%s'%mode in docinfo:  
             # cached toc  
             return docinfo  
           
         docpath = docinfo['textURLPath']  
         # we need to set a result set size  
         pagesize = 1000  
         pn = 1  
         if mode == "text":  
             queryType = "toc"  
         else:  
             queryType = mode  
         # number of entries in toc  
         tocSize = 0  
         tocDiv = None  
         pagexml=self.template.fulltextclient.eval("/mpdl/interface/doc-query.xql", "document=%s&queryType=%s&queryResultPageSize=%s&queryResultPN=%s"%(docpath,queryType,pagesize,pn), outputUnicode=False)  
         # post-processing downloaded xml  
         pagedom = Parse(pagexml)  
         # get number of entries  
         numdivs = pagedom.xpath("//div[@class='queryResultHits']")  
         if len(numdivs) > 0:  
             tocSize = int(getTextFromNode(numdivs[0]))  
             # div contains text  
             #pagedivs = pagedom.xpath("//div[@class='queryResultPage']")  
             #if len(pagedivs) > 0:  
             #    tocDiv = pagedivs[0]  
   
         docinfo['tocSize_%s'%mode] = tocSize  
         #docinfo['tocDiv_%s'%mode] = tocDiv  
         return docinfo  
       
     def getTocPage(self, mode="text", pn=1, pageinfo=None, docinfo=None):  
         """returns single page from the table of contents"""  
         # TODO: this should use the cached TOC  
         if mode == "text":  
             queryType = "toc"  
         else:  
             queryType = mode  
         docpath = docinfo['textURLPath']  
         pagesize = pageinfo['tocPageSize']  
         pn = pageinfo['tocPN']  
           
         selfurl = self.absolute_url()    
         viewMode=  pageinfo['viewMode']  
         tocMode = pageinfo['tocMode']  
         tocPN = pageinfo['tocPN']  
       
         pagexml=self.template.fulltextclient.eval("/mpdl/interface/doc-query.xql", "document=%s&queryType=%s&queryResultPageSize=%s&queryResultPN=%s"%(docpath,queryType, pagesize, pn), outputUnicode=False)  
         page = pagexml.replace('page-fragment.xql?document=/echo/la/Benedetti_1585.xml','%s?url=/mpiwg/online/permanent/library/163127KK&viewMode=%s&tocMode=%s&tocPN=%s'%(selfurl, viewMode, tocMode, tocPN))  
         text = page.replace('mode=image','mode=texttool')  
         return text  
         # post-processing downloaded xml  
         #pagedom = Parse(text)  
         # div contains text  
         #pagedivs = pagedom.xpath("//div[@class='queryResultPage']")  
         #if len(pagedivs) > 0:  
         #    pagenode = pagedivs[0]  
         #    return serializeNode(pagenode)  
         #else:  
         #    return "No 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','')
           pageinfo['s'] =self.REQUEST.get('s','')
           return pageinfo
           
     def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None):      def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None):
         """init document viewer"""          """init document viewer"""
Line 836  class documentViewer(Folder): Line 964  class documentViewer(Folder):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
           
       
           
 def manage_AddDocumentViewerForm(self):  def manage_AddDocumentViewerForm(self):
     """add the viewer form"""      """add the viewer form"""
     pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)      pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
Line 851  def manage_AddDocumentViewer(self,id,ima Line 977  def manage_AddDocumentViewer(self,id,ima
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
 ##  
 ## DocumentViewerTemplate class  ## DocumentViewerTemplate class
 ##  
 class DocumentViewerTemplate(ZopePageTemplate):  class DocumentViewerTemplate(ZopePageTemplate):
     """Template for document viewer"""      """Template for document viewer"""
     meta_type="DocumentViewer Template"      meta_type="DocumentViewer Template"
Removed from v.1.46  
changed lines
  Added in v.1.178

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