1: """ OSAS_contains the basic classes for configuring the OSAS and
2: basic objects for displaying data.
3: All site specific adaptation should be made in OSAS_Root
4: """
5:
6: from OSAS_helpers import *
7: import OSAS_helpers
8: from OFS.SimpleItem import SimpleItem
9: from time import localtime,strftime
10: from Acquisition import Implicit
11: from OFS.Folder import Folder
12: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
13: from Products.PageTemplates.PageTemplate import PageTemplate
14: import urllib
15: from urlparse import *
16: import re
17: import xml.dom.minidom
18: from types import *
19: import logging
20:
21: #ersetzt logging
22: def logger(txt,method,txt2):
23: """logging"""
24: logging.info(txt+ txt2)
25:
26:
27: import os.path
28: import Globals
29: from Globals import package_home
30: from AccessControl import ClassSecurityInfo
31: import xmlrpclib
32: from xml.sax import make_parser
33: from xml.sax.handler import ContentHandler
34: import sys
35:
36: class OSAS_add_contextData(Folder):
37: """Einfuegen eines Documentes in eine Collection"""
38:
39: security=ClassSecurityInfo()
40:
41:
42: meta_type='OSAS_addObjectToCollection'
43:
44: def XmlToTree(self,URL,pwstr=None):
45: """Collection XML to Tree"""
46: def spaces(depth):
47:
48: tmp=""
49: k=0
50: while k<2*depth:
51: k+=1
52: tmp=tmp+" "+" "
53: return tmp
54:
55: class requestHandler(ContentHandler):
56: def __init__(self):
57: self.depth=0
58: self.retStr=""
59:
60: def startElement(self,name,attrs):
61: if name=="element":
62: self.depth+=1
63: begin=""
64: end=""
65: if self.depth==1:
66: begin="<b>"
67: end="</b>"
68:
69: self.retStr+=spaces(self.depth)+"<input type='radio' name='collection' value='%s'>%s</input>"%(attrs.get('url'),begin+urllib.unquote(attrs.get('name')))+end+"<br>\n"
70:
71:
72:
73: def endElement(self,name):
74: if name=="element":
75: self.depth-=1
76:
77: if pwstr=="":
78: pwstr=None
79:
80:
81:
82: try:
83: if pwstr:
84: URL+="/getCollectionTreeXML?pwstr=%s"%pwstr
85: else:
86: URL+="/getCollectionTreeXML"
87: parser=make_parser()
88: curHandler=requestHandler()
89: parser.setContentHandler(curHandler)
90:
91: parser.parse(urllib.urlopen(URL))
92: return curHandler.retStr.encode('utf-8')
93:
94: except:
95: logger('OSAS_Root (addFileToDollection)',logging.ERROR,'%s %s'%sys.exc_info()[:2])
96: return URL
97: return urllib.urlopen(URL).read()
98:
99:
100: def __init__(self,id,collection):
101: self.id=id
102: self.collection=collection
103:
104:
105:
106:
107: def getPartners(self,URL):
108: """Zeige Partnerliste"""
109: class requestHandler(ContentHandler):
110: def __init__(self):
111: self.ret=[]
112:
113: def startElement(self,name,attrs):
114: if name=="partner":
115: self.ret.append((attrs.get('id'),attrs.get('title').encode('utf-8')))
116:
117:
118: URL+="/getPartnersXML"
119: parser=make_parser()
120: curHandler=requestHandler()
121: parser.setContentHandler(curHandler)
122: parser.parse(urllib.urlopen(URL))
123: try:
124:
125: return curHandler.ret
126: except:
127: return [("",URL)]
128:
129:
130:
131: def addContextData(self,path):
132: """Hinzufuegen zu einer Sammlung"""
133:
134: server=xmlrpclib.Server(self.serverUrl)
135:
136:
137: self.REQUEST.SESSION['images']=server.getImages(path)
138:
139:
140: self.REQUEST.SESSION['movies']=server.getMovies(path)
141:
142:
143:
144: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','contextDataMain.zpt')).__of__(self)
145: return pt()
146:
147: index_html=addContextData
148:
149: def addContextData2(self,path,collection,label,description,content_type,responsible,weight,thumb="",streamingfile="",rawfile="",lowresfile="",credits=None):
150: """Hinzufuegen der Resource"""
151: splitted=path.split("/")
152: #print "BLU"
153: id=splitted[len(splitted)-1]
154: title=splitted[len(splitted)-1]
155: metalink=self.REQUEST['SERVER_URL']+path+"/index.meta"
156:
157: #link=TOBEDONE"
158: """Hinzufuegen der Ressource"""
159:
160: gifPath=path.replace("/mpiwg/online/","")
161: rawPath=path.replace("/mpiwg/online/permanent/einstein_exhibition/movies/","")
162: lowresPath=path.replace("/mpiwg/online/permanent/einstein_exhibition/movies/","")
163:
164: thumbUrl="http://einst3.mpiwg-berlin.mpg.de/"+gifPath+"/"+thumb
165: link="rtsp://einst1.mpiwg-berlin.mpg.de/"+gifPath+"/"+streamingfile
166: rawFile="file:///Volumes/einstein_movies/"+rawPath+"/"+rawfile
167: lowresFile="rtsp://einst1.mpiwg-berlin.mpg.de/"+gifPath+"/"+lowresfile
168:
169:
170: params=urllib.urlencode({'id':id,'title':title,'link':link,'thumbUrl':thumbUrl,'rawFile':rawFile,'label':label,'description':description,'contentType':content_type,'responsible':responsible,'weight':weight,'credits':credits,'metalink':metalink})
171:
172:
173: try:
174: server=xmlrpclib.Server(collection,allow_none=True)
175: retStr=server.addMovie(id,title,label,description,content_type,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits)
176: except:
177: logger('OSAS_Root (addFileToDollection2)',logging.ERROR,'%s %s'%sys.exc_info()[:2])
178: return "An Error occured adding the resource\n", collection,params
179:
180: #print "added"
181: if not retStr:
182: return "An Error occured adding the resource\n", collection,params
183:
184: #print collection+"/"+id+"/copyIndex_meta2echo_resource"
185:
186: urllib.urlopen(collection+"/"+id+"/copyIndex_meta2echo_resource").read()
187: #print "copy2res"
188: urllib.urlopen(collection+"/"+id+"/generate_label").read()
189: #print "label"
190: urllib.urlopen(collection+"/"+id+"/generate_title").read()
191: #print "title"
192: return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'/browse?path='+path)
193:
194: manage_options = Folder.manage_options+(
195: {'label':'Main Config','action':'add_contextData_config'},
196: )
197:
198:
199: def add_contextData_config(self):
200: """Main configuration"""
201: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeAddContextData.zpt')).__of__(self)
202: return pt()
203:
204:
205: def change_OSAS_add_contextData(self,collection,pwstr=None,RESPONSE=None):
206: """Change"""
207: self.pwstr=pwstr
208: self.collection=collection
209: if RESPONSE is not None:
210: RESPONSE.redirect('manage_main')
211:
212: def manage_AddOSAS_add_contextDataForm(self):
213: """interface for adding the OSAS_add_Metadata"""
214: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','addContextData.zpt')).__of__(self)
215: return pt()
216:
217: def manage_AddOSAS_add_contextData(self,id,collection,RESPONSE=None):
218: """add the OSAS_root"""
219: newObj=OSAS_add_contextData(id,collection)
220: self.Destination()._setObject(id,newObj)
221: if RESPONSE is not None:
222: RESPONSE.redirect('manage_main')
223:
224:
225:
226:
227:
228:
229: class OSAS_handlerObject(Folder):
230: """
231: Grundlegende Klasse fuer Handler zur Zeit noch in Entwicklung
232:
233: """
234: meta_type="OSAS_HandlerObject__neu"
235:
236:
237: def __init__(self,id,title,prefix,objectTypes,ignorePath=""):
238: """inititialisiere die Klasse
239:
240: :Parameters:
241: - `id` : Zope ID des Objektes
242: - `title`: Titel des Objektes
243: - `prefix` : URL bzw. URL Rumpf der Zusammen mit dem Pfad des Objectes die Anzeige URL ergibt
244: - `objectType` : liste von Objekttypen die mittels dieses Handlers angezeigt werden können.
245: - `ignorePath` : Pfad der bei dem übergebenen Pfad element ingnoriert werden soll. Optional.
246: """
247: self.id=id
248: self.title=title
249: self.prefix=prefix
250: self.objectTypes=toList(objectTypes)
251: self.ignorePath=ignorePath
252:
253: manage_options = Folder.manage_options+(
254: {'label':'Main Config','action':'changeHandlerObjectForm'},
255: )
256:
257: def changeHandlerObjectForm(self):
258: """Main configuration"""
259: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeHandlerObjectForm.zpt')).__of__(self)
260: return pt()
261:
262: def changeHandlerObject(self,title,prefix,objectTypes="",ignorePath=None,newTarget="yes",RESPONSE=None):
263: """Change RootFolderName"""
264: self.title=title
265: self.prefix=prefix
266: self.ignorePath=ignorePath
267: self.objectTypes=toList(objectTypes)
268: self.newTarget=newTarget
269:
270: if RESPONSE is not None:
271: RESPONSE.redirect('manage_main')
272:
273:
274: def manage_addHandlerObjectForm(self):
275: """form for adding a handler Object"""
276: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','addHandlerObjectForm.zpt')).__of__(self)
277: return pt()
278:
279: def manage_addHandlerObject(self,id,title,prefix,objectTypes,ignorePath,RESPONSE=None):
280: """add the OSAS_root"""
281: newObj=OSAS_handlerObject(id,title,prefix,objectTypes,ignorePath)
282: self._setObject(id,newObj)
283:
284: if RESPONSE is not None:
285: RESPONSE.redirect('manage_main')
286:
287:
288: class OSAS_root(Folder,Implicit):
289: """Implicit Folder of the Storage Systems"""
290:
291: security=ClassSecurityInfo()
292:
293: def __init__(self,id,rootFolderName,serverUrl,uploadServletUrl=None):
294: """initialize a new instance
295:
296:
297: @param id: Zope ID des Objektes
298: @param rootFolderName : path zum root folder des Storagesystems
299: @param uploadServerletUrl : url des UploadServlets (required fuer batch upload)
300:
301: """
302:
303: self.id = id
304: self.rootFolderName = rootFolderName
305: self.uploadServletUrl=uploadServletUrl
306: self.serverUrl=serverUrl
307: meta_type="OSAS_Root"
308:
309: manage_options = Folder.manage_options+(
310: {'label':'Main Config','action':'changeRootForm'},
311: )
312:
313:
314: OSASObjectTypes=OSAS_helpers.OSASObjectTypes
315:
316: def extendDict(self,dict1,dict2):
317: """add two dicts"""
318: ret=dict1
319: for name in dict2.keys():
320: ret[name]=dict2[name]
321: return ret
322:
323:
324: def generateMovieThumb(self,name):
325: """generate movie"""
326: server=xmlrpclib.Server(self.serverUrl)
327: name="/mpiwg/online/permanent/einstein_exhibition/movies/"+name
328:
329:
330: ret=server.generateMovieThumb(name,os.path.splitext(name)[0]+".gif")
331: return ret
332:
333: security.declareProtected("View management screens","getOSASObjectTypes")
334: def getOSASObjectTypes(self):
335: """return list of objecttypes"""
336: return OSASObjectTypes
337:
338: def setProxy(self,name,value):
339: """set proxy"""
340: self.REQUEST.SESSION[name]=value
341: return True
342:
343: def listToSingle(self,path):
344: """list to single"""
345: if type(path)==ListType:
346: return path[0]
347: else:
348: return path
349:
350: def splitPath(self,path):
351: """split path"""
352: if type(path)==ListType:
353: path=path[0]
354: return os.path.split(path)
355:
356: def changeRootForm(self):
357: """Main configuration"""
358: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeRootForm.zpt')).__of__(self)
359:
360: return pt()
361:
362: def changeRoot(self,rootFolderName,uploadServletUrl,serverUrl,RESPONSE=None):
363: """Change RootFolderName"""
364: self.rootFolderName=rootFolderName
365: self.serverUrl=serverUrl
366: self.uploadServletUrl=uploadServletUrl
367:
368: if RESPONSE is not None:
369: RESPONSE.redirect('manage_main')
370:
371: localDate=localDate
372:
373: def getUploadServletUrl(self):
374: """gibt url des servlets zurueck"""
375: return self.uploadServletUrl
376:
377:
378: def validateIndexMeta(self,data):
379: """TO BE DONE testet ob data ein gueltiges index.meta file ist, zur Zeit wird dom erzeugt ohne validierung.
380: @param data: zu testendes XML file als string
381: @return: zeiger auf dom falls ok, None andernfalls (z.Z: immmer dom falls parse possible)
382: """
383: try:
384: return xml.dom.minidom.parseString(xmlneu)
385: except:
386: return None
387:
388: security.declareProtected('View management screens','uploadExternalXMLString','uploadExternalXMLUrl','uploadExternalXML')
389:
390: def uploadExternalXMLString(self,index_meta_url,xml_string):
391: """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
392:
393: @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server.
394: @param xml_string: string mit index_meta ersetzt obiges index.meta
395: @return: 'error' als String bei Fehler 'ok' bei ok.
396: """
397:
398: return self.uploadExternalXML(index_meta_url,xml_string)
399:
400:
401: def uploadExternalXMLUrl(self,index_meta_url,xml_url):
402: """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
403:
404: @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server.
405: @param xml_url: externe url auf ein index_meta ersetzt obiges index.meta
406: @return: 'error' als String bei Fehler 'ok' bei ok.
407: """
408:
409: return self.uploadExternalXML(index_meta_url,xml_url)
410:
411:
412: def uploadExternalXML(self,index_meta_url,xml_url=None,xml_string=None):
413: """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
414:
415: @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server.
416: @param xml_url: (optional, default=None) externe url auf ein index_meta ersetzt obiges index.meta
417: @param xml_string: (optional, default=None) string mit index_meta ersetzt obiges index.meta
418: @return: 'error' als String bei Fehler 'ok' bei ok.
419: """
420:
421: if xml_url:
422: xmlneu=urllib.urlopen(xml_url).read()
423: else:
424: xmlneu=xml_string
425:
426: dom=self.validateIndexMeta(xmlneu)
427: if not dom:
428: logger('OSAS_Root (downloadExternalXML)',logging.ERROR,'cannot parse: %s', xml_url)
429: return "error"
430:
431:
432: path=self.rootFolderName+urlparse(index_meta_url)[2]
433:
434: fh=open(path,'w')
435:
436: fh.write(xmlneu)
437: fh.close()
438: return "ok"
439:
440: security.declareProtected('View','getIndexMetaFile')
441:
442:
443: def getIndexMetaFile(self,index_meta):
444: """gibt index metafile aus
445: @param index_meta: index_meta ist eine URI entweder url des index_meta oder file mit file://
446: """
447: filearray=[]
448: urlparsed=urlparse(index_meta)[1:]
449:
450: for x in urlparsed:
451:
452: if not (x==''):
453: filearray.append(x)
454:
455: path=os.sep.join(filearray)
456:
457: realPath=os.path.normpath(os.path.join(self.rootFolderName,path))
458:
459: if realPath.find(self.rootFolderName) <0: #versuch auf Pfad unterhalb des Rootfolder zuzugreifen
460: return {}
461:
462:
463: if not os.path.isfile(realPath):
464: return None,"(ERROR) path %s does not exist."%path
465:
466:
467: fh=file(realPath,'r')
468: str=fh.read()
469: fh.close()
470: return str
471:
472:
473: Globals.InitializeClass(OSAS_root)
474:
475: def manage_addOSAS_rootForm(self):
476: """interface for adding the OSAS_root"""
477: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addOSAS_rootForm.zpt')).__of__(self)
478: return pt()
479:
480: def manage_addOSAS_root(self,id,RootFolderName,uploadServletUrl,serverUrl,RESPONSE=None):
481: """add the OSAS_root"""
482: newObj=OSAS_root(id,RootFolderName,serverUrl,uploadServletUrl)
483: self._setObject(id,newObj)
484: if RESPONSE is not None:
485: RESPONSE.redirect('manage_main')
486:
487:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to OSAS_root.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / OSA_system2