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

Diff for /cdli/cdli_files.py between versions 1.59 and 1.79

version 1.59, 2007/01/24 18:08:15 version 1.79, 2007/08/31 14:22:52
Line 24  import threading Line 24  import threading
 from BTrees.OOBTree import OOBTree  from BTrees.OOBTree import OOBTree
 import logging  import logging
 import transaction  import transaction
   import copy
   import codecs
   import sys
   
   def unicodify(s):
       """decode str (utf-8 or latin-1 representation) into unicode object"""
       if not s:
           return u""
       if isinstance(s, str):
           try:
               return s.decode('utf-8')
           except:
               return s.decode('latin-1')
       else:
           return s
   
   def utf8ify(s):
       """encode unicode object or string into byte string in utf-8 representation.
          assumes string objects to be utf-8"""
       if not s:
           return ""
       if isinstance(s, str):
           return s
       else:
           return s.encode('utf-8')
   
   
   def generateXMLReturn(hash):
       """erzeugt das xml file als returnwert fuer uploadATFRPC"""
   
       ret="<return>"
       
       ret+="<errors>"
       for error in hash['errors']:
           ret+="""<error atf="%s">%s</error>"""%error
       
       ret+="</errors>"
       
       ret+="<changes>"
       for changed in hash['changed']:
           ret+="""<change atf="%s">%s</change>"""%changed
       ret+="</changes>"
       
       ret+="<newPs>"
       for new in hash['newPs']:
           ret+="""<new atf="%s"/>"""%new
       ret+="</newPs>"
       
       ret+="</return>"
       return ret
       
       
       
       
       
       
       
       
       
   
 def unique(s):  def unique(s):
     """Return a list of the elements in s, but without duplicates.      """Return a list of the elements in s, but without duplicates.
Line 136  class uploadATFfinallyThread(Thread): Line 195  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 172  class uploadATFfinallyThread(Thread): Line 232  class uploadATFfinallyThread(Thread):
         conn.close()          conn.close()
         #set flag for end of this method          #set flag for end of this method
         self.end=True          self.end=True
     print "ended"          logging.info("ended")
     return True      return True
           
     def __del__(self):      def __del__(self):
Line 193  class uploadATFfinallyThread(Thread): Line 253  class uploadATFfinallyThread(Thread):
         self.result+="<h2>Start processing</h2>"          self.result+="<h2>Start processing</h2>"
                   
         #shall I only upload the changed files?          #shall I only upload the changed files?
           logging.info("uploadATFfinally procedure: %s"%procedure)
         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 211  class uploadATFfinallyThread(Thread): Line 272  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>"              logging.info("adding start")
               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)
                               logging.info("adding finished")
                   
                   
         #unlock locked files?          #unlock locked files?
         if unlock:          if unlock:
             self.result+="<p>Unlock files</p>"              logging.info("unlocking start")
               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']:
                         unlockFns.append(x)                          unlockFns.append(x)
               logging.info("unlocking have now what to unlock")
                           
             for fn in unlockFns:              for fn in unlockFns:
                   #logging.info("will unlock: %s"%fn)
                 founds=ctx2.CDLICatalog.search({'title':fn})                  founds=ctx2.CDLICatalog.search({'title':fn})
                   #logging.info("found it: %s"%repr(founds))
                 if len(founds)>0:                  if len(founds)>0:
                       #logging.info("unlock: %s"%founds[0].getObject().getId())
                     SESSION['author']=str(username)                      SESSION['author']=str(username)
                                         
                     founds[0].getObject().lockedBy=""                      founds[0].getObject().lockedBy=""
               logging.info("unlocking done")
                                           
         #if a basketname is give, add files to the basket          #if a basketname is given, add files to the basket
         if not (basketname ==''):          if not (basketname ==''):
             self.result+="<p>Add basket</p>"              logging.info("add to basket %s"%basketname)
               self.result="<p>Add to 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
                   logging.info("create basket %s"%basketname)
                   self.result="<p>Create a new basket</p>"+self.result
                 ob=ctx2.basketContainer.addBasket(basketname)                  ob=ctx2.basketContainer.addBasket(basketname)
                 basketId=ob.getId()                  basketId=ob.getId()
             basket=getattr(ctx2.basketContainer,str(basketId))              basket=getattr(ctx2.basketContainer,str(basketId))
