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