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

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

version 1.19, 2006/06/13 18:34:10 version 1.27, 2006/06/17 15:03:19
Line 17  from threading import Thread Line 17  from threading import Thread
 from ZPublisher.HTTPRequest import HTTPRequest  from ZPublisher.HTTPRequest import HTTPRequest
 from ZPublisher.HTTPResponse import HTTPResponse  from ZPublisher.HTTPResponse import HTTPResponse
 from ZPublisher.BaseRequest import RequestContainer  from ZPublisher.BaseRequest import RequestContainer
   import threading
       
   
 global tmpVar  
   
 class uploadATFfinallyThread(Thread):  class uploadATFfinallyThread(Thread):
       """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
     
     def __init__(self):      def __init__(self):
           """init for uploadATFfinallyThread"""
         self.continueVar=True          self.continueVar=True
         self.returnValue=None          self.returnValue=None
         self.end=False          self.end=False
         Thread.__init__(self)          Thread.__init__(self)
                         
     def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):      def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):
         """set values"""          """set start values for the thread"""
         self.procedure=procedure          self.procedure=procedure
         self.comment=comment          self.comment=comment
         self.basketname=basketname          self.basketname=basketname
Line 39  class uploadATFfinallyThread(Thread): Line 42  class uploadATFfinallyThread(Thread):
         self.serverport=serverport          self.serverport=serverport
                   
     def __call__(self):      def __call__(self):
         """wait"""          """call of the thread (equals run)"""
         self.run()          self.run()
         return True          return True
           
     def getContext(self, app,serverport="8080"):      def getContext(self, app,serverport="8080"):
           """get the context within the ZODB"""
           
         resp = HTTPResponse(stdout=None)          resp = HTTPResponse(stdout=None)
         env = {          env = {
             'SERVER_NAME':'localhost',              'SERVER_NAME':'localhost',
Line 55  class uploadATFfinallyThread(Thread): Line 60  class uploadATFfinallyThread(Thread):
                       
           
     def run(self):      def run(self):
           """run"""
   
         self.result=""          self.result=""
           #find context within ZODB
         from Zope import DB          from Zope import DB
         conn = DB.open()          conn = DB.open()
         root = conn.root()          root = conn.root()
         app  = root['Application']          app  = root['Application']
         ctx = self.getContext(app,serverport=self.serverport)          ctx = self.getContext(app,serverport=self.serverport)
   
           #add the files
         self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)          self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
           #commit the transactions
         get_transaction().commit()          get_transaction().commit()
         conn.close()          conn.close()
           #set flag for end of this method
         self.end=True          self.end=True
         return True          return True
           
       def __del__(self):
           """delete"""
           
           
       
     def getResult(self):      def getResult(self):
           """method for accessing result"""
           
         return self.result          return self.result
             
     def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):      def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
         """upload the files"""          """upload the files"""
           #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
         ctx2=ctx.cdliRoot          ctx2=ctx.cdliRoot
         
         self.result+="<h2>Start processing</h2>"          self.result+="<h2>Start processing</h2>"
           
           #shall I only upload the changed files?
         if procedure=="uploadchanged":          if procedure=="uploadchanged":
               
             uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])              uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])
                   
           #or all
         elif procedure=="uploadAll":          elif procedure=="uploadAll":
             uploadFns=[]              uploadFns=[]
             for x in os.listdir(SESSION['tmpdir']):              for x in os.listdir(SESSION['tmpdir']):
                 if not x in SESSION['errors']:                  if not x in SESSION['errors']:
                     uploadFns.append(x)                      uploadFns.append(x)
                       
           #or maybe nothing
         elif procedure=="noupload":          elif procedure=="noupload":
                         return True                          return True
         else:          else:
             uploadFns=[]              uploadFns=[]
                           
           #do first the changed files    
         for fn in uploadFns:          for fn in uploadFns:
             founds=ctx2.CDLICatalog.search({'title':fn})              founds=ctx2.CDLICatalog.search({'title':fn})
             if len(founds)>0:              if len(founds)>0:
Line 99  class uploadATFfinallyThread(Thread): Line 123  class uploadATFfinallyThread(Thread):
                 founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=file(os.path.join(SESSION['tmpdir'],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']          newPs=SESSION['newPs']
         if len(newPs)>0:          if len(newPs)>0:
             tmpDir=SESSION['tmpdir']              tmpDir=SESSION['tmpdir']
             self.result+="<p>Adding files</p>"              self.result+="<p>Adding files</p>"
             ctx2.cdli_main.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)              #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          
           #unlock locked files?
         if unlock:          if unlock:
             self.result+="<p>Unlock files</p>"              self.result+="<p>Unlock files</p>"
             unlockFns=[]              unlockFns=[]
Line 123  class uploadATFfinallyThread(Thread): Line 149  class uploadATFfinallyThread(Thread):
                                         
                     founds[0].getObject().lockedBy=""                      founds[0].getObject().lockedBy=""
                                           
           #if a basketname is give, add files to the basket
         if not (basketname ==''):          if not (basketname ==''):
             self.result+="<p>Add basket</p>"              self.result+="<p>Add basket</p>"
             basketId=ctx2.basketContainer.getBasketIdfromName(basketname)              basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
Line 142  class uploadATFfinallyThread(Thread): Line 169  class uploadATFfinallyThread(Thread):
         return True          return True
           
 class uploadATFThread(Thread):  class uploadATFThread(Thread):
       """class for checking the files befor uploading"""
           
     def __init__(self):      def __init__(self):
           """initialise"""
           
         self.continueVar=True          self.continueVar=True
         self.returnValue=None          self.returnValue=None
                   
Line 151  class uploadATFThread(Thread): Line 181  class uploadATFThread(Thread):
                   
                   
     def set(self,upload,basketId,username,serverport="8080"):      def set(self,upload,basketId,username,serverport="8080"):
           """set start values for the thread"""
         self.result=""          self.result=""
         self.upload=upload          self.upload=upload
         self.basketId=basketId          self.basketId=basketId
Line 158  class uploadATFThread(Thread): Line 189  class uploadATFThread(Thread):
         self.serverport=serverport          self.serverport=serverport
                   
     def __call__(self):      def __call__(self):
         """wait"""          """call method """
         self.run()          self.run()
         return True          return True
           
     def getContext(self, app,serverport="8080"):      def getContext(self, app,serverport="8080"):
           """get the context within the ZODB"""
         resp = HTTPResponse(stdout=None)          resp = HTTPResponse(stdout=None)
         env = {          env = {
             'SERVER_NAME':'localhost',              'SERVER_NAME':'localhost',
Line 175  class uploadATFThread(Thread): Line 207  class uploadATFThread(Thread):
     def run(self):      def run(self):
             
         self.result=""          self.result=""
           #find context within ZODB
         from Zope import DB          from Zope import DB
         conn = DB.open()          conn = DB.open()
         root = conn.root()          root = conn.root()
Line 182  class uploadATFThread(Thread): Line 215  class uploadATFThread(Thread):
         ctx = self.getContext(app,serverport=self.serverport)          ctx = self.getContext(app,serverport=self.serverport)
         self.uploadATFThread(ctx,self.upload,self.basketId)          self.uploadATFThread(ctx,self.upload,self.basketId)
                   
           ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
   
           get_transaction().commit()
           
         while self.continueVar:          while self.continueVar:
             pass              pass
         get_transaction().abort()          
         conn.close()          conn.close()
   
                   
     def getResult(self):      def getResult(self):
           """method for accessing result"""
         return self.result          return self.result
           
     def uploadATFThread(self,ctx,upload,basketId=0):      def uploadATFThread(self,ctx,upload,basketId=0):
         """upload an atf file"""          """upload an atf file"""
         #TODO: add comments          #TODO: add comments
         #TODO: finish uploadATF          #TODO: finish uploadATF
         self.result="<html><body><h2>I am loading your file...</h2>"          self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"
         basketId=str(basketId)  
                   
           #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          ctx2=ctx.cdliRoot
           
           #get temporary file for staging the downloaded and splitted files
         dir=mkdtemp()          dir=mkdtemp()
         changed=[]  
         errors=[]  
         newPs=[]  
         psNotInCatalog=[]  
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)  
                   
           
           changed=[] # changed files
           errors=[]  # files with errors
           newPs=[]   # new p filed
           psNotInCatalog=[] # files not in the catalog
           
           #split the uploadedd atf file
           basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)
           
           #find basketId if not set
           
           #get active abaket
         if basketId == '0':          if basketId == '0':
             basketObj=ctx2.basketContainer.getActiveBasket()              basketObj=ctx2.basketContainer.getActiveBasket()
             if basketObj:              if basketObj:
                 basketId=basketObj.getId()                  basketId=basketObj.getId()
                                   
           #if there is no active baske and no basketid given, id is empty, else get besketname and length
         if basketId == '0':          if basketId == '0':
             basketNameFromId=""              basketNameFromId=""
             basketLen=0              basketLen=0
Line 220  class uploadATFThread(Thread): Line 270  class uploadATFThread(Thread):
             basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()              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>"          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):          for fn in os.listdir(dir):
                           
             self.result+="<p>check:%s</p>"%fn              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):              if ctx2.cdli_main.checkCatalog(fn):
                 psNotInCatalog.append(fn)                  psNotInCatalog.append(fn)
                                   
                               #check if p-file already at the server  
             founds=ctx2.CDLICatalog.search({'title':fn})                  founds=ctx2.CDLICatalog.search({'title':fn})    
               
               #if not than add filename to the list of newfiles
             if len(founds)==0:              if len(founds)==0:
                 newPs.append(fn)                  newPs.append(fn)
                                   
               #if p file alread at the server    
             for found in founds:              for found in founds:
                   #analyse the differences to the actual file
                 obj=found.getObject()                  obj=found.getObject()
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.username):                  if (not obj.lockedBy=='') and (not obj.lockedBy==self.username):
Line 247  class uploadATFThread(Thread): Line 304  class uploadATFThread(Thread):
                         changed.append((obj,diffs))                          changed.append((obj,diffs))
                         #hochladen                          #hochladen
                   
                 #ready, set the returnValues
         self.result+="<h3>Done</h3></body></html>"          self.result+="<h3>Done</h3></body></html>"
                   
         self.returnValue={}          self.returnValue={}
Line 997  def manage_addCDLIBasketVersion(self,use Line 1054  def manage_addCDLIBasketVersion(self,use
     else:      else:
         return ob          return ob
           
 class CDLIFileObject(versionedFileObject):  class CDLIFileObject(versionedFileObject,CatalogAware):
     """CDLI file object"""      """CDLI file object"""
           
     meta_type="CDLI File Object"      meta_type="CDLI File Object"
       default_catalog='CDLIObjectsCatalog'
           
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
           
    
       security.declarePublic('makeThisVersionCurrent')
       
       def makeThisVersionCurrent_html(self):
           """form for making this version current"""
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
           return pt()                 
       def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
           """copy this version to current"""
           parent=self.aq_parent
           
           
           newversion=parent.manage_addCDLIFileObject('',comment,author)
           newversion.data=self.data[0:]
                                           
           if RESPONSE is not None:
               RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
   
   
           return True
       
       security.declarePublic('view')
                                           
     def view(self):      def view(self):
         """view file"""          """view file"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
