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