Annotation of ECHO_content/ECHO_resource.py, revision 1.6.2.2
1.6.2.1 dwinter 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:
1.1 dwinter 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
1.2 dwinter 30: try:
31: from Products.MetaDataProvider.MetaDataClient import MetaDataClient
32: except:
33: print "no metadata services"
1.1 dwinter 34: import urllib
35: import urllib2
36: import cgi
37: import smtplib
38: import time
1.6.2.1 dwinter 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
1.1 dwinter 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:
1.6.2.1 dwinter 76: # viewClassificationList=viewClassificationListMaster
77:
1.1 dwinter 78:
1.6.2.1 dwinter 79:
1.1 dwinter 80: def PrincipiaSearchSource(self):
81: """Return cataloguable key for ourselves."""
82: return str(self)
83:
84: getSubCols = ECHO_helpers.getSubCols
1.6.2.1 dwinter 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)
1.1 dwinter 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"""
1.3 dwinter 221: ap = self.getArchivePathFromMetadata()
222:
223:
224: ret=getRDFDescription(self,self.link,urn=urn,ap=ap)
1.4 dwinter 225:
1.1 dwinter 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:
1.5 dwinter 445: resourcepath=readFieldFromXML_xpath(self.metalink,'//resource/archive-path')
1.1 dwinter 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')
1.5 dwinter 464: resourcepath=readFieldFromXML_xpath(self.metalink,'//resource/archive-path')
1.1 dwinter 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:
490:
491: def setLink(self, link=None):
492: """change link field"""
493: if link is not None:
494: self.link = link
495:
496:
497: def getTextToolsField(self,name,default=''):
498: """Lese Textoolsfelder aus index.meta im path aus"""
499:
500: try:
501: dom=xml.dom.minidom.parse(self.metalink)
502: node=dom.getElementsByTagName('texttool')[0] #getNode
503: subnode=node.getElementsByTagName(name)[0]
504:
505: # bei text wird nur der Folder gebraucht
506: if name=="text":
507: splitted=getText(subnode.childNodes).split("/")
508: return splitted[len(splitted)-2]
509: else:
510: return getText(subnode.childNodes)
511: except:
512: return default
513:
514:
515:
516:
517: security.declarePublic('content_html')
518: def content_html(self):
519: """template fuer content"""
520: return ECHO_basis.content_html(self,'resource')
521:
522: # def getViewClassification(self):
523: # if hasattr(self,'viewClassification'):
524: # return self.viewClassification
525: # else:
526: # return ""
527:
528: def getFullTextXML(self,noredirect=None):
529: """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
530:
531: try:
532: #logger("ECHO Fulltext",logging.INFO,"open %s"%self.metalink)
533: fh=ECHO_helpers.urlopen(self.metalink)
534: #logger("ECHO Fulltext",logging.INFO,"opened %s"%self.metalink)
535: dom=xml.dom.minidom.parse(fh)
536: texttools=dom.getElementsByTagName('texttool')
537: text=texttools[0].getElementsByTagName('text')
538: texturl=getText(text[0].childNodes)
539:
540: #logger("ECHO Fulltext",logging.INFO,"found %s"%texturl)
541: fh.close()
542: #logger("ECHO Fulltext",logging.INFO,"closed fh")
543: #keine url
544: if not (texturl.split(":")[0] in ['http','ftp','file']):
545: if not noredirect:
546: return file(texturl).read()
547: else:
548: return texturl
549:
550: if not noredirect:
551: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
552: logger("ECHO Fulltext",logging.INFO,"redirect to:%s"%texturl)
553: self.REQUEST.RESPONSE.redirect(texturl)
554: else:
555: return texturl
556: except:
557:
558: if not noredirect:
559: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
560: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
561: else:
562: return "<error>no fulltext available</error>"
563:
564: def getImagePath(self):
565: """gibt pfad zum image aus"""
566: return self.getImageView(noredirect="yes",onlyPath="yes")
567:
1.3 dwinter 568: def getArchivePathFromMetadata(self):
569: try:
1.5 dwinter 570: archivePath=readFieldFromXML_xpath(self.metalink,"//resource/archive-path")
571: return archivePath
1.3 dwinter 572: except:
573: return ""
574:
1.1 dwinter 575: def getImageView(self,noredirect=None,onlyPath=None):
576: """getImages; give Imageviewr and <error></error> if somthing goes wrong."""
577: try:
1.5 dwinter 578: archivePath=readFieldFromXML_xpath(self.metalink,"//resource/archive-path")
579:
1.1 dwinter 580: archivepath=re.sub('/mpiwg/online/','',archivepath)
581: imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
582: fh.close()
583:
584: if not noredirect:
585: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
586: self.REQUEST.RESPONSE.redirect(imageurl)
587: else:
588: if not onlyPath:
589: return imageurl
590: else:
591: return archivepath+"/"+imagetemp
592: except:
593:
594: if not noredirect:
595: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
596: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
597: else:
598: return "<error>no images available</error>"
599:
600:
601: def getCopyrightsHTML(self):
602: """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
603:
604: if hasattr(self,'copyrightModel'):
605: obj=self.copyrightModel
606:
607: else:
608: return "ERROR"
609: ret=[]
610:
611: for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
612:
613:
614: try:
615: if hasattr(self.copyrightTypes,copyright[2]):
616: copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
617: link="copyrightTypes/"+copyright[2]+'/copyright.html'
618: else:
619: copyrightTypeObj=getattr(obj,copyright[2])
620: link="copyrightModel/"+copyright[2]+'/copyright.html'
621:
622: label=copyrightTypeObj.label
623: url=getattr(copyrightTypeObj, 'url', '')
624:
625: if url!='':
626: ret.append((url,copyright[0],copyright[1],copyright[2],label))
627: else:
628: if hasattr(copyrightTypeObj, 'copyright.html'):
629: ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
630: else:
631: ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
632: except:
633: """nothing"""
634:
635: return ret
636:
637: def getInstitutionsHTML(self):
638: """gibt Liste der foerdernden Institutionen aus"""
639:
640: if hasattr(self,'support'):
641: obj=self.support
642: ret=obj.getSupporter()
643: return ret
644: else:
645: return ''
646:
647: def getOwnerOriginalsHTML(self):
648: """gibt Liste der foerdernden Institutionen aus"""
649:
650: if hasattr(self,'ownerOriginal'):
651: obj=self.ownerOriginal
652: ret=obj.getOwner()
653: return ret
654: else:
655: return ''
656:
657: def getDigiCopyByHTML(self):
658: """gibt Liste der foerdernden Institutionen aus"""
659:
660: if hasattr(self,'digiCopyBy'):
661: obj=self.digiCopyBy
662: ret=obj.getDigiCopyBy()
663: return ret
664: else:
665: return ''
666:
667: def getCredits(self):
668: """Ausgabe der credits"""
669: if self.credits:
670: return self.credits
671: else:
672: return []
673:
674:
675: def getStorageManagerResourceURL(self):
676: """get the link to storage"""
677: urlbase=self.getStorageManagerURL();
678:
679: #now get the path from the metadatalink
680:
681: path = self.correctPath(self.getMetaDataLink())
682: if path is None:
683: return ""
684: else:
685: path=path.replace("index.meta","")
686: return urlbase+path
687:
688:
689: def correctPath(self,path):
690: #take only the path of the url which starts with /permanent or /experimental
691:
692: rs= re.search("/permanent/(.*)", path);
693: if rs is not None:
694: txt="permanent/"+rs.group(1)
695: else:
696: rs= re.search("/experimental/(.*)", path);
697: if rs is not None:
698: txt="experimental"+rs.group(1)
699: else:
700: return None
701:
702: return txt
703:
704: def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
705:
706: self.id = id
707: """Festlegen der ID"""
708:
709: self.label = label
710: self.link= link
711: self.metalink=metalink
712: self.title=title
713: self.weight=weight
714: self.credits=toList(credits)
715: self.description=description
716: self.contentType=contentType
717: self.copyrightType=copyrightType
718: self.renderingType=renderingType
719: self.responsible=responsible
720: self.resourceID=resourceID
721:
722: if coords:
723: coordsnew=[ string.split(x,",") for x in coords]
724: else:
725: coordsnew=[]
726:
727: self.coords=coordsnew
728: # self.viewClassification=""
729:
730:
731:
732: def getContentType(self):
733: try:
734: return normalizeCt(self.contentType)
735: except:
736: return ""
737:
738: def getCopyrightType(self):
739: try:
740: return self.copyrightType
741: except:
742: return ""
743:
744: def getRenderingType(self):
745: try:
746: return self.renderingType
747: except:
748: return ""
749:
750: def ECHO_resource_config(self):
751: """Main configuration"""
752:
753: if not hasattr(self,'weight'):
754: self.weight=""
755:
756: pt=zptFile(self, 'zpt/ChangeECHO_resource.zpt')
757: return pt()
758:
759:
760: def ECHO_resource_config_main(self):
761: """Main configuration"""
762: if not hasattr(self,'weight'):
763: self.weight=""
764: pt=zptFile(self, 'zpt/ChangeECHO_resource_main.zpt')
765: return pt()
766:
767: def ECHO_resource_config_coords(self):
768: """Coords configuration """
769: pt=zptFile(self, 'zpt/ChangeECHO_resource_coords.zpt')
770: return pt()
771:
772: def ECHO_resource_config_credits(self):
773: """Main configuration"""
774: pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
775: return pt()
776:
777:
778: def changeViewer(self,newViewer):
779: """set newViewer to the url of the new viewer
780: only if metalink is set, otherwise it gives false
781: """
782:
783: texterUrl="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn=/"
784:
785: vl,msg=self.checkValidityOfMetaLink()
786:
787: if not vl: #ungueltiger link, versuche neuen
788: newStr=re.match(".*/mpiwg/online/(.*)",self.metalink) # suche pfad hinter /mpiwg/online
789: oldLink=self.metalink
790:
791: if newStr:
792: self.metalink=texterUrl+newStr.group(1)
793: vl,msg=self.checkValidityOfMetaLink()
794: else:
795: logging.error("change Viewer XX(mew Metadatafile) %s"%self.metalink)
796: vl=False
797:
798: if not vl: # geht immer noch nicht, dann setzte wieder zurueck
799: self.metalink=oldLink
800:
801: logging.info("change Viewer (mew Metadatafile) %s"%self.metalink)
802:
803: if vl:
804: self.newViewer=newViewer
805: return vl,msg
806: else:
807: return vl,msg
808:
809: def checkValidityOfMetaLink(self):
810: """checks if the metalink is valid xml"""
811:
812: ml=self.metalink
813:
814: try:
815: txt=urllib.urlopen(ml)
816:
817: except:
818: return False,"Cannot open: %s)"%ml
819:
820: txt.close()
821: try:
822: dom = NonvalidatingReader.parseUri(ml)
823: except:
824: return False, "Connot parse: %s)"%ml
825:
826: if len(dom.xpath("//texttool"))==0:
827: return False, "No texttools: %s)"%ml
828:
829: return True,""
830:
831: def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,newViewer='',RESPONSE=None):
832: """Aenderung der Properties"""
833: self.resourceID=resourceID
834: self.title=title
835: self.label=label
836: self.description=description
837:
838: self.contentType=contentType
839: self.renderingType=renderingType
840: self.weight=weight
841:
842: self.link=link
843: self.metalink=metalink
844:
845: self.newViewer=newViewer
846:
847:
848: if RESPONSE is not None:
849: RESPONSE.redirect('manage_main')
850:
851:
852: def changeECHO_resource_coords(self,RESPONSE=None):
853: """Aenderung der Properties - coords"""
854: #return self.REQUEST
855: for area in self.getMapAreas():
856: id = area.getId()
857: if self.REQUEST.has_key('del.'+id):
858: # delete this area
859: self._delObject(id)
860: # return to same menu
861: if RESPONSE is not None:
862: RESPONSE.redirect('ECHO_resource_config_coords')
863: return
864: # modify this area
865: coordstring = self.REQUEST.get('coords.'+id, '')
866: coords = string.split(coordstring, ',')
867: angle = self.REQUEST.get('angle.'+id, '0')
868: type = self.REQUEST.get('type.'+id, 'area')
869: if len(coords) == 4:
870: area.setCoordString(coordstring)
871: area.setAngle(angle)
872: area.setType(type)
873: # return to main menu
874: if RESPONSE is not None:
875: RESPONSE.redirect('manage_main')
876:
877:
878: def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
879: """Aenderung der Properties"""
880: self.credits=credits
881: self.responsible=responsible
882: self.copyrightType=copyrightType
883:
884: if RESPONSE is not None:
885: RESPONSE.redirect('manage_main')
886:
887:
1.6.2.1 dwinter 888:
1.1 dwinter 889: def changeECHO_resource_metadata(self,RESPONSE=None):
890: """change metadata"""
1.6.2.1 dwinter 891:
892: self.copyIndex_meta2echo_resource()
893: tags=mappedData.keys()
894:
895:
896: for field in tags:
1.1 dwinter 897: try:
1.6.2.1 dwinter 898: self.metaDataHash[field]=self.REQUEST.form[field]
899:
1.1 dwinter 900: except:
901: logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
902:
903: logging.debug("changeECHO_resource_metadata:"+repr(self.newMetaXML()))
904:
905:
906: mc = MetaDataClient("http://content.mpiwg-berlin.mpg.de/metaDataServer")
907: x=mc.writeMetaDataFile(self.getMetaDataLink(),self.newMetaXML(),compressed=None)
908:
909: logging.debug("changeECHO_resource_metadata (xlrpc return):"+repr(x))
910:
911:
912: if RESPONSE is not None:
913: RESPONSE.redirect('manage_main')
914:
915:
916:
917: def getMDValueSimpleSearchField(self):
1.6.2.1 dwinter 918: """returns value for simple search aus DC daten"""
1.1 dwinter 919:
1.6.2.1 dwinter 920:
921: bibdata=self.getMetaDataManager().getBibData(path=self.getMetaDataLink())
922: dcMapped = self.getMetaDataManager().getDCMappedData(bibdata)
923: logging.debug("getMDValueSimpleSearchField:"+ repr(dcMapped))
924: return " ".join([dcMapped.get('title',''),
925: dcMapped.get('creator',''),
926: dcMapped.get('year',''),self.getTitle()])
1.6 dwinter 927:
1.1 dwinter 928:
929:
930: def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
931: """new index.meta"""
932: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
933:
934: if not hasattr(self,'metaDataHash'):
935:
936: self.copyIndex_meta2echo_resource()
1.6.2.1 dwinter 937:
938: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1.1 dwinter 939:
940: def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
941: """return bibliographical metadata as stored in the object"""
942:
943: try:
944:
945: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
946: except:
947: return "<error> no metadata stored</error>"
948:
949: def getXQueryMetaData(self,xquery):
950: '''
951: execute an xquery on the metadata and returns a list of tuples,
952: each tuple represent the content of the node as text and the whole node as xml-fragment
953: @param xquery: xquery auf den metadaten
954: '''
955:
956: try:
957: md=writeMetadata(self.metalink,self.metaDataHash,xmlfrag="yes")
958: except:
959: return None
960:
961: dom = NonvalidatingReader.parseString(md,"http://www.mpiwg-berlin.mpg.de/")
962:
963: results=Ft.Xml.XPath.Evaluate(xquery, contextNode=dom)
964:
965: ret=[]
966: for result in results:
967:
968: buf = cStringIO.StringIO()
969: PrettyPrint(result, stream=buf)
970: str = buf.getvalue()[0:]
971: buf.close()
972: ret.append((getTextFromNode(result),str))
973:
974: return ret
975:
976: def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
977: """prints out metadata as stored in the echo environment, format is the index.meta format"""
978: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
979: return writeMetadata(self.metalink,self.metaDataHash)
980:
981: def getMetaDataLink(self):
982: """get link to the meta data"""
983: return self.metalink
984:
985: def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
986: """Aenderung der Properties"""
987:
988: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
989: self.link=link
990: self.metalink=metalink
991:
992: if RESPONSE is not None:
993: RESPONSE.redirect('manage_main')
994:
995:
996: manage_options = (
997: {'label':'Main Config','action':'ECHO_resource_config_main'},
1.6.2.1 dwinter 998: {'label':'Edit Metadata','action':'ECHO_getResourceMD'},
1.1 dwinter 999: {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
1000: {'label':'set/change startpage','action':'setStartPageForm'},
1001: {'label':'Change AccessRights','action':'changeAccessRightForm'},
1002: ) + Folder.manage_options
1003:
1004:
1005:
1006:
1007:
1008: def getMetaDataHash(self):
1009: """md hash"""
1.6 dwinter 1010:
1011: return getattr(self,'metaDataHash',{})
1.6.2.1 dwinter 1012:
1013: def getMetaDataValue(self,fieldName):
1014:
1015: self.copyIndex_meta2echo_resource()
1016: return self.metaDataHash.get(fieldName,{}).get('value','')
1017:
1.1 dwinter 1018: def findLabelsFromMapping(self,referenceType):
1019: """gib hash mit label -> generic zurueck"""
1020: #return {},[]
1.6.2.1 dwinter 1021: mo=self.getMetaDataManager().getBibMapping(referenceType)
1.1 dwinter 1022:
1.6.2.1 dwinter 1023: if mo is None:
1024: return [],{}
1025:
1026: return mo.getFieldList(),mo.getFields()
1.1 dwinter 1027:
1028: def findTagsFromMapping(self,referenceType):
1029: """gib hash mit label -> generic zurueck"""
1030:
1.6.2.1 dwinter 1031: return self.findLabelsFromMapping(referenceType)
1.1 dwinter 1032:
1033:
1.6.2.1 dwinter 1034:
1.1 dwinter 1035: def copyIndex_meta2echo_resource(self,RESPONSE=None):
1.6.2.1 dwinter 1036: #copy MD von Index_meta to the echo_resource
1.1 dwinter 1037:
1.6.2.1 dwinter 1038: logging.debug("copyIndex_meta2echo_resource:"+self.metalink)
1039: md = self.getMetaDataManager().getBibData(path=self.metalink)
1040: logging.debug("copyIndex_meta2echo_resource:"+repr(md))
1041: self.metaDataHash=self.getMetaDataManager().getBibMappedData(md)
1042: logging.debug("copyIndex_meta2echo_resource:"+repr(self.metaDataHash))
1.1 dwinter 1043:
1.6.2.1 dwinter 1044: self.contentType=normalizeCt(self.metaDataHash.get('@type',''))
1.1 dwinter 1045:
1.6.2.1 dwinter 1046: return
1.1 dwinter 1047:
1048: def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"):
1049: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
1.6.2.1 dwinter 1050: #(metadict, error)=readMetadata(self.metalink)
1051: logging.debug("getMetaData:"+self.metalink)
1052:
1053: self.copyIndex_meta2echo_resource()
1.1 dwinter 1054: if back:
1055: self.REQUEST.SESSION['back']=back
1056:
1057: if (not self.contentType) or (overwrite=="yes"):
1.6.2.1 dwinter 1058: self.contentType=normalizeCt(normalizeCt(self.metaDataHash.get('@type','')).lower())
1.1 dwinter 1059:
1.6.2.1 dwinter 1060: if not (normalizeCt(self.contentType).lower()==normalizeCt(self.contentType).lower()):
1061: self.REQUEST.SESSION['contentStorage']=normalizeCt(self.contentType)
1.1 dwinter 1062: self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)
1063:
1064: return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
1065:
1066: #self.REQUEST.SESSION['metadict']=metadict
1067:
1068:
1069: if template=="yes":
1070: #pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_resourceMD.zpt'),metadict=metadict).__of__(self)
1071: pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
1072:
1.6.2.1 dwinter 1073: return pt(metadict=self.metaDataHash)
1.1 dwinter 1074:
1075:
1076:
1077:
1078:
1.6.2.1 dwinter 1079: # def ECHO_getMD(self,item):
1080: # """Ausgabe der MD"""
1081: # return getattr(self,item)
1.1 dwinter 1082:
1083: def checkRDF(self,path):
1084: """check if pdf in the path"""
1085: try:
1086: for fileName in os.listdir(path):
1087: if os.path.splitext(fileName)[1]==".pdf":
1088: return os.path.join(path,fileName)
1089: return None
1090: except:
1091: return None
1092:
1093:
1094: security.declareProtected('View','index_html')
1095: def index_html(self):
1096: """standard page"""
1097: pdf=self.checkRDF(self.link)
1098: if pdf:
1099: fh=file(pdf,'r').read()
1100: self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
1101: self.REQUEST.RESPONSE.write(fh)
1102: self.REQUEST.RESPONSE.close()
1103: return
1104:
1105: if getattr(self,'newViewer',''): #benutze den neuen viewer
1106: url=self.newViewer+'url='+self.metalink+"&mode=texttool"
1107: return self.REQUEST.RESPONSE.redirect(url)
1108:
1109: return self.REQUEST.RESPONSE.redirect(self.link)
1110:
1111: def startpage_html(self):
1112: """prints out a startpage for a resource for use e.g. in the BVE"""
1113:
1114: # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
1115:
1116: sp=self.ZopeFind(self,obj_ids=['startpage.html'])
1117:
1118: if sp:
1119: return sp[1]()
1120:
1121: #pruefen ob irgendwo ein template
1122: if hasattr(self,'startpage_index_template'):
1123: return self.startpage_index_template()
1124:
1125: #generisches template ausgeben
1126:
1127: pt=zptFile(self, 'zpt/ECHO_startpage_index_template_standard.zpt')
1128: pt.content_type="text/html"
1129: return pt()
1130:
1131: def toc_html(self):
1132:
1133: sp=self.ZopeFind(self,obj_ids=['toc.html'])
1134:
1135: if sp:
1136: return sp[0][1]()
1137:
1138:
1139: security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
1140:
1141: def generate_label(self):
1142: """Erzeugt_standard_Label aus Template"""
1.6.2.1 dwinter 1143: self.label=self.getMetaDataManager().getBibFormattedLabel(path=self.metalink)
1144: return self.label
1145:
1.1 dwinter 1146:
1147: security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
1148:
1149: def generate_title(self,RESPONSE=None):
1150: """Erzeugt_standard_Label aus Template"""
1.6.2.1 dwinter 1151: self.title=self.generate_label();
1152: return self.title
1.1 dwinter 1153:
1154: Globals.InitializeClass(ECHO_resource)
1155:
1156: def manage_addECHO_resourceForm(self):
1157: """Form for adding a ressource"""
1158: pt=zptFile(self, 'zpt/AddECHO_resourceForm.zpt')
1159: return pt()
1160:
1161:
1162:
1163: 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):
1164: """addresource"""
1165:
1166: newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
1167:
1168: self._setObject(id,newObj)
1169:
1170: if RESPONSE is not None:
1171: RESPONSE.redirect('manage_main')
1172:
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