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