1: """CDLI extensions of the filearchive"""
2: from Products.versionedFile.versionedFile import *
3: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
4: from tempfile import mkstemp
5: import os.path
6: import os
7: from types import *
8:
9: class Basket(Folder):
10: """shopping basket"""
11:
12: meta_type="Basket"
13: _v_stack={}
14:
15: def storeAllLink(self,results):
16: """erzeuge link zum speicher aller results"""
17: nr=self.REQUEST['_ZopeId']
18:
19: if results:
20: self._v_stack[nr]=[x.getObject().getId() for x in results]
21:
22: return self.absolute_url()+"/storeAll?id="+nr
23:
24: def storeAll(self,id):
25: """store all"""
26: try:
27: results=self._v_stack[id]
28: except:
29: #TODO: write expired page
30: return "expired"
31:
32: return self.storeInBasketForm(results)
33:
34: def storeInBasketForm(self,ids):
35: """ store an object form"""
36:
37: if type(ids) is not ListType:
38: ids=[ids]
39: self.REQUEST.SESSION['ids']=ids[0:]
40:
41: self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']
42:
43: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)
44: return pt()
45:
46: def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):
47: """store it"""
48:
49: if not ids:
50: ids=REQUEST.SESSION['ids']
51:
52: self.REQUEST.SESSION['basketUser']=username
53:
54: baskets=self.ZopeFind(self,obj_ids=[username])
55: if len(baskets)>0:
56: basket=baskets[0][1]
57: else:
58: manage_addBasketObject(self,username)
59: basket=self._getOb(username)
60:
61:
62: basket.addObjects(ids)
63: back=self.REQUEST.SESSION.get('BACKLINK', None)
64:
65: if RESPONSE:
66: RESPONSE.redirect(back)
67:
68:
69:
70: def showBasket(self,user=None,set=None,RESPONSE=None):
71: """show the basket"""
72:
73: if user:
74: self.REQUEST.SESSION['basketUser']=user
75:
76: if not user and not set:
77: user=self.REQUEST.SESSION.get('basketUser',None)
78:
79: if not user:
80: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','authorizeBasketUser.zpt')).__of__(self)
81: return pt()
82: else:
83: baskets=self.ZopeFind(self,obj_ids=[user])
84:
85:
86: if len(baskets)>0:
87: RESPONSE.redirect(baskets[0][1].absolute_url())
88: return True
89: else:
90: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)
91: return pt()
92:
93:
94: def manage_addBasketForm(self):
95: """add the basket form"""
96: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
97: return pt()
98:
99: def manage_addBasket(self,id,title,RESPONSE=None):
100: """add the basket"""
101: ob=Basket()
102:
103: ob.id=str(id)
104: ob.title=title
105: self._setObject(id, ob)
106: ob=self._getOb(id)
107:
108: if RESPONSE is not None:
109: RESPONSE.redirect('manage_main')
110:
111:
112: class BasketObject(Folder):
113: """Basket Object"""
114:
115: def __init__(self):
116: """init basket object"""
117: self.contents=[]
118:
119: def numberOfItems(self):
120: """return anzahl der elemente im basket"""
121: return len(self.contents)
122:
123: def addObjects(self,ids):
124: """addObjects"""
125:
126: for id in ids:
127: founds=self.CDLICatalog.search({'path':id})
128: for found in founds:
129: if found.getObject() not in self.contents:
130: tm=self.contents[0:]
131: tm.append(found.getObject())
132: self.contents=tm[0:]
133:
134: return True
135:
136: def index_html(self):
137: """view the basket"""
138: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
139: return pt()
140:
141: def deleteObjects(self,ids,RESPONSE=None):
142: """delete objects"""
143: list = self.contents[0:]
144: for content in list:
145:
146: if content.getId() in ids:
147: self.contents.remove(content)
148:
149:
150: if RESPONSE:
151: RESPONSE.redirect(self.absolute_url())
152:
153:
154:
155: def downloadObjectsAsOneFile(self,REQUEST):
156: """download all selected files in one file"""
157: ret=""
158: for object in self.contents:
159:
160: ret+=object.getLastVersion().data
161:
162: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())
163: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
164: len=len(ret)
165: self.REQUEST.RESPONSE.setHeader("Content-Length",len)
166: self.REQUEST.RESPONSE.write(ret)
167: def manage_addBasketObjectForm(self):
168: """add form"""
169: pass
170:
171: def manage_addBasketObject(self,id,title='',RESPONSE=None):
172: """add"""
173:
174: ob=BasketObject()
175:
176: ob.id=str(id)
177: ob.title=title
178: self._setObject(id, ob)
179: ob=self._getOb(id)
180:
181: if RESPONSE is not None:
182: RESPONSE.redirect('manage_main')
183:
184:
185: class CDLIFile(versionedFile,CatalogAware):
186: """CDLI file"""
187:
188: meta_type="CDLI file"
189: default_catalog='CDLICatalog'
190:
191:
192:
193: def manage_addCDLIFileForm(self):
194: """interface for adding the OSAS_root"""
195: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
196: return pt()
197:
198: def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
199: """add the OSAS_root"""
200: newObj=CDLIFile(id,title,lockedBy,author)
201: self._setObject(id,newObj)
202:
203: if RESPONSE is not None:
204: RESPONSE.redirect('manage_main')
205:
206:
207: class CDLIFileObject(versionedFileObject):
208: """CDLI file object"""
209:
210: meta_type="CDLI File Object"
211:
212: def view(self):
213: """view file"""
214: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
215: return pt()
216:
217: manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
218:
219: def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
220: REQUEST=None):
221: """Add a new File object.
222:
223: Creates a new File object 'id' with the contents of 'file'"""
224:
225: id=str(id)
226: title=str(title)
227: content_type=str(content_type)
228: precondition=str(precondition)
229:
230: id, title = cookId(id, title, file)
231:
232: self=self.this()
233:
234: # First, we create the file without data:
235: self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))
236: self._getOb(id).versionComment=str(vC)
237: self._getOb(id).time=time.localtime()
238:
239: setattr(self._getOb(id),'author',author)
240:
241: # Now we "upload" the data. By doing this in two steps, we
242: # can use a database trick to make the upload more efficient.
243: if file:
244: self._getOb(id).manage_upload(file)
245: if content_type:
246: self._getOb(id).content_type=content_type
247:
248: if REQUEST is not None:
249: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
250:
251:
252: class CDLIFileFolder(versionedFileFolder):
253: """CDLI folder"""
254:
255: meta_type="CDLI Folder"
256: filesMetaType=['CDLI file']
257: folderMetaType=['CDLI Folder']
258: default_catalog='CDLICatalog'
259:
260: def uploadATF(self,upload,RESPONSE):
261: """upload an atf file"""
262: mks
263:
264:
265: def findObjectsFromList(self,upload,RESPONSE):
266: """findObjectsFromList (, TAB oder LINE separated)"""
267: txt=upload.read()
268: txt=txt.replace(",","\n")
269: txt=txt.replace("\t","\n")
270: idsTmp=txt.split("\n")
271: ids=[]
272: for id in idsTmp: # make sure that no empty lines
273: idTmp=id.lstrip().rstrip()
274: if len(idTmp)>0:
275: ids.append(idTmp)
276: #self.REQUEST.SESSION['ids']=" OR ".join(ids)
277:
278: RESPONSE.redirect("filelist.html?path=%s"%" OR ".join(ids))
279:
280: def createAllFilesAsSingleFile(self,RESPONSE=None):
281: """download all files"""
282:
283: def sortF(x,y):
284: return cmp(x[0],y[0])
285:
286: catalog=getattr(self,self.default_catalog)
287: #tf,tfilename=mkstemp()
288:
289:
290: list=[(x.getId,x) for x in catalog()]
291: list.sort(sortF)
292:
293: RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
294: RESPONSE.setHeader("Content-Type","application/octet-stream")
295:
296: for l in list:
297: obj=l[1].getObject()
298:
299: if obj.meta_type=="CDLI file":
300:
301: #os.write(tf,obj.getLastVersion().data)
302: if RESPONSE:
303: RESPONSE.write(obj.getLastVersion().data)
304: #os.close(tf)
305: #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
306: return True
307:
308: def downloadFile(self,fn):
309: """download fn - not used yet"""
310: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
311: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
312: self.REQUEST.RESPONSE.write(file(fn).read())
313:
314:
315:
316: def hasParent(self):
317: """returns true falls subfolder"""
318:
319: if self.aq_parent.meta_type in self.folderMetaType:
320: return True
321: else:
322: return False
323:
324: def getFolders(self):
325: """get all subfolders"""
326: ret=[]
327: folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
328: for folder in folders:
329: ret.append((folder[1],
330: len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
331: len(self.ZopeFind(folder[1],obj_metatypes=self.filesMetaType))
332: ))
333: return ret
334:
335:
336: def getFolders_OLD(self):
337: """get all subfolders"""
338: ret=[]
339: folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
340: for folder in folders:
341: ret.append((folder[1],
342: len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
343: len(getattr(self,self.default_catalog)({'path':folder[0]}))
344: ))
345: return ret
346:
347: def index_html(self):
348: """main"""
349: ext=self.ZopeFind(self,obj_ids=["index.html"])
350: if ext:
351: return ext[0][1]()
352:
353: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
354: return pt()
355:
356: def importFiles(self,comment="",author="" ):
357: """import files"""
358: folderName="/Users/dwinter/Documents/workspace/cdli/atf"
359:
360: files=os.listdir(folderName)
361: for f in files:
362: folder=f[0:3]
363: f2=f[0:5]
364: obj=self.ZopeFind(self,obj_ids=[folder])
365:
366: if not obj:
367: manage_addCDLIFileFolder(self,folder,folder)
368: fobj=getattr(self,folder)
369:
370: else:
371: fobj=obj[0][1]
372:
373: obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
374:
375: if not obj2:
376: manage_addCDLIFileFolder(fobj,f2,f2)
377: fobj2=getattr(fobj,f2)
378:
379: else:
380: fobj2=obj2[0][1]
381:
382: print f
383: file2=file(os.path.join(folderName,f))
384: id=f
385: manage_addCDLIFile(fobj2,f,'','')
386: id=f
387: ob=fobj2._getOb(f)
388: ob.title=id
389:
390: manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')
391:
392: return "ok"
393: manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
394:
395:
396: def manage_addCDLIFileFolder(self, id, title='',
397: createPublic=0,
398: createUserF=0,
399: REQUEST=None):
400: """Add a new Folder object with id *id*.
401:
402: If the 'createPublic' and 'createUserF' parameters are set to any true
403: value, an 'index_html' and a 'UserFolder' objects are created respectively
404: in the new folder.
405: """
406: ob=CDLIFileFolder()
407: ob.id=str(id)
408: ob.title=title
409: self._setObject(id, ob)
410: ob=self._getOb(id)
411:
412: checkPermission=getSecurityManager().checkPermission
413:
414: if createUserF:
415: if not checkPermission('Add User Folders', ob):
416: raise Unauthorized, (
417: 'You are not authorized to add User Folders.'
418: )
419: ob.manage_addUserFolder()
420:
421:
422: if REQUEST is not None:
423: return self.manage_main(self, REQUEST, update_menu=1)
424:
425:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to cdli_files.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / cdli