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

Diff for /cdli/cdli_files.py between versions 1.13 and 1.21

version 1.13, 2006/03/28 15:10:02 version 1.21, 2006/06/13 20:59:56
Line 11  from OFS.SimpleItem import SimpleItem Line 11  from OFS.SimpleItem import SimpleItem
 import time  import time
 from OFS.Folder import manage_addFolder  from OFS.Folder import manage_addFolder
 import re  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
   global tmpVar
   
   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 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.cdli_main.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)
           
           while self.continueVar:
               pass
           get_transaction().abort()
           conn.close()
           print "done"
           
       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 am loading your file...</h2>"
           #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)
           
           #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 checking now the files</p>"
                                      
           #start to check the files
           for fn in os.listdir(dir):
               
               self.result+="<p>check:%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):  class Basket_old(Folder):
     """shopping basket - alte fassung """      """shopping basket - alte fassung """
Line 208  class BasketObject_old(Folder): Line 505  class BasketObject_old(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 537  class CDLIBasket(Folder,CatalogAware): Line 834  class CDLIBasket(Folder,CatalogAware):
   
         
           
     def addObjects(self,ids,deleteOld=None):      def addObjects(self,ids,deleteOld=None,username=None):
         """generate a new version of the basket with objects added"""          """generate a new version of the basket with objects added"""
                 
         lastVersion=self.getLastVersion()          lastVersion=self.getLastVersion()
Line 562  class CDLIBasket(Folder,CatalogAware): Line 859  class CDLIBasket(Folder,CatalogAware):
                     added+=1                      added+=1
   
         content=oldContent+newContent          content=oldContent+newContent
                   if not username:
         user=self.getActualUserName()          user=self.getActualUserName()
           else:
               user = username
                   
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)          ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
           
