1: import urlparse
2: import string
3: import tempfile
4: import zipfile
5: import re
6: import os,shutil
7: import OFS.Image
8: from types import *
9: from OFS.Cache import Cacheable
10: from OFS.Image import Image
11: from Globals import DTMLFile
12: from OFS.Folder import Folder
13: from OFS.SimpleItem import SimpleItem
14: from AccessControl import ClassSecurityInfo
15: from AccessControl.User import UserFolder
16: from Globals import InitializeClass
17: from Globals import DTMLFile
18: import Globals
19: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
20: from Products.PageTemplates.PageTemplate import PageTemplate
21: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate,manage_addPageTemplate
22: from Globals import Persistent, package_home
23: from Acquisition import Implicit
24: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
25: from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
26: from Products.MetaDataProvider.MetaDataClient import MetaDataClient
27: import urllib
28: import urllib2
29: import cgi
30: import smtplib
31: import time
32: from Ft.Xml.Domlette import NonvalidatingReader
33: from Ft.Xml.Domlette import PrettyPrint, Print
34: from Ft.Xml import EMPTY_NAMESPACE
35:
36: import Ft.Xml.XPath
37: import cStringIO
38:
39: import sys
40:
41: try:
42: from psycopg import libpq
43: except:
44: try:
45: from pyPgSQL import libpq
46: except:
47: print "ECHO_collection: Warning - No libpq imported!"
48:
49: import xml.dom.minidom
50:
51: import urllib
52: import xml.dom.minidom
53: import ECHO_helpers
54: from ECHO_helpers import *
55:
56:
57: from ECHO_movie import *
58: import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
59: import xmlrpclib
60:
61: import logging
62:
63: class ECHO_resource(CatalogAware,Folder,Persistent,ECHO_basis):
64: """ECHO Ressource"""
65: security=ClassSecurityInfo()
66: meta_type='ECHO_resource'
67: default_catalog='resourceCatalog'
68:
69: # viewClassificationList=viewClassificationListMaster
70:
71: def PrincipiaSearchSource(self):
72: """Return cataloguable key for ourselves."""
73: return str(self)
74:
75: getSubCols = ECHO_helpers.getSubCols
76:
77: def index_meta(self,RESPONSE=None):
78: """ gibt das im metalink gespeicher xml-file zurueck"""
79: url = self.metalink
80: txt=""
81: logging.debug("ml:%s"%url)
82: try:
83: page = urllib.urlopen(url);
84: if RESPONSE:
85: RESPONSE.setHeader("Content-Type","text/xml")
86:
87: txt = page.read();
88: except:
89: logging.error("Cannot read metadata of: %s"%self.getId())
90:
91: return txt
92:
93: def reindex(self):
94: """generate fields for indexing and reindex"""
95:
96: #TODO: korrigieren des metalink pfades konfigurierbar machen
97: splitted= [x for x in urlparse.urlparse(self.metalink)]
98: splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
99:
100: if splitted[0]=="http":
101: self.metalink=urlparse.urlunparse(splitted)
102:
103:
104: self.fullTextUrl=self.getFullTextXML(noredirect="yes")
105:
106: #TODO: korrigieren relative url to absoluter url volltexten, konfigurierbar?
107: splitted= [x for x in urlparse.urlparse(self.fullTextUrl)]
108: if splitted[0]=="":
109: splitted[0]="http"
110: splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
111:
112: self.fullTextUrl=urlparse.urlunparse(splitted)
113:
114: self.imagePath=self.getImagePath()
115:
116: self.reindex_object()
117:
118:
119: security.declareProtected('View','createPDF')
120: def createPDF(self,RESPONSE=None,local=None,dpi=150):
121: """erzeuge pdf file"""
122: pages=1
123: dpi=float(dpi)
124: imagePath=self.getImagePath().replace("/mpiwg/online","")
125:
126:
127: image="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn="+imagePath+"&dw=%i&dh=%i&pn=%i"
128: xmlInfo="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/dlInfo-xml.jsp?fn="+imagePath
129:
130: dom=xml.dom.minidom.parse(urllib.urlopen(xmlInfo))
131: for parameter in dom.getElementsByTagName('parameter'):
132: if parameter.getAttribute('name')=="pt":
133: pages=int(parameter.getAttribute('value'))
134: break
135:
136:
137: tempdir="/tmp/archivesImageServer"
138: if not os.path.exists(tempdir):
139: os.mkdir(tempdir)
140:
141: tmpPath=tempfile.mkdtemp(dir=tempdir)
142:
143:
144: tmpZip=tempfile.mktemp(dir=tempdir)
145:
146: tmpFn=os.path.split(tmpZip)[1]
147:
148:
149:
150:
151: if RESPONSE:
152: RESPONSE.setHeader("Content-Type","text/html")
153: RESPONSE.write("<h1>I am creating the pdf</h1>")
154: txt="<h3>1. step: getting the images( %i pages)</h3>"%pages
155: RESPONSE.write(txt)
156:
157: c=canvas.Canvas(tmpZip)
158: for i in range(1,pages+1):
159: if RESPONSE:
160: RESPONSE.write(str("<p>Get Page: %i<br>\n"%i))
161: faktor=dpi/72.0
162:
163: fn=tmpPath+"/%i"%i
164:
165: width,height=A4
166: #print image%(width*faktor,height*faktor,i)
167: url=urllib.urlopen(image%(width*faktor,height*faktor,i)).read()
168: fh=file(fn,"w")
169: fh.write(url)
170: fh.close()
171:
172:
173:
174: c.drawImage(fn,0,0,width=width,height=height)
175: c.showPage()
176: c.save()
177: if RESPONSE:
178: RESPONSE.write("<p>finished<br>\n")
179:
180: if RESPONSE:
181: len=os.stat(tmpZip)[6]
182: downloadUrl=self.absolute_url()+"/downloadPDF"
183: RESPONSE.write("""<h1><a href="downloadPDF?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
184: RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>
185: <p><a href="downloadPDF?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))
186: RESPONSE.close()
187:
188:
189: def downloadPDF(self,fn):
190: """download prepared set"""
191: filename="/tmp/archivesImageServer/"+fn
192: namePDF=self.getId()+".pdf"
193: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%namePDF)
194: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
195: len=os.stat(filename)[6]
196: self.REQUEST.RESPONSE.setHeader("Content-Length",len)
197: images=file(filename).read()
198: self.REQUEST.RESPONSE.write(images)
199: self.REQUEST.RESPONSE.close()
200:
201:
202: def getRDF(self,urn=None):
203: """rdf"""
204: ret=getRDFDescription(self,self.link,urn=urn)
205: return ret+self.createSubElementRDF(urn=urn)
206:
207:
208: def changeAccessRightForm(self,preselect=None):
209: """change the access rights"""
210:
211: pt=zptFile(self, 'zpt/ChangeECHO_resourceAccessRight.zpt')
212: return pt(preselect=preselect)
213:
214: def changeAccessRight(self):
215: """changeRights"""
216: argv=self.REQUEST.form
217: self.setAccessRightXML(argv["%s_xml"%self.getId()])
218: self.accessRight=argv["%s_echo"%self.getId()]
219:
220: self.REQUEST.RESPONSE.redirect('manage_main')
221:
222:
223: def getAccessRightSelectorHTML(self,outlook="select",xmldominant=None,preselect=None):
224: """htmlselector, xmldominant= in der regel wird der wert des xmlfiles ausgegeben ausser er existiert nicht"""
225: values=['','free','MPIWG']
226:
227: if preselect:#set all to the preselected
228: ar=(preselect,preselect)
229: else:#else set to actual value
230: ar=self.getAccessRightMD()
231:
232: if outlook=="select":
233: ret="""<select name="%s_xml">"""%self.getId()
234: ret1="""<select name="%s_echo">"""%self.getId()
235: for value in values:
236: if value==ar[0]:
237: ret+="<option selected>%s</option>"%value
238: else:
239: ret+="<option>%s</option>"%value
240:
241: if value==ar[1]:
242: ret1+="<option selected>%s</option>"%value
243: else:
244: ret1+="<option>%s</option>"%value
245:
246:
247: if not xmldominant:
248: return ret+"</select>",ret1+"</select>"
249: else:
250: if ar[0] is not None:
251: return ret+"</select>"
252: else:
253: return "<p>No xml file (only local selection):"+ret1
254:
255: else:
256: ret=""
257: ret1=""
258: for value in values:
259:
260: if value==ar[0]:
261: ret+="""<input type="radio" name="%s_xml" value="%s" checked>%s"""%(self.getId(),value,value)
262: else:
263: ret+="""<input type="radio" name="%s_xml" value="%s">%s"""%(self.getId(),value,value)
264:
265: if value==ar[1]:
266: ret1+="""<input type="radio" name="%s_echo" value="%s" checked>%s"""%(self.getId(),value,value)
267: else:
268: ret1+="""<input type="radio" name="%s_echo" value="%s">%s"""%(self.getId(),value,value)
269:
270: if not xmldominant:
271: return ret,ret1
272: else:
273: if ar[0]:
274: return ret
275: else:
276: return "<p>No xml file (only local selection)</p>"+ret1
277:
278:
279:
280: def copyAccessRightsFromMD(self):
281: """kopiere rechte aus den metadaten"""
282: self.accessRight=self.getAccessRightMD()[0]
283:
284:
285:
286:
287:
288: def getAccessRightMD(self):
289: """set accessright"""
290: url=self.metalink
291:
292: try:
293: urllib.urlopen(url)
294: except:
295: logger("ECHO_Resource (getAccessRightMD)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
296:
297: return None,getattr(self,'accessRight','')
298:
299:
300: try:
301: dom = NonvalidatingReader.parseUri(url)
302: except:
303: logger("ECHO_Resource (getAccessRightMD)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
304: return (None,"Cannot parse: "+url+"<br>"+"%s (%s)"%sys.exc_info()[0:2])
305:
306:
307: accessright=dom.xpath("//meta/access-conditions/access/@type")
308: if accessright:
309: accessright=accessright[0].value
310: if str(accessright)=='institution':
311: tmp=dom.xpath("//meta/access-conditions/access/name")
312: if tmp:
313: accessright=getTextFromNode(tmp[0])
314:
315: if not accessright:
316: accessright=""
317:
318: return accessright,getattr(self,'accessRight','')
319:
320: def changeAccessRightMD(self,accessright,RESPONSE=None):
321: """change the rights - not user anymore"""
322: #TODO: check if method still needed
323: params="accessright=%s"%accessright
324:
325:
326: #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()
327:
328: tries=0
329: for i in range(10):
330: x=ECHO_helpers.urlopen('http://echo.mpiwg-berlin.mpg.de/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/setAccessRightXML'+urllib.quote('?'+params))).read()
331: if x=="ok":
332:
333: break;
334:
335:
336:
337: if RESPONSE is not None:
338: RESPONSE.redirect('manage_main')
339:
340:
341: def setAccessRightXML(self,accessright):
342: """set accessright"""
343: url=self.metalink
344: accessrights=['MPIWG','free']#allowes rights
345:
346: if accessright =='':
347: """do nothing"""
348: return ""
349:
350:
351: try:
352: geturl=""
353: for line in ECHO_helpers.urlopen(url).readlines():
354: geturl=geturl+line
355:
356:
357: except:
358: return (None,"Cannot open: "+url)
359:
360: try:
361: dom=xml.dom.minidom.parseString(geturl)
362: root=dom.getElementsByTagName('resource')[0]
363: except:
364: return (None,"Cannot parse: "+url+"<br>"+geturl)
365:
366: metamains=dom.getElementsByTagName('meta')
367:
368: if not metamains:
369: nodenew=dom.createElement('meta')
370: root.appendChild(nodenew)
371: metamain=nodenew
372: else:
373: metamain=metamains[0]
374:
375:
376: metanodes=metamain.getElementsByTagName('access-conditions')
377:
378: if not metanodes:
379: nodenew=dom.createElement('access-conditions')
380: metamain.appendChild(nodenew)
381: metanode=nodenew
382: else:
383: metanode=metanodes[0]
384:
385: accesses=metanode.getElementsByTagName('access')
386:
387: #delete old
388: if accesses:
389: metanode.removeChild(accesses[0]).unlink()
390:
391: #create new
392:
393: nodenew2=dom.createElement('access')
394: metanode.appendChild(nodenew2)
395: metanode2=nodenew2
396:
397: attribute=metanode2.getAttribute('type')
398:
399: if accessright=="free":
400:
401: metanode2.setAttribute('type','free')
402:
403: elif accessright.upper()=='MPIWG':
404: metanode2.setAttribute('type','institution')
405: nodenew4=dom.createElement('name')
406: metanodetext=dom.createTextNode('MPIWG')
407: nodenew4.appendChild(metanodetext)
408: nodenew2.appendChild(nodenew4)
409: #print dom.toxml().encode('utf-8')
410: string= encodeRPC(dom.toxml().encode('utf-8'))
411:
412: #TODO: make server configurable
413: server=xmlrpclib.Server("http://foxridge.mpiwg-berlin.mpg.de/server")
414:
415: path=urlparse.urlparse(self.metalink)[2]
416:
417: server.writeMetaDataFile(path,string,"yes")
418:
419: def setStartPageForm(self):
420: """Form for changing the startpage"""
421:
422:
423: pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPage.zpt')
424: pt.content_type="text/html"
425: return pt()
426:
427:
428: def createImageUrl(self,pn=1):
429: """create ImageUrl"""
430:
431:
432: resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
433:
434: digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
435: images=readFieldFromXML(self.metalink,'texttool','image')
436:
437:
438: if (not resourcepath) or (not digiliburlprefix) or (not images):
439: logger("ECHO (createImageUrl)",logging.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())
440: return None
441: resourcepath=resourcepath.replace('/mpiwg/online','')
442: if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"
443:
444: if (not images) or (not resourcepath): return None
445:
446: return "%sfn=%s&pn=%i"%(digiliburlprefix,resourcepath+"/"+images,pn)
447:
448: def copyTitleToInfoXML(self,RESPONSE=None):
449: """copy title from the resource"""
450: presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')
451: resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
452: if (not presentationXML) or (not resourcepath):
453: if RESPONSE:
454: RESPONSE.write("Error: %s\n"%self.getId())
455: else:
456: return None,self.absolute_url()
457:
458: try:
459: fh=file(os.path.join(resourcepath,presentationXML),'w')
460: fh.write("""<info>
461: <author></author>
462: <title>%s</title>
463: <date></date>
464: <display>yes</display>
465: </info>"""%self.title)
466: fh.close()
467: return 1,self.getId()
468: except:
469: if RESPONSE:
470: RESPONSE.write("Error: %s\n"%self.getId())
471: else:
472: return None,self.absolute_url()
473:
474:
475: def setStartPage(self,startpage=None,RESPONSE=None):
476: """set start page, if no startpage defined use the generic one of the resource"""
477:
478: if (not (type(startpage)==StringType)):
479: if ("__generic" in startpage): # checke ob generic in der liste
480: startpage=self.absolute_url()+"/startpage_html"
481: elif ("__firstPage" in startpage): # checke ob generic in der liste
482: startpage=self.createImageUrl()
483:
484: if (not startpage):
485: startpage=self.absolute_url()+"/startpage_html"
486: elif (startpage=="__generic"):
487: startpage=self.absolute_url()+"/startpage_html"
488: elif (startpage=="__firstPage"):
489: startpage=self.createImageUrl()
490:
491: params="startpage=%s"%startpage
492: #print 'http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))
493:
494: tries=0
495: for i in range(10):
496: x=ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()
497: if x=="ok":
498:
499: break;
500:
501:
502: path=self.metalink
503:
504: path=re.sub(self.REQUEST['SERVER_URL'],'',path)
505: path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
506:
507: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
508: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
509: path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
510: path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
511: path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
512: path=re.sub('http://vision.mpiwg-berlin.mpg.de','',path) # falls vision als server
513: path=re.sub('http://xserve02.mpiwg-berlin.mpg.de:18880','',path) # falls vision als server
514: path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
515: path=re.sub('/index.meta','',path)
516:
517:
518: ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
519:
520: if RESPONSE is not None:
521: RESPONSE.redirect('manage_main')
522:
523: def changeViewerTemplateSetForm(self):
524: """change the viewer template set"""
525: pt=zptFile(self, 'zpt/changeResourceViewerTemplateSet')
526: return pt()
527:
528:
529: def setLink(self, link=None):
530: """change link field"""
531: if link is not None:
532: self.link = link
533:
534:
535: def getTextToolsField(self,name,default=''):
536: """Lese Textoolsfelder aus index.meta im path aus"""
537:
538: try:
539: dom=xml.dom.minidom.parse(self.metalink)
540: node=dom.getElementsByTagName('texttool')[0] #getNode
541: subnode=node.getElementsByTagName(name)[0]
542:
543: # bei text wird nur der Folder gebraucht
544: if name=="text":
545: splitted=getText(subnode.childNodes).split("/")
546: return splitted[len(splitted)-2]
547: else:
548: return getText(subnode.childNodes)
549: except:
550: return default
551:
552:
553: def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
554: """changeit"""
555:
556: paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']
557:
558:
559: #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)
560:
561: params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
562:
563: try:
564: tries=0
565: for i in range(10):
566: x=ECHO_helpers.urlopen('http://echo.mpiwg-berlin.mpg.de/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()
567: if x=="ok":
568:
569: break;
570:
571: except:
572: logger("ECHO_ressource (changeViewerTemplateSet)", logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
573: logger("ECHO_ressource (changeViewerTemplateSet)", logging.ERROR,'http://echo.mpiwg-berlin.mpg.de/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params)))
574: #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
575: # hack Pfad auf die Dokumente
576: path=self.metalink
577:
578:
579:
580: path=re.sub('/index.meta','',path)
581:
582: #TODO: direct access to the file system necessary, fix that also xmlrpc to the server where the index file is stored is possible
583: parsedUrl=urlparse.urlparse(path)
584: path=parsedUrl[2]
585:
586: try:
587: return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
588: except:
589: logger("ECHO_Resource (changeViewerTemplateSet)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
590: logger("ECHO_Resource (changeViewerTemplateSet)", logging.INFO,"http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path)
591:
592: if RESPONSE is not None:
593: RESPONSE.redirect('manage_main')
594:
595:
596:
597: security.declarePublic('content_html')
598: def content_html(self):
599: """template fuer content"""
600: return ECHO_basis.content_html(self,'resource')
601:
602: # def getViewClassification(self):
603: # if hasattr(self,'viewClassification'):
604: # return self.viewClassification
605: # else:
606: # return ""
607:
608: def getFullTextXML(self,noredirect=None):
609: """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
610:
611: try:
612: #logger("ECHO Fulltext",logging.INFO,"open %s"%self.metalink)
613: fh=ECHO_helpers.urlopen(self.metalink)
614: #logger("ECHO Fulltext",logging.INFO,"opened %s"%self.metalink)
615: dom=xml.dom.minidom.parse(fh)
616: texttools=dom.getElementsByTagName('texttool')
617: text=texttools[0].getElementsByTagName('text')
618: texturl=getText(text[0].childNodes)
619:
620: #logger("ECHO Fulltext",logging.INFO,"found %s"%texturl)
621: fh.close()
622: #logger("ECHO Fulltext",logging.INFO,"closed fh")
623: #keine url
624: if not (texturl.split(":")[0] in ['http','ftp','file']):
625: if not noredirect:
626: return file(texturl).read()
627: else:
628: return texturl
629:
630: if not noredirect:
631: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
632: logger("ECHO Fulltext",logging.INFO,"redirect to:%s"%texturl)
633: self.REQUEST.RESPONSE.redirect(texturl)
634: else:
635: return texturl
636: except:
637:
638: if not noredirect:
639: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
640: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
641: else:
642: return "<error>no fulltext available</error>"
643:
644: def getImagePath(self):
645: """gibt pfad zum image aus"""
646: return self.getImageView(noredirect="yes",onlyPath="yes")
647:
648: def getImageView(self,noredirect=None,onlyPath=None):
649: """getImages; give Imageviewr and <error></error> if somthing goes wrong."""
650: try:
651: fh=ECHO_helpers.urlopen(self.metalink)
652: dom=xml.dom.minidom.parse(fh)
653: texttools=dom.getElementsByTagName('texttool')
654: text=texttools[0].getElementsByTagName('image')
655: imagetemp=getText(text[0].childNodes)
656:
657: text=dom.getElementsByTagName('archive-path')
658: archivepath=getText(text[0].childNodes)
659: archivepath=re.sub('/mpiwg/online/','',archivepath)
660: imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
661: fh.close()
662:
663: if not noredirect:
664: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
665: self.REQUEST.RESPONSE.redirect(imageurl)
666: else:
667: if not onlyPath:
668: return imageurl
669: else:
670: return archivepath+"/"+imagetemp
671: except:
672:
673: if not noredirect:
674: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
675: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
676: else:
677: return "<error>no images available</error>"
678:
679:
680: def getCopyrightsHTML(self):
681: """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
682:
683: if hasattr(self,'copyrightModel'):
684: obj=self.copyrightModel
685:
686: else:
687: return "ERROR"
688: ret=[]
689:
690: for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
691:
692:
693: try:
694: if hasattr(self.copyrightTypes,copyright[2]):
695: copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
696: link="copyrightTypes/"+copyright[2]+'/copyright.html'
697: else:
698: copyrightTypeObj=getattr(obj,copyright[2])
699: link="copyrightModel/"+copyright[2]+'/copyright.html'
700:
701: label=copyrightTypeObj.label
702: url=getattr(copyrightTypeObj, 'url', '')
703:
704: if url!='':
705: ret.append((url,copyright[0],copyright[1],copyright[2],label))
706: else:
707: if hasattr(copyrightTypeObj, 'copyright.html'):
708: ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
709: else:
710: ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
711: except:
712: """nothing"""
713:
714: return ret
715:
716: def getInstitutionsHTML(self):
717: """gibt Liste der foerdernden Institutionen aus"""
718:
719: if hasattr(self,'support'):
720: obj=self.support
721: ret=obj.getSupporter()
722: return ret
723: else:
724: return ''
725:
726: def getOwnerOriginalsHTML(self):
727: """gibt Liste der foerdernden Institutionen aus"""
728:
729: if hasattr(self,'ownerOriginal'):
730: obj=self.ownerOriginal
731: ret=obj.getOwner()
732: return ret
733: else:
734: return ''
735:
736: def getDigiCopyByHTML(self):
737: """gibt Liste der foerdernden Institutionen aus"""
738:
739: if hasattr(self,'digiCopyBy'):
740: obj=self.digiCopyBy
741: ret=obj.getDigiCopyBy()
742: return ret
743: else:
744: return ''
745:
746: def getCredits(self):
747: """Ausgabe der credits"""
748: if self.credits:
749: return self.credits
750: else:
751: return []
752:
753:
754: def getStorageManagerResourceURL(self):
755: """get the link to storage"""
756: urlbase=self.getStorageManagerURL();
757:
758: #now get the path from the metadatalink
759:
760: path = self.correctPath(self.getMetaDataLink())
761: if path is None:
762: return ""
763: else:
764: path=path.replace("index.meta","")
765: return urlbase+path
766:
767:
768: def correctPath(self,path):
769: #take only the path of the url which starts with /permanent or /experimental
770:
771: rs= re.search("/permanent/(.*)", path);
772: if rs is not None:
773: txt="permanent/"+rs.group(1)
774: else:
775: rs= re.search("/experimental/(.*)", path);
776: if rs is not None:
777: txt="experimental"+rs.group(1)
778: else:
779: return None
780:
781: return txt
782:
783: def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
784:
785: self.id = id
786: """Festlegen der ID"""
787:
788: self.label = label
789: self.link= link
790: self.metalink=metalink
791: self.title=title
792: self.weight=weight
793: self.credits=toList(credits)
794: self.description=description
795: self.contentType=contentType
796: self.copyrightType=copyrightType
797: self.renderingType=renderingType
798: self.responsible=responsible
799: self.resourceID=resourceID
800:
801: if coords:
802: coordsnew=[ string.split(x,",") for x in coords]
803: else:
804: coordsnew=[]
805:
806: self.coords=coordsnew
807: # self.viewClassification=""
808:
809:
810:
811: def getContentType(self):
812: try:
813: return normalizeCt(self.contentType)
814: except:
815: return ""
816:
817: def getCopyrightType(self):
818: try:
819: return self.copyrightType
820: except:
821: return ""
822:
823: def getRenderingType(self):
824: try:
825: return self.renderingType
826: except:
827: return ""
828:
829: def ECHO_resource_config(self):
830: """Main configuration"""
831:
832: if not hasattr(self,'weight'):
833: self.weight=""
834:
835: pt=zptFile(self, 'zpt/ChangeECHO_resource.zpt')
836: return pt()
837:
838:
839: def ECHO_resource_config_main(self):
840: """Main configuration"""
841: if not hasattr(self,'weight'):
842: self.weight=""
843: pt=zptFile(self, 'zpt/ChangeECHO_resource_main.zpt')
844: return pt()
845:
846: def ECHO_resource_config_coords(self):
847: """Coords configuration """
848: pt=zptFile(self, 'zpt/ChangeECHO_resource_coords.zpt')
849: return pt()
850:
851: def ECHO_resource_config_credits(self):
852: """Main configuration"""
853: pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
854: return pt()
855:
856: def ECHO_resource_config_metadata(self):
857: """Main configuration"""
858: if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
859: self.metaDataHash={}
860: self.contentType=self.bib_type
861: for data in self.metadata:
862: data_neu=re.sub('-','_',data)
863: self.metaDataHash[data_neu]=getattr(self,data)[0:]
864:
865:
866: pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
867: return pt()
868:
869:
870:
871: def changeViewer(self,newViewer):
872: """set newViewer to the url of the new viewer
873: only if metalink is set, otherwise it gives false
874: """
875:
876: texterUrl="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn=/"
877:
878: vl,msg=self.checkValidityOfMetaLink()
879:
880: if not vl: #ungueltiger link, versuche neuen
881: newStr=re.match(".*/mpiwg/online/(.*)",self.metalink) # suche pfad hinter /mpiwg/online
882: oldLink=self.metalink
883:
884: if newStr:
885: self.metalink=texterUrl+newStr.group(1)
886: vl,msg=self.checkValidityOfMetaLink()
887: else:
888: logging.error("change Viewer XX(mew Metadatafile) %s"%self.metalink)
889: vl=False
890:
891: if not vl: # geht immer noch nicht, dann setzte wieder zurueck
892: self.metalink=oldLink
893:
894: logging.info("change Viewer (mew Metadatafile) %s"%self.metalink)
895:
896: if vl:
897: self.newViewer=newViewer
898: return vl,msg
899: else:
900: return vl,msg
901:
902: def checkValidityOfMetaLink(self):
903: """checks if the metalink is valid xml"""
904:
905: ml=self.metalink
906:
907: try:
908: txt=urllib.urlopen(ml)
909:
910: except:
911: return False,"Cannot open: %s)"%ml
912:
913: txt.close()
914: try:
915: dom = NonvalidatingReader.parseUri(ml)
916: except:
917: return False, "Connot parse: %s)"%ml
918:
919: if len(dom.xpath("//texttool"))==0:
920: return False, "No texttools: %s)"%ml
921:
922: return True,""
923:
924: def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,newViewer='',RESPONSE=None):
925: """Aenderung der Properties"""
926: self.resourceID=resourceID
927: self.title=title
928: self.label=label
929: self.description=description
930:
931: self.contentType=contentType
932: self.renderingType=renderingType
933: self.weight=weight
934:
935: self.link=link
936: self.metalink=metalink
937:
938: self.newViewer=newViewer
939:
940:
941: if RESPONSE is not None:
942: RESPONSE.redirect('manage_main')
943:
944:
945: def changeECHO_resource_coords(self,RESPONSE=None):
946: """Aenderung der Properties - coords"""
947: #return self.REQUEST
948: for area in self.getMapAreas():
949: id = area.getId()
950: if self.REQUEST.has_key('del.'+id):
951: # delete this area
952: self._delObject(id)
953: # return to same menu
954: if RESPONSE is not None:
955: RESPONSE.redirect('ECHO_resource_config_coords')
956: return
957: # modify this area
958: coordstring = self.REQUEST.get('coords.'+id, '')
959: coords = string.split(coordstring, ',')
960: angle = self.REQUEST.get('angle.'+id, '0')
961: type = self.REQUEST.get('type.'+id, 'area')
962: if len(coords) == 4:
963: area.setCoordString(coordstring)
964: area.setAngle(angle)
965: area.setType(type)
966: # return to main menu
967: if RESPONSE is not None:
968: RESPONSE.redirect('manage_main')
969:
970:
971: def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
972: """Aenderung der Properties"""
973: self.credits=credits
974: self.responsible=responsible
975: self.copyrightType=copyrightType
976:
977: if RESPONSE is not None:
978: RESPONSE.redirect('manage_main')
979:
980:
981: def changeECHO_resource_metadata_local(self,RESPONSE=None):
982: """change metadata"""
983: tags=self.findTagsFromMapping(normalizeCt(self.contentType))
984: for field in tags[1]:
985: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
986:
987:
988:
989: if RESPONSE is not None:
990: RESPONSE.redirect('manage_main')
991:
992: def changeECHO_resource_metadata(self,RESPONSE=None):
993: """change metadata"""
994: tags=self.findTagsFromMapping(normalizeCt(self.contentType))
995: self.OSAS_meta={}
996: for field in tags[1]:
997: try:
998: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
999: self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
1000: except:
1001: logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
1002:
1003: logging.debug("changeECHO_resource_metadata:"+repr(self.newMetaXML()))
1004:
1005:
1006: mc = MetaDataClient("http://content.mpiwg-berlin.mpg.de/metaDataServer")
1007: x=mc.writeMetaDataFile(self.getMetaDataLink(),self.newMetaXML(),compressed=None)
1008:
1009: logging.debug("changeECHO_resource_metadata (xlrpc return):"+repr(x))
1010:
1011:
1012: if RESPONSE is not None:
1013: RESPONSE.redirect('manage_main')
1014:
1015:
1016:
1017: def getMDValueSimpleSearchField(self):
1018: """returns value for simple search"""
1019:
1020: try:
1021: return " ".join([self.getMDValue('title',generic="yes"),
1022: self.getMDValue('author',generic="yes"),
1023: self.getMDValue('year',generic="yes"),self.getTitle()])
1024: except:
1025:
1026: #logger(" ECHO_collection(getMDSimpleSearchField)",logging.INFO," ".join([self.getMDValue('title',generic="yes"),
1027: # self.getMDValue('author',generic="yes"),
1028: # self.getMDValue('year',generic="yes"),'']))
1029: return ""
1030:
1031: def getMDValue(self,fieldNameTest,empty=None,generic=None):
1032: """get md values"""
1033: #TODO: cache mappinghash
1034:
1035: fieldName=None
1036: if generic:
1037: if self.contentType:
1038: ct=self.contentType.replace(" ","_").lower()
1039: ct=self.contentType.replace("-","_").lower()
1040: else:
1041: logger("ECHO_collection (getMDValue)", logging.INFO, "no_content type for %s"%self.getId())
1042: ct=""
1043:
1044: #caching
1045: if not hasattr(self,'_v_mapHash'): #noch keine cachevariable
1046: self._v_mapHash={}
1047:
1048:
1049:
1050: tmp=self._v_mapHash.get(ct,None)
1051: if tmp: #teste ob type schon existiert
1052: fieldName=tmp.get(fieldNameTest,None)
1053: else:
1054: self._v_mapHash[ct]={}
1055:
1056:
1057: #noch nicht gecached
1058: if not fieldName and hasattr(self.standardMD,ct):
1059: fieldName=getattr(self.standardMD,ct).generateMappingHash()[fieldNameTest][0]
1060: self._v_mapHash[ct][fieldNameTest]=fieldName
1061: if not fieldName:
1062: fieldName=fieldNameTest
1063: if not empty:
1064: #FIXME: warum gibt es manchmal kein metadatahas
1065: try:
1066:
1067: ret =self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%normalizeCt(self.contentType))
1068: except:
1069: logger("ECHO (line 1069)",logging.ERROR,"no md hash for %s"%self.getId())
1070: return ""
1071:
1072: else:
1073:
1074:
1075: ret= self.metaDataHash.get(fieldNameTest,empty)
1076:
1077: return unicodify(ret)
1078:
1079: getFieldValue=getMDValue #depricated
1080:
1081: def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
1082: """new index.meta"""
1083: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1084:
1085: if not hasattr(self,'metaDataHash'):
1086:
1087: self.copyIndex_meta2echo_resource()
1088: try:
1089:
1090:
1091: return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1092: except:
1093: #print self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix
1094:
1095: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1096:
1097: def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
1098: """return bibliographical metadata as stored in the object"""
1099:
1100: try:
1101:
1102: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
1103: except:
1104: return "<error> no metadata stored</error>"
1105:
1106: def getXQueryMetaData(self,xquery):
1107: '''
1108: execute an xquery on the metadata and returns a list of tuples,
1109: each tuple represent the content of the node as text and the whole node as xml-fragment
1110: @param xquery: xquery auf den metadaten
1111: '''
1112:
1113: try:
1114: md=writeMetadata(self.metalink,self.metaDataHash,xmlfrag="yes")
1115: except:
1116: return None
1117:
1118: dom = NonvalidatingReader.parseString(md,"http://www.mpiwg-berlin.mpg.de/")
1119:
1120: results=Ft.Xml.XPath.Evaluate(xquery, contextNode=dom)
1121:
1122: ret=[]
1123: for result in results:
1124:
1125: buf = cStringIO.StringIO()
1126: PrettyPrint(result, stream=buf)
1127: str = buf.getvalue()[0:]
1128: buf.close()
1129: ret.append((getTextFromNode(result),str))
1130:
1131: return ret
1132:
1133: def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
1134: """prints out metadata as stored in the echo environment, format is the index.meta format"""
1135: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1136: return writeMetadata(self.metalink,self.metaDataHash)
1137:
1138: def getMetaDataLink(self):
1139: """get link to the meta data"""
1140: return self.metalink
1141:
1142: def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
1143: """Aenderung der Properties"""
1144:
1145: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
1146: self.link=link
1147: self.metalink=metalink
1148:
1149: if RESPONSE is not None:
1150: RESPONSE.redirect('manage_main')
1151:
1152:
1153: manage_options = (
1154: {'label':'Main Config','action':'ECHO_resource_config_main'},
1155: {'label':'Change Local Metadata','action':'ECHO_resource_config_metadata'},
1156: {'label':'Sync Metadata with Repository','action':'ECHO_getResourceMD'},
1157: {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
1158: {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
1159: {'label':'set/change startpage','action':'setStartPageForm'},
1160: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
1161: {'label':'Change AccessRights','action':'changeAccessRightForm'},
1162: ) + Folder.manage_options
1163:
1164:
1165: def isDefinedInThisSet(self,fields,field):
1166: """checks if field is defined in fields"""
1167: if (fields[0].has_key(field)) and not (fields[0][field]==""):
1168: return 1
1169: else:
1170:
1171: return 0
1172:
1173: def getFieldLabel(self,fields,field):
1174: """get labels"""
1175: try:
1176: ret =fields[0][field]
1177: if ret == "":
1178: return field
1179: else:
1180: return ret
1181: except:
1182: return field
1183:
1184:
1185:
1186: def getFieldTag(self,fields,field):
1187: """get labels"""
1188: try:
1189: ret =fields[0][field]
1190: if ret == "":
1191: return field
1192: else:
1193: return ret
1194: except:
1195: return field
1196:
1197:
1198:
1199: def getMetaDataHash(self):
1200: """md hash"""
1201: return self.metaDataHash
1202:
1203: def setFieldValue(self,field,value):
1204: """get value"""
1205: #TODO: remove setFieldValue
1206:
1207: if not hasattr(self,'metaDataHash'):
1208: setattr(self,'metaDataHash',{})
1209: self.metaDataHash[field]=value[0:]
1210:
1211: def copySearchFields(self):
1212: """copys metadatafields to the object"""
1213: fields=['author','title','year']
1214:
1215: for field in fields:
1216: setattr(self,'MD_'+field,self.getMDValue(field,generic="yes"))
1217:
1218:
1219: def findLabelsFromMapping(self,referenceType):
1220: """gib hash mit label -> generic zurueck"""
1221: #return {},[]
1222:
1223: temp=self.ZopeFind(self.standardMD)
1224:
1225: if referenceType=="":
1226: referenceType="book"
1227:
1228:
1229: bibdata={}
1230: retdata={}
1231: fields=[]
1232: fieldlist=self.standardMD.fieldList
1233:
1234: tags=self.findTagsFromMapping(normalizeCt(self.contentType))
1235: self.referencetypes=tags[2]
1236: for referenceTypeF in self.referencetypes:
1237:
1238:
1239: if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
1240:
1241: try:
1242: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1243: referenceType=referenceTypeF[1].title
1244: except:
1245: bibdata[referenceType]=referenceTypeF[1].fields
1246:
1247:
1248: bibdata['data']=referenceTypeF[1]
1249: fields=bibdata[referenceType]
1250: for field in fieldlist:
1251: retdata[field]=referenceTypeF[1].getValue(field)[1]
1252:
1253: return retdata,fieldlist,temp,fields
1254:
1255: def findTagsFromMapping(self,referenceType):
1256: """gib hash mit label -> generic zurueck"""
1257:
1258:
1259: if referenceType=="":
1260: referenceType="book"
1261:
1262: temp = self.ZopeFind(self.standardMD)[0:]
1263:
1264:
1265: #self.referencetypes=temp[0:]
1266:
1267:
1268:
1269:
1270: bibdata={}
1271: retdata={}
1272: fieldlist=self.standardMD.fieldList
1273: fields=[]
1274: for referenceTypeF in temp:
1275: #print referenceType
1276:
1277: if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
1278: try:
1279: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1280: referenceType=referenceTypeF[1].title
1281: except:
1282: bibdata[referenceType]=referenceTypeF[1].fields
1283: bibdata['data']=referenceTypeF[1]
1284: fields=bibdata[referenceType]
1285: for field in fieldlist:
1286: retdata[field]=referenceTypeF[1].getValue(field)[0]
1287:
1288: return retdata,fieldlist,temp,fields
1289:
1290:
1291: security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination
1292: def copyIndex_meta2echo_resource(self,RESPONSE=None):
1293: """copy MD von Index_meta to the echo_resource"""
1294:
1295: (metadict, error)=readMetadata(self.metalink)
1296:
1297:
1298:
1299: self.metaDataHash={}
1300: if not error=="": #Fehler beim Auslesen des Metafiles
1301:
1302: return "ERROR:",error,self.absolute_url()
1303:
1304: self.contentType=normalizeCt(metadict['bib_type'])[0:]
1305: fields=self.findTagsFromMapping(normalizeCt(self.contentType))
1306:
1307: #fields=self.findLabelsFromMapping(normalizeCt(self.contentType))
1308: for field in fields[1]:
1309:
1310: if self.isDefinedInThisSet(fields,field):
1311: #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
1312: self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
1313:
1314:
1315:
1316: if RESPONSE:
1317: return RESPONSE.redirect('manage_main')
1318:
1319: return "OK:",self.absolute_url(),normalizeCt(self.contentType)
1320:
1321: def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"):
1322: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
1323: (metadict, error)=readMetadata(self.metalink)
1324:
1325: if back:
1326: self.REQUEST.SESSION['back']=back
1327:
1328: if not error=="": #Fehler beim Auslesen des Metafiles
1329: return "ERROR:",error
1330:
1331: if (not self.contentType) or (overwrite=="yes"):
1332: self.contentType=normalizeCt(normalizeCt(metadict['bib_type']).lower())
1333:
1334: if not (normalizeCt(metadict['bib_type']).lower()==normalizeCt(self.contentType).lower()):
1335: self.REQUEST.SESSION['contentStorage']=normalizeCt(metadict['bib_type'])
1336: self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)
1337:
1338: return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
1339:
1340: #self.REQUEST.SESSION['metadict']=metadict
1341:
1342:
1343:
1344:
1345: self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
1346:
1347:
1348: if template=="yes":
1349: #pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_resourceMD.zpt'),metadict=metadict).__of__(self)
1350: pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
1351:
1352: return pt(metadict=metadict)
1353:
1354:
1355:
1356:
1357:
1358: def ECHO_getMD(self,item):
1359: """Ausgabe der MD"""
1360: return getattr(self,item)
1361:
1362: def checkRDF(self,path):
1363: """check if pdf in the path"""
1364: try:
1365: for fileName in os.listdir(path):
1366: if os.path.splitext(fileName)[1]==".pdf":
1367: return os.path.join(path,fileName)
1368: return None
1369: except:
1370: return None
1371:
1372:
1373: security.declareProtected('View','index_html')
1374: def index_html(self):
1375: """standard page"""
1376: pdf=self.checkRDF(self.link)
1377: if pdf:
1378: fh=file(pdf,'r').read()
1379: self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
1380: self.REQUEST.RESPONSE.write(fh)
1381: self.REQUEST.RESPONSE.close()
1382: return
1383:
1384: if getattr(self,'newViewer',''): #benutze den neuen viewer
1385: url=self.newViewer+'url='+self.metalink+"&mode=texttool"
1386: return self.REQUEST.RESPONSE.redirect(url)
1387:
1388: return self.REQUEST.RESPONSE.redirect(self.link)
1389:
1390: def startpage_html(self):
1391: """prints out a startpage for a resource for use e.g. in the BVE"""
1392:
1393: # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
1394:
1395: sp=self.ZopeFind(self,obj_ids=['startpage.html'])
1396:
1397: if sp:
1398: return sp[1]()
1399:
1400: #pruefen ob irgendwo ein template
1401: if hasattr(self,'startpage_index_template'):
1402: return self.startpage_index_template()
1403:
1404: #generisches template ausgeben
1405:
1406: pt=zptFile(self, 'zpt/ECHO_startpage_index_template_standard.zpt')
1407: pt.content_type="text/html"
1408: return pt()
1409:
1410: def toc_html(self):
1411:
1412: sp=self.ZopeFind(self,obj_ids=['toc.html'])
1413:
1414: if sp:
1415: return sp[0][1]()
1416:
1417:
1418: security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
1419:
1420: def generate_label(self):
1421: """Erzeugt_standard_Label aus Template"""
1422: pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())
1423:
1424: self.label=pt()[0:]
1425: return pt()
1426:
1427: security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
1428:
1429: def generate_title(self,RESPONSE=None):
1430: """Erzeugt_standard_Label aus Template"""
1431: pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())
1432:
1433: self.title=pt()[0:]
1434:
1435: return pt()
1436:
1437: Globals.InitializeClass(ECHO_resource)
1438:
1439: def manage_addECHO_resourceForm(self):
1440: """Form for adding a ressource"""
1441: pt=zptFile(self, 'zpt/AddECHO_resourceForm.zpt')
1442: return pt()
1443:
1444:
1445:
1446: def manage_addECHO_resource(self,id,title,label,description="",responsible="",link="",metalink="",weight="",copyrightType=None,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):
1447: """addresource"""
1448:
1449: newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
1450:
1451: self._setObject(id,newObj)
1452:
1453: if RESPONSE is not None:
1454: RESPONSE.redirect('manage_main')
1455:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ECHO_resource.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ECHO_content