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 == referenceType:
697: #print "OK"
698: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
699: bibdata['data']=referenceTypeF[1]
700: self.fields=bibdata[referenceType]
701: for field in fieldlist:
702: retdata[field]=referenceTypeF[1].getValue(field)[1]
703: #print retdata,fieldlist
704: return retdata,fieldlist
705:
706: def findTagsFromMapping(self,referenceType):
707: """gib hash mit label -> generic zurueck"""
708: self.referencetypes=self.ZopeFind(self.standardMD)
709:
710:
711: bibdata={}
712: retdata={}
713: fieldlist=self.standardMD.fieldList
714:
715: for referenceTypeF in self.referencetypes:
716:
717: if referenceTypeF[1].title == referenceType:
718: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
719: bibdata['data']=referenceTypeF[1]
720: self.fields=bibdata[referenceType]
721: for field in fieldlist:
722: retdata[field]=referenceTypeF[1].getValue(field)[0]
723:
724: return retdata,fieldlist
725:
726:
727:
728:
729: def ECHO_getResourceMD(self,template="yes"):
730: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
731: (metadict, error)=readMetadata(self.metalink)
732:
733:
734:
735: if not error=="": #Fehler beim Auslesen des Metafiles
736: return "ERROR:",error
737:
738:
739: if not (metadict['bib_type']==self.contentType):
740: self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
741: self.REQUEST.SESSION['contentZope']=self.contentType
742:
743: return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()
744:
745: self.REQUEST.SESSION['metadict']=metadict
746:
747: self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
748:
749:
750: if template=="yes":
751: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
752: return pt()
753:
754:
755:
756:
757: def ECHO_getMD(self,item):
758: """Ausgabe der MD"""
759: return getattr(self,item)
760:
761: def index_html(self):
762: """standard page"""
763:
764: return self.REQUEST.RESPONSE.redirect(self.link)
765:
766: def generate_label(self):
767: """Erzeugt_standard_Label aus Template"""
768: pt=getattr(self,"label_template_"+self.bib_type)
769:
770: return pt()
771:
772: def manage_addECHO_resourceForm(self):
773: """Form for adding a ressource"""
774: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
775: return pt()
776:
777:
778:
779: def manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
780: """addaresource"""
781:
782: newObj=ECHO_resource(id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords)
783:
784: self._setObject(id,newObj)
785:
786: if RESPONSE is not None:
787: RESPONSE.redirect('manage_main')
788:
789:
790: class ECHO_externalLink(Folder):
791: """Link zu einer externen Ressource"""
792: security=ClassSecurityInfo()
793: meta_type='ECHO_externalLink'
794:
795: def getTitle(self):
796: """title"""
797: return self.title.encode('utf-8')
798:
799: def getLabel(self):
800: """title"""
801: return self.label.encode('utf-8')
802:
803: def content_html(self):
804: """template fuer content"""
805: return content_html(self,'externalLink')
806:
807: def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
808:
809: self.id = id
810: """Festlegen der ID"""
811:
812: self.credits=toList(credits)
813: self.label = label
814: self.link= link
815: self.title=title
816: self.weight=weight
817: self.description=description
818: self.contentType=contentType
819: self.responsible=responsible
820: coordsnew=[ string.split(x,",") for x in coords]
821: self.coords=coordsnew
822:
823: def ECHO_externalLink_config(self):
824: """Main configuration"""
825:
826: if not hasattr(self,'weight'):
827: self.weight=""
828: if not hasattr(self,'coords'):
829:
830: self.coords=['']
831: #print "G",self.coords
832:
833: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)
834: return pt()
835:
836:
837: def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
838:
839: """Änderung der Properties"""
840: try:
841: coordsnew=[ string.split(x,",") for x in coords]
842: except:
843: coordsnew=[]
844:
845: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
846:
847: self.coords=coordsnew[0:]
848: self.link=link
849: if RESPONSE is not None:
850: RESPONSE.redirect('manage_main')
851:
852:
853: manage_options = Folder.manage_options+(
854: {'label':'Main Config','action':'ECHO_externalLink_config'},
855: )
856:
857: def getCredits(self):
858: """Ausgabe der credits"""
859: if self.credits:
860: return self.credits
861: else:
862: return []
863:
864: def index_html(self):
865: """standard page"""
866:
867: return self.REQUEST.RESPONSE.redirect(self.link)
868:
869: def manage_addECHO_externalLinkForm(self):
870: """Form for external Links"""
871: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)
872: return pt()
873:
874:
875: def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
876: """Add an external Link"""
877:
878: newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
879:
880: self._setObject(id,newObj)
881:
882: if RESPONSE is not None:
883: RESPONSE.redirect('manage_main')
884:
885:
886: class ECHO_link(ECHO_externalLink):
887: """external_link"""
888:
889: meta_type="ECHO_link"
890:
891:
892: def content_html(self):
893: """template fuer link"""
894: if hasattr(self,"link_template"):
895: return content_html(self,'link')
896: else:
897: return content_html(self,'collection')
898:
899: def manage_addECHO_linkForm(self):
900: """Form for external Links"""
901: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)
902: return pt()
903:
904:
905: def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
906: """Add an external Link"""
907:
908: newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
909:
910: self._setObject(id,newObj)
911:
912: if RESPONSE is not None:
913: RESPONSE.redirect('manage_main')
914:
915:
916: class ECHO_collection(Folder, Persistent, Implicit):
917: """ECHO Collection"""
918:
919: security=ClassSecurityInfo()
920: meta_type='ECHO_collection'
921: viewClassificationList=viewClassificationListMaster
922: displayTypes=displayTypes
923:
924: def getViewClassification(self):
925: if hasattr(self,'viewClassification'):
926: return self.viewClassification
927: else:
928: return ""
929:
930: def getTitle(self):
931: """title"""
932: return self.title.encode('utf-8')
933:
934: def getLabel(self):
935: """title"""
936: return self.label.encode('utf-8')
937:
938:
939:
940: def createRessourcesFromXMLForm(self):
941: """form"""
942: pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)
943: return pt()
944:
945: def createRessourcesFromXML(self,fileupload):
946: """read an XML file for generating resources"""
947: dom=xml.dom.minidom.parse(fileupload)
948: ret="<h2>Added</h2>"
949: for resource in dom.getElementsByTagName('resource'):
950: link=getText(resource.getElementsByTagName('link')[0].childNodes)
951: label=getText(resource.getElementsByTagName('label')[0].childNodes)
952: #splitted=link.split("?")[0].split("/")
953: #id=splitted[len(splitted)-1].encode('ascii')
954: id=re.sub(" ","_",label).encode('ascii')
955:
956: ret+="<p>"+label+"</p>"
957: manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")
958: return ret
959: def getImageTag(self):
960: """GetTag"""
961: try:
962: return self.imageTag
963: except:
964: return ""
965:
966: def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
967: """SSS"""
968: try:
969: manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
970: return "done"
971: except:
972: return None
973:
974: def getSecondaryLink(self):
975: """secondary link"""
976: try:
977: return self.secondaryLink
978: except:
979: return ""
980:
981: def getSecondaryLinkTitle(self):
982: """secondary link"""
983: try:
984: return self.secondaryLinkTitle
985: except:
986: return ""
987:
988: def getCollectionTreeXML(self):
989: """Tree as XML"""
990:
991: def getCollection(object,depth=0):
992: depth+=1
993: collections=""
994: for entry in object.__dict__.keys():
995: element=getattr(object,entry)
996: try:
997: if element.meta_type in ["ECHO_collection","ECHO_group"]:
998: collections+="<element name=\""+quote(element.title)+"\" url=\""+element.absolute_url()+"\">"
999: collections+=getCollection(element,depth)+"</element>\n"
1000: except:
1001: """nothing"""
1002: return collections
1003:
1004: ret="""<?xml version="1.0" encoding="utf-8" ?>"""
1005: return ret+"<collection>"+getCollection(self)+"</collection>"
1006:
1007: def createJavaScript(self):
1008: """CreateJava"""
1009: ret=javaScriptMain
1010:
1011: dynamical="\n"
1012: for ob in self.getGraphicCoords():
1013: if ob[4][4] == "":
1014: dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
1015: else:
1016: dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])
1017: dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])
1018: ret+=javaHandler%dynamical
1019: return ret
1020:
1021: def createJSAreas(self):
1022: """new version of createJavaScript"""
1023: dynamical="\n"
1024: for ob in self.getGraphicCoords():
1025: if ob[5] == "area":
1026: dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])
1027: else:
1028: dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])
1029: return dynamical
1030:
1031: def createMapHead(self):
1032: """generate divs"""
1033: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)
1034: return pt()
1035:
1036: def createMapLink(self, ob, text=None):
1037: """generate map link"""
1038: id = ob[1]
1039: link = ob[1]
1040: if text == None:
1041: text = ob[2]
1042: tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
1043: if ob[3].contentType == 'text-popup':
1044: tag += ' title="%s"'%ob[3].description
1045: tag += ">" + text + "</a>"
1046: return tag
1047:
1048: def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):
1049: """generate map link image, text and other stuff"""
1050: id = ob[1]
1051: link = ob[1]
1052: vtype = ob[5]
1053: ctype = ob[3].contentType
1054:
1055: tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)
1056: if vtype == "view point":
1057: rot = ob[4][4]
1058: tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none" />'%(id,arrowsrc,rot)
1059: else:
1060: tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none"'%(id)
1061: if ctype == "text-popup":
1062: desc = ob[3].description
1063: tag += ' title="%s"'%desc
1064: tag += ' />'
1065: tag += '</a>'
1066: return tag
1067:
1068:
1069: security.declarePublic('getCreditObject')
1070: def getCreditObject(self,name):
1071: """credit id to credititem"""
1072: try:
1073: return getattr(self.partners,name)
1074: except:
1075: return ""
1076:
1077: security.declarePublic('ECHO_generateNavBar')
1078: def ECHO_generateNavBar(self):
1079: """Erzeuge Navigationsbar"""
1080: link=""
1081: object="self"
1082: ret=[]
1083: path=self.getPhysicalPath()
1084: for element in path:
1085:
1086:
1087: if not element=="":
1088: object+="."+element
1089:
1090: label=eval(object).label
1091: link+="/"+element
1092: if not label=="":
1093: ret.append((label,link))
1094: return ret
1095:
1096: security.declarePublic('ECHO_rerenderLinksMD')
1097:
1098: def ECHO_rerenderLinksMD(self,obj=None):
1099: """Rerender all Links"""
1100: if not obj:
1101: obj = self
1102:
1103: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
1104:
1105: for entry in entries:
1106: if entry[1].meta_type == 'ECHO_resource':
1107: entry[1].ECHO_getResourceMD(template="no")
1108: #print "rerender",entry[1].getId()
1109: else:
1110: self.ECHO_rerenderLinksMD(entry[1])
1111:
1112:
1113:
1114: return "Rerenderd all links to resources in: "+self.title
1115:
1116: security.declarePublic('ECHO_newViewerLink')
1117:
1118:
1119: def getCoords(self):
1120: try:
1121:
1122: x= [string.join(x,",") for x in self.coords]
1123: return x
1124:
1125: except:
1126:
1127: return []
1128:
1129: def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
1130: #print "CO",coords
1131:
1132: self.id = id
1133: """Festlegen der ID"""
1134: self.credits=toList(credits)
1135: self.label = label
1136: self.title=title
1137: self.description=description
1138: self.contentType=contentType
1139: self.responsible=responsible
1140: self.imageTag=imageTag
1141: self.weight=weight
1142: self.sortfield=sortfield
1143: coordsnew=[ string.split(x,",") for x in coords]
1144: self.coords=coordsnew
1145: self.secondaryLinkTitle=secondaryLinkTitle
1146: self.secondaryLink=secondaryLink
1147: self.bgcolour=bgcolour
1148:
1149:
1150: manage_options = Folder.manage_options+(
1151: {'label':'Main Config','action':'ECHO_collection_config'},
1152: {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
1153: {'label':'Graphics','action':'ECHO_graphicEntry'},
1154: {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
1155:
1156: )
1157:
1158: def getOverview(self):
1159: """overview graphics"""
1160:
1161: return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
1162:
1163:
1164: def ECHO_graphicEntry(self):
1165: """DO nothing"""
1166: overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
1167:
1168:
1169: if overview:
1170: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
1171: return pt()
1172: else:
1173: return "NO OVERVIEW GRAPHICS"
1174:
1175: def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
1176: """Enter coords"""
1177: coords=self.coords
1178: temco=coordstr.split(",")
1179: temco.append(angle)
1180: coords.append(temco)
1181: self.coords=coords[0:]
1182:
1183: if RESPONSE is not None:
1184: RESPONSE.redirect('ECHO_graphicEntry')
1185:
1186:
1187: security.declarePublic('ECHO_collection_config')
1188: def ECHO_collection_config(self):
1189: """Main configuration"""
1190:
1191: if not hasattr(self,'weight'):
1192: self.weight=""
1193:
1194: if not hasattr(self,'sortfield'):
1195: self.sortfield="weight"
1196:
1197: if not hasattr(self,'coords'):
1198: self.coords=[]
1199:
1200: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)
1201: return pt()
1202:
1203:
1204: security.declarePublic('changeECHO_collection')
1205:
1206:
1207: def getBgcolour(self):
1208: """colour"""
1209: if hasattr(self,'bgcolour') and not (self.bgcolour==""):
1210: return self.bgcolour
1211: else:
1212: return "#dddddd"
1213:
1214: def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",viewClassification=None):
1215: """Aenderung der Properties"""
1216:
1217: self.secondaryLink=secondaryLink
1218: self.secondaryLinkTitle=secondaryLinkTitle
1219: self.imageTag=imageTag
1220: self.bgcolour=bgcolour
1221: self.viewClassification=viewClassification
1222:
1223: if coords:
1224: coordsnew=[ string.split(x,",") for x in coords]
1225: self.coords=coordsnew[0:]
1226: else:
1227: coordsnew=None
1228: self.coords=None
1229:
1230: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
1231: try:
1232: self.coords=coordsnew[0:] # HACK fehler in setECHO_collection
1233: except:
1234: """none"""
1235:
1236: self.sortfield=sortfield
1237:
1238: if RESPONSE is not None:
1239: RESPONSE.redirect('manage_main')
1240:
1241: security.declarePublic('index_html')
1242:
1243:
1244: def showOverview(self):
1245: """overview"""
1246: if 'ECHO_overview.html' in self.__dict__.keys():
1247: return getattr(self,'ECHO_overview.html')()
1248: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
1249: return pt()
1250:
1251: security.declareProtected('View','index_html')
1252:
1253: def index_html(self):
1254: """standard page"""
1255:
1256: if 'index.html' in self.__dict__.keys():
1257: return getattr(self,'index.html')()
1258:
1259: elif 'overview' in self.__dict__.keys():
1260: return self.showOverview()
1261: elif hasattr(self,'collection_index_template'):
1262: return self.collection_index_template()
1263: elif hasattr(self,'main_index_template'):
1264: return self.main_index_template()
1265:
1266: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
1267: pt.content_type="text/html"
1268: return pt()
1269:
1270: def content_html(self):
1271: """template fuer content"""
1272: return content_html(self,'collection')
1273:
1274: def getCredits(self):
1275: """Ausgabe der credits"""
1276: if self.credits:
1277: return self.credits
1278: else:
1279: return []
1280:
1281: def area_img(self):
1282: """area image"""
1283: return sendFile(self, 'images/red.gif', 'image/gif')
1284:
1285: def hl_lib_js(self):
1286: """javascript"""
1287: return sendFile(self, 'js/hl_lib.js', 'text/plain')
1288:
1289: def js_lib_js(self):
1290: """javascript"""
1291: return sendFile(self, 'js/js_lib.js', 'text/plain')
1292:
1293: def getGraphicCoords(self):
1294: """Give list of coordinates"""
1295: subColTypes=['ECHO_collection','ECHO_resource']
1296: ids=[]
1297: for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):
1298: object=entrySearch[1]
1299: if hasattr(object,'coords'):
1300: for coordtemp in object.coords:
1301: if len(coordtemp)>3:
1302: coord=coordtemp[0:4]
1303: label=""
1304: vc=""
1305: if hasattr(object,'label') and not object.label=="":
1306: label=object.label
1307: elif hasattr(object,'title') and not object.title=="":
1308: label=object.title
1309: else:
1310: label=object.getId()
1311: if object.viewClassification != "":
1312: vc=object.viewClassification
1313: else:
1314: if len(coordtemp) > 4 and coordtemp[4] != "":
1315: vc="view point"
1316: else:
1317: vc="area"
1318: ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,vc])
1319: return ids
1320:
1321:
1322:
1323:
1324: getSubCols = ECHO_helpers.getSubCols
1325:
1326: Globals.InitializeClass(ECHO_collection)
1327:
1328: def manage_addECHO_collectionForm(self):
1329: """Add collection form"""
1330: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
1331: return pt()
1332:
1333:
1334: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
1335: """add a echo collection"""
1336:
1337:
1338: newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
1339:
1340: self._setObject(id,newObj)
1341:
1342: if RESPONSE is not None:
1343: RESPONSE.redirect('manage_main')
1344:
1345: class ECHO_group(ECHO_collection):
1346: """ECHO Gruppe"""
1347: security=ClassSecurityInfo()
1348: meta_type="ECHO_group"
1349:
1350: manage_options = Folder.manage_options+(
1351: {'label':'Main Config','action':'ECHO_group_config'},
1352: {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
1353: {'label':'Graphics','action':'ECHO_graphicEntry'},
1354: )
1355:
1356: security.declareProtected('View','index_html')
1357: def index_html(self):
1358: """standard page"""
1359: displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
1360: #if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
1361: # return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
1362:
1363: if 'index.html' in self.__dict__.keys():
1364: return getattr(self,'index.html')()
1365:
1366: elif 'overview' in self.__dict__.keys():
1367: return self.showOverview()
1368: elif hasattr(self,'group_index_template'):
1369: return self.group_index_template()
1370: elif hasattr(self,'collection_index_template'):
1371: return self.collection_index_template()
1372: elif hasattr(self,'main_index_template'):
1373: return self.main_index_template()
1374:
1375: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
1376: pt.content_type="text/html"
1377: return pt()
1378:
1379: def ECHO_group_config(self):
1380: """Main configuration"""
1381:
1382: if not hasattr(self,'weight'):
1383: self.weight=""
1384:
1385: if not hasattr(self,'sortfield'):
1386: self.sortfield="weight"
1387:
1388: if not hasattr(self,'coords'):
1389: self.coords=[]
1390:
1391: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
1392: return pt()
1393:
1394: def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
1395: """Änderung der Properties"""
1396:
1397: self.secondaryLink=secondaryLink
1398: self.secondaryLinkTitle=secondaryLinkTitle
1399: self.imageTag=imageTag
1400: self.bgcolour=bgcolour
1401: self.logo=logo
1402:
1403: if coords:
1404: coordsnew=[ string.split(x,",") for x in coords]
1405: self.coords=coordsnew[0:]
1406: else:
1407: coordsnew=None
1408: self.coords=None
1409:
1410: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
1411:
1412:
1413:
1414: self.sortfield=sortfield
1415:
1416: if RESPONSE is not None:
1417: RESPONSE.redirect('manage_main')
1418:
1419: def getLogo(self):
1420: """logo ausgeben"""
1421: try:
1422: return self.logo
1423: except:
1424: return "ECHO_groups"
1425:
1426: def content_html(self):
1427: """template fuer content"""
1428: return content_html(self,'group')
1429:
1430:
1431:
1432: def manage_addECHO_groupForm(self):
1433: """Add group form"""
1434: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
1435: return pt()
1436:
1437:
1438: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
1439: """add a echo group"""
1440:
1441:
1442: newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
1443:
1444: setattr(newObj,'logo',logo)
1445: self._setObject(id,newObj)
1446:
1447: if RESPONSE is not None:
1448: RESPONSE.redirect('manage_main')
1449:
1450: Globals.InitializeClass(ECHO_group)
1451:
1452:
1453: class ECHO_userFolder(UserFolder):
1454: """User folder for Intranet"""
1455: _domain_auth_mode=1 # Identification via domain
1456: meta_type="ECHO_userFolder"
1457:
1458: def authenticate(self, name, password, request):
1459: emergency = self._emergency_user
1460: if name is None:
1461: return None
1462: if emergency and name==emergency.getUserName():
1463: user = emergency
1464: else:
1465: user = self.getUser(name)
1466: if user is not None and user.authenticate(password, request):
1467: return user
1468: else:
1469: return None
1470:
1471: def domainSpecMatch(self,spec, request):
1472: host=''
1473: addr=''
1474:
1475: # Fast exit for the match-all case
1476: if len(spec) == 1 and spec[0] == '*':
1477: return 1
1478:
1479: if request.has_key('REMOTE_HOST'):
1480: host=request['REMOTE_HOST']
1481:
1482: if request.has_key('REMOTE_ADDR'):
1483: addr=request['REMOTE_ADDR']
1484:
1485: if request.has_key('HTTP_X_FORWARDED_FOR'):
1486: addr=request['HTTP_X_FORWARDED_FOR']
1487:
1488:
1489: if not host and not addr:
1490: return 0
1491:
1492: if not host:
1493: try: host=socket.gethostbyaddr(addr)[0]
1494: except: pass
1495: if not addr:
1496: try: addr=socket.gethostbyname(host)
1497: except: pass
1498:
1499:
1500: _host=host.split('.')
1501: _addr=addr.split('.')
1502: _hlen=len(_host)
1503: _alen=len(_addr)
1504:
1505: for ob in spec:
1506: sz=len(ob)
1507: _ob=ob.split('.')
1508: _sz=len(_ob)
1509:
1510: mo = addr_match(ob)
1511: if mo is not None:
1512: if mo.end(0)==sz:
1513: fail=0
1514: for i in range(_sz):
1515: a=_addr[i]
1516: o=_ob[i]
1517: if (o != a) and (o != '*'):
1518: fail=1
1519: break
1520: if fail:
1521: continue
1522: return 1
1523:
1524: mo = host_match(ob)
1525: if mo is not None:
1526: if mo.end(0)==sz:
1527: if _hlen < _sz:
1528: continue
1529: elif _hlen > _sz:
1530: _item=_host[-_sz:]
1531: else:
1532: _item=_host
1533: fail=0
1534: for i in range(_sz):
1535: h=_item[i]
1536: o=_ob[i]
1537: if (o != h) and (o != '*'):
1538: fail=1
1539: break
1540: if fail:
1541: continue
1542: return 1
1543: return 0
1544:
1545: Globals.default__class_init__(ECHO_userFolder)
1546:
1547:
1548:
1549: def manage_addECHO_userFolder(self,dtself=None,REQUEST=None,**ignored):
1550: """add a user folder """
1551: f=ECHO_userFolder()
1552: self=self.this()
1553: try: self._setObject('acl_users', f)
1554: except: return MessageDialog(
1555: title ='Item Exists',
1556: message='This object already contains a User Folder',
1557: action ='%s/manage_main' % REQUEST['URL1'])
1558: self.__allow_groups__=f
1559: if REQUEST is not None:
1560: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
1561:
1562: def manage_addECHO_userFolderForm(self):
1563: """add a user folder form"""
1564: return manage_addECHO_userFolder(self)
1565:
1566: class ECHO_root(Folder,Persistent,Implicit):
1567: """ECHO Root Folder"""
1568:
1569: security=ClassSecurityInfo()
1570:
1571: meta_type="ECHO_root"
1572:
1573:
1574: def getImageTag(self):
1575: """needed by main_template"""
1576: return ""
1577: secondaryLink="" #needed by main_template
1578: secondaryLinkTitle="" #needed by main_template
1579:
1580: def getBgcolour(self):
1581: """hack"""
1582: return "#dddddd"
1583:
1584: def contentTypeSelector_HTML(self,selected=None):
1585: """give type selector"""
1586: if not selected:
1587: retStr="<option selected>\n"
1588: else:
1589: retStr="<option>\n"
1590:
1591: try: # erste version contentTypes exists
1592: for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
1593: if selected and (contentType[0]==selected):
1594: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
1595: else:
1596: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
1597: except:
1598: try:
1599: for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
1600: if selected and (contentType[0]==selected):
1601: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
1602: else:
1603: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
1604: except:
1605: """nothing"""
1606:
1607: return retStr
1608:
1609: def renderingTypeSelector_HTML(self,selected=None):
1610: """give type selector"""
1611: if not selected:
1612: retStr="<option selected>\n"
1613: else:
1614: retStr="<option>\n"
1615:
1616: try: # erste version renderingTypes exists
1617: for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
1618: if selected and (renderingType[0]==selected):
1619: retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
1620: else:
1621: retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
1622: except:
1623: """nothing"""
1624: return retStr
1625:
1626: def renderingTypeSelector_HTML(self,selected=None):
1627: """give type selector"""
1628: if not selected:
1629: retStr="<option selected>\n"
1630: else:
1631: retStr="<option>\n"
1632:
1633: try: # erste version renderingTypes exists
1634: for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
1635: if selected and (renderingType[0]==selected):
1636: retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
1637: else:
1638: retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
1639: except:
1640: """nothing"""
1641: return retStr
1642:
1643:
1644: def copyrightTypeSelector_HTML(self,selected=None):
1645: """give type selector"""
1646: if not selected:
1647: retStr="<option selected>\n"
1648: else:
1649: retStr="<option>\n"
1650:
1651: try: # erste version copyrightTypes exists
1652: for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
1653: if selected and (copyrightType[0]==selected):
1654: retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
1655: else:
1656: retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
1657: except:
1658: """nothing"""
1659: return retStr
1660:
1661:
1662: def patchContentType(self,obj=None):
1663: """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
1664:
1665:
1666: if not obj:
1667: obj = self
1668:
1669: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
1670:
1671: for entry in entries:
1672: setattr(entry[1],'contentType',entry[1].content_type)
1673: #entry[1].contentType == entry[1].content_type
1674:
1675: if entry[1].meta_type == 'ECHO_collection':
1676: entry[1].patchContentType(entry[1])
1677:
1678:
1679: return "changed all contenttypes in: "+self.title
1680:
1681:
1682: def patchViewClassification(self,obj=None):
1683: """setze viewClassification heuristisch"""
1684:
1685: def checkIfArrow(obj):
1686: if hasattr(obj,'coords'):
1687: for coordtemp in obj.coords:
1688: #print obj.title,len(coordtemp)
1689: if (len(coordtemp)>4) and not (coordtemp[4]==''):
1690: return 4
1691: return None
1692: return None
1693:
1694: if not obj:
1695: obj = self
1696:
1697: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
1698:
1699: for entry in entries:
1700:
1701: if checkIfArrow(entry[1]):
1702: setattr(entry[1],'viewClassification','view point')
1703: else:
1704: setattr(entry[1],'viewClassification','area')
1705:
1706: #entry[1].contentType == entry[1].content_type
1707:
1708: if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
1709: entry[1].patchViewClassification(entry[1])
1710:
1711:
1712: return "changed all contenttypes in: "+self.title
1713:
1714: def ECHO_newViewerLink(self,obj=None):
1715: """change links (:86 faellt weg)"""
1716:
1717: if not obj:
1718: obj = self
1719:
1720: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
1721:
1722: for entry in entries:
1723:
1724: if entry[1].meta_type == 'ECHO_resource':
1725:
1726: entry[1].link=re.sub('\:86','',entry[1].link)
1727:
1728: else:
1729:
1730: entry[1].ECHO_newViewerLink(entry[1])
1731:
1732: return "Rerenderd all links to resources in: "+self.title
1733:
1734: def __init__(self,id,title):
1735: """init"""
1736: self.id = id
1737: self.title=title
1738:
1739: def deleteSpace(self,str):
1740: """delete space at the end of a line"""
1741: if str[len(str)-1]==" ":
1742: return str[0:len(str)-1]
1743: else:
1744: return str
1745:
1746:
1747:
1748: # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
1749:
1750: def formatAscii(self,str,url=None):
1751: """ersetze ascii umbrueche durch <br>"""
1752: #url=None
1753: if url:
1754:
1755: retStr=""
1756: words=str.split("\n")
1757:
1758: for word in words:
1759: strUrl=url%word
1760: #print "str",strUrl
1761: retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
1762: str=retStr
1763: if str:
1764: return re.sub(r"[\n]","<br/>",str)
1765: else:
1766: return ""
1767:
1768: def link2html(self,str):
1769: """link2html fuer VLP muss hier noch raus"""
1770: if str:
1771: #print str
1772: str=re.sub("\&","&",str)
1773: dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")
1774: links=dom.getElementsByTagName("link")
1775:
1776: #print "link",links
1777: for link in links:
1778: link.tagName="a"
1779: ref=link.getAttribute("ref")
1780: if self.checkRef(ref):
1781: link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
1782:
1783: return dom.toxml('utf-8')
1784: return ""
1785:
1786:
1787: def checkRef(self,ref):
1788: dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}
1789: res=None
1790: for db in dbs.keys():
1791: #print ref,"select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])
1792:
1793: res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
1794: return res
1795:
1796: #Ende Methode fuer vlp
1797:
1798: def PgQuoteString(self,string):
1799: """Quote string"""
1800: #print "PG",string
1801: return libpq.PgQuoteString(string)
1802:
1803: def getPartners(self):
1804: """Get list of Partners. Presently only from a subfolder partners"""
1805:
1806: return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
1807:
1808:
1809:
1810:
1811:
1812: def getPartnersXML(self):
1813: """partner liste als xml"""
1814: partners=self.getPartners()
1815: ret="""<?xml version="1.0" encoding="utf-8" ?>
1816: <partners>"""
1817:
1818: for partner in partners:
1819: ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),unicode(partner.title,'utf-8','replace'))
1820:
1821: return ret+"\n</partners>"
1822:
1823: def getCollectionTree(self):
1824: """get the collection tree (list of triples (parent,child, depth)"""
1825:
1826: def getCollection(object,depth=0):
1827: depth+=1
1828: collections=[]
1829: for entry in object.__dict__.keys():
1830: element=getattr(object,entry)
1831: try:
1832: if element.meta_type=="ECHO_collection":
1833: collections.append((object,element,depth))
1834: collections+=getCollection(element,depth)
1835: except:
1836: """nothing"""
1837: return collections
1838:
1839:
1840: return getCollection(self)
1841:
1842: def getCollectionTreeIds(self):
1843: """Show the IDs of the Tree"""
1844: ret=[]
1845: for collection in self.getCollectionTree():
1846: ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
1847: return ret
1848:
1849: def getResourcesHTML(self,viewerType=None,filter=None):
1850: """gebe all ressourcen aus"""
1851:
1852: def sortHTML(x,y):
1853: return cmp(x[1].title,y[1].title)
1854:
1855: ret="""<html><body><h2>Resources in ECHO</h3>"""
1856:
1857: resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
1858: ret+="""<h3>Found %i resources</h3>"""%len(resources)
1859: resources.sort(sortHTML)
1860: for resource in resources:
1861: echo_url=resource[1].absolute_url()
1862:
1863: if hasattr(resource[1],'title'):
1864: title=resource[1].title
1865: else:
1866: title="None"
1867: if filter:
1868: if re.search(filter,title):
1869: ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
1870: else:
1871: ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
1872:
1873: ret +="""\n</body></html>"""
1874:
1875: #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
1876: #self.REQUEST.RESPONSE.write(ret)
1877: return ret
1878:
1879: def getResourcesXML(self,viewerType=None,filter=None):
1880: """gebe all ressourcen aus"""
1881: ret="""<?xml version="1.0" ?>
1882: <index>"""
1883: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
1884:
1885: echo_url=resource[1].absolute_url()
1886: if hasattr(resource[1],'link'):
1887: viewer_url=resource[1].link
1888: else:
1889: viewer_url="NO URL"
1890: if filter:
1891: if re.search(filter,viewer_url):
1892: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
1893: else:
1894: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
1895: ret +="""\n</index>"""
1896:
1897: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
1898: self.REQUEST.RESPONSE.write(ret)
1899:
1900: def getFullTextsXML(self,viewerType=None,filter=None):
1901: """gebe all ressourcen aus"""
1902: ret="""<?xml version="1.0" ?>
1903: <index>"""
1904: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
1905:
1906: echo_url=resource[1].absolute_url()
1907: if resource[1].getFullTextXML(noredirect="yes"):
1908: if hasattr(resource[1],'link'):
1909: viewer_url=echo_url+"/getFullTextXML"
1910: else:
1911: viewer_url="NO URL"
1912: if filter:
1913: if re.search(filter,viewer_url):
1914: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
1915: else:
1916: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
1917: ret +="""\n</index>"""
1918: print ret
1919:
1920: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
1921: self.REQUEST.RESPONSE.write(ret)
1922:
1923: def manage_addECHO_root(self,id,title,RESPONSE=None):
1924: """Add an ECHO_root"""
1925: self._setObject(id,ECHO_root(id,title))
1926:
1927: if RESPONSE is not None:
1928: RESPONSE.redirect('manage_main')
1929:
1930: def manage_addECHO_rootForm(self):
1931: """Nothing yet"""
1932: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
1933: return pt()
1934:
1935: class ECHO_partner(Image,Persistent):
1936: """ECHO Partner"""
1937:
1938: meta_type="ECHO_partner"
1939:
1940: def __init__(self, id, title,url, file, content_type='', precondition=''):
1941: self.__name__=id
1942: self.title=title
1943: self.url=url
1944: self.precondition=precondition
1945:
1946: data, size = self._read_data(file)
1947: content_type=self._get_content_type(file, data, id, content_type)
1948: self.update_data(data, content_type, size)
1949:
1950: manage_options = Image.manage_options+(
1951: {'label':'Partner Information','action':'ECHO_partner_config'},
1952: )
1953:
1954: def changeECHO_partner(self,url,RESPONSE=None):
1955: """Change main information"""
1956: self.url=url
1957: if RESPONSE is not None:
1958: RESPONSE.redirect('manage_main')
1959:
1960:
1961:
1962: def ECHO_partner_config(self):
1963: """Main configuration"""
1964: if not hasattr(self,'url'):
1965: self.url=""
1966: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)
1967: return pt()
1968:
1969:
1970: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
1971: Kind='ECHO_partner',kind='ECHO_partner')
1972:
1973:
1974:
1975: def manage_addECHO_partner(self, id, file,url, title='', precondition='', content_type='',
1976: REQUEST=None):
1977: """
1978: Add a new ECHO_partner object.
1979:
1980: Creates a new ECHO_partner object 'id' with the contents of 'file'.
1981: Based on Image.manage_addImage
1982: """
1983:
1984: id=str(id)
1985: title=str(title)
1986: content_type=str(content_type)
1987: precondition=str(precondition)
1988:
1989: id, title = OFS.Image.cookId(id, title, file)
1990:
1991: self=self.this()
1992:
1993: # First, we create the image without data:
1994: self._setObject(id, ECHO_partner(id,title,url,'',content_type, precondition))
1995:
1996: # Now we "upload" the data. By doing this in two steps, we
1997: # can use a database trick to make the upload more efficient.
1998: if file:
1999: self._getOb(id).manage_upload(file)
2000: if content_type:
2001: self._getOb(id).content_type=content_type
2002:
2003: if REQUEST is not None:
2004: try: url=self.DestinationURL()
2005: except: url=REQUEST['URL1']
2006: REQUEST.RESPONSE.redirect('%s/manage_main' % url)
2007: return id
2008:
2009:
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