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.Cache import Cacheable
18: from OFS.Image import Image
19: from Globals import DTMLFile
20: from OFS.Folder import Folder
21: from OFS.SimpleItem import SimpleItem
22: from AccessControl import ClassSecurityInfo
23: from AccessControl.User import UserFolder
24: from Globals import InitializeClass
25: from Globals import DTMLFile
26: import Globals
27: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
28: from Products.PageTemplates.PageTemplate import PageTemplate
29: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
30: from Globals import Persistent, package_home
31: from Acquisition import Implicit
32: from ECHO_helpers import displayTypes, getText,readFieldFromXML
33: import urllib
34: import smtplib
35: import time
36: from Ft.Xml.Domlette import NonvalidatingReader
37: from Ft.Xml.Domlette import PrettyPrint
38: from Ft.Xml import EMPTY_NAMESPACE
39:
40: import Ft.Xml.XPath
41: import cStringIO
42: import zLOG
43:
44: try:
45: from psycopg import libpq
46: except:
47: try:
48: from pyPgSQL import libpq
49: except:
50: print "ECHO_collection: Warning - No libpq imported!"
51:
52: import xml.dom.minidom
53:
54: import urllib
55: import xml.dom.minidom
56: from ECHO_graphicalOverview import javaHandler,javaScriptMain
57: import ECHO_helpers
58:
59: def donatus(txt2):
60: import xmlrpclib
61:
62: server = xmlrpclib.ServerProxy("http://archimedes.fas.harvard.edu/cgi-bin/donatus-rpc")
63:
64: txt=txt2.encode('utf-8')
65: bin=xmlrpclib.Binary(txt)
66:
67:
68:
69: ret=server.donatus.analyze(bin)
70:
71:
72: return ret['morphData'].data
73:
74:
75: def donatusVariant2Lemma(morphData):
76: """creates hash variant -> morphdata"""
77: ret={}
78: dom=xml.dom.minidom.parseString(morphData)
79: lemmas=dom.getElementsByTagName('lemma')
80: for lemma in lemmas:
81: variants=lemma.getElementsByTagName('variant')
82: for variant in variants:
83: atr=variant.getAttribute('form')
84: if ret.has_key(atr):
85: ret[atr].append=lemma.getAttribute('form')
86: else:
87: ret[atr]=[lemma.getAttribute('form')]
88:
89: return ret
90:
91: #regexp for extracting elements from xml
92: patternTXT=r"<\s*txt.*?>(.*?)</txt>"
93: regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL)
94: patternPage=r"<\s*page.*?>(.*?)</page>"
95: regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL)
96:
97:
98: def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
99: """Rerender all Links"""
100: ret=""
101:
102: if not obj:
103: obj = self
104:
105: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource'],search_sub=1)
106:
107: for entry in entries:
108: if entry[1].meta_type == 'ECHO_resource':
109: try:
110: entry[1].ECHO_getResourceMD(template="no")
111: if "title" in types:
112: entry[1].generate_title()
113: if "label" in types:
114: entry[1].generate_label()
115: ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"
116: except:
117: ret+="Error:"+entry[0]+"<br>"
118:
119:
120:
121:
122: return "<html><body>"+ret+"Rerenderd all links to resources in: "+self.title+"</html></body>"
123:
124: def reloadMetaDataFromStorage(self,RESPONSE=None):
125: """copy metadata from the storage to ECHO"""
126: ret=""
127: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
128:
129: for resource in resources:
130: x=str(resource[1].copyIndex_meta2echo_resource())+"<br>"
131: ret+=x
132: #print x
133:
134:
135: if RESPONSE is not None:
136: #RESPONSE.redirect('./manage_main')
137: return "<html><body>"+ret+"</html></body>"
138:
139: return ret
140:
141: def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None):
142: """rdf"""
143:
144: ret=""
145: about="""<RDF:Description RDF:about="%s">"""
146: name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""
147: link="""<ECHONAVIGATION:link xlink:href="%s">%s</ECHONAVIGATION:link>"""
148: clickable="""<ECHONAVIGATION:linkClickable>%s</ECHONAVIGATION:linkClickable>"""
149: #link="""<ECHONAVIGATION:link RDF:about="%s"/>"""
150: type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>"""
151: #xlink="""<ECHONAVIGATION:xlink xlink:href="%s"/>"""
152: if not urn:
153: #urn="urn:"+re.sub('/',':',self.absolute_url())
154: urn=self.absolute_url()
155: about2=about%urn
156: if not nameDef:
157: if hasattr(self,'label') and not (self.label==""):
158: name2=name%self.label
159: elif not self.title=="":
160: name2=name%self.title
161: else:
162: name2=name%self.getId()
163:
164: name2=re.sub('&','&',name2)
165: else:
166: name2=name%nameDef
167:
168: linkURL=re.sub('http:','',linkURL)
169: linkURL2=re.sub('&','&',linkURL)
170: link2=link%(("http:"+linkURL2),("http:"+urllib.quote(linkURL)))
171: clickable2=clickable%"true"
172:
173: if not typeName:
174: type2=type%self.meta_type
175: else:
176: type2=type%typeName
177:
178: #ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
179: ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
180: return ret
181:
182: def getCopyrightsFromForm(self,argv):
183: medias={}
184: partners={}
185: copyrights={}
186:
187: copyrightsFinal=[]
188: for arg in argv.keys():
189:
190: if arg[0:5]=='media':
191: nm=int(arg[5:])
192: medias[nm]=argv[arg]
193: elif arg[0:5]=='partn':
194: nm=int(arg[5:])
195: partners[nm]=argv[arg]
196: elif arg[0:5]=='copyr':
197: nm=int(arg[5:])
198: copyrights[nm]=argv[arg]
199:
200:
201:
202: copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()]
203: for copyright in copyrightsList:
204:
205: if copyright[2]=='institution0000':
206: copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],'')))
207: else:
208: if not copyright[0]=='':
209: copyrightsFinal.append(copyright)
210:
211:
212: return copyrightsFinal
213:
214: #List of different types for the graphical linking viewer
215: viewClassificationListMaster=['view point','area']
216:
217:
218: def checkDiffs(self,metadict):
219: """check differences"""
220:
221:
222:
223:
224: def NoneToEmpty(obj):
225: if obj:
226: return obj
227: else:
228: return ""
229:
230:
231:
232: diffs={}
233:
234: tags=self.findTagsFromMapping(self.contentType)
235: self.referencetypes=tags[2]
236: self.fields=tags[3]
237:
238:
239: for field in tags[1]:
240: try:
241: if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
242: diffs[self.getFieldTag(tags,field)]=1
243: else:
244:
245: diffs[self.getFieldTag(tags,field)]=0
246: except:
247: diffs[self.getFieldTag(tags,field)]=0
248:
249: return diffs
250:
251: def content_html(self,type):
252: """template fuer content"""
253: #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
254: #
255: #if templates:
256: # return templates[0][1]()
257:
258: if hasattr(self,type+"_template"):
259: obj=getattr(self,type+"_template")
260: return obj()
261: else:
262: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)
263: pt.content_type="text/html"
264: return pt()
265:
266: def toList(field):
267: """Einzelfeld in Liste umwandeln"""
268: if type(field)==StringType:
269: return [field]
270: else:
271: return field
272:
273:
274:
275: def getTextFromNode(nodename):
276: nodelist=nodename.childNodes
277: rc = ""
278: for node in nodelist:
279: if node.nodeType == node.TEXT_NODE:
280: rc = rc + node.data
281: return rc
282:
283: def sendFile(self, filename, type):
284: """sends an object or a local file (in the product) as response"""
285: paths = filename.split('/')
286: object = self
287: # look for an object called filename
288: for path in paths:
289: if hasattr(object, path):
290: object = getattr(object, path)
291: else:
292: object = None
293: break
294: if object:
295: # if the object exists then send it
296: return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
297: else:
298: # send a local file with the given content-type
299: fn = os.path.join(package_home(globals()), filename)
300: self.REQUEST.RESPONSE.setHeader("Content-Type", type)
301: self.REQUEST.RESPONSE.write(file(fn).read())
302: return
303:
304: class BrowserCheck:
305: """check the browsers request to find out the browser type"""
306:
307: def __init__(self, zope):
308: self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
309: self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and (string.find(self.ua, 'MSIE') < 0)
310: self.isIE = string.find(self.ua, 'MSIE') > -1
311: self.nav = self.ua[string.find(self.ua, '('):]
312: ie = string.split(self.nav, "; ")[1]
313: if string.find(ie, "MSIE") > -1:
314: self.versIE = string.split(ie, " ")[1]
315: self.isMac = string.find(self.ua, 'Macintosh') > -1
316: self.isWin = string.find(self.ua, 'Windows') > -1
317: self.isIEWin = self.isIE and self.isWin
318: self.isIEMac = self.isIE and self.isMac
319:
320:
321:
322:
323: def writeMetadata(url,metadict,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,xmlfrag=None,digiliburlprefix=None):
324: """Einlesen der Metadaten und und erstellen des geaenderten XML file"""
325:
326: def updateTextToolNode(tag,value):
327: #print dom,tag,value
328: metanode=dom.getElementsByTagName('texttool')[0]
329: try:
330: nodeOld=metanode.getElementsByTagName(tag)
331: except:
332: nodeOld=None
333:
334: if nodeOld:
335: metanode.removeChild(nodeOld[0]).unlink()
336:
337: node=dom.createElement(tag)
338: nodetext=dom.createTextNode(value)
339: node.appendChild(nodetext)
340: metanode.appendChild(node)
341:
342: if xmlfrag:
343: geturl="""<?xml version="1.0" ?>
344: <resource type="MPIWG">
345: <meta>
346: <bib type="Book">
347: </bib>
348: </meta>
349: </resource>"""
350: dom=xml.dom.minidom.parseString(geturl)
351: else:
352: try:
353: geturl=""
354: for line in ECHO_helpers.urlopen(url).readlines():
355: geturl=geturl+line
356:
357:
358: except:
359: return (None,"Cannot open: "+url)
360:
361: try:
362: dom=xml.dom.minidom.parseString(geturl)
363: except:
364: return (None,"Cannot parse: "+url+"<br>"+geturl)
365:
366:
367:
368: metanodes=dom.getElementsByTagName('bib')
369:
370: if not metanodes:
371: metanodes=dom.getElementsByTagName('archimedes')
372:
373: metanode=metanodes[0]
374:
375: for metaData in metadict.keys():
376:
377: try:
378: nodeOld=metanode.getElementsByTagName(metaData)
379: except:
380: nodeOld=None
381:
382: if nodeOld:
383: metanode.removeChild(nodeOld[0]).unlink()
384: else:
385: # try also old writing rule - instead of _:
386: try:
387: nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
388: except:
389: nodeOld=None
390:
391: if nodeOld:
392: metanode.removeChild(nodeOld[0]).unlink()
393:
394: metanodeneu=dom.createElement(metaData)
395: metanodetext=dom.createTextNode(metadict[metaData])
396: #try:
397: #metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))
398: #except:
399: #metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))
400: metanodeneu.appendChild(metanodetext)
401: metanode.appendChild(metanodeneu)
402:
403:
404:
405:
406:
407: if project:
408: updateTextToolNode('project',project)
409:
410: if startpage:
411: updateTextToolNode('startpage',startpage)
412:
413: if topbar:
414: updateTextToolNode('toptemplate',topbar)
415:
416: if thumbtemplate:
417: updateTextToolNode('thumbtemplate',thumbtemplate)
418:
419: if xslt:
420: updateTextToolNode('xslt',xslt)
421:
422:
423: if digiliburlprefix:
424: updateTextToolNode('digiliburlprefix',digiliburlprefix)
425:
426: try:
427: return dom.toxml().encode('utf-8')
428: except:
429: return dom.toxml('utf-8')
430:
431:
432:
433: def readMetadata(url):
434: """Methode zum Auslesen der Metadateninformation zu einer Resource
435: Vorerst noch Typ bib"""
436:
437: metadict={}
438: try:
439: geturl=""
440: for line in ECHO_helpers.urlopen(url).readlines():
441: geturl=geturl+line
442:
443:
444: except:
445: return (None,"Cannot open: "+url)
446:
447: try:
448: dom=xml.dom.minidom.parseString(geturl)
449: except:
450: return (None,"Cannot parse: "+url+"<br>"+geturl)
451:
452: metanode=dom.getElementsByTagName('bib')
453: metadict['bib_type']='Book'
454: if len(metanode)==0:
455: metanode=dom.getElementsByTagName('archimedes')
456: metadict['bib_type']='Archimedes'
457:
458:
459: if not len(metanode)==0:
460: metacontent=metanode[0].childNodes
461:
462: try:
463: metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
464: except:
465: """nothing"""
466:
467: for node in metacontent:
468: try:
469: #print urllib.unquote(getText(node.childNodes)),getText(node.childNodes)
470: metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))
471: except:
472: """nothing"""
473:
474:
475: return metadict,""
476:
477:
478: def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):
479:
480: """Allegemeine Informationen zu einer ECHO Collection"""
481:
482: self.viewClassification=viewClassification
483:
484: self.label = label
485: self.title=title
486: self.description=description
487: self.contentType=contentType
488: self.responsible=responsible
489: self.credits=toList(credits)
490: self.weight=weight
491:
492: coords=[]
493: #coordinates of for rectangles
494:
495:
496: if coordstrs:
497: for coordstr in coordstrs:
498:
499: try:
500: temco=coordstr.split(",")
501: except:
502: temco=[]
503:
504: coords.append(temco)
505:
506:
507: self.coords=coords[0:]
508:
509: class ECHO_copyright(Folder):
510: """Copyright informationen"""
511: meta_type="ECHO_copyright"
512:
513:
514:
515: def __init__(self,id,title,copyrights):
516: """init"""
517: self.title=title
518: self.id=id
519: self.copyrights=copyrights[0:]
520:
521: def getCopyrights(self):
522: """return coyprights"""
523: return self.copyrights
524:
525: manage_options = Folder.manage_options+(
526: {'label':'Main Config','action':'ECHO_copyright_configForm'},
527: )
528:
529:
530: def ECHO_copyright_configForm(self):
531: """change form"""
532: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_copyright').__of__(self)
533: pt.content_type="text/html"
534: return pt()
535:
536: def ECHO_copyright_config(self,title,RESPONSE=None):
537: """change"""
538: self.title=title
539: self.copyrights=[]
540: self.copyrights=getCopyrightsFromForm(self,self.REQUEST.form)[0:]
541:
542: if RESPONSE is not None:
543: RESPONSE.redirect('manage_main')
544:
545:
546: def manage_addECHO_copyrightForm(self):
547: """Form for adding"""
548: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_copyright.zpt').__of__(self)
549: return pt()
550:
551: def manage_addECHO_copyright(self, id,title,RESPONSE=None):
552: """add the copyright"""
553:
554: meta_type="ECHO_copyright"
555:
556: #first generate copyrights as list of tripels (mediaType,partner,copyrightType)
557:
558:
559:
560: self._setObject(id, ECHO_copyright(id, title,getCopyrightsFromForm(self,self.REQUEST.form)))
561:
562: if RESPONSE is not None:
563: RESPONSE.redirect('manage_main')
564:
565: class ECHO_layoutTemplate(ZopePageTemplate):
566: """Create a layout Template for different purposes"""
567:
568: meta_type="ECHO_layoutTemplate"
569:
570: def __init__(self, id, text=None, content_type=None,EchoType=None):
571: self.id = str(id)
572:
573:
574:
575: self.ZBindings_edit(self._default_bindings)
576: if text is None:
577: self._default_content_fn = os.path.join(package_home(globals()),
578: 'zpt/ECHO_%s_template_standard.zpt'%EchoType)
579: text = open(self._default_content_fn).read()
580: self.pt_edit(text, content_type)
581:
582:
583: """change form"""
584:
585:
586: def manage_addECHO_layoutTemplateForm(self):
587: """Form for adding"""
588: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddECHO_layoutTemplate.zpt')).__of__(self)
589: return pt()
590:
591: from urllib import quote
592:
593:
594: def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
595: "Add a Page Template with optional file content."
596: if type(EchoType)==StringType:
597: EchoTypes=[EchoType]
598: else:
599: EchoTypes=EchoType
600:
601: for singleType in EchoTypes:
602:
603: id = str(singleType)+"_template"
604: if REQUEST is None:
605: self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
606: ob = getattr(self, id)
607:
608: if title:
609: ob.pt_setTitle(title)
610: return ob
611: else:
612: file = REQUEST.form.get('file')
613: headers = getattr(file, 'headers', None)
614: if headers is None or not file.filename:
615: zpt = ECHO_layoutTemplate(id,EchoType=singleType)
616: else:
617: zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
618:
619: self._setObject(id, zpt)
620: ob = getattr(self, id)
621: if title:
622: ob.pt_setTitle(title)
623:
624: try:
625: u = self.DestinationURL()
626: except AttributeError:
627: u = REQUEST['URL1']
628:
629:
630: REQUEST.RESPONSE.redirect(u+'/manage_main')
631: return ''
632:
633: class ECHO_fullText(ZopePageTemplate):
634: """echo fulltext in xml"""
635:
636: meta_type="ECHO_fullText"
637:
638: def donatusVariant2Lemma(self,nr='1'):
639: """analyze by donatus"""
640: return donatusVariant2Lemma(donatus(self.lemmatize(nr)))
641:
642: def tagLex(self,nr="1"):
643: """generate Links"""
644: global retLex
645: global toggle
646:
647: toggle=0
648: retLex=""
649:
650: lemmatized=self.lemmatize(nr)[0:]
651: #print "ho",repr(lemmatized)
652: variants=donatusVariant2Lemma(donatus(lemmatized))
653:
654: def createTag(name,attrs):
655: global toggle
656:
657: if name=="w":
658: toggle=1
659: return ""
660: else:
661: tag="<"
662: tag+=name
663: for attr in attrs.keys():
664: tag+=""" %s="%s" """%(attr,attrs[attr])
665: tag+=">"
666: return tag
667:
668: def createData(data):
669: global toggle
670: astring="""<a href="http://141.14.236.86/cgi-bin/toc/dict?step=remotetable;word=%s;lang=de" target="_blank">%s</a> """
671: if toggle: # tag war ein w
672: toggle=0
673: if variants.has_key(data):
674: return astring%(variants[data][0],data)
675: else:
676: return astring%(data,data)
677:
678:
679:
680: # 3 handler functions
681: def start_element(name, attrs):
682: global retLex
683:
684: retLex+=createTag(name,attrs)
685: def end_element(name):
686: global retLex
687: if not name=="w":
688: retLex+="</%s>"%(name.encode('utf-8'))
689:
690:
691: def char_data(data):
692: global retLex
693: if data:
694: try:
695: retLex+=createData(data)
696: except:
697: """no"""
698:
699: p = xml.parsers.expat.ParserCreate()
700:
701: p.StartElementHandler = start_element
702: p.EndElementHandler = end_element
703: p.CharacterDataHandler = char_data
704:
705: p.Parse(lemmatized.encode('utf-8'),1)
706: #print repr(lemmatized.encode('utf-8'))
707:
708: return retLex
709:
710:
711: def lemmatize(self,nr='1',lang="de"):
712: """lemmatize"""
713: global ret
714: ret=""
715:
716: def createTag(name,attrs):
717: tag="<"
718: tag+=name
719: for attr in attrs.keys():
720: tag+=""" %s="%s" """%(attr,attrs[attr])
721: tag+=">"
722: return tag
723:
724: def insertW(str):
725: splitted=str.split()
726: wordlist=["<w>%s</w>"%split for split in splitted]
727: return string.join(wordlist,'\n')
728:
729: # 3 handler functions
730: def start_element(name, attrs):
731: global ret
732: ret+=createTag(name,attrs)
733: def end_element(name):
734: global ret
735: ret+="</%s>"%(name.encode('utf-8'))
736:
737: def char_data(data):
738: global ret
739: ret+=insertW(data)
740:
741: p = xml.parsers.expat.ParserCreate()
742:
743: p.StartElementHandler = start_element
744: p.EndElementHandler = end_element
745: p.CharacterDataHandler = char_data
746:
747: p.Parse(self.getPage(nr), 1)
748: txt="""<wtag locator="xxx">
749: <section lang="%s"><s>%s</s></section>
750: </wtag>"""
751: ret=txt%(lang,ret)
752:
753: return ret
754:
755: def getPage(self,nr='1'):
756: """get page n"""
757: dom=xml.dom.minidom.parseString(self())
758: pages=dom.getElementsByTagName('page')
759:
760: return pages[int(nr)-1].toxml('utf-8')
761:
762: # Product registration and Add support
763: manage_addECHO_fullTextForm = PageTemplateFile(
764: 'zpt/AddECHO_fullText.zpt', globals())
765:
766: from urllib import quote
767:
768: def manage_addECHO_fullText(self, id, title=None, text=None,
769: REQUEST=None, submit=None):
770: "Add a Page Template with optional file content."
771:
772: id = str(id)
773: if REQUEST is None:
774: self._setObject(id, ECHO_fullText(id, text))
775: ob = getattr(self, id)
776: if title:
777: ob.pt_setTitle(title)
778: return ob
779: else:
780: file = REQUEST.form.get('file')
781: headers = getattr(file, 'headers', None)
782: if headers is None or not file.filename:
783: zpt = ECHO_fullText(id)
784: else:
785: zpt = ECHO_fullText(id, file, headers.get('content_type'))
786:
787: self._setObject(id, zpt)
788:
789: try:
790: u = self.DestinationURL()
791: except AttributeError:
792: u = REQUEST['URL1']
793:
794: if submit == " Add and Edit ":
795: u = "%s/%s" % (u, quote(id))
796: REQUEST.RESPONSE.redirect(u+'/manage_main')
797: return ''
798:
799: class ECHO_resource(Folder,Persistent):
800: """ECHO Ressource"""
801: security=ClassSecurityInfo()
802: meta_type='ECHO_resource'
803:
804: viewClassificationList=viewClassificationListMaster
805:
806: getSubCols = ECHO_helpers.getSubCols
807:
808: security.declareProtected('View','index_html')
809:
810: def showRDF(self):
811: """showrdf"""
812: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
813: ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""
814: ret+=self.getRDF(urn="echo:colllectionroot")+"\n"
815:
816: ret+="""</RDF:RDF>"""
817: return ret
818:
819: def getRDF(self,urn=None):
820: """rdf"""
821: ret=getRDFDescription(self,self.link,urn=urn)
822: return ret+self.createSubElementRDF(urn=urn)
823:
824:
825: def createSubElementRDF(self,urn=None):
826: """rdf list"""
827: if not urn:
828: urn=self.absolute_url()
829: ret=""
830:
831: rettemp="""<RDF:Seq RDF:about="%s">\n"""%urn
832: flag=0
833:
834: li="""<RDF:li RDF:resource="%s" />\n"""
835: if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
836: nurn=self.absolute_url()+'/getFullTextXML'
837: rettemp+=li%nurn
838: flag=1
839: if not ('<error>' in self.getImageView(noredirect='Yes')):
840: nurn=self.absolute_url()+'/getImageView'
841: rettemp+=li%nurn
842: flag=1
843:
844:
845: if not ('<error>' in self.showMetaDataXML()):
846: nurn=self.absolute_url()+'/showMetaDataXML'
847: rettemp+=li%nurn
848: flag=1
849:
850: rettemp+="</RDF:Seq>"
851:
852: if flag==1:
853: ret+=rettemp
854:
855: if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
856: nurn=self.absolute_url()+'/getFullTextXML'
857: ret+=getRDFDescription(self,self.absolute_url()+'/getFullTextXML',urn=nurn,nameDef="Fulltext",typeName="ECHO_fulltext")
858:
859: if not ('<error>' in self.getImageView(noredirect='Yes')):
860: nurn=self.absolute_url()+'/getImageView'
861: ret+=getRDFDescription(self,self.absolute_url()+'/getImageView',urn=nurn,nameDef="Image View",typeName="ECHO_imageview")
862:
863: if not ('<error>' in self.showMetaDataXML()):
864: nurn=self.absolute_url()+'/showMetaDataXML'
865: ret+=getRDFDescription(self,self.absolute_url()+'/showMetaDataXML',urn=nurn,nameDef="Metadata",typeName="ECHO_metaData")
866:
867: return ret
868:
869: def getAccessRightSelectorHTML(self,outlook="select"):
870: """htmlselector"""
871: values=['free','mpiwg']
872:
873: if outlook=="select":
874: ret="""<select name="%s">"""%self.getId()
875:
876: for value in values:
877: if value==self.getAccessRightMD():
878: ret+="<option selected>%s</option>"%value
879: else:
880: ret+="<option>%s</option>"%value
881: return ret+"</select>"
882:
883: else:
884: ret=""
885: for value in values:
886:
887: if value==self.getAccessRightMD():
888: ret+="""<input type="radio" name="%s" value="%s" checked>%s"""%(self.getId(),value,value)
889: else:
890: ret+="""<input type="radio" name="%s" value="%s">%s"""%(self.getId(),value,value)
891: return ret
892:
893:
894:
895: def getAccessRightMD(self):
896: """set accessright"""
897: url=self.metalink
898:
899: try:
900: geturl=""
901: for line in ECHO_helpers.urlopen(url).readlines():
902: geturl=geturl+line
903:
904:
905: except:
906: return (None,"Cannot open: "+url)
907:
908: try:
909: dom=xml.dom.minidom.parseString(geturl)
910: root=dom.getElementsByTagName('resource')[0]
911: except:
912: return (None,"Cannot parse: "+url+"<br>"+geturl)
913:
914: internal=dom.getElementsByTagName('internal')
915: if internal:
916: institution=dom.getElementsByTagName('institution')
917: return getText(institution[0].childNodes)
918:
919: free=dom.getElementsByTagName('free')
920: if free:
921: return "free"
922:
923: return "free" #default free
924:
925: def changeAccessRightMD(self,accessright,RESPONSE=None):
926: """change the rights"""
927:
928: params="accessright=%s"%accessright
929:
930:
931: #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()
932:
933:
934: ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/setAccessRightXML'+urllib.quote('?'+params))).read()
935:
936:
937: if RESPONSE is not None:
938: RESPONSE.redirect('manage_main')
939:
940:
941: def setAccessRightXML(self,accessright):
942: """set accessright"""
943: url=self.metalink
944:
945: try:
946: geturl=""
947: for line in ECHO_helpers.urlopen(url).readlines():
948: geturl=geturl+line
949:
950:
951: except:
952: return (None,"Cannot open: "+url)
953:
954: try:
955: dom=xml.dom.minidom.parseString(geturl)
956: root=dom.getElementsByTagName('resource')[0]
957: except:
958: return (None,"Cannot parse: "+url+"<br>"+geturl)
959:
960: metanodes=dom.getElementsByTagName('access-conditions')
961:
962: if not metanodes:
963: nodenew=dom.createElement('access-conditions')
964: root.appendChild(nodenew)
965: metanode=nodenew
966: else:
967: metanode=metanodes[0]
968:
969: accesses=metanode.getElementsByTagName('access')
970:
971: if not accesses:
972: nodenew2=dom.createElement('access')
973: metanode.appendChild(nodenew2)
974: metanode2=nodenew2
975: else:
976: metanode2=accesses[0]
977:
978: internal=metanode.getElementsByTagName('internal')
979:
980: if internal:
981: metanode2.removeChild(internal[0]).unlink()
982:
983: free=metanode.getElementsByTagName('free')
984:
985: if free:
986: metanode2.removeChild(internal[0]).unlink()
987:
988:
989: if accessright=='free':
990: nodenew3=dom.createElement('free')
991: metanode2.appendChild(nodenew3)
992: elif accessright=='mpiwg':
993: nodenew3=dom.createElement('internal')
994: nodenew4=dom.createElement('institution')
995: metanodetext=dom.createTextNode('mpiwg')
996: nodenew4.appendChild(metanodetext)
997: nodenew3.appendChild(nodenew4)
998: metanode2.appendChild(nodenew3)
999:
1000: return dom.toxml().encode('utf-8')
1001:
1002: def setStartPageForm(self):
1003: """Form for changing the startpage"""
1004:
1005:
1006: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resourceStartPage.zpt').__of__(self)
1007: pt.content_type="text/html"
1008: return pt()
1009:
1010:
1011: def createImageUrl(self,pn=1):
1012: """create ImageUrl"""
1013:
1014:
1015: resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
1016:
1017: digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
1018: images=readFieldFromXML(self.metalink,'texttool','image')
1019:
1020:
1021: if (not resourcepath) or (not digiliburlprefix) or (not images):
1022: zLOG.LOG("ECHO (createImageUrl)",zLOG.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())
1023: return None
1024: resourcepath=resourcepath.replace('/mpiwg/online','')
1025: if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"
1026:
1027: if (not images) or (not resourcepath): return None
1028:
1029: return "%sfn=%s&pn=%i"%(digiliburlprefix,resourcepath+"/"+images,pn)
1030:
1031: def copyTitleToInfoXML(self,RESPONSE=None):
1032: """copy title from the resource"""
1033: presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')
1034: resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
1035: if (not presentationXML) or (not resourcepath):
1036: if RESPONSE:
1037: RESPONSE.write("Error: %s\n"%self.getId())
1038: else:
1039: return None,self.absolute_url()
1040:
1041: try:
1042: fh=file(os.path.join(resourcepath,presentationXML),'w')
1043: fh.write("""<info>
1044: <author></author>
1045: <title>%s</title>
1046: <date></date>
1047: <display>yes</display>
1048: </info>"""%self.title)
1049: fh.close()
1050: return 1,self.getId()
1051: except:
1052: if RESPONSE:
1053: RESPONSE.write("Error: %s\n"%self.getId())
1054: else:
1055: return None,self.absolute_url()
1056:
1057:
1058: def setStartPage(self,startpage=None,RESPONSE=None):
1059: """set start page, if no startpage defined use the generic one of the resource"""
1060:
1061: if (not (type(startpage)==StringType)):
1062: if ("__generic" in startpage): # checke ob generic in der liste
1063: startpage=self.absolute_url()+"/startpage_html"
1064: elif ("__firstPage" in startpage): # checke ob generic in der liste
1065: startpage=self.createImageUrl()
1066:
1067: if (not startpage):
1068: startpage=self.absolute_url()+"/startpage_html"
1069: elif (startpage=="__generic"):
1070: startpage=self.absolute_url()+"/startpage_html"
1071: elif (startpage=="__firstPage"):
1072: startpage=self.createImageUrl()
1073:
1074: params="startpage=%s"%startpage
1075: 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))
1076:
1077: ECHO_helpers.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()
1078:
1079:
1080: path=self.metalink
1081:
1082: path=re.sub(self.REQUEST['SERVER_URL'],'',path)
1083: path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
1084:
1085: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
1086: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
1087: path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
1088: path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
1089: path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
1090: path=re.sub('http://vision.mpiwg-berlin.mpg.de','',path) # falls vision als server
1091: path=re.sub('http://xserve02.mpiwg-berlin.mpg.de:18880','',path) # falls vision als server
1092: path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
1093: path=re.sub('/index.meta','',path)
1094:
1095:
1096: ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
1097:
1098: if RESPONSE is not None:
1099: RESPONSE.redirect('manage_main')
1100:
1101: def changeViewerTemplateSetForm(self):
1102: """change the viewer template set"""
1103: pt=PageTemplateFile('Products/ECHO_content/zpt/changeResourceViewerTemplateSet').__of__(self)
1104: return pt()
1105:
1106:
1107:
1108: def getTextToolsField(self,name,default=''):
1109: """Lese Textoolsfelder aus index.meta im path aus"""
1110:
1111: try:
1112: dom=xml.dom.minidom.parse(self.metalink)
1113: node=dom.getElementsByTagName('texttool')[0] #getNode
1114: subnode=node.getElementsByTagName(name)[0]
1115:
1116: # bei text wird nur der Folder gebraucht
1117: if name=="text":
1118: splitted=getText(subnode.childNodes).split("/")
1119: return splitted[len(splitted)-2]
1120: else:
1121: return getText(subnode.childNodes)
1122: except:
1123: return default
1124:
1125:
1126: def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
1127: """changeit"""
1128:
1129: paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']
1130:
1131:
1132: #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)
1133:
1134: params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
1135:
1136:
1137: ECHO_helpers.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()
1138:
1139: #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
1140: # hack Pfad auf die Dokumente
1141: path=self.metalink
1142:
1143:
1144:
1145: path=re.sub('/index.meta','',path)
1146:
1147: path=re.sub(self.REQUEST['SERVER_URL'],'',path)
1148: path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
1149:
1150: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
1151: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
1152: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
1153:
1154: path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
1155: path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
1156: path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
1157: path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
1158:
1159: path=re.sub('http://vision.rz-berlin.mpg.de','',path) # falls vision als server
1160:
1161: return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
1162:
1163:
1164: if RESPONSE is not None:
1165: RESPONSE.redirect('manage_main')
1166:
1167:
1168: def getTitle(self):
1169: """title"""
1170: try:
1171: return self.title.encode('utf-8','ignore')
1172: except:
1173: self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
1174: return self.title.encode('utf-8','ignore')
1175:
1176: def getLabel(self):
1177: """title"""
1178: try:
1179: return self.label.encode('utf-8','ignore')
1180: except:
1181: self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
1182: return self.label.encode('utf-8','ignore')
1183:
1184: def content_html(self):
1185: """template fuer content"""
1186: return content_html(self,'resource')
1187:
1188: def getViewClassification(self):
1189: if hasattr(self,'viewClassification'):
1190: return self.viewClassification
1191: else:
1192: return ""
1193:
1194: def getFullTextXML(self,noredirect=None):
1195: """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
1196:
1197: try:
1198: #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"open %s"%self.metalink)
1199: fh=ECHO_helpers.urlopen(self.metalink)
1200: #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"opened %s"%self.metalink)
1201: dom=xml.dom.minidom.parse(fh)
1202: texttools=dom.getElementsByTagName('texttool')
1203: text=texttools[0].getElementsByTagName('text')
1204: texturl=getText(text[0].childNodes)
1205:
1206: #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"found %s"%texturl)
1207: fh.close()
1208: #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"closed fh")
1209: #keine url
1210: if not (texturl.split(":")[0] in ['http','ftp','file']):
1211: if not noredirect:
1212: return file(texturl).read()
1213: else:
1214: return texturl
1215:
1216: if not noredirect:
1217: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1218: zLOG.LOG("ECHO Fulltext",zLOG.INFO,"redirect to:%s"%texturl)
1219: self.REQUEST.RESPONSE.redirect(texturl)
1220: else:
1221: return texturl
1222: except:
1223:
1224: if not noredirect:
1225: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1226: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
1227: else:
1228: return "<error>no fulltext available</error>"
1229:
1230:
1231: def getImageView(self,noredirect=None):
1232: """getImages; give Imageviewr and <error></error> if somthing goes wrong."""
1233: try:
1234: fh=ECHO_helpers.urlopen(self.metalink)
1235: dom=xml.dom.minidom.parse(fh)
1236: texttools=dom.getElementsByTagName('texttool')
1237: text=texttools[0].getElementsByTagName('image')
1238: imagetemp=getText(text[0].childNodes)
1239:
1240: text=dom.getElementsByTagName('archive-path')
1241: archivepath=getText(text[0].childNodes)
1242: archivepath=re.sub('/mpiwg/online/','',archivepath)
1243: imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
1244: fh.close()
1245:
1246: if not noredirect:
1247: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1248: self.REQUEST.RESPONSE.redirect(imageurl)
1249: else:
1250: return imageurl
1251: except:
1252:
1253: if not noredirect:
1254: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1255: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
1256: else:
1257: return "<error>no images available</error>"
1258:
1259:
1260: def getCopyrightsHTML(self):
1261: """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
1262:
1263: if hasattr(self,'copyrightModel'):
1264: obj=self.copyrightModel
1265:
1266: else:
1267: return "ERROR"
1268: ret=[]
1269:
1270: for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
1271:
1272:
1273: try:
1274: if hasattr(self.copyrightTypes,copyright[2]):
1275: copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
1276: link="copyrightTypes/"+copyright[2]+'/copyright.html'
1277: else:
1278: copyrightTypeObj=getattr(obj,copyright[2])
1279: link="copyrightModel/"+copyright[2]+'/copyright.html'
1280:
1281: label=copyrightTypeObj.label
1282: url=getattr(copyrightTypeObj, 'url', '')
1283:
1284: if url!='':
1285: ret.append((url,copyright[0],copyright[1],copyright[2],label))
1286: else:
1287: if hasattr(copyrightTypeObj, 'copyright.html'):
1288: ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
1289: else:
1290: ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
1291: except:
1292: """nothing"""
1293:
1294: return ret
1295:
1296: def getInstitutionsHTML(self):
1297: """gibt Liste der fÂrdernden Institutionen aus"""
1298:
1299: if hasattr(self,'support'):
1300: obj=self.support
1301: ret=obj.getSupporter()
1302: return ret
1303: else:
1304: return ''
1305:
1306:
1307: def getCredits(self):
1308: """Ausgabe der credits"""
1309: if self.credits:
1310: return self.credits
1311: else:
1312: return []
1313:
1314: def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
1315:
1316: self.id = id
1317: """Festlegen der ID"""
1318:
1319: self.label = label
1320: self.link= link
1321: self.metalink=metalink
1322: self.title=title
1323: self.weight=weight
1324: self.credits=toList(credits)
1325: self.description=description
1326: self.contentType=contentType
1327: self.copyrightType=copyrightType
1328: self.renderingType=renderingType
1329: self.responsible=responsible
1330: self.resourceID=resourceID
1331:
1332: if coords:
1333: coordsnew=[ string.split(x,",") for x in coords]
1334: else:
1335: coordsnew=[]
1336:
1337: self.coords=coordsnew
1338:
1339:
1340: def getCoords(self):
1341: """gibt coordinaten als String zurßck und lÜscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""
1342: retList=[]
1343: if hasattr(self,'coords'):
1344: for x in self.coords:
1345: if len(x)>1:
1346: retList.append(string.join(x,","))
1347: return retList
1348:
1349:
1350:
1351: def getContentType(self):
1352: try:
1353: return self.contentType
1354: except:
1355: return ""
1356:
1357: def getCopyrightType(self):
1358: try:
1359: return self.copyrightType
1360: except:
1361: return ""
1362:
1363: def getRenderingType(self):
1364: try:
1365: return self.renderingType
1366: except:
1367: return ""
1368:
1369: def ECHO_resource_config(self):
1370: """Main configuration"""
1371:
1372: if not hasattr(self,'weight'):
1373: self.weight=""
1374:
1375: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
1376: return pt()
1377:
1378:
1379: def ECHO_resource_config_main(self):
1380: """Main configuration"""
1381:
1382: if not hasattr(self,'weight'):
1383: self.weight=""
1384:
1385: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)
1386: return pt()
1387:
1388: def ECHO_resource_config_coords(self):
1389: """Coords configuration """
1390:
1391: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)
1392: return pt()
1393:
1394: def ECHO_resource_config_credits(self):
1395: """Main configuration"""
1396:
1397: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)
1398: return pt()
1399:
1400: def ECHO_resource_config_metadata(self):
1401: """Main configuration"""
1402:
1403: if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
1404: self.metaDataHash={}
1405: self.contentType=self.bib_type
1406: for data in self.metadata:
1407: data_neu=re.sub('-','_',data)
1408: self.meta
1409: DataHash[data_neu]=getattr(self,data)[0:]
1410:
1411:
1412: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)
1413: return pt()
1414:
1415:
1416:
1417:
1418: def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
1419: """Ănderung der Properties"""
1420: self.resourceID=resourceID
1421: self.title=title
1422: self.label=label
1423: self.description=description
1424:
1425: self.contentType=contentType
1426: self.renderingType=renderingType
1427: self.weight=weight
1428:
1429: self.link=link
1430: self.metalink=metalink
1431:
1432: if RESPONSE is not None:
1433: RESPONSE.redirect('manage_main')
1434:
1435:
1436: def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):
1437: """Ănderung der Properties - coords"""
1438:
1439: if type(coords)==StringType:
1440: coords=[coords]
1441:
1442: try:
1443: coordsnew=[ string.split(x,",") for x in coords]
1444: except:
1445: coordsnew=[]
1446:
1447: self.coords=coordsnew[0:]
1448: self.viewClassification=viewClassification
1449:
1450: if RESPONSE is not None:
1451: RESPONSE.redirect('manage_main')
1452:
1453: def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
1454: """Ănderung der Properties"""
1455: self.credits=credits
1456: self.responsible=responsible
1457: self.copyrightType=copyrightType
1458:
1459: if RESPONSE is not None:
1460: RESPONSE.redirect('manage_main')
1461:
1462:
1463: def changeECHO_resource_metadata_local(self,RESPONSE=None):
1464: """change metadata"""
1465: tags=self.findTagsFromMapping(self.contentType)
1466: for field in tags[1]:
1467: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
1468:
1469:
1470:
1471: if RESPONSE is not None:
1472: RESPONSE.redirect('manage_main')
1473:
1474: def changeECHO_resource_metadata(self,RESPONSE=None):
1475: """change metadata"""
1476: tags=self.findTagsFromMapping(self.contentType)
1477: self.OSAS_meta={}
1478: for field in tags[1]:
1479: try:
1480: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
1481: self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
1482: except:
1483: """nothing"""
1484:
1485: ECHO_helpers.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()
1486:
1487:
1488: if RESPONSE is not None:
1489: RESPONSE.redirect('manage_main')
1490:
1491:
1492: def getMDValue(self,fieldName):
1493: return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)
1494:
1495: def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
1496: """new index.meta"""
1497: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1498:
1499: if not hasattr(self,'metaDataHash'):
1500:
1501: self.copyIndex_meta2echo_resource()
1502: try:
1503: return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1504: except:
1505: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1506:
1507: def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
1508: """schreibe md"""
1509:
1510: try:
1511:
1512: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
1513: except:
1514: return "<error> no metadata stored</error>"
1515:
1516: def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
1517: """prints out metadata as stored in the echo environment, format is the index.meta format"""
1518: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1519: return writeMetadata(self.metalink,self.metaDataHash)
1520:
1521: def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
1522: """Ănderung der Properties"""
1523:
1524: try:
1525: coordsnew=[ string.split(x,",") for x in coords]
1526: except:
1527: coordsnew=[]
1528:
1529: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
1530: self.viewClassification=viewClassification
1531: self.coords=coordsnew[0:]
1532: self.link=link
1533: self.metalink=metalink
1534:
1535: if RESPONSE is not None:
1536: RESPONSE.redirect('manage_main')
1537:
1538:
1539: manage_options = Folder.manage_options+(
1540: {'label':'Main Config','action':'ECHO_resource_config_main'},
1541: {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
1542: {'label':'Change Coords','action':'ECHO_resource_config_coords'},
1543: {'label':'Add coords','action':'ECHO_graphicEntry'},
1544: {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
1545: {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
1546: {'label':'set/change startpage','action':'setStartPageForm'},
1547: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
1548: )
1549:
1550: def getOverview(self):
1551: """overview graphics"""
1552:
1553: return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
1554:
1555: def ECHO_graphicEntry(self):
1556: """DO nothing"""
1557: overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
1558: if overview:
1559: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
1560: return pt()
1561: else:
1562: return "NO OVERVIEW GRAPHICS"
1563:
1564: def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
1565: """Enter coords"""
1566: coords=self.coords
1567: temco=coordstr.split(",")
1568: temco.append(angle)
1569: coords.append(temco)
1570:
1571: self.coords=coords[0:]
1572:
1573: if RESPONSE is not None:
1574: RESPONSE.redirect('ECHO_graphicEntry')
1575:
1576:
1577: def isDefinedInThisSet(self,fields,field):
1578: """checks if field is defined in fields"""
1579: if (fields[0].has_key(field)) and not (fields[0][field]==""):
1580: return 1
1581: else:
1582:
1583: return 0
1584:
1585: def getFieldLabel(self,fields,field):
1586: """get labels"""
1587: try:
1588: ret =fields[0][field]
1589: if ret == "":
1590: return field
1591: else:
1592: return ret
1593: except:
1594: return field
1595:
1596:
1597:
1598: def getFieldTag(self,fields,field):
1599: """get labels"""
1600: try:
1601: ret =fields[0][field]
1602: if ret == "":
1603: return field
1604: else:
1605: return ret
1606: except:
1607: return field
1608:
1609:
1610:
1611: def getFieldValue(self,field):
1612: """get value"""
1613:
1614: try:
1615:
1616: ret=self.metaDataHash[field]
1617: if ret == "":
1618: return None
1619: else:
1620: return ret
1621: except:
1622: return None
1623:
1624: def getMetaDataHash(self):
1625: """md hash"""
1626: return self.metaDataHash
1627:
1628: def setFieldValue(self,field,value):
1629: """get value"""
1630:
1631: if not hasattr(self,'metaDataHash'):
1632: setattr(self,'metaDataHash',{})
1633: self.metaDataHash[field]=value[0:]
1634:
1635:
1636: def copySearchFields(self):
1637: """copys metadatafields to the object"""
1638: fields=['author','title','year']
1639: for field in fields:
1640: setattr(self,'MD_'+field,self.getFieldValue(field))
1641:
1642:
1643: def findLabelsFromMapping(self,referenceType):
1644: """gib hash mit label -> generic zurueck"""
1645: #return {},[]
1646:
1647: temp=self.ZopeFind(self.standardMD)
1648:
1649: if referenceType=="":
1650: referenceType="book"
1651:
1652:
1653: bibdata={}
1654: retdata={}
1655: fields=[]
1656: fieldlist=self.standardMD.fieldList
1657:
1658: for referenceTypeF in self.referencetypes:
1659:
1660: if referenceTypeF[1].title.lower() == referenceType.lower():
1661:
1662: try:
1663: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1664: referenceType=referenceTypeF[1].title
1665: except:
1666: bibdata[referenceType]=referenceTypeF[1].fields
1667:
1668:
1669: bibdata['data']=referenceTypeF[1]
1670: fields=bibdata[referenceType]
1671: for field in fieldlist:
1672: retdata[field]=referenceTypeF[1].getValue(field)[1]
1673:
1674: return retdata,fieldlist,temp,fields
1675:
1676: def findTagsFromMapping(self,referenceType):
1677: """gib hash mit label -> generic zurueck"""
1678:
1679:
1680: if referenceType=="":
1681: referenceType="book"
1682:
1683: temp = self.ZopeFind(self.standardMD)[0:]
1684:
1685:
1686: #self.referencetypes=temp[0:]
1687:
1688:
1689:
1690:
1691:
1692:
1693: bibdata={}
1694: retdata={}
1695: fieldlist=self.standardMD.fieldList
1696: fields=[]
1697: for referenceTypeF in temp:
1698: #print referenceType
1699:
1700: if referenceTypeF[1].title.lower() == referenceType.lower():
1701: try:
1702: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1703: referenceType=referenceTypeF[1].title
1704: except:
1705: bibdata[referenceType]=referenceTypeF[1].fields
1706: bibdata['data']=referenceTypeF[1]
1707: fields=bibdata[referenceType]
1708: for field in fieldlist:
1709: retdata[field]=referenceTypeF[1].getValue(field)[0]
1710:
1711: return retdata,fieldlist,temp,fields
1712:
1713:
1714: security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination
1715: def copyIndex_meta2echo_resource(self,RESPONSE=None):
1716: """copy MD von Index_meta to the echo_resource"""
1717:
1718: (metadict, error)=readMetadata(self.metalink)
1719:
1720:
1721:
1722: self.metaDataHash={}
1723: if not error=="": #Fehler beim Auslesen des Metafiles
1724:
1725: return "ERROR:",error,self.absolute_url()
1726:
1727: self.contentType=metadict['bib_type'][0:]
1728: fields=self.findTagsFromMapping(self.contentType)
1729:
1730: #fields=self.findLabelsFromMapping(self.contentType)
1731: for field in fields[1]:
1732:
1733: if self.isDefinedInThisSet(fields,field):
1734: #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
1735: self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
1736:
1737:
1738:
1739: if RESPONSE:
1740: return RESPONSE.redirect('manage_main')
1741:
1742: def ECHO_getResourceMD(self,template="yes",back=None):
1743: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
1744: (metadict, error)=readMetadata(self.metalink)
1745:
1746: if back:
1747: self.REQUEST.SESSION['back']=back
1748:
1749: if not error=="": #Fehler beim Auslesen des Metafiles
1750: return "ERROR:",error
1751:
1752:
1753: if not (metadict['bib_type'].lower()==self.contentType.lower()):
1754: self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
1755: self.REQUEST.SESSION['contentZope']=self.contentType
1756:
1757: return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()
1758:
1759: self.REQUEST.SESSION['metadict']=metadict
1760:
1761:
1762:
1763: self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])
1764:
1765:
1766:
1767: if template=="yes":
1768: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
1769: return pt()
1770:
1771:
1772:
1773:
1774:
1775: def ECHO_getMD(self,item):
1776: """Ausgabe der MD"""
1777: return getattr(self,item)
1778:
1779: def index_html(self):
1780: """standard page"""
1781:
1782: return self.REQUEST.RESPONSE.redirect(self.link)
1783:
1784: def startpage_html(self):
1785: """prints out a startpage for a resource for use e.g. in the BVE"""
1786:
1787: # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
1788:
1789: sp=self.ZopeFind(self,obj_ids=['startpage.html'])
1790:
1791: if sp:
1792: return sp[1]()
1793:
1794: #prĂźfen ob irgendwo ein template
1795: if hasattr(self,'startpage_index_template'):
1796: return self.startpage_index_template()
1797:
1798: #generisches template ausgeben
1799:
1800: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_startpage_index_template_standard.zpt').__of__(self)
1801: pt.content_type="text/html"
1802: return pt()
1803:
1804: def toc_html(self):
1805:
1806: sp=self.ZopeFind(self,obj_ids=['toc.html'])
1807:
1808: if sp:
1809: return sp[0][1]()
1810:
1811:
1812: security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
1813:
1814: def generate_label(self):
1815: """Erzeugt_standard_Label aus Template"""
1816: pt=getattr(self,"label_template_"+self.contentType.lower())
1817:
1818: self.label=pt()[0:]
1819: return pt()
1820:
1821: security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
1822:
1823: def generate_title(self,RESPONSE=None):
1824: """Erzeugt_standard_Label aus Template"""
1825: pt=getattr(self,"label_template_"+self.contentType.lower())
1826:
1827: self.title=pt()[0:]
1828:
1829: return pt()
1830:
1831: Globals.InitializeClass(ECHO_resource)
1832:
1833: def manage_addECHO_resourceForm(self):
1834: """Form for adding a ressource"""
1835: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
1836: return pt()
1837:
1838:
1839:
1840: 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):
1841: """addaresource"""
1842:
1843: newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
1844:
1845: self._setObject(id,newObj)
1846:
1847: if RESPONSE is not None:
1848: RESPONSE.redirect('manage_main')
1849:
1850:
1851: class ECHO_externalLink(Folder):
1852: """Link zu einer externen Ressource"""
1853: security=ClassSecurityInfo()
1854: meta_type='ECHO_externalLink'
1855:
1856: def getTitle(self):
1857: """title"""
1858: try:
1859: return self.title.encode('utf-8','ignore')
1860: except:
1861: self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
1862: return self.title.encode('utf-8','ignore')
1863:
1864: def getLabel(self):
1865: """title"""
1866: try:
1867: return self.label.encode('utf-8','ignore')
1868: except:
1869: self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
1870: return self.label.encode('utf-8','ignore')
1871:
1872: def content_html(self):
1873: """template fuer content"""
1874: return content_html(self,'externalLink')
1875:
1876: def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
1877:
1878: self.id = id
1879: """Festlegen der ID"""
1880:
1881: self.credits=toList(credits)
1882: self.label = label
1883: self.link= link
1884: self.title=title
1885: self.weight=weight
1886: self.description=description
1887: self.contentType=contentType
1888: self.responsible=responsible
1889: coordsnew=[ string.split(x,",") for x in coords]
1890: self.coords=coordsnew
1891:
1892: def ECHO_externalLink_config(self):
1893: """Main configuration"""
1894:
1895: if not hasattr(self,'weight'):
1896: self.weight=""
1897: if not hasattr(self,'coords'):
1898:
1899: self.coords=['']
1900:
1901:
1902: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)
1903: return pt()
1904:
1905:
1906: def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
1907:
1908: """Ănderung der Properties"""
1909: try:
1910: coordsnew=[ string.split(x,",") for x in coords]
1911: except:
1912: coordsnew=[]
1913:
1914: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
1915:
1916: self.coords=coordsnew[0:]
1917: self.link=link
1918: if RESPONSE is not None:
1919: RESPONSE.redirect('manage_main')
1920:
1921:
1922: manage_options = Folder.manage_options+(
1923: {'label':'Main Config','action':'ECHO_externalLink_config'},
1924: )
1925:
1926:
1927: def index_html(self):
1928: """standard page"""
1929:
1930: return self.REQUEST.RESPONSE.redirect(self.link)
1931:
1932: def manage_addECHO_externalLinkForm(self):
1933: """Form for external Links"""
1934: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)
1935: return pt()
1936:
1937:
1938: def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
1939: """Add an external Link"""
1940:
1941: newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
1942:
1943: self._setObject(id,newObj)
1944:
1945: if RESPONSE is not None:
1946: RESPONSE.redirect('manage_main')
1947:
1948:
1949: class ECHO_link(ECHO_externalLink):
1950: """external_link"""
1951:
1952: meta_type="ECHO_link"
1953:
1954:
1955: def content_html(self):
1956: """template fuer link"""
1957: if hasattr(self,"link_template"):
1958: return content_html(self,'link')
1959: else:
1960: return content_html(self,'collection')
1961:
1962: def manage_addECHO_linkForm(self):
1963: """Form for external Links"""
1964: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)
1965: return pt()
1966:
1967:
1968: def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
1969: """Add an external Link"""
1970:
1971: newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
1972:
1973: self._setObject(id,newObj)
1974:
1975: if RESPONSE is not None:
1976: RESPONSE.redirect('manage_main')
1977:
1978:
1979: class ECHO_collection(Folder, Persistent, Implicit, Cacheable):
1980: """ECHO Collection"""
1981:
1982: security=ClassSecurityInfo()
1983: meta_type='ECHO_collection'
1984: viewClassificationList=viewClassificationListMaster
1985: displayTypes=displayTypes
1986:
1987: path="/mpiwg/online/permanent/shipbuilding"
1988:
1989: def getRDF(self,urn=None):
1990: """rdf of the collection"""
1991:
1992: contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
1993:
1994: ret=getRDFDescription(self,self.absolute_url(),urn=urn)
1995:
1996: if not urn:
1997: urn=self.absolute_url()
1998:
1999: li="""<RDF:li RDF:resource="%s" />\n"""
2000:
2001:
2002: for content in contents:
2003: ret+=content[1].getRDF()+"\n"
2004:
2005: ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
2006: for content in contents:
2007: nurn=content[1].absolute_url()
2008: ret+=li%nurn
2009: return ret+"</RDF:Seq>"
2010:
2011:
2012: def showRDF(self):
2013: """showrdf"""
2014: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
2015: ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""
2016: ret+=self.getRDF(urn="echo:collectionroot")+"\n"
2017:
2018: ret+="""</RDF:RDF>"""
2019:
2020: return ret
2021:
2022:
2023:
2024: def changeLabels(self):
2025: """change form"""
2026: pt=PageTemplateFile('Products/ECHO_content/zpt/changeLabelsForm').__of__(self)
2027: pt.content_type="text/html"
2028: return pt()
2029:
2030: def changeTitles(self):
2031: """change form"""
2032: pt=PageTemplateFile('Products/ECHO_content/zpt/changeTitleForm').__of__(self)
2033: pt.content_type="text/html"
2034: return pt()
2035:
2036: def changeWeights(self):
2037: """change form"""
2038: pt=PageTemplateFile('Products/ECHO_content/zpt/changeWeightForm').__of__(self)
2039: pt.content_type="text/html"
2040: return pt()
2041:
2042: def changeMetaDataLinks(self):
2043: """change form"""
2044: pt=PageTemplateFile('Products/ECHO_content/zpt/changeMetaDataLinkForm').__of__(self)
2045: pt.content_type="text/html"
2046: return pt()
2047: def changeAccessRightsCollection(self):
2048: """change"""
2049: ret=""
2050: argv=self.REQUEST.form
2051:
2052: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2053: for resource in resources:
2054:
2055: try:
2056: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2057: resource[1].changeAccessRightMD(argv[resource[1].getId()])
2058: except:
2059: """not"""
2060: return ret
2061:
2062: def changeMetaDataLinkInCollection(self):
2063: """change all lables of a collection"""
2064: ret=""
2065: argv=self.REQUEST.form
2066:
2067: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2068: for resource in resources:
2069:
2070: try:
2071: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2072: resource[1].metalink=argv[resource[1].getId()][0:]
2073: except:
2074: """not"""
2075: return ret
2076:
2077: def changeMetaDataLinkInCollection(self):
2078: """change all lables of a collection"""
2079: ret=""
2080: argv=self.REQUEST.form
2081:
2082: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2083: for resource in resources:
2084:
2085: try:
2086: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2087: resource[1].metalink=argv[resource[1].getId()][0:]
2088: except:
2089: """not"""
2090: return ret
2091:
2092: def changeWeightsInCollection(self):
2093: """change all lables of a collection"""
2094: ret=""
2095: argv=self.REQUEST.form
2096:
2097: resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
2098: for resource in resources:
2099:
2100: try:
2101: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2102: resource[1].weight=argv[resource[1].getId()][0:]
2103: except:
2104: """not"""
2105: return ret
2106:
2107: def changeTitlesInCollection(self):
2108: """change all lables of a collection"""
2109: ret=""
2110: argv=self.REQUEST.form
2111:
2112: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2113: for resource in resources:
2114:
2115: try:
2116: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2117: resource[1].title=argv[resource[1].getId()][0:]
2118: except:
2119: """not"""
2120: return ret
2121:
2122: def updateCollection(self,RESPONSE=None):
2123: """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
2124: files=os.listdir(self.path)
2125: ret=""
2126: for fileName in files:
2127:
2128: if fileName:
2129:
2130: tempPath=re.sub("/mpiwg/online","",self.path)
2131: link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"
2132:
2133: metalink=self.path+"/"+fileName+"/index.meta"
2134: try:
2135:
2136: #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"
2137:
2138: newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'generated','book','','','','','','')
2139: self._setObject(fileName,newObj)
2140:
2141: genObj=getattr(self,fileName)
2142: #genObj.createIndexFile()
2143: ret+="OK:"+fileName+"<br/>"
2144: except:
2145: print "ERROR"
2146: ret+="ERROR:"+fileName+"<br/>"
2147:
2148: return ret
2149:
2150: if RESPONSE is not None:
2151: RESPONSE.redirect('manage_main')
2152:
2153: def updateCollectionMD(self,RESPONSE=None):
2154: """updateMD"""
2155: files=os.listdir(self.path)
2156: for fileName in files:
2157: if fileName:
2158: genObj=getattr(self,fileName)
2159: genObj.copyIndex_meta2echo_resource()
2160: genObj.generate_title()
2161:
2162: if RESPONSE is not None:
2163: RESPONSE.redirect('manage_main')
2164:
2165:
2166:
2167: def changeViewerTemplateSetsForm(self):
2168: """change the viewer template set"""
2169: pt=PageTemplateFile('Products/ECHO_content/zpt/changeViewerTemplateSet').__of__(self)
2170: return pt()
2171:
2172: def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):
2173: """Get the ViewerTemplateSet title for configuration"""
2174: ret=[]
2175:
2176: try:
2177: viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.
2178:
2179: for viewerTemplateSet in viewerTemplateSets:
2180: ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))
2181:
2182: return ret
2183:
2184: except:
2185: return [('no ViewerTemplateSetfolders','')]
2186:
2187: def getTextToolsField(self,name,default=''):
2188: """Lese viewerTemplateSet der Collection not implemented yet!"""
2189:
2190: return default
2191:
2192:
2193: def isSelectedViewerTemplateSet(self,obj,id):
2194: """is ausgewählt"""
2195:
2196: if self.REQUEST['viewerTemplateSet']==id:
2197: return 1
2198: else:
2199: return None
2200:
2201: def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
2202: """change the templates"""
2203:
2204: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2205:
2206: for resource in resources:
2207:
2208: resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
2209:
2210: if RESPONSE is not None:
2211: RESPONSE.redirect('manage_main')
2212:
2213:
2214: def setStartpageFolderForm(self):
2215: """Form for changing the startpage"""
2216:
2217:
2218: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resourceStartPageFolder.zpt').__of__(self)
2219: pt.content_type="text/html"
2220: return pt()
2221:
2222: def setStartpageFolder(self,startpage=None,RESPONSE=None):
2223: """change the templates"""
2224:
2225: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2226:
2227: for resource in resources:
2228:
2229: resource[1].setStartPage(startpage)
2230:
2231: if RESPONSE is not None:
2232: RESPONSE.redirect('manage_main')
2233:
2234: def copyTitleToInfoXMLFolder(self,RESPONSE=None):
2235: """copy title into the title field of info.xml
2236: author and date werden leer!!!
2237: """
2238:
2239:
2240: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2241:
2242:
2243: for resource in resources:
2244: ret,txt=resource[1].copyTitleToInfoXML()
2245: if (not ret) and RESPONSE:
2246: RESPONSE.write("error: %s\n"%txt)
2247: if ret and RESPONSE:
2248: RESPONSE.write("ok: %s\n"%txt)
2249:
2250: #zLOG.LOG("ECHO (copyTitleToInfoXMLFolder)",zLOG.INFO,txt)
2251: if RESPONSE is not None:
2252: RESPONSE.write("done!\n")
2253: RESPONSE.close()
2254: RESPONSE.redirect('manage_main')
2255:
2256: def copySearchFields(self,RESPONSE=None):
2257: """copys import metadatafields to the object"""
2258: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2259:
2260: for resource in resources:
2261:
2262: resource[1].copySearchFields()
2263:
2264: if RESPONSE is not None:
2265: RESPONSE.redirect('manage_main')
2266:
2267: def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
2268: """warning"""
2269: pt=PageTemplateFile('Products/ECHO_content/zpt/reloadMetaDataFromStorageWarning.zpt').__of__(self)
2270: pt.content_type="text/html"
2271: return pt()
2272:
2273: def reloadMetaDataFromStorage(self,RESPONSE=None):
2274: """copy metadata from the storage to ECHO"""
2275:
2276: return reloadMetaDataFromStorage(self,RESPONSE=None)
2277:
2278:
2279: def getPartnerCopyright(self,name,sonst="generic"):
2280: """gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""
2281: #print "hi",name,sonst
2282: #print getattr(self.partners,name).copyrightType
2283: try:
2284: partner=getattr(self.partners,name)
2285: return partner.copyrightType
2286: except:
2287: print "error"
2288: return sonst
2289:
2290: def partnerSelector_HTML(self,selected=None):
2291: """give type selector"""
2292: if not selected:
2293: retStr="<option selected>\n"
2294: else:
2295: retStr="<option>\n"
2296:
2297: try: # erste version copyrightTypes exists
2298: for partner in self.credits:
2299: if selected and (partner==selected):
2300: retStr+="""<option selected value="%s">%s\n"""%(partner,partner)
2301: else:
2302: retStr+="""<option value="%s">%s\n"""%(partner,partner)
2303: except:
2304: """nothing"""
2305: return retStr
2306:
2307: def getViewClassification(self):
2308: if hasattr(self,'viewClassification'):
2309: return self.viewClassification
2310: else:
2311: return ""
2312:
2313: def getTitle(self):
2314: """title"""
2315: try:
2316: return self.title.encode('utf-8','ignore')
2317: except:
2318: self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
2319: return self.title.encode('utf-8','ignore')
2320:
2321: def getLabel(self):
2322: """title"""
2323: try:
2324: return self.label.encode('utf-8','ignore')
2325: except:
2326: self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
2327: return self.label.encode('utf-8','ignore')
2328:
2329: def createRessourcesFromXMLForm(self):
2330: """form"""
2331: pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)
2332: return pt()
2333:
2334: def createRessourcesFromXML(self,fileupload):
2335: """read an XML file for generating resources"""
2336: dom=xml.dom.minidom.parse(fileupload)
2337: ret="<h2>Added</h2>"
2338: for resource in dom.getElementsByTagName('resource'):
2339: link=getText(resource.getElementsByTagName('link')[0].childNodes)
2340: label=getText(resource.getElementsByTagName('label')[0].childNodes)
2341: #splitted=link.split("?")[0].split("/")
2342: #id=splitted[len(splitted)-1].encode('ascii')
2343: id=re.sub(" ","_",label).encode('ascii')
2344:
2345: ret+="<p>"+label+"</p>"
2346: manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")
2347: return ret
2348:
2349: def getImageTag(self):
2350: """GetTag"""
2351: try:
2352: return self.imageTag
2353: except:
2354: return ""
2355:
2356: def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
2357: """SSS"""
2358: try:
2359: manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
2360: return "done"
2361: except:
2362: return None
2363:
2364: def getSecondaryLink(self):
2365: """secondary link"""
2366: try:
2367: return self.secondaryLink
2368: except:
2369: return ""
2370:
2371: def getSecondaryLinkTitle(self):
2372: """secondary link"""
2373: try:
2374: return self.secondaryLinkTitle
2375: except:
2376: return ""
2377:
2378: def getCollectionTreeXML(self):
2379: """Tree as XML"""
2380:
2381: def addPassWd(str):
2382: """adds a user/passwd to an url"""
2383: txt2=re.sub(r"(http://)(.*?)","\g<1>www:3333@\g<2>",str)
2384: return txt2
2385:
2386: def getCollection(object,depth=0):
2387: depth+=1
2388: collections=""
2389: for entry in object.__dict__.keys():
2390: element=getattr(object,entry)
2391: try:
2392: if element.meta_type in ["ECHO_collection","ECHO_group"]:
2393: collections+="<element name=\""+quote(element.title)+"\" url=\""+addPassWd(element.absolute_url())+"\">"
2394: collections+=getCollection(element,depth)+"</element>\n"
2395: except:
2396: """nothing"""
2397: return collections
2398:
2399: ret="""<?xml version="1.0" encoding="utf-8" ?>"""
2400: return ret+"<collection>"+getCollection(self)+"</collection>"
2401:
2402: def createJavaScript(self):
2403: """OLD CreateJava"""
2404: ret=javaScriptMain
2405:
2406: dynamical="\n"
2407: for ob in self.getGraphicCoords():
2408: if ob[4][4] == "":
2409: dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
2410: else:
2411: dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])
2412: dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])
2413: ret+=javaHandler%dynamical
2414: return ret
2415:
2416: def createJSAreas(self):
2417: """create area calls for JavaScript"""
2418: dynamical="\n"
2419: for ob in self.getGraphicCoords():
2420: if ob[5] == "area":
2421: dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])
2422: else:
2423: dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])
2424: return dynamical
2425:
2426: def createMapHead(self):
2427: """create javascript include and script tags for head"""
2428: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)
2429: return pt()
2430:
2431: def createMapImg(self):
2432: """generate img-tag for map"""
2433: bt = BrowserCheck(self)
2434: tag = ""
2435: src = self.REQUEST['URL1'] + "/overview"
2436: if bt.isN4:
2437: tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
2438: else:
2439: tag += '<img id="overview" src="%s" />'%src
2440: return tag
2441:
2442: def createMapLink(self, ob, text=None):
2443: """generate map link"""
2444: bt = BrowserCheck(self)
2445: id = ob[1]
2446: link = ob[1]
2447: if text == None:
2448: text = ob[2]
2449: tag = ""
2450: if bt.isN4:
2451: tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
2452: tag += ">" + text + "</a></ilayer>"
2453: else:
2454: tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
2455: if ob[3].contentType == 'text-popup':
2456: tag += ' title="%s"'%ob[3].description
2457: tag += ">" + text + "</a>"
2458: return tag
2459:
2460: def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):
2461: """generate map link image, text and other stuff"""
2462: id = ob[1]
2463: link = ob[1]
2464: vtype = ob[5]
2465: ctype = ob[3].contentType
2466: bt = BrowserCheck(self)
2467: tag = ""
2468:
2469: if bt.isN4:
2470: tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
2471: if vtype == "view point":
2472: rot = ob[4][4]
2473: tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,arrowsrc,rot)
2474: else:
2475: tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
2476: if ctype == "text-popup":
2477: desc = ob[3].description
2478: tag += ' alt="%s"'%desc
2479: tag += ' /></a>'
2480: tag += '</layer>'
2481: else:
2482: tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)
2483: if vtype == "view point":
2484: rot = ob[4][4]
2485: if bt.isIEWin and bt.versIE > 5:
2486: 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)
2487: else:
2488: tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,arrowsrc,rot)
2489: else:
2490: if bt.isIEWin:
2491: tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;background:url(area_img)"'%(id)
2492: else:
2493: tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
2494: if ctype == "text-popup":
2495: desc = ob[3].description
2496: tag += ' title="%s"'%desc
2497: tag += '> </div>'
2498: tag += '</a>'
2499: return tag
2500:
2501:
2502: security.declarePublic('getCreditObject')
2503: def getCreditObject(self,name):
2504: """credit id to credititem"""
2505: try:
2506: return getattr(self.partners,name)
2507: except:
2508: return ""
2509:
2510: security.declarePublic('ECHO_generateNavBar')
2511: def ECHO_generateNavBar(self):
2512: """Erzeuge Navigationsbar"""
2513: link=""
2514: object="self"
2515: ret=[]
2516: path=self.getPhysicalPath()
2517: for element in path:
2518:
2519:
2520: if not element=="":
2521: object+="."+element
2522:
2523: label=eval(object).label
2524: link+="/"+element
2525: if not label=="":
2526: ret.append((label,link))
2527: return ret
2528:
2529: security.declarePublic('ECHO_rerenderLinksMD')
2530:
2531:
2532: def ECHO_rerenderLinksMDWarning(self):
2533: """change form"""
2534: pt=PageTemplateFile('Products/ECHO_content/zpt/rerenderLinksWarning').__of__(self)
2535: pt.content_type="text/html"
2536: return pt()
2537:
2538:
2539:
2540: def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
2541: """Rerender all Links"""
2542: return ECHO_rerenderLinksMD(self,obj,types)
2543:
2544:
2545: security.declarePublic('ECHO_newViewerLink')
2546:
2547:
2548: def getCoords(self):
2549: try:
2550:
2551: x= [string.join(x,",") for x in self.coords]
2552: return x
2553:
2554: except:
2555:
2556: return []
2557:
2558: def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
2559:
2560:
2561: self.id = id
2562: """Festlegen der ID"""
2563: self.credits=toList(credits)
2564: self.label = label
2565: self.title=title
2566: self.description=description
2567: self.contentType=contentType
2568: self.responsible=responsible
2569: self.imageTag=imageTag
2570: self.weight=weight
2571: self.sortfield=sortfield
2572: coordsnew=[ string.split(x,",") for x in coords]
2573: self.coords=coordsnew
2574: self.secondaryLinkTitle=secondaryLinkTitle
2575: self.secondaryLink=secondaryLink
2576: self.bgcolour=bgcolour
2577:
2578:
2579: manage_options = Folder.manage_options+ Cacheable.manage_options+(
2580: {'label':'Main Config','action':'ECHO_collection_config'},
2581: {'label':'Change Labels','action':'changeLabels'},
2582: {'label':'Change Titles','action':'changeTitles'},
2583: {'label':'Change Weights','action':'changeWeights'},
2584: {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},
2585: {'label':'Graphics','action':'ECHO_graphicEntry'},
2586: {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
2587: {'label':'Set Startpage','action':'setStartpageFolderForm'},
2588: {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},
2589: {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
2590: {'label':'ImportCollection','action':'updateCollection'},
2591: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
2592: )
2593:
2594: def getOverview(self):
2595: """overview graphics"""
2596:
2597: return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
2598:
2599:
2600: def ECHO_graphicEntry(self):
2601: """DO nothing"""
2602: overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
2603:
2604:
2605: if overview:
2606: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
2607: return pt()
2608: else:
2609: return "NO OVERVIEW GRAPHICS"
2610:
2611: def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
2612: """Enter coords"""
2613: coords=self.coords
2614: temco=coordstr.split(",")
2615: temco.append(angle)
2616: coords.append(temco)
2617: self.coords=coords[0:]
2618:
2619: if RESPONSE is not None:
2620: RESPONSE.redirect('ECHO_graphicEntry')
2621:
2622:
2623: security.declarePublic('ECHO_collection_config')
2624: def ECHO_collection_config(self):
2625: """Main configuration"""
2626:
2627: if not hasattr(self,'weight'):
2628: self.weight=""
2629:
2630: if not hasattr(self,'sortfield'):
2631: self.sortfield="weight"
2632:
2633: if not hasattr(self,'coords'):
2634: self.coords=[]
2635:
2636: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)
2637: return pt()
2638:
2639:
2640: security.declarePublic('changeECHO_collection')
2641:
2642:
2643: def getBgcolour(self):
2644: """colour"""
2645: if hasattr(self,'bgcolour') and not (self.bgcolour==""):
2646: return self.bgcolour
2647: else:
2648: return "#dddddd"
2649:
2650: 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,isAlwaysClickable=None):
2651: """Aenderung der Properties"""
2652:
2653: self.secondaryLink=secondaryLink
2654: self.secondaryLinkTitle=secondaryLinkTitle
2655: self.imageTag=imageTag
2656: self.bgcolour=bgcolour
2657: self.viewClassification=viewClassification
2658: self.location=location
2659: self.isAlwaysClickable=isAlwaysClickable
2660:
2661: if coords:
2662: coordsnew=[ string.split(x,",") for x in coords]
2663: self.coords=coordsnew[0:]
2664: else:
2665: coordsnew=None
2666: self.coords=None
2667:
2668: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
2669: try:
2670: self.coords=coordsnew[0:] # HACK fehler in setECHO_collection
2671: except:
2672: """none"""
2673:
2674: self.sortfield=sortfield
2675:
2676: if RESPONSE is not None:
2677: RESPONSE.redirect('manage_main')
2678:
2679: def setAlwaysClickable(self,flag="yes"):
2680: """set clickable"""
2681: if flag=="yes":
2682: self.isAlwaysClickable="yes"
2683: else:
2684: self.isAlwaysClickable=None
2685:
2686: return flag
2687:
2688: def showOverview(self):
2689: """overview"""
2690: if 'ECHO_overview.html' in self.__dict__.keys():
2691: return getattr(self,'ECHO_overview.html')()
2692: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
2693: return pt()
2694:
2695: security.declareProtected('View','index_html')
2696:
2697: def index_html(self):
2698: """standard page"""
2699: if self.ZCacheable_isCachingEnabled():
2700:
2701: result = self.ZCacheable_get()
2702: if result is not None:
2703: # Got a cached value.
2704: return result
2705:
2706: if 'index.html' in self.__dict__.keys():
2707: ret=getattr(self,'index.html')()
2708:
2709: elif 'overview' in self.__dict__.keys():
2710: ret=self.showOverview()
2711: elif hasattr(self,'collection_index_template'):
2712: ret=self.collection_index_template()
2713: elif hasattr(self,'main_index_template'):
2714: ret=self.main_index_template()
2715: else:
2716: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
2717: pt.content_type="text/html"
2718: ret=pt.render()
2719:
2720: self.ZCacheable_set(ret)
2721: return ret
2722:
2723: def content_html(self):
2724: """template fuer content"""
2725: return content_html(self,'collection')
2726:
2727: def getCredits(self):
2728: """Ausgabe der credits"""
2729: if self.credits:
2730: return self.credits
2731: else:
2732: return []
2733:
2734: def area_img(self):
2735: """area image"""
2736: bt = BrowserCheck(self)
2737: if bt.isIE or bt.isN4:
2738: return sendFile(self, 'images/red.gif', 'image/gif')
2739: else:
2740: return sendFile(self, 'images/reda.png', 'image/png')
2741:
2742: def trans_img(self):
2743: """empty image"""
2744: return sendFile(self, 'images/trans.gif', 'image/gif')
2745:
2746: def hl_lib_js(self):
2747: """javascript"""
2748: return sendFile(self, 'js/hl_lib.js', 'text/plain')
2749:
2750: def js_lib_js(self):
2751: """javascript"""
2752: return sendFile(self, 'js/js_lib.js', 'text/plain')
2753:
2754: def getGraphicCoords(self):
2755: """Give list of coordinates"""
2756: subColTypes=['ECHO_collection','ECHO_resource']
2757: ids=[]
2758: for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):
2759: object=entrySearch[1]
2760: if hasattr(object,'coords'):
2761: for coordtemp in object.coords:
2762: if len(coordtemp)>3:
2763: coord=coordtemp[0:4]
2764: label=""
2765: vc=""
2766: if hasattr(object,'label') and not object.label=="":
2767: label=object.label
2768: elif hasattr(object,'title') and not object.title=="":
2769: label=object.title
2770: else:
2771: label=object.getId()
2772: if object.viewClassification != "":
2773: vc=object.viewClassification
2774: else:
2775: if len(coordtemp) > 4 and coordtemp[4] != "":
2776: vc="view point"
2777: else:
2778: vc="area"
2779: ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,vc])
2780: return ids
2781:
2782:
2783:
2784:
2785: getSubCols = ECHO_helpers.getSubCols
2786:
2787: Globals.InitializeClass(ECHO_collection)
2788:
2789: def manage_addECHO_collectionForm(self):
2790: """Add collection form"""
2791: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
2792: return pt()
2793:
2794:
2795: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
2796: """add a echo collection"""
2797:
2798:
2799: newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
2800:
2801: self._setObject(id,newObj)
2802:
2803: if RESPONSE is not None:
2804: RESPONSE.redirect('manage_main')
2805:
2806: class ECHO_group(ECHO_collection):
2807: """ECHO Gruppe"""
2808: security=ClassSecurityInfo()
2809: meta_type="ECHO_group"
2810:
2811: manage_options = Folder.manage_options+(
2812: {'label':'Main Config','action':'ECHO_group_config'},
2813: {'label':'Rerender Links','action':'ECHO_rerenderLinksMDWarning'},
2814: {'label':'Graphics','action':'ECHO_graphicEntry'},
2815: )
2816:
2817: security.declareProtected('View','index_html')
2818:
2819: def showRDF(self):
2820: """showrdf"""
2821: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
2822: ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""
2823: ret+=self.getRDF(urn="echo:collectionroot")+"\n"
2824:
2825: ret+="""</RDF:RDF>"""
2826:
2827: return ret
2828:
2829: def getRDF(self,urn=None):
2830: """rdf of the collection"""
2831: contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
2832:
2833: ret=getRDFDescription(self,self.absolute_url(),urn=urn)
2834:
2835:
2836: if not urn:
2837: urn=self.absolute_url()
2838: li="""<RDF:li RDF:resource="%s" />\n"""
2839:
2840:
2841: for content in contents:
2842: ret+=content[1].getRDF()+"\n"
2843:
2844: ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
2845: for content in contents:
2846: nurn=content[1].absolute_url()
2847: ret+=li%nurn
2848: return ret+"</RDF:Seq>"
2849:
2850: def index_html(self):
2851: """standard page"""
2852: displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
2853: #if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
2854: # return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
2855:
2856: if 'index.html' in self.__dict__.keys():
2857: return getattr(self,'index.html')()
2858:
2859: elif 'overview' in self.__dict__.keys():
2860: return self.showOverview()
2861: elif hasattr(self,'group_index_template'):
2862: return self.group_index_template()
2863: elif hasattr(self,'collection_index_template'):
2864: return self.collection_index_template()
2865: elif hasattr(self,'main_index_template'):
2866: return self.main_index_template()
2867:
2868: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
2869: pt.content_type="text/html"
2870: return pt()
2871:
2872: def ECHO_group_config(self):
2873: """Main configuration"""
2874:
2875: if not hasattr(self,'weight'):
2876: self.weight=""
2877:
2878: if not hasattr(self,'sortfield'):
2879: self.sortfield="weight"
2880:
2881: if not hasattr(self,'coords'):
2882: self.coords=[]
2883:
2884: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
2885: return pt()
2886:
2887: def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
2888: """Ănderung der Properties"""
2889:
2890: self.secondaryLink=secondaryLink
2891: self.secondaryLinkTitle=secondaryLinkTitle
2892: self.imageTag=imageTag
2893: self.bgcolour=bgcolour
2894: self.logo=logo
2895:
2896: if coords:
2897: coordsnew=[ string.split(x,",") for x in coords]
2898: self.coords=coordsnew[0:]
2899: else:
2900: coordsnew=None
2901: self.coords=None
2902:
2903: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
2904:
2905:
2906:
2907: self.sortfield=sortfield
2908:
2909: if RESPONSE is not None:
2910: RESPONSE.redirect('manage_main')
2911:
2912: def getLogo(self):
2913: """logo ausgeben"""
2914: try:
2915: return self.logo
2916: except:
2917: return "ECHO_groups"
2918:
2919: def content_html(self):
2920: """template fuer content"""
2921: return content_html(self,'group')
2922:
2923:
2924:
2925: def manage_addECHO_groupForm(self):
2926: """Add group form"""
2927: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
2928: return pt()
2929:
2930:
2931: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
2932: """add a echo group"""
2933:
2934:
2935: newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
2936:
2937: setattr(newObj,'logo',logo)
2938: self._setObject(id,newObj)
2939:
2940: if RESPONSE is not None:
2941: RESPONSE.redirect('manage_main')
2942:
2943: Globals.InitializeClass(ECHO_group)
2944:
2945:
2946: class ECHO_userFolder(UserFolder):
2947: """User folder for Intranet"""
2948: _domain_auth_mode=1 # Identification via domain
2949: meta_type="ECHO_userFolder"
2950:
2951: def authenticate(self, name, password, request):
2952: emergency = self._emergency_user
2953: if name is None:
2954: return None
2955: if emergency and name==emergency.getUserName():
2956: user = emergency
2957: else:
2958: user = self.getUser(name)
2959: if user is not None and user.authenticate(password, request):
2960: return user
2961: else:
2962: return None
2963:
2964: def domainSpecMatch(self,spec, request):
2965: host=''
2966: addr=''
2967:
2968: # Fast exit for the match-all case
2969: if len(spec) == 1 and spec[0] == '*':
2970: return 1
2971:
2972: if request.has_key('REMOTE_HOST'):
2973: host=request['REMOTE_HOST']
2974:
2975: if request.has_key('REMOTE_ADDR'):
2976: addr=request['REMOTE_ADDR']
2977:
2978: if request.has_key('HTTP_X_FORWARDED_FOR'):
2979: addr=request['HTTP_X_FORWARDED_FOR']
2980:
2981:
2982: if not host and not addr:
2983: return 0
2984:
2985: if not host:
2986: try: host=socket.gethostbyaddr(addr)[0]
2987: except: pass
2988: if not addr:
2989: try: addr=socket.gethostbyname(host)
2990: except: pass
2991:
2992:
2993: _host=host.split('.')
2994: _addr=addr.split('.')
2995: _hlen=len(_host)
2996: _alen=len(_addr)
2997:
2998: for ob in spec:
2999: sz=len(ob)
3000: _ob=ob.split('.')
3001: _sz=len(_ob)
3002:
3003: mo = addr_match(ob)
3004: if mo is not None:
3005: if mo.end(0)==sz:
3006: fail=0
3007: for i in range(_sz):
3008: a=_addr[i]
3009: o=_ob[i]
3010: if (o != a) and (o != '*'):
3011: fail=1
3012: break
3013: if fail:
3014: continue
3015: return 1
3016:
3017: mo = host_match(ob)
3018: if mo is not None:
3019: if mo.end(0)==sz:
3020: if _hlen < _sz:
3021: continue
3022: elif _hlen > _sz:
3023: _item=_host[-_sz:]
3024: else:
3025: _item=_host
3026: fail=0
3027: for i in range(_sz):
3028: h=_item[i]
3029: o=_ob[i]
3030: if (o != h) and (o != '*'):
3031: fail=1
3032: break
3033: if fail:
3034: continue
3035: return 1
3036: return 0
3037:
3038: Globals.default__class_init__(ECHO_userFolder)
3039:
3040:
3041:
3042: def manage_addECHO_userFolder(self,dtself=None,REQUEST=None,**ignored):
3043: """add a user folder """
3044: f=ECHO_userFolder()
3045: self=self.this()
3046: try: self._setObject('acl_users', f)
3047: except: return MessageDialog(
3048: title ='Item Exists',
3049: message='This object already contains a User Folder',
3050: action ='%s/manage_main' % REQUEST['URL1'])
3051: self.__allow_groups__=f
3052: if REQUEST is not None:
3053: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
3054:
3055: def manage_addECHO_userFolderForm(self):
3056: """add a user folder form"""
3057: return manage_addECHO_userFolder(self)
3058:
3059:
3060:
3061: def createNode(self,descrs,node):
3062: name=descrs[node]['name']
3063: type=descrs[node]['type']
3064: urn=node
3065: #print " will create",node.encode('utf-8')
3066: id=re.sub('[^a-zA-Z0-9]','',name).encode('ascii','ignore')
3067: #print "id",id
3068: #print type
3069: #self.REQUEST.RESPONSE.write("<p>%s<p>\n"%id)
3070: if type=="CDLI_group":
3071:
3072: try:
3073: manage_addECHO_collection(self,id,name,name,"","","","","")
3074:
3075: except:
3076: self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
3077:
3078: self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
3079:
3080: return type,getattr(self,id),urn
3081:
3082: if type=="CDLI_item":
3083: try:
3084: manage_addECHO_resource(self,id,name,name,"","",urn,"","")
3085: except:
3086: self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
3087: self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
3088:
3089:
3090: return "XX"
3091:
3092:
3093: class ECHO_root(Folder,Persistent,Implicit):
3094: """ECHO Root Folder"""
3095:
3096: security=ClassSecurityInfo()
3097:
3098: meta_type="ECHO_root"
3099:
3100: ###CDLI adds -> have to be removed
3101: def getTablet(self,item):
3102: #print "getTablet"
3103: try:
3104: read=urllib.urlopen("http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"%item).read()
3105: read=re.sub("\[search\]","search",read)
3106: return read[read.find("<body>")+6:read.rfind("</body>")]
3107: except:
3108: return "<h1>Sorry no connection to the data server enlil.museum.upenn.edu</h1>"
3109: #return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"
3110: ###END CDLI add
3111:
3112:
3113: def checkResource(self,id):
3114: """checks if a resource is in the tree, gives back none or list of resources"""
3115: if hasattr(self,"_v_checkResource") and self._v_checkResource.has_key(id): #existiert ein cache und id ist bereits drin?
3116: return self._v_checkResource[id]
3117:
3118: else:
3119: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],obj_ids=[id],search_sub=1)
3120:
3121: if not hasattr(self,"_v_checkResource"): self._v_checkResource={}#lege cache an falls nicht existent
3122: if resources:
3123: self._v_checkResource[id]=resources[0:] # slicing to be sure that data is stabil
3124: else:
3125: self._v_checkResource[id]=None
3126:
3127: return self._v_checkResource[id]
3128:
3129: def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):
3130: """sendform"""
3131: toaddrs=["dwinter@mpiwg-berlin.mpg.de"]
3132:
3133: msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n"
3134: % (fromaddr, ", ".join(toaddrs),"testsub"))
3135: server = smtplib.SMTP(server)
3136: #server.set_debuglevel(1)
3137: msg=msg+content
3138: server.sendmail(fromaddr, toaddrs, msg)
3139: server.quit()
3140:
3141: def generateFromRDFForm(self):
3142: """change form"""
3143: pt=PageTemplateFile('Products/ECHO_content/zpt/generateFromRDFForm').__of__(self)
3144: pt.content_type="text/html"
3145: return pt()
3146:
3147: def generateFromRDF(self,file,startNode="/Cuneiform Corpus"):
3148:
3149: """generate from RDF"""
3150:
3151: global seqs
3152: seqs={}
3153: global descrs
3154: descrs={}
3155: global key
3156: key=""
3157: global value
3158: value=""
3159:
3160: def getEdges(seqs,urn):
3161: """edges"""
3162: ret=[]
3163: return seqs[urn]
3164:
3165: def createSubs(self,seqs,descrs,urn,level=0):
3166: """create subs"""
3167: for edge in getEdges(seqs,urn):
3168: cn=createNode(self,descrs,edge)
3169: if cn[0]=="CDLI_group":
3170: createSubs(cn[1],seqs,descrs,cn[2],level+1)
3171: return
3172:
3173: def start_element(name,attrs):
3174:
3175: global seqs
3176: global descrs
3177: global key
3178: global value
3179: seq=""
3180: if name=="RDF:Seq":
3181: key=attrs.get('RDF:about')
3182: try: # teste ob liste
3183: x=seqs[key][0]
3184: except:
3185:
3186: seqs[key]=[]
3187:
3188:
3189: elif name=="RDF:Description":
3190: key=attrs.get('RDF:about')
3191:
3192:
3193: elif name=="RDF:li":
3194: name=attrs.get('RDF:resource')
3195: seqs[key].append(name)
3196:
3197: elif name=="ECHONAVIGATION:type":
3198: value="type"
3199:
3200: elif name=="ECHONAVIGATION:name":
3201: value="name"
3202: elif name=="ECHONAVIGATION:linkClickable":
3203: value="linkClickable"
3204:
3205: def end_element(name):
3206: """nothing"""
3207: key=""
3208: value=""
3209:
3210: def char_data(data):
3211: """nothing"""
3212:
3213: data=re.sub("\n","",data)
3214: try:
3215: if descrs[key].has_key(value):
3216: descrs[key][value]+=data
3217: else:
3218: descrs[key][value]=data
3219: except:
3220:
3221: descrs[key]={}
3222: descrs[key][value]=data
3223:
3224: p = xml.parsers.expat.ParserCreate()
3225:
3226: p.StartElementHandler = start_element
3227: p.EndElementHandler = end_element
3228: p.CharacterDataHandler = char_data
3229:
3230:
3231: p.ParseFile(file)
3232: self.REQUEST.RESPONSE.write("<html><body><h1>Start</h1>")
3233: createSubs(self,seqs,descrs,startNode)
3234: self.REQUEST.RESPONSE.write("<h1>done</h1></body></html>")
3235: #print "done"
3236:
3237:
3238: return "done"
3239:
3240:
3241:
3242:
3243: def changeWeightsInCollection(self):
3244: """change all lables of a collection"""
3245: ret=""
3246: argv=self.REQUEST.form
3247:
3248: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
3249: for resource in resources:
3250:
3251: try:
3252: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
3253: resource[1].weight=argv[resource[1].getId()][0:]
3254: except:
3255: """not"""
3256: return ret
3257:
3258: def changeWeights(self):
3259: """change form"""
3260: pt=PageTemplateFile('Products/ECHO_content/zpt/changeWeightForm').__of__(self)
3261: pt.content_type="text/html"
3262: return pt()
3263: getSubCols = ECHO_helpers.getSubCols
3264:
3265: manage_options=Folder.manage_options+(
3266: {'label':'Main Config','action':'ECHO_copyright_configForm'},
3267: {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
3268: {'label':'Change Weights','action':'changeWeights'},
3269: {'label':'Generate from RDF','action':'generateFromRDFForm'},
3270:
3271: )
3272:
3273:
3274: def showRDF(self):
3275: """showrdf"""
3276: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
3277: ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""
3278: ret+=self.getRDF(urn="echo:collectionroot")+"\n"
3279:
3280: ret+="""</RDF:RDF>"""
3281: return ret
3282:
3283:
3284: def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
3285: """warning"""
3286: pt=PageTemplateFile('Products/ECHO_content/zpt/reloadMetaDataFromStorageWarning.zpt').__of__(self)
3287: pt.content_type="text/html"
3288: return pt()
3289:
3290: def reloadMetaDataFromStorage(self,RESPONSE=None):
3291: """reload MD from Storage"""
3292:
3293: return reloadMetaDataFromStorage(self,RESPONSE)
3294:
3295: def getRDF(self,urn=None):
3296: """rdf of the collection"""
3297:
3298: contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
3299:
3300: ret=getRDFDescription(self,self.absolute_url(),urn=urn)
3301:
3302: li="""<RDF:li RDF:resource="%s" />\n"""
3303:
3304:
3305: for content in contents:
3306: ret+=content[1].getRDF()+"\n"
3307:
3308: ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
3309: for content in contents:
3310: nurn=content[1].absolute_url()
3311: ret+=li%nurn
3312: return ret+"</RDF:Seq>"
3313:
3314:
3315: def showContent(self,path):
3316: """return content/html"""
3317:
3318: return ECHO_helpers.urlopen(path+"/content_html").read()
3319:
3320: def getImageViewers(self):
3321: """images"""
3322: viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])
3323: return viewers
3324:
3325:
3326: def getBibTag(self,tag,content):
3327: """get field tag fĂźr index-meta-generation"""
3328: if not content or content=="":
3329: return ""
3330: ret="<%s>"%tag
3331: #ret+=urllib.quote(content)
3332: ret+=content
3333:
3334: ret+="</%s>"%tag
3335: return ret
3336:
3337: def getValueFromClass(self,field,found):
3338: """retattribute falss existing"""
3339: try:
3340:
3341: return getattr(found,field).decode('ascii','ignore')
3342: except:
3343: return ""
3344:
3345: def getImageTag(self):
3346: """needed by main_template"""
3347: return ""
3348: secondaryLink="" #needed by main_template
3349: secondaryLinkTitle="" #needed by main_template
3350:
3351: def getBgcolour(self):
3352: """hack"""
3353: return "#dddddd"
3354:
3355: def contentTypeSelector_HTML(self,selected=None):
3356: """give type selector"""
3357: if not selected:
3358: retStr="<option selected>\n"
3359: else:
3360: retStr="<option>\n"
3361:
3362: try: # erste version contentTypes exists
3363: for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
3364: if selected and (contentType[0]==selected):
3365: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
3366: else:
3367: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
3368: except:
3369: try:
3370: for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
3371: if selected and (contentType[0]==selected):
3372: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
3373: else:
3374: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
3375: except:
3376: """nothing"""
3377:
3378: return retStr
3379:
3380: def renderingTypeSelector_HTML(self,selected=None):
3381: """give type selector"""
3382: if not selected:
3383: retStr="<option selected>\n"
3384: else:
3385: retStr="<option>\n"
3386:
3387: try: # erste version renderingTypes exists
3388: for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
3389: if selected and (renderingType[0]==selected):
3390: retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
3391: else:
3392: retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
3393: except:
3394: """nothing"""
3395: return retStr
3396:
3397: def renderingTypeSelector_HTML(self,selected=None):
3398: """give type selector"""
3399: if not selected:
3400: retStr="<option selected>\n"
3401: else:
3402: retStr="<option>\n"
3403:
3404: try: # erste version renderingTypes exists
3405: for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
3406: if selected and (renderingType[0]==selected):
3407: retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
3408: else:
3409: retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
3410: except:
3411: """nothing"""
3412: return retStr
3413:
3414:
3415: def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):
3416: """give type selector"""
3417:
3418: if not first:
3419: if not selected:
3420: retStr="<option selected>\n"
3421: else:
3422: retStr="<option>\n"
3423: else:
3424: if not selected:
3425: retStr="""<option selected value="%s">%s\n"""%first
3426: else:
3427: retStr="""<option value="%s">%s\n"""%first
3428:
3429:
3430: try: # erste version copyrightTypes exists
3431: for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
3432: if selected and (copyrightType[0]==selected):
3433: retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3434: else:
3435: retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3436:
3437: for copyrightTypeSelf in self.ZopeFind(object,obj_metatypes=["ECHO_copyrightType"],search_sub=1):
3438: if selected and (copyrightTypeSelf[0]==selected):
3439: retStr+="""<option selected value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
3440: else:
3441: retStr+="""<option value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
3442:
3443: except:
3444: """nothing"""
3445:
3446: return retStr
3447:
3448: def partnerSelector_HTML(self,selected=None):
3449: """give type selector"""
3450: if not selected:
3451: retStr="<option selected>\n"
3452: else:
3453: retStr="<option>\n"
3454:
3455: try: # erste version copyrightTypes exists
3456: for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):
3457: if selected and (copyrightType[0]==selected):
3458: retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3459: else:
3460: retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3461: except:
3462: """nothing"""
3463: return retStr
3464:
3465: mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version Ăźber echoroot??
3466:
3467: def mediaTypeSelector_HTML(self,selected=None):
3468: """give type selector"""
3469: if not selected:
3470: retStr="<option selected>\n"
3471: else:
3472: retStr="<option>\n"
3473:
3474: try: # erste version mediatypesTypes exists
3475: for mediaType in self.mediaTypes:
3476: if selected and (mediaType in selected):
3477: retStr+="""<option selected value="%s">%s\n"""%(mediaType,mediaType)
3478: else:
3479: retStr+="""<option value="%s">%s\n"""%(mediaType,mediaType)
3480: except:
3481: """nothing"""
3482: return retStr
3483:
3484:
3485: def patchContentType(self,obj=None):
3486: """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
3487:
3488:
3489: if not obj:
3490: obj = self
3491:
3492: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
3493:
3494: for entry in entries:
3495: setattr(entry[1],'contentType',entry[1].content_type)
3496: #entry[1].contentType == entry[1].content_type
3497:
3498: if entry[1].meta_type == 'ECHO_collection':
3499: entry[1].patchContentType(entry[1])
3500:
3501:
3502: return "changed all contenttypes in: "+self.title
3503:
3504:
3505: def patchViewClassification(self,obj=None):
3506: """setze viewClassification heuristisch"""
3507:
3508: def checkIfArrow(obj):
3509: if hasattr(obj,'coords'):
3510: for coordtemp in obj.coords:
3511:
3512: if (len(coordtemp)>4) and not (coordtemp[4]==''):
3513: return 4
3514: return None
3515: return None
3516:
3517: if not obj:
3518: obj = self
3519:
3520: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
3521:
3522: for entry in entries:
3523:
3524: if checkIfArrow(entry[1]):
3525: setattr(entry[1],'viewClassification','view point')
3526: else:
3527: setattr(entry[1],'viewClassification','area')
3528:
3529: #entry[1].contentType == entry[1].content_type
3530:
3531: if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
3532: entry[1].patchViewClassification(entry[1])
3533:
3534:
3535: return "changed all contenttypes in: "+self.title
3536:
3537: def deleteCache(self,obj=None,RESPONSE=None):
3538: """setze alle collections auf cache = CacheManager"""
3539:
3540:
3541: if not obj:
3542: obj = self
3543:
3544: entries=obj.ZopeFind(obj,search_sub=1)
3545:
3546: for entry in entries:
3547: if hasattr(entry[1],'_v_hash'):
3548: entry[1]._v_hash=None
3549:
3550:
3551:
3552:
3553: return "changed all CM in: "+self.title
3554:
3555:
3556:
3557: def ECHO_newViewerLink(self,obj=None):
3558: """change links (:86 faellt weg)"""
3559:
3560: if not obj:
3561: obj = self
3562:
3563: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
3564:
3565: for entry in entries:
3566:
3567: if entry[1].meta_type == 'ECHO_resource':
3568:
3569: entry[1].link=re.sub('\:86','',entry[1].link)
3570:
3571: else:
3572:
3573: entry[1].ECHO_newViewerLink(entry[1])
3574:
3575: return "Rerenderd all links to resources in: "+self.title
3576:
3577: def __init__(self,id,title):
3578: """init"""
3579: self.id = id
3580: self.title=title
3581:
3582: def deleteSpace(self,str):
3583: """delete space at the end of a line"""
3584: if str[len(str)-1]==" ":
3585: return str[0:len(str)-1]
3586: else:
3587: return str
3588:
3589:
3590:
3591: # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
3592:
3593: def formatAscii(self,str,url=None):
3594: """ersetze ascii umbrueche durch <br>"""
3595: #url=None
3596: if url:
3597:
3598: retStr=""
3599: words=str.split("\n")
3600:
3601: for word in words:
3602: strUrl=url%word
3603:
3604: retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
3605: str=retStr
3606: if str:
3607: return re.sub(r"[\n]","<br/>",str)
3608: else:
3609: return ""
3610:
3611: def link2html(self,str):
3612: """link2html fuer VLP muss hier noch raus"""
3613: if str:
3614:
3615: str=re.sub("\&","&",str)
3616: dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>")
3617: links=dom.getElementsByTagName("link")
3618:
3619:
3620: for link in links:
3621: link.tagName="a"
3622: ref=link.getAttribute("ref")
3623: pn=link.getAttribute("page")
3624:
3625: if self.checkRef(ref):
3626: if pn:
3627: link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)
3628: else:
3629: link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
3630:
3631:
3632: newxml=dom.toxml('utf-8')
3633:
3634: retStr=regexpTXT.search(newxml)
3635:
3636: return retStr.group(1)
3637:
3638:
3639: return ""
3640:
3641: def xml2html(self,str,quote="yes"):
3642: """link2html fuer VLP muss hier noch raus"""
3643:
3644: if str:
3645: if quote=="yes2":
3646: str=re.sub("\&","&",str)
3647: #dom=xml.dom.minidom.parseString(str)
3648: dom = NonvalidatingReader.parseString(str,"http://www.mpiwg-berlin.mpg.de/")
3649: #links=dom.getElementsByTagName("link")
3650: links=Ft.Xml.XPath.Evaluate(".//link", contextNode=dom)
3651: for link in links:
3652: #link.tagName="a"
3653:
3654: ref=link.getAttributeNS(EMPTY_NAMESPACE,"ref")
3655: pn=link.getAttributeNS(EMPTY_NAMESPACE,"page")
3656:
3657: cns=link.childNodes[0:]
3658:
3659: newLink=dom.createElementNS(EMPTY_NAMESPACE,"a")
3660: for x in cns:
3661: newLink.appendChild(x)
3662:
3663:
3664:
3665: link.parentNode.replaceChild(newLink,link)
3666: if self.checkRef(ref):
3667: if pn:
3668: newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)
3669: else:
3670: newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
3671:
3672: #str= dom.toxml('utf-8')
3673: buf = cStringIO.StringIO()
3674: PrettyPrint(dom, stream=buf, encoding='UTF-8')
3675: str = buf.getvalue()
3676: buf.close()
3677: #str=PrettyPrint(dom.documentElement,encoding='UTF-8')
3678: #print link.toxml('utf-8')
3679: #print type(str)
3680: retStr=regexpPage.search(str)
3681: try: # hack warum fehtl manchmal page??
3682: return retStr.group(1)
3683: except:
3684: return str
3685: return ""
3686:
3687: def checkRef(self,ref):
3688: if ref[0:3]=='lit':
3689: if len(self.library_data({ 'id':ref}))>0:
3690: return 1
3691: try:
3692: if ref[0:7]=="tec_cat":
3693: return 1
3694: except:
3695: """nothing"""
3696:
3697: dbs={'vl_technology':'','vl_people':'','vl_sites':''}
3698: res=None
3699: for db in dbs.keys():
3700: res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
3701: return res
3702:
3703: #Ende Methode fuer vlp
3704:
3705: def PgQuoteString(self,string):
3706: """Quote string"""
3707:
3708: return libpq.PgQuoteString(string)
3709:
3710: def getPartners(self):
3711: """Get list of Partners. Presently only from a subfolder partners"""
3712:
3713: return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
3714:
3715:
3716: def getInstitutions(self):
3717: """Get list of Partners. Presently only from a subfolder partners"""
3718:
3719: return [ item[1] for item in self.institutions.ZopeFind(self.institutions,obj_metatypes=['ECHO_institution'])]
3720:
3721:
3722: def getPartnersXML(self):
3723: """partner liste als xml"""
3724: partners=self.getPartners()
3725: ret="""<?xml version="1.0" encoding="utf-8" ?>
3726: <partners>"""
3727:
3728: for partner in partners:
3729: ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
3730:
3731: return ret+"\n</partners>"
3732:
3733: def getCollectionTree(self):
3734: """get the collection tree (list of triples (parent,child, depth)"""
3735:
3736: def getCollection(object,depth=0):
3737: depth+=1
3738: collections=[]
3739: for entry in object.__dict__.keys():
3740: element=getattr(object,entry)
3741: try:
3742: if element.meta_type=="ECHO_collection":
3743: collections.append((object,element,depth))
3744: collections+=getCollection(element,depth)
3745: except:
3746: """nothing"""
3747: return collections
3748:
3749:
3750: return getCollection(self)
3751:
3752: def getCollectionTreeIds(self):
3753: """Show the IDs of the Tree"""
3754: ret=[]
3755: for collection in self.getCollectionTree():
3756: ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
3757: return ret
3758:
3759: def getResourcesHTML(self,viewerType=None,filter=None):
3760: """gebe all ressourcen aus"""
3761:
3762: def sortHTML(x,y):
3763: return cmp(x[1].title,y[1].title)
3764:
3765: ret="""<html><body><h2>Resources in ECHO</h3>"""
3766:
3767: resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
3768: ret+="""<h3>Found %i resources</h3>"""%len(resources)
3769: resources.sort(sortHTML)
3770: for resource in resources:
3771: echo_url=resource[1].absolute_url()
3772:
3773: if hasattr(resource[1],'title'):
3774: title=resource[1].title
3775: else:
3776: title="None"
3777: if filter:
3778: if re.search(filter,title):
3779: ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
3780: else:
3781: ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
3782:
3783: ret +="""\n</body></html>"""
3784:
3785: #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
3786: #self.REQUEST.RESPONSE.write(ret)
3787: return ret
3788:
3789: def getResourcesXML(self,viewerType=None,filter=None):
3790: """gebe all ressourcen aus"""
3791: ret="""<?xml version="1.0" ?>
3792: <index>"""
3793: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
3794:
3795: echo_url=resource[1].absolute_url()
3796: if hasattr(resource[1],'link'):
3797: viewer_url=resource[1].link
3798: else:
3799: viewer_url="NO URL"
3800: if filter:
3801: if re.search(filter,viewer_url):
3802: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3803: else:
3804: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3805: ret +="""\n</index>"""
3806:
3807: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
3808: self.REQUEST.RESPONSE.write(ret)
3809:
3810: def getFullTextsXML(self,viewerType=None,filter=None):
3811: """gebe all ressourcen aus"""
3812: ret="""<?xml version="1.0" ?>
3813: <index>"""
3814: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
3815:
3816: echo_url=resource[1].absolute_url()
3817: if resource[1].getFullTextXML(noredirect="yes"):
3818: if hasattr(resource[1],'link'):
3819: viewer_url=echo_url+"/getFullTextXML"
3820: else:
3821: viewer_url="NO URL"
3822: if filter:
3823: if re.search(filter,viewer_url):
3824: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3825: else:
3826: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3827: ret +="""\n</index>"""
3828:
3829:
3830: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
3831: self.REQUEST.RESPONSE.write(ret)
3832:
3833:
3834: def getMetaDatasXML(self,viewerType=None,filter=None):
3835: """gebe all ressourcen aus"""
3836: # check if the request's host part was OK
3837: http_host = self.REQUEST['HTTP_HOST']
3838: host_port = self.REQUEST['SERVER_PORT']
3839: fix_host = None
3840: if http_host and http_host.rfind(host_port) == -1:
3841: print "HTTP_HOST needs fixing!"
3842: fix_host = http_host + ":" + host_port
3843:
3844: ret="""<?xml version="1.0" ?>
3845: <index>"""
3846: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
3847:
3848: echo_url=resource[1].absolute_url()
3849: if fix_host:
3850: #print "replacing ", http_host, " by ", fix_host
3851: echo_url = string.replace(echo_url, http_host, fix_host, 1)
3852:
3853: if hasattr(resource[1],'link'):
3854: meta_url=echo_url+"/getMetaDataXML"
3855: else:
3856: meta_url="NO_URL"
3857:
3858: if filter and not re.search(filter,viewer_url):
3859: continue
3860:
3861: #modificationDate=time.strptime(str(resource[1].bobobase_modification_time()),"%Y/%m/%d %H:%M:%S %Z")
3862:
3863: modificationDate=resource[1].bobobase_modification_time().strftime("%Y/%m/%d %H:%M:%S")
3864:
3865: ret+="""\n<resource resourceLink="%s" metaLink="%s" modificationDate="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'),modificationDate)
3866:
3867:
3868: ret +="""\n</index>"""
3869:
3870: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
3871: self.REQUEST.RESPONSE.write(ret)
3872:
3873:
3874: def findPartners(self):
3875: """find all partners in partners"""
3876: par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')
3877: return par
3878:
3879: def getPartnerFromID(self):
3880: """find partner form ID return object"""
3881: pa=self.REQUEST['partner']
3882: par=self.ZopeFind(self.partners, obj_ids=[pa])
3883: return par
3884:
3885: def getPartnerFromIDParameter(self, id):
3886: """ find partners from ID"""
3887: par=self.ZopeFind(self.partners, obj_ids=[id])
3888: return par
3889:
3890: def getInstitutionFromID(self,id):
3891: """ find institution from id """
3892: inst=self.ZopeFind(self.institutions, obj_ids=[id])
3893: return inst
3894:
3895:
3896: def manage_addECHO_root(self,id,title,RESPONSE=None):
3897: """Add an ECHO_root"""
3898: self._setObject(id,ECHO_root(id,title))
3899:
3900: if RESPONSE is not None:
3901: RESPONSE.redirect('manage_main')
3902:
3903: def manage_addECHO_rootForm(self):
3904: """Nothing yet"""
3905: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
3906: return pt()
3907:
3908: class ECHO_copyrightType(Folder):
3909: """copyright typ"""
3910:
3911: meta_type="ECHO_copyrightType"
3912:
3913: def __init__(self,id,title,label,url):
3914: """init"""
3915: self.id=id
3916: self.title=title
3917: self.label=label
3918: self.url=url
3919:
3920: manage_options = Folder.manage_options+(
3921: {'label':'Main Config','action':'ECHO_copyrightType_config_mainForm'},
3922: )
3923:
3924: def ECHO_copyrightType_config_mainForm(self):
3925: """change form"""
3926: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_copyrightType').__of__(self)
3927: pt.content_type="text/html"
3928: return pt()
3929:
3930: def ECHO_copyrightType_config_main(self,title,label,url,RESPONSE=None):
3931: """change"""
3932: self.title=title
3933: self.label=label
3934: self.url=url
3935:
3936: if RESPONSE is not None:
3937: RESPONSE.redirect('manage_main')
3938:
3939: def manage_addECHO_copyrightTypeForm(self):
3940: """Form for adding a ressource"""
3941: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_copyrightTypeForm.zpt').__of__(self)
3942: return pt()
3943:
3944:
3945: def manage_addECHO_copyrightType(self,id,title,label,url,RESPONSE=None):
3946: """addaresource"""
3947:
3948: newObj=ECHO_copyrightType(id,title,label,url)
3949:
3950: self._setObject(id,newObj)
3951:
3952: if RESPONSE is not None:
3953: RESPONSE.redirect('manage_main')
3954:
3955:
3956:
3957: class ECHO_partner(Image,Persistent):
3958: """ECHO Partner"""
3959:
3960: meta_type="ECHO_partner"
3961:
3962: def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):
3963: self.__name__=id
3964: self.title=title
3965: self.url=url
3966: self.person=person
3967: self.email=email
3968: self.country=country
3969: self.color=color
3970: self.precondition=precondition
3971: self.copyrightType=copyrightType
3972: data, size = self._read_data(file)
3973: content_type=self._get_content_type(file, data, id, content_type)
3974: self.update_data(data, content_type, size)
3975:
3976: manage_options = Image.manage_options+(
3977: {'label':'Partner Information','action':'ECHO_partner_config'},
3978: )
3979:
3980:
3981: def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):
3982: """Change main information"""
3983: self.url=url
3984: self.person=person
3985: self.email=email
3986: self.country=country
3987: self.color=color
3988: self.copyrightType=copyrightType
3989: if RESPONSE is not None:
3990: RESPONSE.redirect('manage_main')
3991:
3992:
3993:
3994: def ECHO_partner_config(self):
3995: """Main configuration"""
3996: if not hasattr(self,'url'):
3997: self.url=""
3998: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)
3999: return pt()
4000:
4001:
4002: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
4003: Kind='ECHO_partner',kind='ECHO_partner')
4004:
4005:
4006:
4007: def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',
4008: REQUEST=None):
4009: """
4010: Add a new ECHO_partner object.
4011:
4012: Creates a new ECHO_partner object 'id' with the contents of 'file'.
4013: Based on Image.manage_addImage
4014: """
4015:
4016: id=str(id)
4017: title=str(title)
4018: content_type=str(content_type)
4019: precondition=str(precondition)
4020:
4021: id, title = OFS.Image.cookId(id, title, file)
4022:
4023: self=self.this()
4024:
4025: # First, we create the image without data:
4026: self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))
4027:
4028: # Now we "upload" the data. By doing this in two steps, we
4029: # can use a database trick to make the upload more efficient.
4030: if file:
4031: self._getOb(id).manage_upload(file)
4032: if content_type:
4033: self._getOb(id).content_type=content_type
4034:
4035: if REQUEST is not None:
4036: try: url=self.DestinationURL()
4037: except: url=REQUEST['URL1']
4038: REQUEST.RESPONSE.redirect('%s/manage_main' % url)
4039: return id
4040:
4041: class ECHO_linkList(ZopePageTemplate):
4042: """LinkList Objekt"""
4043: meta_type="ECHO_linkList"
4044:
4045: _default_content_fn = os.path.join(package_home(globals()), 'html/ECHO_pageTemplateDefault.html')
4046:
4047: manage_options = ZopePageTemplate.manage_options+(
4048: {'label':'Main Config','action':'changeECHO_linkListWeightForm'},
4049: )
4050:
4051: def content_html(self):
4052: """content_html"""
4053: return content_html(self,'pageTemplate')
4054:
4055: def changeECHO_linkListWeightForm(self):
4056: """change"""
4057: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_linkListTemplate.zpt').__of__(self)
4058: return pt()
4059:
4060: def changeECHO_linkListWeight(self,contentType,label,RESPONSE=None):
4061: """change"""
4062: self.contentType=contentType
4063: self.label=label
4064:
4065: if RESPONSE is not None:
4066: RESPONSE.redirect('manage_main')
4067:
4068: def getLabel(self):
4069: if hasattr(self,'label'):
4070: return self.label.encode('utf-8')
4071: else:
4072: return 0
4073:
4074: def getcontentType(self):
4075: """get contentType"""
4076: if hasattr(self,'contentType'):
4077: return self.contentType
4078: else:
4079: return 0
4080:
4081: def __init__(self, id, label, title=None, text=None, contentType=None):
4082: self.id = str(id)
4083: self.title=title
4084: self.label=label
4085: self.ZBindings_edit(self._default_bindings)
4086: if text is None:
4087: text = ''
4088: self.pt_edit(text, contentType)
4089:
4090:
4091:
4092:
4093: def manage_addECHO_linkListForm(self):
4094: """Form for adding"""
4095: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkListTemplate.zpt').__of__(self)
4096: return pt()
4097:
4098: from urllib import quote
4099:
4100:
4101: def manage_addECHO_linkList(self, id, label,contentType=0,title=None, text=None,
4102: REQUEST=None, submit=None):
4103: """Add a LinkList with optional file content."""
4104:
4105: id = str(id)
4106: if REQUEST is None:
4107: self._setObject(id, ECHO_linkList(id, label, text))
4108: ob = getattr(self, id)
4109: setattr(ob,'contentType',contentType)
4110: if title:
4111: ob.pt_setTitle(title)
4112: return ob
4113: else:
4114: file = REQUEST.form.get('file')
4115: headers = getattr(file, 'headers', None)
4116: if (headers is None) or (not file.filename):
4117: zpt = ECHO_linkList(id, file)
4118: else:
4119: zpt = ECHO_linkList(id, label,'', file, headers.get('contentType'))
4120:
4121: self._setObject(id, zpt)
4122: ob = getattr(self, id)
4123: if title:
4124: ob.pt_setTitle(title)
4125:
4126: try:
4127: u = self.DestinationURL()
4128: except AttributeError:
4129: u = REQUEST['URL1']
4130:
4131: if submit == " Add and Edit ":
4132: u = "%s/%s" % (u, quote(id))
4133: REQUEST.RESPONSE.redirect(u+'/manage_main')
4134: return ''
4135:
4136:
4137: class ECHO_support(Folder):
4138: """gefÂrdert durch"""
4139: meta_type="ECHO_support"
4140:
4141:
4142:
4143: def __init__(self,id,institutions=None):
4144: """init"""
4145: self.id=id
4146: self.title=''
4147: self.institutions=toList(institutions)
4148:
4149: def getSupporter(self):
4150: """return institutions"""
4151: if self.institutions:
4152: return self.institutions
4153: else:
4154: return []
4155:
4156: manage_options = Folder.manage_options+(
4157: {'label':'Main Config','action':'ECHO_support_configForm'},
4158: )
4159:
4160: def ECHO_support_configForm(self):
4161: """change form"""
4162: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_support').__of__(self)
4163: pt.content_type="text/html"
4164: return pt()
4165:
4166: def ECHO_support_config(self,institutions=None,RESPONSE=None):
4167: """change"""
4168: self.institutions=toList(institutions)
4169:
4170: if RESPONSE is not None:
4171: RESPONSE.redirect('manage_main')
4172:
4173:
4174: def manage_addECHO_supportForm(self):
4175: """Form for adding"""
4176: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_support.zpt').__of__(self)
4177: return pt()
4178:
4179: def manage_addECHO_support(self, id,institutions=None,RESPONSE=None):
4180: """add the copyright"""
4181:
4182: meta_type="ECHO_support"
4183:
4184:
4185: self._setObject(id, ECHO_support(id,institutions))
4186:
4187: if RESPONSE is not None:
4188: RESPONSE.redirect('manage_main')
4189:
4190:
4191: class ECHO_institution(Image,Persistent):
4192: """ECHO Institution"""
4193:
4194: meta_type="ECHO_institution"
4195:
4196: def __init__(self, id, title,url, file, person, email, country, content_type='', precondition=''):
4197: self.__name__=id
4198: self.title=title
4199: self.url=url
4200: self.person=person
4201: self.email=email
4202: self.country=country
4203: self.precondition=precondition
4204: data, size = self._read_data(file)
4205: content_type=self._get_content_type(file, data, id, content_type)
4206: self.update_data(data, content_type, size)
4207:
4208: manage_options = Image.manage_options+(
4209: {'label':'Institution Information','action':'ECHO_institution_config'},
4210: )
4211:
4212:
4213: def changeECHO_institution(self,url,person, email, country,RESPONSE=None):
4214: """Change main information"""
4215: self.url=url
4216: self.person=person
4217: self.email=email
4218: self.country=country
4219: if RESPONSE is not None:
4220: RESPONSE.redirect('manage_main')
4221:
4222:
4223:
4224: def ECHO_institution_config(self):
4225: """Main configuration"""
4226: if not hasattr(self,'url'):
4227: self.url=""
4228: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_institution.zpt').__of__(self)
4229: return pt()
4230:
4231:
4232: manage_addECHO_institutionForm=DTMLFile('dtml/ECHO_institutionAdd',globals(),
4233: Kind='ECHO_institution',kind='ECHO_institution')
4234:
4235:
4236:
4237: def manage_addECHO_institution(self, id, url, person, email, country, file=None, title='', precondition='', content_type='',
4238: REQUEST=None):
4239: """
4240: Add a new ECHO_institution object.
4241:
4242: Creates a new ECHO_institution object 'id' with the contents of 'file'.
4243: Based on Image.manage_addImage
4244: """
4245:
4246: id=str(id)
4247: title=str(title)
4248: content_type=str(content_type)
4249: precondition=str(precondition)
4250:
4251: id, title = OFS.Image.cookId(id, title, file)
4252:
4253: self=self.this()
4254:
4255: # First, we create the image without data:
4256: self._setObject(id, ECHO_institution(id,title,url,'', person, email, country, content_type, precondition))
4257:
4258: # Now we "upload" the data. By doing this in two steps, we
4259: # can use a database trick to make the upload more efficient.
4260: if file:
4261: self._getOb(id).manage_upload(file)
4262: if content_type:
4263: self._getOb(id).content_type=content_type
4264:
4265: if REQUEST is not None:
4266: try: url=self.DestinationURL()
4267: except: url=REQUEST['URL1']
4268: REQUEST.RESPONSE.redirect('%s/manage_main' % url)
4269: return id
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>