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