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