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

Diff for /cdli/cdli_files.py between versions 1.86 and 1.100

version 1.86, 2008/09/29 12:37:37 version 1.100, 2008/10/15 09:54:54
Line 31  from BTrees.IOBTree import IOBTree Line 31  from BTrees.IOBTree import IOBTree
 import cdliSplitter  import cdliSplitter
 from sets import Set  from sets import Set
 import md5  import md5
   from DownloadBasket import DownloadBasketFinallyThread
                                                                                 
 def makelist(mySet):  def makelist(mySet):
         x = list(mySet)          x = list(mySet)
Line 228  class BasketContent(SimpleItem): Line 228  class BasketContent(SimpleItem):
         """content"""          """content"""
         self.contentList=content[0:]          self.contentList=content[0:]
           
     def getContent(self):      def getContent(self,filtered=True):
         """get content"""          """get content"""
           ret=[]
       if filtered:
           for x in self.contentList:
                   if not((x[0] is None) or (x[1] is None)):
                           ret.append(x)
               return ret
   
       else:
         return self.contentList          return self.contentList
           
       def allContent(self):
           """get all content"""
           return self.getContent(filtered=False)
   
     def setContent(self,content):      def setContent(self,content):
         self.contentList=content[0:]          self.contentList=content[0:]
           
Line 401  class uploadATFfinallyThread(Thread): Line 412  class uploadATFfinallyThread(Thread):
                 basketId=ob.getId()                  basketId=ob.getId()
             basket=getattr(ctx2.basketContainer,str(basketId))              basket=getattr(ctx2.basketContainer,str(basketId))
             ids=os.listdir(SESSION['tmpdir'])              ids=os.listdir(SESSION['tmpdir'])
             logging.debug("should add:"+repr(ids))              #logging.debug("should add:"+repr(ids))
             basket.addObjects(ids,deleteOld=True,username=str(username))                  basket.addObjects(ids,deleteOld=True,username=str(username))    
                                 
         logging.debug("uploadatffinallythread uploadfinally done")          logging.debug("uploadatffinallythread uploadfinally done")
Line 640  class CDLIBasketContainer(OrderedFolder) Line 651  class CDLIBasketContainer(OrderedFolder)
                             ret+=str(object[0].getData())+"\n"                              ret+=str(object[0].getData())+"\n"
             elif current=="yes":              elif current=="yes":
                             #search current object                              #search current object
                             logging.debug("current: %s"%object[1].getId().split(".")[0])                              #logging.debug("current: %s"%object[1].getId().split(".")[0])
                             founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})                              founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
                             if len(founds)>0:                                    if len(founds)>0:      
                                 ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"                                  ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
Line 659  class CDLIBasketContainer(OrderedFolder) Line 670  class CDLIBasketContainer(OrderedFolder)
     def deleteBaskets(self,ids=None):      def deleteBaskets(self,ids=None):
         """delete baskets, i.e. move them into trash folder"""          """delete baskets, i.e. move them into trash folder"""
                   
           if ids is None:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
               txt="Sorry, no basket selected!"
               return pt(txt=txt)
                   
         found=self.ZopeFind(self,obj_ids=['trash'])          found=self.ZopeFind(self,obj_ids=['trash'])
                   
Line 670  class CDLIBasketContainer(OrderedFolder) Line 685  class CDLIBasketContainer(OrderedFolder)
                   
         if type(ids) is not ListType:          if type(ids) is not ListType:
             ids=[ids]              ids=[ids]
           logging.error("XERXON:"+repr(ids))
           if len(ids)==0:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
               txt="Sorry, no basket selected!"
               return pt(txt=txt)
      
         cut=self.manage_cutObjects(ids)          cut=self.manage_cutObjects(ids)
         trash.manage_pasteObjects(cut)          trash.manage_pasteObjects(cut)
                   return None
     security.declareProtected('manage','manageBaskets')             security.declareProtected('manage','manageBaskets')       
     def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):      def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):
         """manage baskets, delete or copy"""          """manage baskets, delete or copy"""
         if submit=="delete":          if submit=="delete":
             self.deleteBaskets(ids)              ret= self.deleteBaskets(ids)
                       if ret:
                   return ret
         elif submit=="join":          elif submit=="join":
             flag,msg=self.joinBasket(joinBasket, ids)              flag,msg=self.joinBasket(joinBasket, ids)
             logging.info("joining %s %s"%(flag,msg))              logging.info("joining %s %s"%(flag,msg))
               if not flag:
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
                   
                   return pt(txt=msg)
                           
         elif submit=="subtract":          elif submit=="subtract":
             logging.info("BBBb %s %s"%(basket1,basket2))              logging.info("BBBb %s %s"%(basket1,basket2))
