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