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

Diff for /cdli/cdli_files.py between versions 1.55 and 1.61

version 1.55, 2006/12/22 20:35:33 version 1.61, 2007/01/30 14:26:42
Line 22  from ZPublisher.HTTPResponse import HTTP Line 22  from ZPublisher.HTTPResponse import HTTP
 from ZPublisher.BaseRequest import RequestContainer  from ZPublisher.BaseRequest import RequestContainer
 import threading  import threading
 from BTrees.OOBTree import OOBTree  from BTrees.OOBTree import OOBTree
   import logging
   import transaction
   import copy
   
 def unique(s):  def unique(s):
     """Return a list of the elements in s, but without duplicates.      """Return a list of the elements in s, but without duplicates.
Line 134  class uploadATFfinallyThread(Thread): Line 137  class uploadATFfinallyThread(Thread):
         self.username=username          self.username=username
         self.serverport=serverport          self.serverport=serverport
                   
           
     def __call__(self):      def __call__(self):
         """call of the thread (equals run)"""          """call of the thread (equals run)"""
         self.run()          self.run()
Line 166  class uploadATFfinallyThread(Thread): Line 170  class uploadATFfinallyThread(Thread):
         #add the files          #add the files
         self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)          self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
         #commit the transactions          #commit the transactions
         get_transaction().commit()          transaction.get().commit()
         conn.close()          conn.close()
         #set flag for end of this method          #set flag for end of this method
         self.end=True          self.end=True
Line 192  class uploadATFfinallyThread(Thread): Line 196  class uploadATFfinallyThread(Thread):
                   
         #shall I only upload the changed files?          #shall I only upload the changed files?
         if procedure=="uploadchanged":          if procedure=="uploadchanged":
                 changed=[x[0] for x in SESSION.get('changed',[])]
             uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])              uploadFns=changed+SESSION.get('newPs',[])
                   
         #or all          #or all
         elif procedure=="uploadAll":          elif procedure=="uploadAll":
Line 262  class uploadATFfinallyThread(Thread): Line 266  class uploadATFfinallyThread(Thread):
                 
         return True          return True
           
   class tmpStore(SimpleItem):
       """simple item"""
       meta_type="cdli_upload"
       
       def __init__(self,id):
           """init tmp"""
           self.id=id
           
 class uploadATFThread(Thread):  class uploadATFThread(Thread):
     """class for checking the files befor uploading"""      """class for checking the files befor uploading"""
           
Line 274  class uploadATFThread(Thread): Line 286  class uploadATFThread(Thread):
         Thread.__init__(self)          Thread.__init__(self)
                   
                   
     def set(self,upload,basketId,username,serverport="8080"):      def set(self,upload,basketId,username,idTmp,serverport="8080"):
         """set start values for the thread"""          """set start values for the thread"""
         self.result=""          self.result=""
         self.upload=upload          self.upload=upload
         self.basketId=basketId          self.basketId=basketId
         self.username=username          self.username=username
         self.serverport=serverport          self.serverport=serverport
           self.idTmp=idTmp
                   
     def __call__(self):      def __call__(self):
         """call method """          """call method """
Line 299  class uploadATFThread(Thread): Line 312  class uploadATFThread(Thread):
         return app.__of__(RequestContainer(REQUEST = req))          return app.__of__(RequestContainer(REQUEST = req))
                   
     def run(self):      def run(self):
                idTmp=self.idTmp
         self.result=""          self.result=""
         #find context within ZODB          #find context within ZODB
         from Zope import DB          from Zope import DB
Line 307  class uploadATFThread(Thread): Line 320  class uploadATFThread(Thread):
         root = conn.root()          root = conn.root()
         app  = root['Application']          app  = root['Application']
         ctx = self.getContext(app,serverport=self.serverport)          ctx = self.getContext(app,serverport=self.serverport)
         self.uploadATFThread(ctx,self.upload,self.basketId)          logging.info("run intern")
           ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
           logging.info("call thread intern")
           self.uploadATFThread(ctx,self.upload,idTmp,self.basketId)
             
         #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue          #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
   
         get_transaction().commit()  
           
         while self.continueVar:          transaction.get().commit()
             pass  
                 
         conn.close()          conn.close()
                   
