1: """CDLI extensions of the filearchive"""
2: from Products.versionedFile.versionedFile import *
3: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
4: from tempfile import mkstemp,mkdtemp
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: meta_type="basketObject"
116: def __init__(self):
117: """init basket object"""
118: self.contents=[]
119:
120: def numberOfItems(self):
121: """return anzahl der elemente im basket"""
122: return len(self.contents)
123:
124: def addObjects(self,ids):
125: """addObjects"""
126:
127: for id in ids:
128: founds=self.CDLICatalog.search({'path':id})
129: for found in founds:
130: if found.getObject() not in self.contents:
131: tm=self.contents[0:]
132: tm.append(found.getObject())
133: self.contents=tm[0:]
134:
135: return True
136:
137: def index_html(self):
138: """view the basket"""
139: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
140: return pt()
141:
142: def deleteObjects(self,ids,RESPONSE=None):
143: """delete objects"""
144: list = self.contents[0:]
145: for content in list:
146:
147: if content.getId() in ids:
148: self.contents.remove(content)
149:
150:
151: if RESPONSE:
152: RESPONSE.redirect(self.absolute_url())
153:
154:
155: def unlockTest(self):
156: """unlock all files of the testuser for debuggin"""
157: for object in self.contents:
158:
159: if str(object.lockedBy)=="test":
160: object.lockedBy=""
161:
162: def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
163: """download all selected files in one file"""
164:
165: ret=""
166: lockedObjects={}
167:
168:
169: if lock:
170:
171: if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
172:
173: return "please login first"
174:
175: #check if a locked object exist in the basket.
176: lockedObjects={}
177: for object in self.contents:
178:
179: if not object.lockedBy=="":
180: lockedObjects[object.title]=repr(object.lockedBy)
181:
182:
183: keys=lockedObjects.keys()
184:
185:
186: if len(keys)>0 and (not procedure):
187: self.REQUEST.SESSION['lockedObjects']=lockedObjects
188: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
189: return pt()
190:
191: elif not procedure: #keine fails gesperrt dann alle donwloaden
192: procedure="downloadAll"
193:
194: print procedure
195: for object in self.contents:
196:
197: if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
198: ret+=object.getLastVersion().data
199:
200: if lock and object.lockedBy=='':
201: object.lockedBy=self.REQUEST['AUTHENTICATED_USER']
202:
203:
204: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())
205: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
206: length=len(ret)
207: self.REQUEST.RESPONSE.setHeader("Content-Length",length)
208: self.REQUEST.RESPONSE.write(ret)
209:
210:
211: def manage_addBasketObjectForm(self):
212: """add form"""
213: pass
214:
215: def manage_addBasketObject(self,id,title='',RESPONSE=None):
216: """add"""
217:
218: ob=BasketObject()
219:
220: ob.id=str(id)
221: ob.title=title
222: self._setObject(id, ob)
223: ob=self._getOb(id)
224:
225: if RESPONSE is not None:
226: RESPONSE.redirect('manage_main')
227:
228:
229: class CDLIFile(versionedFile,CatalogAware):
230: """CDLI file"""
231:
232: meta_type="CDLI file"
233: default_catalog='CDLICatalog'
234:
235:
236:
237: def manage_addCDLIFileForm(self):
238: """interface for adding the OSAS_root"""
239: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
240: return pt()
241:
242: def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
243: """add the OSAS_root"""
244: newObj=CDLIFile(id,title,lockedBy,author)
245: self._setObject(id,newObj)
246:
247: if RESPONSE is not None:
248: RESPONSE.redirect('manage_main')
249:
250:
251: class CDLIFileObject(versionedFileObject):
252: """CDLI file object"""
253:
254: meta_type="CDLI File Object"
255:
256: def view(self):
257: """view file"""
258: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
259: return pt()
260:
261: manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
262:
263: def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
264: REQUEST=None):
265: """Add a new File object.
266:
267: Creates a new File object 'id' with the contents of 'file'"""
268:
269: id=str(id)
270: title=str(title)
271: content_type=str(content_type)
272: precondition=str(precondition)
273:
274: id, title = cookId(id, title, file)
275:
276: self=self.this()
277:
278: # First, we create the file without data:
279: self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))
280: self._getOb(id).versionComment=str(vC)
281: self._getOb(id).time=time.localtime()
282:
283: setattr(self._getOb(id),'author',author)
284:
285: # Now we "upload" the data. By doing this in two steps, we
286: # can use a database trick to make the upload more efficient.
287: if file:
288: self._getOb(id).manage_upload(file)
289: if content_type:
290: self._getOb(id).content_type=content_type
291:
292: if REQUEST is not None:
293: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
294:
295:
296: def splitatf(fh,dir=None):
297: """split it"""
298:
299: nf=None
300: for line in fh.readlines():
301:
302: if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
303: if nf:
304: nf.close() #close last file
305:
306:
307: filename=line[1:].split("=")[0].rstrip()+".atf"
308: if dir:
309: filename=os.path.join(dir,filename)
310: nf=file(filename,"w")
311:
312: nf.write(line)
313:
314: nf.close()
315: fh.close()
316:
317: class CDLIFileFolder(versionedFileFolder):
318: """CDLI folder"""
319:
320: meta_type="CDLI Folder"
321: filesMetaType=['CDLI file']
322: folderMetaType=['CDLI Folder']
323: default_catalog='CDLICatalog'
324:
325: def uploadATF(self,upload,comment="",RESPONSE=None):
326: """upload an atf file"""
327: #TODO: finish uploadATF
328: dir=mkdtemp()
329: changed=[]
330: errors=[]
331: splitatf(upload,dir)
332:
333: for fn in os.listdir(dir):
334: founds=self.CDLICatalog.search({'path':fn})
335:
336: for found in founds:
337: obj=found.getObject()
338:
339: if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
340: errors.append(obj)
341: else:
342: data=file(os.path.join(dir,fn)).read()
343: diffs=obj.diff(data)
344: if diffs[0]>0:
345: changed.append((obj,diffs))
346: #hochladen
347:
348:
349: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
350: return pt(changed=changed,errors=errors,dir=dir)
351:
352:
353:
354: def findObjectsFromList(self,upload,RESPONSE):
355: """findObjectsFromList (, TAB oder LINE separated)"""
356: txt=upload.read()
357: txt=txt.replace(",","\n")
358: txt=txt.replace("\t","\n")
359: idsTmp=txt.split("\n")
360: ids=[]
361: for id in idsTmp: # make sure that no empty lines
362: idTmp=id.lstrip().rstrip()
363: if len(idTmp)>0:
364: ids.append(idTmp)
365: #self.REQUEST.SESSION['ids']=" OR ".join(ids)
366:
367: RESPONSE.redirect("filelist.html?path=%s"%" OR ".join(ids))
368:
369: def createAllFilesAsSingleFile(self,RESPONSE=None):
370: """download all files"""
371:
372: def sortF(x,y):
373: return cmp(x[0],y[0])
374:
375: catalog=getattr(self,self.default_catalog)
376: #tf,tfilename=mkstemp()
377:
378:
379: list=[(x.getId,x) for x in catalog()]
380: list.sort(sortF)
381:
382: RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
383: RESPONSE.setHeader("Content-Type","application/octet-stream")
384:
385: for l in list:
386: obj=l[1].getObject()
387:
388: if obj.meta_type=="CDLI file":
389:
390: #os.write(tf,obj.getLastVersion().data)
391: if RESPONSE:
392: RESPONSE.write(obj.getLastVersion().data)
393: #os.close(tf)
394: #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
395: return True
396:
397: def downloadFile(self,fn):
398: """download fn - not used yet"""
399: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
400: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
401: self.REQUEST.RESPONSE.write(file(fn).read())
402:
403:
404:
405: def hasParent(self):
406: """returns true falls subfolder"""
407:
408: if self.aq_parent.meta_type in self.folderMetaType:
409: return True
410: else:
411: return False
412:
413: def getFolders(self):
414: """get all subfolders"""
415: ret=[]
416: folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
417: for folder in folders:
418: ret.append((folder[1],
419: len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
420: len(self.ZopeFind(folder[1],obj_metatypes=self.filesMetaType))
421: ))
422: return ret
423:
424:
425: def getFolders_OLD(self):
426: """get all subfolders"""
427: ret=[]
428: folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
429: for folder in folders:
430: ret.append((folder[1],
431: len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
432: len(getattr(self,self.default_catalog)({'path':folder[0]}))
433: ))
434: return ret
435:
436: def index_html(self):
437: """main"""
438: ext=self.ZopeFind(self,obj_ids=["index.html"])
439: if ext:
440: return ext[0][1]()
441:
442: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
443: return pt()
444:
445: def importFiles(self,comment="",author="" ):
446: """import files"""
447: folderName="/Users/dwinter/Documents/workspace/cdli/atf"
448:
449: files=os.listdir(folderName)
450: for f in files:
451: folder=f[0:3]
452: f2=f[0:5]
453: obj=self.ZopeFind(self,obj_ids=[folder])
454:
455: if not obj:
456: manage_addCDLIFileFolder(self,folder,folder)
457: fobj=getattr(self,folder)
458:
459: else:
460: fobj=obj[0][1]
461:
462: obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
463:
464: if not obj2:
465: manage_addCDLIFileFolder(fobj,f2,f2)
466: fobj2=getattr(fobj,f2)
467:
468: else:
469: fobj2=obj2[0][1]
470:
471: print f
472: file2=file(os.path.join(folderName,f))
473: id=f
474: manage_addCDLIFile(fobj2,f,'','')
475: id=f
476: ob=fobj2._getOb(f)
477: ob.title=id
478:
479: manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')
480:
481: return "ok"
482: manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
483:
484:
485: def manage_addCDLIFileFolder(self, id, title='',
486: createPublic=0,
487: createUserF=0,
488: REQUEST=None):
489: """Add a new Folder object with id *id*.
490:
491: If the 'createPublic' and 'createUserF' parameters are set to any true
492: value, an 'index_html' and a 'UserFolder' objects are created respectively
493: in the new folder.
494: """
495: ob=CDLIFileFolder()
496: ob.id=str(id)
497: ob.title=title
498: self._setObject(id, ob)
499: ob=self._getOb(id)
500:
501: checkPermission=getSecurityManager().checkPermission
502:
503: if createUserF:
504: if not checkPermission('Add User Folders', ob):
505: raise Unauthorized, (
506: 'You are not authorized to add User Folders.'
507: )
508: ob.manage_addUserFolder()
509:
510:
511: if REQUEST is not None:
512: return self.manage_main(self, REQUEST, update_menu=1)
513:
514:
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