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

Diff for /versionedFile/versionedFile.py between versions 1.16 and 1.44

version 1.16, 2004/10/25 12:59:11 version 1.44, 2005/10/17 16:06:27
Line 1 Line 1
   
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from OFS.Image import File  from OFS.Image import File
 from OFS.Image import cookId  from OFS.Image import cookId
Line 7  from AccessControl import getSecurityMan Line 8  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
   try:
    from Products.ImageArchive.ImageArchive import manage_AddImageZogiLib
   except:
    print "no images"
   
   from threading import Thread
   import shutil
   import tempfile
 import os.path  import os.path
   import urllib
   
 import time  import time
   try:
       from Products.ECHO_content.ECHO_collection import ECHO_basis
   except:
       print "ECHO Elements not imported"
       class ECHO_basis:
            """leer"""
                manage_options=()
   
   
 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)
     
 class versionedFileFolder(Folder):          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):
     """Folder with versioned files"""      """Folder with versioned files"""
   
           
Line 22  class versionedFileFolder(Folder): Line 117  class versionedFileFolder(Folder):
     security= ClassSecurityInfo()      security= ClassSecurityInfo()
     security.declareProtected('AUTHENTICATED_USER','addFileForm')      security.declareProtected('AUTHENTICATED_USER','addFileForm')
           
     manage_options = Folder.manage_options+(      if ECHO_basis:
           optTMP= Folder.manage_options+ECHO_basis.manage_options
       else:
           optTMP= Folder.manage_options
   
       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):
         """download help"""          """download help"""
                   
         pt=PageTemplateFile('Products/versionedFile/zpt/helpDownload').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','helpDownload')).__of__(self)
         return pt()          return pt()
           
     def generateIndexHTML(self,RESPONSE=None):      def generateIndexHTML_image(self,RESPONSE=None):
         """lege standard index.html an"""          """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):
           """lege standard index.html an"""
   
                   
         if not hasattr(self,'index.html'):          if not self.ZopeFind(self,obj_ids=['index.html']):
             zt=ZopePageTemplate('index.html')              zt=ZopePageTemplate('index.html')
             self._setObject('index.html',zt)              self._setObject('index.html',zt)
             default_content_fn = os.path.join(package_home(globals()),              default_content_fn = os.path.join(package_home(globals()),
Line 59  class versionedFileFolder(Folder): Line 271  class versionedFileFolder(Folder):
   
                   
   
                   if not self.ZopeFind(self,obj_ids=['history_template.html']):
         if not hasattr(self,'history_template.html'):  
             zt=ZopePageTemplate('history_template.html')              zt=ZopePageTemplate('history_template.html')
             self._setObject('history_template.html',zt)              self._setObject('history_template.html',zt)
             default_content_fn = os.path.join(package_home(globals()),              default_content_fn = os.path.join(package_home(globals()),
Line 74  class versionedFileFolder(Folder): Line 285  class versionedFileFolder(Folder):
         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"""
   
         def sortName(x,y):          def sortName(x,y):
             return cmp(x[1].title,y[1].title)              return cmp(x[1].title.lower(),y[1].title.lower())
   
         def sortDate(x,y):          def sortDate(x,y):
             return cmp(x[1].getLastVersion().getTime(),y[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 95  class versionedFileFolder(Folder): Line 340  class versionedFileFolder(Folder):
             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 107  class versionedFileFolder(Folder): Line 354  class versionedFileFolder(Folder):
         else:          else:
             return ""              return ""
                   
   
       security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
         """main"""          """main"""
         ext=self.ZopeFind(self,obj_ids=["index.html"])          ext=self.ZopeFind(self,obj_ids=["index.html"])
         if ext:          if ext:
             return ext[0][1]()              return ext[0][1]()
                   
         pt=PageTemplateFile('Products/versionedFile/zpt/versionFileFolderMain').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionFileFolderMain')).__of__(self)
         return pt()          return pt()
   
   
     def addFileForm(self):      def addFileForm(self):
         """add a file"""          """add a file"""
           ext=self.ZopeFind(self,obj_ids=["addFileForm.dtml"])
           if ext:
               return ext[0][1]('',globals(),version='1',AUTHENTICATED_USER=self.REQUEST.AUTHENTICATED_USER)
           
         out=DTMLFile('dtml/newFileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version='1').__of__(self)          out=DTMLFile('dtml/newFileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version='1').__of__(self)
         return out()          return out()
   
Line 126  class versionedFileFolder(Folder): Line 379  class versionedFileFolder(Folder):
     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
                   
         vC=self.REQUEST.form['vC']          vC=self.REQUEST.form['vC']
         manage_addVersionedFile(self,id,'','')          manage_addVersionedFile(self,id,'','')
           #if (getattr(self,'commentNonEmpty',0)==1) and vC.strip()=="":
               
               
         ob=self._getOb(id)          ob=self._getOb(id)
         ob.title=id          ob.title=id
         file2=file          file2=file
         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:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
               return pt()
           
           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'])          RESPONSE.redirect(self.REQUEST['URL1'])
   
Line 182  class versionedFileObject(File): Line 463  class versionedFileObject(File):
     manage_editForm  =DTMLFile('dtml/fileEdit',globals(),      manage_editForm  =DTMLFile('dtml/fileEdit',globals(),
                                Kind='File',kind='file')                                 Kind='File',kind='file')
     manage_editForm._setName('manage_editForm')      manage_editForm._setName('manage_editForm')
       security= ClassSecurityInfo()
   
       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")
       
       security.declarePublic('getTime')                                              
     def getTime(self):      def getTime(self):
         """getTime"""          """getTime"""
         #return self.bobobase_modification_time().ISO()          #return self.bobobase_modification_time().ISO()
Line 201  class versionedFileObject(File): Line 518  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())
           txt=urllib.urlopen(self.absolute_url()).read()
       self.REQUEST.RESPONSE.write(txt)
           #self.REQUEST.RESPONSE.write("bl")
           self.REQUEST.close()
           
     def downloadLocked(self):      def downloadLocked(self):
         """download and lock"""          """download and lock"""
Line 222  class versionedFileObject(File): Line 545  class versionedFileObject(File):
         """set version"""          """set version"""
         self.versionNumber=versionNumber          self.versionNumber=versionNumber
   
       security.declarePublic('getVersionNumber')                                              
     def getVersionNumber(self):      def getVersionNumber(self):
         """get version"""          """get version"""
         return self.versionNumber          return self.versionNumber
   
       security.declarePublic('getVersionComment')                                              
       def getVersionComment(self):
           """get version"""
           return self.versionComment
   
      
       security.declarePublic('lastEditor')                                                
     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 288  class versionedFile(Folder): Line 622  class versionedFile(Folder):
         self.lockedBy=lockedBy          self.lockedBy=lockedBy
         self.author=author          self.author=author
               
       def manageImagesForm(self):
           """manage Images attached to the file"""
   
           self.REQUEST.SESSION['refer']=self.REQUEST['HTTP_REFERER']
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageImage')).__of__(self)
           return pt()
   
       def manageImages(self,imageUrl=None,caption=None,REQUEST=None):
           """manage URL"""
           if imageUrl and (not imageUrl==""):
               manage_AddImageZogiLib(self,libPath=imageUrl,caption=caption)
   
           if self.REQUEST.SESSION.has_key('refer'):
   
               return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
           return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
       
       
       
       def changeImages(self,caption=None,submit=None,id=None,REQUEST=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 self.REQUEST.SESSION.has_key('refer'):
   
               return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
           return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
       
           
   
   
       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 311  class versionedFile(Folder): Line 720  class versionedFile(Folder):
         lastVersion=self.getLastVersion()          lastVersion=self.getLastVersion()
         #return "File:"+self.title+"  Version:%i"%lastVersion.versionNumber," modified:",lastVersion.bobobase_modification_time()," size:",lastVersion.getSize(),"modified by:",lastVersion.lastEditor()          #return "File:"+self.title+"  Version:%i"%lastVersion.versionNumber," modified:",lastVersion.bobobase_modification_time()," size:",lastVersion.getSize(),"modified by:",lastVersion.lastEditor()
         return "File: %s Version:%i modified:%s size:%s modified by:%s"%(self.title,lastVersion.versionNumber,lastVersion.getTime(),lastVersion.getSize(),lastVersion.lastEditor())          return "File: %s Version:%i modified:%s size:%s modified by:%s"%(self.title,lastVersion.versionNumber,lastVersion.getTime(),lastVersion.getSize(),lastVersion.lastEditor())
                                                                                security= ClassSecurityInfo()                           
       security.declarePublic('getVersion')                                              
     def getVersion(self):      def getVersion(self):
         tmp=0          tmp=0
         for version in self.ZopeFind(self):          for version in self.ZopeFind(self):
Line 322  class versionedFile(Folder): Line 732  class versionedFile(Folder):
                     tmp=int(version[1].versionNumber,)                      tmp=int(version[1].versionNumber,)
         return tmp+1          return tmp+1
   
     security= ClassSecurityInfo()  
     security.declareProtected('AUTHENTICATED_USER','unlock')      security.declareProtected('AUTHENTICATED_USER','unlock')
   
     def history(self):      def history(self):
Line 332  class versionedFile(Folder): Line 742  class versionedFile(Folder):
         if ext:          if ext:
             return getattr(self,ext[0][1].getId())()              return getattr(self,ext[0][1].getId())()
                   
         pt=PageTemplateFile('Products/versionedFile/zpt/versionHistory').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
         return pt()          return pt()
   
     def getVersions(self):      def getVersions(self):
Line 344  class versionedFile(Folder): Line 754  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 354  class versionedFile(Folder): Line 769  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 369  class versionedFile(Folder): Line 785  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:
               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)
                   return pt()
   
               else:
             RESPONSE.redirect(self.REQUEST['URL2'])              RESPONSE.redirect(self.REQUEST['URL2'])
   
           else:
               return self.ZopeFind(self,obj_ids=[id])[0][1]
           
     security.declareProtected('AUTHENTICATED_USER','downloadLocked')      security.declareProtected('AUTHENTICATED_USER','downloadLocked')
   
     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"""
Line 405  class versionedFile(Folder): Line 851  class versionedFile(Folder):
           
 def manage_addVersionedFileForm(self):  def manage_addVersionedFileForm(self):
     """interface for adding the OSAS_root"""      """interface for adding the OSAS_root"""
     pt=PageTemplateFile('Products/versionedFile/zpt/addVersionedFile.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addVersionedFile.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_addVersionedFile(self,id,title,lockedBy, author=None, RESPONSE=None):  def manage_addVersionedFile(self,id,title,lockedBy, author=None, RESPONSE=None):
Removed from v.1.16  
changed lines
  Added in v.1.44

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