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

Diff for /cdli/cdli_files.py between versions 1.48 and 1.63

version 1.48, 2006/10/05 07:22:58 version 1.63, 2007/02/05 15:23:46
Line 6  import os.path Line 6  import os.path
 import os  import os
 from types import *  from types import *
 import urlparse  import urlparse
   import urllib
   import cgi
 from OFS.OrderedFolder import OrderedFolder  from OFS.OrderedFolder import OrderedFolder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 import time  import time
Line 19  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
   import logging
   import transaction
   import copy
   
   def unique(s):
       """Return a list of the elements in s, but without duplicates.
   
       For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
       unique("abcabc") some permutation of ["a", "b", "c"], and
       unique(([1, 2], [2, 3], [1, 2])) some permutation of
       [[2, 3], [1, 2]].
   
       For best speed, all sequence elements should be hashable.  Then
       unique() will usually work in linear time.
   
       If not possible, the sequence elements should enjoy a total
       ordering, and if list(s).sort() doesn't raise TypeError it's
       assumed that they do enjoy a total ordering.  Then unique() will
       usually work in O(N*log2(N)) time.
   
       If that's not possible either, the sequence elements must support
       equality-testing.  Then unique() will usually work in quadratic
       time.
       (from the python cookbook)
       """
   
       n = len(s)
       if n == 0:
           return []
   
       # Try using a dict first, as that's the fastest and will usually
       # work.  If it doesn't work, it will usually fail quickly, so it
       # usually doesn't cost much to *try* it.  It requires that all the
       # sequence elements be hashable, and support equality comparison.
       u = {}
       try:
           for x in s:
               u[x] = 1
       except TypeError:
           del u  # move on to the next method
       else:
           return u.keys()
   
       # We can't hash all the elements.  Second fastest is to sort,
       # which brings the equal elements together; then duplicates are
       # easy to weed out in a single pass.
       # NOTE:  Python's list.sort() was designed to be efficient in the
       # presence of many duplicate elements.  This isn't true of all
       # sort functions in all languages or libraries, so this approach
       # is more effective in Python than it may be elsewhere.
       try:
           t = list(s)
           t.sort()
       except TypeError:
           del t  # move on to the next method
       else:
           assert n > 0
           last = t[0]
           lasti = i = 1
           while i < n:
               if t[i] != last:
                   t[lasti] = last = t[i]
                   lasti += 1
               i += 1
           return t[:lasti]
   
       # Brute force is all that's left.
       u = []
       for x in s:
           if x not in u:
               u.append(x)
       return u
           
   
 class BasketContent(SimpleItem):  class BasketContent(SimpleItem):
Line 62  class uploadATFfinallyThread(Thread): Line 137  class uploadATFfinallyThread(Thread):
         self.username=username          self.username=username
         self.serverport=serverport          self.serverport=serverport
                   
           
     def __call__(self):      def __call__(self):
         """call of the thread (equals run)"""          """call of the thread (equals run)"""
         self.run()          self.run()
Line 94  class uploadATFfinallyThread(Thread): Line 170  class uploadATFfinallyThread(Thread):
         #add the files          #add the files
         self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)          self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
         #commit the transactions          #commit the transactions
         get_transaction().commit()          transaction.get().commit()
         conn.close()          conn.close()
         #set flag for end of this method          #set flag for end of this method
         self.end=True          self.end=True
       logging.info("ended")
         return True          return True
           
     def __del__(self):      def __del__(self):
Line 119  class uploadATFfinallyThread(Thread): Line 196  class uploadATFfinallyThread(Thread):
                   
         #shall I only upload the changed files?          #shall I only upload the changed files?
         if procedure=="uploadchanged":          if procedure=="uploadchanged":
                 changed=[x[0] for x in SESSION.get('changed',[])]
             uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])              uploadFns=changed+SESSION.get('newPs',[])
                   
         #or all          #or all
         elif procedure=="uploadAll":          elif procedure=="uploadAll":
Line 136  class uploadATFfinallyThread(Thread): Line 213  class uploadATFfinallyThread(Thread):
             uploadFns=[]              uploadFns=[]
                           
         #do first the changed files              #do first the changed files    
       i=0
         for fn in uploadFns:          for fn in uploadFns:
           i+=1
             founds=ctx2.CDLICatalog.search({'title':fn})              founds=ctx2.CDLICatalog.search({'title':fn})
             if len(founds)>0:              if len(founds)>0:
                 SESSION['author']=str(username)                  SESSION['author']=str(username)
                 self.result+="<p>Changing : %s"%fn                  self.result="<p>Changing : %s"%fn+self.result
                 founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn,from_tmp=True))                  founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
                           if i==200:
               i=0
                   transaction.get().commit()
                       logging.info("changing: do commit")
       transaction.get().commit()
       logging.info("changing: last commit")
                   
         #now add the new files                  #now add the new files        
         newPs=SESSION['newPs']          newPs=SESSION['newPs']
         if len(newPs)>0:          if len(newPs)>0:
             tmpDir=SESSION['tmpdir']              tmpDir=SESSION['tmpdir']
             self.result+="<p>Adding files</p>"              self.result="<p>Adding files</p>"+self.result
             #TODO: make this configurable, at the moment base folder for the files has to be cdli_main              #TODO: make this configurable, at the moment base folder for the files has to be cdli_main
                           
             ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)              ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
