1: from OFS.Folder import Folder
2: from OFS.Image import File
3: from OFS.Image import cookId
4: from Globals import DTMLFile, InitializeClass,package_home
5: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
6: from AccessControl import getSecurityManager
7: from Products.PageTemplates.PageTemplate import PageTemplate
8: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
9: from AccessControl import ClassSecurityInfo
10:
11: from threading import Thread
12: import shutil
13: import tempfile
14: import os.path
15:
16: import time
17: try:
18: from Products.ECHO_content.ECHO_collection import ECHO_basis
19: except:
20: print "ECHO Elements not imported"
21: class ECHO_basis:
22: """leer"""
23: manage_options=()
24:
25:
26: def sortv(x,y):
27: return cmp(x[0],y[0])
28: tdir = "/tmp/testia"
29:
30: class generateDownloadZip:
31: """generateDownloadSet"""
32:
33: def __init__(self,folderObject,url):
34: """init downloadzip"""
35: self.folder=folderObject
36: self.done=None
37: self.response=""
38: self.url=url
39:
40: def __call__(self):
41: """call generate download zip"""
42: storeTempDir=tempfile.tempdir
43: tempfile.tempdir=tdir
44:
45: tmpPath=tempfile.mktemp()
46: tmpZip=tempfile.mktemp()+".gtz"
47: tmpFn=os.path.split(tmpZip)[1]
48:
49: if not os.path.exists(tempfile.tempdir):
50: os.mkdir(tempfile.tempdir)
51:
52: if not os.path.exists(tmpPath):
53: os.mkdir(tmpPath)
54:
55: self.response="<h3>1. step: gettung the files</h3>"
56:
57: for files in self.folder.ZopeFind(self.folder,obj_metatypes=['versionedFile']):
58: lastV=files[1].getLastVersion()
59: self.response+=str("<p>Get File: %s<br>\n"%lastV.title)
60:
61: savePath=os.path.join(tmpPath,lastV.title)
62: fh=file(savePath,"w")
63: fh.write(lastV.data)
64: fh.close()
65:
66: self.response+="<h3>2. step: creating the downloadable file</h3>"
67: self.response+="<p>Create gtar<br>"
68: self.response+="<p>This can take a while....<br>\n"
69:
70: fh=os.popen2("tar zcvf %s %s/*"%(tmpZip,tmpPath),1)[1]
71: self.response+="<br>"
72: for c in fh.read():
73: self.response+=c
74: if c==")":
75: self.response+="<br>\n"
76:
77:
78:
79:
80: shutil.rmtree(tmpPath)
81:
82: self.response+="<p>finished<br>\n"
83:
84: len=os.stat(tmpZip)[6]
85: downloadUrl=self.url+"/downloadSet"
86: self.response+="""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len)
87: self.response+="""<p>The file you receive is a tar (gnutar) compressed file, after unpacking you will find a new folder <emph>tmp</emph> where the files are stored in.</p>"""
88: self.response+="""<p>The file will be stored for a while, you can download it later, the URL is:</p>
89: <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn)
90:
91: self.done=True
92:
93:
94: def getResult(self):
95: """get result"""
96: return self.response
97:
98: def isDone(self):
99: if self.done:
100: return True
101: else:
102: return False
103:
104:
105: class versionedFileFolder(Folder,ECHO_basis):
106: """Folder with versioned files"""
107:
108:
109: meta_type = "versionedFileFolder"
110:
111: security= ClassSecurityInfo()
112: security.declareProtected('AUTHENTICATED_USER','addFileForm')
113:
114: if ECHO_basis:
115: optTMP= Folder.manage_options+ECHO_basis.manage_options
116: else:
117: optTMP= Folder.manage_options
118:
119: manage_options =optTMP+(
120: {'label':'Generate Index.html','action':'generateIndexHTML'},
121: {'label':'Generate history_template.html','action':'generateHistoryHTML'},
122: {'label':'Import Folder','action':'importFolderForm'},
123: {'label':'Export Folder','action':'exportFolder'},
124: )
125:
126: def importFolderForm(self):
127: """form fuer folder import"""
128: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importFolderForm.zpt')).__of__(self)
129: return pt()
130:
131: def importFolder(self,path,comment="",author=None,lockedBy=None,RESPONSE=None):
132: """importiere inhalt eines folders"""
133:
134: for fileName in os.listdir(path):
135: if os.path.isfile(os.path.join(path,fileName)):
136: manage_addVersionedFile(self,fileName,'','')
137: id=fileName
138: ob=self._getOb(fileName)
139: ob.title=id
140: file2=file(os.path.join(path,fileName))
141:
142: obj=ob.manage_addVersionedFileObject(id,comment,author,file2,content_type='')
143:
144: if RESPONSE:
145: RESPONSE.redirect(self.REQUEST['URL1'])
146:
147: zipThreads={}
148: zipThreads2={}
149:
150: def refreshTxt(self):
151: """txt fuer refresh"""
152: tn=self.REQUEST.SESSION['threadName']
153: return """ 2;url=%s?repeat=%s """%(self.absolute_url()+"/exportFolder",tn)
154:
155: def exportFolder(self,repeat=None):
156: """exportiert alle akutellen files des folders"""
157: threadName=repeat
158:
159:
160: if not threadName or threadName=="":
161: threadStart=generateDownloadZip(self,self.absolute_url())
162: thread=Thread(target=threadStart)
163:
164: thread.start()
165:
166:
167: self.zipThreads[thread.getName()[0:]]=threadStart
168: self.zipThreads2[thread.getName()[0:]]=thread
169: self.REQUEST.SESSION['threadName']=thread.getName()[0:]
170: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
171: if wait_template:
172: return wait_template[0][1]()
173: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
174: return pt()
175:
176: else:
177: self.REQUEST.SESSION['threadName']=threadName
178:
179: if (self.zipThreads[threadName].getResult()==None):
180:
181: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
182: if wait_template:
183: return wait_template[0][1]()
184:
185: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
186: return pt()
187: else:
188: if self.zipThreads[threadName].isDone():
189: self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
190: self.zipThreads2[threadName].join()
191: del(self.zipThreads2[threadName])
192: del(self.zipThreads[threadName])
193: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
194: return pt()
195:
196: else:
197: self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
198: self.REQUEST.SESSION['threadName']=threadName
199: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)
200: return pt()
201:
202: def downloadSet(self,fn):
203: """download prepared set"""
204: filename=os.path.join(tdir,fn)
205:
206:
207: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"donloadFileFolder.tgz")
208: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
209: len=os.stat(filename)[6]
210: self.REQUEST.RESPONSE.setHeader("Content-Length",len)
211: images=file(filename).read()
212: self.REQUEST.RESPONSE.write(images)
213: self.REQUEST.RESPONSE.close()
214:
215:
216:
217: def helpDownload(self):
218: """download help"""
219:
220: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','helpDownload')).__of__(self)
221: return pt()
222:
223: def generateIndexHTML(self,RESPONSE=None):
224: """lege standard index.html an"""
225:
226:
227: if not self.ZopeFind(self,obj_ids=['index.html']):
228: zt=ZopePageTemplate('index.html')
229: self._setObject('index.html',zt)
230: default_content_fn = os.path.join(package_home(globals()),
231: 'zpt/versionFileFolderMain.zpt')
232: text = open(default_content_fn).read()
233: zt.pt_edit(text, 'text/html')
234:
235: else:
236: return "already exists!"
237:
238: if RESPONSE is not None:
239: RESPONSE.redirect('manage_main')
240:
241:
242: def generateHistoryHTML(self,RESPONSE=None):
243: """lege standard index.html an"""
244:
245:
246:
247: if not self.ZopeFind(self,obj_ids=['history_template.html']):
248: zt=ZopePageTemplate('history_template.html')
249: self._setObject('history_template.html',zt)
250: default_content_fn = os.path.join(package_home(globals()),
251: 'zpt/versionHistory.zpt')
252: text = open(default_content_fn).read()
253: zt.pt_edit(text, 'text/html')
254:
255: else:
256: return "already exists!"
257:
258: if RESPONSE is not None:
259: RESPONSE.redirect('manage_main')
260:
261:
262:
263:
264: def getVersionedFiles(self,sortField='title'):
265: """get all versioned files"""
266:
267: def sortName(x,y):
268: return cmp(x[1].title.lower(),y[1].title.lower())
269:
270: def sortDate(x,y):
271: return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
272:
273:
274: def sortComment(x,y):
275:
276:
277:
278: try:
279: xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
280: except:
281: xc='ZZZZZZZZZZZZZ'.lower()
282: try:
283: yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
284: except:
285: yc='ZZZZZZZZZZZZZ'.lower()
286:
287:
288: if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
289:
290: try:
291: xc=x[1].getLastVersion().getVComment().lower()
292: except:
293: xc='ZZZZZZZZZZZZZ'.lower()
294:
295: if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
296: try:
297: yc=y[1].getLastVersion().getVComment().lower()
298: except:
299: yc='ZZZZZZZZZZZZZ'.lower()
300:
301:
302: return cmp(xc,yc)
303:
304: def sortAuthor(x,y):
305:
306: return cmp(x[1].getLastVersion().lastEditor().lower(),y[1].getLastVersion().lastEditor().lower())
307:
308: versionedFiles=self.ZopeFind(self,obj_metatypes=['versionedFile'])
309:
310: if sortField=='title':
311: versionedFiles.sort(sortName)
312: elif sortField=='date':
313: versionedFiles.sort(sortDate)
314: elif sortField=='author':
315: versionedFiles.sort(sortAuthor)
316: elif sortField=='comment':
317: versionedFiles.sort(sortComment)
318:
319: return versionedFiles
320:
321:
322: def header_html(self):
323: """zusätzlicher header"""
324: ext=self.ZopeFind(self,obj_ids=["header.html"])
325: if ext:
326: return ext[0][1]()
327: else:
328: return ""
329:
330: def index_html(self):
331: """main"""
332: ext=self.ZopeFind(self,obj_ids=["index.html"])
333: if ext:
334: return ext[0][1]()
335:
336: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionFileFolderMain')).__of__(self)
337: return pt()
338:
339:
340: def addFileForm(self):
341: """add a file"""
342: ext=self.ZopeFind(self,obj_ids=["addFileForm.dtml"])
343: if ext:
344: return ext[0][1]('',globals(),version='1',AUTHENTICATED_USER=self.REQUEST.AUTHENTICATED_USER)
345:
346: out=DTMLFile('dtml/newFileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version='1').__of__(self)
347: return out()
348:
349:
350: def addFile(self,vC,file,author,newName='',content_type='',RESPONSE=None):
351: """ add a new file"""
352: if newName=='':
353: filename=file.filename
354: id=filename[max(filename.rfind('/'),
355: filename.rfind('\\'),
356: filename.rfind(':'),
357: )+1:]
358:
359: else:
360: id=newName
361:
362: vC=self.REQUEST.form['vC']
363: manage_addVersionedFile(self,id,'','')
364: #if (getattr(self,'commentNonEmpty',0)==1) and vC.strip()=="":
365:
366:
367: ob=self._getOb(id)
368: ob.title=id
369: file2=file
370:
371: obj=ob.manage_addVersionedFileObject(id,vC,author,file2,content_type=content_type)
372: self.REQUEST.SESSION['objID']=ob.getId()
373: self.REQUEST.SESSION['objID_parent']=None
374:
375: if obj.getSize()==0:
376: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
377: return pt()
378:
379: RESPONSE.redirect(self.REQUEST['URL1'])
380:
381:
382: def deleteEmptyObject(self,submit,RESPONSE=None):
383: """deleteemptyobject"""
384: if submit=="delete it":
385: if self.REQUEST.SESSION['objID_parent']:
386: obj=getattr(self,self.REQUEST.SESSION['objID_parent'])
387:
388: else:
389: obj=self
390: obj.manage_delObjects([self.REQUEST.SESSION['objID']])
391:
392: RESPONSE.redirect(self.REQUEST['URL1'])
393:
394:
395: manage_addVersionedFileFolderForm=DTMLFile('dtml/folderAdd', globals())
396:
397:
398: def manage_addVersionedFileFolder(self, id, title='',
399: createPublic=0,
400: createUserF=0,
401: REQUEST=None):
402: """Add a new Folder object with id *id*.
403:
404: If the 'createPublic' and 'createUserF' parameters are set to any true
405: value, an 'index_html' and a 'UserFolder' objects are created respectively
406: in the new folder.
407: """
408: ob=versionedFileFolder()
409: ob.id=str(id)
410: ob.title=title
411: self._setObject(id, ob)
412: ob=self._getOb(id)
413:
414: checkPermission=getSecurityManager().checkPermission
415:
416: if createUserF:
417: if not checkPermission('Add User Folders', ob):
418: raise Unauthorized, (
419: 'You are not authorized to add User Folders.'
420: )
421: ob.manage_addUserFolder()
422:
423:
424: if REQUEST is not None:
425: return self.manage_main(self, REQUEST, update_menu=1)
426:
427:
428:
429: class versionedFileObject(File):
430: """File Object im Folder"""
431:
432: meta_type = "versionedFileObject"
433:
434: manage_editForm =DTMLFile('dtml/fileEdit',globals(),
435: Kind='File',kind='file')
436: manage_editForm._setName('manage_editForm')
437:
438: def getVComment(self):
439: """get the comment of this file"""
440: if not hasattr(self,'vComment') or (not self.vComment) or (self.vComment.lstrip()==""):
441: return "Add comment"
442:
443: else:
444: return self.vComment
445:
446: def manageVCommentForm(self):
447: """add a comment"""
448:
449: self.REQUEST.SESSION['refer']=self.REQUEST['HTTP_REFERER']
450:
451:
452:
453: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addVComment')).__of__(self)
454: return pt()
455:
456: def manageVComment(self,text,comment_author,submit,REQUEST=None):
457: """manage comments"""
458: if submit =='change':
459: if text=='':
460: self.vComment=None
461: else:
462: self.vComment=text
463: self.vComment_author=comment_author
464:
465: self.vComment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
466:
467: if self.REQUEST.SESSION.has_key('refer'):
468:
469: return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
470: return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url()+"/history")
471:
472:
473: def getTime(self):
474: """getTime"""
475: #return self.bobobase_modification_time().ISO()
476: if hasattr(self,'time'):
477: return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
478: elif hasattr(self,'timefixed'):
479: return self.timefixed
480: else:
481: setattr(self,'timefixed',self.bobobase_modification_time().ISO())
482: return self.bobobase_modification_time().ISO()
483:
484:
485:
486:
487:
488: def download(self):
489: """download and lock"""
490:
491: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getId())
492: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
493:
494: self.content_type="application/octet-stream"
495: #self.REQUEST.RESPONSE.redirect(self.absolute_url())
496: self.REQUEST.RESPONSE.write(self.index_html())
497: #self.REQUEST.RESPONSE.write("bl")
498: self.REQUEST.close()
499:
500: def downloadLocked(self):
501: """download and lock"""
502:
503:
504: if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
505: return "please login first"
506: if not self.aq_parent.lockedBy=="":
507: return "cannot be locked because is already locked by %s"%self.lockedBy
508: self.aq_parent.lockedBy=self.REQUEST['AUTHENTICATED_USER']
509:
510: self.content_type="application/octet-stream"
511: self.REQUEST.RESPONSE.redirect(self.absolute_url())
512:
513: def setVersionNumber(self,versionNumber):
514: """set version"""
515: self.versionNumber=versionNumber
516:
517: def getVersionNumber(self):
518: """get version"""
519: return self.versionNumber
520:
521:
522:
523: def lastEditor(self):
524: """last Editor"""
525: if hasattr(self,'author'):
526: ret=self.author.replace("-","\n")
527: ret=ret.replace("\r","\n")
528: return ret
529:
530: else:
531: jar=self._p_jar
532: oid=self._p_oid
533:
534: if jar is None or oid is None: return None
535:
536: return jar.db().history(oid)[0]['user_name']
537:
538:
539:
540:
541: manage_addVersionedFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject', version='1')
542:
543: def manage_addVersionedFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
544: REQUEST=None):
545: """Add a new File object.
546:
547: Creates a new File object 'id' with the contents of 'file'"""
548:
549: id=str(id)
550: title=str(title)
551: content_type=str(content_type)
552: precondition=str(precondition)
553:
554: id, title = cookId(id, title, file)
555:
556: self=self.this()
557:
558: # First, we create the file without data:
559: self._setObject(id, versionedFileObject(id,title,'',content_type, precondition))
560: self._getOb(id).versionComment=str(vC)
561: self._getOb(id).time=time.localtime()
562:
563: setattr(self._getOb(id),'author',author)
564:
565: # Now we "upload" the data. By doing this in two steps, we
566: # can use a database trick to make the upload more efficient.
567: if file:
568: self._getOb(id).manage_upload(file)
569: if content_type:
570: self._getOb(id).content_type=content_type
571:
572: if REQUEST is not None:
573: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
574:
575:
576:
577:
578: class versionedFile(Folder):
579: """Versioniertes File"""
580:
581: def __init__(self, id, title, lockedBy,author):
582: """init"""
583: self.id=id
584: self.title=title
585: self.lockedBy=lockedBy
586: self.author=author
587:
588: def getComment(self):
589: """get the comment of this file"""
590: if not hasattr(self,'comment') or (not self.comment) or (self.comment.lstrip()==""):
591: return "Add comment"
592:
593: else:
594: return self.comment
595:
596:
597: meta_type="versionedFile"
598:
599: def manageCommentForm(self):
600: """add a comment"""
601: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addComment')).__of__(self)
602: return pt()
603:
604: def manageComment(self,text,comment_author,submit,REQUEST=None):
605: """manage comments"""
606: if submit =='change':
607: if text=='':
608: self.comment=None
609: else:
610: self.comment=text
611: self.comment_author=comment_author
612:
613: self.comment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
614:
615: return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
616:
617: def getLastVersion(self):
618: """Last Version"""
619: tmp=0
620: lastVersion=None
621:
622: for version in self.ZopeFind(self):
623:
624: if hasattr(version[1],'versionNumber'):
625:
626: if int(version[1].versionNumber) > tmp:
627: tmp=int(version[1].versionNumber,)
628: lastVersion=version[1]
629: return lastVersion
630:
631: def index_html(self):
632: """main view"""
633: lastVersion=self.getLastVersion()
634: #return "File:"+self.title+" Version:%i"%lastVersion.versionNumber," modified:",lastVersion.bobobase_modification_time()," size:",lastVersion.getSize(),"modified by:",lastVersion.lastEditor()
635: return "File: %s Version:%i modified:%s size:%s modified by:%s"%(self.title,lastVersion.versionNumber,lastVersion.getTime(),lastVersion.getSize(),lastVersion.lastEditor())
636:
637: def getVersion(self):
638: tmp=0
639: for version in self.ZopeFind(self):
640:
641: if hasattr(version[1],'versionNumber'):
642:
643: if int(version[1].versionNumber) > tmp:
644: tmp=int(version[1].versionNumber,)
645: return tmp+1
646:
647: security= ClassSecurityInfo()
648: security.declareProtected('AUTHENTICATED_USER','unlock')
649:
650: def history(self):
651: """history"""
652:
653: ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
654: if ext:
655: return getattr(self,ext[0][1].getId())()
656:
657: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
658: return pt()
659:
660: def getVersions(self):
661: """get all versions"""
662: ret=[]
663: for version in self.ZopeFind(self):
664: if hasattr(version[1],'versionNumber'):
665: ret.append((version[1].versionNumber,version[1]))
666: ret.sort(sortv)
667: return ret
668:
669: security.declareProtected('AUTHENTICATED_USER','forceunlock')
670: def forceunlock(self,RESPONSE):
671: """unlock"""
672: self.lockedBy=''
673:
674: security.declareProtected('AUTHENTICATED_USER','unlock')
675: def unlock(self,RESPONSE):
676: """unlock"""
677: if str(self.lockedBy) in [str(self.REQUEST['AUTHENTICATED_USER'])]:
678: self.lockedBy=''
679: RESPONSE.redirect(self.REQUEST['URL2'])
680: else:
681: return "Sorry, not locked by you! (%s,%s)"%(self.lockedBy,self.REQUEST['AUTHENTICATED_USER'])
682:
683:
684:
685: security.declareProtected('AUTHENTICATED_USER','addVersionedFileObjectForm')
686:
687: def addVersionedFileObjectForm(self):
688: """add a new version"""
689:
690: if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
691: return "please login first"
692: if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
693: out=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version=self.getVersion()).__of__(self)
694: return out()
695: else:
696: return "Sorry file is locked by somebody else"
697:
698: def manage_addVersionedFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
699: """add"""
700: try: #der ganze vC unsinn muss ueberarbeitet werden
701: vC=self.REQUEST['vC']
702: except:
703: pass
704:
705: author=self.REQUEST['author']
706:
707: if changeName=="yes":
708: filename=file.filename
709: self.title=filename[max(filename.rfind('/'),
710: filename.rfind('\\'),
711: filename.rfind(':'),
712: )+1:]
713:
714:
715: if not newName=='':
716: self.title=newName[0:]
717: print self.title
718:
719: id="V%i"%self.getVersion()+"_"+self.title
720:
721: manage_addVersionedFileObject(self,id,vC,author,file,"V%i"%self.getVersion()+"_"+self.title,precondition, content_type)
722: objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
723: self.REQUEST.SESSION['objID_parent']=self.getId()
724:
725: if RESPONSE:
726: obj=self.ZopeFind(self,obj_ids=[id])[0][1]
727: if obj.getSize()==0:
728: self.REQUEST.SESSION['objID']=obj.getId()
729: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
730: return pt()
731:
732: else:
733: RESPONSE.redirect(self.REQUEST['URL2'])
734:
735: else:
736: return self.ZopeFind(self,obj_ids=[id])[0][1]
737:
738: security.declareProtected('AUTHENTICATED_USER','downloadLocked')
739:
740: def download(self):
741: """download and lock"""
742:
743: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
744: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
745:
746: self.content_type="application/octet-stream"
747: #self.REQUEST.RESPONSE.write("bl")
748: self.REQUEST.RESPONSE.write(self.getLastVersion().index_html())
749: self.REQUEST.close()
750:
751: #self.getLastVersion().content_type="application/octet-stream"
752: #self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
753:
754: def downloadLocked(self):
755: """download and lock"""
756: if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
757: return "please login first"
758: if not self.lockedBy=="":
759: return "cannot be locked because is already locked by %s"%self.lockedBy
760: self.lockedBy=self.REQUEST['AUTHENTICATED_USER']
761: self.getLastVersion().content_type="application/octet-stream"
762: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
763:
764: def manage_addVersionedFileForm(self):
765: """interface for adding the OSAS_root"""
766: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addVersionedFile.zpt')).__of__(self)
767: return pt()
768:
769: def manage_addVersionedFile(self,id,title,lockedBy, author=None, RESPONSE=None):
770: """add the OSAS_root"""
771: newObj=versionedFile(id,title,lockedBy,author)
772: self._setObject(id,newObj)
773:
774: if RESPONSE is not None:
775: RESPONSE.redirect('manage_main')
776:
777:
778: InitializeClass(versionedFile)
779: InitializeClass(versionedFileFolder)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to versionedFile.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / versionedFile