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