Line 821  class CDLIBasketContainer(OrderedFolder) Line 847  class CDLIBasketContainer(OrderedFolder)
         @param basket2: see above          @param basket2: see above
               
         """          """
           
         logging.info("CCCCC %s %s"%(basket1,basket2))          logging.info("CCCCC %s %s"%(basket1,basket2))
         
         try:          try:
Line 861  class CDLIBasketContainer(OrderedFolder) Line 888  class CDLIBasketContainer(OrderedFolder)
         @param newbasket: name of the new basket          @param newbasket: name of the new basket
         @param oldbaskets: list of baskets to be joined          @param oldbaskets: list of baskets to be joined
         """          """
           if oldBaskets is None:
               return False, "No Baskets selected!"
           
         try:          try:
             newB=self.addBasket(newBasket)              newB=self.addBasket(newBasket)
         except:          except:
             return False, "cannot create the new basket"              return False, "cannot create the new basket"
                   
         newBasketContent={}          newBasketContent={}
        
         for ob in oldBaskets:          for ob in oldBaskets:
             x= getattr(self,ob,None)              x= getattr(self,ob,None)
             if x is None:              if x is None:
Line 1032  class CDLIBasket(Folder,CatalogAware): Line 1063  class CDLIBasket(Folder,CatalogAware):
     def isActual(self,obj):      def isActual(self,obj):
         """teste ob im basket die aktuelle version ist"""          """teste ob im basket die aktuelle version ist"""
         try:          try:
             logging.debug("isActual:"+repr(obj))              #logging.debug("isActual:"+repr(obj))
             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:  
                 actualNo=founds[0].getObject().getLastVersion().getVersionNumber()  
                                   
             if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":              #actualNo=self.getFileObjectLastVersion(obj.getId()).getVersionNumber()
                 return False, -1                  
               #if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
               #    return False, -1
                           
             if actualNo==storedNo:              if actualNo==storedNo:
                 return True , 0                  return True , 0
             else:              else:
                 return False, actualNo                  return False, actualNo
         except:          except:
               logging.error( """is actual: %s (%s %s)"""%(repr(obj),sys.exc_info()[0],sys.exc_info()[1]))
       
             return False, -1              return False, -1
                           
     def history(self):      def history(self):
Line 1196  class CDLIBasket(Folder,CatalogAware): Line 1228  class CDLIBasket(Folder,CatalogAware):
         def swap(x):          def swap(x):
             return (x[1],x[0])              return (x[1],x[0])
                           
           logging.info("add to basket (%s)"%(repr(ids)))
         logging.info("add to basket (%s)"%(self.getId()))          logging.info("add to basket (%s)"%(self.getId()))
         lastVersion=self.getLastVersion()          lastVersion=self.getLastVersion()
                   
Line 1223  class CDLIBasket(Folder,CatalogAware): Line 1256  class CDLIBasket(Folder,CatalogAware):
   
         hash = md5.new(repr(makelist(ids))).hexdigest() # erzeuge hash als identification          hash = md5.new(repr(makelist(ids))).hexdigest() # erzeuge hash als identification
         #logging.debug("JJJJJJJ:"+repr(self.makelist(ids)))          #logging.debug("JJJJJJJ:"+repr(self.makelist(ids)))
         logging.debug("JJJJJJJ:"+repr(hash))  
                                               
         if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash):                         
           if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key("hash"):  #TODO: muss eigentlich  self.cdliRoot.v_tmpStore.has_key(hash): heissen (ohne "), erstmal so gesetzt damit der hash hier nie benutzt wird
             logging.debug("from store!")              logging.debug("from store!")
             newContent=Set(map(swap,self.cdliRoot.v_tmpStore[hash]))              newContent=Set(map(swap,self.cdliRoot.v_tmpStore[hash]))
                     
Line 1233  class CDLIBasket(Folder,CatalogAware): Line 1266  class CDLIBasket(Folder,CatalogAware):
             logging.debug("not from store!")              logging.debug("not from store!")
             newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])              newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])
                   
                   #remove all Elements which are not stored
           if (None,None) in newContent:   
               newContent.remove((None,None))
         content=Set(oldContent).union(newContent)          content=Set(oldContent).union(newContent)
         added = len(content)-len(oldContent)          added = len(content)-len(oldContent)
         if not username:          if not username:
Line 1254  class CDLIBasket(Folder,CatalogAware): Line 1289  class CDLIBasket(Folder,CatalogAware):
                   
         lv=self.getLastVersion()          lv=self.getLastVersion()
         for obj in lv.content.getContent():          for obj in lv.content.getContent():
             logging.info("XXXXXXXXXX %s"%repr(obj))              #logging.info("XXXXXXXXXX %s"%repr(obj))
             ret.append((obj[1].getId(),obj[0].versionNumber))              ret.append((obj[1].getId(),obj[0].versionNumber))
                           
         return ret          return ret
