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

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

version 1.15, 2006/05/04 14:40:09 version 1.19, 2006/06/13 18:34:10
Line 11  from OFS.SimpleItem import SimpleItem Line 11  from OFS.SimpleItem import SimpleItem
 import time  import time
 from OFS.Folder import manage_addFolder  from OFS.Folder import manage_addFolder
 import re  import re
   from AccessControl import ClassSecurityInfo
   from Acquisition import Implicit
   from threading import Thread
   from ZPublisher.HTTPRequest import HTTPRequest
   from ZPublisher.HTTPResponse import HTTPResponse
   from ZPublisher.BaseRequest import RequestContainer
   
   global tmpVar
   
   class uploadATFfinallyThread(Thread):
    
       def __init__(self):
           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 values"""
           self.procedure=procedure
           self.comment=comment
           self.basketname=basketname
           self.unlock=unlock
           self.SESSION=SESSION
           self.username=username
           self.serverport=serverport
           
       def __call__(self):
           """wait"""
           self.run()
           return True
       
       def getContext(self, app,serverport="8080"):
           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=""
           from Zope import DB
           conn = DB.open()
           root = conn.root()
           app  = root['Application']
           ctx = self.getContext(app,serverport=self.serverport)
   
           self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
           get_transaction().commit()
           conn.close()
           self.end=True
           return True
       
       def getResult(self):
           return self.result
        
       def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
           """upload the files"""
           ctx2=ctx.cdliRoot
      
           self.result+="<h2>Start processing</h2>"
           if procedure=="uploadchanged":
         
               uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])
           
           elif procedure=="uploadAll":
               uploadFns=[]
               for x in os.listdir(SESSION['tmpdir']):
                   if not x in SESSION['errors']:
                       uploadFns.append(x)
           elif procedure=="noupload":
                           return True
           else:
               uploadFns=[]
               
           for fn in uploadFns:
               founds=ctx2.CDLICatalog.search({'title':fn})
               if len(founds)>0:
                   SESSION['author']=str(username)
                   self.result+="<p>Changing : %s"%fn
                   founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=file(os.path.join(SESSION['tmpdir'],fn)))
               
           
                   
           newPs=SESSION['newPs']
           if len(newPs)>0:
               tmpDir=SESSION['tmpdir']
               self.result+="<p>Adding files</p>"
               ctx2.cdli_main.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
                   
           
           
           #unlock
           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 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):
       
       def __init__(self):
           self.continueVar=True
           self.returnValue=None
           
           Thread.__init__(self)
           
           
       def set(self,upload,basketId,username,serverport="8080"):
           self.result=""
           self.upload=upload
           self.basketId=basketId
           self.username=username
           self.serverport=serverport
           
       def __call__(self):
           """wait"""
           self.run()
           return True
       
       def getContext(self, app,serverport="8080"):
           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=""
           from Zope import DB
           conn = DB.open()
           root = conn.root()
           app  = root['Application']
           ctx = self.getContext(app,serverport=self.serverport)
           self.uploadATFThread(ctx,self.upload,self.basketId)
           
           while self.continueVar:
               pass
           get_transaction().abort()
           conn.close()
   
           
       def getResult(self):
           return self.result
       
       def uploadATFThread(self,ctx,upload,basketId=0):
           """upload an atf file"""
           #TODO: add comments
           #TODO: finish uploadATF
           self.result="<html><body><h2>I am loading your file...</h2>"
           basketId=str(basketId)
           
           
           ctx2=ctx.cdliRoot
           dir=mkdtemp()
           changed=[]
           errors=[]
           newPs=[]
           psNotInCatalog=[]
           basketNameFromFile, numberOfFiles=splitatf(upload,dir)
           
           if basketId == '0':
               basketObj=ctx2.basketContainer.getActiveBasket()
               if basketObj:
                   basketId=basketObj.getId()
                   
           if basketId == '0':
               basketNameFromId=""
               basketLen=0
           else:
               basketNameFromId=getattr(ctx2.basketContainer,basketId).title
               basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
               
           
           self.result+="<html><body><h2>I got the files</h2><p>I am checking now the files</p>"
                                          
           for fn in os.listdir(dir):
               
               self.result+="<p>check:%s</p>"%fn
               
               if ctx2.cdli_main.checkCatalog(fn):
                   psNotInCatalog.append(fn)
                   
                   
               founds=ctx2.CDLICatalog.search({'title':fn})    
         
               if len(founds)==0:
                   newPs.append(fn)
                   
               for found in founds:
                   obj=found.getObject()
          
                   if (not obj.lockedBy=='') and (not obj.lockedBy==self.username):
                       errors.append(obj)
                   else:
                       data=file(os.path.join(dir,fn)).read()
                       diffs=obj.diff(data)
                       if diffs[0]>0:
                           changed.append((obj,diffs))
                           #hochladen
           
         
           self.result+="<h3>Done</h3></body></html>"
           
           self.returnValue={}
           self.returnValue['changed']=changed
           self.returnValue['errors']=errors
           self.returnValue['newPs']=newPs
           self.returnValue['tmpdir']=dir
           self.returnValue['basketLen']=basketLen
           self.returnValue['numberOfFiles']=numberOfFiles
           self.returnValue['basketNameFromId']=basketNameFromId
           self.returnValue['basketNameFromFile']=basketNameFromFile
           self.returnValue['basketId']=basketId
           self.returnValue['dir']=dir
           
           #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
       
   
 class Basket_old(Folder):  class Basket_old(Folder):
     """shopping basket - alte fassung """      """shopping basket - alte fassung """
Line 208  class BasketObject_old(Folder): Line 461  class BasketObject_old(Folder):
             elif not procedure: #keine fails gesperrt dann alle donwloaden              elif not procedure: #keine fails gesperrt dann alle donwloaden
                 procedure="downloadAll"                   procedure="downloadAll" 
                   
         print procedure      
         for object in self.contents:          for object in self.contents:
                           
                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):                  if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
Line 537  class CDLIBasket(Folder,CatalogAware): Line 790  class CDLIBasket(Folder,CatalogAware):
   
         
           
     def addObjects(self,ids,deleteOld=None):      def addObjects(self,ids,deleteOld=None,username=None):
         """generate a new version of the basket with objects added"""          """generate a new version of the basket with objects added"""
                 
         lastVersion=self.getLastVersion()          lastVersion=self.getLastVersion()
Line 562  class CDLIBasket(Folder,CatalogAware): Line 815  class CDLIBasket(Folder,CatalogAware):
                     added+=1                      added+=1
   
         content=oldContent+newContent          content=oldContent+newContent
                   if not username:
         user=self.getActualUserName()          user=self.getActualUserName()
           else:
               user = username
                   
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)          ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
           
Line 758  class CDLIFileObject(versionedFileObject Line 1013  class CDLIFileObject(versionedFileObject
     def getDesignation(self):      def getDesignation(self):
         """get the designation out of the file"""          """get the designation out of the file"""
     try:      try:
             txt=re.search("&[Pp](.*)= (.*)",self.data[0:])                  txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.data[0:])
         except:          except:
         print self.getId()  
         txt=self.data[0:]          txt=self.data[0:]
         print str(txt)  
                   
         return "ERROR"          return "ERROR"
         try:          try:
Line 938  def splitatf(fh,dir=None): Line 1191  def splitatf(fh,dir=None):
     fh.close()      fh.close()
     return ret,len(os.listdir(dir))      return ret,len(os.listdir(dir))
   
   
 class CDLIFileFolder(versionedFileFolder):  class CDLIFileFolder(versionedFileFolder):
     """CDLI File Folder"""      """CDLI File Folder"""
           
       security=ClassSecurityInfo()
     meta_type="CDLI Folder"      meta_type="CDLI Folder"
     filesMetaType=['CDLI file']      filesMetaType=['CDLI file']
     folderMetaType=['CDLI Folder']      folderMetaType=['CDLI Folder']
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
           
       def setTemp(self,name,value):
           """set tmp"""
   
           setattr(self,name,value)
                                           
                                          
     def delete(self,ids):      def delete(self,ids):
         """delete this file, i.e. move into a trash folder"""          """delete this file, i.e. move into a trash folder"""
                             
Line 978  class CDLIFileFolder(versionedFileFolder Line 1239  class CDLIFileFolder(versionedFileFolder
           
     def checkCatalog(self,fn):      def checkCatalog(self,fn):
         """check if fn is in the catalog"""          """check if fn is in the catalog"""
           #TODO add checkCatalog
                     
       def refreshTxt(self,txt=""):
           """txt fuer refresh"""
                   
     def uploadATF(self,upload,basketId=0,RESPONSE=None):          return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,self.threadName)
         """upload an atf file"""  
         #TODO: add comments  
         #TODO: finish uploadATF  
         basketId=str(basketId)  
                   
                   
       def getResult(self):
          """result of thread"""
          try:
           return self._v_uploadATF.getResult()
          except:
           return "One moment, please"
                   
         dir=mkdtemp()      def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
         changed=[]          """standard ausgabe"""
         errors=[]          #self._v_uploadATF.returnValue=None
         newPs=[]  
         psNotInCatalog=[]  
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)  
                   
         if basketId == '0':          threadName=repeat
             basketObj=self.basketContainer.getActiveBasket()          if not threadName or threadName=="":
             if basketObj:              tmpVar=False
                 basketId=basketObj.getId()  
                                   
         if basketId == '0':              self._v_uploadATF=uploadATFThread()
             basketNameFromId=""  
             basketLen=0  
         else:  
             basketNameFromId=getattr(self.basketContainer,basketId).title  
             basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems()  
                           
               #self._xmltrans.start()
               #thread=Thread(target=self._v_uploadATF)
                           
         for fn in os.listdir(dir):              self._v_uploadATF.set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
               #thread.start()
               self._v_uploadATF.start()
                           
             if self.checkCatalog(fn):  
                 psNotInCatalog.append(fn)  
                                   
               self.threadName=self._v_uploadATF.getName()[0:]
               wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                                   
             founds=self.CDLICatalog.search({'title':fn})                  if wait_template:
                   return wait_template[0][1]()
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
               return pt(txt='/uploadATF')
               #_v_xmltrans.run()
               
             if len(founds)==0:          else:
                 newPs.append(fn)  
                                   
             for found in founds:              if not self._v_uploadATF.returnValue:
                 obj=found.getObject()          
   
                   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')
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     errors.append(obj)  
                 else:                  else:
                     data=file(os.path.join(dir,fn)).read()  
                     diffs=obj.diff(data)  
                     if diffs[0]>0:  
                         changed.append((obj,diffs))  
                         #hochladen  
                   
         self.REQUEST.SESSION['changed']=[x[0].getId() for x in changed]                  tmp=self._v_uploadATF.returnValue
         self.REQUEST.SESSION['errors']=[x.getId() for x in errors]                  self._v_uploadATF.continueVar=False
         self.REQUEST.SESSION['newPs']=newPs                  
         self.REQUEST.SESSION['tmpdir']=dir                  self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]
                   self.REQUEST.SESSION['errors']=[x.getId() for x in tmp['errors']]
                   self.REQUEST.SESSION['newPs']=tmp['newPs']
                   self.REQUEST.SESSION['tmpdir']=tmp['dir']
               
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
         return pt(changed=changed,errors=errors,dir=dir,newPs=newPs,basketLen=basketLen,numberOfFiles=numberOfFiles,                  return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                    basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId)                    basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                                           
     def uploadATFfinally(self,procedure,comment="",basketname='',unlock=None,RESPONSE=None):      def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
         """upload the files"""          """nowupload the files"""
                   
         if procedure=="uploadchanged":  
             uploadFns=self.REQUEST.SESSION['changed']+self.REQUEST.SESSION['newPs']  
                   
         elif procedure=="uploadAll":  
             uploadFns=[]  
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                 if not x in self.REQUEST.SESSION['errors']:  
                     uploadFns.append(x)  
         else:  
             uploadFns=[]  
                           
         for fn in uploadFns:          threadName=repeat
             founds=self.CDLICatalog.search({'title':fn})          if not threadName or threadName=="":
             if len(founds)>0:  
                 self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
   
                 founds[0].getObject().manage_addCDLIFileObject('',comment,self.REQUEST.SESSION['author'],file=file(os.path.join(self.REQUEST.SESSION['tmpdir'],fn)))  
                           
               self._v_uploadATF=uploadATFfinallyThread()
                   
                                   
         newPs=self.REQUEST.SESSION['newPs']              self._v_uploadATF.set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
         if len(newPs)>0:  
             tmpDir=self.REQUEST.SESSION['tmpdir']  
                   
             self.cdli_main.importFiles(comment=comment,author=str(self.REQUEST['AUTHENTICATED_USER']) ,folderName=tmpDir, files=newPs)              self._v_uploadATF.start()
                                   
                   
               self.threadName=self._v_uploadATF.getName()[0:]
               wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   
         #unlock              if wait_template:
         if unlock:                  return wait_template[0][1]()
             unlockFns=[]              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                     if not x in self.REQUEST.SESSION['errors']:  
                         unlockFns.append(x)  
                           
             for fn in unlockFns:              return pt(txt='/uploadATFfinally')
                 founds=self.CDLICatalog.search({'title':fn})              #_v_xmltrans.run()
                 if len(founds)>0:  
                     self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                                         
                     founds[0].getObject().lockedBy=""          else:
                                           
         if not (basketname ==''):              if hasattr(self,'_v_uploadATF') and (self._v_uploadATF is not None) and (not self._v_uploadATF.end) :
             basketId=self.basketContainer.getBasketIdfromName(basketname)  
                           
             if not basketId: # create new basket                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                 ob=self.basketContainer.addBasket(basketname)                  if wait_template:
                 basketId=ob.getId()                          return wait_template[0][1]()
             basket=getattr(self.basketContainer,str(basketId))                  
             ids=os.listdir(self.REQUEST.SESSION['tmpdir'])                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
             basket.addObjects(ids,deleteOld=True)                      return pt(txt='/uploadATFfinally')
               else:
                                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect(self.aq_parent.absolute_url())              RESPONSE.redirect(self.aq_parent.absolute_url())
                   
   
   
   
     def findObjectsFromList(self,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):      def findObjectsFromList(self,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
         """findObjectsFromList (, TAB oder LINE separated)"""          """findObjectsFromList (, TAB oder LINE separated)"""
                                                                                 
Line 1143  class CDLIFileFolder(versionedFileFolder Line 1397  class CDLIFileFolder(versionedFileFolder
         if start:          if start:
             RESPONSE.redirect("filelist.html?start:int="+str(start))              RESPONSE.redirect("filelist.html?start:int="+str(start))
                                                                                 
         print "nothing"  
                   
   
       security.declareProtected('Manage','createAllFilesAsSingleFile')
     def createAllFilesAsSingleFile(self,RESPONSE=None):      def createAllFilesAsSingleFile(self,RESPONSE=None):
         """download all files"""          """download all files"""
                   
Line 1221  class CDLIFileFolder(versionedFileFolder Line 1476  class CDLIFileFolder(versionedFileFolder
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
         return pt()          return pt()
           
     def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None):      def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):
         """import files"""          """import files"""
                   
         if not files:          if not files:
Line 1231  class CDLIFileFolder(versionedFileFolder Line 1486  class CDLIFileFolder(versionedFileFolder
             folder=f[0:3]              folder=f[0:3]
             f2=f[0:5]              f2=f[0:5]
             obj=self.ZopeFind(self,obj_ids=[folder])              obj=self.ZopeFind(self,obj_ids=[folder])
               if ext:
                           
                   ext.result+="<p>Adding: %s </p>"%f
             if not obj:              if not obj:
                 manage_addCDLIFileFolder(self,folder,folder)                  manage_addCDLIFileFolder(self,folder,folder)
                 fobj=getattr(self,folder)                  fobj=getattr(self,folder)
Line 1294  def manage_addCDLIFileFolder(self, id, t Line 1551  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.15  
changed lines
  Added in v.1.19

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