Return to versionedFile.py CVS log

Up to [Repository] / versionedFile

locking texts changed and content-type for download added

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


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')
    
    manage_options = Folder.manage_options+(
		{'label':'Generate Index.html','action':'generateIndexHTML'},
                {'label':'Generate history_template.html','action':'generateHistoryHTML'},
		)

    def generateIndexHTML(self,RESPONSE=None):
        """lege standard index.html an"""

        

        
        if not hasattr(self,'index.html'):
            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 generateHistoryHTML(self,RESPONSE=None):
        """lege standard index.html an"""

        

        
        if not hasattr(self,'history_template.html'):
            zt=ZopePageTemplate('history_template.html')
            self._setObject('history_template.html',zt)
            default_content_fn = os.path.join(package_home(globals()),
                                               'zpt/versionHistory.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 getVersionedFiles(self):
        """get all versioned files"""
        
	versionedFiles=self.ZopeFind(self,obj_metatypes=['versionedFile'])
       
        return versionedFiles


    def header_html(self):
        """zusätzlicher header"""
        ext=self.ZopeFind(self,obj_ids=["header.html"])
        if ext:
            return ext[0][1]()
        else:
            return ""
        
    def index_html(self):
        """main"""
        ext=self.ZopeFind(self,obj_ids=["index.html"])
        if ext:
            return ext[0][1]()
        
        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,author,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,author,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 download(self):
        """download and lock"""
        
        
        self.content_type="octet/stream"
        self.REQUEST.RESPONSE.redirect(self.absolute_url())
    
    def downloadLocked(self):
        """download and lock"""
        
        
        if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
            return "please login first"
        if not self.aq_parent.lockedBy=="":
            return "cannot be locked because is already locked by %s"%self.lockedBy
        self.aq_parent.lockedBy=self.REQUEST['AUTHENTICATED_USER']

        self.content_type="octet/stream"
        self.REQUEST.RESPONSE.redirect(self.absolute_url())
    
    def setVersionNumber(self,versionNumber):
        """set version"""
        self.versionNumber=versionNumber

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

    def lastEditor(self):
        """last Editor"""
        if hasattr(self,'author'):
            return self.author            
        else:
            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='',author='', 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)
    setattr(self._getOb(id),'author',author)
    
    # 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,author):
        """init"""
        self.id=id
        self.title=title
        self.lockedBy=lockedBy
        self.author=author
        
    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"""  

        ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
        if ext:
            return getattr(self,ext[0][1].getId())()
        
        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,author,file='',title='',precondition='', content_type='',changeName='no',RESPONSE=None):
        """add"""
        
        vC=self.REQUEST['vC']
        author=self.REQUEST['author']
        
        if changeName=="yes":
            self.title=file.filename[0:]


        id="V%i"%self.getVersion()+"_"+self.title
        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()))

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

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

    def download(self):
        """download and lock"""
        self.getLastVersion().content_type="octet/stream"
        self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
    
    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.getLastVersion().content_type="octet/stream"
        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, author=None, RESPONSE=None):
    """add the OSAS_root"""
    newObj=versionedFile(id,title,lockedBy,author)
    self._setObject(id,newObj)
   
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')


InitializeClass(versionedFile)
InitializeClass(versionedFileFolder)