[BACK]Return to versionedFile.py CVS log [TXT] [DIR] Up to [Repository] / versionedFile

Diff for /versionedFile/versionedFile.py between versions 1.26 and 1.37

version 1.26, 2005/02/24 17:13:27 version 1.37, 2005/06/21 14:12:35
Line 7  from AccessControl import getSecurityMan Line 7  from AccessControl import getSecurityMan
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
   
   from threading import Thread
   import shutil
   import tempfile
 import os.path  import os.path
   
 import time  import time
Line 21  except: Line 25  except:
           
 def sortv(x,y):  def sortv(x,y):
     return cmp(x[0],y[0])      return cmp(x[0],y[0])
   tdir = "/tmp/downloadVersionedFiles"
   
   class generateDownloadZip:
       """generateDownloadSet"""
   
       def __init__(self,folderObject,url):
           """init downloadzip"""
           self.folder=folderObject
           self.done=None
           self.response=""
           self.url=url
           
       def __call__(self):
           """call generate download zip"""
           storeTempDir=tempfile.tempdir
       tempfile.tempdir=tdir
   
           tmpPath=tempfile.mktemp()
           tmpZip=tempfile.mktemp()+".gtz"
           tmpFn=os.path.split(tmpZip)[1]
           
           if not os.path.exists(tempfile.tempdir):
               os.mkdir(tempfile.tempdir) 
   
           if not os.path.exists(tmpPath):
               os.mkdir(tmpPath) 
           
       self.response="<h3>1. step: getting the files</h3>"
   
           for files in self.folder.ZopeFind(self.folder,obj_metatypes=['versionedFile']):
               lastV=files[1].getLastVersion()
               self.response+=str("<p>Get File: %s<br>\n"%lastV.title)
   
               savePath=os.path.join(tmpPath,lastV.title)
               fh=file(savePath,"w")
               fh.write(lastV.data)
               fh.close()
   
           self.response+="<h3>2. step: creating the downloadable file</h3>"
       self.response+="<p>Create gtar<br>"
           self.response+="<p>This can take a while....<br>\n"
   
           fh=os.popen2("tar zcvf %s %s/*"%(tmpZip,tmpPath),1)[1]
           self.response+="<br>"
           for c in fh.read():
               self.response+=c
               if c==")":
                   self.response+="<br>\n"
               
                   
   
           
           shutil.rmtree(tmpPath)
   
           self.response+="<p>finished<br>\n"
   
           len=os.stat(tmpZip)[6]
           downloadUrl=self.url+"/downloadSet"
           self.response+="""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len)
           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>"""
           self.response+="""<p>The file will be stored for a while, you can download it later, the URL is:</p>
               <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn)
   
           self.done=True
   
    
       def getResult(self):
           """get result"""
           return self.response
   
       def isDone(self):
           if self.done:
               return True
           else:
               return False
           
     
 class versionedFileFolder(Folder,ECHO_basis):  class versionedFileFolder(Folder,ECHO_basis):
     """Folder with versioned files"""      """Folder with versioned files"""
Line 39  class versionedFileFolder(Folder,ECHO_ba Line 119  class versionedFileFolder(Folder,ECHO_ba
     manage_options =optTMP+(      manage_options =optTMP+(
         {'label':'Generate Index.html','action':'generateIndexHTML'},          {'label':'Generate Index.html','action':'generateIndexHTML'},
                 {'label':'Generate history_template.html','action':'generateHistoryHTML'},                  {'label':'Generate history_template.html','action':'generateHistoryHTML'},
                   {'label':'Import Folder','action':'importFolderForm'},
                   {'label':'Export Folder','action':'exportFolder'},
                 )                  )
   
       def importFolderForm(self):
           """form fuer folder import"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importFolderForm.zpt')).__of__(self)
           return pt()
           
       def importFolder(self,path,comment="",author=None,lockedBy=None,RESPONSE=None):
           """importiere inhalt eines folders"""
   
           for fileName in os.listdir(path):
               if os.path.isfile(os.path.join(path,fileName)):
                   manage_addVersionedFile(self,fileName,'','')
                   id=fileName
                   ob=self._getOb(fileName)
                   ob.title=id
                   file2=file(os.path.join(path,fileName))
           
                   obj=ob.manage_addVersionedFileObject(id,comment,author,file2,content_type='')
   
           if RESPONSE:
               RESPONSE.redirect(self.REQUEST['URL1'])
   
       zipThreads={}
       zipThreads2={}
   
       def refreshTxt(self):
           """txt fuer refresh"""
           tn=self.REQUEST.SESSION['threadName']
           return """ 2;url=%s?repeat=%s """%(self.absolute_url()+"/exportFolder",tn)
   
       def exportFolder(self,repeat=None):
           """exportiert alle akutellen files des folders"""
           threadName=repeat
           
           downloadZip=generateDownloadZip(self,self.absolute_url())
           downloadZip()
           return downloadZip.getResult()
          ##  if not threadName or threadName=="":
   ##             threadStart=generateDownloadZip(self,self.absolute_url())
   ##             thread=Thread(target=threadStart)
               
   ##             thread.start()
   
                       
   ##             self.zipThreads[thread.getName()[0:]]=threadStart
   ##             self.zipThreads2[thread.getName()[0:]]=thread
   ##             self.REQUEST.SESSION['threadName']=thread.getName()[0:]
   ##             wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
   ##             if wait_template:
   ##                 return wait_template[0][1]()
   ##             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
   ##             return pt()
                   
   ##         else:
   ##             self.REQUEST.SESSION['threadName']=threadName
   
   ##             if (self.zipThreads[threadName].getResult()==None):
   
   ##                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
   ##                 if wait_template:
   ##                     return wait_template[0][1]()
   
   ##                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
   ##                 return pt()
   ##             else:
   ##                 if self.zipThreads[threadName].isDone():
   ##                     self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
   ##                     self.zipThreads2[threadName].join()
   ##                     del(self.zipThreads2[threadName])
   ##                     del(self.zipThreads[threadName])
   ##                     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
   ##                     return pt()
   
   ##                 else:
   ##                     self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
   ##                     self.REQUEST.SESSION['threadName']=threadName
   ##                     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)
   ##                     return pt()
   
       def downloadSet(self,fn):
           """download prepared set"""
           filename=os.path.join(tdir,fn)
   
           
           self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"donloadFileFolder.tgz")
           self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
           len=os.stat(filename)[6]
           self.REQUEST.RESPONSE.setHeader("Content-Length",len)
           images=file(filename).read()
           self.REQUEST.RESPONSE.write(images)
           self.REQUEST.RESPONSE.close()
   
       
           
     def helpDownload(self):      def helpDownload(self):