Line 1377  class CDLIBasketVersion(Implicit,Persist Line 1412  class CDLIBasketVersion(Implicit,Persist
                           
             return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")              return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")
                   
     def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no"):      def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no",repeat=None):
         """print do the download"""          """print do the download"""
         logging.debug("HIHHHH")   
           
         ret=""          ret=""
         lockedObjects={}          lockedObjects={}
   
         self.temp_folder.downloadCounterBaskets+=1   
         self._p_changed=1  
         transaction.get().commit()         
           
         if lock:  
                           
           if lock:
               logging.debug("------lock:"+repr(lock))
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':              if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
                 self.temp_folder.downloadCounterBaskets-=1                   
                 self._p_changed=1  
                 transaction.get().commit()        
                 self.temp_folder.downloadCounterBaskets-=1   
                 self._p_changed=1  
                 transaction.get().commit()        
                 return "please login first"                  return "please login first"
   
             #check if a locked object exist in the basket.              #check if a locked object exist in the basket.
Line 1413  class CDLIBasketVersion(Implicit,Persist Line 1442  class CDLIBasketVersion(Implicit,Persist
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects                  self.REQUEST.SESSION['lockedObjects']=lockedObjects
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
                                   
                 self.temp_folder.downloadCounterBaskets-=1   
                 self._p_changed=1  
                 transaction.get().commit()        
   
                 return pt()                  return pt()
                     
Line 1425  class CDLIBasketVersion(Implicit,Persist Line 1451  class CDLIBasketVersion(Implicit,Persist
                   
   
   
         for object in self.content.getContent():          threadName=repeat
                 logging.error("ret:"+repr(object[0]))          if not threadName or threadName=="":
                 logging.error("    -"+repr(procedure))              thread=DownloadBasketFinallyThread()
                 logging.error("    -"+repr(object[1].lockedBy))              threadName=thread.getName()[0:]
                                   
                 if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):              if (not hasattr(self,'_v_downloadBasket')):
                     logging.error("ret1")                                  self._v_downloadBasket={}
                     if current=="no": #version as they are in the basket  
                         logging.error("ret2")  
                         ret+=str(object[0].getData())+"\n"  
                     elif current=="yes":  
                         logging.error("ret3")  
                         #search current object  
                         founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})  
                         if len(founds)>0:        
                             ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"  
                                                           
                 if lock and object[1].lockedBy=='':  
               self._v_downloadBasket[threadName]=thread
               logging.debug("dwonloadfinally:"+repr(self))
   
               if isinstance(self,CDLIBasketVersion):
                   obj=self
               else:
                   obj=self.aq_parent
               logging.debug("dwonloadfinally2:"+repr(obj))
               logging.debug("dwonloadfinally2:"+repr(obj.aq_parent))
   
               obj2=obj.aq_parent
               if not isinstance(obj2,CDLIBasket):
                   obj2=obj2.aq_parent
   
               basketID=obj2.getId()
               versionNumber=obj.getId()
               logging.debug("dwonloadfinally2:"+repr(basketID))
               logging.debug("dwonloadfinally2:"+repr(versionNumber))
   
   
               if lock:
                   logging.debug("-----start locking")
                   for object in self.content.getContent():
                            if object[1].lockedBy =='':
                     object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']                      object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
                   logging.debug("-----finished locking")
                   
                       #obj.lockedBy=user
               self._v_downloadBasket[threadName].set(lock,procedure,self.REQUEST['AUTHENTICATED_USER'],current,basketID,versionNumber)
   
               self._v_downloadBasket[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','downloadBasketWait.zpt')).__of__(self)
   
               return pt(txt=self.absolute_url()+'/downloadObjectsAsOneFileFinally',threadName=threadName,
                                   counter=self._v_downloadBasket[threadName].getCounter(),
                                   number=self._v_downloadBasket[threadName].getNumberOfFiles())
               #_v_xmltrans.run()
           
           else:
               #recover thread, if lost
               if not hasattr(self,'_v_downloadBasket'):
                  self._v_downloadBasket={}
               if not self._v_downloadBasket.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_downloadBasket[threadName]=thread
                                          
               if self._v_downloadBasket.get(threadName,None) and (self._v_downloadBasket[threadName] is not None) and (not self._v_downloadBasket[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','downloadBasketWait.zpt')).__of__(self)
                   return pt(txt=self.absolute_url()+'/downloadObjectsAsOneFileFinally',threadName=threadName,
                             counter=self._v_downloadBasket[threadName].getCounter(),
                             number=self._v_downloadBasket[threadName].getNumberOfFiles())
               else:
                 
                
                 logging.debug("FINISHED")
                 if not self._v_downloadBasket.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_downloadBasket[threadName]=thread
                                          
                 #files = self._v_downloadBasket[threadName].result
                 files=self.basketContainer.resultHash[threadName]
                 lockedFiles=self.basketContainer.resultLockedHash[threadName]
        
                # fh=file("/var/tmp/test")
                 #ret =fh.read()
                   
         if (not isinstance(self.aq_parent,CDLIBasket)):          if (not isinstance(self.aq_parent,CDLIBasket)):
             basket_name=self.aq_parent.aq_parent.title+"_V"+self.getId()              basket_name=self.aq_parent.aq_parent.title+"_V"+self.getId()
Line 1453  class CDLIBasketVersion(Implicit,Persist Line 1548  class CDLIBasketVersion(Implicit,Persist
                   
           
         #write basketname to header of atf file          #write basketname to header of atf file
         ret="#basket: %s\n"%basket_name+ret  
   
         self.temp_folder.downloadCounterBaskets-=1   
         self._p_changed=1  
         transaction.get().commit()        
                   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)          self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")          self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
         length=len(ret)                #length=len(ret)
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)                #self.REQUEST.RESPONSE.setHeader("Content-Length",length)
           
                 ret="#basket: %s\n"%basket_name
         self.REQUEST.RESPONSE.write(ret)              self.REQUEST.RESPONSE.write(ret)    
         return True                   
                 for fileName in files:
                   try:
                     self.REQUEST.RESPONSE.write(file(fileName).read())
                   except:
                     logging.error("downloadasonefile: cannot read %s"%fileName)
                     
               
                 self.REQUEST.RESPONSE.write("\n# locked files\n")
                 for fileName in lockedFiles:
                     self.REQUEST.RESPONSE.write("#  %s by %s\n"%fileName)
                 
                 self.REQUEST.RESPONSE.write("# locked files end\n")
                 
                 del self.basketContainer.resultHash[threadName]
                 del self.basketContainer.resultLockedHash[threadName]
                   
     def numberOfItems(self):      def numberOfItems(self):
         """return anzahl der elemente im basket"""          """return anzahl der elemente im basket"""
Line 1568  class CDLIFileObject(CatalogAware,extVer Line 1676  class CDLIFileObject(CatalogAware,extVer
            """Return cataloguable key for ourselves."""             """Return cataloguable key for ourselves."""
            return str(self)             return str(self)
                 
       def setAuthor(self, author):
           """change the author"""
           self.author = author
          
     def makeThisVersionCurrent_html(self):      def makeThisVersionCurrent_html(self):
         """form for mthis version current"""          """form for mthis version current"""
                   
Line 2058  class CDLIFileFolder(extVersionedFileFol Line 2170  class CDLIFileFolder(extVersionedFileFol
             ids = fileTree & self.v_file_ids              ids = fileTree & self.v_file_ids
             #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage              #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
             l=makelist(fileTree)[0:]              l=makelist(fileTree)[0:]
             logging.debug("l-list:"+repr(l))              #logging.debug("l-list:"+repr(l))
             self.REQUEST.SESSION['fileIds']=l#store fieldIds in session for further usage              self.REQUEST.SESSION['fileIds']=l#store fieldIds in session for further usage
             self.REQUEST.SESSION['searchList']=l              self.REQUEST.SESSION['searchList']=l
             #self.REQUEST.SESSION['searchList']=['P000001.atf']              #self.REQUEST.SESSION['searchList']=['P000001.atf']
Line 2291  class CDLIRoot(Folder): Line 2403  class CDLIRoot(Folder):
     def getFileObjectLastVersion(self,fileId):      def getFileObjectLastVersion(self,fileId):
         """get an object"""          """get an object"""
         x=self.v_files_lastVersion.get(fileId)          x=self.v_files_lastVersion.get(fileId)
         #logging.debug(x)          #logging.debug("lastVersion: "+repr(x))
         return x          return x
           
     def showFileIds(self):      def showFileIds(self):
Line 2587  class CDLIRoot(Folder): Line 2699  class CDLIRoot(Folder):
       
         return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)          return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
   
       def refreshTxtBasket(self,txt="",threadName=None):
           """txt fuer refresh"""
     
           return """ 2;url=%s?repeat=%s """%(txt,threadName)
   
           
     def getResult(self,threadName=None):      def getResult(self,threadName=None):
        """result of thread"""         """result of thread"""
Removed from v.1.86  
changed lines
  Added in v.1.100

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