Line 157  class uploadATFfinallyThread(Thread): Line 241  class uploadATFfinallyThread(Thread):
                   
         #unlock locked files?          #unlock locked files?
         if unlock:          if unlock:
             self.result+="<p>Unlock files</p>"              self.result="<p>Unlock files</p>"+self.result
             unlockFns=[]              unlockFns=[]
             for x in os.listdir(SESSION['tmpdir']):              for x in os.listdir(SESSION['tmpdir']):
                     if not x in SESSION['errors']:                      if not x in SESSION['errors']:
Line 172  class uploadATFfinallyThread(Thread): Line 256  class uploadATFfinallyThread(Thread):
                                           
         #if a basketname is give, add files to the basket          #if a basketname is give, add files to the basket
         if not (basketname ==''):          if not (basketname ==''):
             self.result+="<p>Add basket</p>"              self.result="<p>Add basket</p>"+self.result
             basketId=ctx2.basketContainer.getBasketIdfromName(basketname)              basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
                           
             if not basketId: # create new basket              if not basketId: # create new basket
Line 189  class uploadATFfinallyThread(Thread): Line 273  class uploadATFfinallyThread(Thread):
                 
         return True          return True
           
   class tmpStore(SimpleItem):
       """simple item"""
       meta_type="cdli_upload"
       
       def __init__(self,id):
           """init tmp"""
           self.id=id
           
 class uploadATFThread(Thread):  class uploadATFThread(Thread):
     """class for checking the files befor uploading"""      """class for checking the files befor uploading"""
           
Line 201  class uploadATFThread(Thread): Line 293  class uploadATFThread(Thread):
         Thread.__init__(self)          Thread.__init__(self)
                   
                   
     def set(self,upload,basketId,username,serverport="8080"):      def set(self,upload,basketId,username,idTmp,serverport="8080"):
         """set start values for the thread"""          """set start values for the thread"""
         self.result=""          self.result=""
         self.upload=upload          self.upload=upload
         self.basketId=basketId          self.basketId=basketId
         self.username=username          self.username=username
         self.serverport=serverport          self.serverport=serverport
           self.idTmp=idTmp
                   
     def __call__(self):      def __call__(self):
         """call method """          """call method """
Line 226  class uploadATFThread(Thread): Line 319  class uploadATFThread(Thread):
         return app.__of__(RequestContainer(REQUEST = req))          return app.__of__(RequestContainer(REQUEST = req))
                   
     def run(self):      def run(self):
                idTmp=self.idTmp
         self.result=""          self.result=""
         #find context within ZODB          #find context within ZODB
         from Zope import DB          from Zope import DB
Line 234  class uploadATFThread(Thread): Line 327  class uploadATFThread(Thread):
         root = conn.root()          root = conn.root()
         app  = root['Application']          app  = root['Application']
         ctx = self.getContext(app,serverport=self.serverport)          ctx = self.getContext(app,serverport=self.serverport)
         self.uploadATFThread(ctx,self.upload,self.basketId)          logging.info("run intern")
           try:
               ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
           except:
               logging.error("thread upload: %s %s"%sys.exc_info()[0:2])
               
           logging.info("call thread intern")
           self.uploadATFThread(ctx,self.upload,idTmp,self.basketId)
             
         #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue          #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
   
         get_transaction().commit()  
                   
         while self.continueVar:          transaction.get().commit()
             pass  
                   
         conn.close()          conn.close()
                   
Line 250  class uploadATFThread(Thread): Line 348  class uploadATFThread(Thread):
         """method for accessing result"""          """method for accessing result"""
         return self.result          return self.result
           
     def uploadATFThread(self,ctx,upload,basketId=0):      def uploadATFThread(self,ctx,upload,idTmp,basketId=0):
         """upload an atf file"""          """upload an atf file"""
         #TODO: add comments          #TODO: add comments
         #TODO: finish uploadATF          #TODO: finish uploadATF
           
           stObj=getattr(ctx.temp_folder,idTmp)
           logging.info("start, upload thread")
         self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"          self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"
           
         #make sure that id is a string and not an integer          #make sure that id is a string and not an integer
