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: import string
13: import re
14: import os
15: import OFS.Image
16: from types import *
17: from OFS.Image import Image
18: from Globals import DTMLFile
19: from OFS.Folder import Folder
20: from OFS.SimpleItem import SimpleItem
21: from AccessControl import ClassSecurityInfo
22: from Globals import InitializeClass
23: from Globals import DTMLFile
24: import Globals
25: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
26: from Products.PageTemplates.PageTemplate import PageTemplate
27: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
28: from Globals import Persistent, package_home
29: from Acquisition import Implicit
30: from ECHO_helpers import displayTypes
31:
32:
33: try:
34: from psycopg import libpq
35: except:
36: try:
37: from pyPgSQL import libpq
38: except:
39: print "ECHO_collection: Warning - No libpq imported!"
40:
41: import xml.dom.minidom
42:
43: import urllib
44: import xml.dom.minidom
45: from ECHO_graphicalOverview import javaHandler,javaScriptMain
46: import ECHO_helpers
47:
48: #List of different types for the graphical linking viewer
49: viewClassificationListMaster=['view point','area']
50:
51: def checkDiffs(self,metadict):
52: """check differences"""
53:
54: def NoneToEmpty(obj):
55: if obj:
56: return obj
57: else:
58: return ""
59:
60: diffs={}
61: tags=self.findTagsFromMapping(self.contentType)
62: for field in tags[1]:
63: try:
64: if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
65: diffs[self.getFieldTag(tags,field)]=1
66: else:
67: print "DIFF",field,self.getFieldValue(self.getFieldTag(tags,field)),metadict[self.getFieldTag(tags,field)]
68: diffs[self.getFieldTag(tags,field)]=0
69: except:
70: diffs[self.getFieldTag(tags,field)]=0
71: print "EX",field
72: return diffs
73:
74: def content_html(self,type):
75: """template fuer content"""
76: #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
77: #
78: #if templates:
79: # return templates[0][1]()
80:
81: try:
82: obj=getattr(self,type+"_template")
83: return obj()
84: except:
85: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)
86: pt.content_type="text/html"
87: return pt()
88:
89: def toList(field):
90: """Einzelfeld in Liste umwandeln"""
91: if type(field)==StringType:
92: return [field]
93: else:
94: return field
95:
96: def getText(nodelist):
97:
98: rc = ""
99: for node in nodelist:
100: if node.nodeType == node.TEXT_NODE:
101: rc = rc + node.data
102: return rc
103:
104:
105: def sendFile(self, filename, type):
106: """sends an object or a local file (in the product) as response"""
107: paths = filename.split('/')
108: object = self
109: # look for an object called filename
110: for path in paths:
111: if hasattr(object, path):
112: object = getattr(object, path)
113: else:
114: object = None
115: break
116: if object:
117: # if the object exists then send it
118: return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
119: else:
120: # send a local file with the given content-type
121: fn = os.path.join(package_home(globals()), filename)
122: self.REQUEST.RESPONSE.setHeader("Content-Type", type)
123: self.REQUEST.RESPONSE.write(file(fn).read())
124: return
125:
126:
127: def writeMetadata(url,metadict):
128: """Einlesen der Metadaten und und erstellen des geänderten XML file"""
129:
130: try:
131: geturl=""
132: for line in urllib.urlopen(url).readlines():
133: geturl=geturl+line
134:
135:
136: except:
137: return (None,"Cannot open: "+url)
138:
139: try:
140: dom=xml.dom.minidom.parseString(geturl)
141: except:
142: return (None,"Cannot parse: "+url+"<br>"+geturl)
143:
144: metanodes=dom.getElementsByTagName('bib')
145:
146: if not metanodes:
147: metanodes=dom.getElementsByTagName('archimedes')
148:
149: metanode=metanodes[0]
150:
151: for metaData in metadict.keys():
152: print metaData,metanode
153: try:
154: nodeOld=metanode.getElementsByTagName(metaData)
155: except:
156: nodeOld=None
157:
158: if nodeOld:
159: metanode.removeChild(nodeOld[0]).unlink()
160: else:
161: # try also old writing rule - instead of _:
162: try:
163: nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
164: except:
165: nodeOld=None
166:
167: if nodeOld:
168: metanode.removeChild(nodeOld[0]).unlink()
169:
170: metanodeneu=dom.createElement(metaData)
171: metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf8"))
172: metanodeneu.appendChild(metanodetext)
173: metanode.appendChild(metanodeneu)
174:
175:
176: return dom.topxml().encode('utf-8')
177:
178: def readMetadata(url):
179: """Methode zum Auslesen der Metadateninformation zu einer Resource
180: Vorerst noch Typ bib"""
181:
182: metadict={}
183: try:
184: geturl=""
185: for line in urllib.urlopen(url).readlines():
186: geturl=geturl+line
187:
188:
189: except:
190: return (None,"Cannot open: "+url)
191:
192: try:
193: dom=xml.dom.minidom.parseString(geturl)
194: except:
195: return (None,"Cannot parse: "+url+"<br>"+geturl)
196:
197: metanode=dom.getElementsByTagName('bib')
198: metadict['bib_type']='Book'
199: if len(metanode)==0:
200: metanode=dom.getElementsByTagName('archimedes')
201: metadict['bib_type']='Archimedes'
202: #print "HELLO"
203:
204: if not len(metanode)==0:
205: metacontent=metanode[0].childNodes
206:
207: try:
208: metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
209: except:
210: """nothing"""
211:
212: for node in metacontent:
213: try:
214: metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)
215: except:
216: """nothing"""
217:
218:
219: return metadict,""
220:
221:
222: def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):
223:
224: """Allegemeine Informationen zu einer ECHO Collection"""
225:
226: self.viewClassification=viewClassification
227:
228: self.label = label
229: self.title=title
230: self.description=description
231: self.contentType=contentType
232: self.responsible=responsible
233: self.credits=toList(credits)
234: self.weight=weight
235:
236: coords=[]
237: #coordinates of for rectangles
238:
239: #print "cs", coordstrs
240: if coordstrs:
241: for coordstr in coordstrs:
242: #print "cs", coordstr
243: try:
244: temco=coordstr.split(",")
245: except:
246: temco=[]
247: #temco.append(angle)
248: coords.append(temco)
249:
250:
251: self.coords=coords[0:]
252:
253:
254: class scientificClassification(SimpleItem,Persistent,Implicit):
255: """outdated will be deleeted in the next versions: subclass"""
256: security=ClassSecurityInfo()
257:
258: def __init__(self,context,science,practice):
259: self.context=context
260: self.science=science
261: self.practice=practice
262: self.id="scientific_Classification"
263:
264: security.declarePublic('get_context')
265: def get_context(self):
266: return self.context
267:
268: security.declarePublic('get_science')
269: def get_science(self):
270: return self.science
271:
272: security.declarePublic('get_practice')
273: def get_practice(self):
274: return self.practice
275:
276:
277: class scientificInformation(Folder,Persistent,Implicit):
278: """outdated will be deleted in the next versions: subclass scientificInformation"""
279: security=ClassSecurityInfo()
280:
281:
282:
283: def __init__(self,source_type,period):
284:
285: self.id="scientific_Information"
286: self.source_type=source_type
287: self.period=period
288:
289:
290:
291: security.declarePublic('get_source_type')
292: def get_source_type(self):
293: return self.source_type
294:
295: security.declarePublic('get_period')
296: def get_period(self):
297: return self.period
298:
299: class ECHO_layoutTemplate(ZopePageTemplate):
300: """Create a layout Template for different purposes"""
301:
302: meta_type="ECHO_layoutTemplate"
303:
304: def __init__(self, id, text=None, content_type=None,EchoType=None):
305: self.id = str(id)
306:
307:
308:
309: self.ZBindings_edit(self._default_bindings)
310: if text is None:
311: self._default_content_fn = os.path.join(package_home(globals()),
312: 'zpt/ECHO_%s_template_standard.zpt'%EchoType)
313: text = open(self._default_content_fn).read()
314: self.pt_edit(text, content_type)
315:
316:
317: """change form"""
318:
319:
320: def manage_addECHO_layoutTemplateForm(self):
321: """Form for adding"""
322: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)
323: return pt()
324:
325: from urllib import quote
326:
327:
328: def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
329: "Add a Page Template with optional file content."
330: if type(EchoType)==StringType:
331: EchoTypes=[EchoType]
332: else:
333: EchoTypes=EchoType
334:
335: for singleType in EchoTypes:
336:
337: id = str(singleType)+"_template"
338: if REQUEST is None:
339: self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
340: ob = getattr(self, id)
341:
342: if title:
343: ob.pt_setTitle(title)
344: return ob
345: else:
346: file = REQUEST.form.get('file')
347: headers = getattr(file, 'headers', None)
348: if headers is None or not file.filename:
349: zpt = ECHO_layoutTemplate(id,EchoType=singleType)
350: else:
351: zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
352:
353: self._setObject(id, zpt)
354: ob = getattr(self, id)
355: if title:
356: ob.pt_setTitle(title)
357:
358: try:
359: u = self.DestinationURL()
360: except AttributeError:
361: u = REQUEST['URL1']
362:
363:
364: REQUEST.RESPONSE.redirect(u+'/manage_main')
365: return ''
366:
367: class ECHO_resource(Folder):
368: """ECHO Ressource"""
369: meta_type='ECHO_resource'
370:
371: viewClassificationList=viewClassificationListMaster
372:
373: getSubCols = ECHO_helpers.getSubCols
374: def getTitle(self):
375: """title"""
376: return self.title.encode('utf-8')
377:
378: def getLabel(self):
379: """title"""
380: return self.label.encode('utf-8')
381:
382: def content_html(self):
383: """template fuer content"""
384: return content_html(self,'resource')
385:
386: def getViewClassification(self):
387: if hasattr(self,'viewClassification'):
388: return self.viewClassification
389: else:
390: return ""
391:
392: def getFullTextXML(self,noredirect=None):
393: """getFullTextXML"""
394: try:
395: fh=urllib.urlopen(self.metalink)
396: dom=xml.dom.minidom.parse(fh)
397: texttools=dom.getElementsByTagName('texttool')
398: text=texttools[0].getElementsByTagName('text')
399: texturl=getText(text[0].childNodes)
400: if not noredirect:
401: self.REQUEST.RESPONSE.redirect(texturl)
402: else:
403: return texturl
404: except:
405: return None
406:
407: def getCredits(self):
408: """Ausgabe der credits"""
409: if self.credits:
410: return self.credits
411: else:
412: return []
413:
414: def __init__(self,id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords):
415:
416: self.id = id
417: """Festlegen der ID"""
418:
419: self.label = label
420: self.link= link
421: self.metalink=metalink
422: self.title=title
423: self.weight=weight
424: self.credits=toList(credits)
425: self.description=description
426: self.contentType=contentType
427: self.responsible=responsible
428:
429: if coords:
430: coordsnew=[ string.split(x,",") for x in coords]
431: else:
432: coordsnew=[]
433:
434: self.coords=coordsnew
435:
436:
437: def getCoords(self):
438: """gibt coordinaten als String zurück und löscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""
439: retList=[]
440: if hasattr(self,'coords'):
441: for x in self.coords:
442: if len(x)>1:
443: retList.append(string.join(x,","))
444: return retList
445:
446:
447:
448: def getContentType(self):
449: try:
450: return self.contentType
451: except:
452: return ""
453:
454: def getCopyrightType(self):
455: try:
456: return self.copyrightType
457: except:
458: return ""
459:
460: def getRenderingType(self):
461: try:
462: return self.renderingType
463: except:
464: return ""
465:
466: def ECHO_resource_config(self):
467: """Main configuration"""
468:
469: if not hasattr(self,'weight'):
470: self.weight=""
471:
472: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
473: return pt()
474:
475:
476: def ECHO_resource_config_main(self):
477: """Main configuration"""
478:
479: if not hasattr(self,'weight'):
480: self.weight=""
481:
482: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)
483: return pt()
484:
485: def ECHO_resource_config_coords(self):
486: """Coords configuration """
487:
488: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)
489: return pt()
490:
491: def ECHO_resource_config_credits(self):
492: """Main configuration"""
493:
494: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)
495: return pt()
496:
497: def ECHO_resource_config_metadata(self):
498: """Main configuration"""
499:
500: if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
501: self.metaDataHash={}
502: self.contentType=self.bib_type
503: for data in self.metadata:
504: data_neu=re.sub('-','_',data)
505: self.metaDataHash[data_neu]=getattr(self,data)
506: #print data_neu, getattr(self,data)
507: #print self.metaDataHash,self.metadata
508:
509: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)
510: return pt()
511:
512:
513:
514:
515: def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
516: """Änderung der Properties"""
517: self.resourceID=resourceID
518: self.title=title
519: self.label=label
520: self.description=description
521:
522: self.contentType=contentType
523: self.renderingType=renderingType
524: self.weight=weight
525:
526: self.link=link
527: self.metalink=metalink
528:
529: if RESPONSE is not None:
530: RESPONSE.redirect('manage_main')
531:
532:
533: def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):
534: """Änderung der Properties - coords"""
535:
536: if type(coords)==StringType:
537: coords=[coords]
538:
539: try:
540: coordsnew=[ string.split(x,",") for x in coords]
541: except:
542: coordsnew=[]
543:
544: self.coords=coordsnew[0:]
545: self.viewClassification=viewClassification
546:
547: if RESPONSE is not None:
548: RESPONSE.redirect('manage_main')
549:
550: def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
551: """Änderung der Properties"""
552: self.credits=credits
553: self.responsible=responsible
554: self.copyrightType=copyrightType
555:
556: if RESPONSE is not None:
557: RESPONSE.redirect('manage_main')
558:
559:
560: def changeECHO_resource_metadata(self,RESPONSE=None):
561: """change metadata"""
562: tags=self.findTagsFromMapping(self.contentType)
563: self.OSAS_meta={}
564: for field in tags[1]:
565: try:
566: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
567: self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
568: except:
569: """nothing"""
570:
571: return urllib.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()
572:
573: if RESPONSE is not None:
574: RESPONSE.redirect('manage_main')
575:
576:
577: def newMetaXML(self):
578: """new index.meta"""
579: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
580: return writeMetadata(self.metalink,self.OSAS_meta)
581:
582:
583: def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
584: """Änderung der Properties"""
585:
586: try:
587: coordsnew=[ string.split(x,",") for x in coords]
588: except:
589: coordsnew=[]
590:
591: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
592: self.viewClassification=viewClassification
593: self.coords=coordsnew[0:]
594: self.link=link
595: self.metalink=metalink
596:
597: if RESPONSE is not None:
598: RESPONSE.redirect('manage_main')
599:
600:
601: manage_options = Folder.manage_options+(
602: {'label':'Main Config','action':'ECHO_resource_config_main'},
603: {'label':'Change Credits & Copyright','action':'ECHO_resource_config_credits'},
604: {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
605: {'label':'Change Coords','action':'ECHO_resource_config_coords'},
606: {'label':'Add coords','action':'ECHO_graphicEntry'},
607: {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
608: )
609:
610: def getOverview(self):
611: """overview graphics"""
612:
613: return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
614:
615: def ECHO_graphicEntry(self):
616: """DO nothing"""
617: overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
618: if overview:
619: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
620: return pt()
621: else:
622: return "NO OVERVIEW GRAPHICS"
623:
624: def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
625: """Enter coords"""
626: coords=self.coords
627: temco=coordstr.split(",")
628: temco.append(angle)
629: coords.append(temco)
630:
631: self.coords=coords[0:]
632:
633: if RESPONSE is not None:
634: RESPONSE.redirect('ECHO_graphicEntry')
635:
636:
637: def isDefinedInThisSet(self,fields,field):
638: """checks if field is defined in fields"""
639: if (fields[0].has_key(field)) and not (fields[0][field]==""):
640: return 1
641: else:
642:
643: return 0
644:
645: def getFieldLabel(self,fields,field):
646: """get labels"""
647: try:
648: ret =fields[0][field]
649: if ret == "":
650: return field
651: else:
652: return ret
653: except:
654: return field
655:
656:
657:
658: def getFieldTag(self,fields,field):
659: """get labels"""
660: try:
661: ret =fields[0][field]
662: if ret == "":
663: return field
664: else:
665: return ret
666: except:
667: return field
668:
669:
670:
671: def getFieldValue(self,field):
672: """get value"""
673: #print field
674: try:
675:
676: ret=self.metaDataHash[field]
677: if ret == "":
678: return None
679: else:
680: return ret
681: except:
682: return None
683:
684: def findLabelsFromMapping(self,referenceType):
685: """gib hash mit label -> generic zurueck"""
686: self.referencetypes=self.ZopeFind(self.standardMD)
687: #print "RT",referenceType
688:
689: bibdata={}
690: retdata={}
691: fieldlist=self.standardMD.fieldList
692:
693: for referenceTypeF in self.referencetypes:
694: #print referenceTypeF[1].title,referenceType
695: if referenceTypeF[1].title == referenceType:
696: #print "OK"
697: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
698: bibdata['data']=referenceTypeF[1]
699: self.fields=bibdata[referenceType]
700: for field in fieldlist:
701: retdata[field]=referenceTypeF[1].getValue(field)[1]
702: #print retdata,fieldlist
703: return retdata,fieldlist
704:
705: def findTagsFromMapping(self,referenceType):
706: """gib hash mit label -> generic zurueck"""
707: self.referencetypes=self.ZopeFind(self.standardMD)
708:
709:
710: bibdata={}
711: retdata={}
712: fieldlist=self.standardMD.fieldList
713:
714: for referenceTypeF in self.referencetypes:
715:
716: if referenceTypeF[1].title == referenceType:
717: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
718: bibdata['data']=referenceTypeF[1]
719: self.fields=bibdata[referenceType]
720: for field in fieldlist:
721: retdata[field]=referenceTypeF[1].getValue(field)[0]
722:
723: return retdata,fieldlist
724:
725:
726:
727:
728: def ECHO_getResourceMD(self,template="yes"):
729: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
730: (metadict, error)=readMetadata(self.metalink)
731:
732:
733:
734: if not error=="": #Fehler beim Auslesen des Metafiles
735: return "ERROR:",error
736:
737:
738: if not (metadict['bib_type']==self.contentType):
739: self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
740: self.REQUEST.SESSION['contentZope']=self.contentType
741:
742: return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()
743:
744: self.REQUEST.SESSION['metadict']=metadict
745:
746: self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
747:
748:
749: if template=="yes":
750: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
751: return pt()
752:
753:
754:
755:
756: def ECHO_getMD(self,item):
757: """Ausgabe der MD"""
758: return getattr(self,item)
759:
760: def index_html(self):
761: """standard page"""
762:
763: return self.REQUEST.RESPONSE.redirect(self.link)
764:
765: def generate_label(self):
766: """Erzeugt_standard_Label aus Template"""
767: pt=getattr(self,"label_template_"+self.bib_type)
768:
769: return pt()
770:
771: def manage_addECHO_resourceForm(self):
772: """Form for adding a ressource"""
773: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
774: return pt()
775:
776:
777:
778: def manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
779: """addaresource"""
780:
781: newObj=ECHO_resource(id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords)
782:
783: self._setObject(id,newObj)
784:
785: if RESPONSE is not None:
786: RESPONSE.redirect('manage_main')
787:
788:
789: class ECHO_externalLink(Folder):
790: """Link zu einer externen Ressource"""
791: security=ClassSecurityInfo()
792: meta_type='ECHO_externalLink'
793:
794: def getTitle(self):
795: """title"""
796: return self.title.encode('utf-8')
797:
798: def getLabel(self):
799: """title"""
800: return self.label.encode('utf-8')
801:
802: def content_html(self):
803: """template fuer content"""
804: return content_html(self,'externalLink')
805:
806: def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
807:
808: self.id = id
809: """Festlegen der ID"""
810:
811: self.credits=toList(credits)
812: self.label = label
813: self.link= link
814: self.title=title
815: self.weight=weight
816: self.description=description
817: self.contentType=contentType
818: self.responsible=responsible
819: coordsnew=[ string.split(x,",") for x in coords]
820: self.coords=coordsnew
821:
822: def ECHO_externalLink_config(self):
823: """Main configuration"""
824:
825: if not hasattr(self,'weight'):
826: self.weight=""
827: if not hasattr(self,'coords'):
828:
829: self.coords=['']
830: #print "G",self.coords
831:
832: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)
833: return pt()
834:
835:
836: def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
837:
838: """Änderung der Properties"""
839: try:
840: coordsnew=[ string.split(x,",") for x in coords]
841: except:
842: coordsnew=[]
843:
844: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
845:
846: self.coords=coordsnew[0:]
847: self.link=link
848: if RESPONSE is not None:
849: RESPONSE.redirect('manage_main')
850:
851:
852: manage_options = Folder.manage_options+(
853: {'label':'Main Config','action':'ECHO_externalLink_config'},
854: )
855:
856: def getCredits(self):
857: """Ausgabe der credits"""
858: if self.credits:
859: return self.credits
860: else:
861: return []
862:
863: def index_html(self):
864: """standard page"""
865:
866: return self.REQUEST.RESPONSE.redirect(self.link)
867:
868: def manage_addECHO_externalLinkForm(self):
869: """Form for external Links"""
870: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)
871: return pt()
872:
873:
874: def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
875: """Add an external Link"""
876:
877: newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
878:
879: self._setObject(id,newObj)
880:
881: if RESPONSE is not None:
882: RESPONSE.redirect('manage_main')
883:
884:
885: class ECHO_link(ECHO_externalLink):
886: """external_link"""
887:
888: meta_type="ECHO_link"
889:
890:
891: def content_html(self):
892: """template fuer link"""
893: if hasattr(self,"link_template"):
894: return content_html(self,'link')
895: else:
896: return content_html(self,'collection')
897:
898: def manage_addECHO_linkForm(self):
899: """Form for external Links"""
900: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)
901: return pt()
902:
903:
904: def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
905: """Add an external Link"""
906:
907: newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
908:
909: self._setObject(id,newObj)
910:
911: if RESPONSE is not None:
912: RESPONSE.redirect('manage_main')
913:
914:
915: class ECHO_collection(Folder, Persistent, Implicit):
916: """ECHO Collection"""
917:
918: security=ClassSecurityInfo()
919: meta_type='ECHO_collection'
920: viewClassificationList=viewClassificationListMaster
921: displayTypes=displayTypes
922:
923: def getViewClassification(self):
924: if hasattr(self,'viewClassification'):
925: return self.viewClassification
926: else:
927: return ""
928:
929: def getTitle(self):
930: """title"""
931: return self.title.encode('utf-8')
932:
933: def getLabel(self):
934: """title"""
935: return self.label.encode('utf-8')
936:
937:
938:
939: def createRessourcesFromXMLForm(self):
940: """form"""
941: pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)
942: return pt()
943:
944: def createRessourcesFromXML(self,fileupload):
945: """read an XML file for generating resources"""
946: dom=xml.dom.minidom.parse(fileupload)
947: ret="<h2>Added</h2>"
948: for resource in dom.getElementsByTagName('resource'):
949: link=getText(resource.getElementsByTagName('link')[0].childNodes)
950: label=getText(resource.getElementsByTagName('label')[0].childNodes)
951: #splitted=link.split("?")[0].split("/")
952: #id=splitted[len(splitted)-1].encode('ascii')
953: id=re.sub(" ","_",label).encode('ascii')
954:
955: ret+="<p>"+label+"</p>"
956: manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")
957: return ret
958: def getImageTag(self):
959: """GetTag"""
960: try:
961: return self.imageTag
962: except:
963: return ""
964:
965: def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
966: """SSS"""
967: try:
968: manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
969: return "done"
970: except:
971: return None
972:
973: def getSecondaryLink(self):
974: """secondary link"""
975: try:
976: return self.secondaryLink
977: except:
978: return ""
979:
980: def getSecondaryLinkTitle(self):
981: """secondary link"""
982: try:
983: return self.secondaryLinkTitle
984: except:
985: return ""
986:
987: def getCollectionTreeXML(self):
988: """Tree as XML"""
989:
990: def getCollection(object,depth=0):
991: depth+=1
992: collections=""
993: for entry in object.__dict__.keys():
994: element=getattr(object,entry)
995: try:
996: if element.meta_type in ["ECHO_collection","ECHO_group"]:
997: collections+="<element name=\""+quote(element.title)+"\" url=\""+element.absolute_url()+"\">"
998: collections+=getCollection(element,depth)+"</element>\n"
999: except:
1000: """nothing"""
1001: return collections
1002:
1003: ret="""<?xml version="1.0" encoding="utf-8" ?>"""
1004: return ret+"<collection>"+getCollection(self)+"</collection>"
1005:
1006: def createJavaScript(self):
1007: """CreateJava"""
1008: ret=javaScriptMain
1009:
1010: dynamical="\n"
1011: for ob in self.getGraphicCoords():
1012: if ob[4][4] == "":
1013: dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
1014: else:
1015: dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])
1016: dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])
1017: ret+=javaHandler%dynamical
1018: return ret
1019:
1020: def createJSAreas(self):
1021: """new version of createJavaScript"""
1022: dynamical="\n"
1023: for ob in self.getGraphicCoords():
1024: if ob[5] == "area":
1025: dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])
1026: else:
1027: dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])
1028: return dynamical
1029:
1030: def createMapHead(self):
1031: """generate divs"""
1032: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)
1033: return pt()
1034:
1035: def createMapLink(self, ob, text=None):
1036: """generate map link"""
1037: id = ob[1]
1038: link = ob[1]
1039: if text == None:
1040: text = ob[2]
1041: tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
1042: if ob[3].contentType == 'text-popup':
1043: tag += ' title="%s"'%ob[3].description
1044: tag += ">" + text + "</a>"
1045: return tag
1046:
1047: def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):
1048: """generate map link image, text and other stuff"""
1049: id = ob[1]
1050: link = ob[1]
1051: vtype = ob[5]
1052: ctype = ob[3].contentType
1053:
1054: tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)
1055: if vtype == "view point":
1056: rot = ob[4][4]
1057: tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none" />'%(id,arrowsrc,rot)
1058: else:
1059: tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none"'%(id)
1060: if ctype == "text-popup":
1061: desc = ob[3].description
1062: tag += ' title="%s"'%desc
1063: tag += ' />'
1064: tag += '</a>'
1065: return tag
1066:
1067:
1068: security.declarePublic('getCreditObject')
1069: def getCreditObject(self,name):
1070: """credit id to credititem"""
1071: try:
1072: return getattr(self.partners,name)
1073: except:
1074: return ""
1075:
1076: security.declarePublic('ECHO_generateNavBar')
1077: def ECHO_generateNavBar(self):
1078: """Erzeuge Navigationsbar"""
1079: link=""
1080: object="self"
1081: ret=[]
1082: path=self.getPhysicalPath()
1083: for element in path:
1084:
1085:
1086: if not element=="":
1087: object+="."+element
1088:
1089: label=eval(object).label
1090: link+="/"+element
1091: if not label=="":
1092: ret.append((label,link))
1093: return ret
1094:
1095: security.declarePublic('ECHO_rerenderLinksMD')
1096:
1097: def ECHO_rerenderLinksMD(self,obj=None):
1098: """Rerender all Links"""
1099: if not obj:
1100: obj = self
1101:
1102: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
1103:
1104: for entry in entries:
1105: if entry[1].meta_type == 'ECHO_resource':
1106: entry[1].ECHO_getResourceMD(template="no")
1107: #print "rerender",entry[1].getId()
1108: else:
1109: self.ECHO_rerenderLinksMD(entry[1])
1110:
1111:
1112:
1113: return "Rerenderd all links to resources in: "+self.title
1114:
1115: security.declarePublic('ECHO_newViewerLink')
1116:
1117:
1118: def getCoords(self):
1119: try:
1120:
1121: x= [string.join(x,",") for x in self.coords]
1122: return x
1123:
1124: except:
1125:
1126: return []
1127:
1128: def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
1129: #print "CO",coords
1130:
1131: self.id = id
1132: """Festlegen der ID"""
1133: self.credits=toList(credits)
1134: self.label = label
1135: self.title=title
1136: self.description=description
1137: self.contentType=contentType
1138: self.responsible=responsible
1139: self.imageTag=imageTag
1140: self.weight=weight
1141: self.sortfield=sortfield
1142: coordsnew=[ string.split(x,",") for x in coords]
1143: self.coords=coordsnew
1144: self.secondaryLinkTitle=secondaryLinkTitle
1145: self.secondaryLink=secondaryLink
1146: self.bgcolour=bgcolour
1147:
1148:
1149: manage_options = Folder.manage_options+(
1150: {'label':'Main Config','action':'ECHO_collection_config'},
1151: {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
1152: {'label':'Graphics','action':'ECHO_graphicEntry'},
1153: {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
1154:
1155: )
1156:
1157: def getOverview(self):
1158: """overview graphics"""
1159:
1160: return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
1161:
1162:
1163: def ECHO_graphicEntry(self):
1164: """DO nothing"""
1165: overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
1166:
1167:
1168: if overview:
1169: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
1170: return pt()
1171: else:
1172: return "NO OVERVIEW GRAPHICS"
1173:
1174: def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
1175: """Enter coords"""
1176: coords=self.coords
1177: temco=coordstr.split(",")
1178: temco.append(angle)
1179: coords.append(temco)
1180: self.coords=coords[0:]
1181:
1182: if RESPONSE is not None:
1183: RESPONSE.redirect('ECHO_graphicEntry')
1184:
1185:
1186: security.declarePublic('ECHO_collection_config')
1187: def ECHO_collection_config(self):
1188: """Main configuration"""
1189:
1190: if not hasattr(self,'weight'):
1191: self.weight=""
1192:
1193: if not hasattr(self,'sortfield'):
1194: self.sortfield="weight"
1195:
1196: if not hasattr(self,'coords'):
1197: self.coords=[]
1198:
1199: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)
1200: return pt()
1201:
1202:
1203: security.declarePublic('changeECHO_collection')
1204:
1205:
1206: def getBgcolour(self):
1207: """colour"""
1208: if hasattr(self,'bgcolour') and not (self.bgcolour==""):
1209: return self.bgcolour
1210: else:
1211: return "#dddddd"
1212:
1213: def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",viewClassification=None):
1214: """Aenderung der Properties"""
1215:
1216: self.secondaryLink=secondaryLink
1217: self.secondaryLinkTitle=secondaryLinkTitle
1218: self.imageTag=imageTag
1219: self.bgcolour=bgcolour
1220: self.viewClassification=viewClassification
1221:
1222: if coords:
1223: coordsnew=[ string.split(x,",") for x in coords]
1224: self.coords=coordsnew[0:]
1225: else:
1226: coordsnew=None
1227: self.coords=None
1228:
1229: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
1230: try:
1231: self.coords=coordsnew[0:] # HACK fehler in setECHO_collection
1232: except:
1233: """none"""
1234:
1235: self.sortfield=sortfield
1236:
1237: if RESPONSE is not None:
1238: RESPONSE.redirect('manage_main')
1239:
1240: security.declarePublic('index_html')
1241:
1242:
1243: def showOverview(self):
1244: """overview"""
1245: if 'ECHO_overview.html' in self.__dict__.keys():
1246: return getattr(self,'ECHO_overview.html')()
1247: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
1248: return pt()
1249:
1250: security.declareProtected('View','index_html')
1251:
1252: def index_html(self):
1253: """standard page"""
1254:
1255: if 'index.html' in self.__dict__.keys():
1256: return getattr(self,'index.html')()
1257:
1258: elif 'overview' in self.__dict__.keys():
1259: return self.showOverview()
1260: elif hasattr(self,'collection_index_template'):
1261: return self.collection_index_template()
1262: elif hasattr(self,'main_index_template'):
1263: return self.main_index_template()
1264:
1265: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
1266: pt.content_type="text/html"
1267: return pt()
1268:
1269: def content_html(self):
1270: """template fuer content"""
1271: return content_html(self,'collection')
1272:
1273: def getCredits(self):
1274: """Ausgabe der credits"""
1275: if self.credits:
1276: return self.credits
1277: else:
1278: return []
1279:
1280: def area_img(self):
1281: """area image"""
1282: return sendFile(self, 'images/red.gif', 'image/gif')
1283:
1284: def hl_lib_js(self):
1285: """javascript"""
1286: return sendFile(self, 'js/hl_lib.js', 'text/plain')
1287:
1288: def js_lib_js(self):
1289: """javascript"""
1290: return sendFile(self, 'js/js_lib.js', 'text/plain')
1291:
1292: def getGraphicCoords(self):
1293: """Give list of coordinates"""
1294: subColTypes=['ECHO_collection','ECHO_resource']
1295: ids=[]
1296: for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):
1297: object=entrySearch[1]
1298: if hasattr(object,'coords'):
1299: for coordtemp in object.coords:
1300: if len(coordtemp)>3:
1301: coord=coordtemp[0:4]
1302: label=""
1303: vc=""
1304: if hasattr(object,'label') and not object.label=="":
1305: label=object.label
1306: elif hasattr(object,'title') and not object.title=="":
1307: label=object.title
1308: else:
1309: label=object.getId()
1310: if object.viewClassification != "":
1311: vc=object.viewClassification
1312: else:
1313: if len(coordtemp) > 4 and coordtemp[4] != "":
1314: vc="view point"
1315: else:
1316: vc="area"
1317: ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,vc])
1318: return ids
1319:
1320:
1321:
1322:
1323: getSubCols = ECHO_helpers.getSubCols
1324:
1325: Globals.InitializeClass(ECHO_collection)
1326:
1327: def manage_addECHO_collectionForm(self):
1328: """Add collection form"""
1329: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
1330: return pt()
1331:
1332:
1333: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
1334: """add a echo collection"""
1335:
1336:
1337: newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
1338:
1339: self._setObject(id,newObj)
1340:
1341: if RESPONSE is not None:
1342: RESPONSE.redirect('manage_main')
1343:
1344: class ECHO_group(ECHO_collection):
1345: """ECHO Gruppe"""
1346: security=ClassSecurityInfo()
1347: meta_type="ECHO_group"
1348:
1349: manage_options = Folder.manage_options+(
1350: {'label':'Main Config','action':'ECHO_group_config'},
1351: {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
1352: {'label':'Graphics','action':'ECHO_graphicEntry'},
1353: )
1354:
1355: security.declareProtected('View','index_html')
1356: def index_html(self):
1357: """standard page"""
1358: displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
1359: #if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
1360: # return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
1361:
1362: if 'index.html' in self.__dict__.keys():
1363: return getattr(self,'index.html')()
1364:
1365: elif 'overview' in self.__dict__.keys():
1366: return self.showOverview()
1367: elif hasattr(self,'group_index_template'):
1368: return self.group_index_template()
1369: elif hasattr(self,'collection_index_template'):
1370: return self.collection_index_template()
1371: elif hasattr(self,'main_index_template'):
1372: return self.main_index_template()
1373:
1374: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
1375: pt.content_type="text/html"
1376: return pt()
1377:
1378: def ECHO_group_config(self):
1379: """Main configuration"""
1380:
1381: if not hasattr(self,'weight'):
1382: self.weight=""
1383:
1384: if not hasattr(self,'sortfield'):
1385: self.sortfield="weight"
1386:
1387: if not hasattr(self,'coords'):
1388: self.coords=[]
1389:
1390: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
1391: return pt()
1392:
1393: def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
1394: """Änderung der Properties"""
1395:
1396: self.secondaryLink=secondaryLink
1397: self.secondaryLinkTitle=secondaryLinkTitle
1398: self.imageTag=imageTag
1399: self.bgcolour=bgcolour
1400: self.logo=logo
1401:
1402: if coords:
1403: coordsnew=[ string.split(x,",") for x in coords]
1404: self.coords=coordsnew[0:]
1405: else:
1406: coordsnew=None
1407: self.coords=None
1408:
1409: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
1410:
1411:
1412:
1413: self.sortfield=sortfield
1414:
1415: if RESPONSE is not None:
1416: RESPONSE.redirect('manage_main')
1417:
1418: def getLogo(self):
1419: """logo ausgeben"""
1420: try:
1421: return self.logo
1422: except:
1423: return "ECHO_groups"
1424:
1425: def content_html(self):
1426: """template fuer content"""
1427: return content_html(self,'group')
1428:
1429:
1430:
1431: def manage_addECHO_groupForm(self):
1432: """Add group form"""
1433: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
1434: return pt()
1435:
1436:
1437: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
1438: """add a echo group"""
1439:
1440:
1441: newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
1442:
1443: setattr(newObj,'logo',logo)
1444: self._setObject(id,newObj)
1445:
1446: if RESPONSE is not None:
1447: RESPONSE.redirect('manage_main')
1448:
1449: Globals.InitializeClass(ECHO_group)
1450:
1451: class ECHO_root(Folder,Persistent,Implicit):
1452: """ECHO Root Folder"""
1453: meta_type="ECHO_root"
1454:
1455:
1456: def getImageTag(self):
1457: """needed by main_template"""
1458: return ""
1459: secondaryLink="" #needed by main_template
1460: secondaryLinkTitle="" #needed by main_template
1461:
1462: def getBgcolour(self):
1463: """hack"""
1464: return "#dddddd"
1465:
1466: def contentTypeSelector_HTML(self,selected=None):
1467: """give type selector"""
1468: if not selected:
1469: retStr="<option selected>\n"
1470: else:
1471: retStr="<option>\n"
1472:
1473: try: # erste version contentTypes exists
1474: for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
1475: if selected and (contentType[0]==selected):
1476: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
1477: else:
1478: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
1479: except:
1480: try:
1481: for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
1482: if selected and (contentType[0]==selected):
1483: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
1484: else:
1485: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
1486: except:
1487: """nothing"""
1488:
1489: return retStr
1490:
1491: def renderingTypeSelector_HTML(self,selected=None):
1492: """give type selector"""
1493: if not selected:
1494: retStr="<option selected>\n"
1495: else:
1496: retStr="<option>\n"
1497:
1498: try: # erste version renderingTypes exists
1499: for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
1500: if selected and (renderingType[0]==selected):
1501: retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
1502: else:
1503: retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
1504: except:
1505: """nothing"""
1506: return retStr
1507:
1508: def renderingTypeSelector_HTML(self,selected=None):
1509: """give type selector"""
1510: if not selected:
1511: retStr="<option selected>\n"
1512: else:
1513: retStr="<option>\n"
1514:
1515: try: # erste version renderingTypes exists
1516: for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
1517: if selected and (renderingType[0]==selected):
1518: retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
1519: else:
1520: retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
1521: except:
1522: """nothing"""
1523: return retStr
1524:
1525:
1526: def copyrightTypeSelector_HTML(self,selected=None):
1527: """give type selector"""
1528: if not selected:
1529: retStr="<option selected>\n"
1530: else:
1531: retStr="<option>\n"
1532:
1533: try: # erste version copyrightTypes exists
1534: for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
1535: if selected and (copyrightType[0]==selected):
1536: retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
1537: else:
1538: retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
1539: except:
1540: """nothing"""
1541: return retStr
1542:
1543:
1544: def patchContentType(self,obj=None):
1545: """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
1546:
1547:
1548: if not obj:
1549: obj = self
1550:
1551: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
1552:
1553: for entry in entries:
1554: setattr(entry[1],'contentType',entry[1].content_type)
1555: #entry[1].contentType == entry[1].content_type
1556:
1557: if entry[1].meta_type == 'ECHO_collection':
1558: entry[1].patchContentType(entry[1])
1559:
1560:
1561: return "changed all contenttypes in: "+self.title
1562:
1563:
1564: def patchViewClassification(self,obj=None):
1565: """setze viewClassification heuristisch"""
1566:
1567: def checkIfArrow(obj):
1568: if hasattr(obj,'coords'):
1569: for coordtemp in obj.coords:
1570: #print obj.title,len(coordtemp)
1571: if (len(coordtemp)>4) and not (coordtemp[4]==''):
1572: return 4
1573: return None
1574: return None
1575:
1576: if not obj:
1577: obj = self
1578:
1579: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
1580:
1581: for entry in entries:
1582:
1583: if checkIfArrow(entry[1]):
1584: setattr(entry[1],'viewClassification','view point')
1585: else:
1586: setattr(entry[1],'viewClassification','area')
1587:
1588: #entry[1].contentType == entry[1].content_type
1589:
1590: if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
1591: entry[1].patchViewClassification(entry[1])
1592:
1593:
1594: return "changed all contenttypes in: "+self.title
1595:
1596: def ECHO_newViewerLink(self,obj=None):
1597: """change links (:86 faellt weg)"""
1598:
1599: if not obj:
1600: obj = self
1601:
1602: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
1603:
1604: for entry in entries:
1605:
1606: if entry[1].meta_type == 'ECHO_resource':
1607:
1608: entry[1].link=re.sub('\:86','',entry[1].link)
1609:
1610: else:
1611:
1612: entry[1].ECHO_newViewerLink(entry[1])
1613:
1614: return "Rerenderd all links to resources in: "+self.title
1615:
1616: def __init__(self,id,title):
1617: """init"""
1618: self.id = id
1619: self.title=title
1620:
1621: def deleteSpace(self,str):
1622: """delete space at the end of a line"""
1623: if str[len(str)-1]==" ":
1624: return str[0:len(str)-1]
1625: else:
1626: return str
1627:
1628:
1629:
1630: # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
1631:
1632: def formatAscii(self,str,url=None):
1633: """ersetze ascii umbrueche durch <br>"""
1634: #url=None
1635: if url:
1636:
1637: retStr=""
1638: words=str.split("\n")
1639:
1640: for word in words:
1641: strUrl=url%word
1642: #print "str",strUrl
1643: retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
1644: str=retStr
1645: if str:
1646: return re.sub(r"[\n]","<br/>",str)
1647: else:
1648: return ""
1649:
1650: def link2html(self,str):
1651: """link2html fuer VLP muss hier noch raus"""
1652: if str:
1653: #print str
1654: str=re.sub("\&","&",str)
1655: dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")
1656: links=dom.getElementsByTagName("link")
1657:
1658: #print "link",links
1659: for link in links:
1660: link.tagName="a"
1661: ref=link.getAttribute("ref")
1662: if self.checkRef(ref):
1663: link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
1664:
1665: return dom.toxml('utf-8')
1666: return ""
1667:
1668:
1669: def checkRef(self,ref):
1670: dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}
1671: res=None
1672: for db in dbs.keys():
1673: #print ref,"select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])
1674:
1675: res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
1676: return res
1677:
1678: #Ende Methode fuer vlp
1679:
1680: def PgQuoteString(self,string):
1681: """Quote string"""
1682: #print "PG",string
1683: return libpq.PgQuoteString(string)
1684:
1685: def getPartners(self):
1686: """Get list of Partners. Presently only from a subfolder partners"""
1687:
1688: return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
1689:
1690:
1691:
1692:
1693:
1694: def getPartnersXML(self):
1695: """partner liste als xml"""
1696: partners=self.getPartners()
1697: ret="""<?xml version="1.0" encoding="utf-8" ?>
1698: <partners>"""
1699:
1700: for partner in partners:
1701: ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),unicode(partner.title,'utf-8','replace'))
1702:
1703: return ret+"\n</partners>"
1704:
1705: def getCollectionTree(self):
1706: """get the collection tree (list of triples (parent,child, depth)"""
1707:
1708: def getCollection(object,depth=0):
1709: depth+=1
1710: collections=[]
1711: for entry in object.__dict__.keys():
1712: element=getattr(object,entry)
1713: try:
1714: if element.meta_type=="ECHO_collection":
1715: collections.append((object,element,depth))
1716: collections+=getCollection(element,depth)
1717: except:
1718: """nothing"""
1719: return collections
1720:
1721:
1722: return getCollection(self)
1723:
1724: def getCollectionTreeIds(self):
1725: """Show the IDs of the Tree"""
1726: ret=[]
1727: for collection in self.getCollectionTree():
1728: ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
1729: return ret
1730:
1731: def getResourcesHTML(self,viewerType=None,filter=None):
1732: """gebe all ressourcen aus"""
1733:
1734: def sortHTML(x,y):
1735: return cmp(x[1].title,y[1].title)
1736:
1737: ret="""<html><body><h2>Resources in ECHO</h3>"""
1738:
1739: resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
1740: ret+="""<h3>Found %i resources</h3>"""%len(resources)
1741: resources.sort(sortHTML)
1742: for resource in resources:
1743: echo_url=resource[1].absolute_url()
1744:
1745: if hasattr(resource[1],'title'):
1746: title=resource[1].title
1747: else:
1748: title="None"
1749: if filter:
1750: if re.search(filter,title):
1751: ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
1752: else:
1753: ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
1754:
1755: ret +="""\n</body></html>"""
1756:
1757: #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
1758: #self.REQUEST.RESPONSE.write(ret)
1759: return ret
1760:
1761: def getResourcesXML(self,viewerType=None,filter=None):
1762: """gebe all ressourcen aus"""
1763: ret="""<?xml version="1.0" ?>
1764: <index>"""
1765: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
1766:
1767: echo_url=resource[1].absolute_url()
1768: if hasattr(resource[1],'link'):
1769: viewer_url=resource[1].link
1770: else:
1771: viewer_url="NO URL"
1772: if filter:
1773: if re.search(filter,viewer_url):
1774: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
1775: else:
1776: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
1777: ret +="""\n</index>"""
1778:
1779: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
1780: self.REQUEST.RESPONSE.write(ret)
1781:
1782: def getFullTextsXML(self,viewerType=None,filter=None):
1783: """gebe all ressourcen aus"""
1784: ret="""<?xml version="1.0" ?>
1785: <index>"""
1786: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
1787:
1788: echo_url=resource[1].absolute_url()
1789: if resource[1].getFullTextXML(noredirect="yes"):
1790: if hasattr(resource[1],'link'):
1791: viewer_url=echo_url+"/getFullTextXML"
1792: else:
1793: viewer_url="NO URL"
1794: if filter:
1795: if re.search(filter,viewer_url):
1796: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
1797: else:
1798: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
1799: ret +="""\n</index>"""
1800: print ret
1801:
1802: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
1803: self.REQUEST.RESPONSE.write(ret)
1804:
1805: def manage_addECHO_root(self,id,title,RESPONSE=None):
1806: """Add an ECHO_root"""
1807: self._setObject(id,ECHO_root(id,title))
1808:
1809: if RESPONSE is not None:
1810: RESPONSE.redirect('manage_main')
1811:
1812: def manage_addECHO_rootForm(self):
1813: """Nothing yet"""
1814: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
1815: return pt()
1816:
1817: class ECHO_partner(Image,Persistent):
1818: """ECHO Partner"""
1819:
1820: meta_type="ECHO_partner"
1821:
1822: def __init__(self, id, title,url, file, content_type='', precondition=''):
1823: self.__name__=id
1824: self.title=title
1825: self.url=url
1826: self.precondition=precondition
1827:
1828: data, size = self._read_data(file)
1829: content_type=self._get_content_type(file, data, id, content_type)
1830: self.update_data(data, content_type, size)
1831:
1832: manage_options = Image.manage_options+(
1833: {'label':'Partner Information','action':'ECHO_partner_config'},
1834: )
1835:
1836: def changeECHO_partner(self,url,RESPONSE=None):
1837: """Change main information"""
1838: self.url=url
1839: if RESPONSE is not None:
1840: RESPONSE.redirect('manage_main')
1841:
1842:
1843:
1844: def ECHO_partner_config(self):
1845: """Main configuration"""
1846: if not hasattr(self,'url'):
1847: self.url=""
1848: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)
1849: return pt()
1850:
1851:
1852: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
1853: Kind='ECHO_partner',kind='ECHO_partner')
1854:
1855:
1856:
1857: def manage_addECHO_partner(self, id, file,url, title='', precondition='', content_type='',
1858: REQUEST=None):
1859: """
1860: Add a new ECHO_partner object.
1861:
1862: Creates a new ECHO_partner object 'id' with the contents of 'file'.
1863: Based on Image.manage_addImage
1864: """
1865:
1866: id=str(id)
1867: title=str(title)
1868: content_type=str(content_type)
1869: precondition=str(precondition)
1870:
1871: id, title = OFS.Image.cookId(id, title, file)
1872:
1873: self=self.this()
1874:
1875: # First, we create the image without data:
1876: self._setObject(id, ECHO_partner(id,title,url,'',content_type, precondition))
1877:
1878: # Now we "upload" the data. By doing this in two steps, we
1879: # can use a database trick to make the upload more efficient.
1880: if file:
1881: self._getOb(id).manage_upload(file)
1882: if content_type:
1883: self._getOb(id).content_type=content_type
1884:
1885: if REQUEST is not None:
1886: try: url=self.DestinationURL()
1887: except: url=REQUEST['URL1']
1888: REQUEST.RESPONSE.redirect('%s/manage_main' % url)
1889: return id
1890:
1891:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ECHO_collection.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ECHO_content