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