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: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
25: from Products.PageTemplates.PageTemplate import PageTemplate
26: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
27: from Globals import Persistent, package_home
28: from Acquisition import Implicit
29:
30: #from psycopg import libpq
31: #from pyPgSQL import libpq
32: import xml.dom.minidom
33:
34: import urllib
35: import xml.dom.minidom
36: from ECHO_graphicalOverview import javaHandler,javaScriptMain
37:
38: #List of different types for the graphical linking viewer
39: viewClassificationListMaster=['view point','area']
40:
41: def content_html(self,type):
42: """template fuer content"""
43: #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
44: #
45: #if templates:
46: # return templates[0][1]()
47:
48: try:
49: obj=getattr(self,type+"_template")
50: return obj()
51: except:
52: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)
53: pt.content_type="text/html"
54: return pt()
55:
56: def toList(field):
57: """Einzelfeld in Liste umwandeln"""
58: if type(field)==StringType:
59: return [field]
60: else:
61: return field
62:
63: def getText(nodelist):
64:
65: rc = ""
66: for node in nodelist:
67: if node.nodeType == node.TEXT_NODE:
68: rc = rc + node.data
69: return rc
70:
71:
72: def readMetadata(url):
73: """Methoden zum Auslesen der Metadateninformation zu einer Resource
74: Vorerst noch Typ bib"""
75:
76: metadict={}
77: try:
78: geturl=""
79: for line in urllib.urlopen(url).readlines():
80: geturl=geturl+line
81:
82:
83: except:
84: return (None,"Cannot open: "+url)
85:
86: try:
87: dom=xml.dom.minidom.parseString(geturl)
88: except:
89: return (None,"Cannot parse: "+url+"<br>"+geturl)
90:
91: metanode=dom.getElementsByTagName('bib')
92: metadict['bib_type']='Book'
93: if len(metanode)==0:
94: metanode=dom.getElementsByTagName('archimedes')
95: metadict['bib_type']='Archimedes'
96: #print "HELLO"
97:
98: if not len(metanode)==0:
99: metacontent=metanode[0].childNodes
100:
101: try:
102: metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
103: except:
104: """nothing"""
105:
106: for node in metacontent:
107: try:
108: metadict[node.tagName.lower()]=getText(node.childNodes)
109: except:
110: """nothing"""
111:
112: #print metadict
113: return metadict,""
114:
115:
116: def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):
117:
118: """Allegemeine Informationen zu einer ECHO Collection"""
119:
120: self.viewClassification=viewClassification
121:
122: self.label = label
123: self.title=title
124: self.description=description
125: self.contentType=contentType
126: self.responsible=responsible
127: self.credits=toList(credits)
128: self.weight=weight
129:
130: coords=[]
131: #coordinates of for rectangles
132:
133: #print "cs", coordstrs
134: if coordstrs:
135: for coordstr in coordstrs:
136: #print "cs", coordstr
137: try:
138: temco=coordstr.split(",")
139: except:
140: temco=[]
141: #temco.append(angle)
142: coords.append(temco)
143:
144:
145: self.coords=coords[0:]
146:
147:
148: class scientificClassification(SimpleItem,Persistent,Implicit):
149: """outdated will be deleeted in the next versions: subclass"""
150: security=ClassSecurityInfo()
151:
152: def __init__(self,context,science,practice):
153: self.context=context
154: self.science=science
155: self.practice=practice
156: self.id="scientific_Classification"
157:
158: security.declarePublic('get_context')
159: def get_context(self):
160: return self.context
161:
162: security.declarePublic('get_science')
163: def get_science(self):
164: return self.science
165:
166: security.declarePublic('get_practice')
167: def get_practice(self):
168: return self.practice
169:
170:
171: class scientificInformation(Folder,Persistent,Implicit):
172: """outdated will be deleted in the next versions: subclass scientificInformation"""
173: security=ClassSecurityInfo()
174:
175:
176:
177: def __init__(self,source_type,period):
178:
179: self.id="scientific_Information"
180: self.source_type=source_type
181: self.period=period
182:
183:
184:
185: security.declarePublic('get_source_type')
186: def get_source_type(self):
187: return self.source_type
188:
189: security.declarePublic('get_period')
190: def get_period(self):
191: return self.period
192:
193: class ECHO_layoutTemplate(ZopePageTemplate):
194: """Create a layout Template for different purposes"""
195:
196: meta_type="ECHO_layoutTemplate"
197:
198: def __init__(self, id, text=None, content_type=None,EchoType=None):
199: self.id = str(id)
200:
201:
202:
203: self.ZBindings_edit(self._default_bindings)
204: if text is None:
205: self._default_content_fn = os.path.join(package_home(globals()),
206: 'zpt/ECHO_%s_template_standard.zpt'%EchoType)
207: text = open(self._default_content_fn).read()
208: self.pt_edit(text, content_type)
209:
210:
211: """change form"""
212:
213:
214: def manage_addECHO_layoutTemplateForm(self):
215: """Form for adding"""
216: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)
217: return pt()
218:
219: from urllib import quote
220:
221:
222: def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
223: "Add a Page Template with optional file content."
224: if type(EchoType)==StringType:
225: EchoTypes=[EchoType]
226: else:
227: EchoTypes=EchoType
228:
229: for singleType in EchoTypes:
230:
231: id = str(singleType)+"_template"
232: if REQUEST is None:
233: self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
234: ob = getattr(self, id)
235:
236: if title:
237: ob.pt_setTitle(title)
238: return ob
239: else:
240: file = REQUEST.form.get('file')
241: headers = getattr(file, 'headers', None)
242: if headers is None or not file.filename:
243: zpt = ECHO_layoutTemplate(id,EchoType=singleType)
244: else:
245: zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
246:
247: self._setObject(id, zpt)
248: ob = getattr(self, id)
249: if title:
250: ob.pt_setTitle(title)
251:
252: try:
253: u = self.DestinationURL()
254: except AttributeError:
255: u = REQUEST['URL1']
256:
257:
258: REQUEST.RESPONSE.redirect(u+'/manage_main')
259: return ''
260:
261: class ECHO_resource(Folder):
262: """ECHO Ressource"""
263: meta_type='ECHO_resource'
264:
265: viewClassificationList=viewClassificationListMaster
266:
267: def content_html(self):
268: """template fuer content"""
269: return content_html(self,'resource')
270:
271: def getViewClassification(self):
272: if hasattr(self,'viewClassification'):
273: return self.viewClassification
274: else:
275: return ""
276:
277: def getCredits(self):
278: """Ausgabe der credits"""
279: if self.credits:
280: return self.credits
281: else:
282: return []
283:
284: def __init__(self,id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords):
285:
286: self.id = id
287: """Festlegen der ID"""
288:
289: self.label = label
290: self.link= link
291: self.metalink=metalink
292: self.title=title
293: self.weight=weight
294: self.credits=toList(credits)
295: self.description=description
296: self.contentType=contentType
297: self.responsible=responsible
298:
299: if coords:
300: coordsnew=[ string.split(x,",") for x in coords]
301: else:
302: coordsnew=[]
303:
304: self.coords=coordsnew
305:
306:
307: def getCoords(self):
308: try:
309: return [string.join(x,",") for x in self.coords]
310: except:
311: return []
312:
313:
314: def ECHO_resource_config(self):
315: """Main configuration"""
316:
317: if not hasattr(self,'weight'):
318: self.weight=""
319: if not hasattr(self,'coords'):
320: self.coords=[]
321:
322: print "vorher",self.coords
323: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
324: return pt()
325:
326:
327: def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
328: """Änderung der Properties"""
329:
330: try:
331: coordsnew=[ string.split(x,",") for x in coords]
332: except:
333: coordsnew=[]
334:
335: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
336:
337: self.coords=coordsnew[0:]
338: self.link=link
339: self.metalink=metalink
340:
341: if RESPONSE is not None:
342: RESPONSE.redirect('manage_main')
343:
344:
345: manage_options = Folder.manage_options+(
346: {'label':'Main Config','action':'ECHO_resource_config'},
347: {'label':'Metadata','action':'ECHO_getResourceMD'},
348: {'label':'Graphics','action':'ECHO_graphicEntry'},
349: )
350:
351: def getOverview(self):
352: """overview graphics"""
353:
354: return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
355:
356: def ECHO_graphicEntry(self):
357: """DO nothing"""
358: overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
359: if overview:
360: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
361: return pt()
362: else:
363: return "NO OVERVIEW GRAPHICS"
364:
365: def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
366: """Enter coords"""
367: coords=self.coords
368: temco=coordstr.split(",")
369: temco.append(angle)
370: coords.append(temco)
371:
372: self.coords=coords[0:]
373:
374: if RESPONSE is not None:
375: RESPONSE.redirect('ECHO_graphicEntry')
376:
377: def ECHO_getResourceMD(self,template="yes"):
378: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
379: (metadict, error)=readMetadata(self.metalink)
380:
381:
382:
383: if not error=="": #Fehler beim Auslesen des Metafiles
384: return "ERROR:",error
385: for key in metadict.keys():#Hinzufügen der Felder
386:
387: setattr(self,key,metadict[key].encode('ascii','replace'))
388:
389:
390: self.metadata=metadict.keys()
391:
392: self.label=self.generate_label()
393:
394: if template=="yes":
395: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
396: return pt()
397:
398: def ECHO_getMD(self,item):
399: """Ausgabe der MD"""
400: return getattr(self,item)
401:
402: def index_html(self):
403: """standard page"""
404:
405: return self.REQUEST.RESPONSE.redirect(self.link)
406:
407: def generate_label(self):
408: """Erzeugt_standard_Label aus Template"""
409: pt=getattr(self,"label_template_"+self.bib_type)
410:
411: return pt()
412:
413: def manage_addECHO_resourceForm(self):
414: """Form for adding a ressource"""
415: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
416: return pt()
417:
418:
419:
420: def manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
421: """addaresource"""
422:
423: newObj=ECHO_resource(id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords)
424:
425: self._setObject(id,newObj)
426:
427: if RESPONSE is not None:
428: RESPONSE.redirect('manage_main')
429:
430:
431: class ECHO_externalLink(Folder):
432: """Link zu einer externen Ressource"""
433: security=ClassSecurityInfo()
434: meta_type='ECHO_externalLink'
435:
436: def content_html(self):
437: """template fuer content"""
438: return content_html(self,'externalLink')
439:
440: def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
441:
442: self.id = id
443: """Festlegen der ID"""
444:
445: self.credits=toList(credits)
446: self.label = label
447: self.link= link
448: self.title=title
449: self.weight=weight
450: self.description=description
451: self.contentType=contentType
452: self.responsible=responsible
453: coordsnew=[ string.split(x,",") for x in coords]
454: self.coords=coordsnew
455:
456: def ECHO_externalLink_config(self):
457: """Main configuration"""
458:
459: if not hasattr(self,'weight'):
460: self.weight=""
461: if not hasattr(self,'coords'):
462:
463: self.coords=['']
464: #print "G",self.coords
465:
466: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)
467: return pt()
468:
469:
470: def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
471:
472: """Änderung der Properties"""
473: try:
474: coordsnew=[ string.split(x,",") for x in coords]
475: except:
476: coordsnew=[]
477:
478: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
479:
480: self.coords=coordsnew[0:]
481: self.link=link
482: if RESPONSE is not None:
483: RESPONSE.redirect('manage_main')
484:
485:
486: manage_options = Folder.manage_options+(
487: {'label':'Main Config','action':'ECHO_externalLink_config'},
488: )
489:
490: def getCredits(self):
491: """Ausgabe der credits"""
492: if self.credits:
493: return self.credits
494: else:
495: return []
496:
497: def index_html(self):
498: """standard page"""
499:
500: return self.REQUEST.RESPONSE.redirect(self.link)
501:
502: def manage_addECHO_externalLinkForm(self):
503: """Form for external Links"""
504: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)
505: return pt()
506:
507:
508: def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
509: """Add an external Link"""
510:
511: newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
512:
513: self._setObject(id,newObj)
514:
515: if RESPONSE is not None:
516: RESPONSE.redirect('manage_main')
517:
518:
519:
520: class ECHO_collection(Folder, Persistent, Implicit):
521: """ECHO Collection"""
522: security=ClassSecurityInfo()
523: meta_type='ECHO_collection'
524:
525: def getImageTag(self):
526: """GetTag"""
527: try:
528: return self.imageTag
529: except:
530: return ""
531:
532: def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
533: """SSS"""
534: try:
535: manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
536: return "done"
537: except:
538: return None
539:
540: def getSecondaryLink(self):
541: """secondary link"""
542: try:
543: return self.secondaryLink
544: except:
545: return ""
546:
547: def getSecondaryLinkTitle(self):
548: """secondary link"""
549: try:
550: return self.secondaryLinkTitle
551: except:
552: return ""
553:
554: def getCollectionTreeXML(self):
555: """Tree as XML"""
556:
557: def getCollection(object,depth=0):
558: depth+=1
559: collections=""
560: for entry in object.__dict__.keys():
561: element=getattr(object,entry)
562: try:
563: if element.meta_type in ["ECHO_collection","ECHO_group"]:
564: collections+="<element name=\""+element.title+"\" url=\""+element.absolute_url()+"\">"
565: collections+=getCollection(element,depth)+"</element>\n"
566: except:
567: """nothing"""
568: return collections
569:
570:
571: return "<collection>"+getCollection(self)+"</collection>"
572:
573: def createJavaScript(self):
574: """CreateJava"""
575: ret=javaScriptMain
576:
577: dynamical=""
578: for ob in self.getGraphicCoords():
579: dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
580: ret+=javaHandler%dynamical
581: return ret
582:
583: security.declarePublic('getCreditObject')
584: def getCreditObject(self,name):
585: """credit id to credititem"""
586: try:
587: return getattr(self.partners,name)
588: except:
589: return ""
590:
591: security.declarePublic('ECHO_generateNavBar')
592: def ECHO_generateNavBar(self):
593: """Erzeuge Navigationsbar"""
594: link=""
595: object="self"
596: ret=[]
597: path=self.getPhysicalPath()
598: for element in path:
599:
600:
601: if not element=="":
602: object+="."+element
603:
604: label=eval(object).label
605: link+="/"+element
606: if not label=="":
607: ret.append((label,link))
608: return ret
609:
610: security.declarePublic('ECHO_rerenderLinksMD')
611: def ECHO_rerenderLinksMD(self):
612: """Rerender all Links"""
613:
614: for entry in self.__dict__.keys():
615: object=getattr(self,entry)
616:
617:
618: try:
619:
620: if object.meta_type == 'ECHO_resource':
621:
622: object.ECHO_getResourceMD(template="no")
623:
624: except:
625: """nothing"""
626:
627: return "Rerenderd all links to resources in: "+self.title
628:
629: security.declarePublic('ECHO_newViewerLink')
630:
631:
632: def getCoords(self):
633: try:
634:
635: x= [string.join(x,",") for x in self.coords]
636: return x
637:
638: except:
639:
640: return []
641:
642: def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
643: #print "CO",coords
644:
645: self.id = id
646: """Festlegen der ID"""
647: self.credits=toList(credits)
648: self.label = label
649: self.title=title
650: self.description=description
651: self.contentType=contentType
652: self.responsible=responsible
653: self.imageTag=imageTag
654: self.weight=weight
655: self.sortfield=sortfield
656: coordsnew=[ string.split(x,",") for x in coords]
657: self.coords=coordsnew
658: self.secondaryLinkTitle=secondaryLinkTitle
659: self.secondaryLink=secondaryLink
660: self.bgcolour=bgcolour
661:
662:
663: manage_options = Folder.manage_options+(
664: {'label':'Main Config','action':'ECHO_collection_config'},
665: {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
666: {'label':'Graphics','action':'ECHO_graphicEntry'},
667:
668: )
669:
670: def getOverview(self):
671: """overview graphics"""
672:
673: return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
674:
675:
676: def ECHO_graphicEntry(self):
677: """DO nothing"""
678: overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
679:
680:
681: if overview:
682: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
683: return pt()
684: else:
685: return "NO OVERVIEW GRAPHICS"
686:
687: def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
688: """Enter coords"""
689: coords=self.coords
690: temco=coordstr.split(",")
691: temco.append(angle)
692: coords.append(temco)
693: self.coords=coords[0:]
694:
695: if RESPONSE is not None:
696: RESPONSE.redirect('ECHO_graphicEntry')
697:
698:
699: security.declarePublic('ECHO_collection_config')
700: def ECHO_collection_config(self):
701: """Main configuration"""
702:
703: if not hasattr(self,'weight'):
704: self.weight=""
705:
706: if not hasattr(self,'sortfield'):
707: self.sortfield="weight"
708:
709: if not hasattr(self,'coords'):
710: self.coords=[]
711:
712: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)
713: return pt()
714:
715:
716: security.declarePublic('changeECHO_collection')
717:
718:
719: def getBgcolour(self):
720: """colour"""
721: if hasattr(self,'bgcolour') and not (self.bgcolour==""):
722: return self.bgcolour
723: else:
724: return "#dddddd"
725:
726: def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour=""):
727: """Änderung der Properties"""
728:
729: self.secondaryLink=secondaryLink
730: self.secondaryLinkTitle=secondaryLinkTitle
731: self.imageTag=imageTag
732: self.bgcolour=bgcolour
733:
734: if coords:
735: coordsnew=[ string.split(x,",") for x in coords]
736: self.coords=coordsnew[0:]
737: else:
738: coordsnew=None
739: self.coords=None
740:
741: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
742:
743:
744:
745: self.sortfield=sortfield
746:
747: if RESPONSE is not None:
748: RESPONSE.redirect('manage_main')
749:
750: security.declarePublic('index_html')
751:
752:
753: def showOverview(self):
754: """overview"""
755: if 'ECHO_overview.html' in self.__dict__.keys():
756: return getattr(self,'ECHO_overview.html')()
757: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
758: return pt()
759:
760:
761: def index_html(self):
762: """standard page"""
763:
764: if 'index.html' in self.__dict__.keys():
765: return getattr(self,'index.html')()
766:
767: elif 'overview' in self.__dict__.keys():
768: return self.showOverview()
769: elif hasattr(self,'collection_index_template'):
770: return self.collection_index_template()
771:
772: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_standard.zpt').__of__(self)
773: pt.content_type="text/html"
774: return pt()
775:
776: def content_html(self):
777: """template fuer content"""
778: return content_html(self,'collection')
779:
780: def getCredits(self):
781: """Ausgabe der credits"""
782: if self.credits:
783: return self.credits
784: else:
785: return []
786:
787:
788:
789: def getGraphicCoords(self):
790: """Give list of coordinates"""
791: subColTypes=['ECHO_collection','ECHO_externalLink','ECHO_resource']
792: ids=[]
793: for entry in self.__dict__.keys():
794: object=getattr(self,entry)
795: try:
796: if object.meta_type in subColTypes:
797: for coordtemp in object.coords:
798: if len(coordtemp)>3:
799: coord=coordtemp[0:4]
800: if hasattr(object,'label') and not object.label=="":
801: ids.append([string.join(coord,", "),object.getId(),object.label,object])
802: elif hasattr(object,'title'):
803: if not object.title=="":
804: ids.append([string.join(coord,", "),object.getId(),object.title,object])
805: else:
806: ids.append([string.join(coord,", "),object.getId(),object.getId(),object])
807: else:
808: ids.append([string.join(coord,", "),object.getId(),object.getId(),object])
809:
810: except:
811: """nothing"""
812:
813: return ids
814:
815: def getSubCols(self,sortfield="weight"):
816:
817: subColTypes=['ECHO_group','ECHO_collection','ECHO_externalLink','ECHO_resource']
818: ids=[]
819: for entry in self.__dict__.keys():
820: object=getattr(self,entry)
821: try:
822: if object.meta_type in subColTypes:
823: ids.append(object)
824:
825: except:
826: """nothing"""
827: try:
828: sortfield=self.sortfield
829: except:
830: """nothing"""
831:
832: tmplist=[]
833: for x in ids:
834: if hasattr(x,sortfield):
835: try:
836: x=int(x)
837: except:
838: """nothing"""
839: tmp=getattr(x,sortfield)
840: else:
841: tmp=10000000
842: tmplist.append((tmp,x))
843: tmplist.sort()
844: return [x for (key,x) in tmplist]
845:
846:
847:
848:
849:
850:
851: def manage_addECHO_collectionForm(self):
852: """Add collection form"""
853: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
854: return pt()
855:
856:
857: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
858: """add a echo collection"""
859:
860:
861: newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
862:
863: self._setObject(id,newObj)
864:
865: if RESPONSE is not None:
866: RESPONSE.redirect('manage_main')
867:
868: class ECHO_group(ECHO_collection):
869: """ECHO Gruppe"""
870: meta_type="ECHO_group"
871:
872: manage_options = Folder.manage_options+(
873: {'label':'Main Config','action':'ECHO_group_config'},
874: {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
875: {'label':'Graphics','action':'ECHO_graphicEntry'},
876: )
877: def ECHO_group_config(self):
878: """Main configuration"""
879:
880: if not hasattr(self,'weight'):
881: self.weight=""
882:
883: if not hasattr(self,'sortfield'):
884: self.sortfield="weight"
885:
886: if not hasattr(self,'coords'):
887: self.coords=[]
888:
889: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
890: return pt()
891:
892: def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour=""):
893: """Änderung der Properties"""
894:
895: self.secondaryLink=secondaryLink
896: self.secondaryLinkTitle=secondaryLinkTitle
897: self.imageTag=imageTag
898: self.bgcolour=bgcolour
899:
900: if coords:
901: coordsnew=[ string.split(x,",") for x in coords]
902: self.coords=coordsnew[0:]
903: else:
904: coordsnew=None
905: self.coords=None
906:
907: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
908:
909:
910:
911: self.sortfield=sortfield
912:
913: if RESPONSE is not None:
914: RESPONSE.redirect('manage_main')
915:
916: def getLogo(self):
917: """logo ausgeben"""
918: return "ECHO_groups"
919:
920: def content_html(self):
921: """template fuer content"""
922: return content_html(self,'group')
923:
924:
925:
926: def manage_addECHO_groupForm(self):
927: """Add group form"""
928: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
929: return pt()
930:
931:
932: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
933: """add a echo group"""
934:
935:
936: newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
937:
938: self._setObject(id,newObj)
939:
940: if RESPONSE is not None:
941: RESPONSE.redirect('manage_main')
942:
943:
944:
945: class ECHO_root(Folder,Persistent,Implicit):
946: """ECHO Root Folder"""
947: meta_type="ECHO_root"
948:
949: def getBgcolour(self):
950: """hack"""
951: return "#dddddd"
952:
953: def contentTypeSelector_HTML(self,selected=None):
954: """give type selector"""
955: if not selected:
956: retStr="<option selected>\n"
957: else:
958: retStr="<option>\n"
959:
960: try:
961: for contentType in self.ZopeFind(self.contentTypes,obj_metatypes="ECHO_contentType"):
962: if selected and (contentType[0]==selected):
963: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
964: else:
965: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
966: except:
967: """nothing"""
968: return retStr
969:
970: def patchContentType(self,obj=None):
971: """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
972:
973:
974: if not obj:
975: obj = self
976:
977: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
978:
979: for entry in entries:
980: setattr(entry[1],'contentType',entry[1].content_type)
981: #entry[1].contentType == entry[1].content_type
982:
983: if entry[1].meta_type == 'ECHO_collection':
984: entry[1].patchContentType(entry[1])
985:
986:
987: return "Rerenderd all links to resources in: "+self.title
988:
989: def ECHO_newViewerLink(self,obj=None):
990: """change links (:86 faellt weg)"""
991:
992: if not obj:
993: obj = self
994:
995: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
996:
997: for entry in entries:
998:
999: if entry[1].meta_type == 'ECHO_resource':
1000:
1001: entry[1].link=re.sub('\:86','',entry[1].link)
1002:
1003: else:
1004:
1005: entry[1].ECHO_newViewerLink(entry[1])
1006:
1007: return "Rerenderd all links to resources in: "+self.title
1008:
1009: def __init__(self,id,title):
1010: """init"""
1011: self.id = id
1012: self.title=title
1013:
1014: def deleteSpace(self,str):
1015: """delete space at the end of a line"""
1016: if str[len(str)-1]==" ":
1017: return str[0:len(str)-1]
1018: else:
1019: return str
1020:
1021:
1022:
1023: # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
1024:
1025: def formatAscii(self,str,url=None):
1026: """ersetze ascii umbrueche durch <br>"""
1027: #url=None
1028: if url:
1029:
1030: retStr=""
1031: words=str.split("\n")
1032:
1033: for word in words:
1034: strUrl=url%word
1035: print "str",strUrl
1036: retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
1037: str=retStr
1038: if str:
1039: return re.sub(r"[\n]","<br/>",str)
1040: else:
1041: return ""
1042:
1043: def link2html(self,str):
1044: """link2html fuer VLP muss hier noch raus"""
1045: if str:
1046: print str
1047: str=re.sub("\&","&",str)
1048: dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")
1049: links=dom.getElementsByTagName("link")
1050:
1051: print "link",links
1052: for link in links:
1053: link.tagName="a"
1054: ref=link.getAttribute("ref")
1055: if self.checkRef(ref):
1056: link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
1057:
1058: return dom.toxml('utf-8')
1059: return ""
1060:
1061:
1062: def checkRef(self,ref):
1063: dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}
1064: res=None
1065: for db in dbs.keys():
1066: #print ref,"select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])
1067:
1068: res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
1069: return res
1070:
1071: #Ende Methode fuer vlp
1072:
1073: def PgQuoteString(self,string):
1074: """Quote string"""
1075: #print "PG",string
1076: return libpq.PgQuoteString(string)
1077:
1078: def getPartners(self):
1079: """Get list of Partners. Presently only from a subfolder partners"""
1080:
1081: return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
1082:
1083:
1084:
1085:
1086:
1087: def getPartnersXML(self):
1088: """partner liste als xml"""
1089: partners=self.getPartners()
1090: ret="<partners>"
1091: for partner in partners:
1092: ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
1093:
1094: return ret+"\n</partners>"
1095:
1096: def getCollectionTree(self):
1097: """get the collection tree (list of triples (parent,child, depth)"""
1098:
1099: def getCollection(object,depth=0):
1100: depth+=1
1101: collections=[]
1102: for entry in object.__dict__.keys():
1103: element=getattr(object,entry)
1104: try:
1105: if element.meta_type=="ECHO_collection":
1106: collections.append((object,element,depth))
1107: collections+=getCollection(element,depth)
1108: except:
1109: """nothing"""
1110: return collections
1111:
1112:
1113: return getCollection(self)
1114:
1115: def getCollectionTreeIds(self):
1116: """Show the IDs of the Tree"""
1117: ret=[]
1118: for collection in self.getCollectionTree():
1119: ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
1120: return ret
1121:
1122:
1123:
1124: def manage_addECHO_root(self,id,title,RESPONSE=None):
1125: """Add an ECHO_root"""
1126: self._setObject(id,ECHO_root(id,title))
1127:
1128: if RESPONSE is not None:
1129: RESPONSE.redirect('manage_main')
1130:
1131: def manage_addECHO_rootForm(self):
1132: """Nothing yet"""
1133: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
1134: return pt()
1135:
1136: class ECHO_partner(Image,Persistent):
1137: """ECHO Partner"""
1138:
1139: meta_type="ECHO_partner"
1140:
1141: def __init__(self, id, title,url, file, content_type='', precondition=''):
1142: self.__name__=id
1143: self.title=title
1144: self.url=url
1145: self.precondition=precondition
1146:
1147: data, size = self._read_data(file)
1148: content_type=self._get_content_type(file, data, id, content_type)
1149: self.update_data(data, content_type, size)
1150:
1151: manage_options = Image.manage_options+(
1152: {'label':'Partner Information','action':'ECHO_partner_config'},
1153: )
1154:
1155: def changeECHO_partner(self,url,RESPONSE=None):
1156: """Change main information"""
1157: self.url=url
1158: if RESPONSE is not None:
1159: RESPONSE.redirect('manage_main')
1160:
1161:
1162:
1163: def ECHO_partner_config(self):
1164: """Main configuration"""
1165: if not hasattr(self,'url'):
1166: self.url=""
1167: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)
1168: return pt()
1169:
1170:
1171: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
1172: Kind='ECHO_partner',kind='ECHO_partner')
1173:
1174:
1175:
1176: def manage_addECHO_partner(self, id, file,url, title='', precondition='', content_type='',
1177: REQUEST=None):
1178: """
1179: Add a new ECHO_partner object.
1180:
1181: Creates a new ECHO_partner object 'id' with the contents of 'file'.
1182: Based on Image.manage_addImage
1183: """
1184:
1185: id=str(id)
1186: title=str(title)
1187: content_type=str(content_type)
1188: precondition=str(precondition)
1189:
1190: id, title = OFS.Image.cookId(id, title, file)
1191:
1192: self=self.this()
1193:
1194: # First, we create the image without data:
1195: self._setObject(id, ECHO_partner(id,title,url,'',content_type, precondition))
1196:
1197: # Now we "upload" the data. By doing this in two steps, we
1198: # can use a database trick to make the upload more efficient.
1199: if file:
1200: self._getOb(id).manage_upload(file)
1201: if content_type:
1202: self._getOb(id).content_type=content_type
1203:
1204: if REQUEST is not None:
1205: try: url=self.DestinationURL()
1206: except: url=REQUEST['URL1']
1207: REQUEST.RESPONSE.redirect('%s/manage_main' % url)
1208: return id
1209:
1210:
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