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