Line 758  class CDLIFileObject(versionedFileObject Line 1057  class CDLIFileObject(versionedFileObject
     def getDesignation(self):      def getDesignation(self):
         """get the designation out of the file"""          """get the designation out of the file"""
     try:      try:
             txt=re.search("&[Pp](.*)= (.*)",self.data[0:])                  txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.data[0:])
         except:          except:
         print self.getId()  
         txt=self.data[0:]          txt=self.data[0:]
         print str(txt)  
                   
         return "ERROR"          return "ERROR"
         try:          try:
Line 938  def splitatf(fh,dir=None): Line 1235  def splitatf(fh,dir=None):
     fh.close()      fh.close()
     return ret,len(os.listdir(dir))      return ret,len(os.listdir(dir))
   
   
 class CDLIFileFolder(versionedFileFolder):  class CDLIFileFolder(versionedFileFolder):
     """CDLI File 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'
           
       def setTemp(self,name,value):
           """set tmp"""
   
           setattr(self,name,value)
                                           
                                          
     def delete(self,ids):      def delete(self,ids):
         """delete this file, i.e. move into a trash folder"""          """delete this file, i.e. move into a trash folder"""
                             
Line 976  class CDLIFileFolder(versionedFileFolder Line 1281  class CDLIFileFolder(versionedFileFolder
                   
         return ret          return ret
           
       def checkCatalog(self,fn):
           """check if fn is in the catalog"""
           #TODO add checkCatalog
     
     def uploadATF(self,upload,basketId=0,RESPONSE=None):      def refreshTxt(self,txt=""):
         """upload an atf file"""          """txt fuer refresh"""
         #TODO: add comments  
         #TODO: finish uploadATF  
         basketId=str(basketId)  
                   
           return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,self.threadName)
                   
                   
         dir=mkdtemp()      def getResult(self):
         changed=[]         """result of thread"""
         errors=[]         try:
         newPs=[]          return self._v_uploadATF.getResult()
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)         except:
           return "One moment, please"
                   
         if basketId == '0':      def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
             basketObj=self.basketContainer.getActiveBasket()          """standard ausgabe"""
             if basketObj:          #self._v_uploadATF.returnValue=None
                 basketId=basketObj.getId()  
           threadName=repeat
           if not threadName or threadName=="":
               tmpVar=False
               thread=uploadATFThread()
               self._v_uploadATF=thread
               #self._xmltrans.start()
               #thread=Thread(target=self._v_uploadATF)
               
               self._v_uploadATF.set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
               #thread.start()
               self._v_uploadATF.start()
   
               
               self.threadName=self._v_uploadATF.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')
               #_v_xmltrans.run()
                                   
         if basketId == '0':  
             basketNameFromId=""  
             basketLen=0  
         else:          else:
             basketNameFromId=getattr(self.basketContainer,basketId).title              #recover thread, if lost
             basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems()              if not hasattr(self,'_v_uploadATF'):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF=thread
                           
               if not self._v_uploadATF.returnValue:
                           
         for fn in os.listdir(dir):  
             founds=self.CDLICatalog.search({'title':fn})      
               
             if len(founds)==0:                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                 newPs.append(fn)                  if wait_template:
                           return wait_template[0][1]()
                                   
             for found in founds:                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                 obj=found.getObject()  
                   return pt(txt='/uploadATF')
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     errors.append(obj)  
                 else:                  else:
                     data=file(os.path.join(dir,fn)).read()  
                     diffs=obj.diff(data)  
                     if diffs[0]>0:  
                         changed.append((obj,diffs))  
                         #hochladen  
                   
         self.REQUEST.SESSION['changed']=[x[0].getId() for x in changed]                  tmp=self._v_uploadATF.returnValue
         self.REQUEST.SESSION['errors']=[x.getId() for x in errors]                  self._v_uploadATF.continueVar=False
         self.REQUEST.SESSION['newPs']=newPs                  
         self.REQUEST.SESSION['tmpdir']=dir                  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)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
         return pt(changed=changed,errors=errors,dir=dir,newPs=newPs,basketLen=basketLen,numberOfFiles=numberOfFiles,                  return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                    basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId)                    basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                                           
     def uploadATFfinally(self,procedure,comment="",basketname='',unlock=None,RESPONSE=None):      def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
         """upload the files"""          """nowupload the files"""
                   
         if procedure=="uploadchanged":  
             uploadFns=self.REQUEST.SESSION['changed']+self.REQUEST.SESSION['newPs']  
                   
         elif procedure=="uploadAll":  
             uploadFns=[]  
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                 if not x in self.REQUEST.SESSION['errors']:  
                     uploadFns.append(x)  
         else:  
             uploadFns=[]  
                           
         for fn in uploadFns:          threadName=repeat
             founds=self.CDLICatalog.search({'title':fn})          if not threadName or threadName=="":
             if len(founds)>0:  
                 self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
   
                 founds[0].getObject().manage_addCDLIFileObject('',comment,self.REQUEST.SESSION['author'],file=file(os.path.join(self.REQUEST.SESSION['tmpdir'],fn)))  
                           
               self._v_uploadATF=uploadATFfinallyThread()
                   
                                   
         newPs=self.REQUEST.SESSION['newPs']              self._v_uploadATF.set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
         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)              self._v_uploadATF.start()
                                   
                   
               self.threadName=self._v_uploadATF.getName()[0:]
               wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   
         #unlock              if wait_template:
         if unlock:                  return wait_template[0][1]()
             unlockFns=[]              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                     if not x in self.REQUEST.SESSION['errors']:  
                         unlockFns.append(x)  
                           
             for fn in unlockFns:              return pt(txt='/uploadATFfinally')
                 founds=self.CDLICatalog.search({'title':fn})              #_v_xmltrans.run()
                 if len(founds)>0:  
                     self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                                         
                     founds[0].getObject().lockedBy=""          else:
               #recover thread, if lost
               if not hasattr(self,'_v_uploadATF'):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF=thread
                                           
         if not (basketname ==''):              if hasattr(self,'_v_uploadATF') and (self._v_uploadATF is not None) and (not self._v_uploadATF.end) :
             basketId=self.basketContainer.getBasketIdfromName(basketname)  
                           
             if not basketId: # create new basket                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                 ob=self.basketContainer.addBasket(basketname)                  if wait_template:
                 basketId=ob.getId()                          return wait_template[0][1]()
             basket=getattr(self.basketContainer,str(basketId))                  
             ids=os.listdir(self.REQUEST.SESSION['tmpdir'])                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
             basket.addObjects(ids,deleteOld=True)                      return pt(txt='/uploadATFfinally')
               else:
                                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect(self.aq_parent.absolute_url())              RESPONSE.redirect(self.aq_parent.absolute_url())
                   
   
   
   
     def findObjectsFromList(self,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):      def findObjectsFromList(self,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          if upload: # list from file upload
             txt=upload.read()              txt=upload.read()
             txt=txt.replace(",","\n")              txt=txt.replace(",","\n")
Line 1117  class CDLIFileFolder(versionedFileFolder Line 1435  class CDLIFileFolder(versionedFileFolder
             pt=getattr(self,'filelist.html')              pt=getattr(self,'filelist.html')
             return pt(basketName=basketName,numberOfObjects=numberOfObjects)              return pt(basketName=basketName,numberOfObjects=numberOfObjects)
                   
         if list: # got already a list          if list is not None: # got already a list
             ret=[]              ret=[]
             for fileId in list:              for fileId in list:
                 if len(fileId.split("."))==1:                  if len(fileId.split("."))==1:
Line 1132  class CDLIFileFolder(versionedFileFolder Line 1450  class CDLIFileFolder(versionedFileFolder
         if start:          if start:
             RESPONSE.redirect("filelist.html?start:int="+str(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 1208  class CDLIFileFolder(versionedFileFolder Line 1529  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):      def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):
         """import files"""          """import files"""
                   
         if not files:          if not files:
Line 1218  class CDLIFileFolder(versionedFileFolder Line 1539  class CDLIFileFolder(versionedFileFolder
             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(self,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(self,folder,folder)
                 fobj=getattr(self,folder)                  fobj=getattr(self,folder)
Line 1281  def manage_addCDLIFileFolder(self, id, t Line 1604  def manage_addCDLIFileFolder(self, id, t
     if REQUEST is not None:      if REQUEST is not None:
         return self.manage_main(self, REQUEST, update_menu=1)          return self.manage_main(self, REQUEST, update_menu=1)
   
   
Removed from v.1.13  
changed lines
  Added in v.1.21

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