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