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 Products.ImageArchive.ImageArchive import manage_AddImageZogiLib

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/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)

        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 Image Index.html','action':'generateIndexHTML_image'},
                {'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):
        """download help"""
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','helpDownload')).__of__(self)
        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 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 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"

    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)