Return to cdli_files.py CVS log

Up to [Repository] / cdli

basked, locking upload

"""CDLI extensions of the filearchive"""
from Products.versionedFile.versionedFile import *
from Products.ZCatalog.CatalogPathAwareness import CatalogAware
from tempfile import mkstemp,mkdtemp
import os.path
import os
from types import *

class Basket(Folder):
    """shopping basket"""
    
    meta_type="Basket"
    _v_stack={}

    def storeAllLink(self,results):
        """erzeuge link zum speicher aller results"""
        nr=self.REQUEST['_ZopeId']
        
        if results:
            self._v_stack[nr]=[x.getObject().getId() for x in results]
        
        return self.absolute_url()+"/storeAll?id="+nr
    
    def storeAll(self,id):
        """store all"""
        try:
            results=self._v_stack[id]
        except:
            #TODO: write expired page
            return "expired"
        
        return self.storeInBasketForm(results)
        
    def storeInBasketForm(self,ids):
        """ store an object form"""
        
        if type(ids) is not ListType:
            ids=[ids]
        self.REQUEST.SESSION['ids']=ids[0:]
        
        self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']

        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)
        return pt()
        
    def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):
        """store it"""
        
        if not ids:
            ids=REQUEST.SESSION['ids']
            
        self.REQUEST.SESSION['basketUser']=username
        
        baskets=self.ZopeFind(self,obj_ids=[username])
        if len(baskets)>0:
            basket=baskets[0][1]
        else:
            manage_addBasketObject(self,username)
            basket=self._getOb(username)
        
        
        basket.addObjects(ids)
        back=self.REQUEST.SESSION.get('BACKLINK', None)

        if RESPONSE:
            RESPONSE.redirect(back)
            

    
    def showBasket(self,user=None,set=None,RESPONSE=None):
        """show the basket"""
        
        if user:
            self.REQUEST.SESSION['basketUser']=user
        
        if not user and not set:
            user=self.REQUEST.SESSION.get('basketUser',None)
        
        if not user:
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','authorizeBasketUser.zpt')).__of__(self)
            return pt()
        else:
            baskets=self.ZopeFind(self,obj_ids=[user])
        

        if len(baskets)>0:
            RESPONSE.redirect(baskets[0][1].absolute_url())
            return True 
        else:
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)
            return pt()
        

def manage_addBasketForm(self):
    """add the basket form"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
    return pt()

def manage_addBasket(self,id,title,RESPONSE=None):
    """add the basket"""
    ob=Basket()
    
    ob.id=str(id)
    ob.title=title
    self._setObject(id, ob)
    ob=self._getOb(id)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

    
class BasketObject(Folder):
    """Basket Object"""
    
    meta_type="basketObject"
    def __init__(self):
        	"""init basket object"""
        	self.contents=[]

    def numberOfItems(self):
        """return anzahl der elemente im basket"""
        return len(self.contents)
    
    def addObjects(self,ids):
        """addObjects"""
        
        for id in ids:
            founds=self.CDLICatalog.search({'path':id})
            for found in founds:
                if found.getObject() not in self.contents:
                    tm=self.contents[0:]
                    tm.append(found.getObject())
                    self.contents=tm[0:]
    
        return True

    def index_html(self):
        	"""view the basket"""
        	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
        	return pt()

    def deleteObjects(self,ids,RESPONSE=None):
        """delete objects"""
        list = self.contents[0:]
        for content in list:
               
                if content.getId() in ids:
                    self.contents.remove(content)
        

        if RESPONSE:
        	    RESPONSE.redirect(self.absolute_url())


    def unlockTest(self):
        """unlock all files of the testuser for debuggin"""
        for object in self.contents:

                if str(object.lockedBy)=="test":
                    object.lockedBy=""
            
    def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
        """download all selected files in one file"""
        
        ret=""
        lockedObjects={}
        

        if lock:
            
            if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
                
                return "please login first"

            #check if a locked object exist in the basket.
            lockedObjects={}
            for object in self.contents:

                if not object.lockedBy=="":
                    lockedObjects[object.title]=repr(object.lockedBy)
                   
                    
            keys=lockedObjects.keys()
            
            
            if len(keys)>0 and (not procedure):
                self.REQUEST.SESSION['lockedObjects']=lockedObjects
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
                return pt()
         
            elif not procedure: #keine fails gesperrt dann alle donwloaden
                procedure="downloadAll" 
        
        print procedure    
        for object in self.contents:
            
                if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
                    ret+=object.getLastVersion().data
                
                if lock and object.lockedBy=='':
                    object.lockedBy=self.REQUEST['AUTHENTICATED_USER']


        self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())
        self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
        length=len(ret)
        self.REQUEST.RESPONSE.setHeader("Content-Length",length)
        self.REQUEST.RESPONSE.write(ret)    
        
        
def manage_addBasketObjectForm(self):
    """add form"""
    pass

def manage_addBasketObject(self,id,title='',RESPONSE=None):
    """add"""
    
    ob=BasketObject()
    
    ob.id=str(id)
    ob.title=title
    self._setObject(id, ob)
    ob=self._getOb(id)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

    
class CDLIFile(versionedFile,CatalogAware):
    """CDLI file"""
    
    meta_type="CDLI file"
    default_catalog='CDLICatalog'

    
        
def manage_addCDLIFileForm(self):
    """interface for adding the OSAS_root"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
    return pt()

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