Line 87  class versionedFileFolder(Folder,ECHO_ba Line 260  class versionedFileFolder(Folder,ECHO_ba
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
       
          
   
     def getVersionedFiles(self,sortField='title'):      def getVersionedFiles(self,sortField='title'):
         """get all versioned files"""          """get all versioned files"""
   
Line 96  class versionedFileFolder(Folder,ECHO_ba Line 272  class versionedFileFolder(Folder,ECHO_ba
         def sortDate(x,y):          def sortDate(x,y):
             return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())              return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
   
           
           def sortComment(x,y):
   
           
               
        try:
           xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
        except:
           xc='ZZZZZZZZZZZZZ'.lower()
        try:
           yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
            except:
               yc='ZZZZZZZZZZZZZ'.lower()
   
   
            if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
                
                try:
                    xc=x[1].getLastVersion().getVComment().lower()
                except:
                    xc='ZZZZZZZZZZZZZ'.lower()
                    
            if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
                try:
                    yc=y[1].getLastVersion().getVComment().lower()
                except:
                    yc='ZZZZZZZZZZZZZ'.lower()
   
            
            return cmp(xc,yc)
   
         def sortAuthor(x,y):          def sortAuthor(x,y):
                           
             return cmp(x[1].getLastVersion().lastEditor(),y[1].getLastVersion().lastEditor())              return cmp(x[1].getLastVersion().lastEditor().lower(),y[1].getLastVersion().lastEditor().lower())
                   
     versionedFiles=self.ZopeFind(self,obj_metatypes=['versionedFile'])      versionedFiles=self.ZopeFind(self,obj_metatypes=['versionedFile'])
   
Line 108  class versionedFileFolder(Folder,ECHO_ba Line 315  class versionedFileFolder(Folder,ECHO_ba
             versionedFiles.sort(sortDate)              versionedFiles.sort(sortDate)
         elif sortField=='author':          elif sortField=='author':
             versionedFiles.sort(sortAuthor)              versionedFiles.sort(sortAuthor)
           elif sortField=='comment':
               versionedFiles.sort(sortComment)
   
         return versionedFiles          return versionedFiles
   
Line 162  class versionedFileFolder(Folder,ECHO_ba Line 371  class versionedFileFolder(Folder,ECHO_ba
         file2=file          file2=file
                   
         obj=ob.manage_addVersionedFileObject(id,vC,author,file2,content_type=content_type)          obj=ob.manage_addVersionedFileObject(id,vC,author,file2,content_type=content_type)
           self.REQUEST.SESSION['objID']=ob.getId()
           self.REQUEST.SESSION['objID_parent']=None
   
         if obj.getSize()==0:          if obj.getSize()==0:
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
Line 170  class versionedFileFolder(Folder,ECHO_ba Line 381  class versionedFileFolder(Folder,ECHO_ba
         RESPONSE.redirect(self.REQUEST['URL1'])          RESPONSE.redirect(self.REQUEST['URL1'])
   
                   
       def deleteEmptyObject(self,submit,RESPONSE=None):
           """deleteemptyobject"""
           if submit=="delete it":
               if self.REQUEST.SESSION['objID_parent']:
                   obj=getattr(self,self.REQUEST.SESSION['objID_parent'])
   
               else:
                   obj=self
               obj.manage_delObjects([self.REQUEST.SESSION['objID']])
   
           RESPONSE.redirect(self.REQUEST['URL1'])
           
           
 manage_addVersionedFileFolderForm=DTMLFile('dtml/folderAdd', globals())  manage_addVersionedFileFolderForm=DTMLFile('dtml/folderAdd', globals())
   
   
Line 213  class versionedFileObject(File): Line 437  class versionedFileObject(File):
                                Kind='File',kind='file')                                 Kind='File',kind='file')
     manage_editForm._setName('manage_editForm')      manage_editForm._setName('manage_editForm')
   
       def getVComment(self):
           """get the comment of this file"""
           if not hasattr(self,'vComment') or (not self.vComment) or (self.vComment.lstrip()==""):
               return "Add comment"
   
           else:
               return self.vComment
               
       def manageVCommentForm(self):
           """add a comment"""
   
           self.REQUEST.SESSION['refer']=self.REQUEST['HTTP_REFERER']
   
   
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addVComment')).__of__(self)
           return pt()
   
       def manageVComment(self,text,comment_author,submit,REQUEST=None):
           """manage comments"""
           if submit =='change':
               if text=='':
                   self.vComment=None
               else:
                   self.vComment=text
                   self.vComment_author=comment_author
   
                   self.vComment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
   
           if self.REQUEST.SESSION.has_key('refer'):
   
               return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
           return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url()+"/history")
       
   
     def getTime(self):      def getTime(self):
         """getTime"""          """getTime"""
         #return self.bobobase_modification_time().ISO()          #return self.bobobase_modification_time().ISO()
Line 231  class versionedFileObject(File): Line 490  class versionedFileObject(File):
     def download(self):      def download(self):
         """download and lock"""          """download and lock"""
                   
           self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getId())
       self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
                   
         self.content_type="application/octet-stream"          self.content_type="application/octet-stream"
         self.REQUEST.RESPONSE.redirect(self.absolute_url())          #self.REQUEST.RESPONSE.redirect(self.absolute_url())
           self.REQUEST.RESPONSE.write(self.index_html())
           #self.REQUEST.RESPONSE.write("bl")
           self.REQUEST.close()
           
     def downloadLocked(self):      def downloadLocked(self):
         """download and lock"""          """download and lock"""
Line 256  class versionedFileObject(File): Line 520  class versionedFileObject(File):
         """get version"""          """get version"""
         return self.versionNumber          return self.versionNumber
   
      
               
     def lastEditor(self):      def lastEditor(self):
         """last Editor"""          """last Editor"""
         if hasattr(self,'author'):          if hasattr(self,'author'):
             return self.author                          ret=self.author.replace("-","\n")
               ret=ret.replace("\r","\n")
               return ret
   
         else:          else:
             jar=self._p_jar              jar=self._p_jar
             oid=self._p_oid              oid=self._p_oid
Line 318  class versionedFile(Folder): Line 587  class versionedFile(Folder):
         self.lockedBy=lockedBy          self.lockedBy=lockedBy
         self.author=author          self.author=author
               
       def getComment(self):
           """get the comment of this file"""
           if not hasattr(self,'comment') or (not self.comment) or (self.comment.lstrip()==""):
               return "Add comment"
   
           else:
               return self.comment
               
                   
     meta_type="versionedFile"      meta_type="versionedFile"
   
Line 391  class versionedFile(Folder): Line 668  class versionedFile(Folder):
         ret.sort(sortv)          ret.sort(sortv)
         return ret          return ret
   
       security.declareProtected('AUTHENTICATED_USER','forceunlock')   
       def forceunlock(self,RESPONSE):
           """unlock"""
           self.lockedBy=''
   
     security.declareProtected('AUTHENTICATED_USER','unlock')         security.declareProtected('AUTHENTICATED_USER','unlock')   
     def unlock(self,RESPONSE):      def unlock(self,RESPONSE):
         """unlock"""          """unlock"""
Line 401  class versionedFile(Folder): Line 683  class versionedFile(Folder):
             return "Sorry, not locked by you! (%s,%s)"%(self.lockedBy,self.REQUEST['AUTHENTICATED_USER'])              return "Sorry, not locked by you! (%s,%s)"%(self.lockedBy,self.REQUEST['AUTHENTICATED_USER'])
                   
           
       
     security.declareProtected('AUTHENTICATED_USER','addVersionedFileObjectForm')      security.declareProtected('AUTHENTICATED_USER','addVersionedFileObjectForm')
   
     def addVersionedFileObjectForm(self):      def addVersionedFileObjectForm(self):
Line 416  class versionedFile(Folder): Line 699  class versionedFile(Folder):
                   
     def manage_addVersionedFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):      def manage_addVersionedFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
         """add"""          """add"""
                   try: #der ganze vC unsinn muss ueberarbeitet werden
         vC=self.REQUEST['vC']          vC=self.REQUEST['vC']
           except:
               pass
           
         author=self.REQUEST['author']          author=self.REQUEST['author']
                   
         if changeName=="yes":          if changeName=="yes":
Line 430  class versionedFile(Folder): Line 716  class versionedFile(Folder):
   
         if not newName=='':          if not newName=='':
             self.title=newName[0:]              self.title=newName[0:]
           print self.title
   
         id="V%i"%self.getVersion()+"_"+self.title          id="V%i"%self.getVersion()+"_"+self.title
                   
         manage_addVersionedFileObject(self,id,vC,author,file,"V%i"%self.getVersion()+"_"+self.title,precondition, content_type)          manage_addVersionedFileObject(self,id,vC,author,file,"V%i"%self.getVersion()+"_"+self.title,precondition, content_type)
         objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))          objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
           self.REQUEST.SESSION['objID_parent']=self.getId()
   
         if RESPONSE:          if RESPONSE:
             if self.ZopeFind(self,obj_ids=[id])[0][1].getSize()==0:              obj=self.ZopeFind(self,obj_ids=[id])[0][1]
               if obj.getSize()==0:
                   self.REQUEST.SESSION['objID']=obj.getId()
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
                 return pt()                  return pt()
   
Line 452  class versionedFile(Folder): Line 741  class versionedFile(Folder):
   
     def download(self):      def download(self):
         """download and lock"""          """download and lock"""
         self.getLastVersion().content_type="application/octet-stream"  
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())          self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
       self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
         
           self.content_type="application/octet-stream"
           #self.REQUEST.RESPONSE.write("bl")
           self.REQUEST.RESPONSE.write(self.getLastVersion().index_html())
           self.REQUEST.close()
   
           #self.getLastVersion().content_type="application/octet-stream"
           #self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
           
     def downloadLocked(self):      def downloadLocked(self):
         """download and lock"""          """download and lock"""
Removed from v.1.26  
changed lines
  Added in v.1.37

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>