source: documentViewer/documentViewer.py @ 465:224aad394350

elementtree
Last change on this file since 465:224aad394350 was 465:224aad394350, checked in by casties, 13 years ago

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