Line 292  class uploadATFThread(Thread): Line 393  class uploadATFThread(Thread):
             basketNameFromId=getattr(ctx2.basketContainer,basketId).title              basketNameFromId=getattr(ctx2.basketContainer,basketId).title
             basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()              basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
                           
                   logging.info("got the file, upload thread")
         self.result+="""<html><body><h2>I got the files</h2><          self.result+="""<html><body><h2>I got the files</h2><
                         p>I am computing the differences to the exisiting files</p>"""                          p>I am computing the differences to the exisiting files</p>"""
                                                                         
         #start to check the files          #start to check the files
         for fn in os.listdir(dir):          for fn in os.listdir(dir):
                           
             self.result+="<p>process:%s</p>"%fn              self.result="<p>process:%s</p>"%fn+self.result
                           
             # check if file is in the catalog              # check if file is in the catalog
             #TODO: checkCatalog is not implemented yet              #TODO: checkCatalog is not implemented yet
Line 327  class uploadATFThread(Thread): Line 428  class uploadATFThread(Thread):
                     obj=found.getObject()                      obj=found.getObject()
   
                     if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):                      if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
                                 lockerrors.append(fn)                                  lockerrors.append((fn,str(obj.lockedBy)))
                     else:                      else:
                                   
                         diffs=obj.diff(data)                          diffs=obj.diff(data)
