source: documentViewer/documentViewer.py @ 471:415a7026eeda

elementtree
Last change on this file since 471:415a7026eeda was 471:415a7026eeda, checked in by casties, 13 years ago

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