Line 261  class uploadATFfinallyThread(Thread): Line 340  class uploadATFfinallyThread(Thread):
             RESPONSE.redirect(self.aq_parent.absolute_url())              RESPONSE.redirect(self.aq_parent.absolute_url())
                   
   
                  logging.info("uploadfinally done")
         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 276  class uploadATFThread(Thread): Line 363  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 301  class uploadATFThread(Thread): Line 389  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 309  class uploadATFThread(Thread): Line 397  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:
               logging.info("created: %s"%idTmp)
               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
                   
                   
         transaction.get().commit()          transaction.get().commit()
         while self.continueVar:  
             pass  
                 
         conn.close()          conn.close()
                   
           return getattr(ctx.temp_folder,idTmp)
                   
     def getResult(self):      def getResult(self):
         """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 367  class uploadATFThread(Thread): Line 465  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 387  class uploadATFThread(Thread): Line 485  class uploadATFThread(Thread):
             #if not than add filename to the list of newfiles              #if not than add filename to the list of newfiles
                           
             data=file(os.path.join(dir,fn)).read()              data=file(os.path.join(dir,fn)).read()
             #status,msg=checkFile(fn,data,dir)              status,msg=checkFile(fn,data,dir)
             status=True              #status=True
             msg=""              
               
             if not status: # error              if not status: # error
                 errors.append((fn,msg))                  errors.append((fn,msg))
               
             else:              else:
                 if len(founds)==0:                  if len(founds)==0:
                     newPs.append(fn)                      newPs.append(fn)
Line 402  class uploadATFThread(Thread): Line 502  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 412  class uploadATFThread(Thread): Line 512  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:  
             self._v_stack[nr]=[x.getObject().getId() for x in results]  
           
         return self.absolute_url()+"/storeAll?id="+nr  
       
     def storeAll(self,id):  
         """store all"""  
         try:  
             results=self._v_stack[id]  
         except:  
             #TODO: write expired page  
             return "expired"  
           
         return self.storeInBasketForm(results)  
           
     def storeInBasketForm(self,ids):  
         """ store an object form"""  
           
         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:          stObj.returnValue['errors']=errors
             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):          stObj.returnValue['newPs']=newPs
                 """view the basket"""          stObj.returnValue['tmpdir']=dir
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)          stObj.returnValue['basketLen']=basketLen
                 return pt()          stObj.returnValue['numberOfFiles']=numberOfFiles
           stObj.returnValue['basketNameFromId']=basketNameFromId
           stObj.returnValue['basketNameFromFile']=basketNameFromFile
           stObj.returnValue['basketId']=basketId
           stObj.returnValue['dir']=dir
           #stObj.returnValue['changed']=copy.copy(changed)
           stObj.returnValue['changed']=[(x[0].getId(),x[1][0]) for x in changed]
           #stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors]
           stObj.returnValue['lockerrors']=[x for x in lockerrors]
           self.returnValue=True
           #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
   
     def deleteObjects(self,ids,RESPONSE=None):  
         """delete objects"""  
         list = self.contents[0:]  
         for content in list:  
                                 
                 if content.getId() in ids:  class CDLIBasketContainer(OrderedFolder):
                     self.contents.remove(content)      """contains the baskets"""
                   
   
         if RESPONSE:      security=ClassSecurityInfo()
                     RESPONSE.redirect(self.absolute_url())      meta_type="CDLIBasketContainer"
   
       def getPNumbersOfBasket(self,basketName):
           """get all pnumbers of a basket as a list, returns an empty list if basket not found
           @param basketName: name of the basket
           """
           ret=[]
           basketId=self.getBasketIdfromName(basketName)
           if not basketId:
               return []
   
     def unlockTest(self):          ob=getattr(self,basketId).getContent()
         """unlock all files of the testuser for debuggin"""  
         for object in self.contents:  
   
                 if str(object.lockedBy)=="test":          ret=[x[0].split(".")[0] for x in ob]
                     object.lockedBy=""  
                           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):          return ret
         """download all selected files in one file"""  
                   
       security.declareProtected('manage','getBasketAsOneFile')       
       def getBasketAsOneFile(self,basketName,current="no"):
           """returns all files of the basket combined in one file
           @param basketName: Name of the basket
           @param current: (optional) if current is set to "yes" then the most current version of 
                           all files are downloaded and not the versions of the files as stored in the basket
           """
         ret=""          ret=""
         lockedObjects={}          basketId=self.getBasketIdfromName(basketName)
               if not basketId:
         if self.temp_folder.downloadCounter > 10:              return ""
             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  
            
         transaction.get().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  
         transaction.get().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):  
     """contains the baskets"""  
       
   
     security=ClassSecurityInfo()          ob=getattr(self,basketId).getLastVersion()
     meta_type="CDLIBasketContainer"          for object in ob.getContent():
               if current=="no": #version as they are in the basket
                               ret+=str(object[0].getData())+"\n"
               elif current=="yes":
                               #search current object
                               logging.info("crrent: %s"%object[1].getId().split(".")[0])
                               founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
                               if len(founds)>0:      
                                   ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
           return ret
           
       security.declareProtected('manage','upDateBaskets') 
     def upDateBaskets(self):      def upDateBaskets(self):
         """update content in to objects"""          """update content in to objects"""
                   
Line 706  class CDLIBasketContainer(OrderedFolder) Line 606  class CDLIBasketContainer(OrderedFolder)
         trash.manage_pasteObjects(cut)          trash.manage_pasteObjects(cut)
                   
     security.declareProtected('manage','manageBaskets')             security.declareProtected('manage','manageBaskets')       
     def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):      def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):
         """manage baskets, delete or copy"""          """manage baskets, delete or copy"""
         if submit=="delete":          if submit=="delete":
             self.deleteBaskets(ids)              self.deleteBaskets(ids)
                   
                  elif submit=="join":
               flag,msg=self.joinBasket(joinBasket, ids)
               logging.info("joining %s %s"%(flag,msg))
               
           elif submit=="subtract":
               logging.info("BBBb %s %s"%(basket1,basket2))
               flag,msg=self.subtractBasket(subtractBasket, basket1,basket2)
               logging.info("subtract %s %s"%(flag,msg))
                           
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect(self.absolute_url())              RESPONSE.redirect(self.absolute_url())
Line 742  class CDLIBasketContainer(OrderedFolder) Line 649  class CDLIBasketContainer(OrderedFolder)
         return pt(basketId=basketId,basketName=basketName)          return pt(basketId=basketId,basketName=basketName)
         
   
     security.declareProtected('View','index_html')          security.declareProtected('manage','index_html')    
     def index_html(self):      def index_html(self):
         """stanadard ansicht"""          """stanadard ansicht"""
                   
Line 836  class CDLIBasketContainer(OrderedFolder) Line 743  class CDLIBasketContainer(OrderedFolder)
         return baskets          return baskets
   
   
       def subtractBasket(self,newBasket,basket1,basket2):
           """subtract basket2 from basket1 
           (i.e. newbasket will contain alle elements of basket1 which are not in basket2), 
           if basket2 contains files which are not in basket1, then theses files fill be ignored
                  
           @param newbasket: name of the new basket
           @param basket1: basket where basket2 will be subtracted from
           @param basket2: see above
         
           """
           logging.info("CCCCC %s %s"%(basket1,basket2))
      
           try:
               newB=self.addBasket(newBasket)
           except:
               return False, "cannot create the new basket"
           
           
   
          
        
           bas2= getattr(self,basket2)            
           bas2content=bas2.getContent()
           bas2ids=[x[0] for x in bas2content]
           
          
               
           bas1= getattr(self,basket1)   
           bas1content=bas1.getContent()
           
           
           newBasketContent={}
           
           for id,version in bas1content:
               if not (id in bas2ids):
                   newBasketContent[id]=version
           
           username=self.getActualUserName()
           
           logging.info("sbc %s"%newBasketContent)
           newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
           
           return True, ""
       
               
       def joinBasket(self,newBasket,oldBaskets):
           """join two baskets
           @param newbasket: name of the new basket
           @param oldbaskets: list of baskets to be joined
           """
           try:
               newB=self.addBasket(newBasket)
           except:
               return False, "cannot create the new basket"
           
           newBasketContent={}
           for ob in oldBaskets:
               x= getattr(self,ob,None)
               if x is None:
                   return False, "cannot find basket: %s"%ob
               
               ids=x.getContent() # hole den Inhalt
               
               for id,version in ids:
                   if newBasketContent.has_key(id): # p number gibt's schon
                       newBasketContent[id]=max(newBasketContent[id],version) # speichere die groessere Versionsnumber
                   else:
                       newBasketContent[id]=version
           username=self.getActualUserName()
           
           logging.info("nbc %s"%newBasketContent)
           newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
           
           return True, ""
                                                 
     def getNewId(self):      def getNewId(self):
         """createIds"""          """createIds"""
Line 872  class CDLIBasketContainer(OrderedFolder) Line 853  class CDLIBasketContainer(OrderedFolder)
         """get name of the actualuser"""          """get name of the actualuser"""
         return str(self.REQUEST['AUTHENTICATED_USER'])          return str(self.REQUEST['AUTHENTICATED_USER'])
           
           security.declareProtected('manage','addBasket') 
     def addBasket(self,newBasketName):      def addBasket(self,newBasketName):
         """add a new basket"""          """add a new basket"""
                   
Line 928  class CDLIBasket(Folder,CatalogAware): Line 909  class CDLIBasket(Folder,CatalogAware):
     meta_type="CDLIBasket"      meta_type="CDLIBasket"
     default_catalog="CDLIBasketCatalog"      default_catalog="CDLIBasketCatalog"
           
       def searchInBasket(self,indexName,searchStr,regExp=False):
           """searchInBasket"""
   
           lst=self.searchInLineIndexDocs(indexName,searchStr,uniq=True,regExp=regExp)
           ret={}
           
           lv=self.getLastVersion()
   
   
           for obj in lv.content.getContent():
               id=obj[1].getId().split(".")[0]
               if id in lst:
           
                   ret[id]=self.showWordInFile(id,searchStr,lineList=self.getLinesFromIndex(indexName,searchStr,id,regExp=regExp),regExp=regExp,indexName=indexName)
           
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','searchResultsInBasket')).__of__(self)
           return pt(result=ret,indexName=indexName,regExp=regExp,word=searchStr)
           
            
    
           
       def searchInBasket_v1(self,searchStr):
           """search occurences of searchStr in files im basket"""
           ret=[]
           lv=self.getLastVersion()
           logging.info("searching")
           for obj in lv.content.getContent():
               txt=obj[0].getData()
               for x in txt.split("\n"):
                   logging.info("search %s"%x)
                   if re.match(searchStr,x):
                       ret.append(x)
           
           return "\n".join(ret)
                   
   
     def getFile(self,obj):      def getFile(self,obj):
         return obj[1]          return obj[1]
Line 980  class CDLIBasket(Folder,CatalogAware): Line 997  class CDLIBasket(Folder,CatalogAware):
         self.shortDescription=shortDescription          self.shortDescription=shortDescription
         self.comment=comment          self.comment=comment
     
       def getActualUserName(self):
           """get name of the actualuser"""
          
           return str(self.REQUEST['AUTHENTICATED_USER'])
         
                         
     def getLastVersion(self):      def getLastVersion(self):
Line 1044  class CDLIBasket(Folder,CatalogAware): Line 1065  class CDLIBasket(Folder,CatalogAware):
                   
         return obj          return obj
           
       def addObjectsWithVersion(self,ids,deleteOld=None,username=None,catalog=None):
           """generate a new version of the basket with objects added, 
           hier wird jedoch nicht die letzte Version jedes Files hinzugefuegt, s
           ondern ids is ein Tupel mit der Id (d.h. der p-number) und der Versionsnummer.
           """
           logging.info("add to basket (%s)"%(self.getId()))
           lastVersion=self.getLastVersion()
           
           if not catalog:
               catalog=self.CDLICatalog
               
           if lastVersion is None:
               oldContent=[]
           else:
               oldContent=lastVersion.content.getContent()
   
           if deleteOld:
               oldContent=[]
   
           newContent=[]
           added=0
          
           for id,version in ids.iteritems():
               logging.info("adding %s %s"%(id,version))
               id=id.split(".")[0] # title nur die pnumber ohne atf
              
               try:
                   founds=catalog.search({'title':id})
               except:
                   founds=[]
               logging.info(" found %s "%(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().getVersions()[version-1][1],found.getObject()))
                       added+=1
   
           content=oldContent+newContent
           if not username:
               logging.error("XXXXXXXXXXX %s"%repr(self))
               user=self.getActualUserName()
           else:
               user = username
               
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
           logging.info("add to basket (%s) done"%(self.getId()))
           return added
       
       
     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"""
                  logging.info("add to basket (%s)"%(self.getId()))
         lastVersion=self.getLastVersion()          lastVersion=self.getLastVersion()
                   
         if lastVersion is None:          if lastVersion is None:
