Return to versionedFile.py CVS log

Up to [Repository] / versionedFile

bug fixed, upload now possible already in the first verson

from OFS.Folder import Folder
from OFS.Image import File
from OFS.Image import cookId
from Globals import DTMLFile, InitializeClass
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from AccessControl import getSecurityManager
from Products.PageTemplates.PageTemplate import PageTemplate
from AccessControl import ClassSecurityInfo

def sortv(x,y):
    return cmp(x[0],y[0])
 
class versionedFileFolder(Folder):
    """Folder with versioned files"""

    meta_type = "versionedFileFolder"

    security= ClassSecurityInfo()
    security.declareProtected('AUTHENTICATED_USER','addFileForm')
    
    def getVersionedFiles(self):
        """get all versioned files"""
        
	versionedFiles=self.ZopeFind(self,obj_metatypes=['versionedFile'])
       
        return versionedFiles

    
    def index_html(self):
        """main"""
        pt=PageTemplateFile('Products/versionedFile/zpt/versionFileFolderMain').__of__(self)
        return pt()


    def addFileForm(self):
        """add a file"""
        out=DTMLFile('dtml/newFileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version='1').__of__(self)
        return out()


    def addFile(self,vC,file,content_type='',RESPONSE=None):
        """ add a new file"""
        id=file.filename
        
        vC=self.REQUEST.form['vC']
        manage_addVersionedFile(self,id,'','')
        ob=self._getOb(id)
        ob.title=id
        file2=file
        ob.manage_addVersionedFileObject(id,vC,file2,content_type=content_type)

        RESPONSE.redirect(self.REQUEST['URL1'])

        
manage_addVersionedFileFolderForm=DTMLFile('dtml/folderAdd', globals())


def manage_addVersionedFileFolder(self, id, title='',
                     createPublic=0,
                     createUserF=0,
                     REQUEST=None):
    """Add a new Folder object with id *id*.

    If the 'createPublic' and 'createUserF' parameters are set to any true
    value, an 'index_html' and a 'UserFolder' objects are created respectively
    in the new folder.
    """
    ob=versionedFileFolder()
    ob.id=str(id)
    ob.title=title
    self._setObject(id, ob)
    ob=self._getOb(id)

    checkPermission=getSecurityManager().checkPermission

    if createUserF:
        if not checkPermission('Add User Folders', ob):
            raise Unauthorized, (
                  'You are not authorized to add User Folders.'
                  )
        ob.manage_addUserFolder()

  
    if REQUEST is not None:
        return self.manage_main(self, REQUEST, update_menu=1)



class versionedFileObject(File):
    """File Object im Folder"""
    
    meta_type = "versionedFileObject"
    
    manage_editForm  =DTMLFile('dtml/fileEdit',globals(),
                               Kind='File',kind='file')
    manage_editForm._setName('manage_editForm')


    def setVersionNumber(self,versionNumber):
        """set version"""
        self.versionNumber=versionNumber

    def getVersionNumber(self):
        """get version"""
        return self.versionNumber

    def lastEditor(self):
        """last Editor"""
        jar=self._p_jar
        oid=self._p_oid
        if jar is None or oid is None: return None
        return jar.db().history(oid)[0]['user_name']

    
    
        
manage_addVersionedFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject', version='1')

def manage_addVersionedFileObject(self,id,vC='',file='',title='',precondition='', content_type='',
                   REQUEST=None):
    """Add a new File object.

    Creates a new File object 'id' with the contents of 'file'"""
    
    id=str(id)
    title=str(title)
    content_type=str(content_type)
    precondition=str(precondition)
    
    id, title = cookId(id, title, file)

    self=self.this()

    # First, we create the file without data:
    self._setObject(id, versionedFileObject(id,title,'',content_type, precondition))
    self._getOb(id).versionComment=str(vC)
    
    # Now we "upload" the data.  By doing this in two steps, we
    # can use a database trick to make the upload more efficient.
    if file:
        self._getOb(id).manage_upload(file)
    if content_type:
        self._getOb(id).content_type=content_type

    if REQUEST is not None:
        REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')




class versionedFile(Folder):
    """Versioniertes File"""

    def __init__(self, id, title, lockedBy):
        """init"""
        self.id=id
        self.title=title
        self.lockedBy=lockedBy
        
    meta_type="versionedFile"

    def getLastVersion(self):
        """Last Version"""
        tmp=0
        lastVersion=None
        
        for version in self.ZopeFind(self):
            
            if hasattr(version[1],'versionNumber'):
                
                if int(version[1].versionNumber) > tmp:
                    tmp=int(version[1].versionNumber,)
                    lastVersion=version[1]
        return lastVersion
    
    def index_html(self):
        """main view"""
        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: %s Version:%i modified:%s size:%s modified by:%s"%(self.title,lastVersion.versionNumber,lastVersion.bobobase_modification_time(),lastVersion.getSize(),lastVersion.lastEditor())
                                                                         
    def getVersion(self):
        tmp=0
        for version in self.ZopeFind(self):
            
            if hasattr(version[1],'versionNumber'):
                
                if int(version[1].versionNumber) > tmp:
                    tmp=int(version[1].versionNumber,)
        return tmp+1

    security= ClassSecurityInfo()
    security.declareProtected('AUTHENTICATED_USER','unlock')

    def history(self):
        """history"""
        pt=PageTemplateFile('Products/versionedFile/zpt/versionHistory').__of__(self)
        return pt()

    def getVersions(self):
        """get all versions"""
        ret=[]
        for version in self.ZopeFind(self):
            if hasattr(version[1],'versionNumber'):
                ret.append((version[1].versionNumber,version[1]))
        ret.sort(sortv)
        return ret

        
    def unlock(self,RESPONSE):
        """unlock"""
        if str(self.lockedBy) in [str(self.REQUEST['AUTHENTICATED_USER'])]:
            self.lockedBy=''
            RESPONSE.redirect(self.REQUEST['URL2'])
        else:
            return "Sorry, not locked by you! (%s,%s)"%(self.lockedBy,self.REQUEST['AUTHENTICATED_USER'])
        
    security= ClassSecurityInfo()
    security.declareProtected('AUTHENTICATED_USER','addVersionedFileObjectForm')

    def addVersionedFileObjectForm(self):
        """add a new version"""
        
        if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
            return "please login first"
        if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
            out=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version=self.getVersion()).__of__(self)
            return out()
        else:
            return "Sorry file is locked by somebody else"
        
    def manage_addVersionedFileObject(self,id,vC,file='',title='',precondition='', content_type='',RESPONSE=None):
        """add"""
        
        vC=self.REQUEST['vC']
        id="V%i"%self.getVersion()+"_"+self.title
        manage_addVersionedFileObject(self,id,vC,file,"V%i"%self.getVersion()+"_"+self.title,precondition, content_type)
        objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))

        if RESPONSE:
            RESPONSE.redirect(self.REQUEST['URL2'])

    security.declareProtected('AUTHENTICATED_USER','downloadLocked')

    def downloadLocked(self):
        """download and lock"""
        if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
            return "please login first"
        if not self.lockedBy=="":
            return "cannot be locked because is already locked by %s"%self.lockedBy
        self.lockedBy=self.REQUEST['AUTHENTICATED_USER']
        
        self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
    
def manage_addVersionedFileForm(self):
    """interface for adding the OSAS_root"""
    pt=PageTemplateFile('Products/versionedFile/zpt/addVersionedFile.zpt').__of__(self)
    return pt()

def manage_addVersionedFile(self,id,title,lockedBy, RESPONSE=None):
    """add the OSAS_root"""
    newObj=versionedFile(id,title,lockedBy)
    self._setObject(id,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')


InitializeClass(versionedFile)
InitializeClass(versionedFileFolder)