Diff for /versionedFile/versionedFile.py between versions 1.35 and 1.63

version 1.35, 2005/06/20 21:34:17 version 1.63, 2006/06/17 16:32:12
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 difflib import Differ
   from pprint import pprint
   
   from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   
   try:
    from Products.ImageArchive.ImageArchive import manage_AddImageZogiLib
   except:
    print "no images"
   
   
 from threading import Thread  from threading import Thread
 import shutil  import shutil
 import tempfile  import tempfile
 import os.path  import os.path
   import urllib
   
 import time  import time
 try:  try:
Line 25  except: Line 36  except:
           
 def sortv(x,y):  def sortv(x,y):
     return cmp(x[0],y[0])      return cmp(x[0],y[0])
 tdir = "/tmp/testia"  tdir = "/tmp/downloadVersionedFiles"
   
 class generateDownloadZip:  class generateDownloadZip:
     """generateDownloadSet"""      """generateDownloadSet"""
Line 52  class generateDownloadZip: Line 63  class generateDownloadZip:
         if not os.path.exists(tmpPath):          if not os.path.exists(tmpPath):
             os.mkdir(tmpPath)               os.mkdir(tmpPath) 
                   
     self.response="<h3>1. step: gettung the files</h3>"      self.response="<h3>1. step: getting the files</h3>"
   
         for files in self.folder.ZopeFind(self.folder,obj_metatypes=['versionedFile']):          for files in self.folder.ZopeFind(self.folder,obj_metatypes=['versionedFile']):
             lastV=files[1].getLastVersion()              lastV=files[1].getLastVersion()
