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