Line 1063  class CDLIFile(versionedFile,CatalogAwar Line 1145  class CDLIFile(versionedFile,CatalogAwar
     meta_type="CDLI file"      meta_type="CDLI file"
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
           
       #security.declarePublic('history')
       def history(self):
           """history"""  
   
           ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
           if ext:
               return getattr(self,ext[0][1].getId())()
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
           return pt()
   
           
     
     def isContainedInBaskets(self,context=None):      def isContainedInBaskets(self,context=None):
Line 1133  class CDLIFile(versionedFile,CatalogAwar Line 1226  class CDLIFile(versionedFile,CatalogAwar
                   
         manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)          manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)
         objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))          objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
           try:
             #FIXME: wozu ist das gut?
         self.REQUEST.SESSION['objID_parent']=self.getId()          self.REQUEST.SESSION['objID_parent']=self.getId()
           except:
             pass
         if RESPONSE:          if RESPONSE:
             obj=self.ZopeFind(self,obj_ids=[id])[0][1]              obj=self.ZopeFind(self,obj_ids=[id])[0][1]
             if obj.getSize()==0:              if obj.getSize()==0:
Line 1157  def manage_addCDLIFileForm(self): Line 1253  def manage_addCDLIFileForm(self):
 def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):  def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
     """add the OSAS_root"""      """add the OSAS_root"""
     newObj=CDLIFile(id,title,lockedBy,author)      newObj=CDLIFile(id,title,lockedBy,author)
                                           
       tryToggle=True
       tryCount=0
       
     
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
         
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   
   
 def splitatf(fh,dir=None):  def splitatf(fh,dir=None,ext=None):
     """split it"""      """split it"""
     ret=None      ret=None
     nf=None      nf=None
       i=0
     for line in fh.readlines():      for line in fh.readlines():
           if ext:
               i+=1
               if (i%100)==0:
                   ext.result+="."
               if i==10000:
                   i=0
                   ext.result+="<br>"
         #check if basket name is in the first line          #check if basket name is in the first line
         if line.find("#atf basket")>=0:          if line.find("#atf basket")>=0:
             ret=line.replace('#atf basket ','')              ret=line.replace('#atf basket ','')
