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