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