Line 323  class uploadATFThread(Thread): Line 337  class uploadATFThread(Thread):
         """method for accessing result"""          """method for accessing result"""
         return self.result          return self.result
           
     def uploadATFThread(self,ctx,upload,basketId=0):      def uploadATFThread(self,ctx,upload,idTmp,basketId=0):
         """upload an atf file"""          """upload an atf file"""
         #TODO: add comments          #TODO: add comments
         #TODO: finish uploadATF          #TODO: finish uploadATF
           
           stObj=getattr(ctx.temp_folder,idTmp)
           logging.info("start, upload thread")
         self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"          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          #make sure that id is a string and not an integer
Line 365  class uploadATFThread(Thread): Line 382  class uploadATFThread(Thread):
             basketNameFromId=getattr(ctx2.basketContainer,basketId).title              basketNameFromId=getattr(ctx2.basketContainer,basketId).title
             basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()              basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
                           
                   logging.info("got the file, upload thread")
         self.result+="""<html><body><h2>I got the files</h2><          self.result+="""<html><body><h2>I got the files</h2><
                         p>I am computing the differences to the exisiting files</p>"""                          p>I am computing the differences to the exisiting files</p>"""
                                                                         
Line 410  class uploadATFThread(Thread): Line 427  class uploadATFThread(Thread):
         #ready, set the returnValues          #ready, set the returnValues
         self.result+="<h3>Done</h3></body></html>"          self.result+="<h3>Done</h3></body></html>"
                   
         self.returnValue={}          stObj.returnValue={}
         self.returnValue['changed']=changed          
         self.returnValue['errors']=errors          stObj.returnValue['errors']=errors
         self.returnValue['lockerrors']=lockerrors  
         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  
                   
           stObj.returnValue['newPs']=newPs
           stObj.returnValue['tmpdir']=dir
           stObj.returnValue['basketLen']=basketLen
           stObj.returnValue['numberOfFiles']=numberOfFiles
           stObj.returnValue['basketNameFromId']=basketNameFromId
           stObj.returnValue['basketNameFromFile']=basketNameFromFile
           stObj.returnValue['basketId']=basketId
           stObj.returnValue['dir']=dir
           #stObj.returnValue['changed']=copy.copy(changed)
           stObj.returnValue['changed']=[(x[0].getId(),x[1][0]) for x in changed]
           #stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors]
       print lockerrors
       stObj.returnValue['lockerrors']=[x for x in lockerrors]
           self.returnValue=True
         #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)          #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
           
                   
Line 589  class BasketObject_old(Folder): Line 611  class BasketObject_old(Folder):
         """unlock all files of the testuser for debuggin"""          """unlock all files of the testuser for debuggin"""
         for object in self.contents:          for object in self.contents:
   
                 if str(object.lockedBy)=="test":                  if str(object.lockedBy)=="dahl":
                     object.lockedBy=""                      object.lockedBy=""
                           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):      def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
Line 629  class BasketObject_old(Folder): Line 651  class BasketObject_old(Folder):
                   
         self.temp_folder.downloadCounter+=1           self.temp_folder.downloadCounter+=1 
         self._p_changed=1          self._p_changed=1
         get_transaction().commit()        
   
           transaction.get().commit()
                   
         for object in self.contents:          for object in self.contents:
                           
