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

Diff for /cdli/cdli_files.py between versions 1.80.2.15 and 1.91

version 1.80.2.15, 2008/01/14 18:43:21 version 1.91, 2008/10/06 12:57:12
Line 21  from ZPublisher.HTTPRequest import HTTPR Line 21  from ZPublisher.HTTPRequest import HTTPR
 from ZPublisher.HTTPResponse import HTTPResponse  from ZPublisher.HTTPResponse import HTTPResponse
 from ZPublisher.BaseRequest import RequestContainer  from ZPublisher.BaseRequest import RequestContainer
 import threading  import threading
 from BTrees.OOBTree import OOBTree  from BTrees.OOBTree import OOBTree, OOTreeSet
 import logging  import logging
 import transaction  import transaction
 import copy  import copy
 import codecs  import codecs
 import sys  import sys
   from BTrees.IOBTree import IOBTree 
 import cdliSplitter  import cdliSplitter
   from sets import Set
   import md5
   from DownloadBasket import DownloadBasketFinallyThread
                                          
   def makelist(mySet):
           x = list(mySet)
           x.sort()
           return x
   
 def unicodify(s):  def unicodify(s):
     """decode str (utf-8 or latin-1 representation) into unicode object"""      """decode str (utf-8 or latin-1 representation) into unicode object"""
Line 108  def formatAtfFullLineNum(txt, nolemma=Tr Line 115  def formatAtfFullLineNum(txt, nolemma=Tr
                 surf = line.replace(words[0],surfaces[words[0]]).strip()                  surf = line.replace(words[0],surfaces[words[0]]).strip()
                           
             elif words[0] == '@column':              elif words[0] == '@column':
                 col = words[1]                  col = ' '.join(words[1:])
                           
         elif line and line[0] in '123456789':          elif line and line[0] in '123456789':
             # ordinary line -> add line number              # ordinary line -> add line number
Line 394  class uploadATFfinallyThread(Thread): Line 401  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))
             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 925  class CDLIBasketContainer(OrderedFolder) Line 933  class CDLIBasketContainer(OrderedFolder)
         if not ids:          if not ids:
             ids=self.REQUEST.SESSION['fileIds']              ids=self.REQUEST.SESSION['fileIds']
                           
         if type(ids) is not ListType:          if (type(ids) is not ListType) and (not isinstance(ids,Set)):
             ids=[ids]              ids=[ids]
                   
           if isinstance(ids,Set):
               ids=list(ids)
               
         if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):          if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
             basketRet=self.addBasket(newBasketName)              basketRet=self.addBasket(newBasketName)
             self.setActiveBasket(basketRet.getId())              self.setActiveBasket(basketRet.getId())
Line 941  class CDLIBasketContainer(OrderedFolder) Line 952  class CDLIBasketContainer(OrderedFolder)
                   
         if fromFileList:          if fromFileList:
   
             return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)              return self.cdli_main.findObjectsFromList(list=ids,basketName=basket.title,numberOfObjects=added)
                 
         if RESPONSE:          if RESPONSE:
                           
Line 1020  class CDLIBasket(Folder,CatalogAware): Line 1031  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:
               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:
               return False, -1
                   
     def history(self):      def history(self):
         """history"""            """history"""  
