source: documentViewer/documentViewer.py @ 467:8b75d55582e8

elementtree
Last change on this file since 467:8b75d55582e8 was 467:8b75d55582e8, checked in by casties, 13 years ago

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