Line 1200  class CDLIFileFolder(versionedFileFolder Line 1311  class CDLIFileFolder(versionedFileFolder
     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
           
       tmpStore2={}
     def setTemp(self,name,value):      def setTemp(self,name,value):
         """set tmp"""          """set tmp"""
   
Line 1241  class CDLIFileFolder(versionedFileFolder Line 1354  class CDLIFileFolder(versionedFileFolder
         """check if fn is in the catalog"""          """check if fn is in the catalog"""
         #TODO add checkCatalog          #TODO add checkCatalog
                     
     def refreshTxt(self,txt=""):  
         """txt fuer refresh"""  
     
         return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,self.threadName)  
   
       
     def getResult(self):  
        """result of thread"""  
        try:  
         return self._v_uploadATF.getResult()  
        except:  
         return "One moment, please"  
       
     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  
   
             self._v_uploadATF=uploadATFThread()  
              
             #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()  
               
         else:  
   
             if not self._v_uploadATF.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')  
                   
             else:  
   
                 tmp=self._v_uploadATF.returnValue  
                 self._v_uploadATF.continueVar=False  
                   
                 self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]  
                 self.REQUEST.SESSION['errors']=[x.getId() for x in tmp['errors']]  
                 self.REQUEST.SESSION['newPs']=tmp['newPs']  
                 self.REQUEST.SESSION['tmpdir']=tmp['dir']  
         
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)  
                 return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],  
                   basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])  
                                          
     def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):  
         """nowupload the files"""  
          
          
          
         threadName=repeat  
         if not threadName or threadName=="":  
               
              
             self._v_uploadATF=uploadATFfinallyThread()  
   
           
             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'])  
   
             self._v_uploadATF.start()  
   
                           
             self.threadName=self._v_uploadATF.getName()[0:]      def findObjectsFromListWithVersion(self,list):
             wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])          """find objects from a list with versions
           @param list: list of tuples  (cdliFile,version)
           """
   
             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')  
             #_v_xmltrans.run()  
                   
         else:          #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
           #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                           
             if hasattr(self,'_v_uploadATF') and (self._v_uploadATF is not None) and (not self._v_uploadATF.end) :  
   
                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])          pt=getattr(self,'filelistVersioned.html')
                 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')  
             else:  
   
               if RESPONSE is not None:          return pt(search=list)
                   RESPONSE.redirect(self.aq_parent.absolute_url())  
                                   
                                                                         
   
       def findObjectsFromList(self,display=False,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)"""
                                                                                 
                   
Line 1390  class CDLIFileFolder(versionedFileFolder Line 1410  class CDLIFileFolder(versionedFileFolder
   
                 ret+=self.CDLICatalog({'title':fileId})                  ret+=self.CDLICatalog({'title':fileId})
             #TODO: get rid of one of these..              #TODO: get rid of one of these..
             self.REQUEST.SESSION['fileIds']=[x.getObject().getId() for x in ret]#store fieldIds in session for further usage              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']              self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
               
               if display:
                   pt=getattr(self,'filelist.html')
                   
                   return pt(search=ids)
               else:      
             return ret              return ret
                   
           
           
         if start:          if start:
             RESPONSE.redirect("filelist.html?start:int="+str(start))              RESPONSE.redirect("filelist.html?start:int="+str(start))
                                                                                 
Line 1476  class CDLIFileFolder(versionedFileFolder Line 1505  class CDLIFileFolder(versionedFileFolder
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
         return pt()          return pt()
           
       
   manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
   
       
   def manage_addCDLIFileFolder(self, id, title='',
                        createPublic=0,
                        createUserF=0,
                        REQUEST=None):
       """Add a new Folder object with id *id*.
   
       If the 'createPublic' and 'createUserF' parameters are set to any true
       value, an 'index_html' and a 'UserFolder' objects are created respectively
       in the new folder.
       """
       ob=CDLIFileFolder()
       ob.id=str(id)
       ob.title=title
       self._setObject(id, ob)
       ob=self._getOb(id)
   
       checkPermission=getSecurityManager().checkPermission
   
       if createUserF:
           if not checkPermission('Add User Folders', ob):
               raise Unauthorized, (
                     'You are not authorized to add User Folders.'
                     )
           ob.manage_addUserFolder()
   
     
       if REQUEST is not None:
           return self.manage_main(self, REQUEST, update_menu=1)
       
   class CDLIRoot(Folder):
       """main folder for cdli"""
       
       meta_type="CDLIRoot"
       
       def forceunlock(self):
           "break all locks"
           ret=[]
           for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
              un=f[1].forceunlock()
              print un
              if un and un !="":
                  ret.append((f[0],un))
           print ret
           return ret                       
       
       def getChangesByAuthor(self,author,n=100):
           """getChangesByAuthor"""
           zcat=self.CDLIObjectsCatalog
           res=zcat({'lastEditor':author,
                        'sort_on':'getTime',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
                          
           return res
       
       def getChangesByAuthor_html(self,author,n=100):
           """html output for changes by author"""
           tmp={}
           list=[]                         
           for x in self.getChangesByAuthor(author):
              nr=x.getObject().getVersionNumber()
              id=x.getObject().aq_parent.getId()
              #hinzufuegen, wenn Version neuer als die 
              if tmp.get(id,(0,0))[1] < nr:
                   tmp[id]=(x.getObject().aq_parent,nr)
   
        
           return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values())           
           
       def getLastChanges(self,n=100):
           """get the last n changes""" 
           n=int(n)                   
           zcat=self.CDLICatalog
           return zcat({'sort_on':'getLastChangeDate',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
        
       
       def getLastChanges_html(self,n=100):
           """get the last n changes"""
           list = [x.getId for x in self.getLastChanges(n)]
           return self.cdli_main.findObjectsFromList(list=list,display=True)
                                          
       def refreshTxt(self,txt="",threadName=None):
           """txt fuer refresh"""
     
           return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
   
       
       def getResult(self,threadName=None):
          """result of thread"""
          try:
           return self._v_uploadATF[threadName].getResult()
          except:
           return "One moment, please"
       
           
       def checkThreads(self):
           """check threads"""
           return threading.enumerate()
       
       def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
           """standard ausgabe"""
           #self._v_uploadATF.returnValue=None
   
           threadName=repeat
           if not threadName or threadName=="":
               tmpVar=False
          
               thread=uploadATFThread()
               threadName=thread.getName()[0:]                                
               if not hasattr(self,'_v_uploadATF'):
                      self._v_uploadATF={}
                                          
               self._v_uploadATF[threadName]=thread
               #self._xmltrans.start()
               #thread=Thread(target=self._v_uploadATF)
               
               self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
               #thread.start()
               self._v_uploadATF[threadName].start()
   
               
               self.threadName=self._v_uploadATF[threadName].getName()[0:]
               wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
   
               if wait_template:
                   return wait_template[0][1]()
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
               return pt(txt='/uploadATF',threadName=threadName)
               #_v_xmltrans.run()
               
           else:
               #recover thread, if lost
               if not hasattr(self,'_v_uploadATF'):
                  self._v_uploadATF={}
               if not self._v_uploadATF.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF[threadName]=thread
                                          
               if not self._v_uploadATF[threadName].returnValue:
           
   
                   wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   if wait_template:
                           return wait_template[0][1]()
                   
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
   
                   return pt(txt='/uploadATF',threadName=threadName)
                   
               else:
   #                tmp={}
   #                for key in self._v_uploadATF[threadName].returnValue.keys():
   #                        t=self._v_uploadATF[threadName].returnValue[key]
   #                        if type(t) is ListType:
   #                                       tmp[key]=self._v_uploadATF[threadName].returnValue[key][0:]
   #                        else:
   #                                       tmp[key]=self._v_uploadATF[threadName].returnValue[key]
                 
                   tmp=self.cdli_main.tmpStore2[threadName]
                   del(self.cdli_main.tmpStore2[threadName])
                   self._v_uploadATF[threadName].continueVar=False
                   self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]
                   self.REQUEST.SESSION['errors']=[x.getId() for x in tmp['errors']]
                   self.REQUEST.SESSION['newPs']=tmp['newPs']
                   self.REQUEST.SESSION['tmpdir']=tmp['dir']
         
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
                   return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                     basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                                          
       def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
           """nowupload the files"""
          
          
          
           threadName=repeat
           if not threadName or threadName=="":
               thread=uploadATFfinallyThread()
               threadName=thread.getName()[0:]
               self._v_uploadATF[threadName]=thread
   
           
               self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
   
               self._v_uploadATF[threadName].start()
   
               
               
               wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
   
               if wait_template:
                   return wait_template[0][1]()
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
   
               return pt(txt='/uploadATFfinally',threadName=threadName)
               #_v_xmltrans.run()
           
           else:
               #recover thread, if lost
               if not hasattr(self,'_v_uploadATF'):
                  self._v_uploadATF={}
               if not self._v_uploadATF.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF[threadName]=thread
                                          
               if self._v_uploadATF.get(threadName,None) and (self._v_uploadATF[threadName] is not None) and (not self._v_uploadATF[threadName].end) :
   
                   wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   if wait_template:
                           return wait_template[0][1]()
                   
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                   return pt(txt='/uploadATFfinally',threadName=threadName)
               else:
   
                 if RESPONSE is not None:
                     RESPONSE.redirect(self.absolute_url())
   
     def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):      def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):
         """import files"""          """import files"""
           root=self.cdli_main
                   
         if not files:          if not files:
             files=os.listdir(folderName)              files=os.listdir(folderName)
Line 1485  class CDLIFileFolder(versionedFileFolder Line 1741  class CDLIFileFolder(versionedFileFolder
         for f in files:          for f in files:
             folder=f[0:3]              folder=f[0:3]
             f2=f[0:5]              f2=f[0:5]
             obj=self.ZopeFind(self,obj_ids=[folder])              obj=self.ZopeFind(root,obj_ids=[folder])
             if ext:              if ext:
       
                 ext.result+="<p>Adding: %s </p>"%f                  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 1519  class CDLIFileFolder(versionedFileFolder Line 1775  class CDLIFileFolder(versionedFileFolder
                           
         return "ok"          return "ok"
           
 manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())  
   
   manage_addCDLIRootForm=DTMLFile('dtml/rootAdd', globals())
           
 def manage_addCDLIFileFolder(self, id, title='',      
   def manage_addCDLIRoot(self, id, title='',
                      createPublic=0,                       createPublic=0,
                      createUserF=0,                       createUserF=0,
                      REQUEST=None):                       REQUEST=None):
Line 1532  def manage_addCDLIFileFolder(self, id, t Line 1789  def manage_addCDLIFileFolder(self, id, t
     value, an 'index_html' and a 'UserFolder' objects are created respectively      value, an 'index_html' and a 'UserFolder' objects are created respectively
     in the new folder.      in the new folder.
     """      """
     ob=CDLIFileFolder()      ob=CDLIRoot()
     ob.id=str(id)      ob.id=str(id)
     ob.title=title      ob.title=title
     self._setObject(id, ob)      self._setObject(id, ob)
Line 1551  def manage_addCDLIFileFolder(self, id, t Line 1808  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.19  
changed lines
  Added in v.1.27

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