Mercurial > hg > documentViewer
comparison documentViewer.py @ 2:8cc283757c39 modularisierung
New Version
author | abukhman |
---|---|
date | Mon, 14 Jun 2010 12:50:06 +0200 |
parents | 96f74b2bab24 |
children | e9085ba2bb51 |
comparison
equal
deleted
inserted
replaced
1:312446f900da | 2:8cc283757c39 |
---|---|
1 | |
2 genericDigilib="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/" | |
3 | 1 |
4 from OFS.Folder import Folder | 2 from OFS.Folder import Folder |
5 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate | 3 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate |
6 from Products.PageTemplates.PageTemplateFile import PageTemplateFile | 4 from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
5 from Products.PythonScripts.standard import url_quote | |
7 from AccessControl import ClassSecurityInfo | 6 from AccessControl import ClassSecurityInfo |
7 from AccessControl import getSecurityManager | |
8 from Globals import package_home | 8 from Globals import package_home |
9 | 9 |
10 from Ft.Xml.Domlette import NonvalidatingReader | 10 from Ft.Xml.Domlette import NonvalidatingReader |
11 from Ft.Xml.Domlette import PrettyPrint, Print | 11 from Ft.Xml.Domlette import PrettyPrint, Print |
12 from Ft.Xml import EMPTY_NAMESPACE | 12 from Ft.Xml import EMPTY_NAMESPACE, Parse |
13 | |
14 from xml.dom.minidom import parse, parseString | |
15 | |
16 from extraFunction import * | |
17 | |
13 | 18 |
14 import Ft.Xml.XPath | 19 import Ft.Xml.XPath |
15 | 20 import cStringIO |
21 import xmlrpclib | |
16 import os.path | 22 import os.path |
23 import sys | |
17 import cgi | 24 import cgi |
18 import urllib | 25 import urllib |
26 import logging | |
27 import math | |
28 | |
29 import urlparse | |
30 from types import * | |
31 | |
32 def logger(txt,method,txt2): | |
33 """logging""" | |
34 logging.info(txt+ txt2) | |
35 | |
36 | |
37 def getInt(number, default=0): | |
38 """returns always an int (0 in case of problems)""" | |
39 try: | |
40 return int(number) | |
41 except: | |
42 return int(default) | |
19 | 43 |
20 def getTextFromNode(nodename): | 44 def getTextFromNode(nodename): |
45 """get the cdata content of a node""" | |
46 if nodename is None: | |
47 return "" | |
21 nodelist=nodename.childNodes | 48 nodelist=nodename.childNodes |
22 rc = "" | 49 rc = "" |
23 for node in nodelist: | 50 for node in nodelist: |
24 if node.nodeType == node.TEXT_NODE: | 51 if node.nodeType == node.TEXT_NODE: |
25 rc = rc + node.data | 52 rc = rc + node.data |
26 return rc | 53 return rc |
27 | 54 |
55 def serializeNode(node, encoding='utf-8'): | |
56 """returns a string containing node as XML""" | |
57 buf = cStringIO.StringIO() | |
58 Print(node, stream=buf, encoding=encoding) | |
59 s = buf.getvalue() | |
60 buf.close() | |
61 return s | |
62 | |
63 | |
64 def getParentDir(path): | |
65 """returns pathname shortened by one""" | |
66 return '/'.join(path.split('/')[0:-1]) | |
67 | |
68 | |
28 import socket | 69 import socket |
29 | 70 |
30 def urlopen(url): | 71 def urlopen(url,timeout=2): |
31 """urlopen mit timeout""" | 72 """urlopen mit timeout""" |
32 socket.setdefaulttimeout(2) | 73 socket.setdefaulttimeout(timeout) |
33 ret=urllib.urlopen(url) | 74 ret=urllib.urlopen(url) |
34 socket.setdefaulttimeout(5) | 75 socket.setdefaulttimeout(5) |
35 return ret | 76 return ret |
36 | 77 |
37 def getParamFromDigilib(path,param): | 78 |
38 """gibt param von dlInfo aus""" | 79 ## |
39 imageUrl=genericDigilib+"/dlInfo-xml.jsp?fn="+path | 80 ## documentViewer class |
40 | 81 ## |
41 try: | 82 class documentViewer(Folder, extraFunction): |
42 dom = NonvalidatingReader.parseUri(imageUrl) | |
43 except: | |
44 return None | |
45 | |
46 | |
47 params=dom.xpath("//document-parameters/parameter[@name='%s']/@value"%param) | |
48 | |
49 if params: | |
50 return params[0].value | |
51 | |
52 def parseUrlTextTool(url): | |
53 """parse index meta""" | |
54 | |
55 try: | |
56 dom = NonvalidatingReader.parseUri(url) | |
57 except: | |
58 zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2]) | |
59 return (None,None,None) | |
60 | |
61 archivePaths=dom.xpath("//resource/archive-path") | |
62 | |
63 if archivePaths and (len(archivePaths)>0): | |
64 archivePath=getTextFromNode(archivePaths[0]) | |
65 else: | |
66 archivePath=None | |
67 | |
68 | |
69 images=dom.xpath("//texttool/image") | |
70 | |
71 if images and (len(images)>0): | |
72 image=getTextFromNode(images[0]) | |
73 else: | |
74 image=None | |
75 | |
76 if image and archivePath: | |
77 image=os.path.join(archivePath,image) | |
78 image=image.replace("/mpiwg/online",'') | |
79 pt=getParamFromDigilib(image,'pt') | |
80 | |
81 else: | |
82 image=None | |
83 | |
84 viewerUrls=dom.xpath("//texttool/digiliburlprefix") | |
85 | |
86 if viewerUrls and (len(viewerUrls)>0): | |
87 viewerUrl=getTextFromNode(viewerUrls[0]) | |
88 else: | |
89 viewerUrl=None | |
90 | |
91 | |
92 textUrls=dom.xpath("//texttool/text") | |
93 | |
94 if textUrls and (len(textUrls)>0): | |
95 textUrl=getTextFromNode(textUrls[0]) | |
96 else: | |
97 textUrl=None | |
98 return viewerUrl,(image,pt),textUrl | |
99 | |
100 | |
101 class documentViewer(ZopePageTemplate): | |
102 """document viewer""" | 83 """document viewer""" |
103 | 84 #textViewerUrl="http://127.0.0.1:8080/HFQP/testXSLT/getPage?" |
85 | |
104 meta_type="Document viewer" | 86 meta_type="Document viewer" |
105 | 87 |
106 security=ClassSecurityInfo() | 88 security=ClassSecurityInfo() |
107 manage_options=ZopePageTemplate.manage_options+( | 89 manage_options=Folder.manage_options+( |
108 {'label':'main config','action':'changeDocumentViewerForm'}, | 90 {'label':'main config','action':'changeDocumentViewerForm'}, |
109 ) | 91 ) |
110 | 92 |
111 _default_content_fn = os.path.join(package_home(globals()),'zpt','documentViewer_template.zpt') | 93 # templates and forms |
112 | 94 viewer_main = PageTemplateFile('zpt/viewer_main', globals()) |
113 def __init__(self,id,imageViewerUrl,title=""): | 95 toc_thumbs = PageTemplateFile('zpt/toc_thumbs', globals()) |
96 toc_text = PageTemplateFile('zpt/toc_text', globals()) | |
97 toc_figures = PageTemplateFile('zpt/toc_figures', globals()) | |
98 page_main_images = PageTemplateFile('zpt/page_main_images', globals()) | |
99 page_main_text = PageTemplateFile('zpt/page_main_text', globals()) | |
100 page_main_text_dict = PageTemplateFile('zpt/page_main_text_dict', globals()) | |
101 page_main_xml = PageTemplateFile('zpt/page_main_xml', globals()) | |
102 head_main = PageTemplateFile('zpt/head_main', globals()) | |
103 docuviewer_css = PageTemplateFile('css/docuviewer.css', globals()) | |
104 info_xml = PageTemplateFile('zpt/info_xml', globals()) | |
105 | |
106 | |
107 thumbs_main_rss = PageTemplateFile('zpt/thumbs_main_rss', globals()) | |
108 security.declareProtected('View management screens','changeDocumentViewerForm') | |
109 changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals()) | |
110 | |
111 | |
112 def __init__(self,id,imageScalerUrl=None,textServerName=None,title="",digilibBaseUrl=None,thumbcols=2,thumbrows=5,authgroups="mpiwg"): | |
114 """init document viewer""" | 113 """init document viewer""" |
115 self.id=id | 114 self.id=id |
116 self.title=title | 115 self.title=title |
117 self.imageViewerUrl=imageViewerUrl | 116 self.thumbcols = thumbcols |
118 | 117 self.thumbrows = thumbrows |
119 security.declareProtected('View management screens','changeDocumentViewerForm') | 118 # authgroups is list of authorized groups (delimited by ,) |
120 def changeDocumentViewerForm(self): | 119 self.authgroups = [s.strip().lower() for s in authgroups.split(',')] |
121 """change it""" | 120 # create template folder so we can always use template.something |
122 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeDocumentViewer.zpt')).__of__(self) | 121 |
123 return pt() | 122 templateFolder = Folder('template') |
123 #self['template'] = templateFolder # Zope-2.12 style | |
124 self._setObject('template',templateFolder) # old style | |
125 try: | |
126 from Products.XMLRpcTools.XMLRpcTools import XMLRpcServerProxy | |
127 xmlRpcClient = XMLRpcServerProxy(id='fulltextclient', serverUrl=textServerName, use_xmlrpc=False) | |
128 #templateFolder['fulltextclient'] = xmlRpcClient | |
129 templateFolder._setObject('fulltextclient',xmlRpcClient) | |
130 except Exception, e: | |
131 logging.error("Unable to create XMLRpcTools for fulltextclient: "+str(e)) | |
132 try: | |
133 from Products.zogiLib.zogiLib import zogiLib | |
134 zogilib = zogiLib(id="zogilib", title="zogilib for docuviewer", dlServerURL=imageScalerUrl, layout="book") | |
135 #templateFolder['zogilib'] = zogilib | |
136 templateFolder._setObject('zogilib',zogilib) | |
137 except Exception, e: | |
138 logging.error("Unable to create zogiLib for zogilib: "+str(e)) | |
139 | |
140 | |
141 security.declareProtected('View','thumbs_rss') | |
142 def thumbs_rss(self,mode,url,viewMode="auto",start=None,pn=1): | |
143 ''' | |
144 view it | |
145 @param mode: defines how to access the document behind url | |
146 @param url: url which contains display information | |
147 @param viewMode: if images display images, if text display text, default is images (text,images or auto) | |
148 | |
149 ''' | |
150 logging.debug("HHHHHHHHHHHHHH:load the rss") | |
151 logger("documentViewer (index)", logging.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn)) | |
152 | |
153 if not hasattr(self, 'template'): | |
154 # create template folder if it doesn't exist | |
155 self.manage_addFolder('template') | |
156 | |
157 if not self.digilibBaseUrl: | |
158 self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary" | |
159 | |
160 docinfo = self.getDocinfo(mode=mode,url=url) | |
161 pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo) | |
162 pt = getattr(self.template, 'thumbs_main_rss') | |
163 | |
164 if viewMode=="auto": # automodus gewaehlt | |
165 if docinfo.get("textURL",'') and self.textViewerUrl: #texturl gesetzt und textViewer konfiguriert | |
166 viewMode="text" | |
167 else: | |
168 viewMode="images" | |
169 | |
170 return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode) | |
124 | 171 |
172 security.declareProtected('View','index_html') | |
173 def index_html(self,url,mode="texttool",viewMode="auto",tocMode="thumbs",start=None,pn=1,mk=None, query=None, querySearch=None): | |
174 ''' | |
175 view it | |
176 @param mode: defines how to access the document behind url | |
177 @param url: url which contains display information | |
178 @param viewMode: if images display images, if text display text, default is auto (text,images or auto) | |
179 @param tocMode: type of 'table of contents' for navigation (thumbs, text, figures, none) | |
180 @param querySearch: type of different search modes (fulltext, fulltextMorph, xpath, xquery, ftIndex, ftIndexMorph, fulltextMorphLemma) | |
181 ''' | |
182 | |
183 logging.debug("documentViewer (index) mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn)) | |
184 | |
185 if not hasattr(self, 'template'): | |
186 # this won't work | |
187 logging.error("template folder missing!") | |
188 return "ERROR: template folder missing!" | |
189 | |
190 if not getattr(self, 'digilibBaseUrl', None): | |
191 self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary" | |
192 | |
193 docinfo = self.getDocinfo(mode=mode,url=url) | |
194 | |
195 | |
196 if tocMode != "thumbs": | |
197 # get table of contents | |
198 docinfo = self.getToc(mode=tocMode, docinfo=docinfo) | |
199 | |
200 if viewMode=="auto": # automodus gewaehlt | |
201 if docinfo.get("textURL",''): #texturl gesetzt und textViewer konfiguriert | |
202 viewMode="text_dict" | |
203 else: | |
204 viewMode="images" | |
205 | |
206 pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo,viewMode=viewMode,tocMode=tocMode) | |
207 | |
208 pt = getattr(self.template, 'viewer_main') | |
209 return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode,mk=self.generateMarks(mk)) | |
125 | 210 |
126 def changeDocumentViewer(self,imageViewerUrl,title="",RESPONSE=None): | 211 def generateMarks(self,mk): |
212 ret="" | |
213 if mk is None: | |
214 return "" | |
215 if type(mk) is not ListType: | |
216 mk=[mk] | |
217 for m in mk: | |
218 ret+="mk=%s"%m | |
219 return ret | |
220 | |
221 | |
222 def findDigilibUrl(self): | |
223 """try to get the digilib URL from zogilib""" | |
224 url = self.template.zogilib.getDLBaseUrl() | |
225 return url | |
226 | |
227 def getDocumentViewerURL(self): | |
228 """returns the URL of this instance""" | |
229 return self.absolute_url() | |
230 | |
231 def getStyle(self, idx, selected, style=""): | |
232 """returns a string with the given style and append 'sel' if path == selected.""" | |
233 #logger("documentViewer (getstyle)", logging.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style)) | |
234 if idx == selected: | |
235 return style + 'sel' | |
236 else: | |
237 return style | |
238 | |
239 def getLink(self,param=None,val=None): | |
240 """link to documentviewer with parameter param set to val""" | |
241 params=self.REQUEST.form.copy() | |
242 if param is not None: | |
243 if val is None: | |
244 if params.has_key(param): | |
245 del params[param] | |
246 else: | |
247 params[param] = str(val) | |
248 | |
249 if params.get("mode", None) == "filepath": #wenn beim erst Aufruf filepath gesetzt wurde aendere das nun zu imagepath | |
250 params["mode"] = "imagepath" | |
251 params["url"] = getParentDir(params["url"]) | |
252 | |
253 # quote values and assemble into query string | |
254 ps = "&".join(["%s=%s"%(k,urllib.quote(v)) for (k, v) in params.items()]) | |
255 url=self.REQUEST['URL1']+"?"+ps | |
256 return url | |
257 | |
258 def getLinkAmp(self,param=None,val=None): | |
259 """link to documentviewer with parameter param set to val""" | |
260 params=self.REQUEST.form.copy() | |
261 if param is not None: | |
262 if val is None: | |
263 if params.has_key(param): | |
264 del params[param] | |
265 else: | |
266 params[param] = str(val) | |
267 | |
268 # quote values and assemble into query string | |
269 logging.info("XYXXXXX: %s"%repr(params.items())) | |
270 ps = "&".join(["%s=%s"%(k,urllib.quote(v)) for (k, v) in params.items()]) | |
271 url=self.REQUEST['URL1']+"?"+ps | |
272 return url | |
273 | |
274 def getInfo_xml(self,url,mode): | |
275 """returns info about the document as XML""" | |
276 | |
277 if not self.digilibBaseUrl: | |
278 self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary" | |
279 | |
280 docinfo = self.getDocinfo(mode=mode,url=url) | |
281 pt = getattr(self.template, 'info_xml') | |
282 return pt(docinfo=docinfo) | |
283 | |
284 | |
285 def isAccessible(self, docinfo): | |
286 """returns if access to the resource is granted""" | |
287 access = docinfo.get('accessType', None) | |
288 logger("documentViewer (accessOK)", logging.INFO, "access type %s"%access) | |
289 if access is not None and access == 'free': | |
290 logger("documentViewer (accessOK)", logging.INFO, "access is free") | |
291 return True | |
292 elif access is None or access in self.authgroups: | |
293 # only local access -- only logged in users | |
294 user = getSecurityManager().getUser() | |
295 if user is not None: | |
296 #print "user: ", user | |
297 return (user.getUserName() != "Anonymous User") | |
298 else: | |
299 return False | |
300 | |
301 logger("documentViewer (accessOK)", logging.INFO, "unknown access type %s"%access) | |
302 return False | |
303 | |
304 | |
305 def getDirinfoFromDigilib(self,path,docinfo=None,cut=0): | |
306 """gibt param von dlInfo aus""" | |
307 num_retries = 3 | |
308 if docinfo is None: | |
309 docinfo = {} | |
310 | |
311 for x in range(cut): | |
312 | |
313 path=getParentDir(path) | |
314 | |
315 infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path | |
316 | |
317 logger("documentViewer (getparamfromdigilib)", logging.INFO, "dirInfo from %s"%(infoUrl)) | |
318 | |
319 for cnt in range(num_retries): | |
320 try: | |
321 # dom = NonvalidatingReader.parseUri(imageUrl) | |
322 txt=urllib.urlopen(infoUrl).read() | |
323 dom = Parse(txt) | |
324 break | |
325 except: | |
326 logger("documentViewer (getdirinfofromdigilib)", logging.ERROR, "error reading %s (try %d)"%(infoUrl,cnt)) | |
327 else: | |
328 raise IOError("Unable to get dir-info from %s"%(infoUrl)) | |
329 | |
330 sizes=dom.xpath("//dir/size") | |
331 logger("documentViewer (getparamfromdigilib)", logging.INFO, "dirInfo:size"%sizes) | |
332 | |
333 if sizes: | |
334 docinfo['numPages'] = int(getTextFromNode(sizes[0])) | |
335 else: | |
336 docinfo['numPages'] = 0 | |
337 | |
338 # TODO: produce and keep list of image names and numbers | |
339 | |
340 return docinfo | |
341 | |
342 | |
343 def getIndexMeta(self, url): | |
344 """returns dom of index.meta document at url""" | |
345 num_retries = 3 | |
346 dom = None | |
347 metaUrl = None | |
348 if url.startswith("http://"): | |
349 # real URL | |
350 metaUrl = url | |
351 else: | |
352 # online path | |
353 server=self.digilibBaseUrl+"/servlet/Texter?fn=" | |
354 metaUrl=server+url.replace("/mpiwg/online","") | |
355 if not metaUrl.endswith("index.meta"): | |
356 metaUrl += "/index.meta" | |
357 logging.debug("METAURL: %s"%metaUrl) | |
358 for cnt in range(num_retries): | |
359 try: | |
360 # patch dirk encoding fehler treten dann nicht mehr auf | |
361 # dom = NonvalidatingReader.parseUri(metaUrl) | |
362 txt=urllib.urlopen(metaUrl).read() | |
363 dom = Parse(txt) | |
364 break | |
365 except: | |
366 logger("ERROR documentViewer (getIndexMeta)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2]) | |
367 | |
368 if dom is None: | |
369 raise IOError("Unable to read index meta from %s"%(url)) | |
370 | |
371 return dom | |
372 | |
373 def getPresentationInfoXML(self, url): | |
374 """returns dom of info.xml document at url""" | |
375 num_retries = 3 | |
376 dom = None | |
377 metaUrl = None | |
378 if url.startswith("http://"): | |
379 # real URL | |
380 metaUrl = url | |
381 else: | |
382 # online path | |
383 server=self.digilibBaseUrl+"/servlet/Texter?fn=" | |
384 metaUrl=server+url.replace("/mpiwg/online","") | |
385 | |
386 for cnt in range(num_retries): | |
387 try: | |
388 # patch dirk encoding fehler treten dann nicht mehr auf | |
389 # dom = NonvalidatingReader.parseUri(metaUrl) | |
390 txt=urllib.urlopen(metaUrl).read() | |
391 dom = Parse(txt) | |
392 break | |
393 except: | |
394 logger("ERROR documentViewer (getPresentationInfoXML)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2]) | |
395 | |
396 if dom is None: | |
397 raise IOError("Unable to read infoXMLfrom %s"%(url)) | |
398 | |
399 return dom | |
400 | |
401 | |
402 def getAuthinfoFromIndexMeta(self,path,docinfo=None,dom=None,cut=0): | |
403 """gets authorization info from the index.meta file at path or given by dom""" | |
404 logger("documentViewer (getauthinfofromindexmeta)", logging.INFO,"path: %s"%(path)) | |
405 | |
406 access = None | |
407 | |
408 if docinfo is None: | |
409 docinfo = {} | |
410 | |
411 if dom is None: | |
412 for x in range(cut): | |
413 path=getParentDir(path) | |
414 dom = self.getIndexMeta(path) | |
415 | |
416 acctype = dom.xpath("//access-conditions/access/@type") | |
417 if acctype and (len(acctype)>0): | |
418 access=acctype[0].value | |
419 if access in ['group', 'institution']: | |
420 access = getTextFromNode(dom.xpath("//access-conditions/access/name")[0]).lower() | |
421 | |
422 docinfo['accessType'] = access | |
423 return docinfo | |
424 | |
425 | |
426 def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None,cut=0): | |
427 """gets bibliographical info from the index.meta file at path or given by dom""" | |
428 logging.debug("documentViewer (getbibinfofromindexmeta) path: %s"%(path)) | |
429 | |
430 if docinfo is None: | |
431 docinfo = {} | |
432 | |
433 if dom is None: | |
434 for x in range(cut): | |
435 path=getParentDir(path) | |
436 dom = self.getIndexMeta(path) | |
437 | |
438 logging.debug("documentViewer (getbibinfofromindexmeta cutted) path: %s"%(path)) | |
439 # put in all raw bib fields as dict "bib" | |
440 bib = dom.xpath("//bib/*") | |
441 if bib and len(bib)>0: | |
442 bibinfo = {} | |
443 for e in bib: | |
444 bibinfo[e.localName] = getTextFromNode(e) | |
445 docinfo['bib'] = bibinfo | |
446 | |
447 # extract some fields (author, title, year) according to their mapping | |
448 metaData=self.metadata.main.meta.bib | |
449 bibtype=dom.xpath("//bib/@type") | |
450 if bibtype and (len(bibtype)>0): | |
451 bibtype=bibtype[0].value | |
452 else: | |
453 bibtype="generic" | |
454 | |
455 bibtype=bibtype.replace("-"," ") # wrong typesiin index meta "-" instead of " " (not wrong! ROC) | |
456 docinfo['bib_type'] = bibtype | |
457 bibmap=metaData.generateMappingForType(bibtype) | |
458 # if there is no mapping bibmap is empty (mapping sometimes has empty fields) | |
459 if len(bibmap) > 0 and len(bibmap['author'][0]) > 0: | |
460 try: | |
461 docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['author'][0])[0]) | |
462 except: pass | |
463 try: | |
464 docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['title'][0])[0]) | |
465 except: pass | |
466 try: | |
467 docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['year'][0])[0]) | |
468 except: pass | |
469 logging.debug("documentViewer (getbibinfofromindexmeta) using mapping for %s"%bibtype) | |
470 try: | |
471 docinfo['lang']=getTextFromNode(dom.xpath("//bib/lang")[0]) | |
472 except: | |
473 docinfo['lang']='' | |
474 | |
475 return docinfo | |
476 | |
477 | |
478 def getDocinfoFromTextTool(self, url, dom=None, docinfo=None): | |
479 """parse texttool tag in index meta""" | |
480 logger("documentViewer (getdocinfofromtexttool)", logging.INFO, "url: %s" % (url)) | |
481 if docinfo is None: | |
482 docinfo = {} | |
483 if docinfo.get('lang', None) is None: | |
484 docinfo['lang'] = '' # default keine Sprache gesetzt | |
485 if dom is None: | |
486 dom = self.getIndexMeta(url) | |
487 | |
488 archivePath = None | |
489 archiveName = None | |
490 | |
491 archiveNames = dom.xpath("//resource/name") | |
492 if archiveNames and (len(archiveNames) > 0): | |
493 archiveName = getTextFromNode(archiveNames[0]) | |
494 else: | |
495 logger("documentViewer (getdocinfofromtexttool)", logging.WARNING, "resource/name missing in: %s" % (url)) | |
496 | |
497 archivePaths = dom.xpath("//resource/archive-path") | |
498 if archivePaths and (len(archivePaths) > 0): | |
499 archivePath = getTextFromNode(archivePaths[0]) | |
500 # clean up archive path | |
501 if archivePath[0] != '/': | |
502 archivePath = '/' + archivePath | |
503 if archiveName and (not archivePath.endswith(archiveName)): | |
504 archivePath += "/" + archiveName | |
505 else: | |
506 # try to get archive-path from url | |
507 logger("documentViewer (getdocinfofromtexttool)", logging.WARNING, "resource/archive-path missing in: %s" % (url)) | |
508 if (not url.startswith('http')): | |
509 archivePath = url.replace('index.meta', '') | |
510 | |
511 if archivePath is None: | |
512 # we balk without archive-path | |
513 raise IOError("Missing archive-path (for text-tool) in %s" % (url)) | |
514 | |
515 imageDirs = dom.xpath("//texttool/image") | |
516 if imageDirs and (len(imageDirs) > 0): | |
517 imageDir = getTextFromNode(imageDirs[0]) | |
518 | |
519 else: | |
520 # we balk with no image tag / not necessary anymore because textmode is now standard | |
521 #raise IOError("No text-tool info in %s"%(url)) | |
522 imageDir = "" | |
523 #xquery="//pb" | |
524 docinfo['imagePath'] = "" # keine Bilder | |
525 docinfo['imageURL'] = "" | |
526 | |
527 if imageDir and archivePath: | |
528 #print "image: ", imageDir, " archivepath: ", archivePath | |
529 imageDir = os.path.join(archivePath, imageDir) | |
530 imageDir = imageDir.replace("/mpiwg/online", '') | |
531 docinfo = self.getDirinfoFromDigilib(imageDir, docinfo=docinfo) | |
532 docinfo['imagePath'] = imageDir | |
533 | |
534 docinfo['imageURL'] = self.digilibBaseUrl + "/servlet/Scaler?fn=" + imageDir | |
535 | |
536 viewerUrls = dom.xpath("//texttool/digiliburlprefix") | |
537 if viewerUrls and (len(viewerUrls) > 0): | |
538 viewerUrl = getTextFromNode(viewerUrls[0]) | |
539 docinfo['viewerURL'] = viewerUrl | |
540 | |
541 textUrls = dom.xpath("//texttool/text") | |
542 if textUrls and (len(textUrls) > 0): | |
543 textUrl = getTextFromNode(textUrls[0]) | |
544 if urlparse.urlparse(textUrl)[0] == "": #keine url | |
545 textUrl = os.path.join(archivePath, textUrl) | |
546 # fix URLs starting with /mpiwg/online | |
547 if textUrl.startswith("/mpiwg/online"): | |
548 textUrl = textUrl.replace("/mpiwg/online", '', 1) | |
549 | |
550 docinfo['textURL'] = textUrl | |
551 | |
552 textUrls = dom.xpath("//texttool/text-url-path") | |
553 if textUrls and (len(textUrls) > 0): | |
554 textUrl = getTextFromNode(textUrls[0]) | |
555 docinfo['textURLPath'] = textUrl | |
556 if not docinfo['imagePath']: | |
557 # text-only, no page images | |
558 docinfo = self.getNumPages(docinfo) #im moment einfach auf eins setzen, navigation ueber die thumbs geht natuerlich nicht | |
559 | |
560 presentationUrls = dom.xpath("//texttool/presentation") | |
561 docinfo = self.getBibinfoFromIndexMeta(url, docinfo=docinfo, dom=dom) # get info von bib tag | |
562 | |
563 if presentationUrls and (len(presentationUrls) > 0): # ueberschreibe diese durch presentation informationen | |
564 # presentation url ergiebt sich ersetzen von index.meta in der url der fuer die Metadaten | |
565 # durch den relativen Pfad auf die presentation infos | |
566 presentationPath = getTextFromNode(presentationUrls[0]) | |
567 if url.endswith("index.meta"): | |
568 presentationUrl = url.replace('index.meta', presentationPath) | |
569 else: | |
570 presentationUrl = url + "/" + presentationPath | |
571 | |
572 docinfo = self.getBibinfoFromTextToolPresentation(presentationUrl, docinfo=docinfo, dom=dom) | |
573 | |
574 docinfo = self.getAuthinfoFromIndexMeta(url, docinfo=docinfo, dom=dom) # get access info | |
575 | |
576 return docinfo | |
577 | |
578 | |
579 def getBibinfoFromTextToolPresentation(self,url,docinfo=None,dom=None): | |
580 """gets the bibliographical information from the preseantion entry in texttools | |
581 """ | |
582 dom=self.getPresentationInfoXML(url) | |
583 try: | |
584 docinfo['author']=getTextFromNode(dom.xpath("//author")[0]) | |
585 except: | |
586 pass | |
587 try: | |
588 docinfo['title']=getTextFromNode(dom.xpath("//title")[0]) | |
589 except: | |
590 pass | |
591 try: | |
592 docinfo['year']=getTextFromNode(dom.xpath("//date")[0]) | |
593 except: | |
594 pass | |
595 return docinfo | |
596 | |
597 def getDocinfoFromImagePath(self,path,docinfo=None,cut=0): | |
598 """path ist the path to the images it assumes that the index.meta file is one level higher.""" | |
599 logger("documentViewer (getdocinfofromimagepath)", logging.INFO,"path: %s"%(path)) | |
600 if docinfo is None: | |
601 docinfo = {} | |
602 path=path.replace("/mpiwg/online","") | |
603 docinfo['imagePath'] = path | |
604 docinfo=self.getDirinfoFromDigilib(path,docinfo=docinfo,cut=cut) | |
605 | |
606 pathorig=path | |
607 for x in range(cut): | |
608 path=getParentDir(path) | |
609 logging.error("PATH:"+path) | |
610 imageUrl=self.digilibBaseUrl+"/servlet/Scaler?fn="+path | |
611 docinfo['imageURL'] = imageUrl | |
612 | |
613 #path ist the path to the images it assumes that the index.meta file is one level higher. | |
614 docinfo = self.getBibinfoFromIndexMeta(pathorig,docinfo=docinfo,cut=cut+1) | |
615 docinfo = self.getAuthinfoFromIndexMeta(pathorig,docinfo=docinfo,cut=cut+1) | |
616 return docinfo | |
617 | |
618 | |
619 def getDocinfo(self, mode, url): | |
620 """returns docinfo depending on mode""" | |
621 logger("documentViewer (getdocinfo)", logging.INFO,"mode: %s, url: %s"%(mode,url)) | |
622 # look for cached docinfo in session | |
623 if self.REQUEST.SESSION.has_key('docinfo'): | |
624 docinfo = self.REQUEST.SESSION['docinfo'] | |
625 # check if its still current | |
626 if docinfo is not None and docinfo.get('mode') == mode and docinfo.get('url') == url: | |
627 logger("documentViewer (getdocinfo)", logging.INFO,"docinfo in session: %s"%docinfo) | |
628 return docinfo | |
629 # new docinfo | |
630 docinfo = {'mode': mode, 'url': url} | |
631 if mode=="texttool": #index.meta with texttool information | |
632 docinfo = self.getDocinfoFromTextTool(url, docinfo=docinfo) | |
633 elif mode=="imagepath": | |
634 docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo) | |
635 elif mode=="filepath": | |
636 docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo,cut=1) | |
637 else: | |
638 logger("documentViewer (getdocinfo)", logging.ERROR,"unknown mode!") | |
639 raise ValueError("Unknown mode %s! Has to be one of 'texttool','imagepath','filepath'."%(mode)) | |
640 | |
641 logger("documentViewer (getdocinfo)", logging.INFO,"docinfo: %s"%docinfo) | |
642 self.REQUEST.SESSION['docinfo'] = docinfo | |
643 return docinfo | |
644 | |
645 def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None, viewMode=None, tocMode=None): | |
646 """returns pageinfo with the given parameters""" | |
647 pageinfo = {} | |
648 current = getInt(current) | |
649 pageinfo['current'] = current | |
650 rows = int(rows or self.thumbrows) | |
651 pageinfo['rows'] = rows | |
652 cols = int(cols or self.thumbcols) | |
653 pageinfo['cols'] = cols | |
654 grpsize = cols * rows | |
655 pageinfo['groupsize'] = grpsize | |
656 start = getInt(start, default=(math.ceil(float(current)/float(grpsize))*grpsize-(grpsize-1))) | |
657 # int(current / grpsize) * grpsize +1)) | |
658 pageinfo['start'] = start | |
659 pageinfo['end'] = start + grpsize | |
660 if (docinfo is not None) and ('numPages' in docinfo): | |
661 np = int(docinfo['numPages']) | |
662 pageinfo['end'] = min(pageinfo['end'], np) | |
663 pageinfo['numgroups'] = int(np / grpsize) | |
664 if np % grpsize > 0: | |
665 pageinfo['numgroups'] += 1 | |
666 pageinfo['viewMode'] = viewMode | |
667 pageinfo['tocMode'] = tocMode | |
668 pageinfo['query'] = self.REQUEST.get('query',' ') | |
669 pageinfo['queryType'] = self.REQUEST.get('queryType',' ') | |
670 pageinfo['querySearch'] =self.REQUEST.get('querySearch', 'fulltext') | |
671 pageinfo['textPN'] = self.REQUEST.get('textPN','1') | |
672 pageinfo['highlightQuery'] = self.REQUEST.get('highlightQuery','') | |
673 pageinfo['tocPageSize'] = self.REQUEST.get('tocPageSize', '30') | |
674 pageinfo['queryPageSize'] =self.REQUEST.get('queryPageSize', '10') | |
675 pageinfo['tocPN'] = self.REQUEST.get('tocPN', '1') | |
676 toc = int (pageinfo['tocPN']) | |
677 pageinfo['textPages'] =int (toc) | |
678 | |
679 if 'tocSize_%s'%tocMode in docinfo: | |
680 tocSize = int(docinfo['tocSize_%s'%tocMode]) | |
681 tocPageSize = int(pageinfo['tocPageSize']) | |
682 # cached toc | |
683 if tocSize%tocPageSize>0: | |
684 tocPages=tocSize/tocPageSize+1 | |
685 else: | |
686 tocPages=tocSize/tocPageSize | |
687 pageinfo['tocPN'] = min (tocPages,toc) | |
688 pageinfo['searchPN'] =self.REQUEST.get('searchPN','1') | |
689 pageinfo['sn'] =self.REQUEST.get('sn','') | |
690 return pageinfo | |
691 | |
692 def changeDocumentViewer(self,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=5,authgroups='mpiwg',RESPONSE=None): | |
127 """init document viewer""" | 693 """init document viewer""" |
128 self.title=title | 694 self.title=title |
129 self.imageViewerUrl=imageViewerUrl | 695 self.digilibBaseUrl = digilibBaseUrl |
130 | 696 self.thumbrows = thumbrows |
697 self.thumbcols = thumbcols | |
698 self.authgroups = [s.strip().lower() for s in authgroups.split(',')] | |
131 if RESPONSE is not None: | 699 if RESPONSE is not None: |
132 RESPONSE.redirect('manage_main') | 700 RESPONSE.redirect('manage_main') |
133 | 701 |
134 | |
135 def imageLink(self,nr): | |
136 """link hinter den images""" | |
137 paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING']) | |
138 params={} | |
139 for x in paramsTmp.iteritems(): | |
140 params[x[0]]=x[1][0] | |
141 | |
142 params['pn']=nr | |
143 newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params) | |
144 return newUrl | |
145 | |
146 | |
147 def thumbruler(self,cols,rows,start,maximum): | |
148 """ruler for thumbs""" | |
149 ret="" | |
150 paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING']) | |
151 params={} | |
152 for x in paramsTmp.iteritems(): | |
153 | |
154 if not x[0]=="start": | |
155 params[x[0]]=x[1][0] | |
156 | |
157 newUrlSelect=self.REQUEST['URL']+"?"+urllib.urlencode(params) | |
158 if start>0: | |
159 newStart=max(start-cols*rows,0) | |
160 params['start']=newStart | |
161 newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params) | |
162 ret+="""<a href="%s">prev</a>"""%newUrl | |
163 | |
164 | |
165 ret+="""<select onChange="location.href='%s&start='+this.options[this.selectedIndex].value" """%newUrlSelect | |
166 nr,rest=divmod(maximum,cols*rows) | |
167 if rest > 0: | |
168 nr+=1 | |
169 for i in range(nr): | |
170 nr=i*cols*rows | |
171 | |
172 if (start >= nr) and (start < nr+cols*rows): | |
173 ret+="""<option value="%s" selected>%s</option>"""%(nr,nr) | |
174 else: | |
175 ret+="""<option value="%s">%s</option>"""%(nr,nr) | |
176 ret+="</select>" | |
177 | |
178 if start<maximum: | |
179 newStart=min(start+cols*rows,maximum) | |
180 params['start']=newStart | |
181 newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params) | |
182 ret+="""<a href="%s">next</a>"""%newUrl | |
183 | |
184 return ret | |
185 | |
186 def textToolThumb(self,url,start=0): | |
187 """understands the texttool format | |
188 @param url: url to index.meta with texttool tag | |
189 """ | |
190 (viewerUrl,imagepath,textpath)=parseUrlTextTool(url) | |
191 | |
192 imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%imagepath[0] | |
193 | |
194 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self) | |
195 return pt(imageUrl=imageUrl,pt=imagepath[1],start=start) | |
196 | |
197 def text(self,mode,url,pn): | |
198 """give text""" | |
199 if mode=="texttool": #index.meta with texttool information | |
200 (viewerUrl,imagepath,textpath)=parseUrlTextTool(url) | |
201 | |
202 print textpath | |
203 try: | |
204 dom = NonvalidatingReader.parseUri(textpath) | |
205 except: | |
206 return None | |
207 | |
208 list=[] | |
209 nodes=dom.xpath("//pb") | |
210 | |
211 node=nodes[int(pn)-1] | |
212 | |
213 p=node | |
214 | |
215 while p.tagName!="p": | |
216 p=p.parentNode | |
217 | |
218 | |
219 endNode=nodes[int(pn)] | |
220 | |
221 | |
222 e=endNode | |
223 | |
224 while e.tagName!="p": | |
225 e=e.parentNode | |
226 | |
227 | |
228 next=node.parentNode | |
229 | |
230 #sammle s | |
231 while next and (next!=endNode.parentNode): | |
232 list.append(next) | |
233 next=next.nextSibling | |
234 list.append(endNode.parentNode) | |
235 | |
236 if p==e:# beide im selben paragraphen | |
237 | |
238 else: | |
239 next=p | |
240 while next!=e: | |
241 print next,e | |
242 list.append(next) | |
243 next=next.nextSibling | |
244 | |
245 for x in list: | |
246 PrettyPrint(x) | |
247 | |
248 return list | |
249 | |
250 def image(self,mode,url,pn): | |
251 """give image out""" | |
252 if mode=="texttool": #index.meta with texttool information | |
253 (viewerUrl,imagepath,textpath)=parseUrlTextTool(url) | |
254 url=viewerUrl+"pn=%s&fn=%s"%(pn,imagepath[0]) | |
255 ret="""<iframe height="100%%" width="100%%" src="%s"/>"""%url | |
256 return url | |
257 | |
258 def thumbs(self,mode,url,start): | |
259 """give thumbs out""" | |
260 if mode=="texttool": #index.meta with texttool information | |
261 return self.textToolThumb(url,int(start)) | |
262 | |
263 security.declareProtected('View','index_html') | |
264 | |
265 | |
266 def index_html(self,mode,url,start=0,pn=0): | |
267 ''' | |
268 view it | |
269 @param mode: defines which type of document is behind url | |
270 @param url: url which contains display information | |
271 ''' | |
272 | |
273 | |
274 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','documentViewer_template.zpt')).__of__(self) | |
275 return pt(mode=mode,url=url,start=start,pn=pn) | |
276 | |
277 | |
278 | |
279 # security.declareProtected('View management screens','renameImageForm') | |
280 | |
281 def manage_AddDocumentViewerForm(self): | 702 def manage_AddDocumentViewerForm(self): |
282 """add the viewer form""" | 703 """add the viewer form""" |
283 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addDocumentViewer.zpt')).__of__(self) | 704 pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self) |
284 return pt() | 705 return pt() |
285 | 706 |
286 def manage_AddDocumentViewer(self,id,imageViewerUrl="",title="",RESPONSE=None): | 707 def manage_AddDocumentViewer(self,id,imageScalerUrl="",textServerName="",title="",RESPONSE=None): |
287 """add the viewer""" | 708 """add the viewer""" |
288 newObj=documentViewer(id,imageViewerUrl,title) | 709 newObj=documentViewer(id,imageScalerUrl=imageScalerUrl,title=title,textServerName=textServerName) |
289 self._setObject(id,newObj) | 710 self._setObject(id,newObj) |
290 | 711 |
291 if RESPONSE is not None: | 712 if RESPONSE is not None: |
292 RESPONSE.redirect('manage_main') | 713 RESPONSE.redirect('manage_main') |
293 | 714 |
715 ## DocumentViewerTemplate class | |
716 class DocumentViewerTemplate(ZopePageTemplate): | |
717 """Template for document viewer""" | |
718 meta_type="DocumentViewer Template" | |
719 | |
720 | |
721 def manage_addDocumentViewerTemplateForm(self): | |
722 """Form for adding""" | |
723 pt=PageTemplateFile('zpt/addDocumentViewerTemplate', globals()).__of__(self) | |
724 return pt() | |
725 | |
726 def manage_addDocumentViewerTemplate(self, id='viewer_main', title=None, text=None, | |
727 REQUEST=None, submit=None): | |
728 "Add a Page Template with optional file content." | |
729 | |
730 self._setObject(id, DocumentViewerTemplate(id)) | |
731 ob = getattr(self, id) | |
732 txt=file(os.path.join(package_home(globals()),'zpt/viewer_main.zpt'),'r').read() | |
733 logging.info("txt %s:"%txt) | |
734 ob.pt_edit(txt,"text/html") | |
735 if title: | |
736 ob.pt_setTitle(title) | |
737 try: | |
738 u = self.DestinationURL() | |
739 except AttributeError: | |
740 u = REQUEST['URL1'] | |
741 | |
742 u = "%s/%s" % (u, urllib.quote(id)) | |
743 REQUEST.RESPONSE.redirect(u+'/manage_main') | |
744 return '' | |
745 | |
746 | |
747 |