source: documentViewer/documentViewer.py @ 474:0bc4a153863a

elementtree
Last change on this file since 474:0bc4a153863a was 474:0bc4a153863a, checked in by casties, 13 years ago

more cleanup (before reversing macro order)
File size: 29.9 KB
Line 
1from OFS.Folder import Folder
2from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
3from Products.PageTemplates.PageTemplateFile import PageTemplateFile
4from AccessControl import ClassSecurityInfo
5from AccessControl import getSecurityManager
6from Globals import package_home
7
8#from Ft.Xml import EMPTY_NAMESPACE, Parse
9#import Ft.Xml.Domlette
10
11import xml.etree.ElementTree as ET
12
13import os.path
14import sys
15import urllib
16import logging
17import math
18import urlparse 
19import re
20import string
21
22from SrvTxtUtils import getInt, getText, getHttpData
23
24def logger(txt,method,txt2):
25    """logging"""
26    logging.info(txt+ txt2)
27   
28   
29def serializeNode(node, encoding="utf-8"):
30    """returns a string containing node as XML"""
31    s = ET.tostring(node)
32   
33    # 4Suite:
34    #    stream = cStringIO.StringIO()
35    #    Ft.Xml.Domlette.Print(node, stream=stream, encoding=encoding)
36    #    s = stream.getvalue()
37    #    stream.close()
38    return s
39
40def browserCheck(self):
41    """check the browsers request to find out the browser type"""
42    bt = {}
43    ua = self.REQUEST.get_header("HTTP_USER_AGENT")
44    bt['ua'] = ua
45    bt['isIE'] = False
46    bt['isN4'] = False
47    bt['versFirefox']=""
48    bt['versIE']=""
49    bt['versSafariChrome']=""
50    bt['versOpera']=""
51   
52    if string.find(ua, 'MSIE') > -1:
53        bt['isIE'] = True
54    else:
55        bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
56    # Safari oder Chrome identification   
57    try:
58        nav = ua[string.find(ua, '('):]
59        nav1=ua[string.find(ua,')'):]
60        nav2=nav1[string.find(nav1,'('):]
61        nav3=nav2[string.find(nav2,')'):]
62        ie = string.split(nav, "; ")[1]
63        ie1 =string.split(nav1, " ")[2]
64        ie2 =string.split(nav3, " ")[1]
65        ie3 =string.split(nav3, " ")[2]
66        if string.find(ie3, "Safari") >-1:
67            bt['versSafariChrome']=string.split(ie2, "/")[1]
68    except: pass
69    # IE identification
70    try:
71        nav = ua[string.find(ua, '('):]
72        ie = string.split(nav, "; ")[1]
73        if string.find(ie, "MSIE") > -1:
74            bt['versIE'] = string.split(ie, " ")[1]
75    except:pass
76    # Firefox identification
77    try:
78        nav = ua[string.find(ua, '('):]
79        nav1=ua[string.find(ua,')'):]
80        if string.find(ie1, "Firefox") >-1:
81            nav5= string.split(ie1, "/")[1]
82            logging.debug("FIREFOX: %s"%(nav5))
83            bt['versFirefox']=nav5[0:3]                   
84    except:pass
85    #Opera identification
86    try:
87        if string.find(ua,"Opera") >-1:
88            nav = ua[string.find(ua, '('):]
89            nav1=nav[string.find(nav,')'):]
90            bt['versOpera']=string.split(nav1,"/")[2]
91    except:pass
92   
93    bt['isMac'] = string.find(ua, 'Macintosh') > -1
94    bt['isWin'] = string.find(ua, 'Windows') > -1
95    bt['isIEWin'] = bt['isIE'] and bt['isWin']
96    bt['isIEMac'] = bt['isIE'] and bt['isMac']
97    bt['staticHTML'] = False
98
99    return bt
100
101def getParentPath(path, cnt=1):
102    """returns pathname shortened by cnt"""
103    # make sure path doesn't end with /
104    path = path.rstrip('/')
105    # split by /, shorten, and reassemble
106    return '/'.join(path.split('/')[0:-cnt])
107
108
109##
110## documentViewer class
111##
112class documentViewer(Folder):
113    """document viewer"""
114    meta_type="Document viewer"
115   
116    security=ClassSecurityInfo()
117    manage_options=Folder.manage_options+(
118        {'label':'main config','action':'changeDocumentViewerForm'},
119        )
120   
121    metadataService = None
122    """MetaDataFolder instance"""
123
124    # templates and forms
125    viewer_main = PageTemplateFile('zpt/viewer_main', globals())
126    toc_thumbs = PageTemplateFile('zpt/toc_thumbs', globals())
127    toc_text = PageTemplateFile('zpt/toc_text', globals())
128    toc_figures = PageTemplateFile('zpt/toc_figures', globals())
129    page_main_images = PageTemplateFile('zpt/page_main_images', globals())
130    page_main_double = PageTemplateFile('zpt/page_main_double', globals())
131    page_main_text = PageTemplateFile('zpt/page_main_text', globals())
132    page_main_text_dict = PageTemplateFile('zpt/page_main_text_dict', globals())
133    page_main_gis =PageTemplateFile ('zpt/page_main_gis', globals())
134    page_main_xml = PageTemplateFile('zpt/page_main_xml', globals())
135    page_main_pureXml = PageTemplateFile('zpt/page_main_pureXml', globals())
136    head_main = PageTemplateFile('zpt/head_main', globals())
137    docuviewer_css = PageTemplateFile('css/docuviewer.css', globals())
138    info_xml = PageTemplateFile('zpt/info_xml', globals())
139   
140   
141    thumbs_main_rss = PageTemplateFile('zpt/thumbs_main_rss', globals())
142
143   
144    def __init__(self,id,imageScalerUrl=None,textServerName=None,title="",digilibBaseUrl=None,thumbcols=2,thumbrows=5,authgroups="mpiwg"):
145        """init document viewer"""
146        self.id=id
147        self.title=title
148        self.thumbcols = thumbcols
149        self.thumbrows = thumbrows
150        # authgroups is list of authorized groups (delimited by ,)
151        self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
152        # create template folder so we can always use template.something
153       
154        templateFolder = Folder('template')
155        #self['template'] = templateFolder # Zope-2.12 style
156        self._setObject('template',templateFolder) # old style
157        try:
158            import MpdlXmlTextServer
159            textServer = MpdlXmlTextServer.MpdlXmlTextServer(id='fulltextclient',serverName=textServerName)
160            #templateFolder['fulltextclient'] = xmlRpcClient
161            templateFolder._setObject('fulltextclient',textServer)
162        except Exception, e:
163            logging.error("Unable to create MpdlXmlTextServer for fulltextclient: "+str(e))
164           
165        try:
166            from Products.zogiLib.zogiLib import zogiLib
167            zogilib = zogiLib(id="zogilib", title="zogilib for docuviewer", dlServerURL=imageScalerUrl, layout="book")
168            #templateFolder['zogilib'] = zogilib
169            templateFolder._setObject('zogilib',zogilib)
170        except Exception, e:
171            logging.error("Unable to create zogiLib for zogilib: "+str(e))
172           
173        try:
174            # assume MetaDataFolder instance is called metadata
175            self.metadataService = getattr(self, 'metadata')
176        except Exception, e:
177            logging.error("Unable to find MetaDataFolder 'metadata': "+str(e))
178           
179       
180    # proxy text server methods to fulltextclient
181    def getTextPage(self, **args):
182        """get page"""
183        return self.template.fulltextclient.getTextPage(**args)
184
185    def getOrigPages(self, **args):
186        """get page"""
187        return self.template.fulltextclient.getOrigPages(**args)
188   
189    def getOrigPagesNorm(self, **args):
190        """get page"""
191        return self.template.fulltextclient.getOrigPagesNorm(**args)
192
193    def getQuery(self, **args):
194        """get query in search"""
195        return self.template.fulltextclient.getQuery(**args)
196     
197    def getSearch(self, **args):
198        """get search"""
199        return self.template.fulltextclient.getSearch(**args)
200   
201    def getGisPlaces(self, **args):
202        """get gis places"""
203        return self.template.fulltextclient.getGisPlaces(**args)
204 
205    def getAllGisPlaces(self, **args):
206        """get all gis places """
207        return self.template.fulltextclient.getAllGisPlaces(**args)
208       
209    def getTranslate(self, **args):
210        """get translate"""
211        return self.template.fulltextclient.getTranslate(**args)
212
213    def getLemma(self, **args):
214        """get lemma"""
215        return self.template.fulltextclient.getLemma(**args)
216
217    def getLemmaQuery(self, **args):
218        """get query"""
219        return self.template.fulltextclient.getLemmaQuery(**args)
220
221    def getLex(self, **args):
222        """get lex"""
223        return self.template.fulltextclient.getLex(**args)
224
225    def getToc(self, **args):
226        """get toc"""
227        return self.template.fulltextclient.getToc(**args)
228
229    def getTocPage(self, **args):
230        """get tocpage"""
231        return self.template.fulltextclient.getTocPage(**args)
232
233   
234    security.declareProtected('View','thumbs_rss')
235    def thumbs_rss(self,mode,url,viewMode="auto",start=None,pn=1):
236        '''
237        view it
238        @param mode: defines how to access the document behind url
239        @param url: url which contains display information
240        @param viewMode: if images display images, if text display text, default is images (text,images or auto)
241       
242        '''
243        logging.debug("HHHHHHHHHHHHHH:load the rss")
244        logging.debug("documentViewer (index) mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
245       
246        if not hasattr(self, 'template'):
247            # create template folder if it doesn't exist
248            self.manage_addFolder('template')
249           
250        if not self.digilibBaseUrl:
251            self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
252           
253        docinfo = self.getDocinfo(mode=mode,url=url)
254        #pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)
255        pageinfo = self.getPageinfo(start=start,current=pn, docinfo=docinfo)
256        ''' ZDES '''
257        pt = getattr(self.template, 'thumbs_main_rss')
258       
259        if viewMode=="auto": # automodus gewaehlt
260            if docinfo.has_key("textURL") or docinfo.get('textURLPath',None): #texturl gesetzt und textViewer konfiguriert
261                viewMode="text"
262            else:
263                viewMode="images"
264               
265        return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode)
266
267 
268    security.declareProtected('View','index_html')
269    def index_html(self,url,mode="texttool",viewMode="auto",viewType=None,tocMode="thumbs",start=1,pn=1):
270        """
271        view page
272        @param url: url which contains display information
273        @param mode: defines how to access the document behind url
274        @param viewMode: 'images': display images, 'text': display text, default is 'auto'
275        @param viewType: sub-type of viewMode, e.g. 'dict' for viewMode='text'
276        @param tocMode: type of 'table of contents' for navigation (thumbs, text, figures, none)
277        """
278       
279        logging.debug("documentViewer (index) mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
280       
281        if not hasattr(self, 'template'):
282            # this won't work
283            logging.error("template folder missing!")
284            return "ERROR: template folder missing!"
285           
286        if not getattr(self, 'digilibBaseUrl', None):
287            self.digilibBaseUrl = self.findDigilibUrl() or "http://digilib.mpiwg-berlin.mpg.de/digitallibrary"
288           
289        docinfo = self.getDocinfo(mode=mode,url=url)
290       
291        if tocMode != "thumbs":
292            # get table of contents
293            docinfo = self.getToc(mode=tocMode, docinfo=docinfo)
294
295        # auto viewMode: text if there is a text else images
296        if viewMode=="auto": 
297            if docinfo.get('textURL', None) or docinfo.get('textURLPath', None): 
298                viewMode = "text"
299                viewType = "dict"
300            else:
301                viewMode = "images"
302               
303        elif viewMode == "text_dict":
304            # legacy fix
305            viewMode = "text"
306            viewType = "dict"
307           
308               
309        pageinfo = self.getPageinfo(start=start, current=pn, docinfo=docinfo, viewMode=viewMode, viewType=viewType, tocMode=tocMode)
310                   
311        # get template /template/viewer_main
312        pt = getattr(self.template, 'viewer_main')
313        # and execute with parameters
314        return pt(docinfo=docinfo, pageinfo=pageinfo)
315 
316    def generateMarks(self,mk):
317        ret=""
318        if mk is None:
319            return ""
320        if not isinstance(mk, list):
321            mk=[mk]
322        for m in mk:
323            ret+="mk=%s"%m
324        return ret
325   
326   
327    def getBrowser(self):
328        """getBrowser the version of browser """
329        bt = browserCheck(self)
330        logging.debug("BROWSER VERSION: %s"%(bt))
331        return bt
332       
333    def findDigilibUrl(self):
334        """try to get the digilib URL from zogilib"""
335        url = self.template.zogilib.getDLBaseUrl()
336        return url
337
338    def getDocumentViewerURL(self):
339        """returns the URL of this instance"""
340        return self.absolute_url()
341   
342    def getStyle(self, idx, selected, style=""):
343        """returns a string with the given style and append 'sel' if path == selected."""
344        #logger("documentViewer (getstyle)", logging.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
345        if idx == selected:
346            return style + 'sel'
347        else:
348            return style
349   
350    def getParams(self, param=None, val=None, params=None):
351        """returns dict with URL parameters.
352       
353        Takes URL parameters and additionally param=val or dict params.
354        Deletes key if value is None."""
355        # copy existing request params
356        newParams=self.REQUEST.form.copy()
357        # change single param
358        if param is not None:
359            if val is None:
360                if newParams.has_key(param):
361                    del newParams[param]
362            else:
363                newParams[param] = str(val)
364               
365        # change more params
366        if params is not None:
367            for k in params.keys():
368                v = params[k]
369                if v is None:
370                    # val=None removes param
371                    if newParams.has_key(k):
372                        del newParams[k]
373                       
374                else:
375                    newParams[k] = v
376                   
377        return newParams
378   
379    def getLink(self, param=None, val=None, params=None, baseUrl=None, paramSep='&'):
380        """returns URL to documentviewer with parameter param set to val or from dict params"""
381        urlParams = self.getParams(param=param, val=val, params=params)
382        # quote values and assemble into query string (not escaping '/')
383        ps = paramSep.join(["%s=%s"%(k,urllib.quote_plus(v,'/')) for (k, v) in urlParams.items()])
384        if baseUrl is None:
385            baseUrl = self.getDocumentViewerURL()
386           
387        url = "%s?%s"%(baseUrl, ps)
388        return url
389
390    def getLinkAmp(self, param=None, val=None, params=None, baseUrl=None):
391        """link to documentviewer with parameter param set to val"""
392        return self.getLink(param, val, params, baseUrl, '&')
393   
394   
395    def getInfo_xml(self,url,mode):
396        """returns info about the document as XML"""
397        if not self.digilibBaseUrl:
398            self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
399       
400        docinfo = self.getDocinfo(mode=mode,url=url)
401        pt = getattr(self.template, 'info_xml')
402        return pt(docinfo=docinfo)
403
404    def isAccessible(self, docinfo):
405        """returns if access to the resource is granted"""
406        access = docinfo.get('accessType', None)
407        logging.debug("documentViewer (accessOK) access type %s"%access)
408        if access == 'free':
409            logging.debug("documentViewer (accessOK) access is free")
410            return True
411       
412        elif access is None or access in self.authgroups:
413            # only local access -- only logged in users
414            user = getSecurityManager().getUser()
415            logging.debug("documentViewer (accessOK) user=%s ip=%s"%(user,self.REQUEST.getClientAddr()))
416            if user is not None:
417                #print "user: ", user
418                return (user.getUserName() != "Anonymous User")
419            else:
420                return False
421       
422        logging.error("documentViewer (accessOK) unknown access type %s"%access)
423        return False
424   
425
426
427    def getDocinfo(self, mode, url):
428        """returns docinfo depending on mode"""
429        logging.debug("getDocinfo: mode=%s, url=%s"%(mode,url))
430        # look for cached docinfo in session
431        if self.REQUEST.SESSION.has_key('docinfo'):
432            docinfo = self.REQUEST.SESSION['docinfo']
433            # check if its still current
434            if docinfo is not None and docinfo.get('mode', None) == mode and docinfo.get('url', None) == url:
435                logging.debug("getDocinfo: docinfo in session. keys=%s"%docinfo.keys())
436                return docinfo
437           
438        # new docinfo
439        docinfo = {'mode': mode, 'url': url}
440        # add self url
441        docinfo['viewerUrl'] = self.getDocumentViewerURL()
442        # get index.meta DOM
443        docUrl = None
444        metaDom = None
445        if mode=="texttool": 
446            # url points to document dir or index.meta
447            metaDom = self.metadataService.getDomFromPathOrUrl(url)
448            docUrl = url.replace('/index.meta', '')
449            if metaDom is None:
450                raise IOError("Unable to find index.meta for mode=texttool!")
451
452        elif mode=="imagepath":
453            # url points to folder with images, index.meta optional
454            # asssume index.meta in parent dir
455            docUrl = getParentPath(url)
456            metaDom = self.metadataService.getDomFromPathOrUrl(docUrl)
457
458        elif mode=="filepath":
459            # url points to image file, index.meta optional
460            # asssume index.meta is two path segments up
461            docUrl = getParentPath(url, 2)
462            metaDom = self.metadataService.getDomFromPathOrUrl(docUrl)
463
464        else:
465            logging.error("documentViewer (getdocinfo) unknown mode: %s!"%mode)
466            raise ValueError("Unknown mode %s! Has to be one of 'texttool','imagepath','filepath'."%(mode))
467       
468        docinfo['documentUrl'] = docUrl
469        # process index.meta contents
470        if metaDom is not None and metaDom.tag == 'resource':
471            # document directory name and path
472            resource = self.metadataService.getResourceData(dom=metaDom)
473            if resource:
474                docinfo = self.getDocinfoFromResource(docinfo, resource)
475
476            # texttool info
477            texttool = self.metadataService.getTexttoolData(dom=metaDom)
478            if texttool:
479                docinfo = self.getDocinfoFromTexttool(docinfo, texttool)
480           
481            # bib info
482            bib = self.metadataService.getBibData(dom=metaDom)
483            if bib:
484                docinfo = self.getDocinfoFromBib(docinfo, bib)
485            else:
486                # no bib - try info.xml
487                docinfo = self.getDocinfoFromPresentationInfoXml(docinfo)
488               
489            # auth info
490            access = self.metadataService.getAccessData(dom=metaDom)
491            if access:
492                docinfo = self.getDocinfoFromAccess(docinfo, access)
493
494            # attribution info
495            attribution = self.metadataService.getAttributionData(dom=metaDom)
496            if attribution:
497                logging.debug("getDocinfo: attribution=%s"%repr(attribution))
498                docinfo['attribution'] = attribution
499                #docinfo = self.getDocinfoFromAccess(docinfo, access)
500
501            # copyright info
502            copyright = self.metadataService.getCopyrightData(dom=metaDom)
503            if copyright:
504                logging.debug("getDocinfo: copyright=%s"%repr(copyright))
505                docinfo['copyright'] = copyright
506                #docinfo = self.getDocinfoFromAccess(docinfo, access)
507
508        # image path
509        if mode != 'texttool':
510            # override image path from texttool
511            docinfo['imagePath'] = url.replace('/mpiwg/online/', '', 1)
512
513        # number of images from digilib
514        if docinfo.get('imagePath', None):
515            docinfo['imageURL'] = self.digilibBaseUrl + "/servlet/Scaler?fn=" + docinfo['imagePath']
516            docinfo = self.getDocinfoFromDigilib(docinfo, docinfo['imagePath'])
517
518        logging.debug("documentViewer (getdocinfo) docinfo: keys=%s"%docinfo.keys())
519        #logging.debug("documentViewer (getdocinfo) docinfo: %s"%docinfo)
520        # store in session
521        self.REQUEST.SESSION['docinfo'] = docinfo
522        return docinfo
523
524    def getDocinfoFromResource(self, docinfo, resource):
525        """reads contents of resource element into docinfo"""
526        docName = resource.get('name', None)
527        docinfo['documentName'] = docName
528        docPath = resource.get('archive-path', None)
529        if docPath:
530            # clean up document path
531            if docPath[0] != '/':
532                docPath = '/' + docPath
533               
534            if docName and (not docPath.endswith(docName)):
535                docPath += "/" + docName
536           
537        else:
538            # use docUrl as docPath
539            docUrl = docinfo['documentURL']
540            if not docUrl.startswith('http:'):
541                docPath = docUrl
542        if docPath:
543            # fix URLs starting with /mpiwg/online
544            docPath = docPath.replace('/mpiwg/online', '', 1)
545
546        docinfo['documentPath'] = docPath
547        return docinfo
548
549    def getDocinfoFromTexttool(self, docinfo, texttool):
550        """reads contents of texttool element into docinfo"""
551        # image dir
552        imageDir = texttool.get('image', None)
553        docPath = docinfo.get('documentPath', None)
554        if imageDir and docPath:
555            #print "image: ", imageDir, " archivepath: ", archivePath
556            imageDir = os.path.join(docPath, imageDir)
557            imageDir = imageDir.replace('/mpiwg/online', '', 1)
558            docinfo['imagePath'] = imageDir
559       
560        # old style text URL
561        textUrl = texttool.get('text', None)
562        if textUrl and docPath:
563            if urlparse.urlparse(textUrl)[0] == "": #keine url
564                textUrl = os.path.join(docPath, textUrl) 
565           
566            docinfo['textURL'] = textUrl
567   
568        # new style text-url-path
569        textUrl = texttool.get('text-url-path', None)
570        if textUrl:
571            docinfo['textURLPath'] = textUrl
572           
573        # page flow
574        docinfo['pageFlow'] = texttool.get('page-flow', 'ltr')
575           
576        # odd pages are left
577        docinfo['oddPage'] = texttool.get('odd-scan-orientation', 'left')
578           
579        # number of title page (0: not defined)
580        docinfo['titlePage'] = texttool.get('title-scan-no', 0)
581           
582        # old presentation stuff
583        presentation = texttool.get('presentation', None)
584        if presentation and docPath:
585            if presentation.startswith('http:'):
586                docinfo['presentationUrl'] = presentation
587            else:
588                docinfo['presentationUrl'] = os.path.join(docPath, presentation)
589           
590       
591        return docinfo
592
593    def getDocinfoFromBib(self, docinfo, bib):
594        """reads contents of bib element into docinfo"""
595        logging.debug("getDocinfoFromBib bib=%s"%repr(bib))
596        # put all raw bib fields in dict "bib"
597        docinfo['bib'] = bib
598        bibtype = bib.get('@type', None)
599        docinfo['bibType'] = bibtype
600        # also store DC metadata for convenience
601        dc = self.metadataService.getDCMappedData(bib)
602        docinfo['creator'] = dc.get('creator',None)
603        docinfo['title'] = dc.get('title',None)
604        docinfo['date'] = dc.get('date',None)
605        return docinfo
606           
607    def getDocinfoFromAccess(self, docinfo, acc):
608        """reads contents of access element into docinfo"""
609        #TODO: also read resource type
610        logging.debug("getDocinfoFromAccess acc=%s"%repr(acc))
611        try:
612            acctype = acc['@attr']['type']
613            if acctype:
614                access=acctype
615                if access in ['group', 'institution']:
616                    access = acc['name'].lower()
617               
618                docinfo['accessType'] = access
619
620        except:
621            pass
622       
623        return docinfo
624
625    def getDocinfoFromDigilib(self, docinfo, path):
626        infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path
627        # fetch data
628        txt = getHttpData(infoUrl)
629        if not txt:
630            logging.error("Unable to get dir-info from %s"%(infoUrl))
631            return docinfo
632
633        dom = ET.fromstring(txt)
634        size = getText(dom.find("size"))
635        logging.debug("getDocinfoFromDigilib: size=%s"%size)
636        if size:
637            docinfo['numPages'] = int(size)
638        else:
639            docinfo['numPages'] = 0
640           
641        # TODO: produce and keep list of image names and numbers
642        return docinfo
643           
644           
645    def getDocinfoFromPresentationInfoXml(self,docinfo):
646        """gets DC-like bibliographical information from the presentation entry in texttools"""
647        url = docinfo.get('presentationUrl', None)
648        if not url:
649            logging.error("getDocinfoFromPresentation: no URL!")
650            return docinfo
651       
652        dom = None
653        metaUrl = None
654        if url.startswith("http://"):
655            # real URL
656            metaUrl = url
657        else:
658            # online path
659           
660            server=self.digilibBaseUrl+"/servlet/Texter?fn="
661            metaUrl=server+url
662       
663        txt=getHttpData(metaUrl)
664        if txt is None:
665            logging.error("Unable to read info.xml from %s"%(url))
666            return docinfo
667           
668        dom = ET.fromstring(txt)
669        docinfo['creator']=getText(dom.find(".//author"))
670        docinfo['title']=getText(dom.find(".//title"))
671        docinfo['date']=getText(dom.find(".//date"))
672        return docinfo
673   
674
675    def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None, viewMode=None, viewType=None, tocMode=None):
676        """returns pageinfo with the given parameters"""
677        pageinfo = {}
678        pageinfo['viewMode'] = viewMode
679        pageinfo['viewType'] = viewType
680        pageinfo['tocMode'] = tocMode
681
682        current = getInt(current)
683        pageinfo['current'] = current
684        rows = int(rows or self.thumbrows)
685        pageinfo['rows'] = rows
686        cols = int(cols or self.thumbcols)
687        pageinfo['cols'] = cols
688        grpsize = cols * rows
689        pageinfo['groupsize'] = grpsize
690        # what does this do?
691        start = getInt(start, default=(math.ceil(float(current)/float(grpsize))*grpsize-(grpsize-1)))
692        # int(current / grpsize) * grpsize +1))
693        pageinfo['start'] = start
694        pageinfo['end'] = start + grpsize
695        pn = self.REQUEST.get('pn','1')
696        pageinfo['pn'] = pn
697        np = int(docinfo.get('numPages', 0))
698        if np == 0:
699            # numPages unknown - maybe we can get it from text page
700            if docinfo.get('textURLPath', None):
701                # cache text page as well
702                pageinfo['textPage'] = self.getTextPage(mode=viewType, pn=pn, docinfo=docinfo, pageinfo=pageinfo)
703                np = int(docinfo.get('numPages', 0))
704               
705        pageinfo['end'] = min(pageinfo['end'], np)
706        pageinfo['numgroups'] = int(np / grpsize)
707        if np % grpsize > 0:
708            pageinfo['numgroups'] += 1
709               
710        pageinfo['characterNormalization'] = self.REQUEST.get('characterNormalization','reg')
711        pageinfo['query'] = self.REQUEST.get('query','') 
712        pageinfo['queryType'] = self.REQUEST.get('queryType','')
713        pageinfo['querySearch'] =self.REQUEST.get('querySearch', 'fulltext')
714        pageinfo['highlightQuery'] = self.REQUEST.get('highlightQuery','')
715        pageinfo['tocPageSize'] = self.REQUEST.get('tocPageSize', '30')
716        pageinfo['queryPageSize'] =self.REQUEST.get('queryPageSize', '10')
717        pageinfo['tocPN'] = self.REQUEST.get('tocPN', '1')
718        # WTF?:
719        toc = int(pageinfo['tocPN'])
720        pageinfo['textPages'] = int(toc)
721       
722        # What does this do?
723        if 'tocSize_%s'%tocMode in docinfo:
724            tocSize = int(docinfo['tocSize_%s'%tocMode])
725            tocPageSize = int(pageinfo['tocPageSize'])
726            # cached toc           
727            if tocSize%tocPageSize>0:
728                tocPages=tocSize/tocPageSize+1
729            else:
730                tocPages=tocSize/tocPageSize
731               
732            pageinfo['tocPN'] = min(tocPages,toc)
733           
734        pageinfo['searchPN'] =self.REQUEST.get('searchPN','1')
735        return pageinfo
736
737
738    security.declareProtected('View management screens','changeDocumentViewerForm')   
739    changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
740   
741    def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None):
742        """init document viewer"""
743        self.title=title
744        self.digilibBaseUrl = digilibBaseUrl
745        self.thumbrows = thumbrows
746        self.thumbcols = thumbcols
747        self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
748        try:
749            # assume MetaDataFolder instance is called metadata
750            self.metadataService = getattr(self, 'metadata')
751        except Exception, e:
752            logging.error("Unable to find MetaDataFolder 'metadata': "+str(e))
753
754        if RESPONSE is not None:
755            RESPONSE.redirect('manage_main')
756       
757def manage_AddDocumentViewerForm(self):
758    """add the viewer form"""
759    pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
760    return pt()
761 
762def manage_AddDocumentViewer(self,id,imageScalerUrl="",textServerName="",title="",RESPONSE=None):
763    """add the viewer"""
764    newObj=documentViewer(id,imageScalerUrl=imageScalerUrl,title=title,textServerName=textServerName)
765    self._setObject(id,newObj)
766   
767    if RESPONSE is not None:
768        RESPONSE.redirect('manage_main')
769
770## DocumentViewerTemplate class
771class DocumentViewerTemplate(ZopePageTemplate):
772    """Template for document viewer"""
773    meta_type="DocumentViewer Template"
774
775
776def manage_addDocumentViewerTemplateForm(self):
777    """Form for adding"""
778    pt=PageTemplateFile('zpt/addDocumentViewerTemplate', globals()).__of__(self)
779    return pt()
780
781def manage_addDocumentViewerTemplate(self, id='viewer_main', title=None, text=None,
782                           REQUEST=None, submit=None):
783    "Add a Page Template with optional file content."
784
785    self._setObject(id, DocumentViewerTemplate(id))
786    ob = getattr(self, id)
787    txt=file(os.path.join(package_home(globals()),'zpt/viewer_main.zpt'),'r').read()
788    logging.info("txt %s:"%txt)
789    ob.pt_edit(txt,"text/html")
790    if title:
791        ob.pt_setTitle(title)
792    try:
793        u = self.DestinationURL()
794    except AttributeError:
795        u = REQUEST['URL1']
796       
797    u = "%s/%s" % (u, urllib.quote(id))
798    REQUEST.RESPONSE.redirect(u+'/manage_main')
799    return ''
800
801
802   
Note: See TracBrowser for help on using the repository browser.