[BACK]Return to cdli_files.py CVS log [TXT] [DIR] Up to [Repository] / cdli

Diff for /cdli/cdli_files.py between versions 1.3 and 1.27

version 1.3, 2005/12/08 17:11:31 version 1.27, 2006/06/17 15:03:19
Line 6  import os.path Line 6  import os.path
 import os  import os
 from types import *  from types import *
 import urlparse  import urlparse
   from OFS.OrderedFolder import OrderedFolder
   from OFS.SimpleItem import SimpleItem
   import time
   from OFS.Folder import manage_addFolder
   import re
   from AccessControl import ClassSecurityInfo
   from Acquisition import Implicit
   from threading import Thread
   from ZPublisher.HTTPRequest import HTTPRequest
   from ZPublisher.HTTPResponse import HTTPResponse
   from ZPublisher.BaseRequest import RequestContainer
   import threading
   
 class Basket(Folder):  
     """shopping basket"""  
   class uploadATFfinallyThread(Thread):
       """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
       
       def __init__(self):
           """init for uploadATFfinallyThread"""
           self.continueVar=True
           self.returnValue=None
           self.end=False
           Thread.__init__(self)
              
       def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):
           """set start values for the thread"""
           self.procedure=procedure
           self.comment=comment
           self.basketname=basketname
           self.unlock=unlock
           self.SESSION=SESSION
           self.username=username
           self.serverport=serverport
           
       def __call__(self):
           """call of the thread (equals run)"""
           self.run()
           return True
       
       def getContext(self, app,serverport="8080"):
           """get the context within the ZODB"""
           
           resp = HTTPResponse(stdout=None)
           env = {
               'SERVER_NAME':'localhost',
               'SERVER_PORT':serverport,
               'REQUEST_METHOD':'GET'
               }
           req = HTTPRequest(None, env, resp)
           return app.__of__(RequestContainer(REQUEST = req))
             
           
       def run(self):
           """run"""
           
           self.result=""
           #find context within ZODB
           from Zope import DB
           conn = DB.open()
           root = conn.root()
           app  = root['Application']
           ctx = self.getContext(app,serverport=self.serverport)
   
           #add the files
           self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
           #commit the transactions
           get_transaction().commit()
           conn.close()
           #set flag for end of this method
           self.end=True
           return True
       
       def __del__(self):
           """delete"""
           
           
       
       def getResult(self):
           """method for accessing result"""
           
           return self.result
        
       def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
           """upload the files"""
           #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
           ctx2=ctx.cdliRoot
      
           self.result+="<h2>Start processing</h2>"
           
           #shall I only upload the changed files?
           if procedure=="uploadchanged":
         
               uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])
           
           #or all
           elif procedure=="uploadAll":
               uploadFns=[]
               for x in os.listdir(SESSION['tmpdir']):
                   if not x in SESSION['errors']:
                       uploadFns.append(x)
                       
           #or maybe nothing
           elif procedure=="noupload":
                           return True
           else:
               uploadFns=[]
               
           #do first the changed files    
           for fn in uploadFns:
               founds=ctx2.CDLICatalog.search({'title':fn})
               if len(founds)>0:
                   SESSION['author']=str(username)
                   self.result+="<p>Changing : %s"%fn
                   founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=file(os.path.join(SESSION['tmpdir'],fn)))
               
           
           #now add the new files        
           newPs=SESSION['newPs']
           if len(newPs)>0:
               tmpDir=SESSION['tmpdir']
               self.result+="<p>Adding files</p>"
               #TODO: make this configurable, at the moment base folder for the files has to be cdli_main
               
               ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
                   
           
           
           #unlock locked files?
           if unlock:
               self.result+="<p>Unlock files</p>"
               unlockFns=[]
               for x in os.listdir(SESSION['tmpdir']):
                       if not x in SESSION['errors']:
                           unlockFns.append(x)
               
               for fn in unlockFns:
                   founds=ctx2.CDLICatalog.search({'title':fn})
                   if len(founds)>0:
                       SESSION['author']=str(username)
                      
                       founds[0].getObject().lockedBy=""
                       
           #if a basketname is give, add files to the basket
           if not (basketname ==''):
               self.result+="<p>Add basket</p>"
               basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
               
               if not basketId: # create new basket
                   ob=ctx2.basketContainer.addBasket(basketname)
                   basketId=ob.getId()
               basket=getattr(ctx2.basketContainer,str(basketId))
               ids=os.listdir(SESSION['tmpdir'])
               basket.addObjects(ids,deleteOld=True,username=str(username))    
                  
           if RESPONSE is not None:
               RESPONSE.redirect(self.aq_parent.absolute_url())
           
   
          
           return True
       
   class uploadATFThread(Thread):
       """class for checking the files befor uploading"""
       
       def __init__(self):
           """initialise"""
           
           self.continueVar=True
           self.returnValue=None
           
           Thread.__init__(self)
           
           
       def set(self,upload,basketId,username,serverport="8080"):
           """set start values for the thread"""
           self.result=""
           self.upload=upload
           self.basketId=basketId
           self.username=username
           self.serverport=serverport
           
       def __call__(self):
           """call method """
           self.run()
           return True
       
       def getContext(self, app,serverport="8080"):
           """get the context within the ZODB"""
           resp = HTTPResponse(stdout=None)
           env = {
               'SERVER_NAME':'localhost',
               'SERVER_PORT':serverport,
               'REQUEST_METHOD':'GET'
               }
           req = HTTPRequest(None, env, resp)
           return app.__of__(RequestContainer(REQUEST = req))
           
       def run(self):
        
           self.result=""
           #find context within ZODB
           from Zope import DB
           conn = DB.open()
           root = conn.root()
           app  = root['Application']
           ctx = self.getContext(app,serverport=self.serverport)
           self.uploadATFThread(ctx,self.upload,self.basketId)
        
           ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
   
           get_transaction().commit()
           
           while self.continueVar:
               pass
           
           conn.close()
           
           
       def getResult(self):
           """method for accessing result"""
           return self.result
       
       def uploadATFThread(self,ctx,upload,basketId=0):
           """upload an atf file"""
           #TODO: add comments
           #TODO: finish uploadATF
           self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"
       
           #make sure that id is a string and not an integer
           basketId=str(basketId)
           
           #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
           ctx2=ctx.cdliRoot
           
           #get temporary file for staging the downloaded and splitted files
           dir=mkdtemp()
           
           
           changed=[] # changed files
           errors=[]  # files with errors
           newPs=[]   # new p filed
           psNotInCatalog=[] # files not in the catalog
           
           #split the uploadedd atf file
           basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)
           
           #find basketId if not set
           
           #get active abaket
           if basketId == '0':
               basketObj=ctx2.basketContainer.getActiveBasket()
               if basketObj:
                   basketId=basketObj.getId()
                   
           #if there is no active baske and no basketid given, id is empty, else get besketname and length
           if basketId == '0':
               basketNameFromId=""
               basketLen=0
           else:
               basketNameFromId=getattr(ctx2.basketContainer,basketId).title
               basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
               
           
           self.result+="""<html><body><h2>I got the files</h2><
                           p>I am computing the differences to the exisiting files</p>"""
                                      
           #start to check the files
           for fn in os.listdir(dir):
               
               self.result+="<p>process:%s</p>"%fn
               
               # check if file is in the catalog
               #TODO: checkCatalog is not implemented yet
               if ctx2.cdli_main.checkCatalog(fn):
                   psNotInCatalog.append(fn)
                   
               #check if p-file already at the server  
               founds=ctx2.CDLICatalog.search({'title':fn})    
         
               #if not than add filename to the list of newfiles
               if len(founds)==0:
                   newPs.append(fn)
               
               #if p file alread at the server    
               for found in founds:
                   #analyse the differences to the actual file
                   obj=found.getObject()
          
                   if (not obj.lockedBy=='') and (not obj.lockedBy==self.username):
                       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
           
           #ready, set the returnValues
           self.result+="<h3>Done</h3></body></html>"
           
           self.returnValue={}
           self.returnValue['changed']=changed
           self.returnValue['errors']=errors
           self.returnValue['newPs']=newPs
           self.returnValue['tmpdir']=dir
           self.returnValue['basketLen']=basketLen
           self.returnValue['numberOfFiles']=numberOfFiles
           self.returnValue['basketNameFromId']=basketNameFromId
           self.returnValue['basketNameFromFile']=basketNameFromFile
           self.returnValue['basketId']=basketId
           self.returnValue['dir']=dir
           
           #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
       
           
   class Basket_old(Folder):
       """shopping basket - alte fassung """
           
     meta_type="Basket"      meta_type="Basket"
     _v_stack={}      _v_stack={}
   
     def getObjUrl(self,objId):      def getObjUrl(self,objId):
         """getUrl"""          """getUrl"""
         founds=self.CDLICatalog.search({'path':objId})          founds=self.CDLICatalog.search({'title':objId})
         if len(founds)>0:          if len(founds)>0:
              return founds[0].getObject().absolute_url()               return founds[0].getObject().absolute_url()
                     
         else: #assume version          else: #assume version number
             splitted=objId.split("_")              splitted=objId.split("_")
             founds=self.CDLICatalog.search({'path':splitted[1]})                      founds=self.CDLICatalog.search({'title':splitted[1]})        
             return founds[0].getObject().absolute_url()+'/'+objId              return founds[0].getObject().absolute_url()+'/'+objId
                   
     def storeAllLink(self,results):      def storeAllLink(self,results):
Line 89  class Basket(Folder): Line 404  class Basket(Folder):
             user=self.REQUEST.SESSION.get('basketUser',None)              user=self.REQUEST.SESSION.get('basketUser',None)
                   
         if not user:          if not user:
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','authorizeBasketUser.zpt')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)
             return pt()              return pt()
         else:          else:
             baskets=self.ZopeFind(self,obj_ids=[user])              baskets=self.ZopeFind(self,obj_ids=[user])
Line 103  class Basket(Folder): Line 418  class Basket(Folder):
             return pt()              return pt()
                   
   
 def manage_addBasketForm(self):  def manage_addBasket_oldForm(self):
     """add the basket form"""      """add the basket form"""
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_addBasket(self,id,title,RESPONSE=None):  def manage_addBasket_old(self,id,title,RESPONSE=None):
     """add the basket"""      """add the basket"""
     ob=Basket()      ob=Basket()
           
Line 121  def manage_addBasket(self,id,title,RESPO Line 436  def manage_addBasket(self,id,title,RESPO
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
           
 class BasketObject(Folder):  class BasketObject_old(Folder):
     """Basket Object"""      """Basket Object - alte fassung"""
           
     meta_type="basketObject"      meta_type="basketObject"
     def __init__(self):      def __init__(self):
Line 137  class BasketObject(Folder): Line 452  class BasketObject(Folder):
         """addObjects"""          """addObjects"""
                   
         for id in ids:          for id in ids:
             founds=self.CDLICatalog.search({'path':id})              founds=self.CDLICatalog.search({'title':id})
             for found in founds:              for found in founds:
                 if found.getObject() not in self.contents:                  if found.getObject() not in self.contents:
                     tm=self.contents[0:]                      tm=self.contents[0:]
Line 203  class BasketObject(Folder): Line 518  class BasketObject(Folder):
             elif not procedure: #keine fails gesperrt dann alle donwloaden              elif not procedure: #keine fails gesperrt dann alle donwloaden
                 procedure="downloadAll"                   procedure="downloadAll" 
                   
         print procedure      
         for object in self.contents:          for object in self.contents:
                           
                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):                  if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
Line 220  class BasketObject(Folder): Line 535  class BasketObject(Folder):
         self.REQUEST.RESPONSE.write(ret)              self.REQUEST.RESPONSE.write(ret)    
                   
                   
 def manage_addBasketObjectForm(self):  def manage_addBasket_oldObjectForm(self):
     """add form"""      """add form"""
     pass      pass
   
 def manage_addBasketObject(self,id,title='',RESPONSE=None):  def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):
     """add"""      """add"""
           
     ob=BasketObject()      ob=BasketObject()
Line 237  def manage_addBasketObject(self,id,title Line 552  def manage_addBasketObject(self,id,title
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
 class CDLIFileObject(versionedFileObject):  
   class CDLIBasketContainer(OrderedFolder):
       """contains the baskets"""
       
   
       security=ClassSecurityInfo()
       meta_type="CDLIBasketContainer"
       
       def deleteBaskets(self,ids=None):
           """delete baskets, i.e. move them into trash folder"""
           
           
           found=self.ZopeFind(self,obj_ids=['trash'])
           
           if len(found)<1:
               manage_addFolder(self, 'trash')
               trash=self._getOb('trash')
           else:
               trash=found[0][1]
           
           if type(ids) is not ListType:
               ids=[ids]
           cut=self.manage_cutObjects(ids)
           trash.manage_pasteObjects(cut)
           
       def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):
           """manage baskets, delete or copy"""
           if submit=="delete":
               self.deleteBaskets(ids)
           
          
               
           if RESPONSE:
               RESPONSE.redirect(self.absolute_url())
       def getBasketIdfromName(self,basketname):
           """get id from name"""
   
           for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):
               if basket[1].title==basketname:
                   return basket[0]
           else:
               None
       
       security.declareProtected('manage','uploadBasket_html')        
               
       def uploadBasket_html(self,basketId='0'):
           """upload an atf file, html form"""
           
   
           basketId=str(basketId)
           if not basketId=='0':
               basketName=getattr(self.basketContainer,basketId).title
           else:
               basketName=""
               
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)
           return pt(basketId=basketId,basketName=basketName)
      
   
           
       def index_html(self):
           """stanadard ansicht"""
           
   
   
           ext=self.ZopeFind(self,obj_ids=["index.html"])
           if ext:
               return ext[0][1]()
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)
           return pt()
       
       def getStorageFolderRoot(self):
           """root des storage folders"""
           return self.cdli_main
       
       def __init__(self,id,title):
           """ init basket container"""
           self.id=id
           self.title=title
        
        
       def getBaskets(self,sortField='title'):
           """get all baskets 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().getComment().lower()
                    except:
                        xc='ZZZZZZZZZZZZZ'.lower()
                        
                if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
                    try:
                        yc=y[1].getLastVersion().getComment().lower()
                    except:
                        yc='ZZZZZZZZZZZZZ'.lower()
       
                
                    return cmp(xc,yc)
           
           def sortAuthor(x,y):
               
               return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())
           
           baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
           
           
           if sortField=='title':
               baskets.sort(sortName)
           elif sortField=='date':
               baskets.sort(sortDate)
           elif sortField=='author':
               baskets.sort(sortAuthor)
           elif sortField=='comment':
               baskets.sort(sortComment)
   
           return baskets
   
   
                          
       def getNewId(self):
           """createIds"""
           last=getattr(self,'last',0)
           last +=1
           while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
               last+=1
       
           self.last=last
           return last
       
       def setActiveBasket(self,basketId,REQUEST=None):
           """store active basketId in a cookie"""
           self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
           
           if REQUEST:
               REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+REQUEST['QUERY_STRING'])
               
       def getActiveBasket(self):
           """get active basket from cookie"""
           
           id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
           if id:
               obj=getattr(self,str(id),None)
           else:
               obj=None
           return obj
       
       def getActualUserName(self):
           """get name of the actualuser"""
           return str(self.REQUEST['AUTHENTICATED_USER'])
       
       
       def addBasket(self,newBasketName):
           """add a new basket"""
           
           ob=manage_addCDLIBasket(self,newBasketName)
           return ob
       
       def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):
           """store it"""
           if not ids:
               ids=self.REQUEST.SESSION['fileIds']
               
           if type(ids) is not ListType:
               ids=[ids]
           
           if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
               basketRet=self.addBasket(newBasketName)
               self.setActiveBasket(basketRet.getId())
               basket=getattr(self,basketRet.getId())
           elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):
               basket=self.getActiveBasket()
           
           added=basket.addObjects(ids)
           back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)
           
           
           if fromFileList:
   
               return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)
          
           if RESPONSE:
               
               RESPONSE.redirect(back)
               
           return True
       
   def manage_addCDLIBasketContainerForm(self):
       """add the CDLIBasketContainer form"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)
       return pt()
   
   def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):
       """add the basket"""
       ob=CDLIBasketContainer(id,title)
       
       self._setObject(id, ob)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   class CDLIBasket(Folder,CatalogAware):
       """basket"""
       
       meta_type="CDLIBasket"
       default_catalog="CDLIBasketCatalog"
       
       def getFile(self,obj):
           return obj[1]
       
       def getFileLastVersion(self,obj):
           return obj[0]
       
       def getFileNamesInLastVersion(self):
           """get content of the last version as list"""
           
           return [x[1].getId() for x in self.getLastVersion().getContent()]
       
       def isActual(self,obj):
           """teste ob im basket die aktuelle version ist"""
           actualNo=obj[1].getLastVersion().getVersionNumber()
           storedNo=obj[0].getVersionNumber()
           
           founds=self.CDLICatalog.search({'title':obj[0].getId()})
           if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
               return False, -1
           
           if actualNo==storedNo:
               return True , 0
           else:
               return False, actualNo
           
       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','BasketHistory')).__of__(self)
           return pt()
       
       def getStorageFolderRoot(self):
           """root des storage folders"""
           return self.aq_parent.cdli_main
       
       def __init__(self,id,title,shortDescription="",comment=""):
           """init a CDLIBasket"""
           
           self.id=id
           self.title=title
           self.shortDescription=shortDescription
           self.comment=comment
    
      
              
       def getLastVersion(self):
           """hole letzte version"""
           ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])]
           ids.sort()
           if len(ids)==0:
               return None
           else:    
               ob=getattr(self,str(ids[-1]))
               return ob
      
       def getVersions(self):
           """get versions"""
           versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])
           return versions
   
      
       
       def addObjects(self,ids,deleteOld=None,username=None):
           """generate a new version of the basket with objects added"""
          
           lastVersion=self.getLastVersion()
           
           if lastVersion is None:
               oldContent=[]
           else:
               oldContent=lastVersion.basketContent[0:]
   
           if deleteOld:
               oldContent=[]
   
           newContent=[]
           added=0
           for id in ids:
               founds=self.CDLICatalog.search({'title':id})
   
               for found in founds:
                   if found.getObject() not in oldContent:
                       #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
                       newContent.append((found.getObject().getLastVersion(),found.getObject()))
                       added+=1
   
           content=oldContent+newContent
           if not username:
               user=self.getActualUserName()
           else:
               user = username
               
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
       
           return added
       
       def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
           """delete objects"""
           
           if type(ids) is not ListType:
               ids=[ids]
          
           lastVersion=self.getLastVersion() 
           oldContent=lastVersion.basketContent[0:]
           newContent=[]
           for obj in oldContent:
               if obj[1].getId() not in ids:
                   newContent.append(obj)
           
                   
           user=self.getActualUserName()
           
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
           
           if RESPONSE:
               obj=self._getOb(ob.getId())
               RESPONSE.redirect(obj.absolute_url())
           
   def manage_addCDLIBasketForm(self):
       """add the CDLIBasketContainer form"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)
       return pt()
   
   def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):
       """add the basket"""
       
       id=str(self.getNewId())
       
       ob=CDLIBasket(id,title,shortDescription,comment)
       
       self._setObject(id, ob)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
       else:
           return ob
   
   class CDLIBasketVersion(SimpleItem):
       """version of a basket"""
       
       meta_type="CDLIBasketVersion"
       
       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.basketContent:
   
                   if not object[1].lockedBy=="":
                       lockedObjects[object[1].title]=repr(object[1].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" 
           
   
           for object in self.basketContent:
               
                   if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):
                       ret+=object[0].data
                   
                   if lock and object[1].lockedBy=='':
                       object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
   
           basket_name=self.aq_parent.title+"_V"+self.getId()
           
           #write basketname to header of atf file
           ret="#atf basket %s\n"%basket_name+ret
           
           self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
           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 numberOfItems(self):
           """return anzahl der elemente im basket"""
           return len(self.basketContent)
       
       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 getContent(self):
           """get Basket Content"""
           return self.basketContent
   
       
       def __init__(self,id,user,comment="",basketContent=[]):
           """ init a basket version"""
           self.id=id
           self.coment=comment
           self.basketContent=basketContent[0:]
           self.user=user
           self.time=time.localtime()
           
       def getUser(self):
           """get user"""
           return self.user
       
       def getComment(self):
           """get Comment"""
           return self.comment
    
       def index_html(self):
               """view the basket"""
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
               return pt()
        
       def getObjUrl(self,result):
           """getUrl of the version of the object"""
           objId=result[1].getTitle()
           founds=self.CDLICatalog.search({'title':objId})
           if len(founds)>0:
                return founds[0].getObject().getLastVersion().absolute_url()
            
           else: #assume version number
               splitted=objId.split("_")
               founds=self.CDLICatalog.search({'title':splitted[1]})        
               return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId
      
   def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
       """add a version"""
       
       #check for already existing versions
    
       lastVersion=self.getLastVersion()
       if lastVersion is None:
           newId=str(1)
       else:
           newId=str(int(lastVersion.getId())+1)
       
       ob=CDLIBasketVersion(newId,user,comment,basketContent)
       
       self._setObject(newId, ob)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
       else:
           return ob
       
   class CDLIFileObject(versionedFileObject,CatalogAware):
     """CDLI file object"""      """CDLI file object"""
           
     meta_type="CDLI File Object"      meta_type="CDLI File Object"
       default_catalog='CDLIObjectsCatalog'
       
       security=ClassSecurityInfo()
       
           
       security.declarePublic('makeThisVersionCurrent')
       
       def makeThisVersionCurrent_html(self):
           """form for making this version current"""
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
           return pt()                 
       def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
           """copy this version to current"""
           parent=self.aq_parent
           
           
           newversion=parent.manage_addCDLIFileObject('',comment,author)
           newversion.data=self.data[0:]
                                           
           if RESPONSE is not None:
               RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
   
   
           return True
       
       security.declarePublic('view')
                   
     def view(self):      def view(self):
         """view file"""          """view file"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
         return pt()          return pt()
           
       security.declarePublic('getDesignation')
       def getDesignation(self):
           """get the designation out of the file"""
           try:
                   txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.data[0:])
           except:
                   txt=self.data[0:]
                   
                   return "ERROR"
           try:
               return txt.group(2)
           except:
               return "ERROR"
           
 manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')  manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
   
 def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',  def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
Line 288  class CDLIFile(versionedFile,CatalogAwar Line 1145  class CDLIFile(versionedFile,CatalogAwar
     meta_type="CDLI file"      meta_type="CDLI file"
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
   
       #security.declarePublic('history')
       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 isContainedInBaskets(self,context=None):
           """check is this file is part of any basket
           @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
                           has to exist.
           """
   
           if not context:
               context=self
           
           ret=[]
           for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()}):
               #if the basket x is deleted it seemes to be that x is sometimes still in the Catalog, why?
               try:
                   ret.append(x.getObject())
               except:
                   pass
           return ret
           #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]
           
           
       def addCDLIFileObjectForm(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='CDLIFileObject',kind='CDLIFileObject',version=self.getVersion()).__of__(self)
               return out()
           else:
               return "Sorry file is locked by somebody else"
           
     def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):      def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
         """add"""          """add"""
         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden          try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
Line 295  class CDLIFile(versionedFile,CatalogAwar Line 1196  class CDLIFile(versionedFile,CatalogAwar
         except:          except:
             pass              pass
                   
         author=self.REQUEST['author']  
                   
         if changeName=="yes":          if changeName=="yes":
             filename=file.filename              filename=file.filename
Line 326  class CDLIFile(versionedFile,CatalogAwar Line 1226  class CDLIFile(versionedFile,CatalogAwar
                   
         manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)          manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)
         objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))          objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
           try:
             #FIXME: wozu ist das gut?
         self.REQUEST.SESSION['objID_parent']=self.getId()          self.REQUEST.SESSION['objID_parent']=self.getId()
           except:
             pass
         if RESPONSE:          if RESPONSE:
             obj=self.ZopeFind(self,obj_ids=[id])[0][1]              obj=self.ZopeFind(self,obj_ids=[id])[0][1]
             if obj.getSize()==0:              if obj.getSize()==0:
Line 336  class CDLIFile(versionedFile,CatalogAwar Line 1239  class CDLIFile(versionedFile,CatalogAwar
                 return pt()                  return pt()
   
             else:              else:
                 RESPONSE.redirect(self.REQUEST['URL2'])                  RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
   
         else:          else:
             return self.ZopeFind(self,obj_ids=[id])[0][1]              return self.ZopeFind(self,obj_ids=[id])[0][1]
Line 350  def manage_addCDLIFileForm(self): Line 1253  def manage_addCDLIFileForm(self):
 def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):  def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
     """add the OSAS_root"""      """add the OSAS_root"""
     newObj=CDLIFile(id,title,lockedBy,author)      newObj=CDLIFile(id,title,lockedBy,author)
                                           
       tryToggle=True
       tryCount=0
       
     
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
         
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   
   
 def splitatf(fh,dir=None):  def splitatf(fh,dir=None,ext=None):
     """split it"""      """split it"""
           ret=None
     nf=None      nf=None
       i=0
     for line in fh.readlines():      for line in fh.readlines():
                  if ext:
               i+=1
               if (i%100)==0:
                   ext.result+="."
               if i==10000:
                   i=0
                   ext.result+="<br>"
           #check if basket name is in the first line
           if line.find("#atf basket")>=0:
               ret=line.replace('#atf basket ','')
               ret=ret.split('_')[0]
           else:
         if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile          if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
             if nf:              if nf:
                 nf.close() #close last file                  nf.close() #close last file
Line 373  def splitatf(fh,dir=None): Line 1295  def splitatf(fh,dir=None):
             if dir:              if dir:
                 filename=os.path.join(dir,filename)                  filename=os.path.join(dir,filename)
             nf=file(filename,"w")              nf=file(filename,"w")
                           if nf:    
         nf.write(line)          nf.write(line)
           
     nf.close()      nf.close()
     fh.close()      fh.close()
       return ret,len(os.listdir(dir))
   
           
 class CDLIFileFolder(versionedFileFolder):  class CDLIFileFolder(versionedFileFolder):
     """CDLI folder"""      """CDLI File Folder"""
           
       security=ClassSecurityInfo()
     meta_type="CDLI Folder"      meta_type="CDLI Folder"
     filesMetaType=['CDLI file']      filesMetaType=['CDLI file']
     folderMetaType=['CDLI Folder']      folderMetaType=['CDLI Folder']
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
       defaultFileCatalog=default_catalog #wenn dieses definiert ist, wird beim hinzufŸgen einer neuen version eines files dieser catalog neuiniziert
           
     def uploadATF(self,upload,RESPONSE=None):      tmpStore2={}
         """upload an atf file"""      def setTemp(self,name,value):
         #TODO: add comments          """set tmp"""
         #TODO: finish uploadATF  
         dir=mkdtemp()  
         changed=[]  
         errors=[]  
         newPs=[]  
         splitatf(upload,dir)  
   
         for fn in os.listdir(dir):          setattr(self,name,value)
             founds=self.CDLICatalog.search({'path':fn})      
             if len(founds)==0:  
                 newPs.append(fn)  
                                   
             for found in founds:  
                 obj=found.getObject()  
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):      def delete(self,ids):
                     errors.append(obj)          """delete this file, i.e. move into a trash folder"""
                
           found=self.ZopeFind(self,obj_ids=['.trash'])
           
           if len(found)<1:
               manage_addCDLIFileFolder(self, '.trash',title="Trash")
               trash=self._getOb('.trash')
                 else:                  else:
                     data=file(os.path.join(dir,fn)).read()              trash=found[0][1]
                     diffs=obj.diff(data)  
                     if diffs[0]>0:  
                         changed.append((obj,diffs))  
                         #hochladen  
                   
         self.REQUEST.SESSION['changed']=[x[0].getId() for x in changed]          if type(ids) is not ListType:
         self.REQUEST.SESSION['errors']=[x.getId() for x in errors]              ids=[ids]
         self.REQUEST.SESSION['newPs']=newPs          cut=self.manage_cutObjects(ids)
         self.REQUEST.SESSION['tmpdir']=dir          trash.manage_pasteObjects(cut)
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)      def getVersionNumbersFromIds(self,ids):
         return pt(changed=changed,errors=errors,dir=dir,newPs=newPs)          """get the numbers of the current versions of documents described by their ids"""
                                           
     def uploadATFfinally(self,procedure,comment="",unlock=None,RESPONSE=None):          ret=[]
         """upload the files"""          searchStr=" OR ".join(ids)
                   
         if procedure=="uploadchanged":          founds=self.CDLICatalog.search({'title':searchStr})
             uploadFns=self.REQUEST.SESSION['changed']+self.REQUEST.SESSION['newPs']  
                   
         elif procedure=="uploadAll":          for found in founds:
             uploadFns=[]              lastVersion=found.getObject().getLastVersion()
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):              ret.append((found.getId,lastVersion))
                 if not x in self.REQUEST.SESSION['errors']:  
                     uploadFns.append(x)  
         else:  
             uploadFns=[]  
                           
         for fn in uploadFns:          return ret
             founds=self.CDLICatalog.search({'path':fn})  
             if len(founds)>0:  
                 self.REQUEST['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                 founds[0].getObject().manage_addCDLIFileObject('',comment,self.REQUEST['author'],file=file(os.path.join(self.REQUEST.SESSION['tmpdir'],fn)))  
                           
       def checkCatalog(self,fn):
           """check if fn is in the catalog"""
           #TODO add checkCatalog
                   
                                   
         newPs=self.REQUEST.SESSION['newPs']  
         if len(newPs)>0:  
             tmpDir=self.REQUEST.SESSION['tmpdir']  
                   
             self.cdli_main.importFiles(comment=comment,author=str(self.REQUEST['AUTHENTICATED_USER']) ,folderName=tmpDir, files=newPs)      def findObjectsFromListWithVersion(self,list):
           """find objects from a list with versions
           @param list: list of tuples  (cdliFile,version)
           """
                                   
                   
                   
         #unlock          #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
         if unlock:          #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
             unlockFns=[]  
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                     if not x in self.REQUEST.SESSION['errors']:  
                         unlockFns.append(x)  
                           
             for fn in unlockFns:  
                 founds=self.CDLICatalog.search({'path':fn})  
                 if len(founds)>0:  
                     self.REQUEST['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                                         
                     founds[0].getObject().lockedBy=""          pt=getattr(self,'filelistVersioned.html')
               
           return pt(search=list)
                                           
         if RESPONSE is not None:  
             RESPONSE.redirect(self.aq_parent.absolute_url())  
                   
   
     def findObjectsFromList(self,upload,RESPONSE):      def findObjectsFromList(self,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
         """findObjectsFromList (, TAB oder LINE separated)"""          """findObjectsFromList (, TAB oder LINE separated)"""
                                          
           
           if upload: # list from file upload
         txt=upload.read()          txt=upload.read()
         txt=txt.replace(",","\n")          txt=txt.replace(",","\n")
         txt=txt.replace("\t","\n")          txt=txt.replace("\t","\n")
               txt=txt.replace("\r","\n")
         idsTmp=txt.split("\n")          idsTmp=txt.split("\n")
         ids=[]          ids=[]
         for id in idsTmp: # make sure that no empty lines          for id in idsTmp: # make sure that no empty lines
             idTmp=id.lstrip().rstrip()              idTmp=id.lstrip().rstrip()
             if len(idTmp)>0:              if len(idTmp)>0:
                       
                 ids.append(idTmp)                  ids.append(idTmp)
                       
         #self.REQUEST.SESSION['ids']=" OR ".join(ids)          #self.REQUEST.SESSION['ids']=" OR ".join(ids)
                   
         RESPONSE.redirect("filelist.html?path=%s"%" OR ".join(ids))              pt=getattr(self,'filelist.html')
               self.REQUEST.SESSION['searchList']=ids
               return pt(search=ids)
           
           if basketName:
               #TODO: get rid of one of these..
               
               pt=getattr(self,'filelist.html')
               return pt(basketName=basketName,numberOfObjects=numberOfObjects)
           
           if list is not None: # got already a list
               ret=[]
               for fileId in list:
                   if len(fileId.split("."))==1:
                           fileId=fileId+".atf"
   
                   ret+=self.CDLICatalog({'title':fileId})
               #TODO: get rid of one of these..
               ids=[x.getObject().getId() for x in ret]
               self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
               self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
               
               if display:
                   pt=getattr(self,'filelist.html')
                   
                   return pt(search=ids)
               else:      
                   return ret
           
           
           
           if start:
               RESPONSE.redirect("filelist.html?start:int="+str(start))
                                          
   
   
       security.declareProtected('Manage','createAllFilesAsSingleFile')
     def createAllFilesAsSingleFile(self,RESPONSE=None):      def createAllFilesAsSingleFile(self,RESPONSE=None):
         """download all files"""          """download all files"""
                   
Line 508  class CDLIFileFolder(versionedFileFolder Line 1452  class CDLIFileFolder(versionedFileFolder
                                   
                 #os.write(tf,obj.getLastVersion().data)                  #os.write(tf,obj.getLastVersion().data)
                 if RESPONSE:                  if RESPONSE:
                     RESPONSE.write(obj.getLastVersion().data)                      RESPONSE.write(obj.getLastVersion().data[0:])
         #os.close(tf)          #os.close(tf)
         #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)          #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
         return True          return True
Line 561  class CDLIFileFolder(versionedFileFolder Line 1505  class CDLIFileFolder(versionedFileFolder
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
         return pt()          return pt()
           
     def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None):      
   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)
       
   class CDLIRoot(Folder):
       """main folder for cdli"""
       
       meta_type="CDLIRoot"
       
       def forceunlock(self):
           "break all locks"
           ret=[]
           for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
              un=f[1].forceunlock()
              print un
              if un and un !="":
                  ret.append((f[0],un))
           print ret
           return ret                       
       
       def getChangesByAuthor(self,author,n=100):
           """getChangesByAuthor"""
           zcat=self.CDLIObjectsCatalog
           res=zcat({'lastEditor':author,
                        'sort_on':'getTime',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
                          
           return res
       
       def getChangesByAuthor_html(self,author,n=100):
           """html output for changes by author"""
           tmp={}
           list=[]                         
           for x in self.getChangesByAuthor(author):
              nr=x.getObject().getVersionNumber()
              id=x.getObject().aq_parent.getId()
              #hinzufuegen, wenn Version neuer als die 
              if tmp.get(id,(0,0))[1] < nr:
                   tmp[id]=(x.getObject().aq_parent,nr)
   
        
           return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values())           
           
       def getLastChanges(self,n=100):
           """get the last n changes""" 
           n=int(n)                   
           zcat=self.CDLICatalog
           return zcat({'sort_on':'getLastChangeDate',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
        
       
       def getLastChanges_html(self,n=100):
           """get the last n changes"""
           list = [x.getId for x in self.getLastChanges(n)]
           return self.cdli_main.findObjectsFromList(list=list,display=True)
                                          
       def refreshTxt(self,txt="",threadName=None):
           """txt fuer refresh"""
     
           return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
   
       
       def getResult(self,threadName=None):
          """result of thread"""
          try:
           return self._v_uploadATF[threadName].getResult()
          except:
           return "One moment, please"
       
           
       def checkThreads(self):
           """check threads"""
           return threading.enumerate()
       
       def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
           """standard ausgabe"""
           #self._v_uploadATF.returnValue=None
   
           threadName=repeat
           if not threadName or threadName=="":
               tmpVar=False
          
               thread=uploadATFThread()
               threadName=thread.getName()[0:]                                
               if not hasattr(self,'_v_uploadATF'):
                      self._v_uploadATF={}
                                          
               self._v_uploadATF[threadName]=thread
               #self._xmltrans.start()
               #thread=Thread(target=self._v_uploadATF)
               
               self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
               #thread.start()
               self._v_uploadATF[threadName].start()
   
               
               self.threadName=self._v_uploadATF[threadName].getName()[0:]
               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','uploadATFWait.zpt')).__of__(self)
               return pt(txt='/uploadATF',threadName=threadName)
               #_v_xmltrans.run()
               
           else:
               #recover thread, if lost
               if not hasattr(self,'_v_uploadATF'):
                  self._v_uploadATF={}
               if not self._v_uploadATF.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF[threadName]=thread
                                          
               if not self._v_uploadATF[threadName].returnValue:
           
   
                   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','uploadATFWait.zpt')).__of__(self)
   
                   return pt(txt='/uploadATF',threadName=threadName)
                   
               else:
   #                tmp={}
   #                for key in self._v_uploadATF[threadName].returnValue.keys():
   #                        t=self._v_uploadATF[threadName].returnValue[key]
   #                        if type(t) is ListType:
   #                                       tmp[key]=self._v_uploadATF[threadName].returnValue[key][0:]
   #                        else:
   #                                       tmp[key]=self._v_uploadATF[threadName].returnValue[key]
                 
                   tmp=self.cdli_main.tmpStore2[threadName]
                   del(self.cdli_main.tmpStore2[threadName])
                   self._v_uploadATF[threadName].continueVar=False
                   self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]
                   self.REQUEST.SESSION['errors']=[x.getId() for x in tmp['errors']]
                   self.REQUEST.SESSION['newPs']=tmp['newPs']
                   self.REQUEST.SESSION['tmpdir']=tmp['dir']
         
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
                   return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                     basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                                          
       def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
           """nowupload the files"""
          
          
          
           threadName=repeat
           if not threadName or threadName=="":
               thread=uploadATFfinallyThread()
               threadName=thread.getName()[0:]
               self._v_uploadATF[threadName]=thread
   
           
               self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
   
               self._v_uploadATF[threadName].start()
   
               
               
               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','uploadATFWait.zpt')).__of__(self)
   
               return pt(txt='/uploadATFfinally',threadName=threadName)
               #_v_xmltrans.run()
           
           else:
               #recover thread, if lost
               if not hasattr(self,'_v_uploadATF'):
                  self._v_uploadATF={}
               if not self._v_uploadATF.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF[threadName]=thread
                                          
               if self._v_uploadATF.get(threadName,None) and (self._v_uploadATF[threadName] is not None) and (not self._v_uploadATF[threadName].end) :
   
                   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','uploadATFWait.zpt')).__of__(self)
                   return pt(txt='/uploadATFfinally',threadName=threadName)
               else:
   
                 if RESPONSE is not None:
                     RESPONSE.redirect(self.absolute_url())
   
       def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):
         """import files"""          """import files"""
           root=self.cdli_main
                   
         if not files:          if not files:
             files=os.listdir(folderName)              files=os.listdir(folderName)
Line 570  class CDLIFileFolder(versionedFileFolder Line 1741  class CDLIFileFolder(versionedFileFolder
         for f in files:          for f in files:
             folder=f[0:3]              folder=f[0:3]
             f2=f[0:5]              f2=f[0:5]
             obj=self.ZopeFind(self,obj_ids=[folder])              obj=self.ZopeFind(root,obj_ids=[folder])
               if ext:
                           
                   ext.result+="<p>Adding: %s </p>"%f
             if not obj:              if not obj:
                 manage_addCDLIFileFolder(self,folder,folder)                  manage_addCDLIFileFolder(root,folder,folder)
                 fobj=getattr(self,folder)                  fobj=getattr(root,folder)
                           #get_transaction().commit()                           
             else:              else:
                 fobj=obj[0][1]                  fobj=obj[0][1]
                           
Line 602  class CDLIFileFolder(versionedFileFolder Line 1775  class CDLIFileFolder(versionedFileFolder
                           
         return "ok"          return "ok"
           
 manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())  
   
   manage_addCDLIRootForm=DTMLFile('dtml/rootAdd', globals())
           
 def manage_addCDLIFileFolder(self, id, title='',      
   def manage_addCDLIRoot(self, id, title='',
                      createPublic=0,                       createPublic=0,
                      createUserF=0,                       createUserF=0,
                      REQUEST=None):                       REQUEST=None):
Line 615  def manage_addCDLIFileFolder(self, id, t Line 1789  def manage_addCDLIFileFolder(self, id, t
     value, an 'index_html' and a 'UserFolder' objects are created respectively      value, an 'index_html' and a 'UserFolder' objects are created respectively
     in the new folder.      in the new folder.
     """      """
     ob=CDLIFileFolder()      ob=CDLIRoot()
     ob.id=str(id)      ob.id=str(id)
     ob.title=title      ob.title=title
     self._setObject(id, ob)      self._setObject(id, ob)
Removed from v.1.3  
changed lines
  Added in v.1.27

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>