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