Line 1064  class CDLIBasket(Folder,CatalogAware): Line 1135  class CDLIBasket(Folder,CatalogAware):
         founds=self.CDLICatalog.search({'title':id})          founds=self.CDLICatalog.search({'title':id})
         except:          except:
         founds=[]          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 1077  class CDLIBasket(Folder,CatalogAware): Line 1149  class CDLIBasket(Folder,CatalogAware):
             user = username              user = username
                           
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)          ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
               logging.info("add to basket (%s) done"%(self.getId()))
         return added          return added
           
           
                                   
       def getContent(self):
           """print content"""
           ret=[]
           
           lv=self.getLastVersion()
           for obj in lv.content.getContent():
               logging.info("XXXXXXXXXX %s"%repr(obj))
               ret.append((obj[1].getId(),obj[0].versionNumber))
               
           return ret
           
     def getContentIds(self):      def getContentIds(self):
         """print basket content"""          """print basket content"""
Line 1169  class CDLIBasketVersion(Implicit,Persist Line 1251  class CDLIBasketVersion(Implicit,Persist
                 return True                  return True
         return False          return False
           
     security.declareProtected('View','downloadObjectsAsOneFile')      def downloadListOfPnumbers(self):
           """download pnumbers of the basket as list"""
           
           basket_name=self.aq_parent.title
           
           ids=self.getContent() # get the list of objects
           logging.error(ids)
           ret="\n".join([x[1].getId().split(".")[0] for x in ids])
           
           self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.txt" """%basket_name)
           self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
           length=len(ret)
           self.REQUEST.RESPONSE.setHeader("Content-Length",length)
           self.REQUEST.RESPONSE.write(ret)    
           
       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"""
                   
Line 1211  class CDLIBasketVersion(Implicit,Persist Line 1308  class CDLIBasketVersion(Implicit,Persist
             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 1241  class CDLIBasketVersion(Implicit,Persist Line 1338  class CDLIBasketVersion(Implicit,Persist
                         ret+=str(object[0].getData())+"\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[1].getId().split(".")[0]})
                         if len(founds)>0:                                if len(founds)>0:      
                             ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"                              ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
                                                           
Line 1287  class CDLIBasketVersion(Implicit,Persist Line 1384  class CDLIBasketVersion(Implicit,Persist
     def __init__(self,id,user,comment="",basketContent=[]):      def __init__(self,id,user,comment="",basketContent=[]):
         """ init a basket version"""          """ init a basket version"""
         self.id=id          self.id=id
         self.coment=comment          self.comment=comment
         self._setObject('content',BasketContent(basketContent))          self._setObject('content',BasketContent(basketContent))
         #self.basketContent=basketContent[0:]a          #self.basketContent=basketContent[0:]a
         self.user=user          self.user=user
Line 1301  class CDLIBasketVersion(Implicit,Persist Line 1398  class CDLIBasketVersion(Implicit,Persist
         """get Comment"""          """get Comment"""
         return self.comment          return self.comment
     
     security.declareProtected('View','index_html')      security.declareProtected('manage','index_html')
     def index_html(self):      def index_html(self):
             """view the basket"""              """view the basket"""
   
Line 1356  class CDLIFileObject(CatalogAware,extVer Line 1453  class CDLIFileObject(CatalogAware,extVer
     
     security.declarePublic('makeThisVersionCurrent')      security.declarePublic('makeThisVersionCurrent')
           
       security.declareProtected('manage','index_html')
     def PrincipiaSearchSource(self):      def PrincipiaSearchSource(self):
            """Return cataloguable key for ourselves."""             """Return cataloguable key for ourselves."""
            return str(self)             return str(self)
Line 1371  class CDLIFileObject(CatalogAware,extVer Line 1469  class CDLIFileObject(CatalogAware,extVer
                   
                   
         newversion=parent.manage_addCDLIFileObject('',comment,author)          newversion=parent.manage_addCDLIFileObject('',comment,author)
         newversion.data=self.data[0:]          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')
Line 1384  class CDLIFileObject(CatalogAware,extVer Line 1482  class CDLIFileObject(CatalogAware,extVer
     def getFormattedData(self):      def getFormattedData(self):
         """fromat text"""          """fromat text"""
         data=self.getData()          data=self.getData()
         return re.sub("\s\#lem"," #lem",data) #remove return vor #lem  #        return re.sub("\s\#lem"," #lem",data) #remove return vor #lem
           return re.sub("#lem","       #lem",data) #remove return vor #lem
                   
     def view(self):      def view(self):
         """view file"""          """view file"""
Line 1463  def manage_addCDLIFileObject(self,id,vC= Line 1562  def manage_addCDLIFileObject(self,id,vC=
 class CDLIFile(extVersionedFile,CatalogAware):  class CDLIFile(extVersionedFile,CatalogAware):
     """CDLI file"""      """CDLI file"""
           
       security=ClassSecurityInfo()
     meta_type="CDLI file"      meta_type="CDLI file"
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
           security.declareProtected('manage','index_html')
     #security.declarePublic('history')      #security.declarePublic('history')
     def getLastVersionData(self):      def getLastVersionData(self):
         """get last version data"""          """get last version data"""
Line 1621  def manage_addCDLIFile(self,id,title,loc Line 1721  def manage_addCDLIFile(self,id,title,loc
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   def checkUTF8(data):
       """check utf 8"""
       try:
           data.encode('utf-8')
           return True
       except:
           return False
   
   
 def checkFile(filename,data,folder):  def checkFile(filename,data,folder):
Line 1632  def checkFile(filename,data,folder): Line 1739  def checkFile(filename,data,folder):
         return False,"P missing in the filename"          return False,"P missing in the filename"
     elif len(fn[0])!=7:      elif len(fn[0])!=7:
         return False,"P number has not the right length 6"          return False,"P number has not the right length 6"
     else:      elif not checkUTF8(data):
         fn=os.path.join(folder,filename)          return False,"not utf-8"
         stin,out=os.popen4("/usr/bin/atfcheck.plx %s"%fn)  
         value=out.read()  
         ret= out.close()  
   
         if value:  
        
             return False,"atf checker error: %s"%value  
         else:          else:
             return True,""              return True,""
           
       
 def splitatf(fh,dir=None,ext=None):  def splitatf(fh,dir=None,ext=None):
     """split it"""      """split it"""
     ret=None      ret=None
     nf=None      nf=None
     i=0      i=0
   
     for lineTmp in fh.readlines():      if (type(fh) is StringType) or (type(fh) is UnicodeType):
           iter=fh.split("\n")
       else:
           iter=fh.readlines()
           
       for lineTmp in iter:
           lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..
     for line in lineTmp.split("\r"):      for line in lineTmp.split("\r"):
               #logging.log("Deal with: %s"%line)
         if ext:          if ext:
         i+=1          i+=1
         if (i%100)==0:          if (i%100)==0:
Line 1677  def splitatf(fh,dir=None,ext=None): Line 1785  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.replace("\n","")+"\n")              nf.write(line.replace("\n","")+"\n")
   
       try:        
     nf.close()      nf.close()
       except:
           pass
       
       if not((type(fh) is StringType) or (type(fh) is UnicodeType)):
     fh.close()      fh.close()
     return ret,len(os.listdir(dir))      return ret,len(os.listdir(dir))
   
Line 1732  class CDLIFileFolder(extVersionedFileFol Line 1846  class CDLIFileFolder(extVersionedFileFol
                   
         return ret          return ret
           
       def getFile(self,fn):
           """get the content of the file fn"""
           founds=self.CDLICatalog.search({'title':fn})
           if not founds:
               return "" 
           else:
               obj=founds[0].getObject().getLastVersion()
   
               return obj.getData()[0:] 
       
     def checkCatalog(self,fn):      def checkCatalog(self,fn):
         """check if fn is in the catalog"""          """check if fn is in the catalog"""
         #TODO add checkCatalog          #TODO add checkCatalog
Line 1754  class CDLIFileFolder(extVersionedFileFol Line 1878  class CDLIFileFolder(extVersionedFileFol
         return pt(search=list,author=author)          return pt(search=list,author=author)
           
           
       def getAllPNumbers(self):
           """get a list of all files (resp their p-numbers) stored"""
           
           ret=[x.getId for x in  self.CDLICatalog()]
        
           return ret
                           
     def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):      def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
         """findObjectsFromList (, TAB oder LINE separated)"""          """findObjectsFromList (, TAB oder LINE separated)"""
Line 1851  class CDLIFileFolder(extVersionedFileFol Line 1981  class CDLIFileFolder(extVersionedFileFol
                 #os.write(tf,obj.getLastVersion().data)                  #os.write(tf,obj.getLastVersion().data)
                 if RESPONSE:                  if RESPONSE:
                     RESPONSE.write(obj.getLastVersion().getData()[0:])                      RESPONSE.write(obj.getLastVersion().getData()[0:])
                       RESPONSE.write("\n")
                 self.temp_folder.downloadCounter-=1                   self.temp_folder.downloadCounter-=1 
                 self._p_changed=1                  self._p_changed=1
         transaction.get().commit()          transaction.get().commit()
Line 1886  class CDLIFileFolder(extVersionedFileFol Line 2017  class CDLIFileFolder(extVersionedFileFol
         return ret          return ret
           
                           
     security.declareProtected('View','index_html')      security.declareProtected('manage','index_html')
     def index_html(self):      def index_html(self):
         """main"""          """main"""
         ext=self.ZopeFind(self,obj_ids=["index.html"])          ext=self.ZopeFind(self,obj_ids=["index.html"])
Line 1935  class CDLIRoot(Folder): Line 2066  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):      def deleteFiles(self,ids):
         """find all words in index which match regexp in SearchTerm"""          """delete files (resp. move into .trash folder)"""
           # find or generete trash folder
           
           found=self.ZopeFind(self,obj_ids=['.trash'])
           
           if len(found)<1:
               manage_addCDLIFileFolder(self, '.trash',title="Trash")
               trash=self._getOb('.trash')
           else:
               logging.info(found)
               trash=found[0][1]
           
           
           for id in ids:
               founds=self.CDLICatalog.search({'title':id.split(".")[0]})
               if founds:
                   logging.info(founds)
                   folder=founds[0].getObject().aq_parent #get the parent folder of the object
                   logging.info(folder)
                   cut=folder.manage_cutObjects([founds[0].getId]) #cut it out
                   trash.manage_pasteObjects(cut)  #paste it in the trash
   
   
       def findWordRegExp(self,indexName,searchTerm):
           """find all words in index which match regexp in SearchTerm
           @param indexName: name of the index to be searched in
           @param searchTerm: word to be searched"""
           
         ret=[]          ret=[]
         for x in self.lineIndex.iterkeys():          for x in self.lineIndexes[indexName].iterkeys():
             if re.match(searchTerm,x):              if re.match(searchTerm,x):
                 ret.append(x)                  ret.append(x)
         return ret          return ret
           
     def searchRegExpInLineIndexDocs(self,searchTerm):      def searchRegExpInLineIndexDocs(self,indexName,searchTerm):
         """search in inLineIndex with regexp"""          """search in inLineIndex with regexp
           @param indexName: name of the index to be searched in
           @param searchTerm: term to be searched
           """
         if not searchTerm:          if not searchTerm:
             return []              return []
         ret=[]          ret=[]
         words=self.findWordRegExp(searchTerm) # suche nach allen Treffern          words=self.findWordRegExp(indexName,searchTerm) # suche nach allen Treffern
         logging.info("wd:%s"%words)          logging.info("wd:%s"%words)
         for word in words:          for word in words:
             ret+=self.searchInLineIndexDocs(word)  
                   
         return unique(ret)              ret+=self.searchInLineIndexDocs(indexName,word)
       
   
           x= unique(ret)
       logging.info("words_done")
           return x
                   
     def showInLineIndex(self):      def showInLineIndex(self):
         """get the index for debug purposes"""          """get the index for debug purposes"""
         print "show"          print "show"
         for x in self.lineIndex.iterkeys():          for key in self.lineIndexes.keys():
               logging.info("index:%s"%key)
               for x in self.lineIndexes[key].iterkeys():
             logging.info("word:%s"%repr(x))              logging.info("word:%s"%repr(x))
             #for y in self.lineIndex[x].iterkeys():              #for y in self.lineIndex[x].iterkeys():
             #    print "doc",repr(y),repr(self.lineIndex[x][y])              #    print "doc",repr(y),repr(self.lineIndex[x][y])
                                   
         return self.lineIndex          return self.lineIndexes
                   
     def searchInLineIndexDocs(self,word,uniq=True,regExp=False):      def searchInLineIndexDocs(self,indexName,word,uniq=True,regExp=False):
         """search occurences"""          """search occurences in an index
           @param indexName: name of the index to be searched in
           @param word: word to be searched
           @param unique: (optional) unify the list of results
           @param regExp: (optional) use regular expressions
           """
   
         if regExp:          if regExp:
             return self.searchRegExpInLineIndexDocs(word)              return self.searchRegExpInLineIndexDocs(indexName,word)
                   
         try:              try:    
             lst=list(self.lineIndex.get(word).keys())                  
                   lst=list(self.lineIndexes[indexName].get(word).keys())
         except:          except:
               logging.error("error: searchInLineIndexDocs (%s %s)"%(sys.exc_info()[0:2]))
             lst=[]              lst=[]
         if uniq:          if uniq:
             return unique(lst)              return unique(lst)
         else:          else:
             return lst              return lst
                   
     def getLinesFromIndex(self,word,doc,regExp=False):      def getLinesFromIndex(self,indexName,word,doc,regExp=False):
         """get lines"""          """return all lines from a document where word is found
           @param indexName: Name of the index
           @param word: word to be searched
           @param doc: name of the document (usuallay the p-number)
           @param regExp: (optional) use regExp       
           """
           
         if not regExp:          if not regExp:
             return self.lineIndex.get(word)[doc]              return self.lineIndexes[indexName].get(word)[doc]
         else: # wenn regexp, suche welches word          else: # wenn regexp, suche welches word
             for w in self.findWordRegExp(word):              for w in self.findWordRegExp(indexName,word):
                 if self.lineIndex.get(w): # ein word in im dex gefunden                  if self.lineIndexes[indexName].get(w): # ein word in im dex gefunden
                     try:                          try:    
                         dc=self.lineIndex.get(word)[doc]                          dc=self.lineIndex[indexName].get(word)[doc]
                         return dc # und ein document dann gib es zurueck                          return dc # und ein document dann gib es zurueck
                     except:                      except:
                          pass #andernfalls weiter                           pass #andernfalls weiter
                                             
     def cleanInLineIndex(self):      def cleanInLineIndex(self,indexName):
         """delete InlineIndex"""          """empty an InlineIndex
         for x in list(self.lineIndex.keys()):          @param indexName: name of the index
             del(self.lineIndex[x])          """
         print [x for x in self.lineIndex.keys()]          for x in list(self.lineIndexes[indexName].keys()):
               del(self.lineIndexes[indexName][x])
           print [x for x in self.lineIndexes[indexName].keys()]
             
         return "ok"          return "ok"
           
     def storeInLineIndex(self,key,value):      def storeInLineIndex(self,indexName,key,value):
         """store in index"""          """store in index, key is normally a word or grapheme 
           and value is a tuple (documentname, line) where the word can be found
           @param indexName: name of the index
           @param key: key in index
           @param value: value in index, value is a tuple (document name, line)
           """
           logging.error("indexing: %s %s"%(indexName,key))
           if (not hasattr(self,'lineIndexes')):
             
         if (not hasattr(self,'lineIndex')) or (type(self.lineIndex) is DictType):              self.lineIndexes={}
             self.lineIndex=OOBTree()              
         li=self.lineIndex          if self.lineIndexes.get(indexName,None) is None:
               #index exisitiert noch nicht dann anlegen
               
               self.lineIndexes[indexName]=OOBTree()
           lis=self.lineIndexes
           li=lis[indexName]
                   
         if li.has_key(key):          if li.has_key(key):
   
Line 2024  class CDLIRoot(Folder): Line 2218  class CDLIRoot(Folder):
             li[key][value[0]]=[value[1]]               li[key][value[0]]=[value[1]] 
                                           
                   
         self.lineIndex=li          self.lineIndexes=lis
             
         transaction.get().commit()          transaction.get().commit()
                   
   
     def showFile(self,fileId):      def showFile(self,fileId,wholePage=False):
         """show a file"""          """show a file
           @param fileId: P-Number of the document to be displayed
           """
         f=self.CDLICatalog({'title':fileId})          f=self.CDLICatalog({'title':fileId})
         if not f:          if not f:
             return ""              return ""
                   
           if wholePage:
               logging.info("whole")
               return f[0].getObject().getLastVersion().view()
           else:
         return f[0].getObject().getLastVersionFormattedData()          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):      def showWordInFile(self,fileId,word,lineList=None,regExp=True,indexName=""):
         """get lines with word  fromFileId"""          """get lines with word  fromFileId"""
                   
         file=self.showFile(fileId)          file=self.showFile(fileId)
       logging.info("regEXP %s"%regExp)
     ret=[]      ret=[]
           if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen
               wordlist=self.findWordRegExp(indexName,word)
           else:
               wordlist=[word]
           
     for line in file.split("\n"):      for line in file.split("\n"):
               found=False
               for word in wordlist:
           try: # just a hack because of possible unicode errors in line
         if line.find(word)>-1:          if line.find(word)>-1:
             if lineList: #liste of moeglichen Zeilennummern              if lineList: #liste of moeglichen Zeilennummern
                 num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile                  num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
Line 2078  class CDLIRoot(Folder): Line 2262  class CDLIRoot(Folder):
                     ret.append(line)                      ret.append(line)
             else: # nimm alles ohne line check              else: # nimm alles ohne line check
                 ret.append(line)                  ret.append(line)
                           
                           break;
           except:
               pass
     return ret      return ret
   
     def tagWordInFile(self,fileId,word,lineList=None):      def tagWordInFile(self,fileId,word,lineList=None,regExp=True,indexName=""):
         """get lines with word  fromFileId"""          """get lines with word  fromFileId"""
                   
         file=self.showFile(fileId)          file=self.showFile(fileId)
     tagStr="""<span class="found">%s</span>"""          tagStr=u'<span class="found">%s</span>'
     ret=[]      ret=[]
           
           if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen
               wordlist=self.findWordRegExp(indexName,word)
           else:
               wordlist=[word]
               
     for line in file.split("\n"):      for line in file.split("\n"):
         if line.find(word)>-1:              line = unicodify(line)
               found=False
               for word in wordlist:
                   if line.find(word)>-1: #word ist gefunden dann makiere und breche die Schleife ab
             if lineList: #liste of moeglichen Zeilennummern              if lineList: #liste of moeglichen Zeilennummern
                 num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile                  num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
   
                 if num in lineList:                   if num in lineList: 
   
                     ret.append(line.replace(word,tagStr%word))                      ret.append(line.replace(word,tagStr%word))
                           
             else: # nimm alles ohne line check              else: # nimm alles ohne line check
                 ret.append(line.replace(word,tagStr%word))                  ret.append(line.replace(word,tagStr%word))
         else:                          found=True
                           break
               if not found: #word wurde nicht gefunden keine makierung
             ret.append(line)              ret.append(line)
     return "<br>\n".join(ret)                          
           return u'<br>\n'.join(ret)
   
     def URLquote(self,str):      def URLquote(self,str):
         """quote url"""          """quote url"""
Line 2128  class CDLIRoot(Folder): Line 2329  class CDLIRoot(Folder):
   
         return ret                                 return ret                       
           
   
     def getChangesByAuthor(self,author,n=100):      def getChangesByAuthor(self,author,n=100):
         """getChangesByAuthor"""          """getChangesByAuthor"""
         zcat=self.CDLIObjectsCatalog          zcat=self.CDLIObjectsCatalog
Line 2189  class CDLIRoot(Folder): Line 2391  class CDLIRoot(Folder):
         return ret          return ret
                                                                                 
                                                                                         
       def uploadATFRPC(self,data,username):
           """upload an atffile via xml-rpc"""
           uploader=uploadATFThread()
           
           #generate an random id for the upload object
           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)
               
           
           uploader.set(data,0,username,idTmp)
           
           stObj=uploader.run()
           
           processor=uploadATFfinallyThread()
           
           basketname=stObj.returnValue['basketNameFromFile']
           
           processor.set("uploadchanged",basketname=basketname,SESSION=stObj.returnValue,username=username,serverport=self.REQUEST['SERVER_PORT'])
           
           processor.run()
           
           
           return generateXMLReturn(stObj.returnValue)
           
     def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):      def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
         """standard ausgabe"""          """upload an atf file / basket file"""
         #self._v_uploadATF.returnValue=None          #self._v_uploadATF.returnValue=None
   
           #generate an random id for the upload thread
           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=="":
               #new thread not called from the waiting page
             tmpVar=False              tmpVar=False
                 
             thread=uploadATFThread()              thread=uploadATFThread()
Line 2206  class CDLIRoot(Folder): Line 2447  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 2230  class CDLIRoot(Folder): Line 2472  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 2242  class CDLIRoot(Folder): Line 2484  class CDLIRoot(Folder):
                 return pt(txt='/uploadATF',threadName=threadName)                  return pt(txt='/uploadATF',threadName=threadName)
                                   
             else:              else:
 #                tmp={}                  tmp=getattr(self.temp_folder,idTmp).returnValue
 #                for key in self._v_uploadATF[threadName].returnValue.keys():  
 #                        t=self._v_uploadATF[threadName].returnValue[key]  
 #                        if type(t) is ListType:  
 #                                       tmp[key]=self._v_uploadATF[threadName].returnValue[key][0:]  
 #                        else:  
 #                                       tmp[key]=self._v_uploadATF[threadName].returnValue[key]  
 #                         repr(tmp[key]),repr(key)  
 #                                         
 #                #  
                 #tmp=self.cdli_main.tmpStore2[threadName]  
                 tmp=self._v_uploadATF[threadName].returnValue  
                   
                 self._v_uploadATF[threadName].continueVar=False  
                   
                 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])  
   
                                 
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
   
Line 2293  class CDLIRoot(Folder): Line 2514  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 2327  class CDLIRoot(Folder): Line 2549  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())
   
Line 2344  class CDLIRoot(Folder): Line 2566  class CDLIRoot(Folder):
             obj=self.ZopeFind(root,obj_ids=[folder])              obj=self.ZopeFind(root,obj_ids=[folder])
             if ext:              if ext:
       
                 ext.result+="<p>adding: %s </p>"%f                  ext.result="<p>adding: %s </p>"%f+ext.result
             if not obj:              if not obj:
                 manage_addCDLIFileFolder(root,folder,folder)                  manage_addCDLIFileFolder(root,folder,folder)
                 fobj=getattr(root,folder)                  fobj=getattr(root,folder)
Line 2398  def manage_addCDLIRoot(self, id, title=' Line 2620  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.59  
changed lines
  Added in v.1.79

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