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: resourcepath=readFieldFromXML(self.metalink,'resource','archive-path').replace('/mpiwg/online','')
1015:
1016: digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
1017: images=readFieldFromXML(self.metalink,'texttool','image')
1018:
1019: if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"
1020:
1021: if (not images) or (not resourcepath): return None
1022:
1023: return "%sfn=%s&pn=%i"%(digiliburlprefix,resourcepath+"/"+images,pn)
1024:
1025: def copyTitleToInfoXML(self):
1026: """copy title from the resource"""
1027: presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')
1028: resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
1029: print os.path.join(resourcepath,presentationXML)
1030: fh=file(os.path.join(resourcepath,presentationXML),'w')
1031: fh.write("""<info>
1032: <author></author>
1033: <title>%s</title>
1034: <date></date>
1035: <display>yes</display>
1036: </info>"""%self.title)
1037: fh.close()
1038:
1039:
1040: def setStartPage(self,startpage=None,RESPONSE=None):
1041: """set start page, if no startpage defined use the generic one of the resource"""
1042:
1043: if (not (type(startpage)==StringType)):
1044: if ("__generic" in startpage): # checke ob generic in der liste
1045: startpage=self.absolute_url()+"/startpage_html"
1046: elif ("__firstPage" in startpage): # checke ob generic in der liste
1047: startpage=self.createImageUrl()
1048:
1049: if (not startpage):
1050: startpage=self.absolute_url()+"/startpage_html"
1051: elif (startpage=="__generic"):
1052: startpage=self.absolute_url()+"/startpage_html"
1053: elif (startpage=="__firstPage"):
1054: startpage=self.createImageUrl()
1055:
1056: params="startpage=%s"%startpage
1057: 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))
1058:
1059: 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()
1060:
1061:
1062: path=self.metalink
1063:
1064: path=re.sub(self.REQUEST['SERVER_URL'],'',path)
1065: path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
1066:
1067: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
1068: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
1069: path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
1070: path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
1071: path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
1072: path=re.sub('http://vision.mpiwg-berlin.mpg.de','',path) # falls vision als server
1073: path=re.sub('http://xserve02.mpiwg-berlin.mpg.de:18880','',path) # falls vision als server
1074: path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
1075: path=re.sub('/index.meta','',path)
1076:
1077:
1078: ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
1079:
1080: if RESPONSE is not None:
1081: RESPONSE.redirect('manage_main')
1082:
1083: def changeViewerTemplateSetForm(self):
1084: """change the viewer template set"""
1085: pt=PageTemplateFile('Products/ECHO_content/zpt/changeResourceViewerTemplateSet').__of__(self)
1086: return pt()
1087:
1088:
1089:
1090: def getTextToolsField(self,name,default=''):
1091: """Lese Textoolsfelder aus index.meta im path aus"""
1092:
1093: try:
1094: dom=xml.dom.minidom.parse(self.metalink)
1095: node=dom.getElementsByTagName('texttool')[0] #getNode
1096: subnode=node.getElementsByTagName(name)[0]
1097:
1098: # bei text wird nur der Folder gebraucht
1099: if name=="text":
1100: splitted=getText(subnode.childNodes).split("/")
1101: return splitted[len(splitted)-2]
1102: else:
1103: return getText(subnode.childNodes)
1104: except:
1105: return default
1106:
1107:
1108: def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
1109: """changeit"""
1110:
1111: paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']
1112:
1113:
1114: #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)
1115:
1116: params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
1117:
1118:
1119: 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()
1120:
1121: #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
1122: # hack Pfad auf die Dokumente
1123: path=self.metalink
1124:
1125:
1126:
1127: path=re.sub('/index.meta','',path)
1128:
1129: path=re.sub(self.REQUEST['SERVER_URL'],'',path)
1130: path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
1131:
1132: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
1133: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
1134: path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
1135:
1136: path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
1137: path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
1138: path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
1139: path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
1140:
1141: path=re.sub('http://vision.rz-berlin.mpg.de','',path) # falls vision als server
1142:
1143: return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
1144:
1145:
1146: if RESPONSE is not None:
1147: RESPONSE.redirect('manage_main')
1148:
1149:
1150: def getTitle(self):
1151: """title"""
1152: try:
1153: return self.title.encode('utf-8','ignore')
1154: except:
1155: self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
1156: return self.title.encode('utf-8','ignore')
1157:
1158: def getLabel(self):
1159: """title"""
1160: try:
1161: return self.label.encode('utf-8','ignore')
1162: except:
1163: self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
1164: return self.label.encode('utf-8','ignore')
1165:
1166: def content_html(self):
1167: """template fuer content"""
1168: return content_html(self,'resource')
1169:
1170: def getViewClassification(self):
1171: if hasattr(self,'viewClassification'):
1172: return self.viewClassification
1173: else:
1174: return ""
1175:
1176: def getFullTextXML(self,noredirect=None):
1177: """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
1178:
1179: try:
1180: zLOG.LOG("ECHO Fulltext",zLOG.INFO,"open %s"%self.metalink)
1181: fh=ECHO_helpers.urlopen(self.metalink)
1182: zLOG.LOG("ECHO Fulltext",zLOG.INFO,"opened %s"%self.metalink)
1183: dom=xml.dom.minidom.parse(fh)
1184: texttools=dom.getElementsByTagName('texttool')
1185: text=texttools[0].getElementsByTagName('text')
1186: texturl=getText(text[0].childNodes)
1187:
1188: zLOG.LOG("ECHO Fulltext",zLOG.INFO,"found %s"%texturl)
1189: fh.close()
1190: zLOG.LOG("ECHO Fulltext",zLOG.INFO,"closed fh")
1191: #keine url
1192: if not (texturl.split(":")[0] in ['http','ftp','file']):
1193: if not noredirect:
1194: return file(texturl).read()
1195: else:
1196: return texturl
1197:
1198: if not noredirect:
1199: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1200: zLOG.LOG("ECHO Fulltext",zLOG.INFO,"redirect to:%s"%texturl)
1201: self.REQUEST.RESPONSE.redirect(texturl)
1202: else:
1203: return texturl
1204: except:
1205:
1206: if not noredirect:
1207: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1208: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
1209: else:
1210: return "<error>no fulltext available</error>"
1211:
1212:
1213: def getImageView(self,noredirect=None):
1214: """getImages; give Imageviewr and <error></error> if somthing goes wrong."""
1215: try:
1216: fh=ECHO_helpers.urlopen(self.metalink)
1217: dom=xml.dom.minidom.parse(fh)
1218: texttools=dom.getElementsByTagName('texttool')
1219: text=texttools[0].getElementsByTagName('image')
1220: imagetemp=getText(text[0].childNodes)
1221:
1222: text=dom.getElementsByTagName('archive-path')
1223: archivepath=getText(text[0].childNodes)
1224: archivepath=re.sub('/mpiwg/online/','',archivepath)
1225: imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
1226: fh.close()
1227:
1228: if not noredirect:
1229: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1230: self.REQUEST.RESPONSE.redirect(imageurl)
1231: else:
1232: return imageurl
1233: except:
1234:
1235: if not noredirect:
1236: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1237: self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
1238: else:
1239: return "<error>no images available</error>"
1240:
1241:
1242: def getCopyrightsHTML(self):
1243: """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
1244:
1245: if hasattr(self,'copyrightModel'):
1246: obj=self.copyrightModel
1247:
1248: else:
1249: return "ERROR"
1250: ret=[]
1251:
1252: for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
1253:
1254:
1255: try:
1256: if hasattr(self.copyrightTypes,copyright[2]):
1257: copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
1258: link="copyrightTypes/"+copyright[2]+'/copyright.html'
1259: else:
1260: copyrightTypeObj=getattr(obj,copyright[2])
1261: link="copyrightModel/"+copyright[2]+'/copyright.html'
1262:
1263: label=copyrightTypeObj.label
1264: url=getattr(copyrightTypeObj, 'url', '')
1265:
1266: if url!='':
1267: ret.append((url,copyright[0],copyright[1],copyright[2],label))
1268: else:
1269: if hasattr(copyrightTypeObj, 'copyright.html'):
1270: ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
1271: else:
1272: ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
1273: except:
1274: """nothing"""
1275:
1276: return ret
1277:
1278: def getInstitutionsHTML(self):
1279: """gibt Liste der fÂrdernden Institutionen aus"""
1280:
1281: if hasattr(self,'support'):
1282: obj=self.support
1283: ret=obj.getSupporter()
1284: return ret
1285: else:
1286: return ''
1287:
1288:
1289: def getCredits(self):
1290: """Ausgabe der credits"""
1291: if self.credits:
1292: return self.credits
1293: else:
1294: return []
1295:
1296: def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
1297:
1298: self.id = id
1299: """Festlegen der ID"""
1300:
1301: self.label = label
1302: self.link= link
1303: self.metalink=metalink
1304: self.title=title
1305: self.weight=weight
1306: self.credits=toList(credits)
1307: self.description=description
1308: self.contentType=contentType
1309: self.copyrightType=copyrightType
1310: self.renderingType=renderingType
1311: self.responsible=responsible
1312: self.resourceID=resourceID
1313:
1314: if coords:
1315: coordsnew=[ string.split(x,",") for x in coords]
1316: else:
1317: coordsnew=[]
1318:
1319: self.coords=coordsnew
1320:
1321:
1322: def getCoords(self):
1323: """gibt coordinaten als String zurßck und lÜscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""
1324: retList=[]
1325: if hasattr(self,'coords'):
1326: for x in self.coords:
1327: if len(x)>1:
1328: retList.append(string.join(x,","))
1329: return retList
1330:
1331:
1332:
1333: def getContentType(self):
1334: try:
1335: return self.contentType
1336: except:
1337: return ""
1338:
1339: def getCopyrightType(self):
1340: try:
1341: return self.copyrightType
1342: except:
1343: return ""
1344:
1345: def getRenderingType(self):
1346: try:
1347: return self.renderingType
1348: except:
1349: return ""
1350:
1351: def ECHO_resource_config(self):
1352: """Main configuration"""
1353:
1354: if not hasattr(self,'weight'):
1355: self.weight=""
1356:
1357: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
1358: return pt()
1359:
1360:
1361: def ECHO_resource_config_main(self):
1362: """Main configuration"""
1363:
1364: if not hasattr(self,'weight'):
1365: self.weight=""
1366:
1367: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)
1368: return pt()
1369:
1370: def ECHO_resource_config_coords(self):
1371: """Coords configuration """
1372:
1373: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)
1374: return pt()
1375:
1376: def ECHO_resource_config_credits(self):
1377: """Main configuration"""
1378:
1379: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)
1380: return pt()
1381:
1382: def ECHO_resource_config_metadata(self):
1383: """Main configuration"""
1384:
1385: if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
1386: self.metaDataHash={}
1387: self.contentType=self.bib_type
1388: for data in self.metadata:
1389: data_neu=re.sub('-','_',data)
1390: self.meta
1391: DataHash[data_neu]=getattr(self,data)[0:]
1392:
1393:
1394: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)
1395: return pt()
1396:
1397:
1398:
1399:
1400: def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
1401: """Ănderung der Properties"""
1402: self.resourceID=resourceID
1403: self.title=title
1404: self.label=label
1405: self.description=description
1406:
1407: self.contentType=contentType
1408: self.renderingType=renderingType
1409: self.weight=weight
1410:
1411: self.link=link
1412: self.metalink=metalink
1413:
1414: if RESPONSE is not None:
1415: RESPONSE.redirect('manage_main')
1416:
1417:
1418: def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):
1419: """Ănderung der Properties - coords"""
1420:
1421: if type(coords)==StringType:
1422: coords=[coords]
1423:
1424: try:
1425: coordsnew=[ string.split(x,",") for x in coords]
1426: except:
1427: coordsnew=[]
1428:
1429: self.coords=coordsnew[0:]
1430: self.viewClassification=viewClassification
1431:
1432: if RESPONSE is not None:
1433: RESPONSE.redirect('manage_main')
1434:
1435: def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
1436: """Ănderung der Properties"""
1437: self.credits=credits
1438: self.responsible=responsible
1439: self.copyrightType=copyrightType
1440:
1441: if RESPONSE is not None:
1442: RESPONSE.redirect('manage_main')
1443:
1444:
1445: def changeECHO_resource_metadata_local(self,RESPONSE=None):
1446: """change metadata"""
1447: tags=self.findTagsFromMapping(self.contentType)
1448: for field in tags[1]:
1449: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
1450:
1451:
1452:
1453: if RESPONSE is not None:
1454: RESPONSE.redirect('manage_main')
1455:
1456: def changeECHO_resource_metadata(self,RESPONSE=None):
1457: """change metadata"""
1458: tags=self.findTagsFromMapping(self.contentType)
1459: self.OSAS_meta={}
1460: for field in tags[1]:
1461: try:
1462: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
1463: self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
1464: except:
1465: """nothing"""
1466:
1467: 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()
1468:
1469:
1470: if RESPONSE is not None:
1471: RESPONSE.redirect('manage_main')
1472:
1473:
1474: def getMDValue(self,fieldName):
1475: return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)
1476:
1477: def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
1478: """new index.meta"""
1479: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1480:
1481: if not hasattr(self,'metaDataHash'):
1482:
1483: self.copyIndex_meta2echo_resource()
1484: try:
1485: return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1486: except:
1487: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
1488:
1489: def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
1490: """schreibe md"""
1491:
1492: try:
1493:
1494: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
1495: except:
1496: return "<error> no metadata stored</error>"
1497:
1498: def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
1499: """prints out metadata as stored in the echo environment, format is the index.meta format"""
1500: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1501: return writeMetadata(self.metalink,self.metaDataHash)
1502:
1503: def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
1504: """Ănderung der Properties"""
1505:
1506: try:
1507: coordsnew=[ string.split(x,",") for x in coords]
1508: except:
1509: coordsnew=[]
1510:
1511: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
1512: self.viewClassification=viewClassification
1513: self.coords=coordsnew[0:]
1514: self.link=link
1515: self.metalink=metalink
1516:
1517: if RESPONSE is not None:
1518: RESPONSE.redirect('manage_main')
1519:
1520:
1521: manage_options = Folder.manage_options+(
1522: {'label':'Main Config','action':'ECHO_resource_config_main'},
1523: {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
1524: {'label':'Change Coords','action':'ECHO_resource_config_coords'},
1525: {'label':'Add coords','action':'ECHO_graphicEntry'},
1526: {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
1527: {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
1528: {'label':'set/change startpage','action':'setStartPageForm'},
1529: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
1530: )
1531:
1532: def getOverview(self):
1533: """overview graphics"""
1534:
1535: return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
1536:
1537: def ECHO_graphicEntry(self):
1538: """DO nothing"""
1539: overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
1540: if overview:
1541: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
1542: return pt()
1543: else:
1544: return "NO OVERVIEW GRAPHICS"
1545:
1546: def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
1547: """Enter coords"""
1548: coords=self.coords
1549: temco=coordstr.split(",")
1550: temco.append(angle)
1551: coords.append(temco)
1552:
1553: self.coords=coords[0:]
1554:
1555: if RESPONSE is not None:
1556: RESPONSE.redirect('ECHO_graphicEntry')
1557:
1558:
1559: def isDefinedInThisSet(self,fields,field):
1560: """checks if field is defined in fields"""
1561: if (fields[0].has_key(field)) and not (fields[0][field]==""):
1562: return 1
1563: else:
1564:
1565: return 0
1566:
1567: def getFieldLabel(self,fields,field):
1568: """get labels"""
1569: try:
1570: ret =fields[0][field]
1571: if ret == "":
1572: return field
1573: else:
1574: return ret
1575: except:
1576: return field
1577:
1578:
1579:
1580: def getFieldTag(self,fields,field):
1581: """get labels"""
1582: try:
1583: ret =fields[0][field]
1584: if ret == "":
1585: return field
1586: else:
1587: return ret
1588: except:
1589: return field
1590:
1591:
1592:
1593: def getFieldValue(self,field):
1594: """get value"""
1595:
1596: try:
1597:
1598: ret=self.metaDataHash[field]
1599: if ret == "":
1600: return None
1601: else:
1602: return ret
1603: except:
1604: return None
1605:
1606: def getMetaDataHash(self):
1607: """md hash"""
1608: return self.metaDataHash
1609:
1610: def setFieldValue(self,field,value):
1611: """get value"""
1612:
1613: if not hasattr(self,'metaDataHash'):
1614: setattr(self,'metaDataHash',{})
1615: self.metaDataHash[field]=value[0:]
1616:
1617:
1618: def copySearchFields(self):
1619: """copys metadatafields to the object"""
1620: fields=['author','title','year']
1621: for field in fields:
1622: setattr(self,'MD_'+field,self.getFieldValue(field))
1623:
1624:
1625: def findLabelsFromMapping(self,referenceType):
1626: """gib hash mit label -> generic zurueck"""
1627: #return {},[]
1628:
1629: temp=self.ZopeFind(self.standardMD)
1630:
1631: if referenceType=="":
1632: referenceType="book"
1633:
1634:
1635: bibdata={}
1636: retdata={}
1637: fields=[]
1638: fieldlist=self.standardMD.fieldList
1639:
1640: for referenceTypeF in self.referencetypes:
1641:
1642: if referenceTypeF[1].title.lower() == referenceType.lower():
1643:
1644: try:
1645: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1646: referenceType=referenceTypeF[1].title
1647: except:
1648: bibdata[referenceType]=referenceTypeF[1].fields
1649:
1650:
1651: bibdata['data']=referenceTypeF[1]
1652: fields=bibdata[referenceType]
1653: for field in fieldlist:
1654: retdata[field]=referenceTypeF[1].getValue(field)[1]
1655:
1656: return retdata,fieldlist,temp,fields
1657:
1658: def findTagsFromMapping(self,referenceType):
1659: """gib hash mit label -> generic zurueck"""
1660:
1661:
1662: if referenceType=="":
1663: referenceType="book"
1664:
1665: temp = self.ZopeFind(self.standardMD)[0:]
1666:
1667:
1668: #self.referencetypes=temp[0:]
1669:
1670:
1671:
1672:
1673:
1674:
1675: bibdata={}
1676: retdata={}
1677: fieldlist=self.standardMD.fieldList
1678: fields=[]
1679: for referenceTypeF in temp:
1680: #print referenceType
1681:
1682: if referenceTypeF[1].title.lower() == referenceType.lower():
1683: try:
1684: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1685: referenceType=referenceTypeF[1].title
1686: except:
1687: bibdata[referenceType]=referenceTypeF[1].fields
1688: bibdata['data']=referenceTypeF[1]
1689: fields=bibdata[referenceType]
1690: for field in fieldlist:
1691: retdata[field]=referenceTypeF[1].getValue(field)[0]
1692:
1693: return retdata,fieldlist,temp,fields
1694:
1695:
1696: security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination
1697: def copyIndex_meta2echo_resource(self,RESPONSE=None):
1698: """copy MD von Index_meta to the echo_resource"""
1699:
1700: (metadict, error)=readMetadata(self.metalink)
1701:
1702:
1703:
1704: self.metaDataHash={}
1705: if not error=="": #Fehler beim Auslesen des Metafiles
1706:
1707: return "ERROR:",error,self.absolute_url()
1708:
1709: self.contentType=metadict['bib_type'][0:]
1710: fields=self.findTagsFromMapping(self.contentType)
1711:
1712: #fields=self.findLabelsFromMapping(self.contentType)
1713: for field in fields[1]:
1714:
1715: if self.isDefinedInThisSet(fields,field):
1716: #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
1717: self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
1718:
1719:
1720:
1721: if RESPONSE:
1722: return RESPONSE.redirect('manage_main')
1723:
1724: def ECHO_getResourceMD(self,template="yes",back=None):
1725: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
1726: (metadict, error)=readMetadata(self.metalink)
1727:
1728: if back:
1729: self.REQUEST.SESSION['back']=back
1730:
1731: if not error=="": #Fehler beim Auslesen des Metafiles
1732: return "ERROR:",error
1733:
1734:
1735: if not (metadict['bib_type'].lower()==self.contentType.lower()):
1736: self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
1737: self.REQUEST.SESSION['contentZope']=self.contentType
1738:
1739: return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()
1740:
1741: self.REQUEST.SESSION['metadict']=metadict
1742:
1743:
1744:
1745: self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])
1746:
1747:
1748:
1749: if template=="yes":
1750: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
1751: return pt()
1752:
1753:
1754:
1755:
1756:
1757: def ECHO_getMD(self,item):
1758: """Ausgabe der MD"""
1759: return getattr(self,item)
1760:
1761: def index_html(self):
1762: """standard page"""
1763:
1764: return self.REQUEST.RESPONSE.redirect(self.link)
1765:
1766: def startpage_html(self):
1767: """prints out a startpage for a resource for use e.g. in the BVE"""
1768:
1769: # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
1770:
1771: sp=self.ZopeFind(self,obj_ids=['startpage.html'])
1772:
1773: if sp:
1774: return sp[1]()
1775:
1776: #prĂźfen ob irgendwo ein template
1777: if hasattr(self,'startpage_index_template'):
1778: return self.startpage_index_template()
1779:
1780: #generisches template ausgeben
1781:
1782: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_startpage_index_template_standard.zpt').__of__(self)
1783: pt.content_type="text/html"
1784: return pt()
1785:
1786: def toc_html(self):
1787:
1788: sp=self.ZopeFind(self,obj_ids=['toc.html'])
1789:
1790: if sp:
1791: return sp[0][1]()
1792:
1793:
1794: security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
1795:
1796: def generate_label(self):
1797: """Erzeugt_standard_Label aus Template"""
1798: pt=getattr(self,"label_template_"+self.contentType.lower())
1799:
1800: self.label=pt()[0:]
1801: return pt()
1802:
1803: security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
1804:
1805: def generate_title(self,RESPONSE=None):
1806: """Erzeugt_standard_Label aus Template"""
1807: pt=getattr(self,"label_template_"+self.contentType.lower())
1808:
1809: self.title=pt()[0:]
1810:
1811: return pt()
1812:
1813: Globals.InitializeClass(ECHO_resource)
1814:
1815: def manage_addECHO_resourceForm(self):
1816: """Form for adding a ressource"""
1817: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
1818: return pt()
1819:
1820:
1821:
1822: 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):
1823: """addaresource"""
1824:
1825: newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
1826:
1827: self._setObject(id,newObj)
1828:
1829: if RESPONSE is not None:
1830: RESPONSE.redirect('manage_main')
1831:
1832:
1833: class ECHO_externalLink(Folder):
1834: """Link zu einer externen Ressource"""
1835: security=ClassSecurityInfo()
1836: meta_type='ECHO_externalLink'
1837:
1838: def getTitle(self):
1839: """title"""
1840: try:
1841: return self.title.encode('utf-8','ignore')
1842: except:
1843: self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
1844: return self.title.encode('utf-8','ignore')
1845:
1846: def getLabel(self):
1847: """title"""
1848: try:
1849: return self.label.encode('utf-8','ignore')
1850: except:
1851: self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
1852: return self.label.encode('utf-8','ignore')
1853:
1854: def content_html(self):
1855: """template fuer content"""
1856: return content_html(self,'externalLink')
1857:
1858: def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
1859:
1860: self.id = id
1861: """Festlegen der ID"""
1862:
1863: self.credits=toList(credits)
1864: self.label = label
1865: self.link= link
1866: self.title=title
1867: self.weight=weight
1868: self.description=description
1869: self.contentType=contentType
1870: self.responsible=responsible
1871: coordsnew=[ string.split(x,",") for x in coords]
1872: self.coords=coordsnew
1873:
1874: def ECHO_externalLink_config(self):
1875: """Main configuration"""
1876:
1877: if not hasattr(self,'weight'):
1878: self.weight=""
1879: if not hasattr(self,'coords'):
1880:
1881: self.coords=['']
1882:
1883:
1884: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)
1885: return pt()
1886:
1887:
1888: def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
1889:
1890: """Ănderung der Properties"""
1891: try:
1892: coordsnew=[ string.split(x,",") for x in coords]
1893: except:
1894: coordsnew=[]
1895:
1896: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
1897:
1898: self.coords=coordsnew[0:]
1899: self.link=link
1900: if RESPONSE is not None:
1901: RESPONSE.redirect('manage_main')
1902:
1903:
1904: manage_options = Folder.manage_options+(
1905: {'label':'Main Config','action':'ECHO_externalLink_config'},
1906: )
1907:
1908:
1909: def index_html(self):
1910: """standard page"""
1911:
1912: return self.REQUEST.RESPONSE.redirect(self.link)
1913:
1914: def manage_addECHO_externalLinkForm(self):
1915: """Form for external Links"""
1916: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)
1917: return pt()
1918:
1919:
1920: def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
1921: """Add an external Link"""
1922:
1923: newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
1924:
1925: self._setObject(id,newObj)
1926:
1927: if RESPONSE is not None:
1928: RESPONSE.redirect('manage_main')
1929:
1930:
1931: class ECHO_link(ECHO_externalLink):
1932: """external_link"""
1933:
1934: meta_type="ECHO_link"
1935:
1936:
1937: def content_html(self):
1938: """template fuer link"""
1939: if hasattr(self,"link_template"):
1940: return content_html(self,'link')
1941: else:
1942: return content_html(self,'collection')
1943:
1944: def manage_addECHO_linkForm(self):
1945: """Form for external Links"""
1946: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)
1947: return pt()
1948:
1949:
1950: def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
1951: """Add an external Link"""
1952:
1953: newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
1954:
1955: self._setObject(id,newObj)
1956:
1957: if RESPONSE is not None:
1958: RESPONSE.redirect('manage_main')
1959:
1960:
1961: class ECHO_collection(Folder, Persistent, Implicit, Cacheable):
1962: """ECHO Collection"""
1963:
1964: security=ClassSecurityInfo()
1965: meta_type='ECHO_collection'
1966: viewClassificationList=viewClassificationListMaster
1967: displayTypes=displayTypes
1968:
1969: path="/mpiwg/online/permanent/shipbuilding"
1970:
1971: def getRDF(self,urn=None):
1972: """rdf of the collection"""
1973:
1974: contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
1975:
1976: ret=getRDFDescription(self,self.absolute_url(),urn=urn)
1977:
1978: if not urn:
1979: urn=self.absolute_url()
1980:
1981: li="""<RDF:li RDF:resource="%s" />\n"""
1982:
1983:
1984: for content in contents:
1985: ret+=content[1].getRDF()+"\n"
1986:
1987: ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
1988: for content in contents:
1989: nurn=content[1].absolute_url()
1990: ret+=li%nurn
1991: return ret+"</RDF:Seq>"
1992:
1993:
1994: def showRDF(self):
1995: """showrdf"""
1996: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
1997: 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"""
1998: ret+=self.getRDF(urn="echo:collectionroot")+"\n"
1999:
2000: ret+="""</RDF:RDF>"""
2001:
2002: return ret
2003:
2004:
2005:
2006: def changeLabels(self):
2007: """change form"""
2008: pt=PageTemplateFile('Products/ECHO_content/zpt/changeLabelsForm').__of__(self)
2009: pt.content_type="text/html"
2010: return pt()
2011:
2012: def changeTitles(self):
2013: """change form"""
2014: pt=PageTemplateFile('Products/ECHO_content/zpt/changeTitleForm').__of__(self)
2015: pt.content_type="text/html"
2016: return pt()
2017:
2018: def changeWeights(self):
2019: """change form"""
2020: pt=PageTemplateFile('Products/ECHO_content/zpt/changeWeightForm').__of__(self)
2021: pt.content_type="text/html"
2022: return pt()
2023:
2024: def changeMetaDataLinks(self):
2025: """change form"""
2026: pt=PageTemplateFile('Products/ECHO_content/zpt/changeMetaDataLinkForm').__of__(self)
2027: pt.content_type="text/html"
2028: return pt()
2029: def changeAccessRightsCollection(self):
2030: """change"""
2031: ret=""
2032: argv=self.REQUEST.form
2033:
2034: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2035: for resource in resources:
2036:
2037: try:
2038: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2039: resource[1].changeAccessRightMD(argv[resource[1].getId()])
2040: except:
2041: """not"""
2042: return ret
2043:
2044: def changeMetaDataLinkInCollection(self):
2045: """change all lables of a collection"""
2046: ret=""
2047: argv=self.REQUEST.form
2048:
2049: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2050: for resource in resources:
2051:
2052: try:
2053: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2054: resource[1].metalink=argv[resource[1].getId()][0:]
2055: except:
2056: """not"""
2057: return ret
2058:
2059: def changeMetaDataLinkInCollection(self):
2060: """change all lables of a collection"""
2061: ret=""
2062: argv=self.REQUEST.form
2063:
2064: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2065: for resource in resources:
2066:
2067: try:
2068: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2069: resource[1].metalink=argv[resource[1].getId()][0:]
2070: except:
2071: """not"""
2072: return ret
2073:
2074: def changeWeightsInCollection(self):
2075: """change all lables of a collection"""
2076: ret=""
2077: argv=self.REQUEST.form
2078:
2079: resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
2080: for resource in resources:
2081:
2082: try:
2083: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2084: resource[1].weight=argv[resource[1].getId()][0:]
2085: except:
2086: """not"""
2087: return ret
2088:
2089: def changeTitlesInCollection(self):
2090: """change all lables of a collection"""
2091: ret=""
2092: argv=self.REQUEST.form
2093:
2094: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2095: for resource in resources:
2096:
2097: try:
2098: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
2099: resource[1].title=argv[resource[1].getId()][0:]
2100: except:
2101: """not"""
2102: return ret
2103:
2104: def updateCollection(self,RESPONSE=None):
2105: """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
2106: files=os.listdir(self.path)
2107: ret=""
2108: for fileName in files:
2109:
2110: if fileName:
2111:
2112: tempPath=re.sub("/mpiwg/online","",self.path)
2113: link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"
2114:
2115: metalink=self.path+"/"+fileName+"/index.meta"
2116: try:
2117:
2118: #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"
2119:
2120: newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'generated','book','','','','','','')
2121: self._setObject(fileName,newObj)
2122:
2123: genObj=getattr(self,fileName)
2124: #genObj.createIndexFile()
2125: ret+="OK:"+fileName+"<br/>"
2126: except:
2127: print "ERROR"
2128: ret+="ERROR:"+fileName+"<br/>"
2129:
2130: return ret
2131:
2132: if RESPONSE is not None:
2133: RESPONSE.redirect('manage_main')
2134:
2135: def updateCollectionMD(self,RESPONSE=None):
2136: """updateMD"""
2137: files=os.listdir(self.path)
2138: for fileName in files:
2139: if fileName:
2140: genObj=getattr(self,fileName)
2141: genObj.copyIndex_meta2echo_resource()
2142: genObj.generate_title()
2143:
2144: if RESPONSE is not None:
2145: RESPONSE.redirect('manage_main')
2146:
2147:
2148:
2149: def changeViewerTemplateSetsForm(self):
2150: """change the viewer template set"""
2151: pt=PageTemplateFile('Products/ECHO_content/zpt/changeViewerTemplateSet').__of__(self)
2152: return pt()
2153:
2154: def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):
2155: """Get the ViewerTemplateSet title for configuration"""
2156: ret=[]
2157:
2158: try:
2159: viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.
2160:
2161: for viewerTemplateSet in viewerTemplateSets:
2162: ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))
2163:
2164: return ret
2165:
2166: except:
2167: return [('no ViewerTemplateSetfolders','')]
2168:
2169: def getTextToolsField(self,name,default=''):
2170: """Lese viewerTemplateSet der Collection not implemented yet!"""
2171:
2172: return default
2173:
2174:
2175: def isSelectedViewerTemplateSet(self,obj,id):
2176: """is ausgewählt"""
2177:
2178: if self.REQUEST['viewerTemplateSet']==id:
2179: return 1
2180: else:
2181: return None
2182:
2183: def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
2184: """change the templates"""
2185:
2186: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2187:
2188: for resource in resources:
2189:
2190: resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
2191:
2192: if RESPONSE is not None:
2193: RESPONSE.redirect('manage_main')
2194:
2195:
2196: def setStartpageFolderForm(self):
2197: """Form for changing the startpage"""
2198:
2199:
2200: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resourceStartPageFolder.zpt').__of__(self)
2201: pt.content_type="text/html"
2202: return pt()
2203:
2204: def setStartpageFolder(self,startpage=None,RESPONSE=None):
2205: """change the templates"""
2206:
2207: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2208:
2209: for resource in resources:
2210:
2211: resource[1].setStartPage(startpage)
2212:
2213: if RESPONSE is not None:
2214: RESPONSE.redirect('manage_main')
2215:
2216: def copyTitleToInfoXMLFolder(self):
2217: """copy title into the title field of info.xml
2218: author and date werden leer!!!
2219: """
2220:
2221: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
2222:
2223: for resource in resources:
2224:
2225: resource[1].copyTitleToInfoXML()
2226:
2227: if RESPONSE is not None:
2228: RESPONSE.redirect('manage_main')
2229:
2230: def copySearchFields(self,RESPONSE=None):
2231: """copys import metadatafields to the object"""
2232: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
2233:
2234: for resource in resources:
2235:
2236: resource[1].copySearchFields()
2237:
2238: if RESPONSE is not None:
2239: RESPONSE.redirect('manage_main')
2240:
2241: def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
2242: """warning"""
2243: pt=PageTemplateFile('Products/ECHO_content/zpt/reloadMetaDataFromStorageWarning.zpt').__of__(self)
2244: pt.content_type="text/html"
2245: return pt()
2246:
2247: def reloadMetaDataFromStorage(self,RESPONSE=None):
2248: """copy metadata from the storage to ECHO"""
2249:
2250: return reloadMetaDataFromStorage(self,RESPONSE=None)
2251:
2252:
2253: def getPartnerCopyright(self,name,sonst="generic"):
2254: """gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""
2255: #print "hi",name,sonst
2256: #print getattr(self.partners,name).copyrightType
2257: try:
2258: partner=getattr(self.partners,name)
2259: return partner.copyrightType
2260: except:
2261: print "error"
2262: return sonst
2263:
2264: def partnerSelector_HTML(self,selected=None):
2265: """give type selector"""
2266: if not selected:
2267: retStr="<option selected>\n"
2268: else:
2269: retStr="<option>\n"
2270:
2271: try: # erste version copyrightTypes exists
2272: for partner in self.credits:
2273: if selected and (partner==selected):
2274: retStr+="""<option selected value="%s">%s\n"""%(partner,partner)
2275: else:
2276: retStr+="""<option value="%s">%s\n"""%(partner,partner)
2277: except:
2278: """nothing"""
2279: return retStr
2280:
2281: def getViewClassification(self):
2282: if hasattr(self,'viewClassification'):
2283: return self.viewClassification
2284: else:
2285: return ""
2286:
2287: def getTitle(self):
2288: """title"""
2289: try:
2290: return self.title.encode('utf-8','ignore')
2291: except:
2292: self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
2293: return self.title.encode('utf-8','ignore')
2294:
2295: def getLabel(self):
2296: """title"""
2297: try:
2298: return self.label.encode('utf-8','ignore')
2299: except:
2300: self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
2301: return self.label.encode('utf-8','ignore')
2302:
2303: def createRessourcesFromXMLForm(self):
2304: """form"""
2305: pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)
2306: return pt()
2307:
2308: def createRessourcesFromXML(self,fileupload):
2309: """read an XML file for generating resources"""
2310: dom=xml.dom.minidom.parse(fileupload)
2311: ret="<h2>Added</h2>"
2312: for resource in dom.getElementsByTagName('resource'):
2313: link=getText(resource.getElementsByTagName('link')[0].childNodes)
2314: label=getText(resource.getElementsByTagName('label')[0].childNodes)
2315: #splitted=link.split("?")[0].split("/")
2316: #id=splitted[len(splitted)-1].encode('ascii')
2317: id=re.sub(" ","_",label).encode('ascii')
2318:
2319: ret+="<p>"+label+"</p>"
2320: manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")
2321: return ret
2322:
2323: def getImageTag(self):
2324: """GetTag"""
2325: try:
2326: return self.imageTag
2327: except:
2328: return ""
2329:
2330: def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
2331: """SSS"""
2332: try:
2333: manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
2334: return "done"
2335: except:
2336: return None
2337:
2338: def getSecondaryLink(self):
2339: """secondary link"""
2340: try:
2341: return self.secondaryLink
2342: except:
2343: return ""
2344:
2345: def getSecondaryLinkTitle(self):
2346: """secondary link"""
2347: try:
2348: return self.secondaryLinkTitle
2349: except:
2350: return ""
2351:
2352: def getCollectionTreeXML(self):
2353: """Tree as XML"""
2354:
2355: def addPassWd(str):
2356: """adds a user/passwd to an url"""
2357: txt2=re.sub(r"(http://)(.*?)","\g<1>www:3333@\g<2>",str)
2358: return txt2
2359:
2360: def getCollection(object,depth=0):
2361: depth+=1
2362: collections=""
2363: for entry in object.__dict__.keys():
2364: element=getattr(object,entry)
2365: try:
2366: if element.meta_type in ["ECHO_collection","ECHO_group"]:
2367: collections+="<element name=\""+quote(element.title)+"\" url=\""+addPassWd(element.absolute_url())+"\">"
2368: collections+=getCollection(element,depth)+"</element>\n"
2369: except:
2370: """nothing"""
2371: return collections
2372:
2373: ret="""<?xml version="1.0" encoding="utf-8" ?>"""
2374: return ret+"<collection>"+getCollection(self)+"</collection>"
2375:
2376: def createJavaScript(self):
2377: """OLD CreateJava"""
2378: ret=javaScriptMain
2379:
2380: dynamical="\n"
2381: for ob in self.getGraphicCoords():
2382: if ob[4][4] == "":
2383: dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
2384: else:
2385: dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])
2386: dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])
2387: ret+=javaHandler%dynamical
2388: return ret
2389:
2390: def createJSAreas(self):
2391: """create area calls for JavaScript"""
2392: dynamical="\n"
2393: for ob in self.getGraphicCoords():
2394: if ob[5] == "area":
2395: dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])
2396: else:
2397: dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])
2398: return dynamical
2399:
2400: def createMapHead(self):
2401: """create javascript include and script tags for head"""
2402: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)
2403: return pt()
2404:
2405: def createMapImg(self):
2406: """generate img-tag for map"""
2407: bt = BrowserCheck(self)
2408: tag = ""
2409: src = self.REQUEST['URL1'] + "/overview"
2410: if bt.isN4:
2411: tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
2412: else:
2413: tag += '<img id="overview" src="%s" />'%src
2414: return tag
2415:
2416: def createMapLink(self, ob, text=None):
2417: """generate map link"""
2418: bt = BrowserCheck(self)
2419: id = ob[1]
2420: link = ob[1]
2421: if text == None:
2422: text = ob[2]
2423: tag = ""
2424: if bt.isN4:
2425: tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
2426: tag += ">" + text + "</a></ilayer>"
2427: else:
2428: tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
2429: if ob[3].contentType == 'text-popup':
2430: tag += ' title="%s"'%ob[3].description
2431: tag += ">" + text + "</a>"
2432: return tag
2433:
2434: def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):
2435: """generate map link image, text and other stuff"""
2436: id = ob[1]
2437: link = ob[1]
2438: vtype = ob[5]
2439: ctype = ob[3].contentType
2440: bt = BrowserCheck(self)
2441: tag = ""
2442:
2443: if bt.isN4:
2444: tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
2445: if vtype == "view point":
2446: rot = ob[4][4]
2447: tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,arrowsrc,rot)
2448: else:
2449: tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
2450: if ctype == "text-popup":
2451: desc = ob[3].description
2452: tag += ' alt="%s"'%desc
2453: tag += ' /></a>'
2454: tag += '</layer>'
2455: else:
2456: tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)
2457: if vtype == "view point":
2458: rot = ob[4][4]
2459: if bt.isIEWin and bt.versIE > 5:
2460: 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)
2461: else:
2462: tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,arrowsrc,rot)
2463: else:
2464: if bt.isIEWin:
2465: tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;background:url(area_img)"'%(id)
2466: else:
2467: tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
2468: if ctype == "text-popup":
2469: desc = ob[3].description
2470: tag += ' title="%s"'%desc
2471: tag += '> </div>'
2472: tag += '</a>'
2473: return tag
2474:
2475:
2476: security.declarePublic('getCreditObject')
2477: def getCreditObject(self,name):
2478: """credit id to credititem"""
2479: try:
2480: return getattr(self.partners,name)
2481: except:
2482: return ""
2483:
2484: security.declarePublic('ECHO_generateNavBar')
2485: def ECHO_generateNavBar(self):
2486: """Erzeuge Navigationsbar"""
2487: link=""
2488: object="self"
2489: ret=[]
2490: path=self.getPhysicalPath()
2491: for element in path:
2492:
2493:
2494: if not element=="":
2495: object+="."+element
2496:
2497: label=eval(object).label
2498: link+="/"+element
2499: if not label=="":
2500: ret.append((label,link))
2501: return ret
2502:
2503: security.declarePublic('ECHO_rerenderLinksMD')
2504:
2505:
2506: def ECHO_rerenderLinksMDWarning(self):
2507: """change form"""
2508: pt=PageTemplateFile('Products/ECHO_content/zpt/rerenderLinksWarning').__of__(self)
2509: pt.content_type="text/html"
2510: return pt()
2511:
2512:
2513:
2514: def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
2515: """Rerender all Links"""
2516: return ECHO_rerenderLinksMD(self,obj,types)
2517:
2518:
2519: security.declarePublic('ECHO_newViewerLink')
2520:
2521:
2522: def getCoords(self):
2523: try:
2524:
2525: x= [string.join(x,",") for x in self.coords]
2526: return x
2527:
2528: except:
2529:
2530: return []
2531:
2532: def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
2533:
2534:
2535: self.id = id
2536: """Festlegen der ID"""
2537: self.credits=toList(credits)
2538: self.label = label
2539: self.title=title
2540: self.description=description
2541: self.contentType=contentType
2542: self.responsible=responsible
2543: self.imageTag=imageTag
2544: self.weight=weight
2545: self.sortfield=sortfield
2546: coordsnew=[ string.split(x,",") for x in coords]
2547: self.coords=coordsnew
2548: self.secondaryLinkTitle=secondaryLinkTitle
2549: self.secondaryLink=secondaryLink
2550: self.bgcolour=bgcolour
2551:
2552:
2553: manage_options = Folder.manage_options+ Cacheable.manage_options+(
2554: {'label':'Main Config','action':'ECHO_collection_config'},
2555: {'label':'Change Labels','action':'changeLabels'},
2556: {'label':'Change Titles','action':'changeTitles'},
2557: {'label':'Change Weights','action':'changeWeights'},
2558: {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},
2559: {'label':'Graphics','action':'ECHO_graphicEntry'},
2560: {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
2561: {'label':'Set Startpage','action':'setStartpageFolderForm'},
2562: {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},
2563: {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
2564: {'label':'ImportCollection','action':'updateCollection'},
2565: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
2566: )
2567:
2568: def getOverview(self):
2569: """overview graphics"""
2570:
2571: return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
2572:
2573:
2574: def ECHO_graphicEntry(self):
2575: """DO nothing"""
2576: overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
2577:
2578:
2579: if overview:
2580: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
2581: return pt()
2582: else:
2583: return "NO OVERVIEW GRAPHICS"
2584:
2585: def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
2586: """Enter coords"""
2587: coords=self.coords
2588: temco=coordstr.split(",")
2589: temco.append(angle)
2590: coords.append(temco)
2591: self.coords=coords[0:]
2592:
2593: if RESPONSE is not None:
2594: RESPONSE.redirect('ECHO_graphicEntry')
2595:
2596:
2597: security.declarePublic('ECHO_collection_config')
2598: def ECHO_collection_config(self):
2599: """Main configuration"""
2600:
2601: if not hasattr(self,'weight'):
2602: self.weight=""
2603:
2604: if not hasattr(self,'sortfield'):
2605: self.sortfield="weight"
2606:
2607: if not hasattr(self,'coords'):
2608: self.coords=[]
2609:
2610: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)
2611: return pt()
2612:
2613:
2614: security.declarePublic('changeECHO_collection')
2615:
2616:
2617: def getBgcolour(self):
2618: """colour"""
2619: if hasattr(self,'bgcolour') and not (self.bgcolour==""):
2620: return self.bgcolour
2621: else:
2622: return "#dddddd"
2623:
2624: 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):
2625: """Aenderung der Properties"""
2626:
2627: self.secondaryLink=secondaryLink
2628: self.secondaryLinkTitle=secondaryLinkTitle
2629: self.imageTag=imageTag
2630: self.bgcolour=bgcolour
2631: self.viewClassification=viewClassification
2632: self.location=location
2633: self.isAlwaysClickable=isAlwaysClickable
2634:
2635: if coords:
2636: coordsnew=[ string.split(x,",") for x in coords]
2637: self.coords=coordsnew[0:]
2638: else:
2639: coordsnew=None
2640: self.coords=None
2641:
2642: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
2643: try:
2644: self.coords=coordsnew[0:] # HACK fehler in setECHO_collection
2645: except:
2646: """none"""
2647:
2648: self.sortfield=sortfield
2649:
2650: if RESPONSE is not None:
2651: RESPONSE.redirect('manage_main')
2652:
2653: def setAlwaysClickable(self,flag="yes"):
2654: """set clickable"""
2655: if flag=="yes":
2656: self.isAlwaysClickable="yes"
2657: else:
2658: self.isAlwaysClickable=None
2659:
2660: return flag
2661:
2662: def showOverview(self):
2663: """overview"""
2664: if 'ECHO_overview.html' in self.__dict__.keys():
2665: return getattr(self,'ECHO_overview.html')()
2666: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
2667: return pt()
2668:
2669: security.declareProtected('View','index_html')
2670:
2671: def index_html(self):
2672: """standard page"""
2673: if self.ZCacheable_isCachingEnabled():
2674:
2675: result = self.ZCacheable_get()
2676: if result is not None:
2677: # Got a cached value.
2678: return result
2679:
2680: if 'index.html' in self.__dict__.keys():
2681: ret=getattr(self,'index.html')()
2682:
2683: elif 'overview' in self.__dict__.keys():
2684: ret=self.showOverview()
2685: elif hasattr(self,'collection_index_template'):
2686: ret=self.collection_index_template()
2687: elif hasattr(self,'main_index_template'):
2688: ret=self.main_index_template()
2689: else:
2690: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
2691: pt.content_type="text/html"
2692: ret=pt.render()
2693:
2694: self.ZCacheable_set(ret)
2695: return ret
2696:
2697: def content_html(self):
2698: """template fuer content"""
2699: return content_html(self,'collection')
2700:
2701: def getCredits(self):
2702: """Ausgabe der credits"""
2703: if self.credits:
2704: return self.credits
2705: else:
2706: return []
2707:
2708: def area_img(self):
2709: """area image"""
2710: bt = BrowserCheck(self)
2711: if bt.isIE or bt.isN4:
2712: return sendFile(self, 'images/red.gif', 'image/gif')
2713: else:
2714: return sendFile(self, 'images/reda.png', 'image/png')
2715:
2716: def trans_img(self):
2717: """empty image"""
2718: return sendFile(self, 'images/trans.gif', 'image/gif')
2719:
2720: def hl_lib_js(self):
2721: """javascript"""
2722: return sendFile(self, 'js/hl_lib.js', 'text/plain')
2723:
2724: def js_lib_js(self):
2725: """javascript"""
2726: return sendFile(self, 'js/js_lib.js', 'text/plain')
2727:
2728: def getGraphicCoords(self):
2729: """Give list of coordinates"""
2730: subColTypes=['ECHO_collection','ECHO_resource']
2731: ids=[]
2732: for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):
2733: object=entrySearch[1]
2734: if hasattr(object,'coords'):
2735: for coordtemp in object.coords:
2736: if len(coordtemp)>3:
2737: coord=coordtemp[0:4]
2738: label=""
2739: vc=""
2740: if hasattr(object,'label') and not object.label=="":
2741: label=object.label
2742: elif hasattr(object,'title') and not object.title=="":
2743: label=object.title
2744: else:
2745: label=object.getId()
2746: if object.viewClassification != "":
2747: vc=object.viewClassification
2748: else:
2749: if len(coordtemp) > 4 and coordtemp[4] != "":
2750: vc="view point"
2751: else:
2752: vc="area"
2753: ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,vc])
2754: return ids
2755:
2756:
2757:
2758:
2759: getSubCols = ECHO_helpers.getSubCols
2760:
2761: Globals.InitializeClass(ECHO_collection)
2762:
2763: def manage_addECHO_collectionForm(self):
2764: """Add collection form"""
2765: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
2766: return pt()
2767:
2768:
2769: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
2770: """add a echo collection"""
2771:
2772:
2773: newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
2774:
2775: self._setObject(id,newObj)
2776:
2777: if RESPONSE is not None:
2778: RESPONSE.redirect('manage_main')
2779:
2780: class ECHO_group(ECHO_collection):
2781: """ECHO Gruppe"""
2782: security=ClassSecurityInfo()
2783: meta_type="ECHO_group"
2784:
2785: manage_options = Folder.manage_options+(
2786: {'label':'Main Config','action':'ECHO_group_config'},
2787: {'label':'Rerender Links','action':'ECHO_rerenderLinksMDWarning'},
2788: {'label':'Graphics','action':'ECHO_graphicEntry'},
2789: )
2790:
2791: security.declareProtected('View','index_html')
2792:
2793: def showRDF(self):
2794: """showrdf"""
2795: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
2796: 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"""
2797: ret+=self.getRDF(urn="echo:collectionroot")+"\n"
2798:
2799: ret+="""</RDF:RDF>"""
2800:
2801: return ret
2802:
2803: def getRDF(self,urn=None):
2804: """rdf of the collection"""
2805: contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
2806:
2807: ret=getRDFDescription(self,self.absolute_url(),urn=urn)
2808:
2809:
2810: if not urn:
2811: urn=self.absolute_url()
2812: li="""<RDF:li RDF:resource="%s" />\n"""
2813:
2814:
2815: for content in contents:
2816: ret+=content[1].getRDF()+"\n"
2817:
2818: ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
2819: for content in contents:
2820: nurn=content[1].absolute_url()
2821: ret+=li%nurn
2822: return ret+"</RDF:Seq>"
2823:
2824: def index_html(self):
2825: """standard page"""
2826: displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
2827: #if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
2828: # return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
2829:
2830: if 'index.html' in self.__dict__.keys():
2831: return getattr(self,'index.html')()
2832:
2833: elif 'overview' in self.__dict__.keys():
2834: return self.showOverview()
2835: elif hasattr(self,'group_index_template'):
2836: return self.group_index_template()
2837: elif hasattr(self,'collection_index_template'):
2838: return self.collection_index_template()
2839: elif hasattr(self,'main_index_template'):
2840: return self.main_index_template()
2841:
2842: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
2843: pt.content_type="text/html"
2844: return pt()
2845:
2846: def ECHO_group_config(self):
2847: """Main configuration"""
2848:
2849: if not hasattr(self,'weight'):
2850: self.weight=""
2851:
2852: if not hasattr(self,'sortfield'):
2853: self.sortfield="weight"
2854:
2855: if not hasattr(self,'coords'):
2856: self.coords=[]
2857:
2858: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
2859: return pt()
2860:
2861: def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
2862: """Ănderung der Properties"""
2863:
2864: self.secondaryLink=secondaryLink
2865: self.secondaryLinkTitle=secondaryLinkTitle
2866: self.imageTag=imageTag
2867: self.bgcolour=bgcolour
2868: self.logo=logo
2869:
2870: if coords:
2871: coordsnew=[ string.split(x,",") for x in coords]
2872: self.coords=coordsnew[0:]
2873: else:
2874: coordsnew=None
2875: self.coords=None
2876:
2877: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
2878:
2879:
2880:
2881: self.sortfield=sortfield
2882:
2883: if RESPONSE is not None:
2884: RESPONSE.redirect('manage_main')
2885:
2886: def getLogo(self):
2887: """logo ausgeben"""
2888: try:
2889: return self.logo
2890: except:
2891: return "ECHO_groups"
2892:
2893: def content_html(self):
2894: """template fuer content"""
2895: return content_html(self,'group')
2896:
2897:
2898:
2899: def manage_addECHO_groupForm(self):
2900: """Add group form"""
2901: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
2902: return pt()
2903:
2904:
2905: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
2906: """add a echo group"""
2907:
2908:
2909: newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
2910:
2911: setattr(newObj,'logo',logo)
2912: self._setObject(id,newObj)
2913:
2914: if RESPONSE is not None:
2915: RESPONSE.redirect('manage_main')
2916:
2917: Globals.InitializeClass(ECHO_group)
2918:
2919:
2920: class ECHO_userFolder(UserFolder):
2921: """User folder for Intranet"""
2922: _domain_auth_mode=1 # Identification via domain
2923: meta_type="ECHO_userFolder"
2924:
2925: def authenticate(self, name, password, request):
2926: emergency = self._emergency_user
2927: if name is None:
2928: return None
2929: if emergency and name==emergency.getUserName():
2930: user = emergency
2931: else:
2932: user = self.getUser(name)
2933: if user is not None and user.authenticate(password, request):
2934: return user
2935: else:
2936: return None
2937:
2938: def domainSpecMatch(self,spec, request):
2939: host=''
2940: addr=''
2941:
2942: # Fast exit for the match-all case
2943: if len(spec) == 1 and spec[0] == '*':
2944: return 1
2945:
2946: if request.has_key('REMOTE_HOST'):
2947: host=request['REMOTE_HOST']
2948:
2949: if request.has_key('REMOTE_ADDR'):
2950: addr=request['REMOTE_ADDR']
2951:
2952: if request.has_key('HTTP_X_FORWARDED_FOR'):
2953: addr=request['HTTP_X_FORWARDED_FOR']
2954:
2955:
2956: if not host and not addr:
2957: return 0
2958:
2959: if not host:
2960: try: host=socket.gethostbyaddr(addr)[0]
2961: except: pass
2962: if not addr:
2963: try: addr=socket.gethostbyname(host)
2964: except: pass
2965:
2966:
2967: _host=host.split('.')
2968: _addr=addr.split('.')
2969: _hlen=len(_host)
2970: _alen=len(_addr)
2971:
2972: for ob in spec:
2973: sz=len(ob)
2974: _ob=ob.split('.')
2975: _sz=len(_ob)
2976:
2977: mo = addr_match(ob)
2978: if mo is not None:
2979: if mo.end(0)==sz:
2980: fail=0
2981: for i in range(_sz):
2982: a=_addr[i]
2983: o=_ob[i]
2984: if (o != a) and (o != '*'):
2985: fail=1
2986: break
2987: if fail:
2988: continue
2989: return 1
2990:
2991: mo = host_match(ob)
2992: if mo is not None:
2993: if mo.end(0)==sz:
2994: if _hlen < _sz:
2995: continue
2996: elif _hlen > _sz:
2997: _item=_host[-_sz:]
2998: else:
2999: _item=_host
3000: fail=0
3001: for i in range(_sz):
3002: h=_item[i]
3003: o=_ob[i]
3004: if (o != h) and (o != '*'):
3005: fail=1
3006: break
3007: if fail:
3008: continue
3009: return 1
3010: return 0
3011:
3012: Globals.default__class_init__(ECHO_userFolder)
3013:
3014:
3015:
3016: def manage_addECHO_userFolder(self,dtself=None,REQUEST=None,**ignored):
3017: """add a user folder """
3018: f=ECHO_userFolder()
3019: self=self.this()
3020: try: self._setObject('acl_users', f)
3021: except: return MessageDialog(
3022: title ='Item Exists',
3023: message='This object already contains a User Folder',
3024: action ='%s/manage_main' % REQUEST['URL1'])
3025: self.__allow_groups__=f
3026: if REQUEST is not None:
3027: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
3028:
3029: def manage_addECHO_userFolderForm(self):
3030: """add a user folder form"""
3031: return manage_addECHO_userFolder(self)
3032:
3033:
3034:
3035: def createNode(self,descrs,node):
3036: name=descrs[node]['name']
3037: type=descrs[node]['type']
3038: urn=node
3039: #print " will create",node.encode('utf-8')
3040: id=re.sub('[^a-zA-Z0-9]','',name).encode('ascii','ignore')
3041: #print "id",id
3042: #print type
3043: #self.REQUEST.RESPONSE.write("<p>%s<p>\n"%id)
3044: if type=="CDLI_group":
3045:
3046: try:
3047: manage_addECHO_collection(self,id,name,name,"","","","","")
3048:
3049: except:
3050: self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
3051:
3052: self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
3053:
3054: return type,getattr(self,id),urn
3055:
3056: if type=="CDLI_item":
3057: try:
3058: manage_addECHO_resource(self,id,name,name,"","",urn,"","")
3059: except:
3060: self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
3061: self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
3062:
3063:
3064: return "XX"
3065:
3066:
3067: class ECHO_root(Folder,Persistent,Implicit):
3068: """ECHO Root Folder"""
3069:
3070: security=ClassSecurityInfo()
3071:
3072: meta_type="ECHO_root"
3073:
3074: ###CDLI adds -> have to be removed
3075: def getTablet(self,item):
3076: #print "getTablet"
3077: try:
3078: read=urllib.urlopen("http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"%item).read()
3079: read=re.sub("\[search\]","search",read)
3080: return read[read.find("<body>")+6:read.rfind("</body>")]
3081: except:
3082: return "<h1>Sorry no connection to the data server enlil.museum.upenn.edu</h1>"
3083: #return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"
3084: ###END CDLI add
3085:
3086: def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):
3087: """sendform"""
3088: toaddrs=["dwinter@mpiwg-berlin.mpg.de"]
3089:
3090: msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n"
3091: % (fromaddr, ", ".join(toaddrs),"testsub"))
3092: server = smtplib.SMTP(server)
3093: #server.set_debuglevel(1)
3094: msg=msg+content
3095: server.sendmail(fromaddr, toaddrs, msg)
3096: server.quit()
3097:
3098: def generateFromRDFForm(self):
3099: """change form"""
3100: pt=PageTemplateFile('Products/ECHO_content/zpt/generateFromRDFForm').__of__(self)
3101: pt.content_type="text/html"
3102: return pt()
3103:
3104: def generateFromRDF(self,file,startNode="/Cuneiform Corpus"):
3105:
3106: """generate from RDF"""
3107:
3108: global seqs
3109: seqs={}
3110: global descrs
3111: descrs={}
3112: global key
3113: key=""
3114: global value
3115: value=""
3116:
3117: def getEdges(seqs,urn):
3118: """edges"""
3119: ret=[]
3120: return seqs[urn]
3121:
3122: def createSubs(self,seqs,descrs,urn,level=0):
3123: """create subs"""
3124: for edge in getEdges(seqs,urn):
3125: cn=createNode(self,descrs,edge)
3126: if cn[0]=="CDLI_group":
3127: createSubs(cn[1],seqs,descrs,cn[2],level+1)
3128: return
3129:
3130: def start_element(name,attrs):
3131:
3132: global seqs
3133: global descrs
3134: global key
3135: global value
3136: seq=""
3137: if name=="RDF:Seq":
3138: key=attrs.get('RDF:about')
3139: try: # teste ob liste
3140: x=seqs[key][0]
3141: except:
3142:
3143: seqs[key]=[]
3144:
3145:
3146: elif name=="RDF:Description":
3147: key=attrs.get('RDF:about')
3148:
3149:
3150: elif name=="RDF:li":
3151: name=attrs.get('RDF:resource')
3152: seqs[key].append(name)
3153:
3154: elif name=="ECHONAVIGATION:type":
3155: value="type"
3156:
3157: elif name=="ECHONAVIGATION:name":
3158: value="name"
3159: elif name=="ECHONAVIGATION:linkClickable":
3160: value="linkClickable"
3161:
3162: def end_element(name):
3163: """nothing"""
3164: key=""
3165: value=""
3166:
3167: def char_data(data):
3168: """nothing"""
3169:
3170: data=re.sub("\n","",data)
3171: try:
3172: if descrs[key].has_key(value):
3173: descrs[key][value]+=data
3174: else:
3175: descrs[key][value]=data
3176: except:
3177:
3178: descrs[key]={}
3179: descrs[key][value]=data
3180:
3181: p = xml.parsers.expat.ParserCreate()
3182:
3183: p.StartElementHandler = start_element
3184: p.EndElementHandler = end_element
3185: p.CharacterDataHandler = char_data
3186:
3187:
3188: p.ParseFile(file)
3189: self.REQUEST.RESPONSE.write("<html><body><h1>Start</h1>")
3190: createSubs(self,seqs,descrs,startNode)
3191: self.REQUEST.RESPONSE.write("<h1>done</h1></body></html>")
3192: #print "done"
3193:
3194:
3195: return "done"
3196:
3197:
3198:
3199:
3200: def changeWeightsInCollection(self):
3201: """change all lables of a collection"""
3202: ret=""
3203: argv=self.REQUEST.form
3204:
3205: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
3206: for resource in resources:
3207:
3208: try:
3209: ret+=resource[1].getId()+" "+argv[resource[1].getId()]+"</br>"
3210: resource[1].weight=argv[resource[1].getId()][0:]
3211: except:
3212: """not"""
3213: return ret
3214:
3215: def changeWeights(self):
3216: """change form"""
3217: pt=PageTemplateFile('Products/ECHO_content/zpt/changeWeightForm').__of__(self)
3218: pt.content_type="text/html"
3219: return pt()
3220: getSubCols = ECHO_helpers.getSubCols
3221:
3222: manage_options=Folder.manage_options+(
3223: {'label':'Main Config','action':'ECHO_copyright_configForm'},
3224: {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
3225: {'label':'Change Weights','action':'changeWeights'},
3226: {'label':'Generate from RDF','action':'generateFromRDFForm'},
3227:
3228: )
3229:
3230:
3231: def showRDF(self):
3232: """showrdf"""
3233: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
3234: 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"""
3235: ret+=self.getRDF(urn="echo:collectionroot")+"\n"
3236:
3237: ret+="""</RDF:RDF>"""
3238: return ret
3239:
3240:
3241: def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
3242: """warning"""
3243: pt=PageTemplateFile('Products/ECHO_content/zpt/reloadMetaDataFromStorageWarning.zpt').__of__(self)
3244: pt.content_type="text/html"
3245: return pt()
3246:
3247: def reloadMetaDataFromStorage(self,RESPONSE=None):
3248: """reload MD from Storage"""
3249:
3250: return reloadMetaDataFromStorage(self,RESPONSE)
3251:
3252: def getRDF(self,urn=None):
3253: """rdf of the collection"""
3254:
3255: contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
3256:
3257: ret=getRDFDescription(self,self.absolute_url(),urn=urn)
3258:
3259: li="""<RDF:li RDF:resource="%s" />\n"""
3260:
3261:
3262: for content in contents:
3263: ret+=content[1].getRDF()+"\n"
3264:
3265: ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
3266: for content in contents:
3267: nurn=content[1].absolute_url()
3268: ret+=li%nurn
3269: return ret+"</RDF:Seq>"
3270:
3271:
3272: def showContent(self,path):
3273: """return content/html"""
3274:
3275: return ECHO_helpers.urlopen(path+"/content_html").read()
3276:
3277: def getImageViewers(self):
3278: """images"""
3279: viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])
3280: return viewers
3281:
3282:
3283: def getBibTag(self,tag,content):
3284: """get field tag fĂźr index-meta-generation"""
3285: if not content or content=="":
3286: return ""
3287: ret="<%s>"%tag
3288: #ret+=urllib.quote(content)
3289: ret+=content
3290:
3291: ret+="</%s>"%tag
3292: return ret
3293:
3294: def getValueFromClass(self,field,found):
3295: """retattribute falss existing"""
3296: try:
3297:
3298: return getattr(found,field).decode('ascii','ignore')
3299: except:
3300: return ""
3301:
3302: def getImageTag(self):
3303: """needed by main_template"""
3304: return ""
3305: secondaryLink="" #needed by main_template
3306: secondaryLinkTitle="" #needed by main_template
3307:
3308: def getBgcolour(self):
3309: """hack"""
3310: return "#dddddd"
3311:
3312: def contentTypeSelector_HTML(self,selected=None):
3313: """give type selector"""
3314: if not selected:
3315: retStr="<option selected>\n"
3316: else:
3317: retStr="<option>\n"
3318:
3319: try: # erste version contentTypes exists
3320: for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
3321: if selected and (contentType[0]==selected):
3322: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
3323: else:
3324: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
3325: except:
3326: try:
3327: for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
3328: if selected and (contentType[0]==selected):
3329: retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
3330: else:
3331: retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
3332: except:
3333: """nothing"""
3334:
3335: return retStr
3336:
3337: def renderingTypeSelector_HTML(self,selected=None):
3338: """give type selector"""
3339: if not selected:
3340: retStr="<option selected>\n"
3341: else:
3342: retStr="<option>\n"
3343:
3344: try: # erste version renderingTypes exists
3345: for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
3346: if selected and (renderingType[0]==selected):
3347: retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
3348: else:
3349: retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
3350: except:
3351: """nothing"""
3352: return retStr
3353:
3354: def renderingTypeSelector_HTML(self,selected=None):
3355: """give type selector"""
3356: if not selected:
3357: retStr="<option selected>\n"
3358: else:
3359: retStr="<option>\n"
3360:
3361: try: # erste version renderingTypes exists
3362: for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
3363: if selected and (renderingType[0]==selected):
3364: retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
3365: else:
3366: retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
3367: except:
3368: """nothing"""
3369: return retStr
3370:
3371:
3372: def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):
3373: """give type selector"""
3374:
3375: if not first:
3376: if not selected:
3377: retStr="<option selected>\n"
3378: else:
3379: retStr="<option>\n"
3380: else:
3381: if not selected:
3382: retStr="""<option selected value="%s">%s\n"""%first
3383: else:
3384: retStr="""<option value="%s">%s\n"""%first
3385:
3386:
3387: try: # erste version copyrightTypes exists
3388: for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
3389: if selected and (copyrightType[0]==selected):
3390: retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3391: else:
3392: retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3393:
3394: for copyrightTypeSelf in self.ZopeFind(object,obj_metatypes=["ECHO_copyrightType"],search_sub=1):
3395: if selected and (copyrightTypeSelf[0]==selected):
3396: retStr+="""<option selected value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
3397: else:
3398: retStr+="""<option value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
3399:
3400: except:
3401: """nothing"""
3402:
3403: return retStr
3404:
3405: def partnerSelector_HTML(self,selected=None):
3406: """give type selector"""
3407: if not selected:
3408: retStr="<option selected>\n"
3409: else:
3410: retStr="<option>\n"
3411:
3412: try: # erste version copyrightTypes exists
3413: for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):
3414: if selected and (copyrightType[0]==selected):
3415: retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3416: else:
3417: retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
3418: except:
3419: """nothing"""
3420: return retStr
3421:
3422: mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version Ăźber echoroot??
3423:
3424: def mediaTypeSelector_HTML(self,selected=None):
3425: """give type selector"""
3426: if not selected:
3427: retStr="<option selected>\n"
3428: else:
3429: retStr="<option>\n"
3430:
3431: try: # erste version mediatypesTypes exists
3432: for mediaType in self.mediaTypes:
3433: if selected and (mediaType in selected):
3434: retStr+="""<option selected value="%s">%s\n"""%(mediaType,mediaType)
3435: else:
3436: retStr+="""<option value="%s">%s\n"""%(mediaType,mediaType)
3437: except:
3438: """nothing"""
3439: return retStr
3440:
3441:
3442: def patchContentType(self,obj=None):
3443: """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
3444:
3445:
3446: if not obj:
3447: obj = self
3448:
3449: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
3450:
3451: for entry in entries:
3452: setattr(entry[1],'contentType',entry[1].content_type)
3453: #entry[1].contentType == entry[1].content_type
3454:
3455: if entry[1].meta_type == 'ECHO_collection':
3456: entry[1].patchContentType(entry[1])
3457:
3458:
3459: return "changed all contenttypes in: "+self.title
3460:
3461:
3462: def patchViewClassification(self,obj=None):
3463: """setze viewClassification heuristisch"""
3464:
3465: def checkIfArrow(obj):
3466: if hasattr(obj,'coords'):
3467: for coordtemp in obj.coords:
3468:
3469: if (len(coordtemp)>4) and not (coordtemp[4]==''):
3470: return 4
3471: return None
3472: return None
3473:
3474: if not obj:
3475: obj = self
3476:
3477: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
3478:
3479: for entry in entries:
3480:
3481: if checkIfArrow(entry[1]):
3482: setattr(entry[1],'viewClassification','view point')
3483: else:
3484: setattr(entry[1],'viewClassification','area')
3485:
3486: #entry[1].contentType == entry[1].content_type
3487:
3488: if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
3489: entry[1].patchViewClassification(entry[1])
3490:
3491:
3492: return "changed all contenttypes in: "+self.title
3493:
3494: def deleteCache(self,obj=None,RESPONSE=None):
3495: """setze alle collections auf cache = CacheManager"""
3496:
3497:
3498: if not obj:
3499: obj = self
3500:
3501: entries=obj.ZopeFind(obj,search_sub=1)
3502:
3503: for entry in entries:
3504: if hasattr(entry[1],'_v_hash'):
3505: entry[1]._v_hash=None
3506:
3507:
3508:
3509:
3510: return "changed all CM in: "+self.title
3511:
3512:
3513:
3514: def ECHO_newViewerLink(self,obj=None):
3515: """change links (:86 faellt weg)"""
3516:
3517: if not obj:
3518: obj = self
3519:
3520: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
3521:
3522: for entry in entries:
3523:
3524: if entry[1].meta_type == 'ECHO_resource':
3525:
3526: entry[1].link=re.sub('\:86','',entry[1].link)
3527:
3528: else:
3529:
3530: entry[1].ECHO_newViewerLink(entry[1])
3531:
3532: return "Rerenderd all links to resources in: "+self.title
3533:
3534: def __init__(self,id,title):
3535: """init"""
3536: self.id = id
3537: self.title=title
3538:
3539: def deleteSpace(self,str):
3540: """delete space at the end of a line"""
3541: if str[len(str)-1]==" ":
3542: return str[0:len(str)-1]
3543: else:
3544: return str
3545:
3546:
3547:
3548: # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
3549:
3550: def formatAscii(self,str,url=None):
3551: """ersetze ascii umbrueche durch <br>"""
3552: #url=None
3553: if url:
3554:
3555: retStr=""
3556: words=str.split("\n")
3557:
3558: for word in words:
3559: strUrl=url%word
3560:
3561: retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
3562: str=retStr
3563: if str:
3564: return re.sub(r"[\n]","<br/>",str)
3565: else:
3566: return ""
3567:
3568: def link2html(self,str):
3569: """link2html fuer VLP muss hier noch raus"""
3570: if str:
3571:
3572: str=re.sub("\&","&",str)
3573: dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>")
3574: links=dom.getElementsByTagName("link")
3575:
3576:
3577: for link in links:
3578: link.tagName="a"
3579: ref=link.getAttribute("ref")
3580: pn=link.getAttribute("page")
3581:
3582: if self.checkRef(ref):
3583: if pn:
3584: link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)
3585: else:
3586: link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
3587:
3588:
3589: newxml=dom.toxml('utf-8')
3590:
3591: retStr=regexpTXT.search(newxml)
3592:
3593: return retStr.group(1)
3594:
3595:
3596: return ""
3597:
3598: def xml2html(self,str,quote="yes"):
3599: """link2html fuer VLP muss hier noch raus"""
3600:
3601: if str:
3602: if quote=="yes2":
3603: str=re.sub("\&","&",str)
3604: #dom=xml.dom.minidom.parseString(str)
3605: dom = NonvalidatingReader.parseString(str,"http://www.mpiwg-berlin.mpg.de/")
3606: #links=dom.getElementsByTagName("link")
3607: links=Ft.Xml.XPath.Evaluate(".//link", contextNode=dom)
3608: for link in links:
3609: #link.tagName="a"
3610:
3611: ref=link.getAttributeNS(EMPTY_NAMESPACE,"ref")
3612: pn=link.getAttributeNS(EMPTY_NAMESPACE,"page")
3613:
3614: cns=link.childNodes[0:]
3615:
3616: newLink=dom.createElementNS(EMPTY_NAMESPACE,"a")
3617: for x in cns:
3618: newLink.appendChild(x)
3619:
3620:
3621:
3622: link.parentNode.replaceChild(newLink,link)
3623: if self.checkRef(ref):
3624: if pn:
3625: newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)
3626: else:
3627: newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
3628:
3629: #str= dom.toxml('utf-8')
3630: buf = cStringIO.StringIO()
3631: PrettyPrint(dom, stream=buf, encoding='UTF-8')
3632: str = buf.getvalue()
3633: buf.close()
3634: #str=PrettyPrint(dom.documentElement,encoding='UTF-8')
3635: #print link.toxml('utf-8')
3636: #print type(str)
3637: retStr=regexpPage.search(str)
3638: try: # hack warum fehtl manchmal page??
3639: return retStr.group(1)
3640: except:
3641: return str
3642: return ""
3643:
3644: def checkRef(self,ref):
3645: if ref[0:3]=='lit':
3646: if len(self.library_data({ 'id':ref}))>0:
3647: return 1
3648: try:
3649: if ref[0:7]=="tec_cat":
3650: return 1
3651: except:
3652: """nothing"""
3653:
3654: dbs={'vl_technology':'','vl_people':'','vl_sites':''}
3655: res=None
3656: for db in dbs.keys():
3657: res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
3658: return res
3659:
3660: #Ende Methode fuer vlp
3661:
3662: def PgQuoteString(self,string):
3663: """Quote string"""
3664:
3665: return libpq.PgQuoteString(string)
3666:
3667: def getPartners(self):
3668: """Get list of Partners. Presently only from a subfolder partners"""
3669:
3670: return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
3671:
3672:
3673: def getInstitutions(self):
3674: """Get list of Partners. Presently only from a subfolder partners"""
3675:
3676: return [ item[1] for item in self.institutions.ZopeFind(self.institutions,obj_metatypes=['ECHO_institution'])]
3677:
3678:
3679: def getPartnersXML(self):
3680: """partner liste als xml"""
3681: partners=self.getPartners()
3682: ret="""<?xml version="1.0" encoding="utf-8" ?>
3683: <partners>"""
3684:
3685: for partner in partners:
3686: ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
3687:
3688: return ret+"\n</partners>"
3689:
3690: def getCollectionTree(self):
3691: """get the collection tree (list of triples (parent,child, depth)"""
3692:
3693: def getCollection(object,depth=0):
3694: depth+=1
3695: collections=[]
3696: for entry in object.__dict__.keys():
3697: element=getattr(object,entry)
3698: try:
3699: if element.meta_type=="ECHO_collection":
3700: collections.append((object,element,depth))
3701: collections+=getCollection(element,depth)
3702: except:
3703: """nothing"""
3704: return collections
3705:
3706:
3707: return getCollection(self)
3708:
3709: def getCollectionTreeIds(self):
3710: """Show the IDs of the Tree"""
3711: ret=[]
3712: for collection in self.getCollectionTree():
3713: ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
3714: return ret
3715:
3716: def getResourcesHTML(self,viewerType=None,filter=None):
3717: """gebe all ressourcen aus"""
3718:
3719: def sortHTML(x,y):
3720: return cmp(x[1].title,y[1].title)
3721:
3722: ret="""<html><body><h2>Resources in ECHO</h3>"""
3723:
3724: resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
3725: ret+="""<h3>Found %i resources</h3>"""%len(resources)
3726: resources.sort(sortHTML)
3727: for resource in resources:
3728: echo_url=resource[1].absolute_url()
3729:
3730: if hasattr(resource[1],'title'):
3731: title=resource[1].title
3732: else:
3733: title="None"
3734: if filter:
3735: if re.search(filter,title):
3736: ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
3737: else:
3738: ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
3739:
3740: ret +="""\n</body></html>"""
3741:
3742: #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
3743: #self.REQUEST.RESPONSE.write(ret)
3744: return ret
3745:
3746: def getResourcesXML(self,viewerType=None,filter=None):
3747: """gebe all ressourcen aus"""
3748: ret="""<?xml version="1.0" ?>
3749: <index>"""
3750: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
3751:
3752: echo_url=resource[1].absolute_url()
3753: if hasattr(resource[1],'link'):
3754: viewer_url=resource[1].link
3755: else:
3756: viewer_url="NO URL"
3757: if filter:
3758: if re.search(filter,viewer_url):
3759: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3760: else:
3761: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3762: ret +="""\n</index>"""
3763:
3764: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
3765: self.REQUEST.RESPONSE.write(ret)
3766:
3767: def getFullTextsXML(self,viewerType=None,filter=None):
3768: """gebe all ressourcen aus"""
3769: ret="""<?xml version="1.0" ?>
3770: <index>"""
3771: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
3772:
3773: echo_url=resource[1].absolute_url()
3774: if resource[1].getFullTextXML(noredirect="yes"):
3775: if hasattr(resource[1],'link'):
3776: viewer_url=echo_url+"/getFullTextXML"
3777: else:
3778: viewer_url="NO URL"
3779: if filter:
3780: if re.search(filter,viewer_url):
3781: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3782: else:
3783: ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
3784: ret +="""\n</index>"""
3785:
3786:
3787: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
3788: self.REQUEST.RESPONSE.write(ret)
3789:
3790:
3791: def getMetaDatasXML(self,viewerType=None,filter=None):
3792: """gebe all ressourcen aus"""
3793: # check if the request's host part was OK
3794: http_host = self.REQUEST['HTTP_HOST']
3795: host_port = self.REQUEST['SERVER_PORT']
3796: fix_host = None
3797: if http_host and http_host.rfind(host_port) == -1:
3798: print "HTTP_HOST needs fixing!"
3799: fix_host = http_host + ":" + host_port
3800:
3801: ret="""<?xml version="1.0" ?>
3802: <index>"""
3803: for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
3804:
3805: echo_url=resource[1].absolute_url()
3806: if fix_host:
3807: #print "replacing ", http_host, " by ", fix_host
3808: echo_url = string.replace(echo_url, http_host, fix_host, 1)
3809:
3810: if hasattr(resource[1],'link'):
3811: meta_url=echo_url+"/getMetaDataXML"
3812: else:
3813: meta_url="NO_URL"
3814:
3815: if filter and not re.search(filter,viewer_url):
3816: continue
3817:
3818: #modificationDate=time.strptime(str(resource[1].bobobase_modification_time()),"%Y/%m/%d %H:%M:%S %Z")
3819:
3820: modificationDate=resource[1].bobobase_modification_time().strftime("%Y/%m/%d %H:%M:%S")
3821:
3822: ret+="""\n<resource resourceLink="%s" metaLink="%s" modificationDate="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'),modificationDate)
3823:
3824:
3825: ret +="""\n</index>"""
3826:
3827: self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
3828: self.REQUEST.RESPONSE.write(ret)
3829:
3830:
3831: def findPartners(self):
3832: """find all partners in partners"""
3833: par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')
3834: return par
3835:
3836: def getPartnerFromID(self):
3837: """find partner form ID return object"""
3838: pa=self.REQUEST['partner']
3839: par=self.ZopeFind(self.partners, obj_ids=[pa])
3840: return par
3841:
3842: def getPartnerFromIDParameter(self, id):
3843: """ find partners from ID"""
3844: par=self.ZopeFind(self.partners, obj_ids=[id])
3845: return par
3846:
3847: def getInstitutionFromID(self,id):
3848: """ find institution from id """
3849: inst=self.ZopeFind(self.institutions, obj_ids=[id])
3850: return inst
3851:
3852:
3853: def manage_addECHO_root(self,id,title,RESPONSE=None):
3854: """Add an ECHO_root"""
3855: self._setObject(id,ECHO_root(id,title))
3856:
3857: if RESPONSE is not None:
3858: RESPONSE.redirect('manage_main')
3859:
3860: def manage_addECHO_rootForm(self):
3861: """Nothing yet"""
3862: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
3863: return pt()
3864:
3865: class ECHO_copyrightType(Folder):
3866: """copyright typ"""
3867:
3868: meta_type="ECHO_copyrightType"
3869:
3870: def __init__(self,id,title,label,url):
3871: """init"""
3872: self.id=id
3873: self.title=title
3874: self.label=label
3875: self.url=url
3876:
3877: manage_options = Folder.manage_options+(
3878: {'label':'Main Config','action':'ECHO_copyrightType_config_mainForm'},
3879: )
3880:
3881: def ECHO_copyrightType_config_mainForm(self):
3882: """change form"""
3883: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_copyrightType').__of__(self)
3884: pt.content_type="text/html"
3885: return pt()
3886:
3887: def ECHO_copyrightType_config_main(self,title,label,url,RESPONSE=None):
3888: """change"""
3889: self.title=title
3890: self.label=label
3891: self.url=url
3892:
3893: if RESPONSE is not None:
3894: RESPONSE.redirect('manage_main')
3895:
3896: def manage_addECHO_copyrightTypeForm(self):
3897: """Form for adding a ressource"""
3898: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_copyrightTypeForm.zpt').__of__(self)
3899: return pt()
3900:
3901:
3902: def manage_addECHO_copyrightType(self,id,title,label,url,RESPONSE=None):
3903: """addaresource"""
3904:
3905: newObj=ECHO_copyrightType(id,title,label,url)
3906:
3907: self._setObject(id,newObj)
3908:
3909: if RESPONSE is not None:
3910: RESPONSE.redirect('manage_main')
3911:
3912:
3913:
3914: class ECHO_partner(Image,Persistent):
3915: """ECHO Partner"""
3916:
3917: meta_type="ECHO_partner"
3918:
3919: def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):
3920: self.__name__=id
3921: self.title=title
3922: self.url=url
3923: self.person=person
3924: self.email=email
3925: self.country=country
3926: self.color=color
3927: self.precondition=precondition
3928: self.copyrightType=copyrightType
3929: data, size = self._read_data(file)
3930: content_type=self._get_content_type(file, data, id, content_type)
3931: self.update_data(data, content_type, size)
3932:
3933: manage_options = Image.manage_options+(
3934: {'label':'Partner Information','action':'ECHO_partner_config'},
3935: )
3936:
3937:
3938: def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):
3939: """Change main information"""
3940: self.url=url
3941: self.person=person
3942: self.email=email
3943: self.country=country
3944: self.color=color
3945: self.copyrightType=copyrightType
3946: if RESPONSE is not None:
3947: RESPONSE.redirect('manage_main')
3948:
3949:
3950:
3951: def ECHO_partner_config(self):
3952: """Main configuration"""
3953: if not hasattr(self,'url'):
3954: self.url=""
3955: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)
3956: return pt()
3957:
3958:
3959: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
3960: Kind='ECHO_partner',kind='ECHO_partner')
3961:
3962:
3963:
3964: def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',
3965: REQUEST=None):
3966: """
3967: Add a new ECHO_partner object.
3968:
3969: Creates a new ECHO_partner object 'id' with the contents of 'file'.
3970: Based on Image.manage_addImage
3971: """
3972:
3973: id=str(id)
3974: title=str(title)
3975: content_type=str(content_type)
3976: precondition=str(precondition)
3977:
3978: id, title = OFS.Image.cookId(id, title, file)
3979:
3980: self=self.this()
3981:
3982: # First, we create the image without data:
3983: self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))
3984:
3985: # Now we "upload" the data. By doing this in two steps, we
3986: # can use a database trick to make the upload more efficient.
3987: if file:
3988: self._getOb(id).manage_upload(file)
3989: if content_type:
3990: self._getOb(id).content_type=content_type
3991:
3992: if REQUEST is not None:
3993: try: url=self.DestinationURL()
3994: except: url=REQUEST['URL1']
3995: REQUEST.RESPONSE.redirect('%s/manage_main' % url)
3996: return id
3997:
3998: class ECHO_linkList(ZopePageTemplate):
3999: """LinkList Objekt"""
4000: meta_type="ECHO_linkList"
4001:
4002: _default_content_fn = os.path.join(package_home(globals()), 'html/ECHO_pageTemplateDefault.html')
4003:
4004: manage_options = ZopePageTemplate.manage_options+(
4005: {'label':'Main Config','action':'changeECHO_linkListWeightForm'},
4006: )
4007:
4008: def content_html(self):
4009: """content_html"""
4010: return content_html(self,'pageTemplate')
4011:
4012: def changeECHO_linkListWeightForm(self):
4013: """change"""
4014: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_linkListTemplate.zpt').__of__(self)
4015: return pt()
4016:
4017: def changeECHO_linkListWeight(self,contentType,label,RESPONSE=None):
4018: """change"""
4019: self.contentType=contentType
4020: self.label=label
4021:
4022: if RESPONSE is not None:
4023: RESPONSE.redirect('manage_main')
4024:
4025: def getLabel(self):
4026: if hasattr(self,'label'):
4027: return self.label.encode('utf-8')
4028: else:
4029: return 0
4030:
4031: def getcontentType(self):
4032: """get contentType"""
4033: if hasattr(self,'contentType'):
4034: return self.contentType
4035: else:
4036: return 0
4037:
4038: def __init__(self, id, label, title=None, text=None, contentType=None):
4039: self.id = str(id)
4040: self.title=title
4041: self.label=label
4042: self.ZBindings_edit(self._default_bindings)
4043: if text is None:
4044: text = ''
4045: self.pt_edit(text, contentType)
4046:
4047:
4048:
4049:
4050: def manage_addECHO_linkListForm(self):
4051: """Form for adding"""
4052: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkListTemplate.zpt').__of__(self)
4053: return pt()
4054:
4055: from urllib import quote
4056:
4057:
4058: def manage_addECHO_linkList(self, id, label,contentType=0,title=None, text=None,
4059: REQUEST=None, submit=None):
4060: """Add a LinkList with optional file content."""
4061:
4062: id = str(id)
4063: if REQUEST is None:
4064: self._setObject(id, ECHO_linkList(id, label, text))
4065: ob = getattr(self, id)
4066: setattr(ob,'contentType',contentType)
4067: if title:
4068: ob.pt_setTitle(title)
4069: return ob
4070: else:
4071: file = REQUEST.form.get('file')
4072: headers = getattr(file, 'headers', None)
4073: if (headers is None) or (not file.filename):
4074: zpt = ECHO_linkList(id, file)
4075: else:
4076: zpt = ECHO_linkList(id, label,'', file, headers.get('contentType'))
4077:
4078: self._setObject(id, zpt)
4079: ob = getattr(self, id)
4080: if title:
4081: ob.pt_setTitle(title)
4082:
4083: try:
4084: u = self.DestinationURL()
4085: except AttributeError:
4086: u = REQUEST['URL1']
4087:
4088: if submit == " Add and Edit ":
4089: u = "%s/%s" % (u, quote(id))
4090: REQUEST.RESPONSE.redirect(u+'/manage_main')
4091: return ''
4092:
4093:
4094: class ECHO_support(Folder):
4095: """gefÂrdert durch"""
4096: meta_type="ECHO_support"
4097:
4098:
4099:
4100: def __init__(self,id,institutions=None):
4101: """init"""
4102: self.id=id
4103: self.title=''
4104: self.institutions=toList(institutions)
4105:
4106: def getSupporter(self):
4107: """return institutions"""
4108: if self.institutions:
4109: return self.institutions
4110: else:
4111: return []
4112:
4113: manage_options = Folder.manage_options+(
4114: {'label':'Main Config','action':'ECHO_support_configForm'},
4115: )
4116:
4117: def ECHO_support_configForm(self):
4118: """change form"""
4119: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_support').__of__(self)
4120: pt.content_type="text/html"
4121: return pt()
4122:
4123: def ECHO_support_config(self,institutions=None,RESPONSE=None):
4124: """change"""
4125: self.institutions=toList(institutions)
4126:
4127: if RESPONSE is not None:
4128: RESPONSE.redirect('manage_main')
4129:
4130:
4131: def manage_addECHO_supportForm(self):
4132: """Form for adding"""
4133: pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_support.zpt').__of__(self)
4134: return pt()
4135:
4136: def manage_addECHO_support(self, id,institutions=None,RESPONSE=None):
4137: """add the copyright"""
4138:
4139: meta_type="ECHO_support"
4140:
4141:
4142: self._setObject(id, ECHO_support(id,institutions))
4143:
4144: if RESPONSE is not None:
4145: RESPONSE.redirect('manage_main')
4146:
4147:
4148: class ECHO_institution(Image,Persistent):
4149: """ECHO Institution"""
4150:
4151: meta_type="ECHO_institution"
4152:
4153: def __init__(self, id, title,url, file, person, email, country, content_type='', precondition=''):
4154: self.__name__=id
4155: self.title=title
4156: self.url=url
4157: self.person=person
4158: self.email=email
4159: self.country=country
4160: self.precondition=precondition
4161: data, size = self._read_data(file)
4162: content_type=self._get_content_type(file, data, id, content_type)
4163: self.update_data(data, content_type, size)
4164:
4165: manage_options = Image.manage_options+(
4166: {'label':'Institution Information','action':'ECHO_institution_config'},
4167: )
4168:
4169:
4170: def changeECHO_institution(self,url,person, email, country,RESPONSE=None):
4171: """Change main information"""
4172: self.url=url
4173: self.person=person
4174: self.email=email
4175: self.country=country
4176: if RESPONSE is not None:
4177: RESPONSE.redirect('manage_main')
4178:
4179:
4180:
4181: def ECHO_institution_config(self):
4182: """Main configuration"""
4183: if not hasattr(self,'url'):
4184: self.url=""
4185: pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_institution.zpt').__of__(self)
4186: return pt()
4187:
4188:
4189: manage_addECHO_institutionForm=DTMLFile('dtml/ECHO_institutionAdd',globals(),
4190: Kind='ECHO_institution',kind='ECHO_institution')
4191:
4192:
4193:
4194: def manage_addECHO_institution(self, id, url, person, email, country, file=None, title='', precondition='', content_type='',
4195: REQUEST=None):
4196: """
4197: Add a new ECHO_institution object.
4198:
4199: Creates a new ECHO_institution object 'id' with the contents of 'file'.
4200: Based on Image.manage_addImage
4201: """
4202:
4203: id=str(id)
4204: title=str(title)
4205: content_type=str(content_type)
4206: precondition=str(precondition)
4207:
4208: id, title = OFS.Image.cookId(id, title, file)
4209:
4210: self=self.this()
4211:
4212: # First, we create the image without data:
4213: self._setObject(id, ECHO_institution(id,title,url,'', person, email, country, content_type, precondition))
4214:
4215: # Now we "upload" the data. By doing this in two steps, we
4216: # can use a database trick to make the upload more efficient.
4217: if file:
4218: self._getOb(id).manage_upload(file)
4219: if content_type:
4220: self._getOb(id).content_type=content_type
4221:
4222: if REQUEST is not None:
4223: try: url=self.DestinationURL()
4224: except: url=REQUEST['URL1']
4225: REQUEST.RESPONSE.redirect('%s/manage_main' % url)
4226: return id
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ECHO_collection.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ECHO_content