source: documentViewer/documentViewer.py @ 468:dc7c48912110

elementtree
Last change on this file since 468:dc7c48912110 was 468:dc7c48912110, checked in by casties, 13 years ago

attribution and copyright works mostly now
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",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.meta.getData(dom=metaDom, all=True, recursive=2)))
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           
569        # page flow
570        docinfo['pageFlow'] = texttool.get('page-flow', 'ltr')
571           
572        # odd pages are left
573        docinfo['oddPage'] = texttool.get('odd-scan-orientation', 'left')
574           
575        # number of title page
576        docinfo['titlePage'] = texttool.get('title-scan-no', 0)
577           
578        # old presentation stuff
579        presentation = texttool.get('presentation', None)
580        if presentation and docPath:
581            if presentation.startswith('http:'):
582                docinfo['presentationUrl'] = presentation
583            else:
584                docinfo['presentationUrl'] = os.path.join(docPath, presentation)
585           
586       
587        return docinfo
588
589    def getDocinfoFromBib(self, docinfo, bib):
590        """reads contents of bib element into docinfo"""
591        logging.debug("getDocinfoFromBib bib=%s"%repr(bib))
592        # put all raw bib fields in dict "bib"
593        docinfo['bib'] = bib
594        bibtype = bib.get('@type', None)
595        docinfo['bibType'] = bibtype
596        # also store DC metadata for convenience
597        dc = self.metadataService.getDCMappedData(bib)
598        docinfo['creator'] = dc.get('creator',None)
599        docinfo['title'] = dc.get('title',None)
600        docinfo['date'] = dc.get('date',None)
601        return docinfo
602           
603    def getDocinfoFromAccess(self, docinfo, acc):
604        """reads contents of access element into docinfo"""
605        #TODO: also read resource type
606        logging.debug("getDocinfoFromAccess acc=%s"%repr(acc))
607        try:
608            acctype = acc['@attr']['type']
609            if acctype:
610                access=acctype
611                if access in ['group', 'institution']:
612                    access = acc['name'].lower()
613               
614                docinfo['accessType'] = access
615
616        except:
617            pass
618       
619        return docinfo
620
621    def getDocinfoFromDigilib(self, docinfo, path):
622        infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path
623        # fetch data
624        txt = getHttpData(infoUrl)
625        if not txt:
626            logging.error("Unable to get dir-info from %s"%(infoUrl))
627            return docinfo
628
629        dom = ET.fromstring(txt)
630        size = getText(dom.find("size"))
631        logging.debug("getDocinfoFromDigilib: size=%s"%size)
632        if size:
633            docinfo['numPages'] = int(size)
634        else:
635            docinfo['numPages'] = 0
636           
637        # TODO: produce and keep list of image names and numbers
638        return docinfo
639           
640           
641    def getDocinfoFromPresentationInfoXml(self,docinfo):
642        """gets DC-like bibliographical information from the presentation entry in texttools"""
643        url = docinfo.get('presentationUrl', None)
644        if not url:
645            logging.error("getDocinfoFromPresentation: no URL!")
646            return docinfo
647       
648        dom = None
649        metaUrl = None
650        if url.startswith("http://"):
651            # real URL
652            metaUrl = url
653        else:
654            # online path
655           
656            server=self.digilibBaseUrl+"/servlet/Texter?fn="
657            metaUrl=server+url
658       
659        txt=getHttpData(metaUrl)
660        if txt is None:
661            logging.error("Unable to read info.xml from %s"%(url))
662            return docinfo
663           
664        dom = ET.fromstring(txt)
665        docinfo['creator']=getText(dom.find(".//author"))
666        docinfo['title']=getText(dom.find(".//title"))
667        docinfo['date']=getText(dom.find(".//date"))
668        return docinfo
669   
670
671    def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None, viewMode=None, tocMode=None):
672        """returns pageinfo with the given parameters"""
673        pageinfo = {}
674        current = getInt(current)
675   
676        pageinfo['current'] = current
677        rows = int(rows or self.thumbrows)
678        pageinfo['rows'] = rows
679        cols = int(cols or self.thumbcols)
680        pageinfo['cols'] = cols
681        grpsize = cols * rows
682        pageinfo['groupsize'] = grpsize
683        # what does this do?
684        start = getInt(start, default=(math.ceil(float(current)/float(grpsize))*grpsize-(grpsize-1)))
685        # int(current / grpsize) * grpsize +1))
686        pageinfo['start'] = start
687        pageinfo['end'] = start + grpsize
688        if (docinfo is not None) and ('numPages' in docinfo):
689            np = int(docinfo['numPages'])
690            pageinfo['end'] = min(pageinfo['end'], np)
691            pageinfo['numgroups'] = int(np / grpsize)
692            if np % grpsize > 0:
693                pageinfo['numgroups'] += 1
694               
695        pageinfo['viewMode'] = viewMode
696        pageinfo['tocMode'] = tocMode
697        pageinfo['characterNormalization'] = self.REQUEST.get('characterNormalization','reg')
698        #pageinfo['optionToggle'] = self.REQUEST.get('optionToggle','1')
699        pageinfo['query'] = self.REQUEST.get('query','') 
700        pageinfo['queryType'] = self.REQUEST.get('queryType','')
701        pageinfo['querySearch'] =self.REQUEST.get('querySearch', 'fulltext')
702        pageinfo['textPN'] = self.REQUEST.get('textPN','1')
703        pageinfo['highlightQuery'] = self.REQUEST.get('highlightQuery','')
704        pageinfo['tocPageSize'] = self.REQUEST.get('tocPageSize', '30')
705        pageinfo['queryPageSize'] =self.REQUEST.get('queryPageSize', '10')
706        pageinfo['tocPN'] = self.REQUEST.get('tocPN', '1')
707        # WTF?:
708        toc = int(pageinfo['tocPN'])
709        pageinfo['textPages'] =int(toc)
710       
711        # What does this do?
712        if 'tocSize_%s'%tocMode in docinfo:
713            tocSize = int(docinfo['tocSize_%s'%tocMode])
714            tocPageSize = int(pageinfo['tocPageSize'])
715            # cached toc           
716            if tocSize%tocPageSize>0:
717                tocPages=tocSize/tocPageSize+1
718            else:
719                tocPages=tocSize/tocPageSize
720               
721            pageinfo['tocPN'] = min(tocPages,toc)
722           
723        pageinfo['searchPN'] =self.REQUEST.get('searchPN','1')
724        pageinfo['sn'] =self.REQUEST.get('sn','')
725        return pageinfo
726
727
728    security.declareProtected('View management screens','changeDocumentViewerForm')   
729    changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
730   
731    def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None):
732        """init document viewer"""
733        self.title=title
734        self.digilibBaseUrl = digilibBaseUrl
735        self.thumbrows = thumbrows
736        self.thumbcols = thumbcols
737        self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
738        try:
739            # assume MetaDataFolder instance is called metadata
740            self.metadataService = getattr(self, 'metadata')
741        except Exception, e:
742            logging.error("Unable to find MetaDataFolder 'metadata': "+str(e))
743
744        if RESPONSE is not None:
745            RESPONSE.redirect('manage_main')
746       
747def manage_AddDocumentViewerForm(self):
748    """add the viewer form"""
749    pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
750    return pt()
751 
752def manage_AddDocumentViewer(self,id,imageScalerUrl="",textServerName="",title="",RESPONSE=None):
753    """add the viewer"""
754    newObj=documentViewer(id,imageScalerUrl=imageScalerUrl,title=title,textServerName=textServerName)
755    self._setObject(id,newObj)
756   
757    if RESPONSE is not None:
758        RESPONSE.redirect('manage_main')
759
760## DocumentViewerTemplate class
761class DocumentViewerTemplate(ZopePageTemplate):
762    """Template for document viewer"""
763    meta_type="DocumentViewer Template"
764
765
766def manage_addDocumentViewerTemplateForm(self):
767    """Form for adding"""
768    pt=PageTemplateFile('zpt/addDocumentViewerTemplate', globals()).__of__(self)
769    return pt()
770
771def manage_addDocumentViewerTemplate(self, id='viewer_main', title=None, text=None,
772                           REQUEST=None, submit=None):
773    "Add a Page Template with optional file content."
774
775    self._setObject(id, DocumentViewerTemplate(id))
776    ob = getattr(self, id)
777    txt=file(os.path.join(package_home(globals()),'zpt/viewer_main.zpt'),'r').read()
778    logging.info("txt %s:"%txt)
779    ob.pt_edit(txt,"text/html")
780    if title:
781        ob.pt_setTitle(title)
782    try:
783        u = self.DestinationURL()
784    except AttributeError:
785        u = REQUEST['URL1']
786       
787    u = "%s/%s" % (u, urllib.quote(id))
788    REQUEST.RESPONSE.redirect(u+'/manage_main')
789    return ''
790
791
792   
Note: See TracBrowser for help on using the repository browser.