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