source: documentViewer/documentViewer.py @ 103:daedc22e4e76

Last change on this file since 103:daedc22e4e76 was 103:daedc22e4e76, checked in by abukhman, 14 years ago

last update
File size: 43.4 KB
Line 
1
2from OFS.Folder import Folder
3from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
4from Products.PageTemplates.PageTemplateFile import PageTemplateFile
5from Products.PythonScripts.standard import url_quote
6from AccessControl import ClassSecurityInfo
7from AccessControl import getSecurityManager
8from Globals import package_home
9
10from Ft.Xml.Domlette import NonvalidatingReader
11from Ft.Xml.Domlette import PrettyPrint, Print
12from Ft.Xml import EMPTY_NAMESPACE, Parse
13
14from xml.dom.minidom import parse, parseString
15
16
17
18import Ft.Xml.XPath
19import cStringIO
20import xmlrpclib
21import os.path
22import sys
23import cgi
24import urllib
25import logging
26import math
27
28import urlparse 
29from types import *
30
31def logger(txt,method,txt2):
32    """logging"""
33    logging.info(txt+ txt2)
34   
35   
36def getInt(number, default=0):
37    """returns always an int (0 in case of problems)"""
38    try:
39        return int(number)
40    except:
41        return int(default)
42
43def getTextFromNode(nodename):
44    """get the cdata content of a node"""
45    if nodename is None:
46        return ""
47    nodelist=nodename.childNodes
48    rc = ""
49    for node in nodelist:
50        if node.nodeType == node.TEXT_NODE:
51           rc = rc + node.data
52    return rc
53
54def serializeNode(node, encoding='utf-8'):
55    """returns a string containing node as XML"""
56    buf = cStringIO.StringIO()
57    Print(node, stream=buf, encoding=encoding)
58    s = buf.getvalue()
59    buf.close()
60    return s
61
62       
63def getParentDir(path):
64    """returns pathname shortened by one"""
65    return '/'.join(path.split('/')[0:-1])
66       
67
68import socket
69
70def urlopen(url,timeout=2):
71        """urlopen mit timeout"""
72        socket.setdefaulttimeout(timeout)
73        ret=urllib.urlopen(url)
74        socket.setdefaulttimeout(5)
75        return ret
76
77
78##
79## documentViewer class
80##
81class documentViewer(Folder):
82    """document viewer"""
83    #textViewerUrl="http://127.0.0.1:8080/HFQP/testXSLT/getPage?"
84   
85    meta_type="Document viewer"
86   
87    security=ClassSecurityInfo()
88    manage_options=Folder.manage_options+(
89        {'label':'main config','action':'changeDocumentViewerForm'},
90        )
91
92    # templates and forms
93    viewer_main = PageTemplateFile('zpt/viewer_main', globals())
94    toc_thumbs = PageTemplateFile('zpt/toc_thumbs', globals())
95    toc_text = PageTemplateFile('zpt/toc_text', globals())
96    toc_figures = PageTemplateFile('zpt/toc_figures', globals())
97    page_main_images = PageTemplateFile('zpt/page_main_images', globals())
98    page_main_text = PageTemplateFile('zpt/page_main_text', globals())
99    page_main_text_dict = PageTemplateFile('zpt/page_main_text_dict', globals())
100    page_main_xml = PageTemplateFile('zpt/page_main_xml', globals())
101    head_main = PageTemplateFile('zpt/head_main', globals())
102    docuviewer_css = PageTemplateFile('css/docuviewer.css', globals())
103    info_xml = PageTemplateFile('zpt/info_xml', globals())
104
105    thumbs_main_rss = PageTemplateFile('zpt/thumbs_main_rss', globals())
106    security.declareProtected('View management screens','changeDocumentViewerForm')   
107    changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
108
109   
110    def __init__(self,id,imageScalerUrl=None,textServerName=None,title="",digilibBaseUrl=None,thumbcols=2,thumbrows=5,authgroups="mpiwg"):
111        """init document viewer"""
112        self.id=id
113        self.title=title
114        self.thumbcols = thumbcols
115        self.thumbrows = thumbrows
116        # authgroups is list of authorized groups (delimited by ,)
117        self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
118        # create template folder so we can always use template.something
119       
120        templateFolder = Folder('template')
121        #self['template'] = templateFolder # Zope-2.12 style
122        self._setObject('template',templateFolder) # old style
123        try:
124            from Products.XMLRpcTools.XMLRpcTools import XMLRpcServerProxy
125            xmlRpcClient = XMLRpcServerProxy(id='fulltextclient', serverUrl=textServerName, use_xmlrpc=False)
126            #templateFolder['fulltextclient'] = xmlRpcClient
127            templateFolder._setObject('fulltextclient',xmlRpcClient)
128        except Exception, e:
129            logging.error("Unable to create XMLRpcTools for fulltextclient: "+str(e))
130        try:
131            from Products.zogiLib.zogiLib import zogiLib
132            zogilib = zogiLib(id="zogilib", title="zogilib for docuviewer", dlServerURL=imageScalerUrl, layout="book")
133            #templateFolder['zogilib'] = zogilib
134            templateFolder._setObject('zogilib',zogilib)
135        except Exception, e:
136            logging.error("Unable to create zogiLib for zogilib: "+str(e))
137       
138
139    security.declareProtected('View','thumbs_rss')
140    def thumbs_rss(self,mode,url,viewMode="auto",start=None,pn=1):
141        '''
142        view it
143        @param mode: defines how to access the document behind url
144        @param url: url which contains display information
145        @param viewMode: if images display images, if text display text, default is images (text,images or auto)
146       
147        '''
148        logging.debug("HHHHHHHHHHHHHH:load the rss")
149        logger("documentViewer (index)", logging.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
150       
151        if not hasattr(self, 'template'):
152            # create template folder if it doesn't exist
153            self.manage_addFolder('template')
154           
155        if not self.digilibBaseUrl:
156            self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
157           
158        docinfo = self.getDocinfo(mode=mode,url=url)
159        pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)
160        pt = getattr(self.template, 'thumbs_main_rss')
161       
162        if viewMode=="auto": # automodus gewaehlt
163            if docinfo.get("textURL",'') and self.textViewerUrl: #texturl gesetzt und textViewer konfiguriert
164                viewMode="text"
165            else:
166                viewMode="images"
167               
168        return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode)
169 
170    security.declareProtected('View','index_html')
171    def index_html(self,url,mode="texttool",viewMode="auto",tocMode="thumbs",start=None,pn=1,mk=None, query=None, querySearch=None):
172        '''
173        view it
174        @param mode: defines how to access the document behind url
175        @param url: url which contains display information
176        @param viewMode: if images display images, if text display text, default is auto (text,images or auto)
177        @param tocMode: type of 'table of contents' for navigation (thumbs, text, figures, none)
178        @param querySearch: type of different search modes (fulltext, fulltextMorph, xpath, xquery, ftIndex, ftIndexMorph, fulltextMorphLemma)
179        '''
180       
181        logging.debug("documentViewer (index) mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
182       
183        if not hasattr(self, 'template'):
184            # this won't work
185            logging.error("template folder missing!")
186            return "ERROR: template folder missing!"
187           
188        if not getattr(self, 'digilibBaseUrl', None):
189            self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
190           
191        docinfo = self.getDocinfo(mode=mode,url=url)
192       
193       
194        if tocMode != "thumbs":
195            # get table of contents
196            docinfo = self.getToc(mode=tocMode, docinfo=docinfo)
197           
198        pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo,viewMode=viewMode,tocMode=tocMode)
199       
200        if viewMode=="auto": # automodus gewaehlt
201            if docinfo.get("textURL",''): #texturl gesetzt und textViewer konfiguriert
202                viewMode="text"
203            else:
204                viewMode="images"
205               
206        pt = getattr(self.template, 'viewer_main')               
207        return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode,mk=self.generateMarks(mk))
208 
209    def generateMarks(self,mk):
210        ret=""
211        if mk is None:
212            return ""
213        if type(mk) is not ListType:
214                mk=[mk]
215        for m in mk:
216            ret+="mk=%s"%m
217        return ret
218
219
220    def findDigilibUrl(self):
221        """try to get the digilib URL from zogilib"""
222        url = self.template.zogilib.getDLBaseUrl()
223        return url
224   
225    def getStyle(self, idx, selected, style=""):
226        """returns a string with the given style and append 'sel' if path == selected."""
227        #logger("documentViewer (getstyle)", logging.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
228        if idx == selected:
229            return style + 'sel'
230        else:
231            return style
232   
233    def getLink(self,param=None,val=None):
234        """link to documentviewer with parameter param set to val"""
235        params=self.REQUEST.form.copy()
236        if param is not None:
237            if val is None:
238                if params.has_key(param):
239                    del params[param]
240            else:
241                params[param] = str(val)
242               
243        if params.get("mode", None) == "filepath": #wenn beim erst Aufruf filepath gesetzt wurde aendere das nun zu imagepath
244                params["mode"] = "imagepath"
245                params["url"] = getParentDir(params["url"])
246               
247        # quote values and assemble into query string
248        ps = "&".join(["%s=%s"%(k,urllib.quote(v)) for (k, v) in params.items()])
249        url=self.REQUEST['URL1']+"?"+ps
250        return url
251
252    def getLinkAmp(self,param=None,val=None):
253        """link to documentviewer with parameter param set to val"""
254        params=self.REQUEST.form.copy()
255        if param is not None:
256            if val is None:
257                if params.has_key(param):
258                    del params[param]
259            else:
260                params[param] = str(val)
261               
262        # quote values and assemble into query string
263        logging.info("XYXXXXX: %s"%repr(params.items()))
264        ps = "&".join(["%s=%s"%(k,urllib.quote(v)) for (k, v) in params.items()])
265        url=self.REQUEST['URL1']+"?"+ps
266        return url
267   
268    def getInfo_xml(self,url,mode):
269        """returns info about the document as XML"""
270
271        if not self.digilibBaseUrl:
272            self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
273       
274        docinfo = self.getDocinfo(mode=mode,url=url)
275        pt = getattr(self.template, 'info_xml')
276        return pt(docinfo=docinfo)
277
278   
279    def isAccessible(self, docinfo):
280        """returns if access to the resource is granted"""
281        access = docinfo.get('accessType', None)
282        logger("documentViewer (accessOK)", logging.INFO, "access type %s"%access)
283        if access is not None and access == 'free':
284            logger("documentViewer (accessOK)", logging.INFO, "access is free")
285            return True
286        elif access is None or access in self.authgroups:
287            # only local access -- only logged in users
288            user = getSecurityManager().getUser()
289            if user is not None:
290                #print "user: ", user
291                return (user.getUserName() != "Anonymous User")
292            else:
293                return False
294       
295        logger("documentViewer (accessOK)", logging.INFO, "unknown access type %s"%access)
296        return False
297   
298               
299    def getDirinfoFromDigilib(self,path,docinfo=None,cut=0):
300        """gibt param von dlInfo aus"""
301        num_retries = 3
302        if docinfo is None:
303            docinfo = {}
304       
305        for x in range(cut):
306               
307                path=getParentDir(path)
308       
309        infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path
310   
311        logger("documentViewer (getparamfromdigilib)", logging.INFO, "dirInfo from %s"%(infoUrl))
312       
313        for cnt in range(num_retries):
314            try:
315                # dom = NonvalidatingReader.parseUri(imageUrl)
316                txt=urllib.urlopen(infoUrl).read()
317                dom = Parse(txt)
318                break
319            except:
320                logger("documentViewer (getdirinfofromdigilib)", logging.ERROR, "error reading %s (try %d)"%(infoUrl,cnt))
321        else:
322            raise IOError("Unable to get dir-info from %s"%(infoUrl))
323       
324        sizes=dom.xpath("//dir/size")
325        logger("documentViewer (getparamfromdigilib)", logging.INFO, "dirInfo:size"%sizes)
326       
327        if sizes:
328            docinfo['numPages'] = int(getTextFromNode(sizes[0]))
329        else:
330            docinfo['numPages'] = 0
331           
332        # TODO: produce and keep list of image names and numbers
333                       
334        return docinfo
335   
336           
337    def getIndexMeta(self, url):
338        """returns dom of index.meta document at url"""
339        num_retries = 3
340        dom = None
341        metaUrl = None
342        if url.startswith("http://"):
343            # real URL
344            metaUrl = url
345        else:
346            # online path
347            server=self.digilibBaseUrl+"/servlet/Texter?fn="
348            metaUrl=server+url.replace("/mpiwg/online","")
349            if not metaUrl.endswith("index.meta"):
350                metaUrl += "/index.meta"
351        logging.debug("METAURL: %s"%metaUrl)
352        for cnt in range(num_retries):
353            try:
354                # patch dirk encoding fehler treten dann nicht mehr auf
355                # dom = NonvalidatingReader.parseUri(metaUrl)
356                txt=urllib.urlopen(metaUrl).read()
357                dom = Parse(txt)
358                break
359            except:
360                logger("ERROR documentViewer (getIndexMeta)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
361               
362        if dom is None:
363            raise IOError("Unable to read index meta from %s"%(url))
364                 
365        return dom
366   
367    def getPresentationInfoXML(self, url):
368        """returns dom of info.xml document at url"""
369        num_retries = 3
370        dom = None
371        metaUrl = None
372        if url.startswith("http://"):
373            # real URL
374            metaUrl = url
375        else:
376            # online path
377            server=self.digilibBaseUrl+"/servlet/Texter?fn="
378            metaUrl=server+url.replace("/mpiwg/online","")
379       
380        for cnt in range(num_retries):
381            try:
382                # patch dirk encoding fehler treten dann nicht mehr auf
383                # dom = NonvalidatingReader.parseUri(metaUrl)
384                txt=urllib.urlopen(metaUrl).read()
385                dom = Parse(txt)
386                break
387            except:
388                logger("ERROR documentViewer (getPresentationInfoXML)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
389               
390        if dom is None:
391            raise IOError("Unable to read infoXMLfrom %s"%(url))
392                 
393        return dom
394                       
395       
396    def getAuthinfoFromIndexMeta(self,path,docinfo=None,dom=None,cut=0):
397        """gets authorization info from the index.meta file at path or given by dom"""
398        logger("documentViewer (getauthinfofromindexmeta)", logging.INFO,"path: %s"%(path))
399       
400        access = None
401       
402        if docinfo is None:
403            docinfo = {}
404           
405        if dom is None:
406            for x in range(cut):
407                path=getParentDir(path)
408            dom = self.getIndexMeta(path)
409       
410        acctype = dom.xpath("//access-conditions/access/@type")
411        if acctype and (len(acctype)>0):
412            access=acctype[0].value
413            if access in ['group', 'institution']:
414                access = getTextFromNode(dom.xpath("//access-conditions/access/name")[0]).lower()
415           
416        docinfo['accessType'] = access
417        return docinfo
418   
419       
420    def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None,cut=0):
421        """gets bibliographical info from the index.meta file at path or given by dom"""
422        logging.debug("documentViewer (getbibinfofromindexmeta) path: %s"%(path))
423       
424        if docinfo is None:
425            docinfo = {}
426       
427        if dom is None:
428            for x in range(cut):
429                path=getParentDir(path)
430            dom = self.getIndexMeta(path)
431       
432        logging.debug("documentViewer (getbibinfofromindexmeta cutted) path: %s"%(path))
433        # put in all raw bib fields as dict "bib"
434        bib = dom.xpath("//bib/*")
435        if bib and len(bib)>0:
436            bibinfo = {}
437            for e in bib:
438                bibinfo[e.localName] = getTextFromNode(e)
439            docinfo['bib'] = bibinfo
440       
441        # extract some fields (author, title, year) according to their mapping
442        metaData=self.metadata.main.meta.bib
443        bibtype=dom.xpath("//bib/@type")
444        if bibtype and (len(bibtype)>0):
445            bibtype=bibtype[0].value
446        else:
447            bibtype="generic"
448           
449        bibtype=bibtype.replace("-"," ") # wrong typesiin index meta "-" instead of " " (not wrong! ROC)
450        docinfo['bib_type'] = bibtype
451        bibmap=metaData.generateMappingForType(bibtype)
452        # if there is no mapping bibmap is empty (mapping sometimes has empty fields)
453        if len(bibmap) > 0 and len(bibmap['author'][0]) > 0:
454            try:
455                docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['author'][0])[0])
456            except: pass
457            try:
458                docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['title'][0])[0])
459            except: pass
460            try:
461                docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['year'][0])[0])
462            except: pass
463            logging.debug("documentViewer (getbibinfofromindexmeta) using mapping for %s"%bibtype)
464            try:
465                docinfo['lang']=getTextFromNode(dom.xpath("//bib/lang")[0])
466            except:
467                docinfo['lang']=''
468
469        return docinfo
470   
471   
472    def getDocinfoFromTextTool(self, url, dom=None, docinfo=None):
473        """parse texttool tag in index meta"""
474        logger("documentViewer (getdocinfofromtexttool)", logging.INFO, "url: %s" % (url))
475        if docinfo is None:
476           docinfo = {}
477        if docinfo.get('lang', None) is None:
478            docinfo['lang'] = '' # default keine Sprache gesetzt
479        if dom is None:
480            dom = self.getIndexMeta(url)
481       
482        archivePath = None
483        archiveName = None
484   
485        archiveNames = dom.xpath("//resource/name")
486        if archiveNames and (len(archiveNames) > 0):
487            archiveName = getTextFromNode(archiveNames[0])
488        else:
489            logger("documentViewer (getdocinfofromtexttool)", logging.WARNING, "resource/name missing in: %s" % (url))
490       
491        archivePaths = dom.xpath("//resource/archive-path")
492        if archivePaths and (len(archivePaths) > 0):
493            archivePath = getTextFromNode(archivePaths[0])
494            # clean up archive path
495            if archivePath[0] != '/':
496                archivePath = '/' + archivePath
497            if archiveName and (not archivePath.endswith(archiveName)):
498                archivePath += "/" + archiveName
499        else:
500            # try to get archive-path from url
501            logger("documentViewer (getdocinfofromtexttool)", logging.WARNING, "resource/archive-path missing in: %s" % (url))
502            if (not url.startswith('http')):
503                archivePath = url.replace('index.meta', '')
504               
505        if archivePath is None:
506            # we balk without archive-path
507            raise IOError("Missing archive-path (for text-tool) in %s" % (url))
508       
509        imageDirs = dom.xpath("//texttool/image")
510        if imageDirs and (len(imageDirs) > 0):
511            imageDir = getTextFromNode(imageDirs[0])
512           
513        else:
514            # we balk with no image tag / not necessary anymore because textmode is now standard
515            #raise IOError("No text-tool info in %s"%(url))
516            imageDir = ""
517            #xquery="//pb" 
518            docinfo['imagePath'] = "" # keine Bilder
519            docinfo['imageURL'] = ""
520           
521        if imageDir and archivePath:
522            #print "image: ", imageDir, " archivepath: ", archivePath
523            imageDir = os.path.join(archivePath, imageDir)
524            imageDir = imageDir.replace("/mpiwg/online", '')
525            docinfo = self.getDirinfoFromDigilib(imageDir, docinfo=docinfo)
526            docinfo['imagePath'] = imageDir
527           
528            docinfo['imageURL'] = self.digilibBaseUrl + "/servlet/Scaler?fn=" + imageDir
529           
530        viewerUrls = dom.xpath("//texttool/digiliburlprefix")
531        if viewerUrls and (len(viewerUrls) > 0):
532            viewerUrl = getTextFromNode(viewerUrls[0])
533            docinfo['viewerURL'] = viewerUrl
534                   
535        textUrls = dom.xpath("//texttool/text")
536        if textUrls and (len(textUrls) > 0):
537            textUrl = getTextFromNode(textUrls[0])
538            if urlparse.urlparse(textUrl)[0] == "": #keine url
539                textUrl = os.path.join(archivePath, textUrl) 
540            # fix URLs starting with /mpiwg/online
541            if textUrl.startswith("/mpiwg/online"):
542                textUrl = textUrl.replace("/mpiwg/online", '', 1)
543           
544            docinfo['textURL'] = textUrl
545   
546        textUrls = dom.xpath("//texttool/text-url-path")
547        if textUrls and (len(textUrls) > 0):
548            textUrl = getTextFromNode(textUrls[0])
549            docinfo['textURLPath'] = textUrl
550            if not docinfo['imagePath']:
551                # text-only, no page images
552                docinfo = self.getNumPages(docinfo) #im moment einfach auf eins setzen, navigation ueber die thumbs geht natuerlich nicht   
553         
554        presentationUrls = dom.xpath("//texttool/presentation")
555        docinfo = self.getBibinfoFromIndexMeta(url, docinfo=docinfo, dom=dom)   # get info von bib tag
556       
557        if presentationUrls and (len(presentationUrls) > 0): # ueberschreibe diese durch presentation informationen
558             # presentation url ergiebt sich ersetzen von index.meta in der url der fuer die Metadaten
559             # durch den relativen Pfad auf die presentation infos
560            presentationPath = getTextFromNode(presentationUrls[0])
561            if url.endswith("index.meta"): 
562                presentationUrl = url.replace('index.meta', presentationPath)
563            else:
564                presentationUrl = url + "/" + presentationPath
565               
566            docinfo = self.getBibinfoFromTextToolPresentation(presentationUrl, docinfo=docinfo, dom=dom)
567   
568        docinfo = self.getAuthinfoFromIndexMeta(url, docinfo=docinfo, dom=dom)   # get access info
569       
570        return docinfo
571   
572   
573    def getBibinfoFromTextToolPresentation(self,url,docinfo=None,dom=None):
574        """gets the bibliographical information from the preseantion entry in texttools
575        """
576        dom=self.getPresentationInfoXML(url)
577        try:
578            docinfo['author']=getTextFromNode(dom.xpath("//author")[0])
579        except:
580            pass
581        try:
582            docinfo['title']=getTextFromNode(dom.xpath("//title")[0])
583        except:
584            pass
585        try:
586            docinfo['year']=getTextFromNode(dom.xpath("//date")[0])
587        except:
588            pass
589        return docinfo
590   
591    def getDocinfoFromImagePath(self,path,docinfo=None,cut=0):
592        """path ist the path to the images it assumes that the index.meta file is one level higher."""
593        logger("documentViewer (getdocinfofromimagepath)", logging.INFO,"path: %s"%(path))
594        if docinfo is None:
595            docinfo = {}
596        path=path.replace("/mpiwg/online","")
597        docinfo['imagePath'] = path
598        docinfo=self.getDirinfoFromDigilib(path,docinfo=docinfo,cut=cut)
599       
600        pathorig=path
601        for x in range(cut):       
602                path=getParentDir(path)
603        logging.error("PATH:"+path)
604        imageUrl=self.digilibBaseUrl+"/servlet/Scaler?fn="+path
605        docinfo['imageURL'] = imageUrl
606       
607        #path ist the path to the images it assumes that the index.meta file is one level higher.
608        docinfo = self.getBibinfoFromIndexMeta(pathorig,docinfo=docinfo,cut=cut+1)
609        docinfo = self.getAuthinfoFromIndexMeta(pathorig,docinfo=docinfo,cut=cut+1)
610        return docinfo
611   
612   
613    def getDocinfo(self, mode, url):
614        """returns docinfo depending on mode"""
615        logger("documentViewer (getdocinfo)", logging.INFO,"mode: %s, url: %s"%(mode,url))
616        # look for cached docinfo in session
617        if self.REQUEST.SESSION.has_key('docinfo'):
618            docinfo = self.REQUEST.SESSION['docinfo']
619            # check if its still current
620            if docinfo is not None and docinfo.get('mode') == mode and docinfo.get('url') == url:
621                logger("documentViewer (getdocinfo)", logging.INFO,"docinfo in session: %s"%docinfo)
622                return docinfo
623        # new docinfo
624        docinfo = {'mode': mode, 'url': url}
625        if mode=="texttool": #index.meta with texttool information
626            docinfo = self.getDocinfoFromTextTool(url, docinfo=docinfo)
627        elif mode=="imagepath":
628            docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo)
629        elif mode=="filepath":
630            docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo,cut=1)
631        else:
632            logger("documentViewer (getdocinfo)", logging.ERROR,"unknown mode!")
633            raise ValueError("Unknown mode %s! Has to be one of 'texttool','imagepath','filepath'."%(mode))
634                       
635        logger("documentViewer (getdocinfo)", logging.INFO,"docinfo: %s"%docinfo)
636        self.REQUEST.SESSION['docinfo'] = docinfo
637        return docinfo
638       
639       
640    def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None, viewMode=None, tocMode=None):
641        """returns pageinfo with the given parameters"""
642        pageinfo = {}
643        current = getInt(current)
644        pageinfo['current'] = current
645        rows = int(rows or self.thumbrows)
646        pageinfo['rows'] = rows
647        cols = int(cols or self.thumbcols)
648        pageinfo['cols'] = cols
649        grpsize = cols * rows
650        pageinfo['groupsize'] = grpsize
651        start = getInt(start, default=(math.ceil(float(current)/float(grpsize))*grpsize-(grpsize-1)))
652        # int(current / grpsize) * grpsize +1))
653        pageinfo['start'] = start
654        pageinfo['end'] = start + grpsize
655        if (docinfo is not None) and ('numPages' in docinfo):
656            np = int(docinfo['numPages'])
657            pageinfo['end'] = min(pageinfo['end'], np)
658            pageinfo['numgroups'] = int(np / grpsize)
659            if np % grpsize > 0:
660                pageinfo['numgroups'] += 1
661       
662         
663        pageinfo['viewMode'] = viewMode
664        pageinfo['tocMode'] = tocMode
665        pageinfo['query'] = self.REQUEST.get('query',' ')
666        pageinfo['queryType'] = self.REQUEST.get('queryType',' ')
667        pageinfo['querySearch'] =self.REQUEST.get('querySearch', 'fulltext')
668       
669        pageinfo['textPN'] = self.REQUEST.get('textPN','1')
670       
671        pageinfo['tocPageSize'] = self.REQUEST.get('tocPageSize', '30')
672        pageinfo['queryPageSize'] =self.REQUEST.get('queryPageSize', '20')
673        pageinfo['tocPN'] = self.REQUEST.get('tocPN', '1')
674        toc = int (pageinfo['tocPN'])
675        pageinfo['textPages'] =int (toc)
676       
677        if 'tocSize_%s'%tocMode in docinfo:
678            tocSize = int(docinfo['tocSize_%s'%tocMode])
679            tocPageSize = int(pageinfo['tocPageSize'])
680            # cached toc
681           
682            if tocSize%tocPageSize>0:
683                tocPages=tocSize/tocPageSize+1
684            else:
685                tocPages=tocSize/tocPageSize
686            pageinfo['tocPN'] = min (tocPages,toc)
687                     
688        pageinfo['searchPN'] =self.REQUEST.get('searchPN','1')
689        pageinfo['sn'] =self.REQUEST.get('sn','1')
690
691        return pageinfo
692               
693    def getSearch(self, pn=1, pageinfo=None,  docinfo=None, query=None, queryType=None):
694        """get search list"""
695        docpath = docinfo['textURLPath'] 
696        url = docinfo['url']
697        logging.debug("documentViewer (gettoc) docpath: %s"%(docpath))
698        logging.debug("documentViewer (gettoc) url: %s"%(url))
699        pagesize = pageinfo['queryPageSize']
700        pn = pageinfo['searchPN']
701        sn = pageinfo['sn']
702        query =pageinfo['query']
703        queryType =pageinfo['queryType']
704        viewMode=  pageinfo['viewMode']
705        tocMode = pageinfo['tocMode']
706        tocPN = pageinfo['tocPN']
707        selfurl = self.absolute_url()
708        logging.debug("documentViewer (gettoc) /mpdl/interface/doc-query.xql?document=%s&mode=%s&queryType=%s&query=%s&queryResultPageSize=%s&queryResultPN=%s&sn=%s&viewMode=%s"%(docpath, 'text', queryType, query, pagesize, pn, sn, viewMode))
709        page=self.template.fulltextclient.eval("/mpdl/interface/doc-query.xql","document=%s&mode=%s&queryType=%s&query=%s&queryResultPageSize=%s&queryResultPN=%s&sn=%s&viewMode=%s"%(docpath, 'text', queryType, query, pagesize, pn, sn, viewMode) ,outputUnicode=False)               
710        pagexml = page.replace('?document=%s'%str(docpath),'?url=%s'%url)
711        pagedom = Parse(pagexml)
712        if (queryType=="fulltext")or(queryType=="xpath")or(queryType=="xquery")or(queryType=="fulltextMorphLemma"):   
713            pagedivs = pagedom.xpath("//div[@class='queryResultPage']")
714            if len(pagedivs)>0:
715                pagenode=pagedivs[0]
716                links=pagenode.xpath("//a")
717                for l in links:
718                    hrefNode = l.getAttributeNodeNS(None, u"href")
719                    if hrefNode:
720                        href = hrefNode.nodeValue
721                        if href.startswith('page-fragment.xql'):
722                            selfurl = self.absolute_url()
723                            #l.setAttributeNS(None, "span class = 'hit highlight'", "background-color: #77DD77;")           
724                            pagexml=href.replace('mode=text','mode=texttool&viewMode=%s&queryType=%s&query=%s&queryResultPageSize=%s&queryResultPN=%s&tocMode=%s&searchPN=%s&tocPN=%s'%(viewMode,queryType,query,pagesize,pn,tocMode,pn,tocPN))
725                            hrefNode.nodeValue = pagexml.replace('page-fragment.xql','%s'%selfurl)                                         
726                            l.setAttributeNS(None, "onClick", "id='highlighting'")             
727                return serializeNode(pagenode)
728       
729        if (queryType=="fulltextMorph"):
730            pagedivs = pagedom.xpath("//div[@class='queryResult']")
731           
732            if len(pagedivs)>0:
733                pagenode=pagedivs[0]
734                links=pagenode.xpath("//a")
735                for l in links:
736                    hrefNode = l.getAttributeNodeNS(None, u"href")
737                    if hrefNode:
738                        href = hrefNode.nodeValue
739                        if href.startswith('page-fragment.xql'):
740                            selfurl = self.absolute_url()       
741                            pagexml=href.replace('mode=text','mode=texttool&viewMode=%s&queryType=%s&query=%s&queryResultPageSize=%s&queryResultPN=%s&tocMode=%s&searchPN=%s&tocPN=%s'%(viewMode,queryType,query,pagesize,pn,tocMode,pn,tocPN))
742                            hrefNode.nodeValue = pagexml.replace('page-fragment.xql','%s'%selfurl) 
743                        if href.startswith('../lt/lemma.xql'):
744                            selfurl = self.absolute_url()
745                            hrefNode.nodeValue = href.replace('lt/lemma.xql','%s/template/head_main_lemma'%selfurl)       
746                            l.setAttributeNS(None, 'target', '_blank')
747                            l.setAttributeNS(None, 'onClick',"popupWin = window.open(this.href, 'contacts', 'location,width=500,height=600,top=180, left=400, scrollbars=1'); return false;")
748                            l.setAttributeNS(None, 'onDblclick', 'popupWin.focus();')                 
749                return serializeNode(pagenode)
750       
751        if (queryType=="ftIndex")or(queryType=="ftIndexMorph"):
752            pagedivs= pagedom.xpath("//div[@class='queryResultPage']")
753            if len(pagedivs)>0:
754                pagenode=pagedivs[0]
755                links=pagenode.xpath("//a")
756                for l in links:
757                    hrefNode = l.getAttributeNodeNS(None, u"href")
758                    if hrefNode:
759                        href = hrefNode.nodeValue
760                        hrefNode.nodeValue=href.replace('mode=text','mode=texttool&viewMode=%s&tocMode=%s&tocPN=%s&pn=%s'%(viewMode,tocMode,tocPN,pn))
761                       
762                        if href.startswith('../lt/lex.xql'):
763                           # selfurl = self.absolute_url()
764                            hrefNode.nodeValue = href.replace('../lt/lex.xql','%s/template/head_main_voc'%selfurl)         
765                            l.setAttributeNS(None, 'target', '_blank')
766                            l.setAttributeNS(None, 'onClick',"popupWin = window.open(this.href, 'contacts', 'location,width=500,height=600,top=180, left=400, scrollbars=1'); return false;")
767                            l.setAttributeNS(None, 'onDblclick', 'popupWin.focus();')
768                        if href.startswith('../lt/lemma.xql'):
769                            #selfurl = self.absolute_url()
770                            hrefNode.nodeValue = href.replace('../lt/lemma.xql','%s/template/head_main_lemma'%selfurl)       
771                            l.setAttributeNS(None, 'target', '_blank')
772                            l.setAttributeNS(None, 'onClick',"popupWin = window.open(this.href, 'contacts', 'location,width=500,height=600,top=180, left=400, scrollbars=1'); return false;")
773                            l.setAttributeNS(None, 'onDblclick', 'popupWin.focus();')
774                return serializeNode(pagenode)     
775        return "no text here"   
776                       
777    def getNumPages(self,docinfo=None):
778        """get list of pages from fulltext and put in docinfo"""
779        xquery = '//pb'
780        text = self.template.fulltextclient.eval("/mpdl/interface/xquery.xql", "document=%s&xquery=%s"%(docinfo['textURLPath'],xquery))
781        # TODO: better processing of the page list. do we need the info somewhere else also?
782        docinfo['numPages'] = text.count("<pb ")
783        return docinfo
784       
785    def getTextPage(self, mode="text", pn=1, docinfo=None, pageinfo=None,):
786        """returns single page from fulltext"""
787        docpath = docinfo['textURLPath']
788        if mode == "text_dict":
789            textmode = "textPollux"
790        else:
791            textmode = mode
792           
793        #selfurl = self.absolute_url() 
794        #viewMode=  pageinfo['viewMode']
795        #tocMode = pageinfo['tocMode']
796        #tocPN = pageinfo['tocPN']
797 
798        pagexml=self.template.fulltextclient.eval("/mpdl/interface/page-fragment.xql", "document=%s&mode=%s&pn=%s"%(docpath,textmode,pn), outputUnicode=False)
799        # post-processing downloaded xml
800        pagedom = Parse(pagexml)
801        # plain text mode
802        if mode == "text":
803            # first div contains text
804            pagedivs = pagedom.xpath("/div")
805            #queryResultPage
806            if len(pagedivs) > 0:
807               
808                pagenode = pagedivs[0]
809                links = pagenode.xpath("//a")
810                for l in links:
811                    hrefNode = l.getAttributeNodeNS(None, u"href")
812                    if hrefNode:
813                        href= hrefNode.nodeValue
814                        if href.startswith('#note-0006-01'):
815                            selfurl = self.absolute_url()
816                            hrefNode.nodeValue = href.replace("href='#note-'",'xaxa/%s/'%selfurl)
817                return serializeNode(pagenode)
818        if mode == "xml":
819              # first div contains text
820              pagedivs = pagedom.xpath("/div")
821              if len(pagedivs) > 0:
822                  pagenode = pagedivs[0]
823                  return serializeNode(pagenode)
824        # text-with-links mode
825        if mode == "text_dict":
826            # first div contains text
827            pagedivs = pagedom.xpath("/div")
828            if len(pagedivs) > 0:
829                pagenode = pagedivs[0]
830                # check all a-tags
831                links = pagenode.xpath("//a")
832                for l in links:
833                    hrefNode = l.getAttributeNodeNS(None, u"href")
834                    if hrefNode:
835                        # is link with href
836                        href = hrefNode.nodeValue
837                        if href.startswith('lt/lex.xql'):
838                            # is pollux link
839                            selfurl = self.absolute_url()
840                            # change href
841                            hrefNode.nodeValue = href.replace('lt/lex.xql','%s/template/head_main_voc'%selfurl)
842                            # add target
843                            l.setAttributeNS(None, 'target', '_blank')
844                            l.setAttributeNS(None, 'onClick',"popupWin = window.open(this.href, 'contacts', 'location,width=500,height=600,top=180, left=700, scrollbars=1'); return false;")
845                            l.setAttributeNS(None, 'onDblclick', 'popupWin.focus();')
846                           
847                        if href.startswith('lt/lemma.xql'):   
848                            selfurl = self.absolute_url()
849                            hrefNode.nodeValue = href.replace('lt/lemma.xql','%s/template/head_main_lemma'%selfurl)
850                            l.setAttributeNS(None, 'target', '_blank')
851                            l.setAttributeNS(None, 'onClick',"popupWin = window.open(this.href, 'contacts', 'location,width=500,height=600,top=180, left=700, scrollbars=1'); return false;")
852                            l.setAttributeNS(None, 'onDblclick', 'popupWin.focus();')
853                return serializeNode(pagenode)
854       
855        return "no text here"
856
857    def getTranslate(self, query=None, language=None):
858        """translate into another languages"""
859        pagexml=self.template.fulltextclient.eval("/mpdl/interface/lt/lex.xql","document=&language="+str(language)+"&query="+url_quote(str(query)))
860        return pagexml
861   
862    def getLemma(self, lemma=None, language=None):
863        """simular words lemma """
864        pagexml=self.template.fulltextclient.eval("/mpdl/interface/lt/lemma.xql","document=&language="+str(language)+"&lemma="+url_quote(str(lemma)))
865        #pagexml=self.template.fulltextclient.eval("/mpdl/interface/lt/lemma.xql","lemma=%s&language=%s"%(lemma,language),outputUnicode=False)
866        return pagexml
867
868    def getQuery (self,  docinfo=None, pageinfo=None, query=None, queryType=None, pn=1):
869         """number of"""
870         docpath = docinfo['textURLPath'] 
871         pagesize = pageinfo['queryPageSize']
872         pn = pageinfo['searchPN']
873         query =pageinfo['query']
874         queryType =pageinfo['queryType']
875
876         tocSearch = 0
877         tocDiv = None
878         pagexml=self.template.fulltextclient.eval("/mpdl/interface/doc-query.xql","document=%s&mode=%s&queryType=%s&query=%s&queryResultPageSize=%s&queryResultPN=%s"%(docpath, 'text', queryType, query, pagesize, pn) ,outputUnicode=False)
879         
880         pagedom = Parse(pagexml)
881         numdivs = pagedom.xpath("//div[@class='queryResultHits']")
882         tocSearch = int(getTextFromNode(numdivs[0]))
883         tc=int((tocSearch/20)+1)
884         logging.debug("documentViewer (gettoc) tc: %s"%(tc))
885         return tc
886
887    def getToc(self, mode="text", docinfo=None):
888        """loads table of contents and stores in docinfo"""
889        logging.debug("documentViewer (gettoc) mode: %s"%(mode))
890        if 'tocSize_%s'%mode in docinfo:
891            # cached toc
892            return docinfo
893        docpath = docinfo['textURLPath']
894        # we need to set a result set size
895        pagesize = 1000
896        pn = 1
897        if mode == "text":
898            queryType = "toc"
899        else:
900            queryType = mode
901        # number of entries in toc
902        tocSize = 0
903        tocDiv = None
904        pagexml=self.template.fulltextclient.eval("/mpdl/interface/doc-query.xql", "document=%s&queryType=%s&queryResultPageSize=%s&queryResultPN=%s"%(docpath,queryType,pagesize,pn), outputUnicode=False)
905        # post-processing downloaded xml
906        pagedom = Parse(pagexml)
907        # get number of entries
908        numdivs = pagedom.xpath("//div[@class='queryResultHits']")
909        if len(numdivs) > 0:
910            tocSize = int(getTextFromNode(numdivs[0]))
911            # div contains text
912            #pagedivs = pagedom.xpath("//div[@class='queryResultPage']")
913            #if len(pagedivs) > 0:
914            #    tocDiv = pagedivs[0]
915
916        docinfo['tocSize_%s'%mode] = tocSize
917        #docinfo['tocDiv_%s'%mode] = tocDiv
918        return docinfo
919   
920    def getTocPage(self, mode="text", pn=1, pageinfo=None, docinfo=None):
921        """returns single page from the table of contents"""
922        # TODO: this should use the cached TOC
923        if mode == "text":
924            queryType = "toc"
925        else:
926            queryType = mode
927        docpath = docinfo['textURLPath']
928        path = docinfo['textURLPath']
929        #logging.debug("documentViewer (gettoc) pathNomer: %s"%(pathNomer))
930        pagesize = pageinfo['tocPageSize']
931        pn = pageinfo['tocPN']
932        url = docinfo['url']
933        selfurl = self.absolute_url() 
934        viewMode=  pageinfo['viewMode']
935        tocMode = pageinfo['tocMode']
936        tocPN = pageinfo['tocPN']
937   
938        pagexml=self.template.fulltextclient.eval("/mpdl/interface/doc-query.xql", "document=%s&queryType=%s&queryResultPageSize=%s&queryResultPN=%s"%(docpath,queryType, pagesize, pn), outputUnicode=False)
939        page = pagexml.replace('page-fragment.xql?document=%s'%str(path),'%s?url=%s&viewMode=%s&tocMode=%s&tocPN=%s'%(selfurl,url, viewMode, tocMode, tocPN))
940        text = page.replace('mode=image','mode=texttool')
941        return text
942        # post-processing downloaded xml
943        #pagedom = Parse(text)
944        # div contains text
945        #pagedivs = pagedom.xpath("//div[@class='queryResultPage']")
946        #if len(pagedivs) > 0:
947        #    pagenode = pagedivs[0]
948        #    return serializeNode(pagenode)
949        #else:
950        #    return "No TOC!"
951
952   
953    def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None):
954        """init document viewer"""
955        self.title=title
956        self.digilibBaseUrl = digilibBaseUrl
957        self.thumbrows = thumbrows
958        self.thumbcols = thumbcols
959        self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
960        if RESPONSE is not None:
961            RESPONSE.redirect('manage_main')
962   
963   
964       
965def manage_AddDocumentViewerForm(self):
966    """add the viewer form"""
967    pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
968    return pt()
969 
970def manage_AddDocumentViewer(self,id,imageScalerUrl="",textServerName="",title="",RESPONSE=None):
971    """add the viewer"""
972    newObj=documentViewer(id,imageScalerUrl=imageScalerUrl,title=title,textServerName=textServerName)
973    self._setObject(id,newObj)
974   
975    if RESPONSE is not None:
976        RESPONSE.redirect('manage_main')
977
978
979##
980## DocumentViewerTemplate class
981##
982class DocumentViewerTemplate(ZopePageTemplate):
983    """Template for document viewer"""
984    meta_type="DocumentViewer Template"
985
986
987def manage_addDocumentViewerTemplateForm(self):
988    """Form for adding"""
989    pt=PageTemplateFile('zpt/addDocumentViewerTemplate', globals()).__of__(self)
990    return pt()
991
992def manage_addDocumentViewerTemplate(self, id='viewer_main', title=None, text=None,
993                           REQUEST=None, submit=None):
994    "Add a Page Template with optional file content."
995
996    self._setObject(id, DocumentViewerTemplate(id))
997    ob = getattr(self, id)
998    txt=file(os.path.join(package_home(globals()),'zpt/viewer_main.zpt'),'r').read()
999    logging.info("txt %s:"%txt)
1000    ob.pt_edit(txt,"text/html")
1001    if title:
1002        ob.pt_setTitle(title)
1003    try:
1004        u = self.DestinationURL()
1005    except AttributeError:
1006        u = REQUEST['URL1']
1007       
1008    u = "%s/%s" % (u, urllib.quote(id))
1009    REQUEST.RESPONSE.redirect(u+'/manage_main')
1010    return ''
1011
1012
1013   
Note: See TracBrowser for help on using the repository browser.