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