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:
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_xpath(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_xpath(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: archivePath=readFieldFromXML_xpath(self.metalink,"//resource/archive-path")
658: return archivePath
659: except:
660: return ""
661:
662: def getImageView(self,noredirect=None,onlyPath=None):
663: """getImages; give Imageviewr and <error></error> if somthing goes wrong."""
664: try:
665: archivePath=readFieldFromXML_xpath(self.metalink,"//resource/archive-path")
666:
667: archivepath=re.sub('/mpiwg/online/','',archivepath)
668: imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
669: fh.close()
670:
671: if not noredirect:
672: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
673: self.REQUEST.RESPONSE.redirect(imageurl)
674: else:
675: if not onlyPath:
676: return imageurl
677: else:
678: return archivepath+"/"+imagetemp
679: except:
680:
681: if not noredirect:
682: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
683: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
684: else:
685: return "<error>no images available</error>"
686:
687:
688: def getCopyrightsHTML(self):
689: """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
690:
691: if hasattr(self,'copyrightModel'):
692: obj=self.copyrightModel
693:
694: else:
695: return "ERROR"
696: ret=[]
697:
698: for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
699:
700:
701: try:
702: if hasattr(self.copyrightTypes,copyright[2]):
703: copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
704: link="copyrightTypes/"+copyright[2]+'/copyright.html'
705: else:
706: copyrightTypeObj=getattr(obj,copyright[2])
707: link="copyrightModel/"+copyright[2]+'/copyright.html'
708:
709: label=copyrightTypeObj.label
710: url=getattr(copyrightTypeObj, 'url', '')
711:
712: if url!='':
713: ret.append((url,copyright[0],copyright[1],copyright[2],label))
714: else:
715: if hasattr(copyrightTypeObj, 'copyright.html'):
716: ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
717: else:
718: ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
719: except:
720: """nothing"""
721:
722: return ret
723:
724: def getInstitutionsHTML(self):
725: """gibt Liste der foerdernden Institutionen aus"""
726:
727: if hasattr(self,'support'):
728: obj=self.support
729: ret=obj.getSupporter()
730: return ret
731: else:
732: return ''
733:
734: def getOwnerOriginalsHTML(self):
735: """gibt Liste der foerdernden Institutionen aus"""
736:
737: if hasattr(self,'ownerOriginal'):
738: obj=self.ownerOriginal
739: ret=obj.getOwner()
740: return ret
741: else:
742: return ''
743:
744: def getDigiCopyByHTML(self):
745: """gibt Liste der foerdernden Institutionen aus"""
746:
747: if hasattr(self,'digiCopyBy'):
748: obj=self.digiCopyBy
749: ret=obj.getDigiCopyBy()
750: return ret
751: else:
752: return ''
753:
754: def getCredits(self):
755: """Ausgabe der credits"""
756: if self.credits:
757: return self.credits
758: else:
759: return []
760:
761:
762: def getStorageManagerResourceURL(self):
763: """get the link to storage"""
764: urlbase=self.getStorageManagerURL();
765:
766: #now get the path from the metadatalink
767:
768: path = self.correctPath(self.getMetaDataLink())
769: if path is None:
770: return ""
771: else:
772: path=path.replace("index.meta","")
773: return urlbase+path
774:
775:
776: def correctPath(self,path):
777: #take only the path of the url which starts with /permanent or /experimental
778:
779: rs= re.search("/permanent/(.*)", path);
780: if rs is not None:
781: txt="permanent/"+rs.group(1)
782: else:
783: rs= re.search("/experimental/(.*)", path);
784: if rs is not None:
785: txt="experimental"+rs.group(1)
786: else:
787: return None
788:
789: return txt
790:
791: def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
792:
793: self.id = id
794: """Festlegen der ID"""
795:
796: self.label = label
797: self.link= link
798: self.metalink=metalink
799: self.title=title
800: self.weight=weight
801: self.credits=toList(credits)
802: self.description=description
803: self.contentType=contentType
804: self.copyrightType=copyrightType
805: self.renderingType=renderingType
806: self.responsible=responsible
807: self.resourceID=resourceID
808:
809: if coords:
810: coordsnew=[ string.split(x,",") for x in coords]
811: else:
812: coordsnew=[]
813:
814: self.coords=coordsnew
815: # self.viewClassification=""
816:
817:
818:
819: def getContentType(self):
820: try:
821: return normalizeCt(self.contentType)
822: except:
823: return ""
824:
825: def getCopyrightType(self):
826: try:
827: return self.copyrightType
828: except:
829: return ""
830:
831: def getRenderingType(self):
832: try:
833: return self.renderingType
834: except:
835: return ""
836:
837: def ECHO_resource_config(self):
838: """Main configuration"""
839:
840: if not hasattr(self,'weight'):
841: self.weight=""
842:
843: pt=zptFile(self, 'zpt/ChangeECHO_resource.zpt')
844: return pt()
845:
846:
847: def ECHO_resource_config_main(self):
848: """Main configuration"""
849: if not hasattr(self,'weight'):
850: self.weight=""
851: pt=zptFile(self, 'zpt/ChangeECHO_resource_main.zpt')
852: return pt()
853:
854: def ECHO_resource_config_coords(self):
855: """Coords configuration """
856: pt=zptFile(self, 'zpt/ChangeECHO_resource_coords.zpt')
857: return pt()
858:
859: def ECHO_resource_config_credits(self):
860: """Main configuration"""
861: pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
862: return pt()
863:
864: def ECHO_resource_config_metadata(self):
865: """Main configuration"""
866: if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
867: self.metaDataHash={}
868: self.contentType=self.bib_type
869: for data in self.metadata:
870: data_neu=re.sub('-','_',data)
871: self.metaDataHash[data_neu]=getattr(self,data)[0:]
872:
873:
874: pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
875: return pt()
876:
877:
878:
879: def changeViewer(self,newViewer):
880: """set newViewer to the url of the new viewer
881: only if metalink is set, otherwise it gives false
882: """
883:
884: texterUrl="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn=/"
885:
886: vl,msg=self.checkValidityOfMetaLink()
887:
888: if not vl: #ungueltiger link, versuche neuen
889: newStr=re.match(".*/mpiwg/online/(.*)",self.metalink) # suche pfad hinter /mpiwg/online
890: oldLink=self.metalink
891:
892: if newStr:
893: self.metalink=texterUrl+newStr.group(1)
894: vl,msg=self.checkValidityOfMetaLink()
895: else:
896: logging.error("change Viewer XX(mew Metadatafile) %s"%self.metalink)
897: vl=False
898:
899: if not vl: # geht immer noch nicht, dann setzte wieder zurueck
900: self.metalink=oldLink
901:
902: logging.info("change Viewer (mew Metadatafile) %s"%self.metalink)
903:
904: if vl:
905: self.newViewer=newViewer
906: return vl,msg
907: else:
908: return vl,msg
909:
910: def checkValidityOfMetaLink(self):
911: """checks if the metalink is valid xml"""
912:
913: ml=self.metalink
914:
915: try:
916: txt=urllib.urlopen(ml)
917:
918: except:
919: return False,"Cannot open: %s)"%ml
920:
921: txt.close()
922: try:
923: dom = NonvalidatingReader.parseUri(ml)
924: except:
925: return False, "Connot parse: %s)"%ml
926:
927: if len(dom.xpath("//texttool"))==0:
928: return False, "No texttools: %s)"%ml
929:
930: return True,""
931:
932: def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,newViewer='',RESPONSE=None):
933: """Aenderung der Properties"""
934: self.resourceID=resourceID
935: self.title=title
936: self.label=label
937: self.description=description
938:
939: self.contentType=contentType
940: self.renderingType=renderingType
941: self.weight=weight
942:
943: self.link=link
944: self.metalink=metalink
945:
946: self.newViewer=newViewer
947:
948:
949: if RESPONSE is not None:
950: RESPONSE.redirect('manage_main')
951:
952:
953: def changeECHO_resource_coords(self,RESPONSE=None):
954: """Aenderung der Properties - coords"""
955: #return self.REQUEST
956: for area in self.getMapAreas():
957: id = area.getId()
958: if self.REQUEST.has_key('del.'+id):
959: # delete this area
960: self._delObject(id)
961: # return to same menu
962: if RESPONSE is not None:
963: RESPONSE.redirect('ECHO_resource_config_coords')
964: return
965: # modify this area
966: coordstring = self.REQUEST.get('coords.'+id, '')
967: coords = string.split(coordstring, ',')
968: angle = self.REQUEST.get('angle.'+id, '0')
969: type = self.REQUEST.get('type.'+id, 'area')
970: if len(coords) == 4:
971: area.setCoordString(coordstring)
972: area.setAngle(angle)
973: area.setType(type)
974: # return to main menu
975: if RESPONSE is not None:
976: RESPONSE.redirect('manage_main')
977:
978:
979: def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
980: """Aenderung der Properties"""
981: self.credits=credits
982: self.responsible=responsible
983: self.copyrightType=copyrightType
984:
985: if RESPONSE is not None:
986: RESPONSE.redirect('manage_main')
987:
988:
989: def changeECHO_resource_metadata_local(self,RESPONSE=None):
990: """change metadata"""
991: tags=self.findTagsFromMapping(normalizeCt(self.contentType))
992: for field in tags[1]:
993: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
994:
995:
996:
997: if RESPONSE is not None:
998: RESPONSE.redirect('manage_main')
999:
1000: def changeECHO_resource_metadata(self,RESPONSE=None):
1001: """change metadata"""
1002: tags=self.findTagsFromMapping(normalizeCt(self.contentType))
1003: self.OSAS_meta={}
1004: for field in tags[1]:
1005: try:
1006: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
1007: self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
1008: except:
1009: logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
1010:
1011: logging.debug("changeECHO_resource_metadata:"+repr(self.newMetaXML()))
1012:
1013:
1014: mc = MetaDataClient("http://content.mpiwg-berlin.mpg.de/metaDataServer")
1015: x=mc.writeMetaDataFile(self.getMetaDataLink(),self.newMetaXML(),compressed=None)
1016:
1017: logging.debug("changeECHO_resource_metadata (xlrpc return):"+repr(x))
1018:
1019:
1020: if RESPONSE is not None:
1021: RESPONSE.redirect('manage_main')
1022:
1023:
1024:
1025: def getMDValueSimpleSearchField(self):
1026: """returns value for simple search"""
1027:
1028: try:
1029: return " ".join([self.getMDValue('title',generic="yes"),
1030: self.getMDValue('author',generic="yes"),
1031: self.getMDValue('year',generic="yes"),self.getTitle()])
1032: except:
1033:
1034: #logger(" ECHO_collection(getMDSimpleSearchField)",logging.INFO," ".join([self.getMDValue('title',generic="yes"),
1035: # self.getMDValue('author',generic="yes"),
1036: # self.getMDValue('year',generic="yes"),'']))
1037: return ""
1038:
1039: def getMDValue(self,fieldNameTest,empty=None,generic=None):
1040: """get md values"""
1041: #TODO: cache mappinghash
1042:
1043: fieldName=None
1044: if generic:
1045: if self.contentType:
1046: ct=self.contentType.replace(" ","_").lower()
1047: ct=self.contentType.replace("-","_").lower()
1048: else:
1049: logger("ECHO_collection (getMDValue)", logging.INFO, "no_content type for %s"%self.getId())
1050: ct=""
1051:
1052: #caching
1053: if not hasattr(self,'_v_mapHash'): #noch keine cachevariable
1054: self._v_mapHash={}
1055:
1056:
1057:
1058: tmp=self._v_mapHash.get(ct,None)
1059: if tmp: #teste ob type schon existiert
1060: fieldName=tmp.get(fieldNameTest,None)
1061: else:
1062: self._v_mapHash[ct]={}
1063:
1064:
1065: #noch nicht gecached
1066: if not fieldName and hasattr(self.standardMD,ct):
1067: fieldName=getattr(self.standardMD,ct).generateMappingHash()[fieldNameTest][0]
1068: self._v_mapHash[ct][fieldNameTest]=fieldName
1069: if not fieldName:
1070: fieldName=fieldNameTest
1071: if not empty:
1072: #FIXME: warum gibt es manchmal kein metadatahas
1073: try:
1074:
1075: ret =self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%normalizeCt(self.contentType))
1076: except:
1077: logger("ECHO (line 1069)",logging.ERROR,"no md hash for %s"%self.getId())
1078: return ""
1079:
1080: else:
1081:
1082:
1083: ret= self.metaDataHash.get(fieldNameTest,empty)
1084:
1085: return unicodify(ret)
1086:
1087: getFieldValue=getMDValue #depricated
1088:
1089: def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
1090: """new index.meta"""
1091: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1092:
1093: if not hasattr(self,'metaDataHash'):
1094:
1095: self.copyIndex_meta2echo_resource()
1096: try:
1097:
1098:
1099: return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1100: except:
1101: #print self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix
1102:
1103: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1104:
1105: def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
1106: """return bibliographical metadata as stored in the object"""
1107:
1108: try:
1109:
1110: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
1111: except:
1112: return "<error> no metadata stored</error>"
1113:
1114: def getXQueryMetaData(self,xquery):
1115: '''
1116: execute an xquery on the metadata and returns a list of tuples,
1117: each tuple represent the content of the node as text and the whole node as xml-fragment
1118: @param xquery: xquery auf den metadaten
1119: '''
1120:
1121: try:
1122: md=writeMetadata(self.metalink,self.metaDataHash,xmlfrag="yes")
1123: except:
1124: return None
1125:
1126: dom = NonvalidatingReader.parseString(md,"http://www.mpiwg-berlin.mpg.de/")
1127:
1128: results=Ft.Xml.XPath.Evaluate(xquery, contextNode=dom)
1129:
1130: ret=[]
1131: for result in results:
1132:
1133: buf = cStringIO.StringIO()
1134: PrettyPrint(result, stream=buf)
1135: str = buf.getvalue()[0:]
1136: buf.close()
1137: ret.append((getTextFromNode(result),str))
1138:
1139: return ret
1140:
1141: def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
1142: """prints out metadata as stored in the echo environment, format is the index.meta format"""
1143: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1144: return writeMetadata(self.metalink,self.metaDataHash)
1145:
1146: def getMetaDataLink(self):
1147: """get link to the meta data"""
1148: return self.metalink
1149:
1150: def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
1151: """Aenderung der Properties"""
1152:
1153: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
1154: self.link=link
1155: self.metalink=metalink
1156:
1157: if RESPONSE is not None:
1158: RESPONSE.redirect('manage_main')
1159:
1160:
1161: manage_options = (
1162: {'label':'Main Config','action':'ECHO_resource_config_main'},
1163: {'label':'Change Local Metadata','action':'ECHO_resource_config_metadata'},
1164: {'label':'Sync Metadata with Repository','action':'ECHO_getResourceMD'},
1165: {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
1166: {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
1167: {'label':'set/change startpage','action':'setStartPageForm'},
1168: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
1169: {'label':'Change AccessRights','action':'changeAccessRightForm'},
1170: ) + Folder.manage_options
1171:
1172:
1173: def isDefinedInThisSet(self,fields,field):
1174: """checks if field is defined in fields"""
1175: if (fields[0].has_key(field)) and not (fields[0][field]==""):
1176: return 1
1177: else:
1178:
1179: return 0
1180:
1181: def getFieldLabel(self,fields,field):
1182: """get labels"""
1183: try:
1184: ret =fields[0][field]
1185: if ret == "":
1186: return field
1187: else:
1188: return ret
1189: except:
1190: return field
1191:
1192:
1193:
1194: def getFieldTag(self,fields,field):
1195: """get labels"""
1196: try:
1197: ret =fields[0][field]
1198: if ret == "":
1199: return field
1200: else:
1201: return ret
1202: except:
1203: return field
1204:
1205:
1206:
1207: def getMetaDataHash(self):
1208: """md hash"""
1209:
1210: return getattr(self,'metaDataHash',{})
1211:
1212: def setFieldValue(self,field,value):
1213: """get value"""
1214: #TODO: remove setFieldValue
1215:
1216: if not hasattr(self,'metaDataHash'):
1217: setattr(self,'metaDataHash',{})
1218: self.metaDataHash[field]=value[0:]
1219:
1220: def copySearchFields(self):
1221: """copys metadatafields to the object"""
1222:
1223: # Zunaechst die gnerischen felder
1224: fields=['author','title','year']
1225: for field in fields:
1226: setattr(self,'MD_'+field,self.getMDValue(field,generic="yes"))
1227:
1228: # jetzt die spezifischen
1229: for field in self.getMetaDataHash().keys():
1230: if not (field in fields):
1231: logging.debug("ECHO_resource (copySearchFields) mapping: "+field)
1232: setattr(self,'MD_'+field,self.getMDValue(field))
1233:
1234:
1235:
1236:
1237: def findLabelsFromMapping(self,referenceType):
1238: """gib hash mit label -> generic zurueck"""
1239: #return {},[]
1240:
1241: temp=self.ZopeFind(self.standardMD)
1242:
1243: if referenceType=="":
1244: referenceType="book"
1245:
1246:
1247: bibdata={}
1248: retdata={}
1249: fields=[]
1250: fieldlist=self.standardMD.fieldList
1251:
1252: tags=self.findTagsFromMapping(normalizeCt(self.contentType))
1253: logging.debug("ECHO_resource(findLabelsFromMapping)"+repr(tags))
1254: self.referencetypes=tags[2]
1255: for referenceTypeF in self.referencetypes:
1256:
1257: logging.debug("--- compare"+normalizeCt(referenceTypeF[1].title)+normalizeCt(referenceType.lower()))
1258: if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
1259:
1260: try:
1261: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1262: referenceType=referenceTypeF[1].title
1263: logging.debug("------fields:"+repr(fields))
1264: except:
1265: bibdata[referenceType]=referenceTypeF[1].fields
1266:
1267:
1268: bibdata['data']=referenceTypeF[1]
1269: fields=bibdata[referenceType]
1270: for field in fieldlist:
1271: retdata[field]=referenceTypeF[1].getValue(field)[1]
1272:
1273: return retdata,fieldlist,temp,fields
1274:
1275: def findTagsFromMapping(self,referenceType):
1276: """gib hash mit label -> generic zurueck"""
1277:
1278:
1279: if referenceType=="":
1280: referenceType="book"
1281:
1282: temp = self.ZopeFind(self.standardMD)[0:]
1283:
1284:
1285: #self.referencetypes=temp[0:]
1286:
1287:
1288:
1289:
1290: bibdata={}
1291: retdata={}
1292: fieldlist=self.standardMD.fieldList
1293: fields=[]
1294: for referenceTypeF in temp:
1295: #print referenceType
1296:
1297: if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
1298: try:
1299: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1300: referenceType=referenceTypeF[1].title
1301: except:
1302: logging.debug("Error in ECHOresource(findTagsFromMapping): %s %s"%(sys.exc_info[0],sys.exc_info[1]))
1303: bibdata[referenceType]=referenceTypeF[1].fields
1304: bibdata['data']=referenceTypeF[1]
1305: fields=bibdata[referenceType]
1306: for field in fieldlist:
1307: retdata[field]=referenceTypeF[1].getValue(field)[0]
1308:
1309: return retdata,fieldlist,temp,fields
1310:
1311:
1312: security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination
1313: def copyIndex_meta2echo_resource(self,RESPONSE=None):
1314: """copy MD von Index_meta to the echo_resource"""
1315:
1316: (metadict, error)=readMetadata(self.metalink)
1317:
1318:
1319:
1320: self.metaDataHash={}
1321: if not error=="": #Fehler beim Auslesen des Metafiles
1322:
1323: return "ERROR:",error,self.absolute_url()
1324:
1325: self.contentType=normalizeCt(metadict['bib_type'])[0:]
1326: fields=self.findTagsFromMapping(normalizeCt(self.contentType))
1327:
1328: #fields=self.findLabelsFromMapping(normalizeCt(self.contentType))
1329: for field in fields[1]:
1330:
1331: if self.isDefinedInThisSet(fields,field):
1332: #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
1333: self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
1334:
1335:
1336:
1337: if RESPONSE:
1338: return RESPONSE.redirect('manage_main')
1339:
1340: return "OK:",self.absolute_url(),normalizeCt(self.contentType)
1341:
1342: def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"):
1343: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
1344: (metadict, error)=readMetadata(self.metalink)
1345:
1346: if back:
1347: self.REQUEST.SESSION['back']=back
1348:
1349: if not error=="": #Fehler beim Auslesen des Metafiles
1350: return "ERROR:",error
1351:
1352: if (not self.contentType) or (overwrite=="yes"):
1353: self.contentType=normalizeCt(normalizeCt(metadict['bib_type']).lower())
1354:
1355: if not (normalizeCt(metadict['bib_type']).lower()==normalizeCt(self.contentType).lower()):
1356: self.REQUEST.SESSION['contentStorage']=normalizeCt(metadict['bib_type'])
1357: self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)
1358:
1359: return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
1360:
1361: #self.REQUEST.SESSION['metadict']=metadict
1362:
1363:
1364:
1365:
1366: self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
1367:
1368:
1369: if template=="yes":
1370: #pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_resourceMD.zpt'),metadict=metadict).__of__(self)
1371: pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
1372:
1373: return pt(metadict=metadict)
1374:
1375:
1376:
1377:
1378:
1379: def ECHO_getMD(self,item):
1380: """Ausgabe der MD"""
1381: return getattr(self,item)
1382:
1383: def checkRDF(self,path):
1384: """check if pdf in the path"""
1385: try:
1386: for fileName in os.listdir(path):
1387: if os.path.splitext(fileName)[1]==".pdf":
1388: return os.path.join(path,fileName)
1389: return None
1390: except:
1391: return None
1392:
1393:
1394: security.declareProtected('View','index_html')
1395: def index_html(self):
1396: """standard page"""
1397: pdf=self.checkRDF(self.link)
1398: if pdf:
1399: fh=file(pdf,'r').read()
1400: self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
1401: self.REQUEST.RESPONSE.write(fh)
1402: self.REQUEST.RESPONSE.close()
1403: return
1404:
1405: if getattr(self,'newViewer',''): #benutze den neuen viewer
1406: url=self.newViewer+'url='+self.metalink+"&mode=texttool"
1407: return self.REQUEST.RESPONSE.redirect(url)
1408:
1409: return self.REQUEST.RESPONSE.redirect(self.link)
1410:
1411: def startpage_html(self):
1412: """prints out a startpage for a resource for use e.g. in the BVE"""
1413:
1414: # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
1415:
1416: sp=self.ZopeFind(self,obj_ids=['startpage.html'])
1417:
1418: if sp:
1419: return sp[1]()
1420:
1421: #pruefen ob irgendwo ein template
1422: if hasattr(self,'startpage_index_template'):
1423: return self.startpage_index_template()
1424:
1425: #generisches template ausgeben
1426:
1427: pt=zptFile(self, 'zpt/ECHO_startpage_index_template_standard.zpt')
1428: pt.content_type="text/html"
1429: return pt()
1430:
1431: def toc_html(self):
1432:
1433: sp=self.ZopeFind(self,obj_ids=['toc.html'])
1434:
1435: if sp:
1436: return sp[0][1]()
1437:
1438:
1439: security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
1440:
1441: def generate_label(self):
1442: """Erzeugt_standard_Label aus Template"""
1443: pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())
1444:
1445: self.label=pt()[0:]
1446: return pt()
1447:
1448: security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
1449:
1450: def generate_title(self,RESPONSE=None):
1451: """Erzeugt_standard_Label aus Template"""
1452: pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())
1453:
1454: self.title=pt()[0:]
1455:
1456: return pt()
1457:
1458: Globals.InitializeClass(ECHO_resource)
1459:
1460: def manage_addECHO_resourceForm(self):
1461: """Form for adding a ressource"""
1462: pt=zptFile(self, 'zpt/AddECHO_resourceForm.zpt')
1463: return pt()
1464:
1465:
1466:
1467: 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):
1468: """addresource"""
1469:
1470: newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
1471:
1472: self._setObject(id,newObj)
1473:
1474: if RESPONSE is not None:
1475: RESPONSE.redirect('manage_main')
1476:
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