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

version 1.3, 2005/12/08 17:11:31 version 1.53, 2006/12/22 11:56:08
Line 1 Line 1
 """CDLI extensions of the filearchive"""  """CDLI extensions of the filearchive"""
 from Products.versionedFile.versionedFile import *  from Products.versionedFile.extVersionedFile import *
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
 from tempfile import mkstemp,mkdtemp  from tempfile import mkstemp,mkdtemp
 import os.path  import os.path
 import os  import os
 from types import *  from types import *
 import urlparse  import urlparse
   import urllib
   import cgi
   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 Globals import Persistent
   from threading import Thread
   from ZPublisher.HTTPRequest import HTTPRequest
   from ZPublisher.HTTPResponse import HTTPResponse
   from ZPublisher.BaseRequest import RequestContainer
   import threading
   from BTrees.OOBTree import OOBTree
   
   class BasketContent(SimpleItem):
       """classe fuer den Inhalt eines Baskets"""
       
       def __init__(self,content=[]):
           """content"""
           self.contentList=content[0:]
   
 class Basket(Folder):      def getContent(self):
     """shopping basket"""          """get content"""
   
           return self.contentList
       
       def setContent(self,content):
           self.contentList=content[0:]
       
       def numberOfItems(self):
           """number"""
           
           return len(self.getContent())
           
       
   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
       print "ended"
       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['lockerrors']:
                       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=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
               
           
           #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
           lockerrors=[]  # 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 basket 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
               
               data=file(os.path.join(dir,fn)).read()
               #status,msg=checkFile(fn,data,dir)
               status=True
               msg=""
               if not status: # error
                   errors.append((fn,msg))
               else:
                   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 (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
                                   lockerrors.append(fn)
                       else:
                   
                           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['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
           
           #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 438  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 452  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 470  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 131  class BasketObject(Folder): Line 480  class BasketObject(Folder):
   
     def numberOfItems(self):      def numberOfItems(self):
         """return anzahl der elemente im basket"""          """return anzahl der elemente im basket"""
         return len(self.contents)          num=len(self.contents)
           
           return num
           
     def addObjects(self,ids):      def addObjects(self,ids):
         """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 177  class BasketObject(Folder): Line 528  class BasketObject(Folder):
         ret=""          ret=""
         lockedObjects={}          lockedObjects={}
                   
           if self.temp_folder.downloadCounter > 10:
               return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
   
   
         if lock:          if lock:
                           
Line 203  class BasketObject(Folder): Line 557  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              self.temp_folder.downloadCounter+=1 
           self._p_changed=1
           get_transaction().commit()      
   
           
         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']):
                     ret+=object.getLastVersion().data                      ret+=object.getLastVersion().getData()
                                   
                 if lock and object.lockedBy=='':                  if lock and object.lockedBy=='':
                     object.lockedBy=self.REQUEST['AUTHENTICATED_USER']                      object.lockedBy=self.REQUEST['AUTHENTICATED_USER']
Line 218  class BasketObject(Folder): Line 576  class BasketObject(Folder):
         length=len(ret)          length=len(ret)
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)          self.REQUEST.RESPONSE.setHeader("Content-Length",length)
         self.REQUEST.RESPONSE.write(ret)              self.REQUEST.RESPONSE.write(ret)    
           self.temp_folder.downloadCounter-=1 
           self._p_changed=1
           get_transaction().commit()      
                   
                   
 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 598  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 upDateBaskets(self):
           """update content in to objects"""
           
           founds=self.ZopeFind(self,obj_metatypes=['CDLIBasketVersion'],search_sub=1)
   
           for found in founds:
               found[1].updateBasket()
           
       security.declareProtected('manage','deleteBaskets')        
       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)
           
       security.declareProtected('manage','manageBaskets')       
       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())
       
       security.declareProtected('View','getBasketIdfromName')       
       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)
      
   
       security.declareProtected('View','index_html')    
       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 getBasketsId(self):
           """get all baskets als klartext"""
           
           ret=""
           baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
           for basket in baskets:
               com,user,time,values = basket[1].getContentIds()
               ret+= "BASKET:"+com+"\t"+user+"\t"+time+"\n"
               for x in values:
                   ret+= x[0]+"\t"+x[1]+"\n"
           return ret
   
       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="/")
       try:
           qs=cgi.parse_qs(REQUEST['QUERY_STRING'])
           del(qs['basketId'])
       except:
           qs={}
           if REQUEST:
               REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+urllib.urlencode(qs))
               
       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:
               actualNo=founds[0].getObject().getLastVersion().getVersionNumber()
               
           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=[]
           idsTmp= self.objectIds()
           for x in idsTmp:
               try:
                   ids.append(int(x))
               except:
                   pass
           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 updateObjects(self,ids,RESPONSE=None,REQUEST=None):
           """update ids, ids not in the basket the add"""
           if type(ids) is not ListType:
               ids=[ids]
          
           lastVersion=self.getLastVersion() 
           oldContent=lastVersion.content.getContent()
           newContent=[]
           
           #first copy the old
           for obj in oldContent:
               if obj[1].getId() not in ids:
                   newContent.append(obj)
           #now add the new
                  
           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()))
           
   
           content=newContent 
           user=self.getActualUserName()
           
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
           
           obj=self._getOb(ob.getId())
           if RESPONSE:
              
               RESPONSE.redirect(obj.absolute_url())
           
           return obj
       
       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.content.getContent()
   
           if deleteOld:
               oldContent=[]
   
           newContent=[]
           added=0
           for id in ids:
           try:
           founds=self.CDLICatalog.search({'title':id})
           except:
           founds=[]
               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 getContentIds(self):
           """print basket content"""
           ret=[]
           lv=self.getLastVersion()
           for obj in lv.content.getContent():
               ret.append((obj[0].getId(),obj[1].getId()))
           
           
           return lv.getComment(),lv.getUser(),lv.getTime(),ret
   
       def changeBasket(self,ids,submit,RESPONSE=None,REQUEST=None):
           """change a basket"""
           if submit=="update":
               return self.updateObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
           elif submit=="delete":
               return self.deleteObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
               
       def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
           """delete objects"""
           
           if type(ids) is not ListType:
               ids=[ids]
          
           lastVersion=self.getLastVersion() 
           oldContent=lastVersion.content.getContent()
           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(Implicit,Persistent,Folder):
       """version of a basket"""
       
       meta_type="CDLIBasketVersion"
       security=ClassSecurityInfo()
       
       def updateBasket(self):
           """update"""
           try:
               self._setObject('content',BasketContent(self.basketContent))
           except:
               try:
                   if len(self.basketContent)>0:
                       self.content.setContent(self.basketContent)
               except:
                   print "error",self.getId(),self.aq_parent.getId()
           self.basketContent=[]
   
           
       def containsNonActualFiles(self):
           """returns True if basket contains one or more non current files"""
           
           objs=self.getContent()
           for obj in objs:
               if not self.isActual(obj)[0]:
                   return True
           return False
       
       security.declareProtected('View','downloadObjectsAsOneFile')
       def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):
           """download all selected files in one file"""
           
           if self.temp_folder.downloadCounterBaskets > 10000:
               return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
   
   
           if (check=="yes") and self.containsNonActualFiles():
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
               
               return pt(lock=lock)
               
           else:
               
               return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")
           
       def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no"):
           """print do the download"""
   
           ret=""
           lockedObjects={}
   
           self.temp_folder.downloadCounterBaskets+=1 
           self._p_changed=1
           get_transaction().commit()       
       
           if lock:
               
               if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
                   self.temp_folder.downloadCounterBaskets-=1 
                   self._p_changed=1
                   get_transaction().commit()      
                   self.temp_folder.downloadCounterBaskets-=1 
                   self._p_changed=1
                   get_transaction().commit()      
                   return "please login first"
   
               #check if a locked object exist in the basket.
               lockedObjects={}
               for object in self.content.getContent():
   
                   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)
                   
                   self.temp_folder.downloadCounterBaskets-=1 
                   self._p_changed=1
                   get_transaction().commit()      
   
                   return pt()
            
               elif not procedure: #keine fails gesperrt dann alle donwloaden
                   procedure="downloadAll" 
           
           
   
   
           for object in self.content.getContent():
       
                   if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):
                       if current=="no": #version as they are in the basket
                           ret+=str(object[0].getData())+"\n"
                       elif current=="yes":
                           #search current object
                           founds=self.CDLICatalog.search({'title':object[0].getId()})
                           if len(founds)>0:      
                               ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
                               
                   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="#basket: %s\n"%basket_name+ret
   
           self.temp_folder.downloadCounterBaskets-=1 
           self._p_changed=1
           get_transaction().commit()      
           
           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)    
           return True
           
       def numberOfItems(self):
           """return anzahl der elemente im basket"""
           return self.content.numberOfItems()
       
       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.content.getContent()
   
       
       def __init__(self,id,user,comment="",basketContent=[]):
           """ init a basket version"""
           self.id=id
           self.coment=comment
           self._setObject('content',BasketContent(basketContent))
           #self.basketContent=basketContent[0:]a
           self.user=user
           self.time=time.localtime()
           
       def getUser(self):
           """get user"""
           return self.user
       
       def getComment(self):
           """get Comment"""
           return self.comment
    
       security.declareProtected('View','index_html')
       def index_html(self):
               """view the basket"""
   
               if self.REQUEST.get('change',False):
                       ob=self.aq_parent.updateObjects(self.REQUEST['change'])
                      
                       self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new 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(CatalogAware,extVersionedFileObject):
     """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 PrincipiaSearchSource(self):
              """Return cataloguable key for ourselves."""
              return str(self)
          
       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 getFormattedData(self):
           """fromat text"""
           data=self.getData()
           return re.sub("\s\#lem"," #lem",data) #remove return vor #lem
                   
     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('getPNumber')
       def getPNumber(self):
           """get the pnumber"""
           try:
                   txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
           except:
                   txt=self.getData()[0:]
                   
                   return "ERROR"
           try:
               return "P"+txt.group(1)
           except:
               return "ERROR"
   
       security.declarePublic('getDesignation')
       def getDesignation(self):
           """get the designation out of the file"""
           try:
                   txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
           except:
                   txt=self.getData()[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='',
                    REQUEST=None):                               from_tmp=False,REQUEST=None):
     """Add a new File object.      """Add a new File object.
   
     Creates a new File object 'id' with the contents of 'file'"""      Creates a new File object 'id' with the contents of 'file'"""
Line 272  def manage_addCDLIFileObject(self,id,vC= Line 1370  def manage_addCDLIFileObject(self,id,vC=
           
     setattr(self._getOb(id),'author',author)      setattr(self._getOb(id),'author',author)
           
       
     # Now we "upload" the data.  By doing this in two steps, we      # Now we "upload" the data.  By doing this in two steps, we
     # can use a database trick to make the upload more efficient.      # can use a database trick to make the upload more efficient.
     if file:  
       if file and not from_tmp:
         self._getOb(id).manage_upload(file)          self._getOb(id).manage_upload(file)
       elif file and from_tmp:
           self._getOb(id).manage_upload_from_tmp(file)
     if content_type:      if content_type:
         self._getOb(id).content_type=content_type          self._getOb(id).content_type=content_type
   
       self.reindex_object()
       self._getOb(id).reindex_object()
   
     if REQUEST is not None:      if REQUEST is not None:
         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')          REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
           
 class CDLIFile(versionedFile,CatalogAware):  class CDLIFile(extVersionedFile,CatalogAware):
     """CDLI file"""      """CDLI file"""
           
     meta_type="CDLI file"      meta_type="CDLI file"
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
   
     def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):      #security.declarePublic('history')
       def getLastVersionData(self):
           """get last version data"""
           return self.getLastVersion().getData()
   
       def getLastVersionFormattedData(self):
           """get last version data"""
           return self.getLastVersion().getFormattedData()
   
       #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 getBasketFromId(self,basketid, context=None):
           """get basket from id"""
   
           if not context:
               context=self
               
           for basket in self.ZopeFind(context,obj_metatypes=["CDLIBasket"]):
               if basket[0]==basketid:
                   return basket[1]
           else:
               None
   
    
       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='', 
                                    come_from=None,
                                    from_tmp=False,RESPONSE=None):
         """add"""          """add"""
         
         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden          try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
             vC=self.REQUEST['vC']              vC=self.REQUEST['vC']
         except:          except:
             pass              pass
                   
         author=self.REQUEST['author']  
                   
         if changeName=="yes":          if changeName=="yes":
             filename=file.filename              filename=file.filename
Line 311  class CDLIFile(versionedFile,CatalogAwar Line 1489  class CDLIFile(versionedFile,CatalogAwar
                   
   
                   
           
         positionVersionNum=getattr(self,'positionVersionNum','front')          positionVersionNum=getattr(self,'positionVersionNum','front')
                   
         if positionVersionNum=='front':          if positionVersionNum=='front':
Line 324  class CDLIFile(versionedFile,CatalogAwar Line 1501  class CDLIFile(versionedFile,CatalogAwar
                 id=tmp[0]+"_V%i"%self.getVersion()                  id=tmp[0]+"_V%i"%self.getVersion()
                           
                   
         manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)          manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type,from_tmp=from_tmp)
         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()))
           objs=getattr(self,id).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:
                 self.REQUEST.SESSION['objID']=obj.getId()                  self.REQUEST.SESSION['objID']=obj.getId()
Line 336  class CDLIFile(versionedFile,CatalogAwar Line 1519  class CDLIFile(versionedFile,CatalogAwar
                 return pt()                  return pt()
   
             else:              else:
                 RESPONSE.redirect(self.REQUEST['URL2'])                  if come_from and (come_from!=""):
                                           RESPONSE.redirect(come_from+"?change="+self.getId())
                   else:
                       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 1536  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)
       getattr(self,id).reindex_object()
         
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   
   def checkFile(filename,data,folder):
       """check the files"""
       # first check the file name
       fn=filename.split(".") # no extension
   
       if not fn[0][0]=="P":
           return False,"P missing in the filename"
       elif len(fn[0])!=7:
           return False,"P number has not the right length 6"
       else:
           fn=os.path.join(folder,filename)
           stin,out=os.popen4("/usr/bin/atfcheck.plx %s"%fn)
           value=out.read()
           ret= out.close()
   
 def splitatf(fh,dir=None):          if value:
     """split it"""  
           
               return False,"atf checker error: %s"%value
           else:
               return True,""
       
   def splitatf(fh,dir=None,ext=None):
       """split it"""
       ret=None
     nf=None      nf=None
     for line in fh.readlines():      i=0
                 
       for lineTmp in fh.readlines():
       for line in lineTmp.split("\r"):
           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: #old convention
           ret=line.replace('#atf basket ','')
           ret=ret.split('_')[0]
           elif line.find("#basket:")>=0: #new convention
           ret=line.replace('#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 1604  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.replace("\n","")+"\n")
           
     nf.close()      nf.close()
     fh.close()      fh.close()
       return ret,len(os.listdir(dir))
   
           
 class CDLIFileFolder(versionedFileFolder):  class CDLIFileFolder(extVersionedFileFolder):
     """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
       #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
       tmpStore2={}
       def setTemp(self,name,value):
           """set tmp"""
           
     def uploadATF(self,upload,RESPONSE=None):          setattr(self,name,value)
         """upload an atf file"""  
         #TODO: add comments  
         #TODO: finish uploadATF  
         dir=mkdtemp()  
         changed=[]  
         errors=[]  
         newPs=[]  
         splitatf(upload,dir)  
   
         for fn in os.listdir(dir):  
             founds=self.CDLICatalog.search({'path':fn})      
             if len(founds)==0:  
                 newPs.append(fn)  
                                   
             for found in founds:      def delete(self,ids):
                 obj=found.getObject()          """delete this file, i.e. move into a trash folder"""
                
           found=self.ZopeFind(self,obj_ids=['.trash'])
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):          if len(found)<1:
                     errors.append(obj)              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,author=None):
           """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')
                                           
         if RESPONSE is not None:          return pt(search=list,author=author)
             RESPONSE.redirect(self.aq_parent.absolute_url())  
                   
   
     def findObjectsFromList(self,upload,RESPONSE):              
       def findObjectsFromList(self,enterList=None,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()
                                          
           if enterList:
               txt=enterList
               
           if upload or enterList:
         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 fileId.find("*"): #check for wildcards
                           fileId=fileId
                   elif 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 493  class CDLIFileFolder(versionedFileFolder Line 1752  class CDLIFileFolder(versionedFileFolder
                   
         catalog=getattr(self,self.default_catalog)          catalog=getattr(self,self.default_catalog)
         #tf,tfilename=mkstemp()          #tf,tfilename=mkstemp()
       if not hasattr(self.temp_folder,'downloadCounter'):
           self.temp_folder.downloadCounter=0
   
           if getattr(self.temp_folder,'downloadCounter',0) > 5:
               return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
                   
           self.temp_folder.downloadCounter+=1
           self._p_changed=1
           get_transaction().commit()
                   
         list=[(x.getId,x) for x in catalog()]          list=[(x.getId,x) for x in catalog()]
         list.sort(sortF)          list.sort(sortF)
                   
   
           
         RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")          RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
         RESPONSE.setHeader("Content-Type","application/octet-stream")          RESPONSE.setHeader("Content-Type","application/octet-stream")
                  tmp=""
         for l in list:          for l in list:
             obj=l[1].getObject()              obj=l[1].getObject()
                           
Line 508  class CDLIFileFolder(versionedFileFolder Line 1777  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().getData()[0:])
                   self.temp_folder.downloadCounter-=1 
                   self._p_changed=1
           get_transaction().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 541  class CDLIFileFolder(versionedFileFolder Line 1813  class CDLIFileFolder(versionedFileFolder
         return ret          return ret
           
                           
     def getFolders_OLD(self):      security.declareProtected('View','index_html')
         """get all subfolders"""  
         ret=[]  
         folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)  
         for folder in folders:  
             ret.append((folder[1],  
                         len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),  
                         len(getattr(self,self.default_catalog)({'path':folder[0]}))  
                         ))  
         return ret  
       
     def index_html(self):      def index_html(self):
         """main"""          """main"""
         ext=self.ZopeFind(self,obj_ids=["index.html"])          ext=self.ZopeFind(self,obj_ids=["index.html"])
Line 561  class CDLIFileFolder(versionedFileFolder Line 1823  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):  
         """import files"""  
                   
   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"
       downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible
       
       def showInLineIndex(self):
           """get the index for debug purposes"""
           print "show"
           for x in self.lineIndex.iterkeys():
               print "word:",x
               for y in self.lineIndex[x].iterkeys():
                   print "doc",y,self.lineIndex[x][y]
                   
           return self.lineIndex
           
       def searchInLineIndexDocs(self,word):
           """search occurences"""
           return list(self.lineIndex.get(word.upper()).keys())
   
       def getLinesFromIndex(self,word,doc):
           """get lines"""
           return self.lineIndex[word][doc]
   
       def cleanInLineIndex(self):
           """delete InlineIndex"""
           for x in list(self.lineIndex.keys()):
               del(self.lineIndex[x])
           print [x for x in self.lineIndex.keys()]
        
           return "ok"
       
       def storeInLineIndex(self,key,value):
           """store in index"""
        
           if (not hasattr(self,'lineIndex')) or (type(self.lineIndex) is DictType):
               self.lineIndex=OOBTree()
           li=self.lineIndex
           
           if li.has_key(key):
               
               if li[key].has_key(value[0]) and (not (value[1] in li[key][value[0]])):
                   li[key][value[0]].append(value[1]) # add it if now in the array
               else:
                   li[key][value[0]]=[value[1]] # new array for lines
                   
           else:
               
               li[key]=OOBTree()# new btree for lines
               li[key][value[0]]=[value[1]] 
                       
           
           self.lineIndex=li
        
           get_transaction().commit()
           
   
       def showFile(self,fileId):
           """show a file"""
           f=self.CDLICatalog({'title':fileId})
           if not f:
               return ""
           
           return f[0].getObject().getLastVersionFormattedData()
           
       def URLquote(self,str):
           """quote url"""
           return urllib.quote(str)
       
       def URLunquote(self,str):
           """unquote url"""
           return urllib.unquote(str)
       
       
       def forceunlock(self):
           "break all locks"
           ret=[]
           for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
              un=f[1].forceunlock()
   
              if un and un !="":
                  ret.append((f[0],un))
   
           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(),author=author)           
           
       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"""
           ret="<html><body>"
           for thread in threading.enumerate():
              ret+="<p>%s (%s): %s</p>"%(repr(thread),thread.getName(),thread.isAlive())
          
           return ret
                                          
                                              
       
       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]
   #                         repr(tmp[key]),repr(key)
   #                                       
   #                #
                   #tmp=self.cdli_main.tmpStore2[threadName]
                   tmp=self._v_uploadATF[threadName].returnValue
                   
                   self._v_uploadATF[threadName].continueVar=False
                   
                   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])
   
                  
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
   
                   return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],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 redoUpload(self,threadName):
          """redo the upload"""
          tmp=self.cdli_main.tmpStore2[threadName]
          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
          return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],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:]
   
               if (not hasattr(self,'_v_uploadATF')):
                                   self._v_uploadATF={}
   
   
               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/atf", files=None,ext=None):
           """import files"""
           root=self.cdli_main
           count=0
         if not files:          if not files:
             files=os.listdir(folderName)              files=os.listdir(folderName)
                           
         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 588  class CDLIFileFolder(versionedFileFolder Line 2174  class CDLIFileFolder(versionedFileFolder
             else:              else:
                 fobj2=obj2[0][1]                  fobj2=obj2[0][1]
                               
             file2=file(os.path.join(folderName,f))                 file2=os.path.join(folderName,f)  
             id=f              id=f
             manage_addCDLIFile(fobj2,f,'','')              manage_addCDLIFile(fobj2,f,'','')
             id=f              id=f
             ob=fobj2._getOb(f)              ob=fobj2._getOb(f)
             ob.title=id              ob.title=id
                           
             manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')              manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='',from_tmp=True)
             self.CDLICatalog.catalog_object(ob)              self.CDLICatalog.catalog_object(ob)
             #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)              #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)
             #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])              #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])
           count+=1
                           
           if count > 1000:
           print "committing"
           get_transaction().commit()
           count=0
       get_transaction().commit()
         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 2208  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)
Line 634  def manage_addCDLIFileFolder(self, id, t Line 2227  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.3  
changed lines
  Added in v.1.53


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