class CDLIFileObject(versionedFileObject):
    """CDLI file object"""
    
    meta_type="CDLI File Object"
    
    def view(self):
        """view file"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
        return pt()
    
manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')

def manage_addCDLIFileObject(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, CDLIFileObject(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')


def splitatf(fh,dir=None):
    """split it"""
    
    nf=None
    for line in fh.readlines():
       
        if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
            if nf:
                nf.close() #close last file
        
            
            filename=line[1:].split("=")[0].rstrip()+".atf"
            if dir:
                filename=os.path.join(dir,filename)
            nf=file(filename,"w")
            
        nf.write(line)
    
    nf.close()
    fh.close()
    
class CDLIFileFolder(versionedFileFolder):
    """CDLI folder"""
    
    meta_type="CDLI Folder"
    filesMetaType=['CDLI file']
    folderMetaType=['CDLI Folder']
    default_catalog='CDLICatalog'
    
    def uploadATF(self,upload,comment="",RESPONSE=None):
        """upload an atf file"""
        #TODO: finish uploadATF
        dir=mkdtemp()
        changed=[]
        errors=[]
        splitatf(upload,dir)

        for fn in os.listdir(dir):
            founds=self.CDLICatalog.search({'path':fn})    
    
            for found in founds:
                obj=found.getObject()
       
                if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
                    errors.append(obj)
                else:
                    data=file(os.path.join(dir,fn)).read()
                    diffs=obj.diff(data)
                    if diffs[0]>0:
                        changed.append((obj,diffs))
                        #hochladen
        
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
        return pt(changed=changed,errors=errors,dir=dir)
                    
        
        
    def findObjectsFromList(self,upload,RESPONSE):
        """findObjectsFromList (, TAB oder LINE separated)"""
        txt=upload.read()
        txt=txt.replace(",","\n")
        txt=txt.replace("\t","\n")
        idsTmp=txt.split("\n")
        ids=[]
        for id in idsTmp: # make sure that no empty lines
            idTmp=id.lstrip().rstrip()
            if len(idTmp)>0:
                ids.append(idTmp)
        #self.REQUEST.SESSION['ids']=" OR ".join(ids)
        
        RESPONSE.redirect("filelist.html?path=%s"%" OR ".join(ids))
    
    def createAllFilesAsSingleFile(self,RESPONSE=None):
        """download all files"""
        
        def sortF(x,y):
            return cmp(x[0],y[0])
        
        catalog=getattr(self,self.default_catalog)
        #tf,tfilename=mkstemp()
        
        
        list=[(x.getId,x) for x in catalog()]
        list.sort(sortF)
        
        RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
        RESPONSE.setHeader("Content-Type","application/octet-stream")
       
        for l in list:
            obj=l[1].getObject()
            
            if obj.meta_type=="CDLI file":
                
                #os.write(tf,obj.getLastVersion().data)
                if RESPONSE:
                    RESPONSE.write(obj.getLastVersion().data)
        #os.close(tf)
        #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
        return True
    
    def downloadFile(self,fn):
        """download fn - not used yet"""
        self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
        self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
        self.REQUEST.RESPONSE.write(file(fn).read())
        
      
                
    def hasParent(self):
        """returns true falls subfolder"""
      
        if self.aq_parent.meta_type in self.folderMetaType:
            return True
        else:
            return False
        
    def getFolders(self):
        """get all subfolders"""
        ret=[]
        folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
        for folder in folders:
            ret.append((folder[1],
                        len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
                        len(self.ZopeFind(folder[1],obj_metatypes=self.filesMetaType))
                        ))
        return ret
    
            
    def getFolders_OLD(self):
        """get all subfolders"""
        ret=[]
        folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
        for folder in folders:
            ret.append((folder[1],
                        len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
                        len(getattr(self,self.default_catalog)({'path':folder[0]}))
                        ))
        return ret
    
    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','CDLIFileFolderMain')).__of__(self)
        return pt()
    
    def importFiles(self,comment="",author="" ):
        """import files"""
        folderName="/Users/dwinter/Documents/workspace/cdli/atf"
        
        files=os.listdir(folderName)
        for f in files:
            folder=f[0:3]
            f2=f[0:5]
            obj=self.ZopeFind(self,obj_ids=[folder])
            
            if not obj:
                manage_addCDLIFileFolder(self,folder,folder)
                fobj=getattr(self,folder)
        
            else:
                fobj=obj[0][1]
            
            obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
        
            if not obj2:
                manage_addCDLIFileFolder(fobj,f2,f2)
                fobj2=getattr(fobj,f2)
        
            else:
                fobj2=obj2[0][1]
              
            print f
            file2=file(os.path.join(folderName,f))   
            id=f
            manage_addCDLIFile(fobj2,f,'','')
            id=f
            ob=fobj2._getOb(f)
            ob.title=id
            
            manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')
    
        return "ok"
manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())

    
def manage_addCDLIFileFolder(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=CDLIFileFolder()
    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)