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