1: #TODO: change metaDataHash, jetzt tag -> data(tags aus dem neuen Metadatamain)
2: #TODO: erstes OSAS_meta ueberall durch self.metaDataHAst
3: #TODO: contentType aus den Metadaten
4:
5: import urlparse
6: import string
7: import tempfile
8: import zipfile
9: import re
10: import os,shutil
11: import OFS.Image
12: from types import *
13: from OFS.Cache import Cacheable
14: from OFS.Image import Image
15: from Globals import DTMLFile
16: from OFS.Folder import Folder
17: from OFS.SimpleItem import SimpleItem
18: from AccessControl import ClassSecurityInfo
19: from AccessControl.User import UserFolder
20: from Globals import InitializeClass
21: from Globals import DTMLFile
22: import Globals
23: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
24: from Products.PageTemplates.PageTemplate import PageTemplate
25: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate,manage_addPageTemplate
26: from Globals import Persistent, package_home
27: from Acquisition import Implicit
28: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
29: from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
30: try:
31: from Products.MetaDataProvider.MetaDataClient import MetaDataClient
32: except:
33: print "no metadata services"
34: import urllib
35: import urllib2
36: import cgi
37: import smtplib
38: import time
39: #from Ft.Xml.Domlette import NonvalidatingReader
40: #from Ft.Xml.Domlette import PrettyPrint, Print
41: #from Ft.Xml import EMPTY_NAMESPACE
42: #
43: #import Ft.Xml.XPath
44: import cStringIO
45:
46: import sys
47:
48: try:
49: from psycopg import libpq
50: except:
51: try:
52: from pyPgSQL import libpq
53: except:
54: print "ECHO_collection: Warning - No libpq imported!"
55:
56: import xml.dom.minidom
57:
58: import urllib
59: import xml.dom.minidom
60: import ECHO_helpers
61: from ECHO_helpers import *
62:
63:
64: from ECHO_movie import *
65: import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
66: import xmlrpclib
67:
68: import logging
69:
70: class ECHO_resource(CatalogAware,Folder,Persistent,ECHO_basis):
71: """ECHO Ressource"""
72: security=ClassSecurityInfo()
73: meta_type='ECHO_resource'
74: default_catalog='resourceCatalog'
75:
76: # viewClassificationList=viewClassificationListMaster
77:
78:
79:
80: def PrincipiaSearchSource(self):
81: """Return cataloguable key for ourselves."""
82: return str(self)
83:
84: getSubCols = ECHO_helpers.getSubCols
85:
86: def getMetaDataManager(self):
87: """hole eine Instanz von MetaDataFolder
88: TODO: sollte konfigurierbar sein.
89: zur Zeit wird enfach nur self.metadata falls vorhanden zurueckggegeben.
90: """
91:
92: return getattr(self,"metadata",None)
93:
94: def index_meta(self,RESPONSE=None):
95: """ gibt das im metalink gespeicher xml-file zurueck"""
96: url = self.metalink
97: txt=""
98: logging.debug("ml:%s"%url)
99: try:
100: page = urllib.urlopen(url);
101: if RESPONSE:
102: RESPONSE.setHeader("Content-Type","text/xml")
103:
104: txt = page.read();
105: except:
106: logging.error("Cannot read metadata of: %s"%self.getId())
107:
108: return txt
109:
110: def reindex(self):
111: """generate fields for indexing and reindex"""
112:
113: #TODO: korrigieren des metalink pfades konfigurierbar machen
114: splitted= [x for x in urlparse.urlparse(self.metalink)]
115: splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
116:
117: if splitted[0]=="http":
118: self.metalink=urlparse.urlunparse(splitted)
119:
120:
121: self.fullTextUrl=self.getFullTextXML(noredirect="yes")
122:
123: #TODO: korrigieren relative url to absoluter url volltexten, konfigurierbar?
124: splitted= [x for x in urlparse.urlparse(self.fullTextUrl)]
125: if splitted[0]=="":
126: splitted[0]="http"
127: splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
128:
129: self.fullTextUrl=urlparse.urlunparse(splitted)
130:
131: self.imagePath=self.getImagePath()
132:
133: self.reindex_object()
134:
135:
136: security.declareProtected('View','createPDF')
137: def createPDF(self,RESPONSE=None,local=None,dpi=150):
138: """erzeuge pdf file"""
139: pages=1
140: dpi=float(dpi)
141: imagePath=self.getImagePath().replace("/mpiwg/online","")
142:
143:
144: image="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn="+imagePath+"&dw=%i&dh=%i&pn=%i"
145: xmlInfo="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/dlInfo-xml.jsp?fn="+imagePath
146:
147: dom=xml.dom.minidom.parse(urllib.urlopen(xmlInfo))
148: for parameter in dom.getElementsByTagName('parameter'):
149: if parameter.getAttribute('name')=="pt":
150: pages=int(parameter.getAttribute('value'))
151: break
152:
153:
154: tempdir="/tmp/archivesImageServer"
155: if not os.path.exists(tempdir):
156: os.mkdir(tempdir)
157:
158: tmpPath=tempfile.mkdtemp(dir=tempdir)
159:
160:
161: tmpZip=tempfile.mktemp(dir=tempdir)
162:
163: tmpFn=os.path.split(tmpZip)[1]
164:
165:
166:
167:
168: if RESPONSE:
169: RESPONSE.setHeader("Content-Type","text/html")
170: RESPONSE.write("<h1>I am creating the pdf</h1>")
171: txt="<h3>1. step: getting the images( %i pages)</h3>"%pages
172: RESPONSE.write(txt)
173:
174: c=canvas.Canvas(tmpZip)
175: for i in range(1,pages+1):
176: if RESPONSE:
177: RESPONSE.write(str("<p>Get Page: %i<br>\n"%i))
178: faktor=dpi/72.0
179:
180: fn=tmpPath+"/%i"%i
181:
182: width,height=A4
183: #print image%(width*faktor,height*faktor,i)
184: url=urllib.urlopen(image%(width*faktor,height*faktor,i)).read()
185: fh=file(fn,"w")
186: fh.write(url)
187: fh.close()
188:
189:
190:
191: c.drawImage(fn,0,0,width=width,height=height)
192: c.showPage()
193: c.save()
194: if RESPONSE:
195: RESPONSE.write("<p>finished<br>\n")
196:
197: if RESPONSE:
198: len=os.stat(tmpZip)[6]
199: downloadUrl=self.absolute_url()+"/downloadPDF"
200: RESPONSE.write("""<h1><a href="downloadPDF?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
201: RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>
202: <p><a href="downloadPDF?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))
203: RESPONSE.close()
204:
205:
206: def downloadPDF(self,fn):
207: """download prepared set"""
208: filename="/tmp/archivesImageServer/"+fn
209: namePDF=self.getId()+".pdf"
210: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%namePDF)
211: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
212: len=os.stat(filename)[6]
213: self.REQUEST.RESPONSE.setHeader("Content-Length",len)
214: images=file(filename).read()
215: self.REQUEST.RESPONSE.write(images)
216: self.REQUEST.RESPONSE.close()
217:
218:
219: def getRDF(self,urn=None):
220: """rdf"""
221: ap = self.getArchivePathFromMetadata()
222:
223:
224: ret=getRDFDescription(self,self.link,urn=urn,ap=ap)
225:
226: return ret+self.createSubElementRDF(urn=urn)
227:
228:
229: def changeAccessRightForm(self,preselect=None):
230: """change the access rights"""
231:
232: pt=zptFile(self, 'zpt/ChangeECHO_resourceAccessRight.zpt')
233: return pt(preselect=preselect)
234:
235: def changeAccessRight(self):
236: """changeRights"""
237: argv=self.REQUEST.form
238: self.setAccessRightXML(argv["%s_xml"%self.getId()])
239: self.accessRight=argv["%s_echo"%self.getId()]
240:
241: self.REQUEST.RESPONSE.redirect('manage_main')
242:
243:
244: def getAccessRightSelectorHTML(self,outlook="select",xmldominant=None,preselect=None):
245: """htmlselector, xmldominant= in der regel wird der wert des xmlfiles ausgegeben ausser er existiert nicht"""
246: values=['','free','MPIWG']
247:
248: if preselect:#set all to the preselected
249: ar=(preselect,preselect)
250: else:#else set to actual value
251: ar=self.getAccessRightMD()
252:
253: if outlook=="select":
254: ret="""<select name="%s_xml">"""%self.getId()
255: ret1="""<select name="%s_echo">"""%self.getId()
256: for value in values:
257: if value==ar[0]:
258: ret+="<option selected>%s</option>"%value
259: else:
260: ret+="<option>%s</option>"%value
261:
262: if value==ar[1]:
263: ret1+="<option selected>%s</option>"%value
264: else:
265: ret1+="<option>%s</option>"%value
266:
267:
268: if not xmldominant:
269: return ret+"</select>",ret1+"</select>"
270: else:
271: if ar[0] is not None:
272: return ret+"</select>"
273: else:
274: return "<p>No xml file (only local selection):"+ret1
275:
276: else:
277: ret=""
278: ret1=""
279: for value in values:
280:
281: if value==ar[0]:
282: ret+="""<input type="radio" name="%s_xml" value="%s" checked>%s"""%(self.getId(),value,value)
283: else:
284: ret+="""<input type="radio" name="%s_xml" value="%s">%s"""%(self.getId(),value,value)
285:
286: if value==ar[1]:
287: ret1+="""<input type="radio" name="%s_echo" value="%s" checked>%s"""%(self.getId(),value,value)
288: else:
289: ret1+="""<input type="radio" name="%s_echo" value="%s">%s"""%(self.getId(),value,value)
290:
291: if not xmldominant:
292: return ret,ret1
293: else:
294: if ar[0]:
295: return ret
296: else:
297: return "<p>No xml file (only local selection)</p>"+ret1
298:
299:
300:
301: def copyAccessRightsFromMD(self):
302: """kopiere rechte aus den metadaten"""
303: self.accessRight=self.getAccessRightMD()[0]
304:
305:
306:
307:
308:
309: def getAccessRightMD(self):
310: """set accessright"""
311: url=self.metalink
312:
313: try:
314: urllib.urlopen(url)
315: except:
316: logger("ECHO_Resource (getAccessRightMD)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
317:
318: return None,getattr(self,'accessRight','')
319:
320:
321: try:
322: dom = NonvalidatingReader.parseUri(url)
323: except:
324: logger("ECHO_Resource (getAccessRightMD)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
325: return (None,"Cannot parse: "+url+"<br>"+"%s (%s)"%sys.exc_info()[0:2])
326:
327:
328: accessright=dom.xpath("//meta/access-conditions/access/@type")
329: if accessright:
330: accessright=accessright[0].value
331: if str(accessright)=='institution':
332: tmp=dom.xpath("//meta/access-conditions/access/name")
333: if tmp:
334: accessright=getTextFromNode(tmp[0])
335:
336: if not accessright:
337: accessright=""
338:
339: return accessright,getattr(self,'accessRight','')
340:
341: def changeAccessRightMD(self,accessright,RESPONSE=None):
342: """change the rights - not user anymore"""
343: #TODO: check if method still needed
344: params="accessright=%s"%accessright
345:
346:
347: #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()
348:
349: tries=0
350: for i in range(10):
351: 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()
352: if x=="ok":
353:
354: break;
355:
356:
357:
358: if RESPONSE is not None:
359: RESPONSE.redirect('manage_main')
360:
361:
362: def setAccessRightXML(self,accessright):
363: """set accessright"""
364: url=self.metalink
365: accessrights=['MPIWG','free']#allowes rights
366:
367: if accessright =='':
368: """do nothing"""
369: return ""
370:
371:
372: try:
373: geturl=""
374: for line in ECHO_helpers.urlopen(url).readlines():
375: geturl=geturl+line
376:
377:
378: except:
379: return (None,"Cannot open: "+url)
380:
381: try:
382: dom=xml.dom.minidom.parseString(geturl)
383: root=dom.getElementsByTagName('resource')[0]
384: except:
385: return (None,"Cannot parse: "+url+"<br>"+geturl)
386:
387: metamains=dom.getElementsByTagName('meta')
388:
389: if not metamains:
390: nodenew=dom.createElement('meta')
391: root.appendChild(nodenew)
392: metamain=nodenew
393: else:
394: metamain=metamains[0]
395:
396:
397: metanodes=metamain.getElementsByTagName('access-conditions')
398:
399: if not metanodes:
400: nodenew=dom.createElement('access-conditions')
401: metamain.appendChild(nodenew)
402: metanode=nodenew
403: else:
404: metanode=metanodes[0]
405:
406: accesses=metanode.getElementsByTagName('access')
407:
408: #delete old
409: if accesses:
410: metanode.removeChild(accesses[0]).unlink()
411:
412: #create new
413:
414: nodenew2=dom.createElement('access')
415: metanode.appendChild(nodenew2)
416: metanode2=nodenew2
417:
418: attribute=metanode2.getAttribute('type')
419:
420: if accessright=="free":
421:
422: metanode2.setAttribute('type','free')
423:
424: elif accessright.upper()=='MPIWG':
425: metanode2.setAttribute('type','institution')
426: nodenew4=dom.createElement('name')
427: metanodetext=dom.createTextNode('MPIWG')
428: nodenew4.appendChild(metanodetext)
429: nodenew2.appendChild(nodenew4)
430: #print dom.toxml().encode('utf-8')
431: string= encodeRPC(dom.toxml().encode('utf-8'))
432:
433: #TODO: make server configurable
434: server=xmlrpclib.Server("http://foxridge.mpiwg-berlin.mpg.de/server")
435:
436: path=urlparse.urlparse(self.metalink)[2]
437:
438: server.writeMetaDataFile(path,string,"yes")
439:
440:
441: def createImageUrl(self,pn=1):
442: """create ImageUrl"""
443:
444:
445: resourcepath=readFieldFromXML_xpath(self.metalink,'//resource/archive-path')
446:
447: digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
448: images=readFieldFromXML(self.metalink,'texttool','image')
449:
450:
451: if (not resourcepath) or (not digiliburlprefix) or (not images):
452: logger("ECHO (createImageUrl)",logging.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())
453: return None
454: resourcepath=resourcepath.replace('/mpiwg/online','')
455: if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"
456:
457: if (not images) or (not resourcepath): return None
458:
459: return "%sfn=%s&pn=%i"%(digiliburlprefix,resourcepath+"/"+images,pn)
460:
461: def copyTitleToInfoXML(self,RESPONSE=None):
462: """copy title from the resource"""
463: presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')
464: resourcepath=readFieldFromXML_xpath(self.metalink,'//resource/archive-path')
465: if (not presentationXML) or (not resourcepath):
466: if RESPONSE:
467: RESPONSE.write("Error: %s\n"%self.getId())
468: else:
469: return None,self.absolute_url()
470:
471: try:
472: fh=file(os.path.join(resourcepath,presentationXML),'w')
473: fh.write("""<info>
474: <author></author>
475: <title>%s</title>
476: <date></date>
477: <display>yes</display>
478: </info>"""%self.title)
479: fh.close()
480: return 1,self.getId()
481: except:
482: if RESPONSE:
483: RESPONSE.write("Error: %s\n"%self.getId())
484: else:
485: return None,self.absolute_url()
486:
487:
488:
489: def changeViewerTemplateSetForm(self):
490: """change the viewer template set"""
491: pt=zptFile(self, 'zpt/changeResourceViewerTemplateSet')
492: return pt()
493:
494:
495: def setLink(self, link=None):
496: """change link field"""
497: if link is not None:
498: self.link = link
499:
500:
501: def getTextToolsField(self,name,default=''):
502: """Lese Textoolsfelder aus index.meta im path aus"""
503:
504: try:
505: dom=xml.dom.minidom.parse(self.metalink)
506: node=dom.getElementsByTagName('texttool')[0] #getNode
507: subnode=node.getElementsByTagName(name)[0]
508:
509: # bei text wird nur der Folder gebraucht
510: if name=="text":
511: splitted=getText(subnode.childNodes).split("/")
512: return splitted[len(splitted)-2]
513: else:
514: return getText(subnode.childNodes)
515: except:
516: return default
517:
518:
519:
520:
521: security.declarePublic('content_html')
522: def content_html(self):
523: """template fuer content"""
524: return ECHO_basis.content_html(self,'resource')
525:
526: # def getViewClassification(self):
527: # if hasattr(self,'viewClassification'):
528: # return self.viewClassification
529: # else:
530: # return ""
531:
532: def getFullTextXML(self,noredirect=None):
533: """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
534:
535: try:
536: #logger("ECHO Fulltext",logging.INFO,"open %s"%self.metalink)
537: fh=ECHO_helpers.urlopen(self.metalink)
538: #logger("ECHO Fulltext",logging.INFO,"opened %s"%self.metalink)
539: dom=xml.dom.minidom.parse(fh)
540: texttools=dom.getElementsByTagName('texttool')
541: text=texttools[0].getElementsByTagName('text')
542: texturl=getText(text[0].childNodes)
543:
544: #logger("ECHO Fulltext",logging.INFO,"found %s"%texturl)
545: fh.close()
546: #logger("ECHO Fulltext",logging.INFO,"closed fh")
547: #keine url
548: if not (texturl.split(":")[0] in ['http','ftp','file']):
549: if not noredirect:
550: return file(texturl).read()
551: else:
552: return texturl
553:
554: if not noredirect:
555: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
556: logger("ECHO Fulltext",logging.INFO,"redirect to:%s"%texturl)
557: self.REQUEST.RESPONSE.redirect(texturl)
558: else:
559: return texturl
560: except:
561:
562: if not noredirect:
563: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
564: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
565: else:
566: return "<error>no fulltext available</error>"
567:
568: def getImagePath(self):
569: """gibt pfad zum image aus"""
570: return self.getImageView(noredirect="yes",onlyPath="yes")
571:
572: def getArchivePathFromMetadata(self):
573: try:
574: archivePath=readFieldFromXML_xpath(self.metalink,"//resource/archive-path")
575: return archivePath
576: except:
577: return ""
578:
579: def getImageView(self,noredirect=None,onlyPath=None):
580: """getImages; give Imageviewr and <error></error> if somthing goes wrong."""
581: try:
582: archivePath=readFieldFromXML_xpath(self.metalink,"//resource/archive-path")
583:
584: archivepath=re.sub('/mpiwg/online/','',archivepath)
585: imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
586: fh.close()
587:
588: if not noredirect:
589: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
590: self.REQUEST.RESPONSE.redirect(imageurl)
591: else:
592: if not onlyPath:
593: return imageurl
594: else:
595: return archivepath+"/"+imagetemp
596: except:
597:
598: if not noredirect:
599: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
600: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
601: else:
602: return "<error>no images available</error>"
603:
604:
605: def getCopyrightsHTML(self):
606: """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
607:
608: if hasattr(self,'copyrightModel'):
609: obj=self.copyrightModel
610:
611: else:
612: return "ERROR"
613: ret=[]
614:
615: for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
616:
617:
618: try:
619: if hasattr(self.copyrightTypes,copyright[2]):
620: copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
621: link="copyrightTypes/"+copyright[2]+'/copyright.html'
622: else:
623: copyrightTypeObj=getattr(obj,copyright[2])
624: link="copyrightModel/"+copyright[2]+'/copyright.html'
625:
626: label=copyrightTypeObj.label
627: url=getattr(copyrightTypeObj, 'url', '')
628:
629: if url!='':
630: ret.append((url,copyright[0],copyright[1],copyright[2],label))
631: else:
632: if hasattr(copyrightTypeObj, 'copyright.html'):
633: ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
634: else:
635: ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
636: except:
637: """nothing"""
638:
639: return ret
640:
641: def getInstitutionsHTML(self):
642: """gibt Liste der foerdernden Institutionen aus"""
643:
644: if hasattr(self,'support'):
645: obj=self.support
646: ret=obj.getSupporter()
647: return ret
648: else:
649: return ''
650:
651: def getOwnerOriginalsHTML(self):
652: """gibt Liste der foerdernden Institutionen aus"""
653:
654: if hasattr(self,'ownerOriginal'):
655: obj=self.ownerOriginal
656: ret=obj.getOwner()
657: return ret
658: else:
659: return ''
660:
661: def getDigiCopyByHTML(self):
662: """gibt Liste der foerdernden Institutionen aus"""
663:
664: if hasattr(self,'digiCopyBy'):
665: obj=self.digiCopyBy
666: ret=obj.getDigiCopyBy()
667: return ret
668: else:
669: return ''
670:
671: def getCredits(self):
672: """Ausgabe der credits"""
673: if self.credits:
674: return self.credits
675: else:
676: return []
677:
678:
679: def getStorageManagerResourceURL(self):
680: """get the link to storage"""
681: urlbase=self.getStorageManagerURL();
682:
683: #now get the path from the metadatalink
684:
685: path = self.correctPath(self.getMetaDataLink())
686: if path is None:
687: return ""
688: else:
689: path=path.replace("index.meta","")
690: return urlbase+path
691:
692:
693: def correctPath(self,path):
694: #take only the path of the url which starts with /permanent or /experimental
695:
696: rs= re.search("/permanent/(.*)", path);
697: if rs is not None:
698: txt="permanent/"+rs.group(1)
699: else:
700: rs= re.search("/experimental/(.*)", path);
701: if rs is not None:
702: txt="experimental"+rs.group(1)
703: else:
704: return None
705:
706: return txt
707:
708: def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
709:
710: self.id = id
711: """Festlegen der ID"""
712:
713: self.label = label
714: self.link= link
715: self.metalink=metalink
716: self.title=title
717: self.weight=weight
718: self.credits=toList(credits)
719: self.description=description
720: self.contentType=contentType
721: self.copyrightType=copyrightType
722: self.renderingType=renderingType
723: self.responsible=responsible
724: self.resourceID=resourceID
725:
726: if coords:
727: coordsnew=[ string.split(x,",") for x in coords]
728: else:
729: coordsnew=[]
730:
731: self.coords=coordsnew
732: # self.viewClassification=""
733:
734:
735:
736: def getContentType(self):
737: try:
738: return normalizeCt(self.contentType)
739: except:
740: return ""
741:
742: def getCopyrightType(self):
743: try:
744: return self.copyrightType
745: except:
746: return ""
747:
748: def getRenderingType(self):
749: try:
750: return self.renderingType
751: except:
752: return ""
753:
754: def ECHO_resource_config(self):
755: """Main configuration"""
756:
757: if not hasattr(self,'weight'):
758: self.weight=""
759:
760: pt=zptFile(self, 'zpt/ChangeECHO_resource.zpt')
761: return pt()
762:
763:
764: def ECHO_resource_config_main(self):
765: """Main configuration"""
766: if not hasattr(self,'weight'):
767: self.weight=""
768: pt=zptFile(self, 'zpt/ChangeECHO_resource_main.zpt')
769: return pt()
770:
771: def ECHO_resource_config_coords(self):
772: """Coords configuration """
773: pt=zptFile(self, 'zpt/ChangeECHO_resource_coords.zpt')
774: return pt()
775:
776: def ECHO_resource_config_credits(self):
777: """Main configuration"""
778: pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
779: return pt()
780:
781:
782: def changeViewer(self,newViewer):
783: """set newViewer to the url of the new viewer
784: only if metalink is set, otherwise it gives false
785: """
786:
787: texterUrl="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn=/"
788:
789: vl,msg=self.checkValidityOfMetaLink()
790:
791: if not vl: #ungueltiger link, versuche neuen
792: newStr=re.match(".*/mpiwg/online/(.*)",self.metalink) # suche pfad hinter /mpiwg/online
793: oldLink=self.metalink
794:
795: if newStr:
796: self.metalink=texterUrl+newStr.group(1)
797: vl,msg=self.checkValidityOfMetaLink()
798: else:
799: logging.error("change Viewer XX(mew Metadatafile) %s"%self.metalink)
800: vl=False
801:
802: if not vl: # geht immer noch nicht, dann setzte wieder zurueck
803: self.metalink=oldLink
804:
805: logging.info("change Viewer (mew Metadatafile) %s"%self.metalink)
806:
807: if vl:
808: self.newViewer=newViewer
809: return vl,msg
810: else:
811: return vl,msg
812:
813: def checkValidityOfMetaLink(self):
814: """checks if the metalink is valid xml"""
815:
816: ml=self.metalink
817:
818: try:
819: txt=urllib.urlopen(ml)
820:
821: except:
822: return False,"Cannot open: %s)"%ml
823:
824: txt.close()
825: try:
826: dom = NonvalidatingReader.parseUri(ml)
827: except:
828: return False, "Connot parse: %s)"%ml
829:
830: if len(dom.xpath("//texttool"))==0:
831: return False, "No texttools: %s)"%ml
832:
833: return True,""
834:
835: def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,newViewer='',RESPONSE=None):
836: """Aenderung der Properties"""
837: self.resourceID=resourceID
838: self.title=title
839: self.label=label
840: self.description=description
841:
842: self.contentType=contentType
843: self.renderingType=renderingType
844: self.weight=weight
845:
846: self.link=link
847: self.metalink=metalink
848:
849: self.newViewer=newViewer
850:
851:
852: if RESPONSE is not None:
853: RESPONSE.redirect('manage_main')
854:
855:
856: def changeECHO_resource_coords(self,RESPONSE=None):
857: """Aenderung der Properties - coords"""
858: #return self.REQUEST
859: for area in self.getMapAreas():
860: id = area.getId()
861: if self.REQUEST.has_key('del.'+id):
862: # delete this area
863: self._delObject(id)
864: # return to same menu
865: if RESPONSE is not None:
866: RESPONSE.redirect('ECHO_resource_config_coords')
867: return
868: # modify this area
869: coordstring = self.REQUEST.get('coords.'+id, '')
870: coords = string.split(coordstring, ',')
871: angle = self.REQUEST.get('angle.'+id, '0')
872: type = self.REQUEST.get('type.'+id, 'area')
873: if len(coords) == 4:
874: area.setCoordString(coordstring)
875: area.setAngle(angle)
876: area.setType(type)
877: # return to main menu
878: if RESPONSE is not None:
879: RESPONSE.redirect('manage_main')
880:
881:
882: def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
883: """Aenderung der Properties"""
884: self.credits=credits
885: self.responsible=responsible
886: self.copyrightType=copyrightType
887:
888: if RESPONSE is not None:
889: RESPONSE.redirect('manage_main')
890:
891:
892:
893: def changeECHO_resource_metadata(self,RESPONSE=None):
894: """change metadata"""
895:
896: self.copyIndex_meta2echo_resource()
897: tags=mappedData.keys()
898:
899:
900: for field in tags:
901: try:
902: self.metaDataHash[field]=self.REQUEST.form[field]
903:
904: except:
905: logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
906:
907: logging.debug("changeECHO_resource_metadata:"+repr(self.newMetaXML()))
908:
909:
910: mc = MetaDataClient("http://content.mpiwg-berlin.mpg.de/metaDataServer")
911: x=mc.writeMetaDataFile(self.getMetaDataLink(),self.newMetaXML(),compressed=None)
912:
913: logging.debug("changeECHO_resource_metadata (xlrpc return):"+repr(x))
914:
915:
916: if RESPONSE is not None:
917: RESPONSE.redirect('manage_main')
918:
919:
920:
921: def getMDValueSimpleSearchField(self):
922: """returns value for simple search aus DC daten"""
923:
924:
925: bibdata=self.getMetaDataManager().getBibData(path=self.getMetaDataLink())
926: dcMapped = self.getMetaDataManager().getDCMappedData(bibdata)
927: logging.debug("getMDValueSimpleSearchField:"+ repr(dcMapped))
928: return " ".join([dcMapped.get('title',''),
929: dcMapped.get('creator',''),
930: dcMapped.get('year',''),self.getTitle()])
931:
932:
933:
934: def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
935: """new index.meta"""
936: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
937:
938: if not hasattr(self,'metaDataHash'):
939:
940: self.copyIndex_meta2echo_resource()
941:
942: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
943:
944: def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
945: """return bibliographical metadata as stored in the object"""
946:
947: try:
948:
949: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
950: except:
951: return "<error> no metadata stored</error>"
952:
953: def getXQueryMetaData(self,xquery):
954: '''
955: execute an xquery on the metadata and returns a list of tuples,
956: each tuple represent the content of the node as text and the whole node as xml-fragment
957: @param xquery: xquery auf den metadaten
958: '''
959:
960: try:
961: md=writeMetadata(self.metalink,self.metaDataHash,xmlfrag="yes")
962: except:
963: return None
964:
965: dom = NonvalidatingReader.parseString(md,"http://www.mpiwg-berlin.mpg.de/")
966:
967: results=Ft.Xml.XPath.Evaluate(xquery, contextNode=dom)
968:
969: ret=[]
970: for result in results:
971:
972: buf = cStringIO.StringIO()
973: PrettyPrint(result, stream=buf)
974: str = buf.getvalue()[0:]
975: buf.close()
976: ret.append((getTextFromNode(result),str))
977:
978: return ret
979:
980: def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
981: """prints out metadata as stored in the echo environment, format is the index.meta format"""
982: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
983: return writeMetadata(self.metalink,self.metaDataHash)
984:
985: def getMetaDataLink(self):
986: """get link to the meta data"""
987: return self.metalink
988:
989: def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
990: """Aenderung der Properties"""
991:
992: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
993: self.link=link
994: self.metalink=metalink
995:
996: if RESPONSE is not None:
997: RESPONSE.redirect('manage_main')
998:
999:
1000: manage_options = (
1001: {'label':'Main Config','action':'ECHO_resource_config_main'},
1002: {'label':'Edit Metadata','action':'ECHO_getResourceMD'},
1003: {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
1004: {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
1005: {'label':'set/change startpage','action':'setStartPageForm'},
1006: {'label':'Change AccessRights','action':'changeAccessRightForm'},
1007: ) + Folder.manage_options
1008:
1009:
1010:
1011:
1012:
1013: def getMetaDataHash(self):
1014: """md hash"""
1015:
1016: return getattr(self,'metaDataHash',{})
1017:
1018: def getMetaDataValue(self,fieldName):
1019:
1020: self.copyIndex_meta2echo_resource()
1021: return self.metaDataHash.get(fieldName,{}).get('value','')
1022:
1023: def findLabelsFromMapping(self,referenceType):
1024: """gib hash mit label -> generic zurueck"""
1025: #return {},[]
1026: mo=self.getMetaDataManager().getBibMapping(referenceType)
1027:
1028: if mo is None:
1029: return [],{}
1030:
1031: return mo.getFieldList(),mo.getFields()
1032:
1033: def findTagsFromMapping(self,referenceType):
1034: """gib hash mit label -> generic zurueck"""
1035:
1036: return self.findLabelsFromMapping(referenceType)
1037:
1038:
1039:
1040: def copyIndex_meta2echo_resource(self,RESPONSE=None):
1041: #copy MD von Index_meta to the echo_resource
1042:
1043: logging.debug("copyIndex_meta2echo_resource:"+self.metalink)
1044: md = self.getMetaDataManager().getBibData(path=self.metalink)
1045: logging.debug("copyIndex_meta2echo_resource:"+repr(md))
1046: self.metaDataHash=self.getMetaDataManager().getBibMappedData(md)
1047: logging.debug("copyIndex_meta2echo_resource:"+repr(self.metaDataHash))
1048:
1049: self.contentType=normalizeCt(self.metaDataHash.get('@type',''))
1050:
1051: return
1052:
1053: def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"):
1054: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
1055: #(metadict, error)=readMetadata(self.metalink)
1056: logging.debug("getMetaData:"+self.metalink)
1057:
1058: self.copyIndex_meta2echo_resource()
1059: if back:
1060: self.REQUEST.SESSION['back']=back
1061:
1062: if (not self.contentType) or (overwrite=="yes"):
1063: self.contentType=normalizeCt(normalizeCt(self.metaDataHash.get('@type','')).lower())
1064:
1065: if not (normalizeCt(self.contentType).lower()==normalizeCt(self.contentType).lower()):
1066: self.REQUEST.SESSION['contentStorage']=normalizeCt(self.contentType)
1067: self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)
1068:
1069: return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
1070:
1071: #self.REQUEST.SESSION['metadict']=metadict
1072:
1073:
1074: if template=="yes":
1075: #pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_resourceMD.zpt'),metadict=metadict).__of__(self)
1076: pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
1077:
1078: return pt(metadict=self.metaDataHash)
1079:
1080:
1081:
1082:
1083:
1084: # def ECHO_getMD(self,item):
1085: # """Ausgabe der MD"""
1086: # return getattr(self,item)
1087:
1088: def checkRDF(self,path):
1089: """check if pdf in the path"""
1090: try:
1091: for fileName in os.listdir(path):
1092: if os.path.splitext(fileName)[1]==".pdf":
1093: return os.path.join(path,fileName)
1094: return None
1095: except:
1096: return None
1097:
1098:
1099: security.declareProtected('View','index_html')
1100: def index_html(self):
1101: """standard page"""
1102: pdf=self.checkRDF(self.link)
1103: if pdf:
1104: fh=file(pdf,'r').read()
1105: self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
1106: self.REQUEST.RESPONSE.write(fh)
1107: self.REQUEST.RESPONSE.close()
1108: return
1109:
1110: if getattr(self,'newViewer',''): #benutze den neuen viewer
1111: url=self.newViewer+'url='+self.metalink+"&mode=texttool"
1112: return self.REQUEST.RESPONSE.redirect(url)
1113:
1114: return self.REQUEST.RESPONSE.redirect(self.link)
1115:
1116: def startpage_html(self):
1117: """prints out a startpage for a resource for use e.g. in the BVE"""
1118:
1119: # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
1120:
1121: sp=self.ZopeFind(self,obj_ids=['startpage.html'])
1122:
1123: if sp:
1124: return sp[1]()
1125:
1126: #pruefen ob irgendwo ein template
1127: if hasattr(self,'startpage_index_template'):
1128: return self.startpage_index_template()
1129:
1130: #generisches template ausgeben
1131:
1132: pt=zptFile(self, 'zpt/ECHO_startpage_index_template_standard.zpt')
1133: pt.content_type="text/html"
1134: return pt()
1135:
1136: def toc_html(self):
1137:
1138: sp=self.ZopeFind(self,obj_ids=['toc.html'])
1139:
1140: if sp:
1141: return sp[0][1]()
1142:
1143:
1144: security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
1145:
1146: def generate_label(self):
1147: """Erzeugt_standard_Label aus Template"""
1148: self.label=self.getMetaDataManager().getBibFormattedLabel(path=self.metalink)
1149: return self.label
1150:
1151:
1152: security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
1153:
1154: def generate_title(self,RESPONSE=None):
1155: """Erzeugt_standard_Label aus Template"""
1156: self.title=self.generate_label();
1157: return self.title
1158:
1159: Globals.InitializeClass(ECHO_resource)
1160:
1161: def manage_addECHO_resourceForm(self):
1162: """Form for adding a ressource"""
1163: pt=zptFile(self, 'zpt/AddECHO_resourceForm.zpt')
1164: return pt()
1165:
1166:
1167:
1168: 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):
1169: """addresource"""
1170:
1171: newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
1172:
1173: self._setObject(id,newObj)
1174:
1175: if RESPONSE is not None:
1176: RESPONSE.redirect('manage_main')
1177:
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