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