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