source: documentViewer/documentViewer.py @ 102:27513c893ba9

Last change on this file since 102:27513c893ba9 was 102:27513c893ba9, checked in by casties, 14 years ago

trying to fix text-only documents
File size: 42.8 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        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)               
709        pagexml = page.replace('?document=%s'%str(docpath),'?url=%s'%url)
710        pagedom = Parse(pagexml)
711        if (queryType=="fulltext")or(queryType=="xpath")or(queryType=="xquery")or(queryType=="fulltextMorphLemma"):   
712            pagedivs = pagedom.xpath("//div[@class='queryResultPage']")
713            if len(pagedivs)>0:
714                pagenode=pagedivs[0]
715                links=pagenode.xpath("//a")
716                for l in links:
717                    hrefNode = l.getAttributeNodeNS(None, u"href")
718                    if hrefNode:
719                        href = hrefNode.nodeValue
720                        if href.startswith('page-fragment.xql'):
721                            selfurl = self.absolute_url()
722                            #l.setAttributeNS(None, "span class = 'hit highlight'", "background-color: #77DD77;")           
723                            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))
724                            hrefNode.nodeValue = pagexml.replace('page-fragment.xql','%s'%selfurl)                                         
725                            l.setAttributeNS(None, "onClick", "id='highlighting'") 
726                             
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                pagenode = pagedivs[0]
808                return serializeNode(pagenode)
809        if mode == "xml":
810              # first div contains text
811              pagedivs = pagedom.xpath("/div")
812              if len(pagedivs) > 0:
813                  pagenode = pagedivs[0]
814                  return serializeNode(pagenode)
815        # text-with-links mode
816        if mode == "text_dict":
817            # first div contains text
818            pagedivs = pagedom.xpath("/div")
819            if len(pagedivs) > 0:
820                pagenode = pagedivs[0]
821                # check all a-tags
822                links = pagenode.xpath("//a")
823                for l in links:
824                    hrefNode = l.getAttributeNodeNS(None, u"href")
825                    if hrefNode:
826                        # is link with href
827                        href = hrefNode.nodeValue
828                        if href.startswith('lt/lex.xql'):
829                            # is pollux link
830                            selfurl = self.absolute_url()
831                            # change href
832                            hrefNode.nodeValue = href.replace('lt/lex.xql','%s/template/head_main_voc'%selfurl)
833                            # add target
834                            l.setAttributeNS(None, 'target', '_blank')
835                            l.setAttributeNS(None, 'onClick',"popupWin = window.open(this.href, 'contacts', 'location,width=500,height=600,top=180, left=700, scrollbars=1'); return false;")
836                            l.setAttributeNS(None, 'onDblclick', 'popupWin.focus();')
837                           
838                        if href.startswith('lt/lemma.xql'):   
839                            selfurl = self.absolute_url()
840                            hrefNode.nodeValue = href.replace('lt/lemma.xql','%s/template/head_main_lemma'%selfurl)
841                            l.setAttributeNS(None, 'target', '_blank')
842                            l.setAttributeNS(None, 'onClick',"popupWin = window.open(this.href, 'contacts', 'location,width=500,height=600,top=180, left=700, scrollbars=1'); return false;")
843                            l.setAttributeNS(None, 'onDblclick', 'popupWin.focus();')
844                return serializeNode(pagenode)
845       
846        return "no text here"
847
848    def getTranslate(self, query=None, language=None):
849        """translate into another languages"""
850        pagexml=self.template.fulltextclient.eval("/mpdl/interface/lt/lex.xql","document=&language="+str(language)+"&query="+url_quote(str(query)))
851        return pagexml
852   
853    def getLemma(self, lemma=None, language=None):
854        """simular words lemma """
855        pagexml=self.template.fulltextclient.eval("/mpdl/interface/lt/lemma.xql","document=&language="+str(language)+"&lemma="+url_quote(str(lemma)))
856        #pagexml=self.template.fulltextclient.eval("/mpdl/interface/lt/lemma.xql","lemma=%s&language=%s"%(lemma,language),outputUnicode=False)
857        return pagexml
858
859    def getQuery (self,  docinfo=None, pageinfo=None, query=None, queryType=None, pn=1):
860         """number of"""
861         docpath = docinfo['textURLPath'] 
862         pagesize = pageinfo['queryPageSize']
863         pn = pageinfo['searchPN']
864         query =pageinfo['query']
865         queryType =pageinfo['queryType']
866
867         tocSearch = 0
868         tocDiv = None
869         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)
870         
871         pagedom = Parse(pagexml)
872         numdivs = pagedom.xpath("//div[@class='queryResultHits']")
873         tocSearch = int(getTextFromNode(numdivs[0]))
874         tc=int((tocSearch/20)+1)
875         logging.debug("documentViewer (gettoc) tc: %s"%(tc))
876         return tc
877
878    def getToc(self, mode="text", docinfo=None):
879        """loads table of contents and stores in docinfo"""
880        logging.debug("documentViewer (gettoc) mode: %s"%(mode))
881        if 'tocSize_%s'%mode in docinfo:
882            # cached toc
883            return docinfo
884        docpath = docinfo['textURLPath']
885        # we need to set a result set size
886        pagesize = 1000
887        pn = 1
888        if mode == "text":
889            queryType = "toc"
890        else:
891            queryType = mode
892        # number of entries in toc
893        tocSize = 0
894        tocDiv = None
895        pagexml=self.template.fulltextclient.eval("/mpdl/interface/doc-query.xql", "document=%s&queryType=%s&queryResultPageSize=%s&queryResultPN=%s"%(docpath,queryType,pagesize,pn), outputUnicode=False)
896        # post-processing downloaded xml
897        pagedom = Parse(pagexml)
898        # get number of entries
899        numdivs = pagedom.xpath("//div[@class='queryResultHits']")
900        if len(numdivs) > 0:
901            tocSize = int(getTextFromNode(numdivs[0]))
902            # div contains text
903            #pagedivs = pagedom.xpath("//div[@class='queryResultPage']")
904            #if len(pagedivs) > 0:
905            #    tocDiv = pagedivs[0]
906
907        docinfo['tocSize_%s'%mode] = tocSize
908        #docinfo['tocDiv_%s'%mode] = tocDiv
909        return docinfo
910   
911    def getTocPage(self, mode="text", pn=1, pageinfo=None, docinfo=None):
912        """returns single page from the table of contents"""
913        # TODO: this should use the cached TOC
914        if mode == "text":
915            queryType = "toc"
916        else:
917            queryType = mode
918        docpath = docinfo['textURLPath']
919        path = docinfo['textURLPath']
920        #logging.debug("documentViewer (gettoc) pathNomer: %s"%(pathNomer))
921        pagesize = pageinfo['tocPageSize']
922        pn = pageinfo['tocPN']
923        url = docinfo['url']
924        selfurl = self.absolute_url() 
925        viewMode=  pageinfo['viewMode']
926        tocMode = pageinfo['tocMode']
927        tocPN = pageinfo['tocPN']
928   
929        pagexml=self.template.fulltextclient.eval("/mpdl/interface/doc-query.xql", "document=%s&queryType=%s&queryResultPageSize=%s&queryResultPN=%s"%(docpath,queryType, pagesize, pn), outputUnicode=False)
930        page = pagexml.replace('page-fragment.xql?document=%s'%str(path),'%s?url=%s&viewMode=%s&tocMode=%s&tocPN=%s'%(selfurl,url, viewMode, tocMode, tocPN))
931        text = page.replace('mode=image','mode=texttool')
932        return text
933        # post-processing downloaded xml
934        #pagedom = Parse(text)
935        # div contains text
936        #pagedivs = pagedom.xpath("//div[@class='queryResultPage']")
937        #if len(pagedivs) > 0:
938        #    pagenode = pagedivs[0]
939        #    return serializeNode(pagenode)
940        #else:
941        #    return "No TOC!"
942
943   
944    def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None):
945        """init document viewer"""
946        self.title=title
947        self.digilibBaseUrl = digilibBaseUrl
948        self.thumbrows = thumbrows
949        self.thumbcols = thumbcols
950        self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
951        if RESPONSE is not None:
952            RESPONSE.redirect('manage_main')
953   
954   
955       
956def manage_AddDocumentViewerForm(self):
957    """add the viewer form"""
958    pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
959    return pt()
960 
961def manage_AddDocumentViewer(self,id,imageScalerUrl="",textServerName="",title="",RESPONSE=None):
962    """add the viewer"""
963    newObj=documentViewer(id,imageScalerUrl=imageScalerUrl,title=title,textServerName=textServerName)
964    self._setObject(id,newObj)
965   
966    if RESPONSE is not None:
967        RESPONSE.redirect('manage_main')
968
969
970##
971## DocumentViewerTemplate class
972##
973class DocumentViewerTemplate(ZopePageTemplate):
974    """Template for document viewer"""
975    meta_type="DocumentViewer Template"
976
977
978def manage_addDocumentViewerTemplateForm(self):
979    """Form for adding"""
980    pt=PageTemplateFile('zpt/addDocumentViewerTemplate', globals()).__of__(self)
981    return pt()
982
983def manage_addDocumentViewerTemplate(self, id='viewer_main', title=None, text=None,
984                           REQUEST=None, submit=None):
985    "Add a Page Template with optional file content."
986
987    self._setObject(id, DocumentViewerTemplate(id))
988    ob = getattr(self, id)
989    txt=file(os.path.join(package_home(globals()),'zpt/viewer_main.zpt'),'r').read()
990    logging.info("txt %s:"%txt)
991    ob.pt_edit(txt,"text/html")
992    if title:
993        ob.pt_setTitle(title)
994    try:
995        u = self.DestinationURL()
996    except AttributeError:
997        u = REQUEST['URL1']
998       
999    u = "%s/%s" % (u, urllib.quote(id))
1000    REQUEST.RESPONSE.redirect(u+'/manage_main')
1001    return ''
1002
1003
1004   
Note: See TracBrowser for help on using the repository browser.