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

Diff for /cdli/cdli_files.py between versions 1.56 and 1.62

version 1.56, 2007/01/08 14:36:28 version 1.62, 2007/02/02 14:31:49
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
     print "ended"      logging.info("ended")
     return True      return True
           
     def __del__(self):      def __del__(self):
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 209  class uploadATFfinallyThread(Thread): Line 213  class uploadATFfinallyThread(Thread):
             uploadFns=[]              uploadFns=[]
                           
         #do first the changed files              #do first the changed files    
       i=0
         for fn in uploadFns:          for fn in uploadFns:
           i+=1
             founds=ctx2.CDLICatalog.search({'title':fn})              founds=ctx2.CDLICatalog.search({'title':fn})
             if len(founds)>0:              if len(founds)>0:
                 SESSION['author']=str(username)                  SESSION['author']=str(username)
                 self.result+="<p>Changing : %s"%fn                  self.result+="<p>Changing : %s"%fn
                 founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)                  founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
                           if i==200:
               i=0
                   transaction.get().commit()
                       logging.info("changing: do commit")
       transaction.get().commit()
       logging.info("changing: last commit")
                   
         #now add the new files                  #now add the new files        
         newPs=SESSION['newPs']          newPs=SESSION['newPs']
Line 262  class uploadATFfinallyThread(Thread): Line 273  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 293  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 319  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 327  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 344  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 389  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 434  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 618  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 658  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 677  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 1221  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 1251  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 1281  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 1704  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 1864  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 1884  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 1966  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:",repr(x)              logging.info("word:%s"%repr(x))
             #for y in self.lineIndex[x].iterkeys():              #for y in self.lineIndex[x].iterkeys():
             #    print "doc",repr(y),repr(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)
           
         try:              try:    
             lst=list(self.lineIndex.get(word).keys())              lst=list(self.lineIndex.get(word).keys())
     except:      except:
Line 1954  class CDLIRoot(Folder): Line 2011  class CDLIRoot(Folder):
         else:          else:
             return lst              return lst
                   
     def getLinesFromIndex(self,word,doc):      def getLinesFromIndex(self,word,doc,regExp=False):
         """get lines"""          """get lines"""
               if not regExp:
         return self.lineIndex.get(word)[doc]          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 1992  class CDLIRoot(Folder): Line 2057  class CDLIRoot(Folder):
                   
         self.lineIndex=li          self.lineIndex=li
             
         get_transaction().commit()          transaction.get().commit()
                   
   
     def showFile(self,fileId):      def showFile(self,fileId):
Line 2074  class CDLIRoot(Folder): Line 2139  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 2086  class CDLIRoot(Folder): Line 2159  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 2151  class CDLIRoot(Folder): Line 2236  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 2164  class CDLIRoot(Folder): Line 2256  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 2188  class CDLIRoot(Folder): Line 2281  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 2211  class CDLIRoot(Folder): Line 2304  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 2251  class CDLIRoot(Folder): Line 2341  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 2285  class CDLIRoot(Folder): Line 2376  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 2306  class CDLIRoot(Folder): Line 2397  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 2334  class CDLIRoot(Folder): Line 2425  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 2356  def manage_addCDLIRoot(self, id, title=' Line 2447  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.56  
changed lines
  Added in v.1.62

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