source: documentViewer/documentViewer.py @ 469:15394486ab75

elementtree
Last change on this file since 469:15394486ab75 was 469:15394486ab75, checked in by casties, 13 years ago

working with new templates
File size: 29.7 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",tocMode="thumbs",start=None,pn=1,mk=None):
270        """
271        view it
272        @param mode: defines how to access the document behind url
273        @param url: url which contains display information
274        @param viewMode: if images display images, if text display text, default is auto (text,images or auto)
275        @param tocMode: type of 'table of contents' for navigation (thumbs, text, figures, none)
276        """
277       
278        logging.debug("documentViewer (index) mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
279       
280        if not hasattr(self, 'template'):
281            # this won't work
282            logging.error("template folder missing!")
283            return "ERROR: template folder missing!"
284           
285        if not getattr(self, 'digilibBaseUrl', None):
286            self.digilibBaseUrl = self.findDigilibUrl() or "http://digilib.mpiwg-berlin.mpg.de/digitallibrary"
287           
288        docinfo = self.getDocinfo(mode=mode,url=url)
289       
290        if tocMode != "thumbs":
291            # get table of contents
292            docinfo = self.getToc(mode=tocMode, docinfo=docinfo)
293
294        # auto viewMode: text_dict if text else images
295        if viewMode=="auto": 
296            if docinfo.get('textURL', None) or docinfo.get('textURLPath', None): 
297                viewMode="text_dict"
298            else:
299                viewMode="images"
300               
301        pageinfo = self.getPageinfo(start=start, current=pn, docinfo=docinfo, viewMode=viewMode, tocMode=tocMode)
302                   
303        # get template /template/viewer_main
304        pt = getattr(self.template, 'viewer_main')
305        # and execute with parameters
306        return pt(docinfo=docinfo, pageinfo=pageinfo, viewMode=viewMode, mk=self.generateMarks(mk))
307 
308    def generateMarks(self,mk):
309        ret=""
310        if mk is None:
311            return ""
312        if not isinstance(mk, list):
313            mk=[mk]
314        for m in mk:
315            ret+="mk=%s"%m
316        return ret
317   
318   
319    def getBrowser(self):
320        """getBrowser the version of browser """
321        bt = browserCheck(self)
322        logging.debug("BROWSER VERSION: %s"%(bt))
323        return bt
324       
325    def findDigilibUrl(self):
326        """try to get the digilib URL from zogilib"""
327        url = self.template.zogilib.getDLBaseUrl()
328        return url
329
330    def getDocumentViewerURL(self):
331        """returns the URL of this instance"""
332        return self.absolute_url()
333   
334    def getStyle(self, idx, selected, style=""):
335        """returns a string with the given style and append 'sel' if path == selected."""
336        #logger("documentViewer (getstyle)", logging.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
337        if idx == selected:
338            return style + 'sel'
339        else:
340            return style
341   
342    def getParams(self, param=None, val=None, params=None):
343        """returns dict with URL parameters.
344       
345        Takes URL parameters and additionally param=val or dict params.
346        Deletes key if value is None."""
347        # copy existing request params
348        newParams=self.REQUEST.form.copy()
349        # change single param
350        if param is not None:
351            if val is None:
352                if newParams.has_key(param):
353                    del newParams[param]
354            else:
355                newParams[param] = str(val)
356               
357        # change more params
358        if params is not None:
359            for k in params.keys():
360                v = params[k]
361                if v is None:
362                    # val=None removes param
363                    if newParams.has_key(k):
364                        del newParams[k]
365                       
366                else:
367                    newParams[k] = v
368                   
369        return newParams
370   
371    def getLink(self, param=None, val=None, params=None, baseUrl=None, paramSep='&'):
372        """returns URL to documentviewer with parameter param set to val or from dict params"""
373        urlParams = self.getParams(param=param, val=val, params=params)
374        # quote values and assemble into query string (not escaping '/')
375        ps = paramSep.join(["%s=%s"%(k,urllib.quote_plus(v,'/')) for (k, v) in urlParams.items()])
376        if baseUrl is None:
377            baseUrl = self.getDocumentViewerURL()
378           
379        url = "%s?%s"%(baseUrl, ps)
380        return url
381
382    def getLinkAmp(self, param=None, val=None, params=None, baseUrl=None):
383        """link to documentviewer with parameter param set to val"""
384        return self.getLink(param, val, params, baseUrl, '&')
385   
386   
387    def getInfo_xml(self,url,mode):
388        """returns info about the document as XML"""
389        if not self.digilibBaseUrl:
390            self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
391       
392        docinfo = self.getDocinfo(mode=mode,url=url)
393        pt = getattr(self.template, 'info_xml')
394        return pt(docinfo=docinfo)
395
396    def isAccessible(self, docinfo):
397        """returns if access to the resource is granted"""
398        access = docinfo.get('accessType', None)
399        logging.debug("documentViewer (accessOK) access type %s"%access)
400        if access == 'free':
401            logging.debug("documentViewer (accessOK) access is free")
402            return True
403       
404        elif access is None or access in self.authgroups:
405            # only local access -- only logged in users
406            user = getSecurityManager().getUser()
407            logging.debug("documentViewer (accessOK) user=%s ip=%s"%(user,self.REQUEST.getClientAddr()))
408            if user is not None:
409                #print "user: ", user
410                return (user.getUserName() != "Anonymous User")
411            else:
412                return False
413       
414        logging.error("documentViewer (accessOK) unknown access type %s"%access)
415        return False
416   
417
418
419    def getDocinfo(self, mode, url):
420        """returns docinfo depending on mode"""
421        logging.debug("getDocinfo: mode=%s, url=%s"%(mode,url))
422        # look for cached docinfo in session
423        if self.REQUEST.SESSION.has_key('docinfo'):
424            docinfo = self.REQUEST.SESSION['docinfo']
425            # check if its still current
426            if docinfo is not None and docinfo.get('mode', None) == mode and docinfo.get('url', None) == url:
427                logging.debug("getDocinfo: docinfo in session. keys=%s"%docinfo.keys())
428                return docinfo
429           
430        # new docinfo
431        docinfo = {'mode': mode, 'url': url}
432        # add self url
433        docinfo['viewerUrl'] = self.getDocumentViewerURL()
434        # get index.meta DOM
435        docUrl = None
436        metaDom = None
437        if mode=="texttool": 
438            # url points to document dir or index.meta
439            metaDom = self.metadataService.getDomFromPathOrUrl(url)
440            docUrl = url.replace('/index.meta', '')
441            if metaDom is None:
442                raise IOError("Unable to find index.meta for mode=texttool!")
443
444        elif mode=="imagepath":
445            # url points to folder with images, index.meta optional
446            # asssume index.meta in parent dir
447            docUrl = getParentPath(url)
448            metaDom = self.metadataService.getDomFromPathOrUrl(docUrl)
449
450        elif mode=="filepath":
451            # url points to image file, index.meta optional
452            # asssume index.meta is two path segments up
453            docUrl = getParentPath(url, 2)
454            metaDom = self.metadataService.getDomFromPathOrUrl(docUrl)
455
456        else:
457            logging.error("documentViewer (getdocinfo) unknown mode: %s!"%mode)
458            raise ValueError("Unknown mode %s! Has to be one of 'texttool','imagepath','filepath'."%(mode))
459       
460        docinfo['documentUrl'] = docUrl
461        # process index.meta contents
462        if metaDom is not None:
463            # document directory name and path
464            resource = self.metadataService.getResourceData(dom=metaDom)
465            if resource:
466                docinfo = self.getDocinfoFromResource(docinfo, resource)
467
468            # texttool info
469            texttool = self.metadataService.getTexttoolData(dom=metaDom)
470            if texttool:
471                docinfo = self.getDocinfoFromTexttool(docinfo, texttool)
472           
473            # bib info
474            bib = self.metadataService.getBibData(dom=metaDom)
475            if bib:
476                docinfo = self.getDocinfoFromBib(docinfo, bib)
477            else:
478                # no bib - try info.xml
479                docinfo = self.getDocinfoFromPresentationInfoXml(docinfo)
480               
481            # auth info
482            access = self.metadataService.getAccessData(dom=metaDom)
483            if access:
484                docinfo = self.getDocinfoFromAccess(docinfo, access)
485
486            # attribution info
487            attribution = self.metadataService.getAttributionData(dom=metaDom)
488            if attribution:
489                logging.debug("getDocinfo: attribution=%s"%repr(attribution))
490                docinfo['attribution'] = attribution
491                #docinfo = self.getDocinfoFromAccess(docinfo, access)
492
493            # copyright info
494            copyright = self.metadataService.getCopyrightData(dom=metaDom)
495            if copyright:
496                logging.debug("getDocinfo: copyright=%s"%repr(copyright))
497                docinfo['copyright'] = copyright
498                #docinfo = self.getDocinfoFromAccess(docinfo, access)
499
500        # image path
501        if mode != 'texttool':
502            # override image path from texttool
503            docinfo['imagePath'] = url.replace('/mpiwg/online/', '', 1)
504
505        # number of images from digilib
506        if docinfo.get('imagePath', None):
507            docinfo['imageURL'] = self.digilibBaseUrl + "/servlet/Scaler?fn=" + docinfo['imagePath']
508            docinfo = self.getDocinfoFromDigilib(docinfo, docinfo['imagePath'])
509
510        logging.debug("documentViewer (getdocinfo) docinfo: keys=%s"%docinfo.keys())
511        #logging.debug("documentViewer (getdocinfo) docinfo: %s"%docinfo)
512        # store in session
513        self.REQUEST.SESSION['docinfo'] = docinfo
514        return docinfo
515
516    def getDocinfoFromResource(self, docinfo, resource):
517        """reads contents of resource element into docinfo"""
518        docName = resource.get('name', None)
519        docinfo['documentName'] = docName
520        docPath = resource.get('archive-path', None)
521        if docPath:
522            # clean up document path
523            if docPath[0] != '/':
524                docPath = '/' + docPath
525               
526            if docName and (not docPath.endswith(docName)):
527                docPath += "/" + docName
528           
529        else:
530            # use docUrl as docPath
531            docUrl = docinfo['documentURL']
532            if not docUrl.startswith('http:'):
533                docPath = docUrl
534        if docPath:
535            # fix URLs starting with /mpiwg/online
536            docPath = docPath.replace('/mpiwg/online', '', 1)
537
538        docinfo['documentPath'] = docPath
539        return docinfo
540
541    def getDocinfoFromTexttool(self, docinfo, texttool):
542        """reads contents of texttool element into docinfo"""
543        # image dir
544        imageDir = texttool.get('image', None)
545        docPath = docinfo.get('documentPath', None)
546        if imageDir and docPath:
547            #print "image: ", imageDir, " archivepath: ", archivePath
548            imageDir = os.path.join(docPath, imageDir)
549            imageDir = imageDir.replace('/mpiwg/online', '', 1)
550            docinfo['imagePath'] = imageDir
551       
552        # old style text URL
553        textUrl = texttool.get('text', None)
554        if textUrl and docPath:
555            if urlparse.urlparse(textUrl)[0] == "": #keine url
556                textUrl = os.path.join(docPath, textUrl) 
557           
558            docinfo['textURL'] = textUrl
559   
560        # new style text-url-path
561        textUrl = texttool.get('text-url-path', None)
562        if textUrl:
563            docinfo['textURLPath'] = textUrl
564           
565        # page flow
566        docinfo['pageFlow'] = texttool.get('page-flow', 'ltr')
567           
568        # odd pages are left
569        docinfo['oddPage'] = texttool.get('odd-scan-orientation', 'left')
570           
571        # number of title page (0: not defined)
572        docinfo['titlePage'] = texttool.get('title-scan-no', 0)
573           
574        # old presentation stuff
575        presentation = texttool.get('presentation', None)
576        if presentation and docPath:
577            if presentation.startswith('http:'):
578                docinfo['presentationUrl'] = presentation
579            else:
580                docinfo['presentationUrl'] = os.path.join(docPath, presentation)
581           
582       
583        return docinfo
584
585    def getDocinfoFromBib(self, docinfo, bib):
586        """reads contents of bib element into docinfo"""
587        logging.debug("getDocinfoFromBib bib=%s"%repr(bib))
588        # put all raw bib fields in dict "bib"
589        docinfo['bib'] = bib
590        bibtype = bib.get('@type', None)
591        docinfo['bibType'] = bibtype
592        # also store DC metadata for convenience
593        dc = self.metadataService.getDCMappedData(bib)
594        docinfo['creator'] = dc.get('creator',None)
595        docinfo['title'] = dc.get('title',None)
596        docinfo['date'] = dc.get('date',None)
597        return docinfo
598           
599    def getDocinfoFromAccess(self, docinfo, acc):
600        """reads contents of access element into docinfo"""
601        #TODO: also read resource type
602        logging.debug("getDocinfoFromAccess acc=%s"%repr(acc))
603        try:
604            acctype = acc['@attr']['type']
605            if acctype:
606                access=acctype
607                if access in ['group', 'institution']:
608                    access = acc['name'].lower()
609               
610                docinfo['accessType'] = access
611
612        except:
613            pass
614       
615        return docinfo
616
617    def getDocinfoFromDigilib(self, docinfo, path):
618        infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path
619        # fetch data
620        txt = getHttpData(infoUrl)
621        if not txt:
622            logging.error("Unable to get dir-info from %s"%(infoUrl))
623            return docinfo
624
625        dom = ET.fromstring(txt)
626        size = getText(dom.find("size"))
627        logging.debug("getDocinfoFromDigilib: size=%s"%size)
628        if size:
629            docinfo['numPages'] = int(size)
630        else:
631            docinfo['numPages'] = 0
632           
633        # TODO: produce and keep list of image names and numbers
634        return docinfo
635           
636           
637    def getDocinfoFromPresentationInfoXml(self,docinfo):
638        """gets DC-like bibliographical information from the presentation entry in texttools"""
639        url = docinfo.get('presentationUrl', None)
640        if not url:
641            logging.error("getDocinfoFromPresentation: no URL!")
642            return docinfo
643       
644        dom = None
645        metaUrl = None
646        if url.startswith("http://"):
647            # real URL
648            metaUrl = url
649        else:
650            # online path
651           
652            server=self.digilibBaseUrl+"/servlet/Texter?fn="
653            metaUrl=server+url
654       
655        txt=getHttpData(metaUrl)
656        if txt is None:
657            logging.error("Unable to read info.xml from %s"%(url))
658            return docinfo
659           
660        dom = ET.fromstring(txt)
661        docinfo['creator']=getText(dom.find(".//author"))
662        docinfo['title']=getText(dom.find(".//title"))
663        docinfo['date']=getText(dom.find(".//date"))
664        return docinfo
665   
666
667    def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None, viewMode=None, tocMode=None):
668        """returns pageinfo with the given parameters"""
669        pageinfo = {}
670        current = getInt(current)
671        pageinfo['current'] = current
672        rows = int(rows or self.thumbrows)
673        pageinfo['rows'] = rows
674        cols = int(cols or self.thumbcols)
675        pageinfo['cols'] = cols
676        grpsize = cols * rows
677        pageinfo['groupsize'] = grpsize
678        # what does this do?
679        start = getInt(start, default=(math.ceil(float(current)/float(grpsize))*grpsize-(grpsize-1)))
680        # int(current / grpsize) * grpsize +1))
681        pageinfo['start'] = start
682        pageinfo['end'] = start + grpsize
683        pn = self.REQUEST.get('pn','1')
684        pageinfo['pn'] = pn
685        np = int(docinfo.get('numPages', 0))
686        if np == 0:
687            # numPages unknown - maybe we can get it from text page
688            if docinfo.get('textURLPath', None):
689                # cache text page as well
690                pageinfo['textPage'] = self.getTextPage(mode=viewMode, pn=pn, docinfo=docinfo, pageinfo=pageinfo)
691                np = int(docinfo.get('numPages', 0))
692               
693        pageinfo['end'] = min(pageinfo['end'], np)
694        pageinfo['numgroups'] = int(np / grpsize)
695        if np % grpsize > 0:
696            pageinfo['numgroups'] += 1
697               
698        pageinfo['viewMode'] = viewMode
699        pageinfo['tocMode'] = tocMode
700        pageinfo['characterNormalization'] = self.REQUEST.get('characterNormalization','reg')
701        #pageinfo['optionToggle'] = self.REQUEST.get('optionToggle','1')
702        pageinfo['query'] = self.REQUEST.get('query','') 
703        pageinfo['queryType'] = self.REQUEST.get('queryType','')
704        pageinfo['querySearch'] =self.REQUEST.get('querySearch', 'fulltext')
705        pageinfo['highlightQuery'] = self.REQUEST.get('highlightQuery','')
706        pageinfo['tocPageSize'] = self.REQUEST.get('tocPageSize', '30')
707        pageinfo['queryPageSize'] =self.REQUEST.get('queryPageSize', '10')
708        pageinfo['tocPN'] = self.REQUEST.get('tocPN', '1')
709        # WTF?:
710        toc = int(pageinfo['tocPN'])
711        pageinfo['textPages'] =int(toc)
712       
713        # What does this do?
714        if 'tocSize_%s'%tocMode in docinfo:
715            tocSize = int(docinfo['tocSize_%s'%tocMode])
716            tocPageSize = int(pageinfo['tocPageSize'])
717            # cached toc           
718            if tocSize%tocPageSize>0:
719                tocPages=tocSize/tocPageSize+1
720            else:
721                tocPages=tocSize/tocPageSize
722               
723            pageinfo['tocPN'] = min(tocPages,toc)
724           
725        pageinfo['searchPN'] =self.REQUEST.get('searchPN','1')
726        return pageinfo
727
728
729    security.declareProtected('View management screens','changeDocumentViewerForm')   
730    changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
731   
732    def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None):
733        """init document viewer"""
734        self.title=title
735        self.digilibBaseUrl = digilibBaseUrl
736        self.thumbrows = thumbrows
737        self.thumbcols = thumbcols
738        self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
739        try:
740            # assume MetaDataFolder instance is called metadata
741            self.metadataService = getattr(self, 'metadata')
742        except Exception, e:
743            logging.error("Unable to find MetaDataFolder 'metadata': "+str(e))
744
745        if RESPONSE is not None:
746            RESPONSE.redirect('manage_main')
747       
748def manage_AddDocumentViewerForm(self):
749    """add the viewer form"""
750    pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
751    return pt()
752 
753def manage_AddDocumentViewer(self,id,imageScalerUrl="",textServerName="",title="",RESPONSE=None):
754    """add the viewer"""
755    newObj=documentViewer(id,imageScalerUrl=imageScalerUrl,title=title,textServerName=textServerName)
756    self._setObject(id,newObj)
757   
758    if RESPONSE is not None:
759        RESPONSE.redirect('manage_main')
760
761## DocumentViewerTemplate class
762class DocumentViewerTemplate(ZopePageTemplate):
763    """Template for document viewer"""
764    meta_type="DocumentViewer Template"
765
766
767def manage_addDocumentViewerTemplateForm(self):
768    """Form for adding"""
769    pt=PageTemplateFile('zpt/addDocumentViewerTemplate', globals()).__of__(self)
770    return pt()
771
772def manage_addDocumentViewerTemplate(self, id='viewer_main', title=None, text=None,
773                           REQUEST=None, submit=None):
774    "Add a Page Template with optional file content."
775
776    self._setObject(id, DocumentViewerTemplate(id))
777    ob = getattr(self, id)
778    txt=file(os.path.join(package_home(globals()),'zpt/viewer_main.zpt'),'r').read()
779    logging.info("txt %s:"%txt)
780    ob.pt_edit(txt,"text/html")
781    if title:
782        ob.pt_setTitle(title)
783    try:
784        u = self.DestinationURL()
785    except AttributeError:
786        u = REQUEST['URL1']
787       
788    u = "%s/%s" % (u, urllib.quote(id))
789    REQUEST.RESPONSE.redirect(u+'/manage_main')
790    return ''
791
792
793   
Note: See TracBrowser for help on using the repository browser.