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