source: documentViewer/documentViewer.py @ 466:1641be8dc6b5

elementtree
Last change on this file since 466:1641be8dc6b5 was 466:1641be8dc6b5, checked in by casties, 13 years ago

attribution works now
File size: 29.5 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            # attribution info
490            attribution = self.metadataService.getAttributionData(dom=metaDom)
491            if attribution:
492                logging.debug("getDocinfo: attribution=%s"%repr(attribution))
493                docinfo['attribution'] = attribution
494                #docinfo = self.getDocinfoFromAccess(docinfo, access)
495
496            # copyright info
497            copyright = self.metadataService.getCopyrightData(dom=metaDom)
498            if copyright:
499                logging.debug("getDocinfo: copyright=%s"%repr(copyright))
500                docinfo['copyright'] = copyright
501                #docinfo = self.getDocinfoFromAccess(docinfo, access)
502
503        # image path
504        if mode != 'texttool':
505            # override image path from texttool
506            docinfo['imagePath'] = url.replace('/mpiwg/online/', '', 1)
507
508        # number of images from digilib
509        if docinfo.get('imagePath', None):
510            docinfo['imageURL'] = self.digilibBaseUrl + "/servlet/Scaler?fn=" + docinfo['imagePath']
511            docinfo = self.getDocinfoFromDigilib(docinfo, docinfo['imagePath'])
512
513        logging.debug("documentViewer (getdocinfo) docinfo: keys=%s"%docinfo.keys())
514        #logging.debug("documentViewer (getdocinfo) docinfo: %s"%docinfo)
515        # store in session
516        self.REQUEST.SESSION['docinfo'] = docinfo
517        return docinfo
518
519    def getDocinfoFromResource(self, docinfo, resource):
520        """reads contents of resource element into docinfo"""
521        docName = resource.get('name', None)
522        docinfo['documentName'] = docName
523        docPath = resource.get('archive-path', None)
524        if docPath:
525            # clean up document path
526            if docPath[0] != '/':
527                docPath = '/' + docPath
528               
529            if docName and (not docPath.endswith(docName)):
530                docPath += "/" + docName
531           
532        else:
533            # use docUrl as docPath
534            docUrl = docinfo['documentURL']
535            if not docUrl.startswith('http:'):
536                docPath = docUrl
537        if docPath:
538            # fix URLs starting with /mpiwg/online
539            docPath = docPath.replace('/mpiwg/online', '', 1)
540
541        docinfo['documentPath'] = docPath
542        return docinfo
543
544    def getDocinfoFromTexttool(self, docinfo, texttool):
545        """reads contents of texttool element into docinfo"""
546        # image dir
547        imageDir = texttool.get('image', None)
548        docPath = docinfo.get('documentPath', None)
549        if imageDir and docPath:
550            #print "image: ", imageDir, " archivepath: ", archivePath
551            imageDir = os.path.join(docPath, imageDir)
552            imageDir = imageDir.replace('/mpiwg/online', '', 1)
553            docinfo['imagePath'] = imageDir
554       
555        # old style text URL
556        textUrl = texttool.get('text', None)
557        if textUrl and docPath:
558            if urlparse.urlparse(textUrl)[0] == "": #keine url
559                textUrl = os.path.join(docPath, textUrl) 
560           
561            docinfo['textURL'] = textUrl
562   
563        # new style text-url-path
564        textUrl = texttool.get('text-url-path', None)
565        if textUrl:
566            docinfo['textURLPath'] = textUrl
567            #TODO: ugly:
568            #textUrlkurz = string.split(textUrl, ".")[0]
569            #docinfo['textURLPathkurz'] = textUrlkurz
570           
571        # old presentation stuff
572        presentation = texttool.get('presentation', None)
573        if presentation and docPath:
574            if presentation.startswith('http:'):
575                docinfo['presentationUrl'] = presentation
576            else:
577                docinfo['presentationUrl'] = os.path.join(docPath, presentation)
578           
579        return docinfo
580
581    def getDocinfoFromBib(self, docinfo, bib):
582        """reads contents of bib element into docinfo"""
583        logging.debug("getDocinfoFromBib bib=%s"%repr(bib))
584        # put all raw bib fields in dict "bib"
585        docinfo['bib'] = bib
586        bibtype = bib.get('@type', None)
587        docinfo['bibType'] = bibtype
588        # also store DC metadata for convenience
589        dc = self.metadataService.getDCMappedData(bib)
590        docinfo['creator'] = dc.get('creator',None)
591        docinfo['title'] = dc.get('title',None)
592        docinfo['date'] = dc.get('date',None)
593        return docinfo
594           
595    def getDocinfoFromAccess(self, docinfo, acc):
596        """reads contents of access element into docinfo"""
597        #TODO: also read resource type
598        logging.debug("getDocinfoFromAccess acc=%s"%repr(acc))
599        try:
600            acctype = acc['@attr']['type']
601            if acctype:
602                access=acctype
603                if access in ['group', 'institution']:
604                    access = acc['name'].lower()
605               
606                docinfo['accessType'] = access
607
608        except:
609            pass
610       
611        return docinfo
612
613    def getDocinfoFromDigilib(self, docinfo, path):
614        infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path
615        # fetch data
616        txt = getHttpData(infoUrl)
617        if not txt:
618            logging.error("Unable to get dir-info from %s"%(infoUrl))
619            return docinfo
620
621        dom = ET.fromstring(txt)
622        size = getText(dom.find("size"))
623        logging.debug("getDocinfoFromDigilib: size=%s"%size)
624        if size:
625            docinfo['numPages'] = int(size)
626        else:
627            docinfo['numPages'] = 0
628           
629        # TODO: produce and keep list of image names and numbers
630        return docinfo
631           
632           
633    def getDocinfoFromPresentationInfoXml(self,docinfo):
634        """gets DC-like bibliographical information from the presentation entry in texttools"""
635        url = docinfo.get('presentationUrl', None)
636        if not url:
637            logging.error("getDocinfoFromPresentation: no URL!")
638            return docinfo
639       
640        dom = None
641        metaUrl = None
642        if url.startswith("http://"):
643            # real URL
644            metaUrl = url
645        else:
646            # online path
647           
648            server=self.digilibBaseUrl+"/servlet/Texter?fn="
649            metaUrl=server+url
650       
651        txt=getHttpData(metaUrl)
652        if txt is None:
653            logging.error("Unable to read info.xml from %s"%(url))
654            return docinfo
655           
656        dom = ET.fromstring(txt)
657        docinfo['creator']=getText(dom.find(".//author"))
658        docinfo['title']=getText(dom.find(".//title"))
659        docinfo['date']=getText(dom.find(".//date"))
660        return docinfo
661   
662
663    def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None, viewMode=None, tocMode=None):
664        """returns pageinfo with the given parameters"""
665        pageinfo = {}
666        current = getInt(current)
667   
668        pageinfo['current'] = current
669        rows = int(rows or self.thumbrows)
670        pageinfo['rows'] = rows
671        cols = int(cols or self.thumbcols)
672        pageinfo['cols'] = cols
673        grpsize = cols * rows
674        pageinfo['groupsize'] = grpsize
675        # what does this do?
676        start = getInt(start, default=(math.ceil(float(current)/float(grpsize))*grpsize-(grpsize-1)))
677        # int(current / grpsize) * grpsize +1))
678        pageinfo['start'] = start
679        pageinfo['end'] = start + grpsize
680        if (docinfo is not None) and ('numPages' in docinfo):
681            np = int(docinfo['numPages'])
682            pageinfo['end'] = min(pageinfo['end'], np)
683            pageinfo['numgroups'] = int(np / grpsize)
684            if np % grpsize > 0:
685                pageinfo['numgroups'] += 1
686               
687        pageinfo['viewMode'] = viewMode
688        pageinfo['tocMode'] = tocMode
689        pageinfo['characterNormalization'] = self.REQUEST.get('characterNormalization','reg')
690        #pageinfo['optionToggle'] = self.REQUEST.get('optionToggle','1')
691        pageinfo['query'] = self.REQUEST.get('query','') 
692        pageinfo['queryType'] = self.REQUEST.get('queryType','')
693        pageinfo['querySearch'] =self.REQUEST.get('querySearch', 'fulltext')
694        pageinfo['textPN'] = self.REQUEST.get('textPN','1')
695        pageinfo['highlightQuery'] = self.REQUEST.get('highlightQuery','')
696        pageinfo['tocPageSize'] = self.REQUEST.get('tocPageSize', '30')
697        pageinfo['queryPageSize'] =self.REQUEST.get('queryPageSize', '10')
698        pageinfo['tocPN'] = self.REQUEST.get('tocPN', '1')
699        # WTF?:
700        toc = int(pageinfo['tocPN'])
701        pageinfo['textPages'] =int(toc)
702       
703        # What does this do?
704        if 'tocSize_%s'%tocMode in docinfo:
705            tocSize = int(docinfo['tocSize_%s'%tocMode])
706            tocPageSize = int(pageinfo['tocPageSize'])
707            # cached toc           
708            if tocSize%tocPageSize>0:
709                tocPages=tocSize/tocPageSize+1
710            else:
711                tocPages=tocSize/tocPageSize
712               
713            pageinfo['tocPN'] = min(tocPages,toc)
714           
715        pageinfo['searchPN'] =self.REQUEST.get('searchPN','1')
716        pageinfo['sn'] =self.REQUEST.get('sn','')
717        return pageinfo
718
719
720    security.declareProtected('View management screens','changeDocumentViewerForm')   
721    changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
722   
723    def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None):
724        """init document viewer"""
725        self.title=title
726        self.digilibBaseUrl = digilibBaseUrl
727        self.thumbrows = thumbrows
728        self.thumbcols = thumbcols
729        self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
730        try:
731            # assume MetaDataFolder instance is called metadata
732            self.metadataService = getattr(self, 'metadata')
733        except Exception, e:
734            logging.error("Unable to find MetaDataFolder 'metadata': "+str(e))
735
736        if RESPONSE is not None:
737            RESPONSE.redirect('manage_main')
738       
739def manage_AddDocumentViewerForm(self):
740    """add the viewer form"""
741    pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
742    return pt()
743 
744def manage_AddDocumentViewer(self,id,imageScalerUrl="",textServerName="",title="",RESPONSE=None):
745    """add the viewer"""
746    newObj=documentViewer(id,imageScalerUrl=imageScalerUrl,title=title,textServerName=textServerName)
747    self._setObject(id,newObj)
748   
749    if RESPONSE is not None:
750        RESPONSE.redirect('manage_main')
751
752## DocumentViewerTemplate class
753class DocumentViewerTemplate(ZopePageTemplate):
754    """Template for document viewer"""
755    meta_type="DocumentViewer Template"
756
757
758def manage_addDocumentViewerTemplateForm(self):
759    """Form for adding"""
760    pt=PageTemplateFile('zpt/addDocumentViewerTemplate', globals()).__of__(self)
761    return pt()
762
763def manage_addDocumentViewerTemplate(self, id='viewer_main', title=None, text=None,
764                           REQUEST=None, submit=None):
765    "Add a Page Template with optional file content."
766
767    self._setObject(id, DocumentViewerTemplate(id))
768    ob = getattr(self, id)
769    txt=file(os.path.join(package_home(globals()),'zpt/viewer_main.zpt'),'r').read()
770    logging.info("txt %s:"%txt)
771    ob.pt_edit(txt,"text/html")
772    if title:
773        ob.pt_setTitle(title)
774    try:
775        u = self.DestinationURL()
776    except AttributeError:
777        u = REQUEST['URL1']
778       
779    u = "%s/%s" % (u, urllib.quote(id))
780    REQUEST.RESPONSE.redirect(u+'/manage_main')
781    return ''
782
783
784   
Note: See TracBrowser for help on using the repository browser.