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