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