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