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

from threading import Thread
import shutil
import tempfile
import os.path

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):
    return cmp(x[0],y[0])
tdir = "/tmp/testia"

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: gettung 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):
    """Folder with versioned files"""

    
    meta_type = "versionedFileFolder"

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

    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 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
        
                       
        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" """%"donloadFileFolder.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):
        """download help"""
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','helpDownload')).__of__(self)
        return pt()
    
    def generateIndexHTML(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.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 self.ZopeFind(self,obj_ids=['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,sortField='title'):
        """get all versioned files"""

        def sortName(x,y):
            return cmp(x[1].title.lower(),y[1].title.lower())

        def sortDate(x,y):
            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):
            
            return cmp(x[1].getLastVersion().lastEditor().lower(),y[1].getLastVersion().lastEditor().lower())
        
	versionedFiles=self.ZopeFind(self,obj_metatypes=['versionedFile'])

        if sortField=='title':
            versionedFiles.sort(sortName)
        elif sortField=='date':
            versionedFiles.sort(sortDate)
        elif sortField=='author':
            versionedFiles.sort(sortAuthor)
        elif sortField=='comment':
            versionedFiles.sort(sortComment)

        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(os.path.join(package_home(globals()),'zpt','versionFileFolderMain')).__of__(self)
        return pt()


    def addFileForm(self):
        """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)
        return out()


    def addFile(self,vC,file,author,newName='',content_type='',RESPONSE=None):
        """ add a new file"""
        if newName=='':
            filename=file.filename
            id=filename[max(filename.rfind('/'),
                                    filename.rfind('\\'),
                                    filename.rfind(':'),
                                    )+1:]

        else:
            id=newName
        
        vC=self.REQUEST.form['vC']
        manage_addVersionedFile(self,id,'','')
        #if (getattr(self,'commentNonEmpty',0)==1) and vC.strip()=="":
            
            
        ob=self._getOb(id)
        ob.title=id
        file2=file
        
        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'])
        
        
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 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):
        """getTime"""
        #return self.bobobase_modification_time().ISO()
        if hasattr(self,'time'):
            return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
	elif hasattr(self,'timefixed'):
	    return self.timefixed
        else:
	    setattr(self,'timefixed',self.bobobase_modification_time().ISO())
            return self.bobobase_modification_time().ISO()



    

    def download(self):
        """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.REQUEST.RESPONSE.redirect(self.absolute_url())
        self.REQUEST.RESPONSE.write(self.index_html())
        #self.REQUEST.RESPONSE.write("bl")
        self.REQUEST.close()
    
    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="application/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'):
            ret=self.author.replace("-","\n")
            ret=ret.replace("\r","\n")
            return ret

        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)
    self._getOb(id).time=time.localtime()
    
    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

    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"

    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):
        """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.getTime(),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(os.path.join(package_home(globals()),'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

    security.declareProtected('AUTHENTICATED_USER','forceunlock')   
    def forceunlock(self,RESPONSE):
        """unlock"""
        self.lockedBy=''

    security.declareProtected('AUTHENTICATED_USER','unlock')   
    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.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',newName='', RESPONSE=None):
        """add"""
        try: #der ganze vC unsinn muss ueberarbeitet werden
            vC=self.REQUEST['vC']
        except:
            pass
        
        author=self.REQUEST['author']
        
        if changeName=="yes":
            filename=file.filename
            self.title=filename[max(filename.rfind('/'),
                        filename.rfind('\\'),
                        filename.rfind(':'),
                        )+1:]


        if not newName=='':
            self.title=newName[0:]
        print 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)
        objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
        self.REQUEST.SESSION['objID_parent']=self.getId()

        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'])

        else:
            return self.ZopeFind(self,obj_ids=[id])[0][1]
        
    security.declareProtected('AUTHENTICATED_USER','downloadLocked')

    def download(self):
        """download and lock"""

        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):
        """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="application/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(os.path.join(package_home(globals()),'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)