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

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

version 1.8, 2006/02/28 15:17:52 version 1.19, 2006/06/13 18:34:10
Line 9  import urlparse Line 9  import urlparse
 from OFS.OrderedFolder import OrderedFolder  from OFS.OrderedFolder import OrderedFolder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 import time  import time
   from OFS.Folder import manage_addFolder
   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):
Line 20  class Basket_old(Folder): Line 273  class Basket_old(Folder):
   
     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 number          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 142  class BasketObject_old(Folder): Line 395  class BasketObject_old(Folder):
         """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 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 247  class CDLIBasketContainer(OrderedFolder) Line 500  class CDLIBasketContainer(OrderedFolder)
     """contains the baskets"""      """contains the baskets"""
           
   
           security=ClassSecurityInfo()
     meta_type="CDLIBasketContainer"      meta_type="CDLIBasketContainer"
           
       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)
           
       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())
     def getBasketIdfromName(self,basketname):      def getBasketIdfromName(self,basketname):
         """get id from name"""          """get id from name"""
   
Line 259  class CDLIBasketContainer(OrderedFolder) Line 537  class CDLIBasketContainer(OrderedFolder)
                 return basket[0]                  return basket[0]
         else:          else:
             None              None
       
       security.declareProtected('manage','uploadBasket_html')        
               
     def uploadBasket_html(self,basketId='0'):      def uploadBasket_html(self,basketId='0'):
         """upload an atf file, html form"""          """upload an atf file, html form"""
           
   
         basketId=str(basketId)          basketId=str(basketId)
         if not basketId=='0':          if not basketId=='0':
             basketName=getattr(self.basketContainer,basketId).title              basketName=getattr(self.basketContainer,basketId).title
Line 274  class CDLIBasketContainer(OrderedFolder) Line 557  class CDLIBasketContainer(OrderedFolder)
                   
     def index_html(self):      def index_html(self):
         """stanadard ansicht"""          """stanadard ansicht"""
           
   
   
         ext=self.ZopeFind(self,obj_ids=["index.html"])          ext=self.ZopeFind(self,obj_ids=["index.html"])
         if ext:          if ext:
             return ext[0][1]()              return ext[0][1]()
Line 364  class CDLIBasketContainer(OrderedFolder) Line 650  class CDLIBasketContainer(OrderedFolder)
     def setActiveBasket(self,basketId,REQUEST=None):      def setActiveBasket(self,basketId,REQUEST=None):
         """store active basketId in a cookie"""          """store active basketId in a cookie"""
         self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")          self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
           
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(REQUEST['URL1'])              REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+REQUEST['QUERY_STRING'])
                           
     def getActiveBasket(self):      def getActiveBasket(self):
         """get active basket from cookie"""          """get active basket from cookie"""
Line 452  class CDLIBasket(Folder,CatalogAware): Line 739  class CDLIBasket(Folder,CatalogAware):
         """teste ob im basket die aktuelle version ist"""          """teste ob im basket die aktuelle version ist"""
         actualNo=obj[1].getLastVersion().getVersionNumber()          actualNo=obj[1].getLastVersion().getVersionNumber()
         storedNo=obj[0].getVersionNumber()          storedNo=obj[0].getVersionNumber()
           
           founds=self.CDLICatalog.search({'title':obj[0].getId()})
           if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
               return False, -1
           
         if actualNo==storedNo:          if actualNo==storedNo:
             return True              return True , 0
         else:          else:
             return False              return False, actualNo
                   
     def history(self):      def history(self):
         """history"""            """history"""  
Line 498  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 523  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)
           
         return added          return added
           
     def deleteObjects(self,ids,RESPONSE=None):      def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
         """delete objects"""          """delete objects"""
         #TODO: implement delete Objects          
           if type(ids) is not ListType:
               ids=[ids]
          
           lastVersion=self.getLastVersion() 
           oldContent=lastVersion.basketContent[0:]
           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):  def manage_addCDLIBasketForm(self):
     """add the CDLIBasketContainer form"""      """add the CDLIBasketContainer form"""
Line 658  class CDLIBasketVersion(SimpleItem): Line 970  class CDLIBasketVersion(SimpleItem):
         objId=result[1].getTitle()          objId=result[1].getTitle()
         founds=self.CDLICatalog.search({'title':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().getLastVersion().absolute_url()
                     
         else: #assume version number          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().getLastVersion().absolute_url()+'/'+objId
         
 def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):  def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
     """add a version"""      """add a version"""
Line 690  class CDLIFileObject(versionedFileObject Line 1002  class CDLIFileObject(versionedFileObject
           
     meta_type="CDLI File Object"      meta_type="CDLI File Object"
           
       security=ClassSecurityInfo()
                   
     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('getDesignation')
       def getDesignation(self):
           """get the designation out of the file"""
           try:
                   txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.data[0:])
           except:
                   txt=self.data[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='',
Line 747  class CDLIFile(versionedFile,CatalogAwar Line 1074  class CDLIFile(versionedFile,CatalogAwar
         if not context:          if not context:
             context=self              context=self
                           
         return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]          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):      def addCDLIFileObjectForm(self):
Line 768  class CDLIFile(versionedFile,CatalogAwar Line 1103  class CDLIFile(versionedFile,CatalogAwar
         except:          except:
             pass              pass
                   
         author=self.REQUEST['author']  
                   
         if changeName=="yes":          if changeName=="yes":
             filename=file.filename              filename=file.filename
Line 809  class CDLIFile(versionedFile,CatalogAwar Line 1143  class CDLIFile(versionedFile,CatalogAwar
                 return pt()                  return pt()
   
             else:              else:
                 RESPONSE.redirect(self.REQUEST['URL2'])                  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 857  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):
           """delete this file, i.e. move into a trash folder"""
                
           found=self.ZopeFind(self,obj_ids=['.trash'])
           
           if len(found)<1:
               manage_addCDLIFileFolder(self, '.trash',title="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)
           
     def getVersionNumbersFromIds(self,ids):      def getVersionNumbersFromIds(self,ids):
         """get the numbers of the current versions of documents described by their ids"""          """get the numbers of the current versions of documents described by their ids"""
                   
         ret=[]          ret=[]
         searchStr=" OR ".join(ids)          searchStr=" OR ".join(ids)
                   
         founds=self.CDLICatalog.search({'path':searchStr})          founds=self.CDLICatalog.search({'title':searchStr})
                   
         for found in founds:          for found in founds:
             lastVersion=found.getObject().getLastVersion()              lastVersion=found.getObject().getLastVersion()
Line 879  class CDLIFileFolder(versionedFileFolder Line 1237  class CDLIFileFolder(versionedFileFolder
                   
         return ret          return ret
           
       def checkCatalog(self,fn):
           """check if fn is in the catalog"""
           #TODO add checkCatalog
     
     def uploadATF(self,upload,basketId=0,RESPONSE=None):      def refreshTxt(self,txt=""):
         """upload an atf file"""          """txt fuer refresh"""
         #TODO: add comments  
         #TODO: finish uploadATF  
         basketId=str(basketId)  
                   
           return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,self.threadName)
                   
                   
         dir=mkdtemp()      def getResult(self):
         changed=[]         """result of thread"""
         errors=[]         try:
         newPs=[]          return self._v_uploadATF.getResult()
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)         except:
         if basketId == '0':          return "One moment, please"
             basketNameFromId=""      
             basketLen=0      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:          else:
             basketNameFromId=getattr(self.basketContainer,basketId).title  
             basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems()  
                           
               if not self._v_uploadATF.returnValue:
                           
         for fn in os.listdir(dir):  
             founds=self.CDLICatalog.search({'title':fn})      
               
             if len(founds)==0:                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                 newPs.append(fn)                  if wait_template:
                           return wait_template[0][1]()
                                   
             for found in founds:                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                 obj=found.getObject()  
                   return pt(txt='/uploadATF')
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     errors.append(obj)  
                 else:                  else:
                     data=file(os.path.join(dir,fn)).read()  
                     diffs=obj.diff(data)  
                     if diffs[0]>0:  
                         changed.append((obj,diffs))  
                         #hochladen  
                   
         self.REQUEST.SESSION['changed']=[x[0].getId() for x in changed]                  tmp=self._v_uploadATF.returnValue
         self.REQUEST.SESSION['errors']=[x.getId() for x in errors]                  self._v_uploadATF.continueVar=False
         self.REQUEST.SESSION['newPs']=newPs                  
         self.REQUEST.SESSION['tmpdir']=dir                  self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]
                   self.REQUEST.SESSION['errors']=[x.getId() for x in tmp['errors']]
                   self.REQUEST.SESSION['newPs']=tmp['newPs']
                   self.REQUEST.SESSION['tmpdir']=tmp['dir']
               
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
         return pt(changed=changed,errors=errors,dir=dir,newPs=newPs,basketLen=basketLen,numberOfFiles=numberOfFiles,                  return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                    basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId)                    basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                                           
     def uploadATFfinally(self,procedure,comment="",basketname='',unlock=None,RESPONSE=None):      def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
         """upload the files"""          """nowupload the files"""
                   
         if procedure=="uploadchanged":  
             uploadFns=self.REQUEST.SESSION['changed']+self.REQUEST.SESSION['newPs']  
                   
         elif procedure=="uploadAll":  
             uploadFns=[]  
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                 if not x in self.REQUEST.SESSION['errors']:  
                     uploadFns.append(x)  
         else:  
             uploadFns=[]  
                           
         for fn in uploadFns:          threadName=repeat
             founds=self.CDLICatalog.search({'path':fn})          if not threadName or threadName=="":
             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)))  
                           
                   
               self._v_uploadATF=uploadATFfinallyThread()
                                   
         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)              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()
                   
                   
         #unlock              self.threadName=self._v_uploadATF.getName()[0:]
         if unlock:              wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
             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:              if wait_template:
                 founds=self.CDLICatalog.search({'path':fn})                  return wait_template[0][1]()
                 if len(founds)>0:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                     self.REQUEST['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                                         
                     founds[0].getObject().lockedBy=""              return pt(txt='/uploadATFfinally')
               #_v_xmltrans.run()
                                           
         if not (basketname ==''):          else:
             basketId=self.basketFolder.getBasketIdfromName(basketname)  
                           
             basket=getattr(self.basketFolder,basketId)              if hasattr(self,'_v_uploadATF') and (self._v_uploadATF is not None) and (not self._v_uploadATF.end) :
             ids=os.listdir(self.REQUEST.SESSION['tmpdir'])  
             basket.addObjects(ids,deleteOld=True)                      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')
               else:
                                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect(self.aq_parent.absolute_url())              RESPONSE.redirect(self.aq_parent.absolute_url())
                   
   
   
   
     def findObjectsFromList(self,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):      def findObjectsFromList(self,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
         """findObjectsFromList (, TAB oder LINE separated)"""          """findObjectsFromList (, TAB oder LINE separated)"""
                                          
           
         if upload: # list from file upload          if upload: # list from file upload
             txt=upload.read()              txt=upload.read()
             txt=txt.replace(",","\n")              txt=txt.replace(",","\n")
             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
Line 1009  class CDLIFileFolder(versionedFileFolder Line 1382  class CDLIFileFolder(versionedFileFolder
             pt=getattr(self,'filelist.html')              pt=getattr(self,'filelist.html')
             return pt(basketName=basketName,numberOfObjects=numberOfObjects)              return pt(basketName=basketName,numberOfObjects=numberOfObjects)
                   
         if list: # got already a list          if list is not None: # got already a list
             ret=[]              ret=[]
             for fileId in list:              for fileId in list:
                 if len(fileId.split("."))==1:                  if len(fileId.split("."))==1:
Line 1024  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))
           
   
   
       security.declareProtected('Manage','createAllFilesAsSingleFile')
     def createAllFilesAsSingleFile(self,RESPONSE=None):      def createAllFilesAsSingleFile(self,RESPONSE=None):
         """download all files"""          """download all files"""
                   
Line 1047  class CDLIFileFolder(versionedFileFolder Line 1423  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().data[0:])
         #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 1100  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 1110  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 1173  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.8  
changed lines
  Added in v.1.19

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