Line 84  class generateDownloadZip: Line 95  class generateDownloadZip:
         len=os.stat(tmpZip)[6]          len=os.stat(tmpZip)[6]
         downloadUrl=self.url+"/downloadSet"          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+="""<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>          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)              <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn)
   
Line 109  class versionedFileFolder(Folder,ECHO_ba Line 121  class versionedFileFolder(Folder,ECHO_ba
   
     security= ClassSecurityInfo()      security= ClassSecurityInfo()
     security.declareProtected('AUTHENTICATED_USER','addFileForm')      security.declareProtected('AUTHENTICATED_USER','addFileForm')
       filesMetaType=['versionedFile']
     if ECHO_basis:      if ECHO_basis:
         optTMP= Folder.manage_options+ECHO_basis.manage_options          optTMP= Folder.manage_options+ECHO_basis.manage_options
     else:      else:
Line 117  class versionedFileFolder(Folder,ECHO_ba Line 129  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':'Import Folder','action':'importFolderForm'},
                   {'label':'Export Folder','action':'exportFolder'},
                   {'label':'Position of version number','action':'changeHistoryFileNamesForm'},
                 )                  )
   
       def changeHistoryFileNamesForm(self):
           """change position of version num"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeHistoryFileNamesForm.zpt')).__of__(self)
           return pt()
       
       
       def changeHistoryFileNames(self,positionVersionNum="front",RESPONSE=None):
           """change position of version num"""
           
           
           
           versions=self.ZopeFind(self,obj_metatypes=['versionedFileObject'],search_sub=1)
           
           if not (getattr(self,'positionVersionNum','front')==positionVersionNum):
   
               for version in versions:
                                   
                   if positionVersionNum=="front":
           
                       titleTmp=os.path.splitext(version[1].title)
                       titleTmp2="_".join(titleTmp[0].split("_")[0:-1])
                       if len(titleTmp)>1:
                           id=titleTmp[0].split("_")[-1]+"_"+titleTmp2+"."+titleTmp[1]
                       else:
                           id=titleTmp[0].split("_")[-1]+"_"+titleTmp2
   
                   else:
                       titleTmp="_".join(version[1].getId().split("_")[1:])
                       tmp=os.path.splitext(titleTmp)
                       if len(tmp)>1:
                           id=tmp[0]+"_"+version[1].getId().split("_")[0]+tmp[1]
                       else:
                           id=tmp[0]+"_"+version[1].getId().split("_")[0]
                   
                   
                   
                   version[1].aq_parent.manage_renameObjects(ids=[version[1].getId()],new_ids=[id])
                   version[1].title=id
                   
                   
           self.positionVersionNum=positionVersionNum        
           if RESPONSE:
               RESPONSE.redirect("manage_main")
           
           
           
     def importFolderForm(self):      def importFolderForm(self):
         """form fuer folder import"""          """form fuer folder import"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importFolderForm.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importFolderForm.zpt')).__of__(self)
Line 154  class versionedFileFolder(Folder,ECHO_ba Line 215  class versionedFileFolder(Folder,ECHO_ba
         """exportiert alle akutellen files des folders"""          """exportiert alle akutellen files des folders"""
         threadName=repeat          threadName=repeat
                   
                                  downloadZip=generateDownloadZip(self,self.absolute_url())
         if not threadName or threadName=="":          downloadZip()
             threadStart=generateDownloadZip(self,self.absolute_url())          return downloadZip.getResult()
             thread=Thread(target=threadStart)         ##  if not threadName or threadName=="":
               ##             threadStart=generateDownloadZip(self,self.absolute_url())
             thread.start()  ##             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:]  ##             self.zipThreads[thread.getName()[0:]]=threadStart
             wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])  ##             self.zipThreads2[thread.getName()[0:]]=thread
             if wait_template:  ##             self.REQUEST.SESSION['threadName']=thread.getName()[0:]
                 return wait_template[0][1]()  ##             wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)  ##             if wait_template:
             return pt()  ##                 return wait_template[0][1]()
                   ##             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
         else:  ##             return pt()
             self.REQUEST.SESSION['threadName']=threadName                  
   ##         else:
             if (self.zipThreads[threadName].getResult()==None):  ##             self.REQUEST.SESSION['threadName']=threadName
   
                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])  ##             if (self.zipThreads[threadName].getResult()==None):
                 if wait_template:  
                     return wait_template[0][1]()  ##                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
   ##                 if wait_template:
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)  ##                     return wait_template[0][1]()
                 return pt()  
             else:  ##                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
                 if self.zipThreads[threadName].isDone():  ##                 return pt()
                     self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()  ##             else:
                     self.zipThreads2[threadName].join()  ##                 if self.zipThreads[threadName].isDone():
                     del(self.zipThreads2[threadName])  ##                     self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
                     del(self.zipThreads[threadName])  ##                     self.zipThreads2[threadName].join()
                     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)  ##                     del(self.zipThreads2[threadName])
                     return pt()  ##                     del(self.zipThreads[threadName])
   ##                     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
                 else:  ##                     return pt()
                     self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()  
                     self.REQUEST.SESSION['threadName']=threadName  ##                 else:
                     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)  ##                     self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
                     return pt()  ##                     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):      def downloadSet(self,fn):
         """download prepared set"""          """download prepared set"""
         filename=os.path.join(tdir,fn)          filename=os.path.join(tdir,fn)
   
                   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"donloadFileFolder.tgz")          self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"downloadFileFolder.tgz")
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")          self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
         len=os.stat(filename)[6]          len=os.stat(filename)[6]
         self.REQUEST.RESPONSE.setHeader("Content-Length",len)          self.REQUEST.RESPONSE.setHeader("Content-Length",len)
Line 218  class versionedFileFolder(Folder,ECHO_ba Line 281  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 generateAddFileForm(self,RESPONSE=None):
           """lege standard addfileform an"""
           #TODO: write generateaddfileform only a dummy at them moment
   
           if not self.ZopeFind(self,obj_ids=['addFileForm.dtml']):
               zt=ZopePageTemplate('index.html')
               self._setObject('index.html',zt)
               default_content_fn = os.path.join(package_home(globals()),
                                                  'zpt/versionFileFolderMain.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 303  class versionedFileFolder(Folder,ECHO_ba Line 404  class versionedFileFolder(Folder,ECHO_ba
                           
             return cmp(x[1].getLastVersion().lastEditor().lower(),y[1].getLastVersion().lastEditor().lower())              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=self.filesMetaType)
           
   
         if sortField=='title':          if sortField=='title':
             versionedFiles.sort(sortName)              versionedFiles.sort(sortName)
Line 325  class versionedFileFolder(Folder,ECHO_ba Line 427  class versionedFileFolder(Folder,ECHO_ba
         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"])
Line 335  class versionedFileFolder(Folder,ECHO_ba Line 439  class versionedFileFolder(Folder,ECHO_ba
         return pt()          return pt()
   
   
   
     def addFileForm(self):      def addFileForm(self):
         """add a file"""          """add a file"""
         ext=self.ZopeFind(self,obj_ids=["addFileForm.dtml"])          ext=self.ZopeFind(self,obj_ids=["addFileForm.dtml"])
Line 426  def manage_addVersionedFileFolder(self, Line 531  def manage_addVersionedFileFolder(self,
   
 class versionedFileObject(File):  class versionedFileObject(File):
     """File Object im Folder"""      """File Object im Folder"""
           security= ClassSecurityInfo()
     meta_type = "versionedFileObject"      meta_type = "versionedFileObject"
           
     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.declarePublic('getTitle')
   
       def getTitle(self):
           """get title"""
           return self.title
    
       security.declarePublic('getVComment')
     def getVComment(self):      def getVComment(self):
         """get the comment of this file"""          """get the comment of this file"""
         if not hasattr(self,'vComment') or (not self.vComment) or (self.vComment.lstrip()==""):          if not hasattr(self,'vComment') or (not self.vComment) or (self.vComment.lstrip()==""):
Line 468  class versionedFileObject(File): Line 583  class versionedFileObject(File):
         return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url()+"/history")          return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url()+"/history")
           
   
       security.declarePublic('getVersionComment')
       def getVersionComment(self):
           """getversioncomment"""
           return self.versionComment
       
       security.declarePublic('getTime')
   
     def getTime(self):      def getTime(self):
         """getTime"""          """getTime"""
         #return self.bobobase_modification_time().ISO()          #return self.bobobase_modification_time().ISO()
Line 483  class versionedFileObject(File): Line 605  class versionedFileObject(File):
   
           
   
     def download(self):      def download(self,REQUEST=None,RESPONSE=None):
         """download and lock"""          """download and lock"""
                   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getId())          self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getId())
     self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")      self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
       #try:
       #   txt=self.index_html()
       #except:
       #   txt=self.index_html(REQUEST,RESPONSE)
       #
       #self.REQUEST.RESPONSE.setHeader("Content-Length","str(len(txt)+1000)")
               
         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())          #txt=urllib.urlopen(self.absolute_url()).read()
         #self.REQUEST.RESPONSE.write("bl")          #self.REQUEST.RESPONSE.write(txt)
         self.REQUEST.close()      
   
           #self.REQUEST.close()
           
       security.declareProtected('AUTHENTICATED_USER','downloadLocked')    
     def downloadLocked(self):      def downloadLocked(self):
         """download and lock"""          """download and lock"""
                   
                   
         if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':          if repr(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
             return "please login first"              return "please login first"
         if not self.aq_parent.lockedBy=="":          if not self.aq_parent.lockedBy=="":
             return "cannot be locked because is already locked by %s"%self.lockedBy              return "cannot be locked because is already locked by %s"%self.lockedBy
Line 512  class versionedFileObject(File): Line 643  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'):
               try:
             ret=self.author.replace("-","\n")              ret=self.author.replace("-","\n")
               except:#old version of versionded file sometimes stored the user object and not only the name the following corrects this
                   ret=str(self.author).replace("-","\n")
             ret=ret.replace("\r","\n")              ret=ret.replace("\r","\n")
             return ret              return ret.lstrip().rstrip()
   
         else:          else:
             jar=self._p_jar              jar=self._p_jar
Line 573  def manage_addVersionedFileObject(self,i Line 717  def manage_addVersionedFileObject(self,i
   
   
   
 class versionedFile(Folder):  class versionedFile(CatalogAware,Folder):
     """Versioniertes File"""      """Versioniertes File"""
   
       default_catalog='fileCatalog'
       
       security= ClassSecurityInfo()   
       
       security.declarePublic('getTitle')
       def getTitle(self):
           """get title"""
           return self.title
       
       def PrincipiaSearchSource(self):
              """Return cataloguable key for ourselves."""
              return str(self)
          
     def __init__(self, id, title, lockedBy,author):      def __init__(self, id, title, lockedBy,author):
         """init"""          """init"""
         self.id=id          self.id=id
Line 583  class versionedFile(Folder): Line 740  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
                                
       security.declarePublic('getComment')
     def getComment(self):      def getComment(self):
         """get the comment of this file"""          """get the comment of this file"""
         if not hasattr(self,'comment') or (not self.comment) or (self.comment.lstrip()==""):          if not hasattr(self,'comment') or (not self.comment) or (self.comment.lstrip()==""):
Line 612  class versionedFile(Folder): Line 819  class versionedFile(Folder):
   
         return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())          return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
           
       security.declarePublic('getLastChangeDate')
       
       def getLastChangeDate(self):
           """get last change date"""
           lv=self.getLastVersion()
           time=lv.getTime()
           return time
       
       def getLastEditor(self):
           """get last change date"""
           lv=self.getLastVersion()
           le=lv.lastEditor()
           return le
       
       def getLockedBy(self):
           """get locked by"""
           return str(self.lockedBy)
           
       security.declarePublic('getLastVersion')
     def getLastVersion(self):      def getLastVersion(self):
         """Last Version"""          """Last Version"""
         tmp=0          tmp=0
         lastVersion=None          lastVersion=None
                   
           
         for version in self.ZopeFind(self):          for version in self.ZopeFind(self):
                           
             if hasattr(version[1],'versionNumber'):              if hasattr(version[1],'versionNumber'):
Line 624  class versionedFile(Folder): Line 851  class versionedFile(Folder):
                 if int(version[1].versionNumber) > tmp:                  if int(version[1].versionNumber) > tmp:
                     tmp=int(version[1].versionNumber,)                      tmp=int(version[1].versionNumber,)
                     lastVersion=version[1]                      lastVersion=version[1]
               if lastVersion==None:
                   lastVersion=version[1]
                   lastVersion.versionNumber=1
         return lastVersion          return lastVersion
           
       
       def diff(self,data):
           """differenz between lastversion and data"""
           d=Differ()
           tmp=self.getLastVersion().data
           #print "XX",data,tmp
           l=list(d.compare(data.splitlines(1),tmp.splitlines(1)))
           
           plus=0
           minus=0
           for a in l:
               if a[0]=='+':
                   plus+=1
               if a[0]=='-':
                   minus+=1
           
           
           return max([plus,minus]),l
       security.declarePublic('index_html')
     def index_html(self):      def index_html(self):
         """main view"""          """main view"""
         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.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 642  class versionedFile(Folder): Line 894  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 665  class versionedFile(Folder): Line 917  class versionedFile(Folder):
         return ret          return ret
   
     security.declareProtected('AUTHENTICATED_USER','forceunlock')         security.declareProtected('AUTHENTICATED_USER','forceunlock')   
     def forceunlock(self,RESPONSE):      def forceunlock(self,RESPONSE=None):
         """unlock"""          """unlock"""
           #safe who had the lock
           if self.lockedBy:
               self.brokenLock=str(self.lockedBy)
           else:
               self.brokenLock=""
         self.lockedBy=''          self.lockedBy=''
           return self.brokenLock
   
     security.declareProtected('AUTHENTICATED_USER','unlock')         security.declareProtected('AUTHENTICATED_USER','unlock')   
     def unlock(self,RESPONSE):      def unlock(self,RESPONSE):
         """unlock"""          """unlock"""
         if str(self.lockedBy) in [str(self.REQUEST['AUTHENTICATED_USER'])]:          if str(self.lockedBy) in [str(self.REQUEST['AUTHENTICATED_USER'])]:
             self.lockedBy=''              self.lockedBy=''
             RESPONSE.redirect(self.REQUEST['URL2'])              RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])
         else:          else:
             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'])
                   
Line 688  class versionedFile(Folder): Line 946  class versionedFile(Folder):
         if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:          if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
             return "please login first"              return "please login first"
         if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):          if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
               ext=self.ZopeFind(self.aq_parent,obj_ids=["addNewVersion.dtml"])
               if ext:
                   return ext[0][1]('',globals(),version=self.getVersion(),lastComment=self.getLastVersion().getVersionComment(),AUTHENTICATED_USER=self.REQUEST.AUTHENTICATED_USER)
               else:
             out=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version=self.getVersion()).__of__(self)              out=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version=self.getVersion()).__of__(self)
             return out()              return out()
         else:          else:
Line 712  class versionedFile(Folder): Line 974  class versionedFile(Folder):
   
         if not newName=='':          if not newName=='':
             self.title=newName[0:]              self.title=newName[0:]
         print self.title  
                   
           
   
           
           
           positionVersionNum=getattr(self,'positionVersionNum','front')
           
           if positionVersionNum=='front':
         id="V%i"%self.getVersion()+"_"+self.title          id="V%i"%self.getVersion()+"_"+self.title
           else:
               tmp=os.path.splitext(self.title)
               if len(tmp)>1:
                   id=tmp[0]+"_V%i"%self.getVersion()+tmp[1]
               else:
                   id=tmp[0]+"_V%i"%self.getVersion()
               
                   
         manage_addVersionedFileObject(self,id,vC,author,file,"V%i"%self.getVersion()+"_"+self.title,precondition, content_type)          manage_addVersionedFileObject(self,id,vC,author,file,id,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()          self.REQUEST.SESSION['objID_parent']=self.getId()
   
           if getattr(self,'defaultFileCatalog',None):
               
               self.reindex_object()
               
         if RESPONSE:          if RESPONSE:
             obj=self.ZopeFind(self,obj_ids=[id])[0][1]              obj=self.ZopeFind(self,obj_ids=[id])[0][1]
             if obj.getSize()==0:              if obj.getSize()==0:
Line 741  class versionedFile(Folder): Line 1020  class versionedFile(Folder):
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%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.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
               
       #try:   
       #   txt=self.getLastVersion.index_html()
       #except:
       #   txt=self.getLastVersion.index_html(REQUEST,RESPONSE)
   
       #self.REQUEST.RESPONSE.setHeader("Content-Length","str(len(txt)+1000)")
           
         self.content_type="application/octet-stream"          self.content_type="application/octet-stream"
         #self.REQUEST.RESPONSE.write("bl")          #self.REQUEST.RESPONSE.write("bl")
         self.REQUEST.RESPONSE.write(self.getLastVersion().index_html())          #self.REQUEST.RESPONSE.write(txt)
         self.REQUEST.close()          #self.REQUEST.close()
   
         #self.getLastVersion().content_type="application/octet-stream"          #self.getLastVersion().content_type="application/octet-stream"
         #self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())          self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
           
       security.declareProtected('AUTHENTICATED_USER','downloadLocked')    
     def downloadLocked(self):      def downloadLocked(self):
         """download and lock"""          """download and lock"""
         if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':  
           if repr(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
             return "please login first"              return "please login first"
         if not self.lockedBy=="":          if not self.lockedBy=="":
             return "cannot be locked because is already locked by %s"%self.lockedBy              return "cannot be locked because is already locked by %s"%self.lockedBy

Removed from v.1.35  
changed lines
  Added in v.1.63


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