Line 337  class uploadATFThread(Thread): Line 438  class uploadATFThread(Thread):
         #ready, set the returnValues          #ready, set the returnValues
         self.result+="<h3>Done</h3></body></html>"          self.result+="<h3>Done</h3></body></html>"
                   
         self.returnValue={}          stObj.returnValue={}
         self.returnValue['changed']=changed  
         self.returnValue['errors']=errors  
         self.returnValue['lockerrors']=lockerrors  
         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):  
     """shopping basket - alte fassung """  
       
     meta_type="Basket"  
     _v_stack={}  
   
     def getObjUrl(self,objId):  
         """getUrl"""  
         founds=self.CDLICatalog.search({'title':objId})  
         if len(founds)>0:  
              return founds[0].getObject().absolute_url()  
            
         else: #assume version number  
             splitted=objId.split("_")  
             founds=self.CDLICatalog.search({'title':splitted[1]})          
             return founds[0].getObject().absolute_url()+'/'+objId  
           
     def storeAllLink(self,results):  
         """erzeuge link zum speicher aller results"""  
         nr=self.REQUEST['_ZopeId']  
                   
         if results:          stObj.returnValue['errors']=errors
             self._v_stack[nr]=[x.getObject().getId() for x in results]  
                   
         return self.absolute_url()+"/storeAll?id="+nr          stObj.returnValue['newPs']=newPs
               stObj.returnValue['tmpdir']=dir
     def storeAll(self,id):          stObj.returnValue['basketLen']=basketLen
         """store all"""          stObj.returnValue['numberOfFiles']=numberOfFiles
         try:          stObj.returnValue['basketNameFromId']=basketNameFromId
             results=self._v_stack[id]          stObj.returnValue['basketNameFromFile']=basketNameFromFile
         except:          stObj.returnValue['basketId']=basketId
             #TODO: write expired page          stObj.returnValue['dir']=dir
             return "expired"          #stObj.returnValue['changed']=copy.copy(changed)
                   stObj.returnValue['changed']=[(x[0].getId(),x[1][0]) for x in changed]
         return self.storeInBasketForm(results)          #stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors]
                   stObj.returnValue['lockerrors']=[x for x in lockerrors]
     def storeInBasketForm(self,ids):          self.returnValue=True
         """ store an object form"""          #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
           
         if type(ids) is not ListType:  
             ids=[ids]  
         self.REQUEST.SESSION['ids']=ids[0:]  
           
         self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']  
   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)  
         return pt()  
           
     def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):  
         """store it"""  
           
         if not ids:  
             ids=REQUEST.SESSION['ids']  
               
         self.REQUEST.SESSION['basketUser']=username  
           
         baskets=self.ZopeFind(self,obj_ids=[username])  
         if len(baskets)>0:  
             basket=baskets[0][1]  
         else:  
             manage_addBasketObject(self,username)  
             basket=self._getOb(username)  
           
           
         basket.addObjects(ids)  
         back=self.REQUEST.SESSION.get('BACKLINK', None)  
   
         if RESPONSE:  
             RESPONSE.redirect(back)  
               
   
       
     def showBasket(self,user=None,set=None,RESPONSE=None):  
         """show the basket"""  
           
         if user:  
             self.REQUEST.SESSION['basketUser']=user  
           
         if not user and not set:  
             user=self.REQUEST.SESSION.get('basketUser',None)  
           
         if not user:  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)  
             return pt()  
         else:  
             baskets=self.ZopeFind(self,obj_ids=[user])  
           
   
         if len(baskets)>0:  
             RESPONSE.redirect(baskets[0][1].absolute_url())  
             return True   
         else:  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)  
             return pt()  
           
   
 def manage_addBasket_oldForm(self):  
     """add the basket form"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)  
     return pt()  
   
 def manage_addBasket_old(self,id,title,RESPONSE=None):  
     """add the basket"""  
     ob=Basket()  
       
     ob.id=str(id)  
     ob.title=title  
     self._setObject(id, ob)  
     ob=self._getOb(id)  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
       
 class BasketObject_old(Folder):  
     """Basket Object - alte fassung"""  
       
     meta_type="basketObject"  
     def __init__(self):  
                 """init basket object"""  
                 self.contents=[]  
   
     def numberOfItems(self):  
         """return anzahl der elemente im basket"""  
         num=len(self.contents)  
           
         return num  
       
     def addObjects(self,ids):  
         """addObjects"""  
           
         for id in ids:  
             founds=self.CDLICatalog.search({'title':id})  
             for found in founds:  
                 if found.getObject() not in self.contents:  
                     tm=self.contents[0:]  
                     tm.append(found.getObject())  
                     self.contents=tm[0:]  
       
         return True  
   
     def index_html(self):  
                 """view the basket"""  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)  
                 return pt()  
   
     def deleteObjects(self,ids,RESPONSE=None):  
         """delete objects"""  
         list = self.contents[0:]  
         for content in list:  
                  
                 if content.getId() in ids:  
                     self.contents.remove(content)  
           
   
         if RESPONSE:  
                     RESPONSE.redirect(self.absolute_url())  
   
   
     def unlockTest(self):  
         """unlock all files of the testuser for debuggin"""  
         for object in self.contents:  
   
                 if str(object.lockedBy)=="test":  
                     object.lockedBy=""  
               
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):  
         """download all selected files in one file"""  
           
         ret=""  
         lockedObjects={}  
       
         if self.temp_folder.downloadCounter > 10:  
             return """I am sorry, currently the server has to many requests for downloads, please come back later!"""  
   
   
         if lock:  
               
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':  
                   
                 return "please login first"  
   
             #check if a locked object exist in the basket.  
             lockedObjects={}  
             for object in self.contents:  
   
                 if not object.lockedBy=="":  
                     lockedObjects[object.title]=repr(object.lockedBy)  
                      
                       
             keys=lockedObjects.keys()  
               
               
             if len(keys)>0 and (not procedure):  
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)  
                 return pt()  
            
             elif not procedure: #keine fails gesperrt dann alle donwloaden  
                 procedure="downloadAll"   
           
         self.temp_folder.downloadCounter+=1   
         self._p_changed=1  
         get_transaction().commit()        
   
           
         for object in self.contents:  
               
                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     ret+=object.getLastVersion().getData()  
                   
                 if lock and object.lockedBy=='':  
                     object.lockedBy=self.REQUEST['AUTHENTICATED_USER']  
   
   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())  
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")  
         length=len(ret)  
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)  
         self.REQUEST.RESPONSE.write(ret)      
         self.temp_folder.downloadCounter-=1   
         self._p_changed=1  
         get_transaction().commit()        
           
           
 def manage_addBasket_oldObjectForm(self):  
     """add form"""  
     pass  
   
 def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):  
     """add"""  
       
     ob=BasketObject()  
       
     ob.id=str(id)  
     ob.title=title  
     self._setObject(id, ob)  
     ob=self._getOb(id)  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
   
 class CDLIBasketContainer(OrderedFolder):  class CDLIBasketContainer(OrderedFolder):
Line 689  class CDLIBasketContainer(OrderedFolder) Line 551  class CDLIBasketContainer(OrderedFolder)
         self.title=title          self.title=title
             
             
       def getBasketsId(self):
           """get all baskets als klartext"""
           
           ret=""
           baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
           for basket in baskets:
               com,user,time,values = basket[1].getContentIds()
               ret+= "BASKET:"+com+"\t"+user+"\t"+time+"\n"
               for x in values:
                   ret+= x[0]+"\t"+x[1]+"\n"
           return ret
   
     def getBaskets(self,sortField='title'):      def getBaskets(self,sortField='title'):
         """get all baskets files"""          """get all baskets files"""
   
Line 762  class CDLIBasketContainer(OrderedFolder) Line 636  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="/")
               try:
           qs=cgi.parse_qs(REQUEST['QUERY_STRING'])
           del(qs['basketId'])
       except:
           qs={}
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+REQUEST['QUERY_STRING'])              REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+urllib.urlencode(qs))
                           
     def getActiveBasket(self):      def getActiveBasket(self):
         """get active basket from cookie"""          """get active basket from cookie"""
Line 968  class CDLIBasket(Folder,CatalogAware): Line 846  class CDLIBasket(Folder,CatalogAware):
         newContent=[]          newContent=[]
         added=0          added=0
         for id in ids:          for id in ids:
           try:
             founds=self.CDLICatalog.search({'title':id})              founds=self.CDLICatalog.search({'title':id})
           except:
           founds=[]
             for found in founds:              for found in founds:
                 if found.getObject() not in oldContent:                  if found.getObject() not in oldContent:
                     #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version                      #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
Line 986  class CDLIBasket(Folder,CatalogAware): Line 866  class CDLIBasket(Folder,CatalogAware):
           
         return added          return added
           
       
                   
       
       def getContentIds(self):
           """print basket content"""
           ret=[]
           lv=self.getLastVersion()
           for obj in lv.content.getContent():
               ret.append((obj[0].getId(),obj[1].getId()))
           
           
           return lv.getComment(),lv.getUser(),lv.getTime(),ret
   
     def changeBasket(self,ids,submit,RESPONSE=None,REQUEST=None):      def changeBasket(self,ids,submit,RESPONSE=None,REQUEST=None):
         """change a basket"""          """change a basket"""
         if submit=="update":          if submit=="update":
Line 1087  class CDLIBasketVersion(Implicit,Persist Line 980  class CDLIBasketVersion(Implicit,Persist
   
         self.temp_folder.downloadCounterBaskets+=1           self.temp_folder.downloadCounterBaskets+=1 
         self._p_changed=1          self._p_changed=1
         get_transaction().commit()                 transaction.get().commit()       
           
         if lock:          if lock:
                           
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':              if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
                 self.temp_folder.downloadCounterBaskets-=1                   self.temp_folder.downloadCounterBaskets-=1 
                 self._p_changed=1                  self._p_changed=1
                 get_transaction().commit()                        transaction.get().commit()      
                 self.temp_folder.downloadCounterBaskets-=1                   self.temp_folder.downloadCounterBaskets-=1 
                 self._p_changed=1                  self._p_changed=1
                 get_transaction().commit()                        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.
             lockedObjects={}              lockedObjects={}
             for object in self.content.getContent():              for object in self.content.getContent():
   
                 if not object[1].lockedBy=="":                  if (not str(object[1].lockedBy)=="") and (not (str(object[1].lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):
                     lockedObjects[object[1].title]=repr(object[1].lockedBy)                      lockedObjects[object[1].title]=repr(object[1].lockedBy)
                                         
                                           
Line 1117  class CDLIBasketVersion(Implicit,Persist Line 1010  class CDLIBasketVersion(Implicit,Persist
                                   
                 self.temp_folder.downloadCounterBaskets-=1                   self.temp_folder.downloadCounterBaskets-=1 
                 self._p_changed=1                  self._p_changed=1
                 get_transaction().commit()                        transaction.get().commit()      
   
                 return pt()                  return pt()
                     
Line 1131  class CDLIBasketVersion(Implicit,Persist Line 1024  class CDLIBasketVersion(Implicit,Persist
           
                 if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):                  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                      if current=="no": #version as they are in the basket
                         ret+=str(object[0].data)+"\n"                          ret+=str(object[0].getData())+"\n"
                     elif current=="yes":                      elif current=="yes":
                         #search current object                          #search current object
                         founds=self.CDLICatalog.search({'title':object[0].getId()})                          founds=self.CDLICatalog.search({'title':object[0].getId()})
                         if len(founds)>0:                                if len(founds)>0:      
                             ret+=str(founds[0].getObject().getLastVersion().data)+"\n"                              ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
                                                           
                 if lock and object[1].lockedBy=='':                  if lock and object[1].lockedBy=='':
                     object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']                      object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
Line 1147  class CDLIBasketVersion(Implicit,Persist Line 1040  class CDLIBasketVersion(Implicit,Persist
   
         self.temp_folder.downloadCounterBaskets-=1           self.temp_folder.downloadCounterBaskets-=1 
         self._p_changed=1          self._p_changed=1
         get_transaction().commit()                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")
Line 1274  class CDLIFileObject(CatalogAware,extVer Line 1167  class CDLIFileObject(CatalogAware,extVer
           
     security.declarePublic('view')      security.declarePublic('view')
                                                                                   
       def getFormattedData(self):
           """fromat text"""
           data=self.getData()
           return re.sub("\s\#lem"," #lem",data) #remove return vor #lem
           
     def view(self):      def view(self):
         """view file"""          """view file"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
