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