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

Diff for /versionedFile/versionedFile.py between versions 1.23 and 1.39

version 1.23, 2005/01/06 16:04:46 version 1.39, 2005/07/04 10:59:03
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 Products.ImageArchive.ImageArchive import manage_AddImageZogiLib
   
   from threading import Thread
   import shutil
   import tempfile
 import os.path  import os.path
   
   
 import time  import time
 try:  try:
     from Products.ECHO_content.ECHO_collection import ECHO_basis      from Products.ECHO_content.ECHO_collection import ECHO_basis
Line 21  except: Line 27  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 38  class versionedFileFolder(Folder,ECHO_ba Line 120  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 Image Index.html','action':'generateIndexHTML_image'},
                 {'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" """%"downloadFileFolder.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 49  class versionedFileFolder(Folder,ECHO_ba Line 225  class versionedFileFolder(Folder,ECHO_ba
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','helpDownload')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','helpDownload')).__of__(self)
         return pt()          return pt()
           
       def generateIndexHTML_image(self,RESPONSE=None):
           """lege standard index.html an"""
   
   
           if not self.ZopeFind(self,obj_ids=['index.html']):
               zt=ZopePageTemplate('index.html')
               self._setObject('index.html',zt)
               default_content_fn = os.path.join(package_home(globals()),
                                                  'zpt/versionFileFolderMain_image.zpt')
               text = open(default_content_fn).read()
               zt.pt_edit(text, 'text/html')
   
           else:
               return "already exists!"
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
     def generateIndexHTML(self,RESPONSE=None):      def generateIndexHTML(self,RESPONSE=None):
         """lege standard index.html an"""          """lege standard index.html an"""
   
Line 87  class versionedFileFolder(Folder,ECHO_ba Line 281  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 293  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 336  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 143  class versionedFileFolder(Folder,ECHO_ba Line 373  class versionedFileFolder(Folder,ECHO_ba
     def addFile(self,vC,file,author,newName='',content_type='',RESPONSE=None):      def addFile(self,vC,file,author,newName='',content_type='',RESPONSE=None):
         """ add a new file"""          """ add a new file"""
         if newName=='':          if newName=='':
             id=file.filename              filename=file.filename
               id=filename[max(filename.rfind('/'),
                                       filename.rfind('\\'),
                                       filename.rfind(':'),
                                       )+1:]
   
         else:          else:
             id=newName              id=newName
                   
Line 157  class versionedFileFolder(Folder,ECHO_ba Line 392  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 165  class versionedFileFolder(Folder,ECHO_ba Line 402  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 208  class versionedFileObject(File): Line 458  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 226  class versionedFileObject(File): Line 512  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 251  class versionedFileObject(File): Line 542  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 313  class versionedFile(Folder): Line 609  class versionedFile(Folder):
         self.lockedBy=lockedBy          self.lockedBy=lockedBy
         self.author=author          self.author=author
               
       def manageImagesForm(self):
           """manage Images attached to the file"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageImage')).__of__(self)
           return pt()
   
       def manageImages(self,imageUrl=None,caption=None,RESPONSE=None):
           """manage URL"""
           if imageUrl and (not imageUrl==""):
               manage_AddImageZogiLib(self,libPath=imageUrl,caption=caption)
               
           if RESPONSE is not None:
               RESPONSE.redirect('../../')
   
       def changeImages(self,caption=None,submit=None,id=None,RESPONSE=None):
           """manage URL"""
           if submit=="change caption":
               image=self.ZopeFind(self,obj_ids=[id])
               if image:
                   image[0][1].caption=caption[0:]
           
           elif submit=="delete":
               image=self.ZopeFind(self,obj_ids=[id])
               if image:
                   self.manage_delObjects([image[0][1].getId()])
           if RESPONSE is not None:
               RESPONSE.redirect('../../')
   
   
       def getImages(self):
           """get Images"""
           images=self.ZopeFind(self,obj_metatypes=["ImageZogiLib"])
           if not images:
               return None
           else:
               return images
                                
           
       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"
   
       def manageCommentForm(self):
           """add a comment"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addComment')).__of__(self)
           return pt()
   
       def manageComment(self,text,comment_author,submit,REQUEST=None):
           """manage comments"""
           if submit =='change':
               if text=='':
                   self.comment=None
               else:
                   self.comment=text
                   self.comment_author=comment_author
   
                   self.comment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
   
           return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
       
     def getLastVersion(self):      def getLastVersion(self):
         """Last Version"""          """Last Version"""
Line 369  class versionedFile(Folder): Line 727  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 379  class versionedFile(Folder): Line 742  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 394  class versionedFile(Folder): Line 758  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":
             self.title=file.filename[0:]              filename=file.filename
               self.title=filename[max(filename.rfind('/'),
                           filename.rfind('\\'),
                           filename.rfind(':'),
                           )+1:]
   
   
         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 425  class versionedFile(Folder): Line 800  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.23  
changed lines
  Added in v.1.39

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