Line 1283  class CDLIFileObject(CatalogAware,extVer Line 1181  class CDLIFileObject(CatalogAware,extVer
     def getPNumber(self):      def getPNumber(self):
         """get the pnumber"""          """get the pnumber"""
         try:          try:
                 txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.data[0:])                  txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
         except:          except:
                 txt=self.data[0:]                  txt=self.getData()[0:]
                                   
                 return "ERROR"                  return "ERROR"
         try:          try:
Line 1343  def manage_addCDLIFileObject(self,id,vC= Line 1241  def manage_addCDLIFileObject(self,id,vC=
         self._getOb(id).content_type=content_type          self._getOb(id).content_type=content_type
   
     self.reindex_object()      self.reindex_object()
       self._getOb(id).reindex_object()
   
     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 1353  class CDLIFile(extVersionedFile,CatalogA Line 1253  class CDLIFile(extVersionedFile,CatalogA
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
           
     #security.declarePublic('history')      #security.declarePublic('history')
       def getLastVersionData(self):
           """get last version data"""
           return self.getLastVersion().getData()
   
       def getLastVersionFormattedData(self):
           """get last version data"""
           return self.getLastVersion().getFormattedData()
   
       #security.declarePublic('history')
       
       
     def history(self):      def history(self):
         """history"""            """history"""  
   
Line 1524  def splitatf(fh,dir=None,ext=None): Line 1435  def splitatf(fh,dir=None,ext=None):
     ret=None      ret=None
     nf=None      nf=None
     i=0      i=0
     for line in fh.readlines():  
       for lineTmp in fh.readlines():
       for line in lineTmp.split("\r"):
         if ext:          if ext:
             i+=1              i+=1
             if (i%100)==0:              if (i%100)==0:
Line 1550  def splitatf(fh,dir=None,ext=None): Line 1463  def splitatf(fh,dir=None,ext=None):
                 if dir:                  if dir:
                     filename=os.path.join(dir,filename)                      filename=os.path.join(dir,filename)
                 nf=file(filename,"w")                  nf=file(filename,"w")
               logging.info("open %s"%filename)
             if nf:                  if nf:    
                 nf.write(line)              nf.write(line.replace("\n","")+"\n")
                   
       try:    
     nf.close()      nf.close()
       except:
       pass
     fh.close()      fh.close()
     return ret,len(os.listdir(dir))      return ret,len(os.listdir(dir))
   
Line 1698  class CDLIFileFolder(extVersionedFileFol Line 1615  class CDLIFileFolder(extVersionedFileFol
                   
         catalog=getattr(self,self.default_catalog)          catalog=getattr(self,self.default_catalog)
         #tf,tfilename=mkstemp()          #tf,tfilename=mkstemp()
       if not hasattr(self.temp_folder,'downloadCounter'):
           self.temp_folder.downloadCounter=0
               
         if self.temp_folder.downloadCounter > 5:          if getattr(self.temp_folder,'downloadCounter',0) > 5:
             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!"""
   
         self.temp_folder.downloadCounter+=1          self.temp_folder.downloadCounter+=1
         self._p_changed=1          self._p_changed=1
         get_transaction().commit()          transaction.get().commit()
                 
         list=[(x.getId,x) for x in catalog()]          list=[(x.getId,x) for x in catalog()]
         list.sort(sortF)          list.sort(sortF)
Line 1721  class CDLIFileFolder(extVersionedFileFol Line 1640  class CDLIFileFolder(extVersionedFileFol
                                   
                 #os.write(tf,obj.getLastVersion().data)                  #os.write(tf,obj.getLastVersion().data)
                 if RESPONSE:                  if RESPONSE:
                     RESPONSE.write(obj.getLastVersion().data[0:])                      RESPONSE.write(obj.getLastVersion().getData()[0:])
                 self.temp_folder.downloadCounter-=1                   self.temp_folder.downloadCounter-=1 
                 self._p_changed=1                  self._p_changed=1
         get_transaction().commit()          transaction.get().commit()
         #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 1805  class CDLIRoot(Folder): Line 1724  class CDLIRoot(Folder):
           
     meta_type="CDLIRoot"      meta_type="CDLIRoot"
     downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible      downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible
       
       def findWordRegExp(self,searchTerm):
           """find all words in index which match regexp in SearchTerm"""
           ret=[]
           for x in self.lineIndex.iterkeys():
               if re.match(searchTerm,x):
                   ret.append(x)
           return ret
       
       def searchRegExpInLineIndexDocs(self,searchTerm):
           """search in inLineIndex with regexp"""
           if not searchTerm:
               return []
           ret=[]
           words=self.findWordRegExp(searchTerm) # suche nach allen Treffern
           logging.info("wd:%s"%words)
           for word in words:
               ret+=self.searchInLineIndexDocs(word)
           
           return unique(ret)
           
       def showInLineIndex(self):
           """get the index for debug purposes"""
           print "show"
           for x in self.lineIndex.iterkeys():
               logging.info("word:%s"%repr(x))
               #for y in self.lineIndex[x].iterkeys():
               #    print "doc",repr(y),repr(self.lineIndex[x][y])
                   
           return self.lineIndex
           
       def searchInLineIndexDocs(self,word,uniq=True,regExp=False):
           """search occurences"""
   
           if regExp:
               return self.searchRegExpInLineIndexDocs(word)
           
           try:    
               lst=list(self.lineIndex.get(word).keys())
           except:
               lst=[]
           if uniq:
               return unique(lst)
           else:
               return lst
           
       def getLinesFromIndex(self,word,doc,regExp=False):
           """get lines"""
           if not regExp:
               return self.lineIndex.get(word)[doc]
           else: # wenn regexp, suche welches word
               for w in self.findWordRegExp(word):
                   if self.lineIndex.get(w): # ein word in im dex gefunden
                       try:    
                           dc=self.lineIndex.get(word)[doc]
                           return dc # und ein document dann gib es zurueck
                       except:
                            pass #andernfalls weiter
                        
       def cleanInLineIndex(self):
           """delete InlineIndex"""
           for x in list(self.lineIndex.keys()):
               del(self.lineIndex[x])
           print [x for x in self.lineIndex.keys()]
        
           return "ok"
       
       def storeInLineIndex(self,key,value):
           """store in index"""
        
           if (not hasattr(self,'lineIndex')) or (type(self.lineIndex) is DictType):
               self.lineIndex=OOBTree()
           li=self.lineIndex
           
           if li.has_key(key):
   
   #            if li[key].has_key(value[0]) and (not (value[1] in li[key][value[0]])):
               if li[key].has_key(value[0]):
                   tmp=li[key][value[0]]
                   tmp.append(value[1]) # add it if now in the array
                   li[key][value[0]]=tmp[0:]
               else:
                   li[key][value[0]]=[value[1]] # new array for lines
                   
           else:
               
               li[key]=OOBTree()# new btree for lines
               li[key][value[0]]=[value[1]] 
                       
           
           self.lineIndex=li
        
           transaction.get().commit()
           
   
       def showFile(self,fileId):
           """show a file"""
           f=self.CDLICatalog({'title':fileId})
           if not f:
               return ""
           
           return f[0].getObject().getLastVersionFormattedData()
       
       def showLineFromFile(self,fileId,lineNum,word):
           """get line lineNum fromFileId"""
           
           file=self.showFile(fileId)
           #str="^%s\.[^%s\.]*%s[^\n]*\n"%(lineNum,lineNum,word)
       #str="^%s\..*?%s[^\n]*\n"%(lineNum,word)
           
       #print str
           #m=re.search(str,file,flags=re.M|re.DOTALL)
           #if m:
           #    return m.group()
           #else:
           #       return ""
       #ret=lineNum+"."
           #splitted=file.split(lineNum+".")
       #if len(splitted)>1:
           #for part in splitted[1:]:
               #if part.find(word)>-1:
                # for x in part.split("\n"):
                   #ret+=x
                   #if x.find(word)>-1:
                       #break
                 #break;
       #return ret
   
       def showWordInFile(self,fileId,word,lineList=None):
           """get lines with word  fromFileId"""
           
           file=self.showFile(fileId)
   
       ret=[]
       for line in file.split("\n"):
           if line.find(word)>-1:
               if lineList: #liste of moeglichen Zeilennummern
                   num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
   
                   if num in lineList: 
   
                       ret.append(line)
               else: # nimm alles ohne line check
                   ret.append(line)
       return ret
   
       def tagWordInFile(self,fileId,word,lineList=None):
           """get lines with word  fromFileId"""
           
           file=self.showFile(fileId)
       tagStr="""<span class="found">%s</span>"""
       ret=[]
       for line in file.split("\n"):
           if line.find(word)>-1:
               if lineList: #liste of moeglichen Zeilennummern
                   num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
   
                   if num in lineList: 
   
                       ret.append(line.replace(word,tagStr%word))
               else: # nimm alles ohne line check
                   ret.append(line.replace(word,tagStr%word))
           else:
               ret.append(line)
       return "<br>\n".join(ret)
   
     def URLquote(self,str):      def URLquote(self,str):
         """quote url"""          """quote url"""
         return urllib.quote(str)          return urllib.quote(str)
Line 1813  class CDLIRoot(Folder): Line 1898  class CDLIRoot(Folder):
         """unquote url"""          """unquote url"""
         return urllib.unquote(str)          return urllib.unquote(str)
           
       def URLquote_plus(self,str):
           """quote url"""
           return urllib.quote_plus(str)
       
       def URLunquote_plus(self,str):
           """unquote url"""
           return urllib.unquote_plus(str)
       
           
     def forceunlock(self):      def forceunlock(self):
         "break all locks"          "break all locks"
Line 1825  class CDLIRoot(Folder): Line 1918  class CDLIRoot(Folder):
   
         return ret                                 return ret                       
           
       def forceDahl(self):
           "break all locks"
           ret=[]
           for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
          if str(f[1].lockedBy)=="dahl":
                  un=f[1].forceunlock()
   
                      if un and un !="":
                         ret.append((f[0],un))
   
           return ret                       
       
     def getChangesByAuthor(self,author,n=100):      def getChangesByAuthor(self,author,n=100):
         """getChangesByAuthor"""          """getChangesByAuthor"""
         zcat=self.CDLIObjectsCatalog          zcat=self.CDLIObjectsCatalog
Line 1890  class CDLIRoot(Folder): Line 1995  class CDLIRoot(Folder):
     def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):      def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
         """standard ausgabe"""          """standard ausgabe"""
         #self._v_uploadATF.returnValue=None          #self._v_uploadATF.returnValue=None
           from random import randint
           if (not self.REQUEST.SESSION.get('idTmp',None)):
   
               idTmp=str(randint(0,1000000000))
               self.REQUEST.SESSION['idTmp']=idTmp
           else:
               idTmp=self.REQUEST.SESSION.get('idTmp',None)
   
         threadName=repeat          threadName=repeat
         if not threadName or threadName=="":          if not threadName or threadName=="":
Line 1903  class CDLIRoot(Folder): Line 2015  class CDLIRoot(Folder):
             self._v_uploadATF[threadName]=thread              self._v_uploadATF[threadName]=thread
             #self._xmltrans.start()              #self._xmltrans.start()
             #thread=Thread(target=self._v_uploadATF)              #thread=Thread(target=self._v_uploadATF)
                           logging.info("set thread. extern")
             self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])              self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],idTmp,serverport=self.REQUEST['SERVER_PORT'])
             #thread.start()              #thread.start()
               logging.info("start thread. extern")
             self._v_uploadATF[threadName].start()              self._v_uploadATF[threadName].start()
   
                           
Line 1927  class CDLIRoot(Folder): Line 2040  class CDLIRoot(Folder):
                          if threadName == thread.getName():                           if threadName == thread.getName():
                                        self._v_uploadATF[threadName]=thread                                         self._v_uploadATF[threadName]=thread
                                                                                 
             if not self._v_uploadATF[threadName].returnValue:              if self._v_uploadATF.get(threadName,None) and (not self._v_uploadATF[threadName].returnValue):
                   
   
                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
Line 1950  class CDLIRoot(Folder): Line 2063  class CDLIRoot(Folder):
 #                                         #                                       
 #                #  #                #
                 #tmp=self.cdli_main.tmpStore2[threadName]                  #tmp=self.cdli_main.tmpStore2[threadName]
                 tmp=self._v_uploadATF[threadName].returnValue  
                                   
                 #self._v_uploadATF[threadName].continueVar=False                  tmp=getattr(self.temp_folder,idTmp).returnValue
                   
                   
                   
                                   
                 self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]  
                 self.REQUEST.SESSION['lockerrors']=[x[0].getId() for x in tmp['lockerrors']]  
                 self.REQUEST.SESSION['errors']=tmp['errors']  
                 self.REQUEST.SESSION['newPs']=tmp['newPs']  
                 self.REQUEST.SESSION['tmpdir']=tmp['dir']  
                 #del(self.cdli_main.tmpStore2[threadName])                  #del(self.cdli_main.tmpStore2[threadName])
   
                                 
Line 1990  class CDLIRoot(Folder): Line 2100  class CDLIRoot(Folder):
   
             self._v_uploadATF[threadName]=thread              self._v_uploadATF[threadName]=thread
   
                       idTmp=self.REQUEST.SESSION['idTmp']
             self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])              stObj=getattr(self.temp_folder,idTmp)
               self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=stObj.returnValue,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
   
             self._v_uploadATF[threadName].start()              self._v_uploadATF[threadName].start()
   
Line 2024  class CDLIRoot(Folder): Line 2135  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:
                 self.REQUEST.SESSION['idTmp']=None
               if RESPONSE is not None:                if RESPONSE is not None:
                   RESPONSE.redirect(self.absolute_url())                    RESPONSE.redirect(self.absolute_url())
   
     def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):      def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):
         """import files"""          """import files"""
         root=self.cdli_main          root=self.cdli_main
                   count=0
         if not files:          if not files:
             files=os.listdir(folderName)              files=os.listdir(folderName)
                           
Line 2045  class CDLIRoot(Folder): Line 2156  class CDLIRoot(Folder):
             if not obj:              if not obj:
                 manage_addCDLIFileFolder(root,folder,folder)                  manage_addCDLIFileFolder(root,folder,folder)
                 fobj=getattr(root,folder)                  fobj=getattr(root,folder)
                 #get_transaction().commit()                                             #transaction.get().commit()                           
             else:              else:
                 fobj=obj[0][1]                  fobj=obj[0][1]
                           
Line 2069  class CDLIRoot(Folder): Line 2180  class CDLIRoot(Folder):
             self.CDLICatalog.catalog_object(ob)              self.CDLICatalog.catalog_object(ob)
             #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)              #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)
             #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])              #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])
           count+=1
                           
           if count > 1000:
           print "committing"
           transaction.get().commit()
           count=0
           transaction.get().commit()
         return "ok"          return "ok"
                     
   
Line 2089  def manage_addCDLIRoot(self, id, title=' Line 2206  def manage_addCDLIRoot(self, id, title='
     ob=CDLIRoot()      ob=CDLIRoot()
     ob.id=str(id)      ob.id=str(id)
     ob.title=title      ob.title=title
       try:
     self._setObject(id, ob)      self._setObject(id, ob)
       except:
       pass
     ob=self._getOb(id)      ob=self._getOb(id)
   
     checkPermission=getSecurityManager().checkPermission      checkPermission=getSecurityManager().checkPermission
Removed from v.1.48  
changed lines
  Added in v.1.63

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