Line 648  class BasketObject_old(Folder): Line 670  class BasketObject_old(Folder):
         self.REQUEST.RESPONSE.write(ret)              self.REQUEST.RESPONSE.write(ret)    
         self.temp_folder.downloadCounter-=1           self.temp_folder.downloadCounter-=1 
         self._p_changed=1          self._p_changed=1
         get_transaction().commit()                transaction.get().commit()
                
                   
                   
 def manage_addBasket_oldObjectForm(self):  def manage_addBasket_oldObjectForm(self):
Line 1191  class CDLIBasketVersion(Implicit,Persist Line 1214  class CDLIBasketVersion(Implicit,Persist
   
         self.temp_folder.downloadCounterBaskets+=1           self.temp_folder.downloadCounterBaskets+=1 
         self._p_changed=1          self._p_changed=1
         get_transaction().commit()                 transaction.get().commit()       
           
         if lock:          if lock:
                           
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':              if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
                 self.temp_folder.downloadCounterBaskets-=1                   self.temp_folder.downloadCounterBaskets-=1 
                 self._p_changed=1                  self._p_changed=1
                 get_transaction().commit()                        transaction.get().commit()      
                 self.temp_folder.downloadCounterBaskets-=1                   self.temp_folder.downloadCounterBaskets-=1 
                 self._p_changed=1                  self._p_changed=1
                 get_transaction().commit()                        transaction.get().commit()      
                 return "please login first"                  return "please login first"
   
             #check if a locked object exist in the basket.              #check if a locked object exist in the basket.
Line 1221  class CDLIBasketVersion(Implicit,Persist Line 1244  class CDLIBasketVersion(Implicit,Persist
                                   
                 self.temp_folder.downloadCounterBaskets-=1                   self.temp_folder.downloadCounterBaskets-=1 
                 self._p_changed=1                  self._p_changed=1
                 get_transaction().commit()                        transaction.get().commit()      
   
                 return pt()                  return pt()
                     
Line 1251  class CDLIBasketVersion(Implicit,Persist Line 1274  class CDLIBasketVersion(Implicit,Persist
   
         self.temp_folder.downloadCounterBaskets-=1           self.temp_folder.downloadCounterBaskets-=1 
         self._p_changed=1          self._p_changed=1
         get_transaction().commit()                transaction.get().commit()      
                   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)          self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")          self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
Line 1674  def splitatf(fh,dir=None,ext=None): Line 1697  def splitatf(fh,dir=None,ext=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")
               logging.info("open %s"%filename)
         if nf:              if nf:    
             nf.write(line.replace("\n","")+"\n")              nf.write(line.replace("\n","")+"\n")
   
       try:    
     nf.close()      nf.close()
       except:
       pass
     fh.close()      fh.close()
     return ret,len(os.listdir(dir))      return ret,len(os.listdir(dir))
   
Line 1830  class CDLIFileFolder(extVersionedFileFol Line 1857  class CDLIFileFolder(extVersionedFileFol
   
         self.temp_folder.downloadCounter+=1          self.temp_folder.downloadCounter+=1
         self._p_changed=1          self._p_changed=1
         get_transaction().commit()          transaction.get().commit()
                 
         list=[(x.getId,x) for x in catalog()]          list=[(x.getId,x) for x in catalog()]
         list.sort(sortF)          list.sort(sortF)
Line 1850  class CDLIFileFolder(extVersionedFileFol Line 1877  class CDLIFileFolder(extVersionedFileFol
                     RESPONSE.write(obj.getLastVersion().getData()[0:])                      RESPONSE.write(obj.getLastVersion().getData()[0:])
                 self.temp_folder.downloadCounter-=1                   self.temp_folder.downloadCounter-=1 
                 self._p_changed=1                  self._p_changed=1
         get_transaction().commit()          transaction.get().commit()
         #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 1932  class CDLIRoot(Folder): Line 1959  class CDLIRoot(Folder):
     meta_type="CDLIRoot"      meta_type="CDLIRoot"
     downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible      downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible
           
       def findWordRegExp(self,searchTerm):
           """find all words in index which match regexp in SearchTerm"""
           ret=[]
           for x in self.lineIndex.iterkeys():
               if re.match(searchTerm,x):
                   ret.append(x)
           return ret
       
       def searchRegExpInLineIndexDocs(self,searchTerm):
           """search in inLineIndex with regexp"""
           if not searchTerm:
               return []
           ret=[]
           words=self.findWordRegExp(searchTerm) # suche nach allen Treffern
           logging.info("wd:%s"%words)
           for word in words:
               ret+=self.searchInLineIndexDocs(word)
           
           return unique(ret)
           
     def showInLineIndex(self):      def showInLineIndex(self):
         """get the index for debug purposes"""          """get the index for debug purposes"""
         print "show"          print "show"
         for x in self.lineIndex.iterkeys():          for x in self.lineIndex.iterkeys():
             print "word:",x              logging.info("word:%s"%repr(x))
             for y in self.lineIndex[x].iterkeys():              #for y in self.lineIndex[x].iterkeys():
                 print "doc",y,self.lineIndex[x][y]              #    print "doc",repr(y),repr(self.lineIndex[x][y])
                                   
         return self.lineIndex          return self.lineIndex
                   
     def searchInLineIndexDocs(self,word,uniq=True):      def searchInLineIndexDocs(self,word,uniq=True,regExp=False):
         """search occurences"""          """search occurences"""
                   
           if regExp:
               return self.searchRegExpInLineIndexDocs(word)
                           
         lst=list(self.lineIndex.get(word.upper()).keys())          try:    
               lst=list(self.lineIndex.get(word).keys())
           except:
               lst=[]
         if uniq:          if uniq:
             return unique(lst)              return unique(lst)
         else:          else:
             return lst              return lst
                   
     def getLinesFromIndex(self,word,doc):      def getLinesFromIndex(self,word,doc,regExp=False):
         """get lines"""          """get lines"""
         return self.lineIndex[word][doc]          if not regExp:
               return self.lineIndex.get(word)[doc]
           else: # wenn regexp, suche welches word
               for w in self.findWordRegExp(word):
                   if self.lineIndex.get(w): # ein word in im dex gefunden
                       try:    
                           dc=self.lineIndex.get(word)[doc]
                           return dc # und ein document dann gib es zurueck
                       except:
                            pass #andernfalls weiter
   
     def cleanInLineIndex(self):      def cleanInLineIndex(self):
         """delete InlineIndex"""          """delete InlineIndex"""
Line 1989  class CDLIRoot(Folder): Line 2050  class CDLIRoot(Folder):
                   
         self.lineIndex=li          self.lineIndex=li
             
         get_transaction().commit()          transaction.get().commit()
                   
   
     def showFile(self,fileId):      def showFile(self,fileId):
Line 2000  class CDLIRoot(Folder): Line 2061  class CDLIRoot(Folder):
                   
         return f[0].getObject().getLastVersionFormattedData()          return f[0].getObject().getLastVersionFormattedData()
           
     def showLineFromFile(self,fileId,lineNum):      def showLineFromFile(self,fileId,lineNum,word):
         """get line lineNum fromFileId"""          """get line lineNum fromFileId"""
                   
         file=self.showFile(fileId)          file=self.showFile(fileId)
         str="^%s\.(.*)"%lineNum          #str="^%s\.[^%s\.]*%s[^\n]*\n"%(lineNum,lineNum,word)
       #str="^%s\..*?%s[^\n]*\n"%(lineNum,word)
           
       #print str
           #m=re.search(str,file,flags=re.M|re.DOTALL)
           #if m:
           #    return m.group()
           #else:
           #       return ""
       #ret=lineNum+"."
           #splitted=file.split(lineNum+".")
       #if len(splitted)>1:
           #for part in splitted[1:]:
               #if part.find(word)>-1:
                # for x in part.split("\n"):
                   #ret+=x
                   #if x.find(word)>-1:
                       #break
                 #break;
       #return ret
   
       def showWordInFile(self,fileId,word,lineList=None):
           """get lines with word  fromFileId"""
           
           file=self.showFile(fileId)
                 
         m=re.search(str,file,flags=re.M)      ret=[]
         if m:      for line in file.split("\n"):
             return m.group(1)          if line.find(word)>-1:
               if lineList: #liste of moeglichen Zeilennummern
                   num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
   
                   if num in lineList: 
   
                       ret.append(line)
               else: # nimm alles ohne line check
                   ret.append(line)
       return ret
   
       def tagWordInFile(self,fileId,word,lineList=None):
           """get lines with word  fromFileId"""
           
           file=self.showFile(fileId)
       tagStr="""<span class="found">%s</span>"""
       ret=[]
       for line in file.split("\n"):
           if line.find(word)>-1:
               if lineList: #liste of moeglichen Zeilennummern
                   num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
   
                   if num in lineList: 
   
                       ret.append(line.replace(word,tagStr%word))
               else: # nimm alles ohne line check
                   ret.append(line.replace(word,tagStr%word))
         else:          else:
             return ""              ret.append(line)
       return "<br>\n".join(ret)
                   
     def URLquote(self,str):      def URLquote(self,str):
         """quote url"""          """quote url"""
Line 2020  class CDLIRoot(Folder): Line 2132  class CDLIRoot(Folder):
         """unquote url"""          """unquote url"""
         return urllib.unquote(str)          return urllib.unquote(str)
           
       def URLquote_plus(self,str):
           """quote url"""
           return urllib.quote_plus(str)
       
       def URLunquote_plus(self,str):
           """unquote url"""
           return urllib.unquote_plus(str)
       
           
     def forceunlock(self):      def forceunlock(self):
         "break all locks"          "break all locks"
Line 2032  class CDLIRoot(Folder): Line 2152  class CDLIRoot(Folder):
   
         return ret                                 return ret                       
           
       def forceDahl(self):
           "break all locks"
           ret=[]
           for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
          if str(f[1].lockedBy)=="dahl":
                  un=f[1].forceunlock()
   
                      if un and un !="":
                         ret.append((f[0],un))
   
           return ret                       
       
     def getChangesByAuthor(self,author,n=100):      def getChangesByAuthor(self,author,n=100):
         """getChangesByAuthor"""          """getChangesByAuthor"""
         zcat=self.CDLIObjectsCatalog          zcat=self.CDLIObjectsCatalog
Line 2097  class CDLIRoot(Folder): Line 2229  class CDLIRoot(Folder):
     def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):      def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
         """standard ausgabe"""          """standard ausgabe"""
         #self._v_uploadATF.returnValue=None          #self._v_uploadATF.returnValue=None
           from random import randint
           if (not self.REQUEST.SESSION.get('idTmp',None)):
   
               idTmp=str(randint(0,1000000000))
               self.REQUEST.SESSION['idTmp']=idTmp
           else:
               idTmp=self.REQUEST.SESSION.get('idTmp',None)
   
         threadName=repeat          threadName=repeat
         if not threadName or threadName=="":          if not threadName or threadName=="":
Line 2110  class CDLIRoot(Folder): Line 2249  class CDLIRoot(Folder):
             self._v_uploadATF[threadName]=thread              self._v_uploadATF[threadName]=thread
             #self._xmltrans.start()              #self._xmltrans.start()
             #thread=Thread(target=self._v_uploadATF)              #thread=Thread(target=self._v_uploadATF)
                           logging.info("set thread. extern")
             self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])              self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],idTmp,serverport=self.REQUEST['SERVER_PORT'])
             #thread.start()              #thread.start()
               logging.info("start thread. extern")
             self._v_uploadATF[threadName].start()              self._v_uploadATF[threadName].start()
   
                           
Line 2134  class CDLIRoot(Folder): Line 2274  class CDLIRoot(Folder):
                          if threadName == thread.getName():                           if threadName == thread.getName():
                                        self._v_uploadATF[threadName]=thread                                         self._v_uploadATF[threadName]=thread
                                                                                 
             if not self._v_uploadATF[threadName].returnValue:              if self._v_uploadATF.get(threadName,None) and (not self._v_uploadATF[threadName].returnValue):
                   
   
                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
Line 2157  class CDLIRoot(Folder): Line 2297  class CDLIRoot(Folder):
 #                                         #                                       
 #                #  #                #
                 #tmp=self.cdli_main.tmpStore2[threadName]                  #tmp=self.cdli_main.tmpStore2[threadName]
                 tmp=self._v_uploadATF[threadName].returnValue  
                                   
                 self._v_uploadATF[threadName].continueVar=False                  tmp=getattr(self.temp_folder,idTmp).returnValue
                   
                   
                   
                                   
                 self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]  
                 self.REQUEST.SESSION['lockerrors']=[x[0].getId() for x in tmp['lockerrors']]  
                 self.REQUEST.SESSION['errors']=tmp['errors']  
                 self.REQUEST.SESSION['newPs']=tmp['newPs']  
                 self.REQUEST.SESSION['tmpdir']=tmp['dir']  
                 #del(self.cdli_main.tmpStore2[threadName])                  #del(self.cdli_main.tmpStore2[threadName])
   
                                 
Line 2197  class CDLIRoot(Folder): Line 2334  class CDLIRoot(Folder):
   
             self._v_uploadATF[threadName]=thread              self._v_uploadATF[threadName]=thread
   
                       idTmp=self.REQUEST.SESSION['idTmp']
             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'])              stObj=getattr(self.temp_folder,idTmp)
               self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=stObj.returnValue,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
   
             self._v_uploadATF[threadName].start()              self._v_uploadATF[threadName].start()
   
Line 2231  class CDLIRoot(Folder): Line 2369  class CDLIRoot(Folder):
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                 return pt(txt='/uploadATFfinally',threadName=threadName)                  return pt(txt='/uploadATFfinally',threadName=threadName)
             else:              else:
                 self.REQUEST.SESSION['idTmp']=None
               if RESPONSE is not None:                if RESPONSE is not None:
                   RESPONSE.redirect(self.absolute_url())                    RESPONSE.redirect(self.absolute_url())
   
Line 2252  class CDLIRoot(Folder): Line 2390  class CDLIRoot(Folder):
             if not obj:              if not obj:
                 manage_addCDLIFileFolder(root,folder,folder)                  manage_addCDLIFileFolder(root,folder,folder)
                 fobj=getattr(root,folder)                  fobj=getattr(root,folder)
                 #get_transaction().commit()                                             #transaction.get().commit()                           
             else:              else:
                 fobj=obj[0][1]                  fobj=obj[0][1]
                           
Line 2280  class CDLIRoot(Folder): Line 2418  class CDLIRoot(Folder):
   
         if count > 1000:          if count > 1000:
         print "committing"          print "committing"
         get_transaction().commit()          transaction.get().commit()
         count=0          count=0
     get_transaction().commit()          transaction.get().commit()
         return "ok"          return "ok"
                     
   
Line 2302  def manage_addCDLIRoot(self, id, title=' Line 2440  def manage_addCDLIRoot(self, id, title='
     ob=CDLIRoot()      ob=CDLIRoot()
     ob.id=str(id)      ob.id=str(id)
     ob.title=title      ob.title=title
       try:
     self._setObject(id, ob)      self._setObject(id, ob)
       except:
       pass
     ob=self._getOb(id)      ob=self._getOb(id)
   
     checkPermission=getSecurityManager().checkPermission      checkPermission=getSecurityManager().checkPermission
Removed from v.1.55  
changed lines
  Added in v.1.61

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