1: """New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""
2: """Echo collection provides the classes for the ECHO content web-site.
3:
4: class ECHO_collection is the basis class for an ECHO collection.
5:
6: class ECHO_resource contains information on ECHO resources (e.g. an Display environment for Metadata
7:
8: class ECHO_externalLink contains information on externalLinks
9:
10:
11: """
12: try:
13: from reportlab.pdfgen import canvas
14: from reportlab.lib.pagesizes import A4
15: except:
16: print "PDF generation will not work"
17:
18: import urlparse
19: import string
20: import tempfile
21: import zipfile
22: import re
23: import os,shutil
24: import OFS.Image
25: from types import *
26: from OFS.Cache import Cacheable
27: from OFS.Image import Image
28: from Globals import DTMLFile
29: from OFS.Folder import Folder
30: from OFS.SimpleItem import SimpleItem
31: from AccessControl import ClassSecurityInfo
32: from AccessControl.User import UserFolder
33: from Globals import InitializeClass
34: from Globals import DTMLFile
35: import Globals
36: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
37: from Products.PageTemplates.PageTemplate import PageTemplate
38: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate,manage_addPageTemplate
39: from Globals import Persistent, package_home
40: from Acquisition import Implicit
41: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
42: from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
43:
44: import urllib
45: import urllib2
46: import cgi
47: import smtplib
48: import time
49: from Ft.Xml.Domlette import NonvalidatingReader
50: from Ft.Xml.Domlette import PrettyPrint, Print
51: from Ft.Xml import EMPTY_NAMESPACE
52:
53: import Ft.Xml.XPath
54: import cStringIO
55:
56: import sys
57:
58: try:
59: from psycopg import libpq
60: except:
61: try:
62: from pyPgSQL import libpq
63: except:
64: print "ECHO_collection: Warning - No libpq imported!"
65:
66: import xml.dom.minidom
67:
68: import urllib
69: import xml.dom.minidom
70: import ECHO_helpers
71: from ECHO_helpers import *
72:
73: try:
74: from ECHO_language import *
75: except:
76: print "no echo_language"
77: class ECHO_language:
78: """ leere Klasse"""
79: pass
80:
81: from ECHO_movie import *
82: import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
83: import xmlrpclib
84:
85: import logging
86:
87: #ersetzt logging.info
88: def logger(txt,method,txt2):
89: """logging"""
90: logging.info(txt+ txt2)
91:
92: def normalizeCt(str):
93: """normalizes content_type"""
94: #str= str.replace(" ","_")
95: return str.replace("-"," ").lower()
96:
97: def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs=""):
98:
99: """Allegemeine Informationen zu einer ECHO Collection"""
100:
101: self.label = label
102: self.title=title
103: self.description=description
104: self.contentType=contentType
105: self.responsible=responsible
106: self.credits=toList(credits)
107: self.weight=weight
108:
109: class ECHO_partner(Image,Persistent,ECHO_basis):
110: """ECHO Partner"""
111:
112: meta_type="ECHO_partner"
113:
114: def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):
115: self.__name__=id
116: self.title=title
117: self.url=url
118: self.person=person
119: self.email=email
120: self.country=country
121: self.color=color
122: self.precondition=precondition
123: self.copyrightType=copyrightType
124: data, size = self._read_data(file)
125: content_type=self._get_content_type(file, data, id, content_type)
126: self.update_data(data, content_type, size)
127:
128: manage_options = Image.manage_options+(
129: {'label':'Partner Information','action':'ECHO_partner_config'},
130: )
131:
132:
133: def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):
134: """Change main information"""
135: self.url=url
136: self.person=person
137: self.email=email
138: self.country=country
139: self.color=color
140: self.copyrightType=copyrightType
141: if RESPONSE is not None:
142: RESPONSE.redirect('manage_main')
143:
144:
145:
146: def ECHO_partner_config(self):
147: """Main configuration"""
148: if not hasattr(self,'url'):
149: self.url=""
150: pt=zptFile(self, 'zpt/ChangeECHO_partner.zpt')
151: return pt()
152:
153:
154: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
155: Kind='ECHO_partner',kind='ECHO_partner')
156:
157:
158:
159: def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',
160: REQUEST=None):
161: """
162: Add a new ECHO_partner object.
163:
164: Creates a new ECHO_partner object 'id' with the contents of 'file'.
165: Based on Image.manage_addImage
166: """
167:
168: id=str(id)
169: title=str(title)
170: content_type=str(content_type)
171: precondition=str(precondition)
172:
173: id, title = OFS.Image.cookId(id, title, file)
174:
175: self=self.this()
176:
177: # First, we create the image without data:
178: self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))
179:
180: # Now we "upload" the data. By doing this in two steps, we
181: # can use a database trick to make the upload more efficient.
182: if file:
183: self._getOb(id).manage_upload(file)
184: if content_type:
185: self._getOb(id).content_type=content_type
186:
187: if REQUEST is not None:
188: try: url=self.DestinationURL()
189: except: url=REQUEST['URL1']
190: REQUEST.RESPONSE.redirect('%s/manage_main' % url)
191: return id
192:
193: class ECHO_locale(ZopePageTemplate):
194: """localisierung"""
195:
196: meta_type="ECHO_locale"
197:
198: def __init__(self,id,lang,title,label,text=None,content_type=None):
199: self.lang=lang
200: self.title=title
201: self.label=label
202: if text:
203: if content_type is None:
204: content_type = self.content_type
205: self.pt_edit(text, content_type)
206: self.id=id
207:
208: manage_options = ZopePageTemplate.manage_options+(
209: {'label':'Main Config','action':'change_ECHO_localeForm'},
210: )
211:
212: def change_ECHO_localeForm(self):
213: """change form"""
214: pt=zptFile(self, 'zpt/ChangeECHO_localeForm.zpt')
215: return pt()
216:
217: def change_ECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
218: """change echo locale"""
219: self.lang=lang
220: self.title=title
221: self.label=label
222: if not text is None:
223: if content_type is None:
224: content_type = self.content_type
225: self.pt_edit(text, content_type)
226:
227: if RESPONSE is not None:
228: RESPONSE.redirect('manage_main')
229:
230:
231: def manage_addECHO_localeForm(self):
232: """Form for adding"""
233: pt=zptFile(self, 'zpt/AddECHO_localeForm.zpt')
234: return pt()
235:
236: def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
237: """add echo locale"""
238:
239: id="locale_"+lang
240:
241: self._setObject(id, ECHO_locale(id,lang,title,label,text,content_type))
242: if RESPONSE is not None:
243: RESPONSE.redirect('manage_main')
244:
245:
246: class ECHO_copyright(Folder,ECHO_basis):
247: """Copyright informationen"""
248: meta_type="ECHO_copyright"
249:
250:
251:
252: def __init__(self,id,title,copyrights):
253: """init"""
254: self.title=title
255: self.id=id
256: self.copyrights=copyrights[0:]
257:
258: def getCopyrights(self):
259: """return coyprights"""
260: return self.copyrights
261:
262: manage_options = Folder.manage_options+(
263: {'label':'Main Config','action':'ECHO_copyright_configForm'},
264: )
265:
266:
267: def ECHO_copyright_configForm(self):
268: """change form"""
269: pt=zptFile(self, 'zpt/ChangeECHO_copyright')
270: pt.content_type="text/html"
271: return pt()
272:
273: def ECHO_copyright_config(self,title,RESPONSE=None):
274: """change"""
275: self.title=title
276: self.copyrights=[]
277: self.copyrights=getCopyrightsFromForm(self,self.REQUEST.form)[0:]
278:
279: if RESPONSE is not None:
280: RESPONSE.redirect('manage_main')
281:
282:
283: def manage_addECHO_copyrightForm(self):
284: """Form for adding"""
285: pt=zptFile(self, 'zpt/AddECHO_copyright.zpt')
286: return pt()
287:
288: def manage_addECHO_copyright(self, id,title,RESPONSE=None):
289: """add the copyright"""
290:
291: meta_type="ECHO_copyright"
292:
293: #first generate copyrights as list of tripels (mediaType,partner,copyrightType)
294:
295:
296:
297: self._setObject(id, ECHO_copyright(id, title,getCopyrightsFromForm(self,self.REQUEST.form)))
298:
299: if RESPONSE is not None:
300: RESPONSE.redirect('manage_main')
301:
302: class ECHO_layoutTemplate(ZopePageTemplate,ECHO_basis):
303: """Create a layout Template for different purposes"""
304:
305: meta_type="ECHO_layoutTemplate"
306:
307: def __init__(self, id, text=None, content_type=None,EchoType=None):
308: self.id = str(id)
309:
310: self.ZBindings_edit(self._default_bindings)
311: if text is None:
312: self._default_content_fn = os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%EchoType)
313: text = open(self._default_content_fn).read()
314: if content_type is None:
315: content_type = self.content_type
316: self.pt_edit(text, content_type)
317:
318:
319: def manage_addECHO_layoutTemplateForm(self):
320: """Form for adding"""
321: pt=zptFile(self, 'zpt/AddECHO_layoutTemplate.zpt')
322: return pt()
323:
324:
325: def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
326: "Add a Page Template with optional file content."
327: if type(EchoType)==StringType:
328: EchoTypes=[EchoType]
329: else:
330: EchoTypes=EchoType
331:
332: for singleType in EchoTypes:
333:
334: id = str(singleType)+"_template"
335: if REQUEST is None:
336: self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
337: ob = getattr(self, id)
338:
339: if title:
340: ob.pt_setTitle(title)
341: return ob
342: else:
343: file = REQUEST.form.get('file')
344: headers = getattr(file, 'headers', None)
345: if headers is None or not file.filename:
346: zpt = ECHO_layoutTemplate(id,EchoType=singleType)
347: else:
348: zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
349:
350: self._setObject(id, zpt)
351: ob = getattr(self, id)
352: if title:
353: ob.pt_setTitle(title)
354:
355: try:
356: u = self.DestinationURL()
357: except AttributeError:
358: u = REQUEST['URL1']
359:
360:
361: REQUEST.RESPONSE.redirect(u+'/manage_main')
362: return ''
363:
364: class ECHO_fullText(ZopePageTemplate,ECHO_basis,ECHO_language):
365: """echo fulltext in xml"""
366:
367: meta_type="ECHO_fullText"
368:
369:
370: def getPage(self,nr='1'):
371: """get page n"""
372: #return self().encode('latin-1','ignore')
373: try:
374: dom=xml.dom.minidom.parseString(self())
375: except:
376: dom=xml.dom.minidom.parseString(self().encode('latin-1'))
377: pages=dom.getElementsByTagName('page')
378:
379: return pages[int(nr)-1].toxml()
380:
381: # Product registration and Add support
382: manage_addECHO_fullTextForm = PageTemplateFile(
383: 'zpt/AddECHO_fullText.zpt', globals())
384:
385: def manage_addECHO_fullText(self, id, title=None, text=None,
386: REQUEST=None, submit=None):
387: "Add a Page Template with optional file content."
388:
389: id = str(id)
390: if REQUEST is None:
391: self._setObject(id, ECHO_fullText(id, text))
392: ob = getattr(self, id)
393: if title:
394: ob.pt_setTitle(title)
395: return ob
396: else:
397: file = REQUEST.form.get('file')
398: headers = getattr(file, 'headers', None)
399: if headers is None or not file.filename:
400: zpt = ECHO_fullText(id)
401: else:
402: zpt = ECHO_fullText(id, file, headers.get('content_type'))
403:
404: self._setObject(id, zpt)
405:
406: try:
407: u = self.DestinationURL()
408: except AttributeError:
409: u = REQUEST['URL1']
410:
411: if submit == " Add and Edit ":
412: u = "%s/%s" % (u, urllib.quote(id))
413: REQUEST.RESPONSE.redirect(u+'/manage_main')
414: return ''
415:
416:
417: class ECHO_resource(CatalogAware,Folder,Persistent,ECHO_basis):
418: """ECHO Ressource"""
419: security=ClassSecurityInfo()
420: meta_type='ECHO_resource'
421: default_catalog='resourceCatalog'
422:
423: # viewClassificationList=viewClassificationListMaster
424:
425: def PrincipiaSearchSource(self):
426: """Return cataloguable key for ourselves."""
427: return str(self)
428:
429: getSubCols = ECHO_helpers.getSubCols
430:
431: def reindex(self):
432: """generate fields for indexing and reindex"""
433:
434: #TODO: korrigieren des metalink pfades konfigurierbar machen
435: splitted= [x for x in urlparse.urlparse(self.metalink)]
436: splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
437:
438: if splitted[0]=="http":
439: self.metalink=urlparse.urlunparse(splitted)
440:
441:
442: self.fullTextUrl=self.getFullTextXML(noredirect="yes")
443:
444: #TODO: korrigieren relative url to absoluter url volltexten, konfigurierbar?
445: splitted= [x for x in urlparse.urlparse(self.fullTextUrl)]
446: if splitted[0]=="":
447: splitted[0]="http"
448: splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
449:
450: self.fullTextUrl=urlparse.urlunparse(splitted)
451:
452: self.imagePath=self.getImagePath()
453:
454: self.reindex_object()
455:
456:
457: security.declareProtected('View','createPDF')
458: def createPDF(self,RESPONSE=None,local=None,dpi=150):
459: """erzeuge pdf file"""
460: pages=1
461: dpi=float(dpi)
462: imagePath=self.getImagePath().replace("/mpiwg/online","")
463:
464:
465: image="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn="+imagePath+"&dw=%i&dh=%i&pn=%i"
466: xmlInfo="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/dlInfo-xml.jsp?fn="+imagePath
467:
468: dom=xml.dom.minidom.parse(urllib.urlopen(xmlInfo))
469: for parameter in dom.getElementsByTagName('parameter'):
470: if parameter.getAttribute('name')=="pt":
471: pages=int(parameter.getAttribute('value'))
472: break
473:
474:
475: tempdir="/tmp/archivesImageServer"
476: if not os.path.exists(tempdir):
477: os.mkdir(tempdir)
478:
479: tmpPath=tempfile.mkdtemp(dir=tempdir)
480:
481:
482: tmpZip=tempfile.mktemp(dir=tempdir)
483:
484: tmpFn=os.path.split(tmpZip)[1]
485:
486:
487:
488:
489: if RESPONSE:
490: RESPONSE.setHeader("Content-Type","text/html")
491: RESPONSE.write("<h1>I am creating the pdf</h1>")
492: txt="<h3>1. step: getting the images( %i pages)</h3>"%pages
493: RESPONSE.write(txt)
494:
495: c=canvas.Canvas(tmpZip)
496: for i in range(1,pages+1):
497: if RESPONSE:
498: RESPONSE.write(str("<p>Get Page: %i<br>\n"%i))
499: faktor=dpi/72.0
500:
501: fn=tmpPath+"/%i"%i
502:
503: width,height=A4
504: #print image%(width*faktor,height*faktor,i)
505: url=urllib.urlopen(image%(width*faktor,height*faktor,i)).read()
506: fh=file(fn,"w")
507: fh.write(url)
508: fh.close()
509:
510:
511:
512: c.drawImage(fn,0,0,width=width,height=height)
513: c.showPage()
514: c.save()
515: if RESPONSE:
516: RESPONSE.write("<p>finished<br>\n")
517:
518: if RESPONSE:
519: len=os.stat(tmpZip)[6]
520: downloadUrl=self.absolute_url()+"/downloadPDF"
521: RESPONSE.write("""<h1><a href="downloadPDF?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
522: RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>
523: <p><a href="downloadPDF?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))
524: RESPONSE.close()
525:
526:
527: def downloadPDF(self,fn):
528: """download prepared set"""
529: filename="/tmp/archivesImageServer/"+fn
530: namePDF=self.getId()+".pdf"
531: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%namePDF)
532: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
533: len=os.stat(filename)[6]
534: self.REQUEST.RESPONSE.setHeader("Content-Length",len)
535: images=file(filename).read()
536: self.REQUEST.RESPONSE.write(images)
537: self.REQUEST.RESPONSE.close()
538:
539:
540: def getRDF(self,urn=None):
541: """rdf"""
542: ret=getRDFDescription(self,self.link,urn=urn)
543: return ret+self.createSubElementRDF(urn=urn)
544:
545:
546: def changeAccessRightForm(self,preselect=None):
547: """change the access rights"""
548:
549: pt=zptFile(self, 'zpt/ChangeECHO_resourceAccessRight.zpt')
550: return pt(preselect=preselect)
551:
552: def changeAccessRight(self):
553: """changeRights"""
554: argv=self.REQUEST.form
555: self.setAccessRightXML(argv["%s_xml"%self.getId()])
556: self.accessRight=argv["%s_echo"%self.getId()]
557:
558: self.REQUEST.RESPONSE.redirect('manage_main')
559:
560:
561: def getAccessRightSelectorHTML(self,outlook="select",xmldominant=None,preselect=None):
562: """htmlselector, xmldominant= in der regel wird der wert des xmlfiles ausgegeben ausser er existiert nicht"""
563: values=['','free','MPIWG']
564:
565: if preselect:#set all to the preselected
566: ar=(preselect,preselect)
567: else:#else set to actual value
568: ar=self.getAccessRightMD()
569:
570: if outlook=="select":
571: ret="""<select name="%s_xml">"""%self.getId()
572: ret1="""<select name="%s_echo">"""%self.getId()
573: for value in values:
574: if value==ar[0]:
575: ret+="<option selected>%s</option>"%value
576: else:
577: ret+="<option>%s</option>"%value
578:
579: if value==ar[1]:
580: ret1+="<option selected>%s</option>"%value
581: else:
582: ret1+="<option>%s</option>"%value
583:
584:
585: if not xmldominant:
586: return ret+"</select>",ret1+"</select>"
587: else:
588: if ar[0] is not None:
589: return ret+"</select>"
590: else:
591: return "<p>No xml file (only local selection):"+ret1
592:
593: else:
594: ret=""
595: ret1=""
596: for value in values:
597:
598: if value==ar[0]:
599: ret+="""<input type="radio" name="%s_xml" value="%s" checked>%s"""%(self.getId(),value,value)
600: else:
601: ret+="""<input type="radio" name="%s_xml" value="%s">%s"""%(self.getId(),value,value)
602:
603: if value==ar[1]:
604: ret1+="""<input type="radio" name="%s_echo" value="%s" checked>%s"""%(self.getId(),value,value)
605: else:
606: ret1+="""<input type="radio" name="%s_echo" value="%s">%s"""%(self.getId(),value,value)
607:
608: if not xmldominant:
609: return ret,ret1
610: else:
611: if ar[0]:
612: return ret
613: else:
614: return "<p>No xml file (only local selection)</p>"+ret1
615:
616:
617:
618: def copyAccessRightsFromMD(self):
619: """kopiere rechte aus den metadaten"""
620: self.accessRight=self.getAccessRightMD()[0]
621:
622:
623:
624:
625:
626: def getAccessRightMD(self):
627: """set accessright"""
628: url=self.metalink
629:
630: try:
631: urllib.urlopen(url)
632: except:
633: logger("ECHO_Resource (getAccessRightMD)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
634:
635: return None,getattr(self,'accessRight','')
636:
637:
638: try:
639: dom = NonvalidatingReader.parseUri(url)
640: except:
641: logger("ECHO_Resource (getAccessRightMD)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
642: return (None,"Cannot parse: "+url+"<br>"+"%s (%s)"%sys.exc_info()[0:2])
643:
644:
645: accessright=dom.xpath("//meta/access-conditions/access/@type")
646: if accessright:
647: accessright=accessright[0].value
648: if str(accessright)=='institution':
649: tmp=dom.xpath("//meta/access-conditions/access/name")
650: if tmp:
651: accessright=getTextFromNode(tmp[0])
652:
653: if not accessright:
654: accessright=""
655:
656: return accessright,getattr(self,'accessRight','')
657:
658: def changeAccessRightMD(self,accessright,RESPONSE=None):
659: """change the rights - not user anymore"""
660: #TODO: check if method still needed
661: params="accessright=%s"%accessright
662:
663:
664: #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()
665:
666: tries=0
667: for i in range(10):
668: 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()
669: if x=="ok":
670:
671: break;
672:
673:
674:
675: if RESPONSE is not None:
676: RESPONSE.redirect('manage_main')
677:
678:
679: def setAccessRightXML(self,accessright):
680: """set accessright"""
681: url=self.metalink
682: accessrights=['MPIWG','free']#allowes rights
683:
684: if accessright =='':
685: """do nothing"""
686: return ""
687:
688:
689: try:
690: geturl=""
691: for line in ECHO_helpers.urlopen(url).readlines():
692: geturl=geturl+line
693:
694:
695: except:
696: return (None,"Cannot open: "+url)
697:
698: try:
699: dom=xml.dom.minidom.parseString(geturl)
700: root=dom.getElementsByTagName('resource')[0]
701: except:
702: return (None,"Cannot parse: "+url+"<br>"+geturl)
703:
704: metamains=dom.getElementsByTagName('meta')
705:
706: if not metamains:
707: nodenew=dom.createElement('meta')
708: root.appendChild(nodenew)
709: metamain=nodenew
710: else:
711: metamain=metamains[0]
712:
713:
714: metanodes=metamain.getElementsByTagName('access-conditions')
715:
716: if not metanodes:
717: nodenew=dom.createElement('access-conditions')
718: metamain.appendChild(nodenew)
719: metanode=nodenew
720: else:
721: metanode=metanodes[0]
722:
723: accesses=metanode.getElementsByTagName('access')
724:
725: #delete old
726: if accesses:
727: metanode.removeChild(accesses[0]).unlink()
728:
729: #create new
730:
731: nodenew2=dom.createElement('access')
732: metanode.appendChild(nodenew2)
733: metanode2=nodenew2
734:
735: attribute=metanode2.getAttribute('type')
736:
737: if accessright=="free":
738:
739: metanode2.setAttribute('type','free')
740:
741: elif accessright.upper()=='MPIWG':
742: metanode2.setAttribute('type','institution')
743: nodenew4=dom.createElement('name')
744: metanodetext=dom.createTextNode('MPIWG')
745: nodenew4.appendChild(metanodetext)
746: nodenew2.appendChild(nodenew4)
747: #print dom.toxml().encode('utf-8')
748: string= encodeRPC(dom.toxml().encode('utf-8'))
749:
750: #TODO: make server configurable
751: server=xmlrpclib.Server("http://foxridge.mpiwg-berlin.mpg.de/server")
752:
753: path=urlparse.urlparse(self.metalink)[2]
754:
755: server.writeMetaDataFile(path,string,"yes")
756:
757: def setStartPageForm(self):
758: """Form for changing the startpage"""
759:
760:
761: pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPage.zpt')
762: pt.content_type="text/html"
763: return pt()
764:
765:
766: def createImageUrl(self,pn=1):
767: """create ImageUrl"""
768:
769:
770: resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
771:
772: digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
773: images=readFieldFromXML(self.metalink,'texttool','image')
774:
775:
776: if (not resourcepath) or (not digiliburlprefix) or (not images):
777: logger("ECHO (createImageUrl)",logging.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())
778: return None
779: resourcepath=resourcepath.replace('/mpiwg/online','')
780: if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"
781:
782: if (not images) or (not resourcepath): return None
783:
784: return "%sfn=%s&pn=%i"%(digiliburlprefix,resourcepath+"/"+images,pn)
785:
786: def copyTitleToInfoXML(self,RESPONSE=None):
787: """copy title from the resource"""
788: presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')
789: resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
790: if (not presentationXML) or (not resourcepath):
791: if RESPONSE:
792: RESPONSE.write("Error: %s\n"%self.getId())
793: else:
794: return None,self.absolute_url()
795:
796: try:
797: fh=file(os.path.join(resourcepath,presentationXML),'w')
798: fh.write("""<info>
799: <author></author>
800: <title>%s</title>
801: <date></date>
802: <display>yes</display>
803: </info>"""%self.title)
804: fh.close()
805: return 1,self.getId()
806: except:
807: if RESPONSE:
808: RESPONSE.write("Error: %s\n"%self.getId())
809: else:
810: return None,self.absolute_url()
811:
812:
813: def setStartPage(self,startpage=None,RESPONSE=None):
814: """set start page, if no startpage defined use the generic one of the resource"""
815:
816: if (not (type(startpage)==StringType)):
817: if ("__generic" in startpage): # checke ob generic in der liste
818: startpage=self.absolute_url()+"/startpage_html"
819: elif ("__firstPage" in startpage): # checke ob generic in der liste
820: startpage=self.createImageUrl()
821:
822: if (not startpage):
823: startpage=self.absolute_url()+"/startpage_html"
824: elif (startpage=="__generic"):
825: startpage=self.absolute_url()+"/startpage_html"
826: elif (startpage=="__firstPage"):
827: startpage=self.createImageUrl()
828:
829: params="startpage=%s"%startpage
830: #print 'http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))
831:
832: tries=0
833: for i in range(10):
834: x=ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()
835: if x=="ok":
836:
837: break;
838:
839:
840: path=self.metalink
841:
842: path=re.sub(self.REQUEST['SERVER_URL'],'',path)
843: path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
844:
845: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
846: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
847: path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
848: path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
849: path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
850: path=re.sub('http://vision.mpiwg-berlin.mpg.de','',path) # falls vision als server
851: path=re.sub('http://xserve02.mpiwg-berlin.mpg.de:18880','',path) # falls vision als server
852: path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
853: path=re.sub('/index.meta','',path)
854:
855:
856: ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
857:
858: if RESPONSE is not None:
859: RESPONSE.redirect('manage_main')
860:
861: def changeViewerTemplateSetForm(self):
862: """change the viewer template set"""
863: pt=zptFile(self, 'zpt/changeResourceViewerTemplateSet')
864: return pt()
865:
866:
867: def setLink(self, link=None):
868: """change link field"""
869: if link is not None:
870: self.link = link
871:
872:
873: def getTextToolsField(self,name,default=''):
874: """Lese Textoolsfelder aus index.meta im path aus"""
875:
876: try:
877: dom=xml.dom.minidom.parse(self.metalink)
878: node=dom.getElementsByTagName('texttool')[0] #getNode
879: subnode=node.getElementsByTagName(name)[0]
880:
881: # bei text wird nur der Folder gebraucht
882: if name=="text":
883: splitted=getText(subnode.childNodes).split("/")
884: return splitted[len(splitted)-2]
885: else:
886: return getText(subnode.childNodes)
887: except:
888: return default
889:
890:
891: def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
892: """changeit"""
893:
894: paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']
895:
896:
897: #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)
898:
899: params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
900:
901: try:
902: tries=0
903: for i in range(10):
904: 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()+'/newMetaXML'+urllib.quote('?'+params))).read()
905: if x=="ok":
906:
907: break;
908:
909: except:
910: logger("ECHO_ressource (changeViewerTemplateSet)", logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
911: logger("ECHO_ressource (changeViewerTemplateSet)", logging.ERROR,'http://echo.mpiwg-berlin.mpg.de/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params)))
912: #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
913: # hack Pfad auf die Dokumente
914: path=self.metalink
915:
916:
917:
918: path=re.sub('/index.meta','',path)
919:
920: #TODO: direct access to the file system necessary, fix that also xmlrpc to the server where the index file is stored is possible
921: parsedUrl=urlparse.urlparse(path)
922: path=parsedUrl[2]
923:
924: try:
925: return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
926: except:
927: logger("ECHO_Resource (changeViewerTemplateSet)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
928: logger("ECHO_Resource (changeViewerTemplateSet)", logging.INFO,"http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path)
929:
930: if RESPONSE is not None:
931: RESPONSE.redirect('manage_main')
932:
933:
934:
935: security.declarePublic('content_html')
936: def content_html(self):
937: """template fuer content"""
938: return ECHO_basis.content_html(self,'resource')
939:
940: # def getViewClassification(self):
941: # if hasattr(self,'viewClassification'):
942: # return self.viewClassification
943: # else:
944: # return ""
945:
946: def getFullTextXML(self,noredirect=None):
947: """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
948:
949: try:
950: #logger("ECHO Fulltext",logging.INFO,"open %s"%self.metalink)
951: fh=ECHO_helpers.urlopen(self.metalink)
952: #logger("ECHO Fulltext",logging.INFO,"opened %s"%self.metalink)
953: dom=xml.dom.minidom.parse(fh)
954: texttools=dom.getElementsByTagName('texttool')
955: text=texttools[0].getElementsByTagName('text')
956: texturl=getText(text[0].childNodes)
957:
958: #logger("ECHO Fulltext",logging.INFO,"found %s"%texturl)
959: fh.close()
960: #logger("ECHO Fulltext",logging.INFO,"closed fh")
961: #keine url
962: if not (texturl.split(":")[0] in ['http','ftp','file']):
963: if not noredirect:
964: return file(texturl).read()
965: else:
966: return texturl
967:
968: if not noredirect:
969: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
970: logger("ECHO Fulltext",logging.INFO,"redirect to:%s"%texturl)
971: self.REQUEST.RESPONSE.redirect(texturl)
972: else:
973: return texturl
974: except:
975:
976: if not noredirect:
977: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
978: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
979: else:
980: return "<error>no fulltext available</error>"
981:
982: def getImagePath(self):
983: """gibt pfad zum image aus"""
984: return self.getImageView(noredirect="yes",onlyPath="yes")
985:
986: def getImageView(self,noredirect=None,onlyPath=None):
987: """getImages; give Imageviewr and <error></error> if somthing goes wrong."""
988: try:
989: fh=ECHO_helpers.urlopen(self.metalink)
990: dom=xml.dom.minidom.parse(fh)
991: texttools=dom.getElementsByTagName('texttool')
992: text=texttools[0].getElementsByTagName('image')
993: imagetemp=getText(text[0].childNodes)
994:
995: text=dom.getElementsByTagName('archive-path')
996: archivepath=getText(text[0].childNodes)
997: archivepath=re.sub('/mpiwg/online/','',archivepath)
998: imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
999: fh.close()
1000:
1001: if not noredirect:
1002: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1003: self.REQUEST.RESPONSE.redirect(imageurl)
1004: else:
1005: if not onlyPath:
1006: return imageurl
1007: else:
1008: return archivepath+"/"+imagetemp
1009: except:
1010:
1011: if not noredirect:
1012: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1013: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
1014: else:
1015: return "<error>no images available</error>"
1016:
1017:
1018: def getCopyrightsHTML(self):
1019: """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
1020:
1021: if hasattr(self,'copyrightModel'):
1022: obj=self.copyrightModel
1023:
1024: else:
1025: return "ERROR"
1026: ret=[]
1027:
1028: for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
1029:
1030:
1031: try:
1032: if hasattr(self.copyrightTypes,copyright[2]):
1033: copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
1034: link="copyrightTypes/"+copyright[2]+'/copyright.html'
1035: else:
1036: copyrightTypeObj=getattr(obj,copyright[2])
1037: link="copyrightModel/"+copyright[2]+'/copyright.html'
1038:
1039: label=copyrightTypeObj.label
1040: url=getattr(copyrightTypeObj, 'url', '')
1041:
1042: if url!='':
1043: ret.append((url,copyright[0],copyright[1],copyright[2],label))
1044: else:
1045: if hasattr(copyrightTypeObj, 'copyright.html'):
1046: ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
1047: else:
1048: ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
1049: except:
1050: """nothing"""
1051:
1052: return ret
1053:
1054: def getInstitutionsHTML(self):
1055: """gibt Liste der foerdernden Institutionen aus"""
1056:
1057: if hasattr(self,'support'):
1058: obj=self.support
1059: ret=obj.getSupporter()
1060: return ret
1061: else:
1062: return ''
1063:
1064: def getOwnerOriginalsHTML(self):
1065: """gibt Liste der foerdernden Institutionen aus"""
1066:
1067: if hasattr(self,'ownerOriginal'):
1068: obj=self.ownerOriginal
1069: ret=obj.getOwner()
1070: return ret
1071: else:
1072: return ''
1073:
1074: def getDigiCopyByHTML(self):
1075: """gibt Liste der foerdernden Institutionen aus"""
1076:
1077: if hasattr(self,'digiCopyBy'):
1078: obj=self.digiCopyBy
1079: ret=obj.getDigiCopyBy()
1080: return ret
1081: else:
1082: return ''
1083:
1084: def getCredits(self):
1085: """Ausgabe der credits"""
1086: if self.credits:
1087: return self.credits
1088: else:
1089: return []
1090:
1091:
1092:
1093: def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
1094:
1095: self.id = id
1096: """Festlegen der ID"""
1097:
1098: self.label = label
1099: self.link= link
1100: self.metalink=metalink
1101: self.title=title
1102: self.weight=weight
1103: self.credits=toList(credits)
1104: self.description=description
1105: self.contentType=contentType
1106: self.copyrightType=copyrightType
1107: self.renderingType=renderingType
1108: self.responsible=responsible
1109: self.resourceID=resourceID
1110:
1111: if coords:
1112: coordsnew=[ string.split(x,",") for x in coords]
1113: else:
1114: coordsnew=[]
1115:
1116: self.coords=coordsnew
1117: # self.viewClassification=""
1118:
1119:
1120:
1121: def getContentType(self):
1122: try:
1123: return normalizeCt(self.contentType)
1124: except:
1125: return ""
1126:
1127: def getCopyrightType(self):
1128: try:
1129: return self.copyrightType
1130: except:
1131: return ""
1132:
1133: def getRenderingType(self):
1134: try:
1135: return self.renderingType
1136: except:
1137: return ""
1138:
1139: def ECHO_resource_config(self):
1140: """Main configuration"""
1141:
1142: if not hasattr(self,'weight'):
1143: self.weight=""
1144:
1145: pt=zptFile(self, 'zpt/ChangeECHO_resource.zpt')
1146: return pt()
1147:
1148:
1149: def ECHO_resource_config_main(self):
1150: """Main configuration"""
1151: if not hasattr(self,'weight'):
1152: self.weight=""
1153: pt=zptFile(self, 'zpt/ChangeECHO_resource_main.zpt')
1154: return pt()
1155:
1156: def ECHO_resource_config_coords(self):
1157: """Coords configuration """
1158: pt=zptFile(self, 'zpt/ChangeECHO_resource_coords.zpt')
1159: return pt()
1160:
1161: def ECHO_resource_config_credits(self):
1162: """Main configuration"""
1163: pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
1164: return pt()
1165:
1166: def ECHO_resource_config_metadata(self):
1167: """Main configuration"""
1168: if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
1169: self.metaDataHash={}
1170: self.contentType=self.bib_type
1171: for data in self.metadata:
1172: data_neu=re.sub('-','_',data)
1173: self.metaDataHash[data_neu]=getattr(self,data)[0:]
1174:
1175:
1176: pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
1177: return pt()
1178:
1179:
1180:
1181: def changeViewer(self,newViewer):
1182: """set newViewer to the url of the new viewer
1183: only if metalink is set, otherwise it gives false
1184: """
1185:
1186: texterUrl="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn=/"
1187:
1188: vl,msg=self.checkValidityOfMetaLink()
1189:
1190: if not vl: #ungueltiger link, versuche neuen
1191: newStr=re.match(".*/mpiwg/online/(.*)",self.metalink) # suche pfad hinter /mpiwg/online
1192: oldLink=self.metalink
1193:
1194: if newStr:
1195: self.metalink=texterUrl+newStr.group(1)
1196: vl,msg=self.checkValidityOfMetaLink()
1197: else:
1198: logging.error("change Viewer XX(mew Metadatafile) %s"%self.metalink)
1199: vl=False
1200:
1201: if not vl: # geht immer noch nicht, dann setzte wieder zurueck
1202: self.metaLink=oldLink
1203:
1204: logging.info("change Viewer (mew Metadatafile) %s"%self.metalink)
1205:
1206: if vl:
1207: self.newViewer=newViewer
1208: return vl,msg
1209: else:
1210: return vl,msg
1211:
1212: def checkValidityOfMetaLink(self):
1213: """checks if the metalink is valid xml"""
1214:
1215: ml=self.metalink
1216:
1217: try:
1218: txt=urllib.urlopen(ml)
1219:
1220: except:
1221: return False,"Cannot open: %s)"%ml
1222:
1223: txt.close()
1224: try:
1225: dom = NonvalidatingReader.parseUri(ml)
1226: except:
1227: return False, "Connot parse: %s)"%ml
1228:
1229: if len(dom.xpath("//texttool"))==0:
1230: return False, "No texttools: %s)"%ml
1231:
1232: return True,""
1233:
1234: def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,newViewer='',RESPONSE=None):
1235: """Aenderung der Properties"""
1236: self.resourceID=resourceID
1237: self.title=title
1238: self.label=label
1239: self.description=description
1240:
1241: self.contentType=contentType
1242: self.renderingType=renderingType
1243: self.weight=weight
1244:
1245: self.link=link
1246: self.metalink=metalink
1247:
1248: self.newViewer=newViewer
1249:
1250:
1251: if RESPONSE is not None:
1252: RESPONSE.redirect('manage_main')
1253:
1254:
1255: def changeECHO_resource_coords(self,RESPONSE=None):
1256: """Aenderung der Properties - coords"""
1257: #return self.REQUEST
1258: for area in self.getMapAreas():
1259: id = area.getId()
1260: if self.REQUEST.has_key('del.'+id):
1261: # delete this area
1262: self._delObject(id)
1263: # return to same menu
1264: if RESPONSE is not None:
1265: RESPONSE.redirect('ECHO_resource_config_coords')
1266: return
1267: # modify this area
1268: coordstring = self.REQUEST.get('coords.'+id, '')
1269: coords = string.split(coordstring, ',')
1270: angle = self.REQUEST.get('angle.'+id, '0')
1271: type = self.REQUEST.get('type.'+id, 'area')
1272: if len(coords) == 4:
1273: area.setCoordString(coordstring)
1274: area.setAngle(angle)
1275: area.setType(type)
1276: # return to main menu
1277: if RESPONSE is not None:
1278: RESPONSE.redirect('manage_main')
1279:
1280:
1281: def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
1282: """Aenderung der Properties"""
1283: self.credits=credits
1284: self.responsible=responsible
1285: self.copyrightType=copyrightType
1286:
1287: if RESPONSE is not None:
1288: RESPONSE.redirect('manage_main')
1289:
1290:
1291: def changeECHO_resource_metadata_local(self,RESPONSE=None):
1292: """change metadata"""
1293: tags=self.findTagsFromMapping(normalizeCt(self.contentType))
1294: for field in tags[1]:
1295: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
1296:
1297:
1298:
1299: if RESPONSE is not None:
1300: RESPONSE.redirect('manage_main')
1301:
1302: def changeECHO_resource_metadata(self,RESPONSE=None):
1303: """change metadata"""
1304: tags=self.findTagsFromMapping(normalizeCt(self.contentType))
1305: self.OSAS_meta={}
1306: for field in tags[1]:
1307: try:
1308: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
1309: self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
1310: except:
1311: logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
1312:
1313: print self.newMetaXML()
1314: tries=0
1315: for i in range(10):
1316: x=ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML')).read()
1317: if x=="ok":
1318:
1319: break;
1320:
1321:
1322:
1323: if RESPONSE is not None:
1324: RESPONSE.redirect('manage_main')
1325:
1326:
1327:
1328: def getMDValueSimpleSearchField(self):
1329: """returns value for simple search"""
1330:
1331: try:
1332: return " ".join([self.getMDValue('title',generic="yes"),
1333: self.getMDValue('author',generic="yes"),
1334: self.getMDValue('year',generic="yes"),self.getTitle()])
1335: except:
1336:
1337: #logger(" ECHO_collection(getMDSimpleSearchField)",logging.INFO," ".join([self.getMDValue('title',generic="yes"),
1338: # self.getMDValue('author',generic="yes"),
1339: # self.getMDValue('year',generic="yes"),'']))
1340: return ""
1341:
1342: def getMDValue(self,fieldNameTest,empty=None,generic=None):
1343: """get md values"""
1344: #TODO: cache mappinghash
1345:
1346: fieldName=None
1347: if generic:
1348: if self.contentType:
1349: ct=self.contentType.replace(" ","_").lower()
1350: ct=self.contentType.replace("-","_").lower()
1351: else:
1352: logger("ECHO_collection (getMDValue)", logging.INFO, "no_content type for %s"%self.getId())
1353: ct=""
1354:
1355: #caching
1356: if not hasattr(self,'_v_mapHash'): #noch keine cachevariable
1357: self._v_mapHash={}
1358:
1359:
1360:
1361: tmp=self._v_mapHash.get(ct,None)
1362: if tmp: #teste ob type schon existiert
1363: fieldName=tmp.get(fieldNameTest,None)
1364: else:
1365: self._v_mapHash[ct]={}
1366:
1367:
1368: #noch nicht gecached
1369: if not fieldName and hasattr(self.standardMD,ct):
1370: fieldName=getattr(self.standardMD,ct).generateMappingHash()[fieldNameTest][0]
1371: self._v_mapHash[ct][fieldNameTest]=fieldName
1372: if not fieldName:
1373: fieldName=fieldNameTest
1374: if not empty:
1375: #FIXME: warum gibt es manchmal kein metadatahas
1376: try:
1377:
1378: ret =self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%normalizeCt(self.contentType))
1379: except:
1380: logger("ECHO (line 1069)",logging.ERROR,"no md hash for %s"%self.getId())
1381: return ""
1382:
1383: else:
1384:
1385:
1386: ret= self.metaDataHash.get(fieldNameTest,empty)
1387:
1388: if type(ret) is StringType:
1389: return ret.decode('utf-8')
1390: else:
1391: return ret
1392:
1393: getFieldValue=getMDValue #depricated
1394:
1395: def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
1396: """new index.meta"""
1397: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1398:
1399: if not hasattr(self,'metaDataHash'):
1400:
1401: self.copyIndex_meta2echo_resource()
1402: try:
1403:
1404:
1405: return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1406: except:
1407: #print self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix
1408:
1409: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1410:
1411: def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
1412: """return bibliographical metadata as stored in the object"""
1413:
1414: try:
1415:
1416: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
1417: except:
1418: return "<error> no metadata stored</error>"
1419:
1420: def getXQueryMetaData(self,xquery):
1421: '''
1422: execute an xquery on the metadata and returns a list of tuples,
1423: each tuple represent the content of the node as text and the whole node as xml-fragment
1424: @param xquery: xquery auf den metadaten
1425: '''
1426:
1427: try:
1428: md=writeMetadata(self.metalink,self.metaDataHash,xmlfrag="yes")
1429: except:
1430: return None
1431:
1432: dom = NonvalidatingReader.parseString(md,"http://www.mpiwg-berlin.mpg.de/")
1433:
1434: results=Ft.Xml.XPath.Evaluate(xquery, contextNode=dom)
1435:
1436: ret=[]
1437: for result in results:
1438:
1439: buf = cStringIO.StringIO()
1440: PrettyPrint(result, stream=buf)
1441: str = buf.getvalue()[0:]
1442: buf.close()
1443: ret.append((getTextFromNode(result),str))
1444:
1445: return ret
1446:
1447: def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
1448: """prints out metadata as stored in the echo environment, format is the index.meta format"""
1449: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1450: return writeMetadata(self.metalink,self.metaDataHash)
1451:
1452: def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
1453: """Aenderung der Properties"""
1454:
1455: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
1456: self.link=link
1457: self.metalink=metalink
1458:
1459: if RESPONSE is not None:
1460: RESPONSE.redirect('manage_main')
1461:
1462:
1463: manage_options = Folder.manage_options+(
1464: {'label':'Main Config','action':'ECHO_resource_config_main'},
1465: {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
1466: {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
1467: {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
1468: {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
1469: {'label':'set/change startpage','action':'setStartPageForm'},
1470: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
1471: {'label':'Change AccessRights','action':'changeAccessRightForm'},
1472: )
1473:
1474:
1475: def isDefinedInThisSet(self,fields,field):
1476: """checks if field is defined in fields"""
1477: if (fields[0].has_key(field)) and not (fields[0][field]==""):
1478: return 1
1479: else:
1480:
1481: return 0
1482:
1483: def getFieldLabel(self,fields,field):
1484: """get labels"""
1485: try:
1486: ret =fields[0][field]
1487: if ret == "":
1488: return field
1489: else:
1490: return ret
1491: except:
1492: return field
1493:
1494:
1495:
1496: def getFieldTag(self,fields,field):
1497: """get labels"""
1498: try:
1499: ret =fields[0][field]
1500: if ret == "":
1501: return field
1502: else:
1503: return ret
1504: except:
1505: return field
1506:
1507:
1508:
1509: def getMetaDataHash(self):
1510: """md hash"""
1511: return self.metaDataHash
1512:
1513: def setFieldValue(self,field,value):
1514: """get value"""
1515: #TODO: remove setFieldValue
1516:
1517: if not hasattr(self,'metaDataHash'):
1518: setattr(self,'metaDataHash',{})
1519: self.metaDataHash[field]=value[0:]
1520:
1521: def copySearchFields(self):
1522: """copys metadatafields to the object"""
1523: fields=['author','title','year']
1524:
1525: for field in fields:
1526: setattr(self,'MD_'+field,self.getMDValue(field,generic="yes"))
1527:
1528:
1529: def findLabelsFromMapping(self,referenceType):
1530: """gib hash mit label -> generic zurueck"""
1531: #return {},[]
1532:
1533: temp=self.ZopeFind(self.standardMD)
1534:
1535: if referenceType=="":
1536: referenceType="book"
1537:
1538:
1539: bibdata={}
1540: retdata={}
1541: fields=[]
1542: fieldlist=self.standardMD.fieldList
1543:
1544: tags=self.findTagsFromMapping(normalizeCt(self.contentType))
1545: self.referencetypes=tags[2]
1546: for referenceTypeF in self.referencetypes:
1547:
1548:
1549: if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
1550:
1551: try:
1552: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1553: referenceType=referenceTypeF[1].title
1554: except:
1555: bibdata[referenceType]=referenceTypeF[1].fields
1556:
1557:
1558: bibdata['data']=referenceTypeF[1]
1559: fields=bibdata[referenceType]
1560: for field in fieldlist:
1561: retdata[field]=referenceTypeF[1].getValue(field)[1]
1562:
1563: return retdata,fieldlist,temp,fields
1564:
1565: def findTagsFromMapping(self,referenceType):
1566: """gib hash mit label -> generic zurueck"""
1567:
1568:
1569: if referenceType=="":
1570: referenceType="book"
1571:
1572: temp = self.ZopeFind(self.standardMD)[0:]
1573:
1574:
1575: #self.referencetypes=temp[0:]
1576:
1577:
1578:
1579:
1580: bibdata={}
1581: retdata={}
1582: fieldlist=self.standardMD.fieldList
1583: fields=[]
1584: for referenceTypeF in temp:
1585: #print referenceType
1586:
1587: if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
1588: try:
1589: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1590: referenceType=referenceTypeF[1].title
1591: except:
1592: bibdata[referenceType]=referenceTypeF[1].fields
1593: bibdata['data']=referenceTypeF[1]
1594: fields=bibdata[referenceType]
1595: for field in fieldlist:
1596: retdata[field]=referenceTypeF[1].getValue(field)[0]
1597:
1598: return retdata,fieldlist,temp,fields
1599:
1600:
1601: security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination
1602: def copyIndex_meta2echo_resource(self,RESPONSE=None):
1603: """copy MD von Index_meta to the echo_resource"""
1604:
1605: (metadict, error)=readMetadata(self.metalink)
1606:
1607:
1608:
1609: self.metaDataHash={}
1610: if not error=="": #Fehler beim Auslesen des Metafiles
1611:
1612: return "ERROR:",error,self.absolute_url()
1613:
1614: self.contentType=normalizeCt(metadict['bib_type'])[0:]
1615: fields=self.findTagsFromMapping(normalizeCt(self.contentType))
1616:
1617: #fields=self.findLabelsFromMapping(normalizeCt(self.contentType))
1618: for field in fields[1]:
1619:
1620: if self.isDefinedInThisSet(fields,field):
1621: #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
1622: self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
1623:
1624:
1625:
1626: if RESPONSE:
1627: return RESPONSE.redirect('manage_main')
1628:
1629: return "OK:",self.absolute_url(),normalizeCt(self.contentType)
1630:
1631: def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"):
1632: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
1633: (metadict, error)=readMetadata(self.metalink)
1634:
1635: if back:
1636: self.REQUEST.SESSION['back']=back
1637:
1638: if not error=="": #Fehler beim Auslesen des Metafiles
1639: return "ERROR:",error
1640:
1641: if (not self.contentType) or (overwrite=="yes"):
1642: self.contentType=normalizeCt(normalizeCt(metadict['bib_type']).lower())
1643:
1644: if not (normalizeCt(metadict['bib_type']).lower()==normalizeCt(self.contentType).lower()):
1645: self.REQUEST.SESSION['contentStorage']=normalizeCt(metadict['bib_type'])
1646: self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)
1647:
1648: return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
1649:
1650: #self.REQUEST.SESSION['metadict']=metadict
1651:
1652:
1653:
1654:
1655: self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
1656:
1657:
1658: if template=="yes":
1659: #pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_resourceMD.zpt'),metadict=metadict).__of__(self)
1660: pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
1661:
1662: return pt(metadict=metadict)
1663:
1664:
1665:
1666:
1667:
1668: def ECHO_getMD(self,item):
1669: """Ausgabe der MD"""
1670: return getattr(self,item)
1671:
1672: def checkRDF(self,path):
1673: """check if pdf in the path"""
1674: try:
1675: for fileName in os.listdir(path):
1676: if os.path.splitext(fileName)[1]==".pdf":
1677: return os.path.join(path,fileName)
1678: return None
1679: except:
1680: return None
1681:
1682:
1683: security.declareProtected('View','index_html')
1684: def index_html(self):
1685: """standard page"""
1686: pdf=self.checkRDF(self.link)
1687: if pdf:
1688: fh=file(pdf,'r').read()
1689: self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
1690: self.REQUEST.RESPONSE.write(fh)
1691: self.REQUEST.RESPONSE.close()
1692: return
1693:
1694: if getattr(self,'newViewer',''): #benutze den neuen viewer
1695: url=self.newViewer+'url='+self.metalink+"&mode=texttool"
1696: return self.REQUEST.RESPONSE.redirect(url)
1697:
1698: return self.REQUEST.RESPONSE.redirect(self.link)
1699:
1700: def startpage_html(self):
1701: """prints out a startpage for a resource for use e.g. in the BVE"""
1702:
1703: # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
1704:
1705: sp=self.ZopeFind(self,obj_ids=['startpage.html'])
1706:
1707: if sp:
1708: return sp[1]()
1709:
1710: #pruefen ob irgendwo ein template
1711: if hasattr(self,'startpage_index_template'):
1712: return self.startpage_index_template()
1713:
1714: #generisches template ausgeben
1715:
1716: pt=zptFile(self, 'zpt/ECHO_startpage_index_template_standard.zpt')
1717: pt.content_type="text/html"
1718: return pt()
1719:
1720: def toc_html(self):
1721:
1722: sp=self.ZopeFind(self,obj_ids=['toc.html'])
1723:
1724: if sp:
1725: return sp[0][1]()
1726:
1727:
1728: security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
1729:
1730: def generate_label(self):
1731: """Erzeugt_standard_Label aus Template"""
1732: pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())
1733:
1734: self.label=pt()[0:]
1735: return pt()
1736:
1737: security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
1738:
1739: def generate_title(self,RESPONSE=None):
1740: """Erzeugt_standard_Label aus Template"""
1741: pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())
1742:
1743: self.title=pt()[0:]
1744:
1745: return pt()
1746:
1747: Globals.InitializeClass(ECHO_resource)
1748:
1749: def manage_addECHO_resourceForm(self):
1750: """Form for adding a ressource"""
1751: pt=zptFile(self, 'zpt/AddECHO_resourceForm.zpt')
1752: return pt()
1753:
1754:
1755:
1756: 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):
1757: """addresource"""
1758:
1759: newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
1760:
1761: self._setObject(id,newObj)
1762:
1763: if RESPONSE is not None:
1764: RESPONSE.redirect('manage_main')
1765:
1766:
1767: class ECHO_externalLink(Folder,ECHO_basis):
1768: """Link zu einer externen Ressource"""
1769: security=ClassSecurityInfo()
1770: meta_type='ECHO_externalLink'
1771:
1772: security.declarePublic('content_html')
1773: def content_html(self):
1774: """template fuer content"""
1775: ret= ECHO_basis.content_html(self,'externalLink')
1776:
1777: if type(ret) is StringType:
1778: return ret.decode('utf-8')
1779: else:
1780: return ret
1781:
1782:
1783:
1784: def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType):
1785:
1786: self.id = id
1787: """Festlegen der ID"""
1788:
1789: self.credits=toList(credits)
1790: self.label = label
1791: self.link= link
1792: self.title=title
1793: self.weight=weight
1794: self.description=description
1795: self.contentType=contentType
1796: self.responsible=responsible
1797: coordsnew=[ string.split(x,",") for x in coords]
1798: self.coords=coordsnew
1799: self.linkType = linkType # Linktypen 'otherPresentation','external'
1800:
1801:
1802: def ECHO_externalLink_config(self):
1803: """Main configuration"""
1804:
1805: if not hasattr(self,'weight'):
1806: self.weight=""
1807: if not hasattr(self,'coords'):
1808:
1809: self.coords=['']
1810:
1811:
1812: pt=zptFile(self, 'zpt/ChangeECHO_externalLink.zpt')
1813: return pt()
1814:
1815:
1816: def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
1817: """Aenderung der Properties"""
1818: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
1819:
1820: self.link=link
1821: self.linkType = linkType
1822: if RESPONSE is not None:
1823: RESPONSE.redirect('manage_main')
1824:
1825: def getLinkType(self):
1826: """ return linkType """
1827: if hasattr(self,"linkType"):
1828: return self.linkType
1829: else :
1830: return 'otherPresentation'
1831:
1832: def setLinkType(self,type):
1833: """ set linkType """
1834: self.linkType = type
1835:
1836: def checkLink(self):
1837: """ returns tuple (isWorking,Error) """
1838: try:
1839: urllib2.urlopen(self.link)
1840: return (True, '')
1841: except urllib2.HTTPError, e:
1842: return (False, e.code)
1843: except urllib2.URLError, e:
1844: return (False, str(e.reason))
1845: except:
1846: return (False, 'unknown Error')
1847:
1848:
1849: manage_options = (
1850: {'label':'Main Config','action':'ECHO_externalLink_config'},
1851: {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
1852: )+Folder.manage_options
1853:
1854:
1855: def index_html(self):
1856: """standard page"""
1857:
1858: return self.REQUEST.RESPONSE.redirect(self.link)
1859:
1860:
1861: def manage_addECHO_externalLinkForm(self):
1862: """Form for external Links"""
1863: pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')
1864: return pt()
1865:
1866:
1867: def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
1868: """Add an external Link"""
1869:
1870: newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
1871:
1872: self._setObject(id,newObj)
1873:
1874: if RESPONSE is not None:
1875: RESPONSE.redirect('manage_main')
1876:
1877:
1878: class ECHO_link(ECHO_externalLink):
1879: """external_link"""
1880:
1881: meta_type="ECHO_link"
1882:
1883: manage_options = ECHO_externalLink.manage_options+(
1884: {'label':'add links config','action':'ECHO_link_addLinksForm'},
1885: )
1886:
1887: def ECHO_link_addLinksForm(self):
1888: """Main configuration"""
1889:
1890: pt=zptFile(self, 'zpt/ChangeECHO_link_addLinks.zpt')
1891: return pt()
1892:
1893: def ECHO_link_addLinks(self,addLinks,RESPONSE):
1894: """add links"""
1895: self.addLinks=addLinks
1896: if RESPONSE is not None:
1897: RESPONSE.redirect('manage_main')
1898:
1899: def content_html(self):
1900: """template fuer link"""
1901:
1902:
1903: if hasattr(self,"link_template"):
1904: ret=ECHO_basis.content_html(self,'link')
1905:
1906: else:
1907: ret=ECHO_basis.content_html(self,'collection')
1908:
1909:
1910: #return ret
1911: return ret
1912: #
1913: #
1914: # try:
1915: # return ret.decode('utf-8')
1916: # except:
1917: # try:
1918: # return ret.decode('latin-1')
1919: # except:
1920: #
1921: # return ret
1922: #
1923: def getCopyrightsHTML(self):
1924: """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
1925:
1926: if hasattr(self,'copyrightModel'):
1927: obj=self.copyrightModel
1928:
1929: else:
1930: return "ERROR"
1931: ret=[]
1932:
1933: for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
1934:
1935:
1936: try:
1937: if hasattr(self.copyrightTypes,copyright[2]):
1938: copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
1939: link="copyrightTypes/"+copyright[2]+'/copyright.html'
1940: else:
1941: copyrightTypeObj=getattr(obj,copyright[2])
1942: link="copyrightModel/"+copyright[2]+'/copyright.html'
1943:
1944: label=copyrightTypeObj.label
1945: url=getattr(copyrightTypeObj, 'url', '')
1946:
1947: if url!='':
1948: ret.append((url,copyright[0],copyright[1],copyright[2],label))
1949: else:
1950: if hasattr(copyrightTypeObj, 'copyright.html'):
1951: ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
1952: else:
1953: ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
1954: except:
1955: """nothing"""
1956:
1957: return ret
1958:
1959: def getInstitutionsHTML(self):
1960: """gibt Liste der foerdernden Institutionen aus"""
1961:
1962: if hasattr(self,'support'):
1963: obj=self.support
1964: ret=obj.getSupporter()
1965: return ret
1966: else:
1967: return ''
1968:
1969: def getOwnerOriginalsHTML(self):
1970: """gibt Liste der foerdernden Institutionen aus"""
1971:
1972: if hasattr(self,'ownerOriginal'):
1973: obj=self.ownerOriginal
1974: ret=obj.getOwner()
1975: return ret
1976: else:
1977: return ''
1978:
1979: def getDigiCopyByHTML(self):
1980: """gibt Liste der foerdernden Institutionen aus"""
1981:
1982: if hasattr(self,'digiCopyBy'):
1983: obj=self.digiCopyBy
1984: ret=obj.getDigiCopyBy()
1985: return ret
1986: else:
1987: return ''
1988:
1989: def index_html(self):
1990: """standard link"""
1991: if self.link:
1992: splitted=self.link.split("?")
1993: if len(splitted)>1:
1994: params=cgi.parse_qs(splitted[1])
1995:
1996: for x in params.keys():
1997: if type(params[x]) is ListType:
1998: params[x]=params[x][0]
1999:
2000:
2001: else:
2002: params={}
2003:
2004: if getattr(self,'addLinks','yes')=="yes":
2005: params['backLink']=self.aq_parent.absolute_url()
2006: params['startLink']=splitted[0]+"?"+urllib.urlencode(params)
2007:
2008:
2009: return self.REQUEST.RESPONSE.redirect(splitted[0]+"?"+urllib.urlencode(params))
2010: else:
2011: return ""
2012:
2013: def manage_addECHO_linkForm(self):
2014: """Form for external Links"""
2015: pt=zptFile(self, 'zpt/AddECHO_linkForm.zpt')
2016: return pt()
2017:
2018:
2019: def manage_addECHO_link(self,id,title,label,description="",contentType="",responsible="",link="",weight="",coords=[],credits=None,linkType="external",RESPONSE=None):
2020: """Add an external Link"""
2021:
2022: newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
2023:
2024: self._setObject(id,newObj)
2025:
2026: getattr(self,id).addLinks='no'
2027:
2028: if RESPONSE is not None:
2029: RESPONSE.redirect('manage_main')
2030:
2031:
2032: class ECHO_collection(CatalogAware, Folder, Persistent, Implicit, Cacheable,ECHO_basis):
2033: """ECHO Collection"""
2034:
2035: management_page_charset="utf-8"
2036: security=ClassSecurityInfo()
2037: meta_type='ECHO_collection'
2038: default_catalog='resourceCatalog'
2039:
2040: # viewClassificationList=viewClassificationListMaster
2041: displayTypes=displayTypes
2042:
2043: path="/mpiwg/online/permanent/shipbuilding"
2044:
2045:
2046: def exportImportObjects_html(self,RESPONSE):
2047: """ImportObject"""
2048: pt=zptFile(self, 'zpt/exportImportObjects.zpt')
2049: pt.content_type="text/html"
2050: return pt()
2051:
2052: def importObjects_html(self,RESPONSE):
2053: """ImportObject"""
2054: pt=zptFile(self, 'zpt/importObjects.zpt')
2055: pt.content_type="text/html"
2056: return pt()
2057:
2058: def importObjects(self,zfile,RESPONSE=None,REQUEST=None):
2059: """import object from file"""
2060:
2061: zf=zipfile.ZipFile(zfile,"r")
2062: tmpdir=tempfile.mkdtemp() # create tempdir
2063: ret=None
2064:
2065: for name in zf.namelist():
2066: fn=tempfile.mkstemp()[1]
2067: tf=file(fn,"w")
2068: x=zf.read(name)
2069: tf.write(x)
2070: tf.close()
2071: try:
2072: self._importObjectFromFile(fn,set_owner=1)
2073: except:
2074: if not ret:
2075: ret=""
2076: ret+="Cannot import: %s (Already existing?)<br>"%name
2077: os.remove(fn)
2078:
2079: if ret:
2080: return """<html><body>%s</body></html>"""%ret
2081: if RESPONSE:
2082: RESPONSE.redirect(self.absolute_url())
2083:
2084: def exportObjects_html(self,RESPONSE):
2085: """Export objects"""
2086:
2087: pt=zptFile(self, 'zpt/exportObjects.zpt')
2088: pt.content_type="text/html"
2089: return pt()
2090:
2091: def exportObjects(self,ids,RESPONSE=None):
2092: """export objects with type id"""
2093: if not (type(ids) is ListType):
2094: ids=[ids]
2095:
2096: tmpdir=tempfile.mkdtemp() # create tempdir
2097: objs=self.ZopeFind(self,obj_ids=ids)
2098: tmpfile=tempfile.mkstemp()[1]
2099:
2100: zf=zipfile.ZipFile(tmpfile,"w")
2101: for obj in objs:
2102:
2103: f = os.path.join(tmpdir, '%s.zexp' %obj[0])
2104: #print E.absolute_url()
2105:
2106: obj[1]._p_jar.exportFile(obj[1]._p_oid, f)
2107:
2108: zf.write(f,obj[0])
2109:
2110: zf.close()
2111: shutil.rmtree(tmpdir)
2112: if RESPONSE:
2113: RESPONSE.setHeader("Content-Type","application/octet-stream")
2114: len=os.stat(tmpfile)[6]
2115: RESPONSE.setHeader("Content-Length",len)
2116: RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"export.zip")
2117: fh=file(tmpfile)
2118: for x in fh.read():
2119: RESPONSE.write(x)
2120: fh.close()
2121:
2122: def getMDValueSimpleSearchField(self):
2123: """returns value for simple search"""
2124: return " ".join([self.title,self.description])
2125:
2126: def getTitleAndLabel(self):
2127: """gibt title und label zurueck"""
2128: return (getattr(self,'title',''),getattr(self,'label',''))
2129:
2130: def localizeObjects(self):
2131: """localize all objects"""
2132: contents=self.ZopeFind(self,obj_metatypes=['ECHO_externalLink','ECHO_link','ECHO_mapText'])
2133:
2134: find=self.ZopeFind(self,obj_ids=('locale_en'))
2135: if not find:
2136: self.manage_addECHO_locale("en",'','')
2137: for content in contents:
2138:
2139: if content[1].meta_type in ['ECHO_link','ECHO_externalLink']:
2140:
2141: find=content[1].ZopeFind(content[1],obj_metatypes=('ECHO_mapText'))
2142: if find:
2143: root=find[0][1]
2144:
2145: locale=find[0][1].ZopeFind(find[0][1],obj_ids=('locale_en'))
2146: else:
2147: root=None
2148: else:
2149: root=content[1]
2150: locale=content[1].ZopeFind(content[1],obj_ids=('locale_en'))
2151: if root and not locale:
2152: root.manage_addECHO_locale("en",'','')
2153:
2154: pt=zptFile(self, 'zpt/localizeObjects.zpt')
2155: return pt()
2156:
2157:
2158: def localize(self,REQUEST,RESPONSE):
2159: """localize"""
2160: for key in REQUEST.form.keys():
2161: splitted=key.split("!")
2162:
2163: if splitted[0]=="" or splitted[0]=="en" or splitted[0]=="title" or splitted[0]=="label":
2164: if splitted[0]=="en":
2165: setattr(self.locale_en,splitted[1],REQUEST.form[key])
2166: else:
2167: setattr(self,splitted[0],REQUEST.form[key])
2168: else:
2169: obj=getattr(self,splitted[0])
2170:
2171: if obj.meta_type=="ECHO_mapText":
2172: if splitted[1]=="en":
2173: obj.locale_en.pt_edit(REQUEST.form[key],obj.locale_en.content_type)
2174: else:
2175: obj.pt_edit(REQUEST.form[key],obj.content_type)
2176: else:
2177: text=obj.ZopeFind(obj,obj_metatypes=['ECHO_mapText'])
2178: if splitted[1]=="en":
2179:
2180: text[0][1].locale_en.pt_edit(REQUEST.form[key],text[0][1].locale_en.content_type)
2181: else:
2182: text[0][1].pt_edit(REQUEST.form[key],text[0][1].content_type)
2183: if RESPONSE is not None:
2184: RESPONSE.redirect('manage_main')
2185:
2186:
2187: def getRDF(self,urn=None):
2188: """rdf of the collection"""
2189:
2190: contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
2191:
2192: ret=getRDFDescription(self,self.absolute_url(),urn=urn)
2193:
2194: if not urn:
2195: urn=self.absolute_url()
2196:
2197: li="""<RDF:li RDF:resource="%s" />\n"""
2198:
2199:
2200: for content in contents:
2201: ret+=content[1].getRDF()+"\n"
2202:
2203: ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
2204: for content in contents:
2205: nurn=content[1].absolute_url()
2206: ret+=li%nurn
2207: return ret+"</RDF:Seq>"
2208:
2209:
2210:
2211: def changeLabels(self):
2212: """change form"""
2213: pt=zptFile(self, 'zpt/changeLabelsForm')
2214: pt.content_type="text/html"
2215: return pt()
2216:
2217: def changeTitles(self):
2218: """change form"""
2219: pt=zptFile(self, 'zpt/changeTitleForm')
2220: pt.content_type="text/html"
2221: return pt()
2222:
2223: def changeWeights(self):
2224: """change form"""
2225: pt=zptFile(self, 'zpt/changeWeightForm')
2226: pt.content_type="text/html"
2227: return pt()
2228:
2229: def changeMetaDataLinks(self):
2230: """change form"""
2231: pt=zptFile(self, 'zpt/changeMetaDataLinkForm')
2232: pt.content_type="text/html"
2233: return pt()
2234:
2235: def changeAccessRightsCollectionForm(self,preselect=None):
2236: """change access rights of all resources in this collection"""
2237:
2238: pt=zptFile(self, 'zpt/changeAccessRightsCollectionForm')
2239: pt.content_type="text/html"
2240: return pt(preselect=preselect)
2241:
2242:
2243: def changeAccessRightsCollection(self):
2244: """change"""
2245: ret=""
2246: argv=self.REQUEST.form
2247:
2248: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2249: for resource in resources:
2250:
2251: if argv.has_key(resource[1].getId()+'_xml'):
2252: ret+=resource[1].getId()+" "+argv[resource[1].getId()+'_xml']+"</br>"
2253: resource[1].setAccessRightXML(argv[resource[1].getId()+'_xml'])
2254: resource[1].accessRight=argv[resource[1].getId()+'_xml']
2255: elif argv.has_key(resource[1].getId()+'_echo'):
2256: ret+="only local:"+resource[1].getId()+" "+argv[resource[1].getId()+'_echo']+"</br>"
2257: resource[1].accessRight=argv[resource[1].getId()+'_echo']
2258: else:
2259: ret+="ERROR:" +resource[0]
2260: return ret
2261:
2262: def changeMetaDataLinkInCollection(self):
2263: """change all lables of a collection"""
2264: ret=""
2265: argv=self.REQUEST.form
2266:
2267: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2268: for resource in resources:
2269:
2270: try:
2271: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2272: resource[1].metalink=argv[resource[1].getId()][0:]
2273: except:
2274: pass
2275: return ret
2276:
2277: def changeMetaDataLinkInCollection(self):
2278: """change all lables of a collection"""
2279: ret=""
2280: argv=self.REQUEST.form
2281:
2282: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2283: for resource in resources:
2284:
2285: try:
2286: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2287: resource[1].metalink=argv[resource[1].getId()][0:]
2288: except:
2289: pass
2290: return ret
2291:
2292: def changeWeightsInCollection(self):
2293: """change all lables of a collection"""
2294: ret=""
2295: argv=self.REQUEST.form
2296:
2297: resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
2298: for resource in resources:
2299:
2300: try:
2301: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2302: resource[1].weight=argv[resource[1].getId()][0:]
2303: except:
2304: pass
2305: return ret
2306:
2307: def changeTitlesInCollection(self):
2308: """change all lables of a collection"""
2309: ret=""
2310: argv=self.REQUEST.form
2311:
2312: resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
2313: for resource in resources:
2314:
2315: try:
2316: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2317: resource[1].title=argv[resource[1].getId()][0:]
2318: except:
2319: pass
2320: return ret
2321:
2322: def changeLabelsInCollection(self):
2323: """change all lables of a collection"""
2324: ret=""
2325: argv=self.REQUEST.form
2326:
2327: resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
2328: for resource in resources:
2329:
2330: try:
2331: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2332: resource[1].label=argv[resource[1].getId()][0:]
2333: except:
2334: pass
2335: return ret
2336:
2337: def importCollection(self,path=None,RESPONSE=None):
2338: """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
2339:
2340: if path is None:
2341: pt=zptFile(self, 'zpt/importCollection.zpt')
2342: return pt()
2343:
2344: files=os.listdir(path)
2345: ret=""
2346: for fileName in files:
2347:
2348: if fileName:
2349:
2350: tempPath=re.sub("/mpiwg/online","",path)
2351: link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"
2352:
2353: metalink=self.path+"/"+fileName+"/index.meta"
2354: try:
2355:
2356: #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"
2357:
2358: newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'generated','book','','','','','','')
2359: self._setObject(fileName,newObj)
2360:
2361: genObj=getattr(self,fileName)
2362: #genObj.createIndexFile()
2363: ret+="OK:"+fileName+"<br/>"
2364: except:
2365: print "ERROR"
2366: ret+="ERROR:"+fileName+"<br/>"
2367:
2368: return ret
2369:
2370: if RESPONSE is not None:
2371: RESPONSE.redirect('manage_main')
2372:
2373: def changeViewerTemplateSetsForm(self):
2374: """change the viewer template set"""
2375: pt=zptFile(self, 'zpt/changeViewerTemplateSet')
2376: return pt()
2377:
2378: def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):
2379: """Get the ViewerTemplateSet title for configuration"""
2380: ret=[]
2381:
2382: try:
2383: viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.
2384:
2385: for viewerTemplateSet in viewerTemplateSets:
2386: ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))
2387:
2388: return ret
2389:
2390: except:
2391: return [('no ViewerTemplateSetfolders','')]
2392:
2393: def getTextToolsField(self,name,default=''):
2394: """Lese viewerTemplateSet der Collection not implemented yet!"""
2395:
2396: return default
2397:
2398:
2399: def isSelectedViewerTemplateSet(self,obj,id):
2400: """is ausgewaehlt"""
2401:
2402: if self.REQUEST['viewerTemplateSet']==id:
2403: return 1
2404: else:
2405: return None
2406:
2407: def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):
2408: """changes all ressources to the newViewer"""
2409:
2410: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2411: if RESPONSE is not None:
2412: RESPONSE.write("<html><body>")
2413:
2414: for resource in resources:
2415:
2416: done,msg=resource[1].changeViewer(newViewer)
2417: if done:
2418: if RESPONSE is not None:
2419: RESPONSE.write("<p>OK: %s"%resource[0])
2420: else:
2421: if RESPONSE is not None:
2422: RESPONSE.write("<p><a href='%s'>ERROR: %s (%s)</a>"%(resource[1].absolute_url()+'/ECHO_resource_config_main',resource[0],msg))
2423:
2424:
2425:
2426: if RESPONSE is not None:
2427: RESPONSE.write("<p>Done</p></body></html>")
2428:
2429: def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
2430: """change the templates"""
2431:
2432: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2433:
2434: for resource in resources:
2435:
2436: resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
2437:
2438: if RESPONSE is not None:
2439: RESPONSE.redirect('manage_main')
2440:
2441:
2442: def setStartpageFolderForm(self):
2443: """Form for changing the startpage"""
2444:
2445:
2446: pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPageFolder.zpt')
2447: pt.content_type="text/html"
2448: return pt()
2449:
2450: def setStartpageFolder(self,startpage=None,RESPONSE=None):
2451: """change the templates"""
2452:
2453: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2454:
2455: for resource in resources:
2456:
2457: resource[1].setStartPage(startpage)
2458:
2459: if RESPONSE is not None:
2460: RESPONSE.redirect('manage_main')
2461:
2462: def copyTitleToInfoXMLFolder(self,RESPONSE=None):
2463: """copy title into the title field of info.xml
2464: author and date werden leer!!!
2465: """
2466:
2467:
2468: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2469:
2470:
2471: for resource in resources:
2472: ret,txt=resource[1].copyTitleToInfoXML()
2473: if (not ret) and RESPONSE:
2474: RESPONSE.write("error: %s\n"%txt)
2475: if ret and RESPONSE:
2476: RESPONSE.write("ok: %s\n"%txt)
2477:
2478: #logger("ECHO (copyTitleToInfoXMLFolder)",logging.INFO,txt)
2479: if RESPONSE is not None:
2480: RESPONSE.write("done!\n")
2481: RESPONSE.close()
2482: RESPONSE.redirect('manage_main')
2483:
2484: def copySearchFields(self,RESPONSE=None):
2485: """copys < metadatafields to the object"""
2486: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2487:
2488: for resource in resources:
2489:
2490: resource[1].copySearchFields()
2491:
2492: if RESPONSE is not None:
2493: RESPONSE.redirect('manage_main')
2494:
2495: def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
2496: """warning"""
2497: pt=zptFile(self, 'zpt/reloadMetaDataFromStorageWarning.zpt')
2498: pt.content_type="text/html"
2499: return pt()
2500:
2501: def reloadMetaDataFromStorage(self,RESPONSE=None):
2502: """copy metadata from the storage to ECHO"""
2503:
2504: return reloadMetaDataFromStorage(self,RESPONSE)
2505:
2506:
2507: def getPartnerCopyright(self,name,sonst="generic"):
2508: """gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""
2509: #print "hi",name,sonst
2510: #print getattr(self.partners,name).copyrightType
2511: try:
2512: partner=getattr(self.partners,name)
2513: return partner.copyrightType
2514: except:
2515: print "error"
2516: return sonst
2517:
2518: def partnerSelector_HTML(self,selected=None):
2519: """give type selector"""
2520: if not selected:
2521: retStr="<option selected>\n"
2522: else:
2523: retStr="<option>\n"
2524:
2525: try: # erste version copyrightTypes exists
2526: for partner in self.getPartners():
2527: partnerTitle = partner.title
2528: partnerId = partner.__name__
2529: if selected and (partnerId==selected):
2530: retStr+="""<option selected value="%s">%s\n"""%(partnerId,partnerTitle)
2531: else:
2532: retStr+="""<option value="%s">%s\n"""%(partnerId,partnerTitle)
2533: except:
2534: """nothing"""
2535: return retStr
2536:
2537: # def getViewClassification(self):
2538: # if hasattr(self,'viewClassification'):
2539: # return self.viewClassification
2540: # else:
2541: # return ""
2542:
2543:
2544: def createRessourcesFromXMLForm(self):
2545: """form"""
2546: pt=zptFile(self, 'zpt/createRessourcesFromXMLForm.zpt')
2547: return pt()
2548:
2549: def createRessourcesFromXML(self,fileupload):
2550: """read an XML file for generating resources"""
2551: dom=xml.dom.minidom.parse(fileupload)
2552: ret="<h2>Added</h2>"
2553: for resource in dom.getElementsByTagName('resource'):
2554: link=getText(resource.getElementsByTagName('link')[0].childNodes)
2555: label=getText(resource.getElementsByTagName('label')[0].childNodes)
2556: pageimglink=getText(resource.getElementsByTagName('pageimglink')[0].childNodes)
2557: #splitted=link.split("?")[0].split("/")
2558: #id=splitted[len(splitted)-1].encode('ascii')
2559: id=re.sub(" ","_",label).encode('ascii')
2560:
2561: ret+="<p>"+label+"</p>"
2562: manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","",pageimglink.encode('ascii'),link.encode('ascii'),"","")
2563: return ret
2564:
2565: security.declarePublic('getImageTag')
2566: def getImageTag(self):
2567: """GetTag"""
2568: try:
2569: return self.imageTag
2570: except:
2571: return ""
2572:
2573:
2574: def addMovie(self,id,title,label,description,contentType,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None):
2575: """SSS"""
2576:
2577: #manage_addECHO_movie(self,id,title,label,description,responsible,link,thumbUrl,rawFile,metalink,weight,credits=None,coords=None,RESPONSE=None)
2578: if not hasattr(self,id):
2579: try:
2580: manage_addECHO_movie(self,id,title,label,description,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None)
2581: return "done"
2582: except:
2583: return None
2584: else:
2585: obj=getattr(self,id)
2586: obj.changeECHO_movie_main(metalink,link,rawFile,lowresFile,thumbUrl,title,label,description,contentType,weight=weight)
2587:
2588: return "changed"
2589:
2590: def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
2591: """SSS"""
2592: try:
2593: manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
2594: return "done"
2595: except:
2596: return None
2597:
2598: def getSecondaryLink(self):
2599: """secondary link"""
2600: try:
2601: return self.secondaryLink
2602: except:
2603: return ""
2604:
2605: def getSecondaryLinkTitle(self):
2606: """secondary link"""
2607: try:
2608: return self.secondaryLinkTitle
2609: except:
2610: return ""
2611:
2612: def getCollectionTreeXML(self,pwstr=None):
2613: """Tree as XML"""
2614:
2615: def addPassWd(str,pwstr=None):
2616: """adds a user/passwd to an url"""
2617: if pwstr:
2618: txt2=re.sub(r"(http://)(.*?)","\g<1>%s@\g<2>"%pwstr,str)
2619: else:
2620: txt2=re.sub(r"(http://)(.*?)","\g<1>www:3333@\g<2>",str)
2621: return txt2
2622:
2623: def getCollection(object,depth=0,pwstr=None):
2624: depth+=1
2625: collections=""
2626: for entry in object.__dict__.keys():
2627: element=getattr(object,entry)
2628: try:
2629: if element.meta_type in ["ECHO_collection","ECHO_group"]:
2630: collections+="<element name=\""+urllib.quote(element.title)+"\" url=\""+addPassWd(element.absolute_url(),pwstr=pwstr)+"\">"
2631: collections+=getCollection(element,depth)+"</element>\n"
2632: except:
2633: """nothing"""
2634: return collections
2635:
2636: ret="""<?xml version="1.0" encoding="utf-8" ?>"""
2637: return ret+"<collection>"+getCollection(self,pwstr=pwstr)+"</collection>"
2638:
2639: def createAllJSAreas(self,mapColTypes=None):
2640: """create area calls for JavaScript"""
2641: areas = self.getAllMapAreas(mapColTypes=mapColTypes)
2642: return self.createJSAreas(areas)
2643:
2644:
2645: emptyPartner=ECHO_partner("", "","", "", "", "", "", "", "")
2646:
2647: security.declarePublic('getCreditObject')
2648: def getCreditObject(self,name):
2649: """credit id to credititem"""
2650: try:
2651: return getattr(self.partners,name)
2652: except:
2653:
2654: return self.emptyPartner
2655:
2656:
2657: security.declarePublic('ECHO_generateNavBar')
2658: def ECHO_generateNavBar(self):
2659: """Erzeuge Navigationsbar"""
2660: link=""
2661: object="self"
2662: ret=[]
2663: path=self.getPhysicalPath()
2664: for element in path:
2665:
2666:
2667: if not element=="":
2668: object+="."+element
2669:
2670: label=eval(object).label
2671: link+="/"+element
2672: if not label=="":
2673: ret.append((label,link))
2674: return ret
2675:
2676:
2677: def ECHO_rerenderLinksMDWarning(self):
2678: """change form"""
2679: pt=zptFile(self, 'zpt/rerenderLinksWarning')
2680: pt.content_type="text/html"
2681: return pt()
2682:
2683:
2684:
2685: security.declarePublic('ECHO_rerenderLinksMD')
2686: def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
2687: """Rerender all Links"""
2688: return ECHO_rerenderLinksMD(self,obj,types)
2689:
2690:
2691: def __init__(self,id,title,label,description="",contentType="",responsible="",credits="",weight="",sortfield="",coords=[],secondaryLinkTitle="",secondaryLink="",imageTag="",bgcolour="",isVisible=True):
2692:
2693: self.id = id
2694: """Festlegen der ID"""
2695: self.credits=toList(credits)
2696: self.label = label
2697: self.title=title
2698: self.description=description
2699: self.contentType=contentType
2700: self.responsible=responsible
2701: self.imageTag=imageTag
2702: self.weight=weight
2703: self.sortfield=sortfield
2704: coordsnew=[ string.split(x,",") for x in coords]
2705: self.coords=coordsnew
2706: self.secondaryLinkTitle=secondaryLinkTitle
2707: self.secondaryLink=secondaryLink
2708: self.bgcolour=bgcolour
2709: self.isVisible=isVisible
2710:
2711:
2712: manage_options = Folder.manage_options+ Cacheable.manage_options+(
2713: {'label':'Main Config','action':'ECHO_collection_config'},
2714: {'label':'Change Labels','action':'changeLabels'},
2715: {'label':'Change Titles','action':'changeTitles'},
2716: {'label':'Localize','action':'localizeObjects'},
2717: {'label':'Change Weights','action':'changeWeights'},
2718: {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},
2719: {'label':'Export/Import Objects','action':'exportImportObjects_html'},
2720: {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
2721: {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
2722: {'label':'Set Startpage','action':'setStartpageFolderForm'},
2723: {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},
2724: {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
2725: {'label':'ImportCollection','action':'importCollection'},
2726: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
2727: {'label':'Change access rights', 'action':'changeAccessRightsCollectionForm'},
2728: )
2729:
2730:
2731: security.declarePublic('ECHO_collection_config')
2732: def ECHO_collection_config(self):
2733: """Main configuration"""
2734:
2735: if not hasattr(self,'weight'):
2736: self.weight=""
2737:
2738: if not hasattr(self,'sortfield'):
2739: self.sortfield="weight"
2740:
2741: pt=zptFile(self, 'zpt/ChangeECHO_collection.zpt')
2742: return pt()
2743:
2744:
2745: def getBgcolour(self):
2746: """colour"""
2747: if hasattr(self,'bgcolour') and not (self.bgcolour==""):
2748: return self.bgcolour
2749: else:
2750: return "#dddddd"
2751:
2752:
2753: security.declarePublic('changeECHO_collection')
2754: def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",location=None,isAlwaysClickable=None,prefix="",suffix="",isVisible=True):
2755: """Aenderung der Properties"""
2756:
2757: self.secondaryLink=secondaryLink
2758: self.secondaryLinkTitle=secondaryLinkTitle
2759: self.imageTag=imageTag
2760: self.bgcolour=bgcolour
2761: self.location=location
2762: self.isAlwaysClickable=isAlwaysClickable
2763: self.prefix=prefix[0:]
2764: self.suffix=suffix[0:]
2765: self.setIsVisible(isVisible)
2766:
2767: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
2768:
2769: self.sortfield=sortfield
2770:
2771: if RESPONSE is not None:
2772: RESPONSE.redirect('manage_main')
2773:
2774: def setAlwaysClickable(self,flag="yes"):
2775: """set clickable"""
2776: if flag=="yes":
2777: self.isAlwaysClickable="yes"
2778: else:
2779: self.isAlwaysClickable=None
2780:
2781: return flag
2782:
2783: def showOverview(self):
2784: """overview"""
2785: if 'ECHO_overview.html' in self.__dict__.keys():
2786: return getattr(self,'ECHO_overview.html')()
2787: pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')
2788: return pt()
2789:
2790:
2791: security.declareProtected('View','index_html')
2792: def index_html(self):
2793: """standard page"""
2794: if self.ZCacheable_isCachingEnabled():
2795:
2796: result = self.ZCacheable_get()
2797: if result is not None:
2798: # Got a cached value.
2799: return result
2800:
2801: if 'index.html' in self.__dict__.keys():
2802: ret=getattr(self,'index.html')()
2803:
2804: elif 'overview' in self.__dict__.keys():
2805: ret=self.showOverview()
2806: elif hasattr(self,'collection_index_template'):
2807: ret=self.collection_index_template()
2808: elif hasattr(self,'main_index_template'):
2809:
2810: ret=self.main_index_template.__of__(self)(self.main_template)
2811: else:
2812: pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
2813: pt.content_type="text/html"
2814: ret=pt.render()
2815:
2816: self.ZCacheable_set(ret)
2817: return ret
2818:
2819: security.declarePublic('content_html')
2820: def content_html(self,**argv):
2821: """template fuer content"""
2822: #print "NN",argv
2823: ret = ECHO_basis.content_html(self,'collection')
2824:
2825: if type(ret) is StringType:
2826: return ret.decode('utf-8')
2827: else:
2828: return ret
2829:
2830:
2831: def getCredits(self):
2832: """Ausgabe der credits"""
2833: if self.credits:
2834: return self.credits
2835: else:
2836: return []
2837:
2838: def area_img(self):
2839: """area image"""
2840: bt = BrowserCheck(self)
2841: if bt.isIE or bt.isN4:
2842: return sendFile(self, 'images/red.gif', 'image/gif')
2843: else:
2844: return sendFile(self, 'images/reda.png', 'image/png')
2845:
2846: def trans_img(self):
2847: """empty image"""
2848: return sendFile(self, 'images/trans.gif', 'image/gif')
2849:
2850: def hl_lib_js(self):
2851: """javascript"""
2852: return sendFile(self, 'js/hl_lib.js', 'text/plain')
2853:
2854: def js_lib_js(self):
2855: """javascript -- old name"""
2856: return sendFile(self, 'js/baselib.js', 'text/plain')
2857:
2858: def baselib_js(self):
2859: """javascript"""
2860: return sendFile(self, 'js/baselib.js', 'text/plain')
2861:
2862: def hl_add_js(self):
2863: """javascript"""
2864: return sendFile(self, 'js/hl_add.js', 'text/plain')
2865:
2866: def getAllMapAreas(self,mapColTypes=None):
2867: """Give list of coordinates"""
2868: if mapColTypes is None:
2869: mapColTypes=['ECHO_collection','ECHO_resource','ECHO_link','ECHO_externalLink']
2870:
2871: areas=[]
2872: for entry in self.getSubCols(subColTypes=mapColTypes):
2873: object=entry
2874: areas.extend(object.getMapAreas())
2875: return areas
2876:
2877:
2878: def deleteMapAreas(self):
2879: """deletes all map areas from this object"""
2880: for obs in self.ZopeFind(self, obj_metatypes=['MapArea'], search_sub=1):
2881: ob = obs[1]
2882: id = ob.id
2883: parent = ob.aq_parent
2884: print "deleting: ", ob.id
2885: parent._delObject(id)
2886: return "Done"
2887:
2888:
2889: getSubCols = ECHO_helpers.getSubCols
2890:
2891: def getSubcolsXMLRpc(self,searchSimple):
2892: """simplesearch results suitable for xml rpc, gives back array objid,url"""
2893:
2894: return [x.absolute_url() for x in self.getSubCols(searchSimple=searchSimple)]
2895:
2896:
2897: Globals.InitializeClass(ECHO_collection)
2898:
2899: def manage_addECHO_collectionForm(self):
2900: """Add collection form"""
2901: pt=zptFile(self, 'zpt/AddECHO_collectionForm.zpt')
2902: return pt()
2903:
2904:
2905: def manage_addECHO_collection(self,id,title,label,description="",contentType="",responsible="",weight=0,sortfield="weight",coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",isVisible=True):
2906: """add a echo collection"""
2907:
2908:
2909: newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="",isVisible=isVisible)
2910:
2911: self._setObject(id,newObj)
2912:
2913: if RESPONSE is not None:
2914: RESPONSE.redirect('manage_main')
2915:
2916: class ECHO_group(ECHO_collection):
2917: """ECHO Gruppe"""
2918: security=ClassSecurityInfo()
2919: meta_type="ECHO_group"
2920:
2921: manage_options = Folder.manage_options+(
2922: {'label':'Main Config','action':'ECHO_group_config'},
2923: {'label':'Rerender Links','action':'ECHO_rerenderLinksMDWarning'},
2924: {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
2925: )
2926:
2927: security.declareProtected('View','index_html')
2928:
2929:
2930: def getRDF(self,urn=None):
2931: """rdf of the collection"""
2932: contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
2933:
2934: ret=getRDFDescription(self,self.absolute_url(),urn=urn)
2935:
2936:
2937: if not urn:
2938: urn=self.absolute_url()
2939: li="""<RDF:li RDF:resource="%s" />\n"""
2940:
2941:
2942: for content in contents:
2943: ret+=content[1].getRDF()+"\n"
2944:
2945: ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
2946: for content in contents:
2947: nurn=content[1].absolute_url()
2948: ret+=li%nurn
2949: return ret+"</RDF:Seq>"
2950:
2951: def index_html(self):
2952: """standard page"""
2953: displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
2954: #if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
2955: # return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
2956:
2957: if 'index.html' in self.__dict__.keys():
2958: return getattr(self,'index.html')()
2959:
2960: elif 'overview' in self.__dict__.keys():
2961: return self.showOverview()
2962: elif hasattr(self,'group_index_template'):
2963: return self.group_index_template()
2964: elif hasattr(self,'collection_index_template'):
2965: return self.collection_index_template()
2966: elif hasattr(self,'main_index_template'):
2967: return self.main_index_template()
2968:
2969: pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
2970: pt.content_type="text/html"
2971: return pt()
2972:
2973: def ECHO_group_config(self):
2974: """Main configuration"""
2975:
2976: if not hasattr(self,'weight'):
2977: self.weight=""
2978:
2979: if not hasattr(self,'sortfield'):
2980: self.sortfield="weight"
2981:
2982: if not hasattr(self,'coords'):
2983: self.coords=[]
2984:
2985: pt=zptFile(self, 'zpt/ChangeECHO_group.zpt')
2986: return pt()
2987:
2988: def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
2989: """Aenderung der Properties"""
2990:
2991: self.secondaryLink=secondaryLink
2992: self.secondaryLinkTitle=secondaryLinkTitle
2993: self.imageTag=imageTag
2994: self.bgcolour=bgcolour
2995: self.logo=logo
2996:
2997: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
2998:
2999:
3000:
3001: self.sortfield=sortfield
3002:
3003: if RESPONSE is not None:
3004: RESPONSE.redirect('manage_main')
3005:
3006: def getLogo(self):
3007: """logo ausgeben"""
3008: try:
3009: return self.logo
3010: except:
3011: return "ECHO_groups"
3012:
3013: security.declarePublic('content_html')
3014: def content_html(self):
3015: """template fuer content"""
3016: return ECHO_basis.content_html(self,'group')
3017:
3018:
3019:
3020: def manage_addECHO_groupForm(self):
3021: """Add group form"""
3022: pt=zptFile(self, 'zpt/AddECHO_groupForm.zpt')
3023: return pt()
3024:
3025:
3026: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
3027: """add a echo group"""
3028:
3029:
3030: newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
3031:
3032: setattr(newObj,'logo',logo)
3033: self._setObject(id,newObj)
3034:
3035: if RESPONSE is not None:
3036: RESPONSE.redirect('manage_main')
3037:
3038: Globals.InitializeClass(ECHO_group)
3039:
3040:
3041: class ECHO_userFolder(UserFolder):
3042: """User folder for Intranet"""
3043: _domain_auth_mode=1 # Identification via domain
3044: meta_type="ECHO_userFolder"
3045:
3046: def authenticate(self, name, password, request):
3047: emergency = self._emergency_user
3048: if name is None:
3049: return None
3050: if emergency and name==emergency.getUserName():
3051: user = emergency
3052: else:
3053: user = self.getUser(name)
3054: if user is not None and user.authenticate(password, request):
3055: return user
3056: else:
3057: return None
3058:
3059: def domainSpecMatch(self,spec, request):
3060: host=''
3061: addr=''
3062:
3063: # Fast exit for the match-all case
3064: if len(spec) == 1 and spec[0] == '*':
3065: return 1
3066:
3067: if request.has_key('REMOTE_HOST'):
3068: host=request['REMOTE_HOST']
3069:
3070: if request.has_key('REMOTE_ADDR'):
3071: addr=request['REMOTE_ADDR']
3072:
3073: if request.has_key('HTTP_X_FORWARDED_FOR'):
3074: addr=request['HTTP_X_FORWARDED_FOR']
3075:
3076:
3077: if not host and not addr:
3078: return 0
3079:
3080: if not host:
3081: try: host=socket.gethostbyaddr(addr)[0]
3082: except: pass
3083: if not addr:
3084: try: addr=socket.gethostbyname(host)
3085: except: pass
3086:
3087:
3088: _host=host.split('.')
3089: _addr=addr.split('.')
3090: _hlen=len(_host)
3091: _alen=len(_addr)
3092:
3093: for ob in spec:
3094: sz=len(ob)
3095: _ob=ob.split('.')
3096: _sz=len(_ob)
3097:
3098: mo = addr_match(ob)
3099: if mo is not None:
3100: if mo.end(0)==sz:
3101: fail=0
3102: for i in range(_sz):
3103: a=_addr[i]
3104: o=_ob[i]
3105: if (o != a) and (o != '*'):
3106: fail=1
3107: break
3108: if fail:
3109: continue
3110: return 1
3111:
3112: mo = host_match(ob)
3113: if mo is not None:
3114: if mo.end(0)==sz:
3115: if _hlen < _sz:
3116: continue
3117: elif _hlen > _sz:
3118: _item=_host[-_sz:]
3119: else:
3120: _item=_host
3121: fail=0
3122: for i in range(_sz):
3123: h=_item[i]
3124: o=_ob[i]
3125: if (o != h) and (o != '*'):
3126: fail=1
3127: break
3128: if fail:
3129: continue
3130: return 1
3131: return 0
3132:
3133: Globals.default__class_init__(ECHO_userFolder)
3134:
3135:
3136:
3137: def manage_addECHO_userFolder(self,dtself=None,REQUEST=None,**ignored):
3138: """add a user folder """
3139: f=ECHO_userFolder()
3140: self=self.this()
3141: try: self._setObject('acl_users', f)
3142: except: return MessageDialog(
3143: title ='Item Exists',
3144: message='This object already contains a User Folder',
3145: action ='%s/manage_main' % REQUEST['URL1'])
3146: self.__allow_groups__=f
3147: if REQUEST is not None:
3148: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
3149:
3150: def manage_addECHO_userFolderForm(self):
3151: """add a user folder form"""
3152: return manage_addECHO_userFolder(self)
3153:
3154:
3155:
3156: def createNode(self,descrs,node):
3157: name=descrs[node]['name']
3158: type=descrs[node]['type']
3159: urn=node
3160: #print " will create",node.encode('utf-8')
3161: id=re.sub('[^a-zA-Z0-9]','',name).encode('ascii','ignore')
3162: #print "id",id
3163: #print type
3164: #self.REQUEST.RESPONSE.write("<p>%s<p>\n"%id)
3165: if type=="CDLI_group":
3166:
3167: try:
3168: manage_addECHO_collection(self,id,name,name,"","","","","")
3169:
3170: except:
3171: self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
3172:
3173: self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
3174:
3175: return type,getattr(self,id),urn
3176:
3177: if type=="CDLI_item":
3178: try:
3179: manage_addECHO_resource(self,id,name,name,"","",urn,"","")
3180: except:
3181: self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
3182: self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
3183:
3184:
3185: return "XX"
3186:
3187:
3188: class ECHO_root(Folder,Persistent,Implicit):
3189: """ECHO Root Folder"""
3190:
3191: security=ClassSecurityInfo()
3192:
3193: meta_type="ECHO_root"
3194: management_page_charset="utf-8"
3195:
3196: getSubCols = ECHO_helpers.getSubCols
3197:
3198: manage_options=Folder.manage_options+(
3199: {'label':'Main Config','action':'ECHO_copyright_configForm'},
3200: {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
3201: {'label':'Change Weights','action':'changeWeights'},
3202: {'label':'Generate from RDF','action':'generateFromRDFForm'},
3203: {'label':'update Resource Catalog','action':'updateResourceCatalog'},
3204: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
3205: )
3206:
3207:
3208: def copySearchFields(self,RESPONSE=None):
3209: """copys < metadatafields to the object"""
3210: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
3211:
3212: for resource in resources:
3213:
3214: resource[1].copySearchFields()
3215:
3216: if RESPONSE is not None:
3217: RESPONSE.redirect('manage_main')
3218:
3219: def mod_re_sub(self,pattern,replace,string):
3220: """re.sub aus mod re zur Verfuegung stellen"""
3221: return re.sub(pattern,replace,string)
3222:
3223: def findObjectFromFulltext(self,existUri):
3224: '''
3225:
3226: @param url:
3227: @param existUri:
3228: '''
3229:
3230: if existUri:
3231: #TODO: at the moment assume that the filename is unique, the whole has to changed to a system of ids.
3232: filename=existUri.split("/")[-1]
3233:
3234: founds=self.resourceCatalog.search({'fullTextUrl':os.path.splitext(filename)[0]})
3235:
3236: ret=[(found.title,found.getObject().absolute_url(),found.getObject().aq_parent.absolute_url()) for found in founds]
3237:
3238: return ret
3239:
3240: def reindex(self,RESPONSE=None):
3241: """indiziere alle Objecte neu"""
3242:
3243: if RESPONSE:
3244: RESPONSE.write("<html><body>")
3245:
3246: resources=self.ZopeFind(self,obj_metatypes=["ECHO_resource"], search_sub=1)
3247:
3248: for resource in resources:
3249: resource[1].reindex()
3250: #print "<p> done %s </p>\n"
3251: if RESPONSE:
3252: RESPONSE.write("<p> done %s </p>\n"%resource[0])
3253:
3254: if RESPONSE:
3255: RESPONSE.write("<p> ok </p></html></body>\n")
3256:
3257:
3258: def setLanguage(self,lang):
3259: """Set language cookie"""
3260: self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
3261:
3262: def switchLanguage(self):
3263: """Set language cookie"""
3264: if self.getLanguage()=="en":
3265: lang="de"
3266: else:
3267: lang="en"
3268:
3269: self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
3270: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1'])
3271:
3272: def getLanguage(self):
3273: """get language cookie"""
3274: lang= self.REQUEST.cookies.get('lang_exhibition','de')
3275: if lang == '':
3276: lang="de"
3277: return lang
3278:
3279: def getContentOverviewTemplate(self):
3280: """produces overview template with macro"""
3281: pt = zptObjectOrFile(self, 'content_overview_template')
3282: return pt
3283:
3284: def mapstyle_css(self):
3285: """send mapstyle.css"""
3286: sendFile(self, 'html/ECHO_mapstyle.css', 'text/css')
3287:
3288:
3289: ###Cdli adds -> have to be removed
3290: def getTablet(self,item):
3291: #print "getTablet"
3292: try:
3293: read=urllib.urlopen("http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"%item).read()
3294: read=re.sub("\[search\]","search",read)
3295: return read[read.find("<body>")+6:read.rfind("</body>")]
3296: except:
3297: return "<h1>Sorry no connection to the data server enlil.museum.upenn.edu</h1>"
3298: #return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"
3299: ###END CDLI add
3300:
3301:
3302: def URLquote(self, text):
3303: """urllib.quote fuer Michael"""
3304: return urllib.quote(text)
3305:
3306:
3307: def checkResource(self,id):
3308: """checks if a resource is in the tree, gives back none or list of resources"""
3309: if not id:
3310: id=""
3311: splitted=id.split("/")
3312: id=splitted[len(splitted)-1]
3313: if hasattr(self,"_v_checkResource") and self._v_checkResource.has_key(id): #existiert ein cache und id ist bereits drin?
3314: return self._v_checkResource[id]
3315:
3316: else:
3317: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],obj_ids=[id],search_sub=1)
3318:
3319: if not hasattr(self,"_v_checkResource"): self._v_checkResource={}#lege cache an falls nicht existent
3320: if resources:
3321: self._v_checkResource[id]=resources[0:] # slicing to be sure that data is stabil
3322: else:
3323: self._v_checkResource[id]=None
3324:
3325: return self._v_checkResource[id]
3326:
3327: def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):
3328: """sendform"""
3329: toaddrs=["dwinter@mpiwg-berlin.mpg.de"]
3330:
3331: msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n"
3332: % (fromaddr, ", ".join(toaddrs),"testsub"))
3333: server = smtplib.SMTP(server)
3334: #server.set_debuglevel(1)
3335: msg=msg+content
3336: server.sendmail(fromaddr, toaddrs, msg)
3337: server.quit()
3338:
3339: def generateFromRDFForm(self):
3340: """change form"""
3341: pt=zptFile(self, 'zpt/generateFromRDFForm')
3342: pt.content_type="text/html"
3343: return pt()
3344:
3345: def generateFromRDF(self,file,startNode="/Cuneiform Corpus"):
3346:
3347: """generate from RDF"""
3348:
3349: global seqs
3350: seqs={}
3351: global descrs
3352: descrs={}
3353: global key
3354: key=""
3355: global value
3356: value=""
3357:
3358: def getEdges(seqs,urn):
3359: """edges"""
3360: ret=[]
3361: return seqs[urn]
3362:
3363: def createSubs(self,seqs,descrs,urn,level=0):
3364: """create subs"""
3365: for edge in getEdges(seqs,urn):
3366: cn=createNode(self,descrs,edge)
3367: if cn[0]=="CDLI_group":
3368: createSubs(cn[1],seqs,descrs,cn[2],level+1)
3369: return
3370:
3371: def start_element(name,attrs):
3372:
3373: global seqs
3374: global descrs
3375: global key
3376: global value
3377: seq=""
3378: if name=="RDF:Seq":
3379: key=attrs.get('RDF:about')
3380: try: # teste ob liste
3381: x=seqs[key][0]
3382: except:
3383:
3384: seqs[key]=[]
3385:
3386:
3387: elif name=="RDF:Description":
3388: key=attrs.get('RDF:about')
3389:
3390:
3391: elif name=="RDF:li":
3392: name=attrs.get('RDF:resource')
3393: seqs[key].append(name)
3394:
3395: elif name=="ECHONAVIGATION:type":
3396: value="type"
3397:
3398: elif name=="ECHONAVIGATION:name":
3399: value="name"
3400: elif name=="ECHONAVIGATION:linkClickable":
3401: value="linkClickable"
3402:
3403: def end_element(name):
3404: """nothing"""
3405: key=""
3406: value=""
3407:
3408: def char_data(data):
3409: """nothing"""
3410:
3411: data=re.sub("\n","",data)
3412: try:
3413: if descrs[key].has_key(value):
3414: descrs[key][value]+=data
3415: else:
3416: descrs[key][value]=data
3417: except:
3418:
3419: descrs[key]={}
3420: descrs[key][value]=data
3421:
3422: p = xml.parsers.expat.ParserCreate()
3423:
3424: p.StartElementHandler = start_element
3425: p.EndElementHandler = end_element
3426: p.CharacterDataHandler = char_data
3427:
3428:
3429: p.ParseFile(file)
3430: self.REQUEST.RESPONSE.write("<html><body><h1>Start</h1>")
3431: createSubs(self,seqs,descrs,startNode)
3432: self.REQUEST.RESPONSE.write("<h1>done</h1></body></html>")
3433: #print "done"
3434:
3435:
3436: return "done"
3437:
3438:
3439:
3440:
3441: def changeWeightsInCollection(self):
3442: """change all lables of a collection"""
3443: ret=""
3444: argv=self.REQUEST.form
3445:
3446: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
3447: for resource in resources:
3448:
3449: try:
3450: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
3451: resource[1].weight=argv[resource[1].getId()][0:]
3452: except:
3453: pass
3454: return ret
3455:
3456: def changeWeights(self):
3457: """change form"""
3458: pt=zptFile(self, 'zpt/changeWeightForm')
3459: pt.content_type="text/html"
3460: return pt()
3461:
3462:
3463: def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
3464: """warning"""
3465: pt=zptFile(self, 'zpt/reloadMetaDataFromStorageWarning.zpt')
3466: pt.content_type="text/html"
3467: return pt()
3468:
3469: def reloadMetaDataFromStorage(self,RESPONSE=None):
3470: """reload MD from Storage"""
3471:
3472: return reloadMetaDataFromStorage(self,RESPONSE)
3473:
3474: def getRDF(self,urn=None):
3475: """rdf of the collection"""
3476:
3477: contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
3478:
3479: ret=getRDFDescription(self,self.absolute_url(),urn=urn)
3480:
3481: li="""<RDF:li RDF:resource="%s" />\n"""
3482:
3483:
3484: for content in contents:
3485: ret+=content[1].getRDF()+"\n"
3486:
3487: ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
3488: for content in contents:
3489: nurn=content[1].absolute_url()
3490: ret+=li%nurn
3491: return ret+"</RDF:Seq>"
3492:
3493:
3494: def showContent(self,path):
3495: """return content/html"""
3496:
3497: return ECHO_helpers.urlopen(path+"/content_html").read()
3498:
3499: def getImageViewers(self):
3500: """images"""
3501: viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])
3502: return viewers
3503:
3504:
3505: def getBibTag(self,tag,content):
3506: """get field tag for index-meta-generation"""
3507: if not content or content=="":
3508: return ""
3509: ret="<%s>"%tag
3510: #ret+=urllib.quote(content)
3511: ret+=content
3512:
3513: ret+="</%s>"%tag
3514: return ret
3515:
3516: def getValueFromClass(self,field,found):
3517: """ret attribute if existing"""
3518: try:
3519:
3520: return getattr(found,field).decode('ascii','ignore')
3521: except:
3522: return ""
3523:
3524: security.declarePublic('getImageTag')
3525: def getImageTag(self):
3526: """needed by main_template"""
3527: return ""
3528:
3529: secondaryLink="" #needed by main_template
3530: secondaryLinkTitle="" #needed by main_template
3531:
3532: def getBgcolour(self):
3533: """hack"""
3534: return "#dddddd"
3535:
3536: security.declareProtected('View','contentTypeSelector_HTML')
3537: def contentTypeSelector_HTML(self,selected=None):
3538: """give type selector"""
3539: if not selected:
3540: retStr="<option selected>\n"
3541: else:
3542: retStr="<option>\n"
3543:
3544: try: # erste version contentTypes exists
3545: for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
3546: if selected and (contentType[0]==selected):
3547: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
3548: else:
3549: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
3550: except:
3551: try:
3552: for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
3553: if selected and (contentType[0]==selected):
3554: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
3555: else:
3556: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
3557: except:
3558: """nothing"""
3559:
3560: return retStr
3561:
3562: def renderingTypeSelector_HTML(self,selected=None):
3563: """give type selector"""
3564: if not selected:
3565: retStr="<option selected>\n"
3566: else:
3567: retStr="<option>\n"
3568:
3569: try: # erste version renderingTypes exists
3570: for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
3571: if selected and (renderingType[0]==selected):
3572: retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
3573: else:
3574: retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
3575: except:
3576: """nothing"""
3577: return retStr
3578:
3579:
3580: def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):
3581: """give type selector"""
3582:
3583: if not first:
3584: if not selected:
3585: retStr="<option selected>\n"
3586: else:
3587: retStr="<option>\n"
3588: else:
3589: if not selected:
3590: retStr="""<option selected value="%s">%s\n"""%first
3591: else:
3592: retStr="""<option value="%s">%s\n"""%first
3593:
3594:
3595: try: # erste version copyrightTypes exists
3596: for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
3597: if selected and (copyrightType[0]==selected):
3598: retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3599: else:
3600: retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3601:
3602: for copyrightTypeSelf in self.ZopeFind(object,obj_metatypes=["ECHO_copyrightType"],search_sub=1):
3603: if selected and (copyrightTypeSelf[0]==selected):
3604: retStr+="""<option selected value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
3605: else:
3606: retStr+="""<option value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
3607:
3608: except:
3609: """nothing"""
3610:
3611: return retStr
3612:
3613: def partnerSelector_HTML(self,selected=None):
3614: """give type selector"""
3615: if not selected:
3616: retStr="<option selected>\n"
3617: else:
3618: retStr="<option>\n"
3619:
3620: try: # erste version copyrightTypes exists
3621: for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):
3622: if selected and (copyrightType[0]==selected):
3623: retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3624: else:
3625: retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3626: except:
3627: """nothing"""
3628: return retStr
3629:
3630: mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version ueber echoroot??
3631:
3632: def mediaTypeSelector_HTML(self,selected=None):
3633: """give type selector"""
3634: if not selected:
3635: retStr="<option selected>\n"
3636: else:
3637: retStr="<option>\n"
3638:
3639: try: # erste version mediatypesTypes exists
3640: for mediaType in self.mediaTypes:
3641: if selected and (mediaType in selected):
3642: retStr+="""<option selected value="%s">%s\n"""%(mediaType,mediaType)
3643: else:
3644: retStr+="""<option value="%s">%s\n"""%(mediaType,mediaType)
3645: except:
3646: """nothing"""
3647: return retStr
3648:
3649:
3650: def patchContentType(self,obj=None):
3651: """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
3652:
3653:
3654: if not obj:
3655: obj = self
3656:
3657: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
3658:
3659: for entry in entries:
3660: setattr(entry[1],'contentType',entry[1].content_type)
3661: #entry[1].contentType == entry[1].content_type
3662:
3663: if entry[1].meta_type == 'ECHO_collection':
3664: entry[1].patchContentType(entry[1])
3665:
3666:
3667: return "changed all contenttypes in: "+self.title
3668:
3669:
3670: def repairAllCoords(self):
3671: """updates map coordinates on the same and sublevels"""
3672: return repairCoords(self)
3673:
3674:
3675: def patchViewClassification(self,obj=None):
3676: """setze viewClassification heuristisch"""
3677:
3678: def checkIfArrow(obj):
3679: if hasattr(obj,'coords'):
3680: for coordtemp in obj.coords:
3681:
3682: if (len(coordtemp)>4) and not (coordtemp[4]==''):
3683: return 4
3684: return None
3685: return None
3686:
3687: if not obj:
3688: obj = self
3689:
3690: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
3691:
3692: for entry in entries:
3693:
3694: if checkIfArrow(entry[1]):
3695: setattr(entry[1],'viewClassification','view point')
3696: else:
3697: setattr(entry[1],'viewClassification','area')
3698:
3699: #entry[1].contentType == entry[1].content_type
3700:
3701: if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
3702: entry[1].patchViewClassification(entry[1])
3703:
3704:
3705: return "changed all contenttypes in: "+self.title
3706:
3707: def deleteCache(self,obj=None,RESPONSE=None):
3708: """setze alle collections auf cache = CacheManager"""
3709: if not obj:
3710: obj = self
3711: entries=obj.ZopeFind(obj,search_sub=1)
3712: for entry in entries:
3713: if hasattr(entry[1],'_v_hash'):
3714: entry[1]._v_hash=None
3715:
3716: return "changed all CM in: "+self.title
3717:
3718:
3719: security.declarePublic('ECHO_newViewerLink')
3720: def ECHO_newViewerLink(self,obj=None):
3721: """change links (:86 faellt weg)"""
3722:
3723: if not obj:
3724: obj = self
3725:
3726: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
3727:
3728: for entry in entries:
3729:
3730: if entry[1].meta_type == 'ECHO_resource':
3731:
3732: entry[1].link=re.sub('\:86','',entry[1].link)
3733:
3734: else:
3735:
3736: entry[1].ECHO_newViewerLink(entry[1])
3737:
3738: return "Rerenderd all links to resources in: "+self.title
3739:
3740: def __init__(self,id,title):
3741: """init"""
3742: self.id = id
3743: self.title=title
3744:
3745: def deleteSpace(self,str):
3746: """delete space at the end of a line"""
3747: if str[len(str)-1]==" ":
3748: return str[0:len(str)-1]
3749: else:
3750: return str
3751:
3752:
3753:
3754: # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
3755:
3756: def formatAscii(self,str,url=None):
3757: """ersetze ascii umbrueche durch <br>"""
3758:
3759: if not str:
3760: return ""
3761:
3762: if url:
3763:
3764: retStr=""
3765: words=str.split("\n")
3766:
3767: for word in words:
3768: strUrl=url%word
3769:
3770: retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
3771: str=retStr
3772: if str:
3773: str = re.sub(r"[\n]","<br/>",str)
3774: return unicodify(str)
3775: else:
3776: return u""
3777:
3778: link2html=vlp_xmlhelpers.link2html
3779: related2html=vlp_xmlhelpers.related2html
3780:
3781: xml2html=vlp_xmlhelpers.xml2html
3782:
3783: checkRef=vlp_xmlhelpers.checkRef
3784:
3785: # def checkRef(self,ref):
3786: # if ref[0:3]=='lit':
3787: # if len(self.library_data({ 'id':ref}))>0:
3788: # return 1
3789: # try:
3790: # if ref[0:7]=="tec_cat":
3791: # return 1
3792: # except:
3793: # """nothing"""
3794: #
3795: # dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''}
3796: # res=None
3797: # for db in dbs.keys():
3798: # res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
3799: # return res
3800: #
3801: # #Ende Methode fuer vlp
3802:
3803: def PgQuoteString(self,string):
3804: """Quote string"""
3805:
3806: return libpq.PgQuoteString(string)
3807:
3808: security.declareProtected('View','getPartners')
3809: def getPartners(self):
3810: """Get list of Partners. Presently only from a subfolder partners"""
3811: if hasattr(self,'partners'):
3812: ret = [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
3813: def sort_title(one, another) : return cmp(one.title, another.title)
3814: ret.sort(sort_title)
3815: return ret
3816: else:
3817: return []
3818:
3819: def getInstitutions(self):
3820: """Get list of Partners. Presently only from a subfolder partners"""
3821:
3822: return [ item[1] for item in self.institutions.ZopeFind(self.institutions,obj_metatypes=['ECHO_institution'])]
3823:
3824:
3825: def getPartnersXML(self):
3826: """partner liste als xml"""
3827: partners=self.getPartners()
3828: ret="""<?xml version="1.0" encoding="utf-8" ?>
3829: <partners>"""
3830:
3831: for partner in partners:
3832: ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
3833:
3834: return ret+"\n</partners>"
3835:
3836: def getCollectionTree(self):
3837: """get the collection tree (list of triples (parent,child, depth)"""
3838:
3839: def getCollection(object,depth=0):
3840: depth+=1
3841: collections=[]
3842: for entry in object.__dict__.keys():
3843: element=getattr(object,entry)
3844: try:
3845: if element.meta_type=="ECHO_collection":
3846: collections.append((object,element,depth))
3847: collections+=getCollection(element,depth)
3848: except:
3849: """nothing"""
3850: return collections
3851:
3852:
3853: return getCollection(self)
3854:
3855: def getCollectionTreeIds(self):
3856: """Show the IDs of the Tree"""
3857: ret=[]
3858: for collection in self.getCollectionTree():
3859: ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
3860: return ret
3861:
3862: def getResourcesHTML(self,viewerType=None,filter=None):
3863: """gebe all ressourcen aus"""
3864:
3865: def sortHTML(x,y):
3866: return cmp(x[1].title,y[1].title)
3867:
3868: ret="""<html><body><h2>Resources in ECHO</h3>"""
3869:
3870: resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
3871: ret+="""<h3>Found %i resources</h3>"""%len(resources)
3872: resources.sort(sortHTML)
3873: for resource in resources:
3874: echo_url=resource[1].absolute_url()
3875:
3876: if hasattr(resource[1],'title'):
3877: title=resource[1].title
3878: else:
3879: title="None"
3880: if filter:
3881: if re.search(filter,title):
3882: ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
3883: else:
3884: ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
3885:
3886: ret +="""\n</body></html>"""
3887:
3888: #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
3889: #self.REQUEST.RESPONSE.write(ret)
3890: return ret
3891:
3892: def getResourcesXML(self,viewerType=None,filter=None):
3893: """gebe all ressourcen aus"""
3894: ret="""<?xml version="1.0" ?>
3895: <index>"""
3896: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
3897:
3898: echo_url=resource[1].absolute_url()
3899: if hasattr(resource[1],'link'):
3900: viewer_url=resource[1].link
3901: else:
3902: viewer_url="NO URL"
3903: if filter:
3904: if re.search(filter,viewer_url):
3905: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3906: else:
3907: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3908: ret +="""\n</index>"""
3909:
3910: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
3911: self.REQUEST.RESPONSE.write(ret)
3912:
3913: def getFullTextsXML(self,viewerType=None,filter=None):
3914: """gebe all ressourcen aus"""
3915: ret="""<?xml version="1.0" ?>
3916: <index>"""
3917: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
3918:
3919: echo_url=resource[1].absolute_url()
3920: if resource[1].getFullTextXML(noredirect="yes"):
3921: if hasattr(resource[1],'link'):
3922: viewer_url=echo_url+"/getFullTextXML"
3923: else:
3924: viewer_url="NO URL"
3925: if filter:
3926: if re.search(filter,viewer_url):
3927: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3928: else:
3929: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3930: ret +="""\n</index>"""
3931:
3932:
3933: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
3934: self.REQUEST.RESPONSE.write(ret)
3935:
3936:
3937: def getMetaDatasXML(self,viewerType=None,filter=None):
3938: """gebe all ressourcen aus"""
3939: # check if the request's host part was OK
3940: http_host = self.REQUEST['HTTP_HOST']
3941: host_port = self.REQUEST['SERVER_PORT']
3942: fix_host = None
3943: if http_host and http_host.rfind(host_port) == -1:
3944: print "HTTP_HOST needs fixing!"
3945: fix_host = http_host + ":" + host_port
3946:
3947: ret="""<?xml version="1.0" ?>
3948: <index>"""
3949: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
3950:
3951: echo_url=resource[1].absolute_url()
3952: if fix_host:
3953: #print "replacing ", http_host, " by ", fix_host
3954: echo_url = string.replace(echo_url, http_host, fix_host, 1)
3955:
3956: if hasattr(resource[1],'link'):
3957: meta_url=echo_url+"/getMetaDataXML"
3958: else:
3959: meta_url="NO_URL"
3960:
3961: if filter and not re.search(filter,viewer_url):
3962: continue
3963:
3964: #modificationDate=time.strptime(str(resource[1].bobobase_modification_time()),"%Y/%m/%d %H:%M:%S %Z")
3965:
3966: modificationDate=resource[1].bobobase_modification_time().strftime("%Y/%m/%d %H:%M:%S")
3967:
3968: ret+="""\n<resource resourceLink="%s" metaLink="%s" modificationDate="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'),modificationDate)
3969:
3970:
3971: ret +="""\n</index>"""
3972:
3973: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
3974: self.REQUEST.RESPONSE.write(ret)
3975:
3976:
3977: def findPartners(self):
3978: """find all partners in partners"""
3979: par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')
3980: return par
3981:
3982: def getPartnerFromID(self):
3983: """find partner form ID return object"""
3984: pa=self.REQUEST['partner']
3985: par=self.ZopeFind(self.partners, obj_ids=[pa])
3986: return par
3987:
3988: def getPartnerFromIDParameter(self, id):
3989: """ find partners from ID"""
3990: par=self.ZopeFind(self.partners, obj_ids=[id])
3991: return par
3992:
3993: def getInstitutionFromID(self,id):
3994: """ find institution from id """
3995: inst=self.ZopeFind(self.institutions, obj_ids=[id])
3996: return inst
3997:
3998: def updateResourceCatalog(self,REQUEST,RESPONSE):
3999: """update ressource catalog"""
4000: catalog=getattr(self,'resourceCatalog',None)
4001: if not catalog:
4002: return """<html><body><h3>No resourceCatalog available</h3></body></html>"""
4003:
4004: else:
4005: class element:
4006: def __init__(self,group,name):
4007: self.group=group
4008: self.name=name
4009: catalog.manage_delObjects('author splitter')
4010: #elements=[element('Stop Words',""" Don't remove stop words' """),element('Word Splitter','ECHO author splitter')]
4011: elements=[element('Word Splitter','ECHO author splitter')]
4012: manage_addLexicon(catalog,id="author splitter",elements=elements)
4013:
4014: return catalog.manage_catalogReindex(REQUEST,RESPONSE,'manage_main')
4015:
4016:
4017: def checkMetaDataLinks(self,correct=None):
4018: """check all metadatalinks and if correct is set change the servername to content.mpiwg-berlin.mpg.de"""
4019:
4020: self.REQUEST.RESPONSE.write("<html><body>")
4021: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
4022: metalink=resource[1].metalink
4023:
4024: try:
4025: url=urllib.urlopen(metalink)
4026: except:
4027:
4028: self.REQUEST.RESPONSE.write("<p>ERROR (opening %s):"%resource[1].absolute_url() +" -- %s %s <br>"%sys.exc_info()[0:2])
4029: self.REQUEST.RESPONSE.write("-----------%s"%metalink)
4030:
4031: if correct:
4032: urlparsed=[x for x in urlparse.urlparse(metalink)]
4033: urlparsed[1]="content.mpiwg-berlin.mpg.de"
4034: neu=urlparse.urlunparse(urlparsed)
4035: resource[1].metalink=neu[0:]
4036: self.REQUEST.RESPONSE.write("----------changed to:%s)"%neu)
4037:
4038: def manage_addECHO_root(self,id,title,RESPONSE=None):
4039: """Add an ECHO_root"""
4040: self._setObject(id,ECHO_root(id,title))
4041:
4042: if RESPONSE is not None:
4043: RESPONSE.redirect('manage_main')
4044:
4045: def manage_addECHO_rootForm(self):
4046: """Nothing yet"""
4047: pt=zptFile(self, 'zpt/AddECHO_root.zpt')
4048: return pt()
4049:
4050: class ECHO_copyrightType(Folder,ECHO_basis):
4051: """copyright typ"""
4052:
4053: meta_type="ECHO_copyrightType"
4054:
4055: def __init__(self,id,title,label,url):
4056: """init"""
4057: self.id=id
4058: self.title=title
4059: self.label=label
4060: self.url=url
4061:
4062: manage_options = Folder.manage_options+(
4063: {'label':'Main Config','action':'ECHO_copyrightType_config_mainForm'},
4064: )
4065:
4066: def ECHO_copyrightType_config_mainForm(self):
4067: """change form"""
4068: pt=zptFile(self, 'zpt/ChangeECHO_copyrightType')
4069: pt.content_type="text/html"
4070: return pt()
4071:
4072: def ECHO_copyrightType_config_main(self,title,label,url,RESPONSE=None):
4073: """change"""
4074: self.title=title
4075: self.label=label
4076: self.url=url
4077:
4078: if RESPONSE is not None:
4079: RESPONSE.redirect('manage_main')
4080:
4081: def manage_addECHO_copyrightTypeForm(self):
4082: """Form for adding a ressource"""
4083: pt=zptFile(self, 'zpt/AddECHO_copyrightTypeForm.zpt')
4084: return pt()
4085:
4086:
4087: def manage_addECHO_copyrightType(self,id,title,label,url,RESPONSE=None):
4088: """addaresource"""
4089:
4090: newObj=ECHO_copyrightType(id,title,label,url)
4091:
4092: self._setObject(id,newObj)
4093:
4094: if RESPONSE is not None:
4095: RESPONSE.redirect('manage_main')
4096:
4097:
4098:
4099:
4100: class ECHO_linkList(ZopePageTemplate,ECHO_basis):
4101: """LinkList Objekt"""
4102: meta_type="ECHO_linkList"
4103:
4104: _default_content_fn = os.path.join(package_home(globals()), 'html/ECHO_pageTemplateDefault.html')
4105:
4106: manage_options = ZopePageTemplate.manage_options+(
4107: {'label':'Main Config','action':'changeECHO_linkListWeightForm'},
4108: )
4109:
4110: def content_html(self):
4111: """content_html"""
4112: return ECHO_basis.content_html(self,'pageTemplate')
4113:
4114: def changeECHO_linkListWeightForm(self):
4115: """change"""
4116: pt=zptFile(self, 'zpt/ChangeECHO_linkListTemplate.zpt')
4117: return pt()
4118:
4119: def changeECHO_linkListWeight(self,contentType,label,RESPONSE=None):
4120: """change"""
4121: self.contentType=contentType
4122: self.label=label
4123:
4124: if RESPONSE is not None:
4125: RESPONSE.redirect('manage_main')
4126:
4127: def getLabel(self):
4128: if hasattr(self,'label'):
4129: return self.label.encode('utf-8')
4130: else:
4131: return 0
4132:
4133: def getcontentType(self):
4134: """get contentType"""
4135: if hasattr(self,'contentType'):
4136: return normalizeCt(self.contentType)
4137: else:
4138: return 0
4139:
4140: def __init__(self, id, label, title=None, text=None, contentType=None):
4141: self.id = str(id)
4142: self.title=title
4143: self.label=label
4144: self.ZBindings_edit(self._default_bindings)
4145: if text is None:
4146: text = ''
4147: if content_type is None:
4148: content_type = self.content_type
4149: self.pt_edit(text, contentType)
4150:
4151:
4152:
4153:
4154: def manage_addECHO_linkListForm(self):
4155: """Form for adding"""
4156: pt=zptFile(self, 'zpt/AddECHO_linkListTemplate.zpt')
4157: return pt()
4158:
4159:
4160: def manage_addECHO_linkList(self, id, label,contentType=0,title=None, text=None,
4161: REQUEST=None, submit=None):
4162: """Add a LinkList with optional file content."""
4163:
4164: id = str(id)
4165: if REQUEST is None:
4166: self._setObject(id, ECHO_linkList(id, label, text))
4167: ob = getattr(self, id)
4168: setattr(ob,'contentType',contentType)
4169: if title:
4170: ob.pt_setTitle(title)
4171: return ob
4172: else:
4173: file = REQUEST.form.get('file')
4174: headers = getattr(file, 'headers', None)
4175: if (headers is None) or (not file.filename):
4176: zpt = ECHO_linkList(id, file)
4177: else:
4178: zpt = ECHO_linkList(id, label,'', file, headers.get('contentType'))
4179:
4180: self._setObject(id, zpt)
4181: ob = getattr(self, id)
4182: if title:
4183: ob.pt_setTitle(title)
4184:
4185: try:
4186: u = self.DestinationURL()
4187: except AttributeError:
4188: u = REQUEST['URL1']
4189:
4190: if submit == " Add and Edit ":
4191: u = "%s/%s" % (u, urllib.quote(id))
4192: REQUEST.RESPONSE.redirect(u+'/manage_main')
4193: return ''
4194:
4195:
4196: class ECHO_support(Folder,ECHO_basis):
4197: """gefoerdert durch"""
4198: meta_type="ECHO_support"
4199:
4200:
4201:
4202: def __init__(self,id,institutions=None):
4203: """init"""
4204: self.id=id
4205: self.title=''
4206: self.institutions=toList(institutions)
4207:
4208: def getSupporter(self):
4209: """return institutions"""
4210: if self.institutions:
4211: return self.institutions
4212: else:
4213: return []
4214:
4215: manage_options = Folder.manage_options+(
4216: {'label':'Main Config','action':'ECHO_support_configForm'},
4217: )
4218:
4219: def ECHO_support_configForm(self):
4220: """change form"""
4221: pt=zptFile(self, 'zpt/ChangeECHO_support')
4222: pt.content_type="text/html"
4223: return pt()
4224:
4225: def ECHO_support_config(self,institutions=None,RESPONSE=None):
4226: """change"""
4227: self.institutions=toList(institutions)
4228:
4229: if RESPONSE is not None:
4230: RESPONSE.redirect('manage_main')
4231:
4232:
4233: def manage_addECHO_supportForm(self):
4234: """Form for adding"""
4235: pt=zptFile(self, 'zpt/AddECHO_support.zpt')
4236: return pt()
4237:
4238: def manage_addECHO_support(self, id,institutions=None,RESPONSE=None):
4239: """add the copyright"""
4240:
4241: meta_type="ECHO_support"
4242:
4243:
4244: self._setObject(id, ECHO_support(id,institutions))
4245:
4246: if RESPONSE is not None:
4247: RESPONSE.redirect('manage_main')
4248:
4249: # ECHO - owner of original
4250: class ECHO_ownerOriginal(Folder,ECHO_basis):
4251: """besitzer des originals"""
4252: meta_type="ECHO_ownerOriginal"
4253: security=ClassSecurityInfo()
4254:
4255:
4256: def __init__(self,id,institutions=None):
4257: """init"""
4258: self.id=id
4259: self.title=''
4260: self.institutions=toList(institutions)
4261:
4262: security.declarePublic('getOwner')
4263: def getOwner(self):
4264: """return institutions"""
4265: if self.institutions:
4266: return self.institutions
4267: else:
4268: return []
4269:
4270: manage_options = Folder.manage_options+(
4271: {'label':'Main Config','action':'ECHO_ownerOriginal_configForm'},
4272: )
4273:
4274: def ECHO_ownerOriginal_configForm(self):
4275: """change form"""
4276: pt=zptFile(self, 'zpt/ChangeECHO_ownerOriginal')
4277: pt.content_type="text/html"
4278: return pt()
4279:
4280: def ECHO_ownerOriginal_config(self,institutions=None,RESPONSE=None):
4281: """change"""
4282: self.institutions=toList(institutions)
4283:
4284: if RESPONSE is not None:
4285: RESPONSE.redirect('manage_main')
4286:
4287:
4288: def manage_addECHO_ownerOriginalForm(self):
4289: """Form for adding"""
4290: pt=zptFile(self, 'zpt/AddECHO_ownerOriginal.zpt')
4291: return pt()
4292:
4293: def manage_addECHO_ownerOriginal(self, id,institutions=None,RESPONSE=None):
4294: """add the copyright"""
4295:
4296: meta_type="ECHO_ownerOriginal"
4297:
4298:
4299: self._setObject(id, ECHO_ownerOriginal(id,institutions))
4300:
4301: if RESPONSE is not None:
4302: RESPONSE.redirect('manage_main')
4303:
4304: # --------------------------------------------------------------------------------
4305:
4306: # ECHO - digitized copy by
4307: class ECHO_digiCopyBy(Folder,ECHO_basis):
4308: """besitzer des originals"""
4309: meta_type="ECHO_digiCopyBy"
4310: security=ClassSecurityInfo()
4311:
4312:
4313: def __init__(self,id,institutions=None):
4314: """init"""
4315: self.id=id
4316: self.title=''
4317: self.institutions=toList(institutions)
4318:
4319: security.declarePublic('getDigiCopyBy')
4320: def getDigiCopyBy(self):
4321: """return institutions"""
4322: if self.institutions:
4323: return self.institutions
4324: else:
4325: return []
4326:
4327: manage_options = Folder.manage_options+(
4328: {'label':'Main Config','action':'ECHO_digiCopyBy_configForm'},
4329: )
4330:
4331: def ECHO_digiCopyBy_configForm(self):
4332: """change form"""
4333: pt=zptFile(self, 'zpt/ChangeECHO_digiCopyBy')
4334: pt.content_type="text/html"
4335: return pt()
4336:
4337: def ECHO_digiCopyBy_config(self,institutions=None,RESPONSE=None):
4338: """change"""
4339: self.institutions=toList(institutions)
4340:
4341: if RESPONSE is not None:
4342: RESPONSE.redirect('manage_main')
4343:
4344:
4345: def manage_addECHO_digiCopyByForm(self):
4346: """Form for adding"""
4347: pt=zptFile(self, 'zpt/AddECHO_digiCopyBy.zpt')
4348: return pt()
4349:
4350: def manage_addECHO_digiCopyBy(self, id,institutions=None,RESPONSE=None):
4351: """add the copyright"""
4352:
4353: meta_type="ECHO_digiCopyBy"
4354:
4355:
4356: self._setObject(id, ECHO_digiCopyBy(id,institutions))
4357:
4358: if RESPONSE is not None:
4359: RESPONSE.redirect('manage_main')
4360:
4361: # --------------------------------------------------------------------------------
4362:
4363: class ECHO_institution(Image,Persistent,ECHO_basis):
4364: """ECHO Institution"""
4365:
4366: meta_type="ECHO_institution"
4367:
4368: def __init__(self, id, title,url, file, person, email, country, content_type='', precondition=''):
4369: self.__name__=id
4370: self.title=title
4371: self.url=url
4372: self.person=person
4373: self.email=email
4374: self.country=country
4375: self.precondition=precondition
4376: data, size = self._read_data(file)
4377: content_type=self._get_content_type(file, data, id, content_type)
4378: self.update_data(data, content_type, size)
4379:
4380: manage_options = Image.manage_options+(
4381: {'label':'Institution Information','action':'ECHO_institution_config'},
4382: )
4383:
4384:
4385: def changeECHO_institution(self,url,person, email, country,RESPONSE=None):
4386: """Change main information"""
4387: self.url=url
4388: self.person=person
4389: self.email=email
4390: self.country=country
4391: if RESPONSE is not None:
4392: RESPONSE.redirect('manage_main')
4393:
4394:
4395:
4396: def ECHO_institution_config(self):
4397: """Main configuration"""
4398: if not hasattr(self,'url'):
4399: self.url=""
4400: pt=zptFile(self, 'zpt/ChangeECHO_institution.zpt')
4401: return pt()
4402:
4403:
4404: manage_addECHO_institutionForm=DTMLFile('dtml/ECHO_institutionAdd',globals(),
4405: Kind='ECHO_institution',kind='ECHO_institution')
4406:
4407:
4408:
4409: def manage_addECHO_institution(self, id, url, person, email, country, file=None, title='', precondition='', content_type='',
4410: REQUEST=None):
4411: """
4412: Add a new ECHO_institution object.
4413:
4414: Creates a new ECHO_institution object 'id' with the contents of 'file'.
4415: Based on Image.manage_addImage
4416: """
4417:
4418: id=str(id)
4419: title=str(title)
4420: content_type=str(content_type)
4421: precondition=str(precondition)
4422:
4423: id, title = OFS.Image.cookId(id, title, file)
4424:
4425: self=self.this()
4426:
4427: # First, we create the image without data:
4428: self._setObject(id, ECHO_institution(id,title,url,'', person, email, country, content_type, precondition))
4429:
4430: # Now we "upload" the data. By doing this in two steps, we
4431: # can use a database trick to make the upload more efficient.
4432: if file:
4433: self._getOb(id).manage_upload(file)
4434: if content_type:
4435: self._getOb(id).content_type=content_type
4436:
4437: if REQUEST is not None:
4438: try: url=self.DestinationURL()
4439: except: url=REQUEST['URL1']
4440: REQUEST.RESPONSE.redirect('%s/manage_main' % url)
4441: return id
4442:
4443: def repairCoords(self):
4444: """updates map coordinates to new MapArea objects"""
4445: msg = ""
4446: for cols in self.ZopeFind(self, obj_metatypes=['ECHO_collection','ECHO_resource'], search_sub=1):
4447: col = cols[1]
4448: if not hasattr(col, 'coords'):
4449: continue
4450: print "fixing: ", col.id
4451: msg += "fixing: "+col.id+"\n"
4452: coords = col.coords
4453: if len(coords) > 0:
4454: # delete old MapAreas
4455: for areas in self.ZopeFind(col, obj_metatypes=['MapArea']):
4456: #area = areas[1]
4457: id = areas[0]
4458: print " deleting: ", id
4459: msg += " deleting: "+id+"\n"
4460: col._delObject(id)
4461: # add new MapAreas
4462: areacnt = 0
4463: for coord in coords:
4464: if len(coord) < 4:
4465: continue
4466: type = col.viewClassification
4467: if type == 'view point':
4468: type = 'arrow'
4469: if type is None:
4470: if len(coord) > 4:
4471: type = 'arrow'
4472: else:
4473: type = 'area'
4474: newid = "a%02d"%areacnt
4475: areacnt += 1
4476: area = MapArea(newid, coord, type=type)
4477: print " adding: ", newid
4478: msg += " adding: "+newid+"\n"
4479: col.addMapArea(area)
4480: msg += "\nDone!"
4481: return msg
4482:
4483: from ECHO_Nav import ECHO_navigation
4484:
4485: class ECHO_main(ECHO_root,ECHO_navigation):
4486: """echo main object combines ECHO_root and ECHO_navigation"""
4487:
4488: meta_type="ECHO_main"
4489:
4490: def __init__(self,id,title):
4491: """init"""
4492: self.id=id
4493: self.title=title
4494: self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.
4495: self.displayedMetaTypes=displayTypes
4496:
4497:
4498: manage_options = Folder.manage_options+(
4499: {'label':'Main Config','action':'ECHO_navigationConfigForm'},
4500: {'label':'Cache','action':'ECHO_cacheManageForm'},
4501: {'label':'Main Config','action':'ECHO_copyright_configForm'},
4502: {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
4503: {'label':'Change Weights','action':'changeWeights'},
4504: {'label':'Generate from RDF','action':'generateFromRDFForm'},
4505: {'label':'update Resource Catalog','action':'updateResourceCatalog'},
4506: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
4507: )
4508:
4509:
4510: def manage_addECHO_mainForm(self):
4511: """Form for adding"""
4512: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)
4513: return pt()
4514:
4515: def manage_addECHO_main(self,id,title,RESPONSE=None):
4516: """Add an ECHO_main"""
4517: self._setObject(id,ECHO_main(id,title))
4518:
4519: obj=self._getOb(id)
4520: text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()
4521:
4522: manage_addPageTemplate(obj,'main_template',text=text)
4523:
4524:
4525: if RESPONSE is not None:
4526: RESPONSE.redirect('manage_main')
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ECHO_collection.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ECHO_content