Line 1177  class CDLIBasket(Folder,CatalogAware): Line 1191  class CDLIBasket(Folder,CatalogAware):
           
     def addObjects(self,ids,deleteOld=None,username=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"""
           
           def swap(x):
               return (x[1],x[0])
               
         logging.info("add to basket (%s)"%(self.getId()))          logging.info("add to basket (%s)"%(self.getId()))
         lastVersion=self.getLastVersion()          lastVersion=self.getLastVersion()
                   
Line 1188  class CDLIBasket(Folder,CatalogAware): Line 1206  class CDLIBasket(Folder,CatalogAware):
         if deleteOld:          if deleteOld:
             oldContent=[]              oldContent=[]
   
         newContent=[]  
         added=0          added=0
         for id in ids:  #        for id in ids:
             try:  #            logging.debug("adding:"+id)
                 founds=self.CDLICatalog.search({'title':id})  #            try:
             except:  #                founds=self.CDLICatalog.search({'title':id})
                 founds=[]  #            except:
   #                founds=[]
   #           
   #            for found in founds:
   #                if found.getObject() not in oldContent:
   #                    #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
   #                    newContent.append((found.getObject().getLastVersion(),found.getObject()))
   #                    added+=1
   
           hash = md5.new(repr(makelist(ids))).hexdigest() # erzeuge hash als identification
           #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): 
               logging.debug("from store!")
               newContent=Set(map(swap,self.cdliRoot.v_tmpStore[hash]))
                         
             for found in founds:          else:
                 if found.getObject() not in oldContent:              logging.debug("not from store!")
                     #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version              newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])
                     newContent.append((found.getObject().getLastVersion(),found.getObject()))  
                     added+=1  
   
         content=oldContent+newContent          
           content=Set(oldContent).union(newContent)
           added = len(content)-len(oldContent)
         if not username:          if not username:
             user=self.getActualUserName()              user=self.getActualUserName()
         else:          else:
             user = username              user = username
                           
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)          #logging.debug("content:"+repr(list(content)))
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=list(content))
         logging.info("add to basket (%s) done"%(self.getId()))          logging.info("add to basket (%s) done"%(self.getId()))
         return added          return added
           
Line 1329  class CDLIBasketVersion(Implicit,Persist Line 1362  class CDLIBasketVersion(Implicit,Persist
     security.declareProtected('manage','downloadObjectsAsOneFile')      security.declareProtected('manage','downloadObjectsAsOneFile')
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):      def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):
         """download all selected files in one file"""          """download all selected files in one file"""
                   logging.debug("doasof")
         if self.temp_folder.downloadCounterBaskets > 10000:          if self.temp_folder.downloadCounterBaskets > 10000:
             return """I am sorry, currently the server has to many requests for downloads, please come back later!"""              return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
   
Line 1343  class CDLIBasketVersion(Implicit,Persist Line 1376  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()         
           
           logging.debug("lock:"+repr(lock))
         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 1379  class CDLIBasketVersion(Implicit,Persist Line 1406  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 1391  class CDLIBasketVersion(Implicit,Persist Line 1415  class CDLIBasketVersion(Implicit,Persist
                   
   
   
         for object in self.content.getContent():          threadName=repeat
           if not threadName or threadName=="":
               thread=DownloadBasketFinallyThread()
               threadName=thread.getName()[0:]
   
               if (not hasattr(self,'_v_downloadBasket')):
                                   self._v_downloadBasket={}
           
                 if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     if current=="no": #version as they are in the basket  
                         ret+=str(object[0].getData())+"\n"  
                     elif current=="yes":  
                         #search current object  
                         founds=self.CDLICatalog.search({'title':object[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))
               basketID=self.aq_parent.aq_parent.getId()
               versionNumber=self.aq_parent.getId()
            
               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]
                 logging.error(files)
                # fh=file("/var/tmp/test")
                 #ret =fh.read()
            
                 if (not isinstance(self.aq_parent,CDLIBasket)):
                     basket_name=self.aq_parent.aq_parent.title+"_V"+self.getId()
                 else:
         basket_name=self.aq_parent.title+"_V"+self.getId()          basket_name=self.aq_parent.title+"_V"+self.getId()
                   
           
       
         #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\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 1522  class CDLIFileObject(CatalogAware,extVer Line 1625  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 making this version current"""          """form for mthis version current"""
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
         return pt()                           return pt()                 
Line 1532  class CDLIFileObject(CatalogAware,extVer Line 1639  class CDLIFileObject(CatalogAware,extVer
     def makeThisVersionCurrent(self,comment,author,RESPONSE=None):      def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
         """copy this version to current"""          """copy this version to current"""
         parent=self.aq_parent          parent=self.aq_parent
         newversion=parent.manage_addCDLIFileObject('',comment,author)          parent.manage_addVersionedFileObject(id=None,vC=comment,author=author,file=self.getData(),RESPONSE=RESPONSE)
         newversion.manage_upload(self.getData())          #newversion=parent.manage_addCDLIFileObject('',comment,author)
           #newversion.manage_upload(self.getData())
                                                                                   
         if RESPONSE is not None:          #if RESPONSE is not None:
             RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')          #    RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
   
         return True          return True
           
Line 1615  def manage_addCDLIFileObject(self,id,vC= Line 1723  def manage_addCDLIFileObject(self,id,vC=
     logging.debug("reindex2: %s in %s"%(repr(fob), repr(fob.default_catalog)))      logging.debug("reindex2: %s in %s"%(repr(fob), repr(fob.default_catalog)))
     fob.index_object()      fob.index_object()
   
       self.CDLIRoot.updateOrAddToFileBTree(ob)
     if REQUEST is not None:      if REQUEST is not None:
         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')          REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
           
Line 1728  class CDLIFile(extVersionedFile,CatalogA Line 1837  class CDLIFile(extVersionedFile,CatalogA
         except:          except:
             pass              pass
       
           #self.cdliRoot.updateOrAddToFileBTree(self)# now update the object in the cache
         
           
         if RESPONSE:          if RESPONSE:
             if ob.getSize()==0:              if ob.getSize()==0:
                 self.REQUEST.SESSION['objID']=ob.getId()                  self.REQUEST.SESSION['objID']=ob.getId()
Line 1930  class CDLIFileFolder(extVersionedFileFol Line 2042  class CDLIFileFolder(extVersionedFileFol
             
         return ret          return ret
           
     def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):      def expandFile(self,fileId,fileTree):
           """wildcard in fileID suche alle Treffer"""
           founds=self.CDLICatalog({'title':fileId})
           for found in founds:
               fileTree.add(found.getId)
               logging.debug("ADDD:"+found.getId)
            
       def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None,REQUEST=None,returnHash=False,hash=None):
         """findObjectsFromList (, TAB oder LINE separated)"""          """findObjectsFromList (, TAB oder LINE separated)"""
                                                                                 
           logging.debug("start: findObjectsFromList")
           #logging.debug("start: findObjectsFromList"+repr(list))
           
                   
         if upload: # list from file upload          if upload: # list from file upload
             txt=upload.read()              txt=upload.read()
Line 1964  class CDLIFileFolder(extVersionedFileFol Line 2086  class CDLIFileFolder(extVersionedFileFol
             pt=getattr(self,'filelist.html')              pt=getattr(self,'filelist.html')
             return pt(basketName=basketName,numberOfObjects=numberOfObjects)              return pt(basketName=basketName,numberOfObjects=numberOfObjects)
                   
           if hash is not None and hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash): 
                  
                  logging.debug("asking for storage2")
                  result =self.cdliRoot.v_tmpStore[hash]
                  if result:
                      logging.debug("give result from storage2")
                      return hash,self.cdliRoot.v_tmpStore[hash]
             
         if list is not None: # got already a list          if list is not None: # got already a list
               
               logging.debug(" ----List version")
             ret=[]              ret=[]
               fileTree=Set()
               
             for fileId in list:              for fileId in list:
                 if fileId.find("*"): #check for wildcards                 
                         fileId=fileId                  if fileId.find("*")>-1: #check for wildcards
                           self.expandFile(fileId,fileTree)
                           
                 elif len(fileId.split("."))==1:                  elif len(fileId.split("."))==1:
                         fileId=fileId+".atf"                          fileId=fileId+".atf"
                           fileTree.add(fileId)
                   #logging.debug("   -----:"+fileId)
                   #ret+=self.CDLICatalog({'title':fileId})
                   #x =self.getFileObject(fileId)
                   #if x is not None:
                   #    ret.append(x)
                   
               
               
               ids = fileTree & self.v_file_ids
               #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
               l=makelist(fileTree)[0:]
               logging.debug("l-list:"+repr(l))
               self.REQUEST.SESSION['fileIds']=l#store fieldIds in session for further usage
               self.REQUEST.SESSION['searchList']=l
               #self.REQUEST.SESSION['searchList']=['P000001.atf']
             
               
               hash = md5.new(repr(makelist(fileTree))).hexdigest() # erzeuge hash als identification
               self.REQUEST.SESSION['hash']=hash
               #TODO: do I need garbage collection for v_tmpStore ?
               
               #logging.debug("Hash:"+repr(hash))
   #        
   #            if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash): 
   #               logging.debug("asking for storage")
   #               res=self.cdliRoot.v_tmpStore[hash]
   #               if res:
   #                   if returnHash == True:
   #                       return hash,res
   #                   return res
                                   
                 ret+=self.CDLICatalog({'title':fileId})  
             #TODO: get rid of one of these..              #TODO: get rid of one of these..
             ids=[x.getObject().getId() for x in ret]              #ids=[x.getObject().getId() for x in ret]
             self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage              ret=[(self.getFileObject(x),self.getFileObjectLastVersion(x)) for x in ids]
             self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']              
               #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
               #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                           
             if display:              if display:
                 pt=getattr(self,'filelist.html')                  pt=getattr(self,'filelist.html')
                                   
                 return pt(search=ids)                  return pt(search=ids)
             else:                    else:      
                   #self.REQUEST.SESSION['hash'] = ret # store in session 
                   if not hasattr(self,'v_tmpStore'):
                       self.cdliRoot.v_tmpStore={}
                   #logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))
                   #logging.debug("HHHHHHNEU:"+repr(hash))
                   self.cdliRoot.v_tmpStore[hash] = ret # store in session 
                   if returnHash == True:
                       return hash,ret
                 return ret                  return ret
                   
                   
Line 1990  class CDLIFileFolder(extVersionedFileFol Line 2166  class CDLIFileFolder(extVersionedFileFol
         if start:          if start:
             RESPONSE.redirect("filelist.html?start:int="+str(start))              RESPONSE.redirect("filelist.html?start:int="+str(start))
                                                                                 
   
     security.declareProtected('Manage','createAllFilesAsSingleFile')      security.declareProtected('Manage','createAllFilesAsSingleFile')
     def createAllFilesAsSingleFile(self,RESPONSE=None):      def createAllFilesAsSingleFile(self,RESPONSE=None):
         """download all files"""          """download all files"""
Line 2118  class CDLIRoot(Folder): Line 2293  class CDLIRoot(Folder):
                 'graphemes':cdliSplitter.graphemeSplitter()}                  'graphemes':cdliSplitter.graphemeSplitter()}
           
           
       def viewATF(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           logging.debug(ob[0].getObject().getLastVersion().absolute_url()+"/view")
           if len(ob)>0:
               RESPONSE.redirect(ob[0].getObject().getLastVersion().absolute_url()+"/view")
           return "not found"
       
       def history(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/history")
           return "not found"
       
   
       def downloadLocked(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/downloadLocked")
           return "not found"
       
       def download(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].getLastVersion().absolute_url())
           return "not found"
       def addCDLIFileObjectForm(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/addCDLIFileObjectForm")
           return "not found"
       
       def addVersionedFileObjectForm(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/addVersionedFileObjectForm")
           return "not found"
       
       def unlock(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/unlock")
           return "not found"
       
       def getFileObject(self,fileId):
           """get an object"""
           x=self.v_files.get(fileId)
           #logging.debug(x)
           return x
       
       def getFileObjectLastVersion(self,fileId):
           """get an object"""
           x=self.v_files_lastVersion.get(fileId)
           #logging.debug(x)
           return x
       
       def showFileIds(self):
           """showIds"""
           return self.v_file_ids
       
       def generateFileBTree(self):
           """erzeuge einen Btree aus allen Files"""
           self.v_files = OOBTree()
           self.v_files_lastVersion = OOBTree()
           self.v_file_ids = Set()
           
           for x in self.CDLICatalog.searchResults():
               
               self.v_files.update({x.getId:x.getObject()})
               self.v_files_lastVersion.update({x.getId:x.getObject().getLastVersion()})
               self.v_file_ids.add(x.getId)
               logging.debug("add:"+x.getId+"XXX"+repr(x.getObject()))
           
           return True
       
       
       def updateOrAddToFileBTree(self,obj):
           """update a BTree"""
           self.v_files.update({obj.getId():obj})
           self.v_files_lastVersion.update({obj.getId():obj.getLastVersion()})
           
           self.v_file_ids.add(obj.getId())
           logging.debug("update:"+obj.getId()+"XXX"+repr(obj))
           
       def deleteFromBTree(self,objId):
           """delete an obj"""
           self.v_files.pop(objId)
           self.v_files_lastVersion.pop(objId)
           self.v_file_ids.remove(objId)
           
   
    
     def deleteFiles(self,ids):      def deleteFiles(self,ids):
         """delete files"""          """delete files"""
         for id in ids:          for id in ids:
Line 2156  class CDLIRoot(Folder): Line 2429  class CDLIRoot(Folder):
         return f[0].getObject().getData()          return f[0].getObject().getData()
                     
   
   
     def showFile(self,fileId,wholePage=False):      def showFile(self,fileId,wholePage=False):
         """show a file          """show a file
         @param fileId: P-Number of the document to be displayed          @param fileId: P-Number of the document to be displayed
Line 2237  class CDLIRoot(Folder): Line 2509  class CDLIRoot(Folder):
         # split search terms again (for grapheme search with words)          # split search terms again (for grapheme search with words)
         splitwords = dict(((w,self.splitter[indexName].process([w])) for w in words))          splitwords = dict(((w,self.splitter[indexName].process([w])) for w in words))
                           
         for line in file.linesplit():          for line in file.splitlines():
             line = unicodify(line)              line = unicodify(line)
             # ignore lemma and other lines              # ignore lemma and other lines
             if line.lstrip().startswith('#lem:'):              if line.lstrip().startswith('#lem:'):
Line 2295  class CDLIRoot(Folder): Line 2567  class CDLIRoot(Folder):
         return dict([(id,self.tagWordInFile(id, word, indexName, regExp)) for id in fileIds])          return dict([(id,self.tagWordInFile(id, word, indexName, regExp)) for id in fileIds])
           
   
       def getFileVersionList(self, pnum):
           """get the version history as a list for the translit file with the given pnum"""
           f = getattr(self, self.file_catalog).search({'textid':pnum})
           if not f:
               return []
           
           return f[0].getObject().getVersionList()
            
   
     def URLquote(self,str):      def URLquote(self,str):
         """quote url"""          """quote url"""
         return urllib.quote(str)          return urllib.quote(str)
Line 2367  class CDLIRoot(Folder): Line 2648  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"""
Line 2543  class CDLIRoot(Folder): Line 2829  class CDLIRoot(Folder):
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                 return pt(txt='/uploadATFfinally',threadName=threadName)                  return pt(txt='/uploadATFfinally',threadName=threadName)
             else:              else:
                 
                
                 idTmp=self.REQUEST.SESSION['idTmp']
                 stObj=getattr(self.temp_folder,idTmp) 
               self.REQUEST.SESSION['idTmp']=None                self.REQUEST.SESSION['idTmp']=None
                
                 #update changed
                 logging.debug("dir:"+repr(stObj.returnValue['changed']))
                 for x in stObj.returnValue['changed']:
                       ob=self.CDLICatalog.search({'title':x[0]})
                      
                       self.cdliRoot.updateOrAddToFileBTree(ob[0].getObject())
               if RESPONSE is not None:                if RESPONSE is not None:
                   RESPONSE.redirect(self.absolute_url())                    RESPONSE.redirect(self.absolute_url())
   
Line 2558  class CDLIRoot(Folder): Line 2855  class CDLIRoot(Folder):
         for f in files:          for f in files:
             folder=f[0:3]              folder=f[0:3]
             f2=f[0:5]              f2=f[0:5]
               
               #check if main folder PXX already exists
             obj=self.ZopeFind(root,obj_ids=[folder])              obj=self.ZopeFind(root,obj_ids=[folder])
             logging.debug("importFiles: folder=%s f2=%s obj=%s"%(folder,f2,obj))               logging.debug("importFiles: folder=%s f2=%s obj=%s"%(folder,f2,obj)) 
             if ext:              if ext:
                 ext.result="<p>adding: %s </p>"%f+ext.result                  ext.result="<p>adding: %s </p>"%f+ext.result
   
             if not obj:              
               if not obj: # if not create it
                 manage_addCDLIFileFolder(root,folder,folder)                  manage_addCDLIFileFolder(root,folder,folder)
                 fobj=getattr(root,folder)                  fobj=getattr(root,folder)
                 #transaction.get().commit()                                             #transaction.get().commit()                           
Line 2571  class CDLIRoot(Folder): Line 2871  class CDLIRoot(Folder):
             else:              else:
                 fobj=obj[0][1]                  fobj=obj[0][1]
                           
               #check IF PYYYYY already exist
             obj2=fobj.ZopeFind(fobj,obj_ids=[f2])              obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
             logging.debug("importFiles: fobj=%s obj2=%s"%(fobj,obj2))               logging.debug("importFiles: fobj=%s obj2=%s"%(fobj,obj2)) 
                   
             if not obj2:              if not obj2:# if not create it
                 manage_addCDLIFileFolder(fobj,f2,f2)                  manage_addCDLIFileFolder(fobj,f2,f2)
                 fobj2=getattr(fobj,f2)                  fobj2=getattr(fobj,f2)
                   
             else:              else:
                 fobj2=obj2[0][1]                  fobj2=obj2[0][1]
                               
               # not add the file
             file2=os.path.join(folderName,f)                file2=os.path.join(folderName,f)  
             id=f              id=f
             logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))              logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))
             fobj2.addFile(vC='',file=file(file2),author=author,newName=f)              fobj2.addFile(vC='',file=file(file2),author=author,newName=f)
             count+=1              count+=1
   
               #now add the file to the storage
               ob = getattr(fobj2,f)
               self.cdliRoot.updateOrAddToFileBTree(ob)
               
             if count%100==0:              if count%100==0:
                 logging.debug("importfiles: committing")                  logging.debug("importfiles: committing")
                 transaction.get().commit()                  transaction.get().commit()
Removed from v.1.80.2.15  
changed lines
  Added in v.1.91

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