Diff for /cdli/cdli_files.py between versions 1.21 and 1.53

version 1.21, 2006/06/13 20:59:56 version 1.53, 2006/12/22 11:56:08
Line 1 Line 1
 """CDLI extensions of the filearchive"""  """CDLI extensions of the filearchive"""
 from Products.versionedFile.versionedFile import *  from Products.versionedFile.extVersionedFile import *
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
 from tempfile import mkstemp,mkdtemp  from tempfile import mkstemp,mkdtemp
 import os.path  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 13  from OFS.Folder import manage_addFolder Line 15  from OFS.Folder import manage_addFolder
 import re  import re
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
 from Acquisition import Implicit  from Acquisition import Implicit
   from Globals import Persistent
 from threading import Thread  from threading import Thread
 from ZPublisher.HTTPRequest import HTTPRequest  from ZPublisher.HTTPRequest import HTTPRequest
 from ZPublisher.HTTPResponse import HTTPResponse  from ZPublisher.HTTPResponse import HTTPResponse
 from ZPublisher.BaseRequest import RequestContainer  from ZPublisher.BaseRequest import RequestContainer
 import threading  import threading
 global tmpVar  from BTrees.OOBTree import OOBTree
   
   class BasketContent(SimpleItem):
       """classe fuer den Inhalt eines Baskets"""
       
       def __init__(self,content=[]):
           """content"""
           self.contentList=content[0:]
       
       def getContent(self):
           """get content"""
   
           return self.contentList
       
       def setContent(self,content):
           self.contentList=content[0:]
       
       def numberOfItems(self):
           """number"""
           
           return len(self.getContent())
           
   
 class uploadATFfinallyThread(Thread):  class uploadATFfinallyThread(Thread):
     """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""      """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
Line 76  class uploadATFfinallyThread(Thread): Line 100  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"
         return True          return True
           
       def __del__(self):
           """delete"""
           
           
       
     def getResult(self):      def getResult(self):
         """method for accessing result"""          """method for accessing result"""
                   
Line 99  class uploadATFfinallyThread(Thread): Line 129  class uploadATFfinallyThread(Thread):
         elif procedure=="uploadAll":          elif procedure=="uploadAll":
             uploadFns=[]              uploadFns=[]
             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['lockerrors']:
                     uploadFns.append(x)                      uploadFns.append(x)
                                           
         #or maybe nothing          #or maybe nothing
Line 114  class uploadATFfinallyThread(Thread): Line 144  class uploadATFfinallyThread(Thread):
             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
                 founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=file(os.path.join(SESSION['tmpdir'],fn)))                  founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
                           
                   
         #now add the new files                  #now add the new files        
Line 123  class uploadATFfinallyThread(Thread): Line 153  class uploadATFfinallyThread(Thread):
             tmpDir=SESSION['tmpdir']              tmpDir=SESSION['tmpdir']
             self.result+="<p>Adding files</p>"              self.result+="<p>Adding files</p>"
             #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.cdli_main.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 208  class uploadATFThread(Thread): Line 239  class uploadATFThread(Thread):
         ctx = self.getContext(app,serverport=self.serverport)          ctx = self.getContext(app,serverport=self.serverport)
         self.uploadATFThread(ctx,self.upload,self.basketId)          self.uploadATFThread(ctx,self.upload,self.basketId)
                   
           #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
   
           get_transaction().commit()
       
         while self.continueVar:          while self.continueVar:
             pass              pass
         get_transaction().abort()         
         conn.close()          conn.close()
         print "done"          
                   
     def getResult(self):      def getResult(self):
         """method for accessing result"""          """method for accessing result"""
Line 222  class uploadATFThread(Thread): Line 257  class uploadATFThread(Thread):
         """upload an atf file"""          """upload an atf file"""
         #TODO: add comments          #TODO: add comments
         #TODO: finish uploadATF          #TODO: finish uploadATF
         self.result="<html><body><h2>I am loading your file...</h2>"          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
         basketId=str(basketId)          basketId=str(basketId)
                   
Line 235  class uploadATFThread(Thread): Line 271  class uploadATFThread(Thread):
                   
         changed=[] # changed files          changed=[] # changed files
         errors=[]  # files with errors          errors=[]  # files with errors
           lockerrors=[]  # files with errors
   
         newPs=[]   # new p filed          newPs=[]   # new p filed
         psNotInCatalog=[] # files not in the catalog          psNotInCatalog=[] # files not in the catalog
                   
         #split the uploadedd atf file          #split the uploadedd atf file
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)          basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)
                   
         #find basketId if not set          #find basketId if not set
                   
Line 249  class uploadATFThread(Thread): Line 287  class uploadATFThread(Thread):
             if basketObj:              if basketObj:
                 basketId=basketObj.getId()                  basketId=basketObj.getId()
                                   
         #if there is no active baske and no basketid given, id is empty, else get besketname and length          #if there is no active basket and no basketid given, id is empty, else get besketname and length
         if basketId == '0':          if basketId == '0':
             basketNameFromId=""              basketNameFromId=""
             basketLen=0              basketLen=0
Line 258  class uploadATFThread(Thread): Line 296  class uploadATFThread(Thread):
             basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()              basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
                           
                   
         self.result+="<html><body><h2>I got the files</h2><p>I am checking now the files</p>"          self.result+="""<html><body><h2>I got the files</h2><
                           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>check:%s</p>"%fn              self.result+="<p>process:%s</p>"%fn
                           
             # 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 274  class uploadATFThread(Thread): Line 313  class uploadATFThread(Thread):
             founds=ctx2.CDLICatalog.search({'title':fn})                  founds=ctx2.CDLICatalog.search({'title':fn})    
               
             #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()
               #status,msg=checkFile(fn,data,dir)
               status=True
               msg=""
               if not status: # error
                   errors.append((fn,msg))
               else:
             if len(founds)==0:              if len(founds)==0:
                 newPs.append(fn)                  newPs.append(fn)
                           
Line 282  class uploadATFThread(Thread): Line 329  class uploadATFThread(Thread):
                 #analyse the differences to the actual file                  #analyse the differences to the actual file
                 obj=found.getObject()                  obj=found.getObject()
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.username):                      if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
                     errors.append(obj)                                  lockerrors.append(fn)
                 else:                  else:
                     data=file(os.path.join(dir,fn)).read()                  
                     diffs=obj.diff(data)                      diffs=obj.diff(data)
                     if diffs[0]>0:                      if diffs[0]>0:
                         changed.append((obj,diffs))                              changed.append((obj,diffs)) #hochladen
                         #hochladen  
                   
         #ready, set the returnValues          #ready, set the returnValues
         self.result+="<h3>Done</h3></body></html>"          self.result+="<h3>Done</h3></body></html>"
Line 297  class uploadATFThread(Thread): Line 343  class uploadATFThread(Thread):
         self.returnValue={}          self.returnValue={}
         self.returnValue['changed']=changed          self.returnValue['changed']=changed
         self.returnValue['errors']=errors          self.returnValue['errors']=errors
           self.returnValue['lockerrors']=lockerrors
         self.returnValue['newPs']=newPs          self.returnValue['newPs']=newPs
         self.returnValue['tmpdir']=dir          self.returnValue['tmpdir']=dir
         self.returnValue['basketLen']=basketLen          self.returnValue['basketLen']=basketLen
Line 433  class BasketObject_old(Folder): Line 480  class BasketObject_old(Folder):
   
     def numberOfItems(self):      def numberOfItems(self):
         """return anzahl der elemente im basket"""          """return anzahl der elemente im basket"""
         return len(self.contents)          num=len(self.contents)
           
           return num
           
     def addObjects(self,ids):      def addObjects(self,ids):
         """addObjects"""          """addObjects"""
Line 479  class BasketObject_old(Folder): Line 528  class BasketObject_old(Folder):
         ret=""          ret=""
         lockedObjects={}          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 lock:
                           
Line 505  class BasketObject_old(Folder): Line 557  class BasketObject_old(Folder):
             elif not procedure: #keine fails gesperrt dann alle donwloaden              elif not procedure: #keine fails gesperrt dann alle donwloaden
                 procedure="downloadAll"                   procedure="downloadAll" 
                   
           self.temp_folder.downloadCounter+=1 
           self._p_changed=1
           get_transaction().commit()      
   
   
         for object in self.contents:          for object in self.contents:
                           
                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):                  if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
                     ret+=object.getLastVersion().data                      ret+=object.getLastVersion().getData()
                                   
                 if lock and object.lockedBy=='':                  if lock and object.lockedBy=='':
                     object.lockedBy=self.REQUEST['AUTHENTICATED_USER']                      object.lockedBy=self.REQUEST['AUTHENTICATED_USER']
Line 520  class BasketObject_old(Folder): Line 576  class BasketObject_old(Folder):
         length=len(ret)          length=len(ret)
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)          self.REQUEST.RESPONSE.setHeader("Content-Length",length)
         self.REQUEST.RESPONSE.write(ret)              self.REQUEST.RESPONSE.write(ret)    
           self.temp_folder.downloadCounter-=1 
           self._p_changed=1
           get_transaction().commit()      
                   
                   
 def manage_addBasket_oldObjectForm(self):  def manage_addBasket_oldObjectForm(self):
Line 547  class CDLIBasketContainer(OrderedFolder) Line 606  class CDLIBasketContainer(OrderedFolder)
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type="CDLIBasketContainer"      meta_type="CDLIBasketContainer"
           
       def upDateBaskets(self):
           """update content in to objects"""
           
           founds=self.ZopeFind(self,obj_metatypes=['CDLIBasketVersion'],search_sub=1)
   
           for found in founds:
               found[1].updateBasket()
           
       security.declareProtected('manage','deleteBaskets')        
     def deleteBaskets(self,ids=None):      def deleteBaskets(self,ids=None):
         """delete baskets, i.e. move them into trash folder"""          """delete baskets, i.e. move them into trash folder"""
                   
Line 564  class CDLIBasketContainer(OrderedFolder) Line 632  class CDLIBasketContainer(OrderedFolder)
         cut=self.manage_cutObjects(ids)          cut=self.manage_cutObjects(ids)
         trash.manage_pasteObjects(cut)          trash.manage_pasteObjects(cut)
                   
       security.declareProtected('manage','manageBaskets')       
     def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):      def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):
         """manage baskets, delete or copy"""          """manage baskets, delete or copy"""
         if submit=="delete":          if submit=="delete":
Line 573  class CDLIBasketContainer(OrderedFolder) Line 642  class CDLIBasketContainer(OrderedFolder)
                           
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect(self.absolute_url())              RESPONSE.redirect(self.absolute_url())
       
       security.declareProtected('View','getBasketIdfromName')       
     def getBasketIdfromName(self,basketname):      def getBasketIdfromName(self,basketname):
         """get id from name"""          """get id from name"""
   
Line 598  class CDLIBasketContainer(OrderedFolder) Line 669  class CDLIBasketContainer(OrderedFolder)
         return pt(basketId=basketId,basketName=basketName)          return pt(basketId=basketId,basketName=basketName)
         
   
               security.declareProtected('View','index_html')    
     def index_html(self):      def index_html(self):
         """stanadard ansicht"""          """stanadard ansicht"""
                   
Line 621  class CDLIBasketContainer(OrderedFolder) Line 692  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 694  class CDLIBasketContainer(OrderedFolder) Line 777  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 768  class CDLIBasket(Folder,CatalogAware): Line 855  class CDLIBasket(Folder,CatalogAware):
     meta_type="CDLIBasket"      meta_type="CDLIBasket"
     default_catalog="CDLIBasketCatalog"      default_catalog="CDLIBasketCatalog"
           
   
     def getFile(self,obj):      def getFile(self,obj):
         return obj[1]          return obj[1]
           
Line 779  class CDLIBasket(Folder,CatalogAware): Line 867  class CDLIBasket(Folder,CatalogAware):
                   
         return [x[1].getId() for x in self.getLastVersion().getContent()]          return [x[1].getId() for x in self.getLastVersion().getContent()]
           
   
     def isActual(self,obj):      def isActual(self,obj):
         """teste ob im basket die aktuelle version ist"""          """teste ob im basket die aktuelle version ist"""
         actualNo=obj[1].getLastVersion().getVersionNumber()          actualNo=obj[1].getLastVersion().getVersionNumber()
         storedNo=obj[0].getVersionNumber()          storedNo=obj[0].getVersionNumber()
                   
         founds=self.CDLICatalog.search({'title':obj[0].getId()})          founds=self.CDLICatalog.search({'title':obj[0].getId()})
           if len(founds)>0:
               actualNo=founds[0].getObject().getLastVersion().getVersionNumber()
               
         if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":          if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
             return False, -1              return False, -1
                   
Line 819  class CDLIBasket(Folder,CatalogAware): Line 911  class CDLIBasket(Folder,CatalogAware):
                         
     def getLastVersion(self):      def getLastVersion(self):
         """hole letzte version"""          """hole letzte version"""
         ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])]  
           ids=[]
           idsTmp= self.objectIds()
           for x in idsTmp:
               try:
                   ids.append(int(x))
               except:
                   pass
         ids.sort()          ids.sort()
         
         if len(ids)==0:          if len(ids)==0:
             return None              return None
         else:              else:    
             ob=getattr(self,str(ids[-1]))              ob=getattr(self,str(ids[-1]))
   
               
             return ob              return ob
         
     def getVersions(self):      def getVersions(self):
Line 833  class CDLIBasket(Folder,CatalogAware): Line 935  class CDLIBasket(Folder,CatalogAware):
         return versions          return versions
   
         
       def updateObjects(self,ids,RESPONSE=None,REQUEST=None):
           """update ids, ids not in the basket the add"""
           if type(ids) is not ListType:
               ids=[ids]
          
           lastVersion=self.getLastVersion() 
           oldContent=lastVersion.content.getContent()
           newContent=[]
           
           #first copy the old
           for obj in oldContent:
               if obj[1].getId() not in ids:
                   newContent.append(obj)
           #now add the new
                  
           for id in ids:
               founds=self.CDLICatalog.search({'title':id})
   
               for found in founds:
                   if found.getObject() not in oldContent:
                       #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
                       newContent.append((found.getObject().getLastVersion(),found.getObject()))
           
   
           content=newContent 
           user=self.getActualUserName()
           
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
           
           obj=self._getOb(ob.getId())
           if RESPONSE:
              
               RESPONSE.redirect(obj.absolute_url())
           
           return obj
           
     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"""
Line 842  class CDLIBasket(Folder,CatalogAware): Line 979  class CDLIBasket(Folder,CatalogAware):
         if lastVersion is None:          if lastVersion is None:
             oldContent=[]              oldContent=[]
         else:          else:
             oldContent=lastVersion.basketContent[0:]              oldContent=lastVersion.content.getContent()
   
         if deleteOld:          if deleteOld:
             oldContent=[]              oldContent=[]
Line 850  class CDLIBasket(Folder,CatalogAware): Line 987  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 868  class CDLIBasket(Folder,CatalogAware): Line 1007  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):
           """change a basket"""
           if submit=="update":
               return self.updateObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
           elif submit=="delete":
               return self.deleteObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
               
     def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):      def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
         """delete objects"""          """delete objects"""
                   
Line 875  class CDLIBasket(Folder,CatalogAware): Line 1034  class CDLIBasket(Folder,CatalogAware):
             ids=[ids]              ids=[ids]
                 
         lastVersion=self.getLastVersion()           lastVersion=self.getLastVersion() 
         oldContent=lastVersion.basketContent[0:]          oldContent=lastVersion.content.getContent()
         newContent=[]          newContent=[]
         for obj in oldContent:          for obj in oldContent:
             if obj[1].getId() not in ids:              if obj[1].getId() not in ids:
Line 909  def manage_addCDLIBasket(self,title,shor Line 1068  def manage_addCDLIBasket(self,title,shor
     else:      else:
         return ob          return ob
   
 class CDLIBasketVersion(SimpleItem):  class CDLIBasketVersion(Implicit,Persistent,Folder):
     """version of a basket"""      """version of a basket"""
           
     meta_type="CDLIBasketVersion"      meta_type="CDLIBasketVersion"
       security=ClassSecurityInfo()
           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):      def updateBasket(self):
           """update"""
           try:
               self._setObject('content',BasketContent(self.basketContent))
           except:
               try:
                   if len(self.basketContent)>0:
                       self.content.setContent(self.basketContent)
               except:
                   print "error",self.getId(),self.aq_parent.getId()
           self.basketContent=[]
   
           
       def containsNonActualFiles(self):
           """returns True if basket contains one or more non current files"""
           
           objs=self.getContent()
           for obj in objs:
               if not self.isActual(obj)[0]:
                   return True
           return False
       
       security.declareProtected('View','downloadObjectsAsOneFile')
       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"""
                   
           if self.temp_folder.downloadCounterBaskets > 10000:
               return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
   
   
           if (check=="yes") and self.containsNonActualFiles():
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
               
               return pt(lock=lock)
               
           else:
               
               return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")
           
       def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no"):
           """print do the download"""
   
         ret=""          ret=""
         lockedObjects={}          lockedObjects={}
                   
           self.temp_folder.downloadCounterBaskets+=1 
           self._p_changed=1
           get_transaction().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._p_changed=1
                   get_transaction().commit()      
                   self.temp_folder.downloadCounterBaskets-=1 
                   self._p_changed=1
                   get_transaction().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.basketContent:              for object in self.content.getContent():
   
                 if not object[1].lockedBy=="":                  if not object[1].lockedBy=="":
                     lockedObjects[object[1].title]=repr(object[1].lockedBy)                      lockedObjects[object[1].title]=repr(object[1].lockedBy)
Line 941  class CDLIBasketVersion(SimpleItem): Line 1148  class CDLIBasketVersion(SimpleItem):
             if len(keys)>0 and (not procedure):              if len(keys)>0 and (not procedure):
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects                  self.REQUEST.SESSION['lockedObjects']=lockedObjects
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
                   
                   self.temp_folder.downloadCounterBaskets-=1 
                   self._p_changed=1
                   get_transaction().commit()      
   
                 return pt()                  return pt()
                     
             elif not procedure: #keine fails gesperrt dann alle donwloaden              elif not procedure: #keine fails gesperrt dann alle donwloaden
                 procedure="downloadAll"                   procedure="downloadAll" 
                   
   
         for object in self.basketContent:  
   
           for object in self.content.getContent():
                           
                 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']):
                     ret+=object[0].data                      if current=="no": #version as they are in the basket
                           ret+=str(object[0].getData())+"\n"
                       elif current=="yes":
                           #search current object
                           founds=self.CDLICatalog.search({'title':object[0].getId()})
                           if len(founds)>0:      
                               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']
   
         basket_name=self.aq_parent.title+"_V"+self.getId()          basket_name=self.aq_parent.title+"_V"+self.getId()
                   
         #write basketname to header of atf file          #write basketname to header of atf file
         ret="#atf basket %s\n"%basket_name+ret          ret="#basket: %s\n"%basket_name+ret
   
           self.temp_folder.downloadCounterBaskets-=1 
           self._p_changed=1
           get_transaction().commit()      
                   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)          self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")          self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
         length=len(ret)          length=len(ret)
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)          self.REQUEST.RESPONSE.setHeader("Content-Length",length)
         self.REQUEST.RESPONSE.write(ret)              self.REQUEST.RESPONSE.write(ret)    
                   return True
     
     def numberOfItems(self):      def numberOfItems(self):
         """return anzahl der elemente im basket"""          """return anzahl der elemente im basket"""
         return len(self.basketContent)          return self.content.numberOfItems()
           
     def getTime(self):      def getTime(self):
         """getTime"""          """getTime"""
Line 985  class CDLIBasketVersion(SimpleItem): Line 1208  class CDLIBasketVersion(SimpleItem):
           
     def getContent(self):      def getContent(self):
         """get Basket Content"""          """get Basket Content"""
         return self.basketContent          return self.content.getContent()
   
           
     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.coment=comment
         self.basketContent=basketContent[0:]          self._setObject('content',BasketContent(basketContent))
           #self.basketContent=basketContent[0:]a
         self.user=user          self.user=user
         self.time=time.localtime()          self.time=time.localtime()
                   
Line 1004  class CDLIBasketVersion(SimpleItem): Line 1228  class CDLIBasketVersion(SimpleItem):
         """get Comment"""          """get Comment"""
         return self.comment          return self.comment
     
       security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
             """view the basket"""              """view the basket"""
   
               if self.REQUEST.get('change',False):
                       ob=self.aq_parent.updateObjects(self.REQUEST['change'])
                      
                       self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket
                                           
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
             return pt()              return pt()
             
Line 1041  def manage_addCDLIBasketVersion(self,use Line 1272  def manage_addCDLIBasketVersion(self,use
     else:      else:
         return ob          return ob
           
 class CDLIFileObject(versionedFileObject):  class CDLIFileObject(CatalogAware,extVersionedFileObject):
     """CDLI file object"""      """CDLI file object"""
           
     meta_type="CDLI File Object"      meta_type="CDLI File Object"
       default_catalog='CDLIObjectsCatalog'
           
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
           
    
       security.declarePublic('makeThisVersionCurrent')
       
       def PrincipiaSearchSource(self):
              """Return cataloguable key for ourselves."""
              return str(self)
          
       def makeThisVersionCurrent_html(self):
           """form for making this version current"""
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
           return pt()                 
       def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
           """copy this version to current"""
           parent=self.aq_parent
           
           
           newversion=parent.manage_addCDLIFileObject('',comment,author)
           newversion.data=self.data[0:]
                                           
           if RESPONSE is not None:
               RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
   
   
           return True
       
       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)
         return pt()          return pt()
           
       security.declarePublic('getPNumber')
       def getPNumber(self):
           """get the pnumber"""
           try:
                   txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
           except:
                   txt=self.getData()[0:]
                   
                   return "ERROR"
           try:
               return "P"+txt.group(1)
           except:
               return "ERROR"
   
     security.declarePublic('getDesignation')      security.declarePublic('getDesignation')
     def getDesignation(self):      def getDesignation(self):
         """get the designation out of the file"""          """get the designation out of the file"""
         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 1070  class CDLIFileObject(versionedFileObject Line 1349  class CDLIFileObject(versionedFileObject
 manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')  manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
   
 def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',  def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
                    REQUEST=None):                               from_tmp=False,REQUEST=None):
     """Add a new File object.      """Add a new File object.
   
     Creates a new File object 'id' with the contents of 'file'"""      Creates a new File object 'id' with the contents of 'file'"""
Line 1091  def manage_addCDLIFileObject(self,id,vC= Line 1370  def manage_addCDLIFileObject(self,id,vC=
           
     setattr(self._getOb(id),'author',author)      setattr(self._getOb(id),'author',author)
           
       
     # Now we "upload" the data.  By doing this in two steps, we      # Now we "upload" the data.  By doing this in two steps, we
     # can use a database trick to make the upload more efficient.      # can use a database trick to make the upload more efficient.
     if file:  
       if file and not from_tmp:
         self._getOb(id).manage_upload(file)          self._getOb(id).manage_upload(file)
       elif file and from_tmp:
           self._getOb(id).manage_upload_from_tmp(file)
     if content_type:      if content_type:
         self._getOb(id).content_type=content_type          self._getOb(id).content_type=content_type
   
       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')
           
 class CDLIFile(versionedFile,CatalogAware):  class CDLIFile(extVersionedFile,CatalogAware):
     """CDLI file"""      """CDLI file"""
           
     meta_type="CDLI file"      meta_type="CDLI file"
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
           
       #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):
           """history"""  
   
           ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
           if ext:
               return getattr(self,ext[0][1].getId())()
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
           return pt()
   
   
       def getBasketFromId(self,basketid, context=None):
           """get basket from id"""
   
           if not context:
               context=self
               
           for basket in self.ZopeFind(context,obj_metatypes=["CDLIBasket"]):
               if basket[0]==basketid:
                   return basket[1]
           else:
               None
           
     
     def isContainedInBaskets(self,context=None):      def isContainedInBaskets(self,context=None):
Line 1140  class CDLIFile(versionedFile,CatalogAwar Line 1460  class CDLIFile(versionedFile,CatalogAwar
         else:          else:
             return "Sorry file is locked by somebody else"              return "Sorry file is locked by somebody else"
                   
     def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):      def manage_addCDLIFileObject(self,id,vC,author,
                                    file='',title='',
                                    precondition='', 
                                    content_type='',
                                    changeName='no',newName='', 
                                    come_from=None,
                                    from_tmp=False,RESPONSE=None):
         """add"""          """add"""
         
         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden          try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
             vC=self.REQUEST['vC']              vC=self.REQUEST['vC']
         except:          except:
Line 1162  class CDLIFile(versionedFile,CatalogAwar Line 1489  class CDLIFile(versionedFile,CatalogAwar
                   
   
                   
           
         positionVersionNum=getattr(self,'positionVersionNum','front')          positionVersionNum=getattr(self,'positionVersionNum','front')
                   
         if positionVersionNum=='front':          if positionVersionNum=='front':
Line 1175  class CDLIFile(versionedFile,CatalogAwar Line 1501  class CDLIFile(versionedFile,CatalogAwar
                 id=tmp[0]+"_V%i"%self.getVersion()                  id=tmp[0]+"_V%i"%self.getVersion()
                           
                   
         manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)          manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type,from_tmp=from_tmp)
         objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))          #objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
           objs=getattr(self,id).setVersionNumber(int(self.getVersion()))
           try:
             #FIXME: wozu ist das gut?
         self.REQUEST.SESSION['objID_parent']=self.getId()          self.REQUEST.SESSION['objID_parent']=self.getId()
           except:
             pass
   
         if RESPONSE:          if RESPONSE:
       
             obj=self.ZopeFind(self,obj_ids=[id])[0][1]              obj=self.ZopeFind(self,obj_ids=[id])[0][1]
             if obj.getSize()==0:              if obj.getSize()==0:
                 self.REQUEST.SESSION['objID']=obj.getId()                  self.REQUEST.SESSION['objID']=obj.getId()
Line 1187  class CDLIFile(versionedFile,CatalogAwar Line 1519  class CDLIFile(versionedFile,CatalogAwar
                 return pt()                  return pt()
   
             else:              else:
                   if come_from and (come_from!=""):
                                           RESPONSE.redirect(come_from+"?change="+self.getId())
                   else:
                 RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)                  RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
   
         else:          else:
Line 1201  def manage_addCDLIFileForm(self): Line 1536  def manage_addCDLIFileForm(self):
 def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):  def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
     """add the OSAS_root"""      """add the OSAS_root"""
     newObj=CDLIFile(id,title,lockedBy,author)      newObj=CDLIFile(id,title,lockedBy,author)
                                           
       tryToggle=True
       tryCount=0
       
     
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
       getattr(self,id).reindex_object()
         
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   
   def checkFile(filename,data,folder):
       """check the files"""
       # first check the file name
       fn=filename.split(".") # no extension
   
       if not fn[0][0]=="P":
           return False,"P missing in the filename"
       elif len(fn[0])!=7:
           return False,"P number has not the right length 6"
       else:
           fn=os.path.join(folder,filename)
           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:
               return True,""
   
 def splitatf(fh,dir=None):  def splitatf(fh,dir=None,ext=None):
     """split it"""      """split it"""
     ret=None      ret=None
     nf=None      nf=None
     for line in fh.readlines():      i=0
   
       for lineTmp in fh.readlines():
       for line in lineTmp.split("\r"):
           if ext:
           i+=1
           if (i%100)==0:
               ext.result+="."
           if i==10000:
               i=0
               ext.result+="<br>"
         #check if basket name is in the first line          #check if basket name is in the first line
         if line.find("#atf basket")>=0:          if line.find("#atf basket")>=0: #old convention
             ret=line.replace('#atf basket ','')              ret=line.replace('#atf basket ','')
             ret=ret.split('_')[0]              ret=ret.split('_')[0]
           elif line.find("#basket:")>=0: #new convention
           ret=line.replace('#basket: ','')
           ret=ret.split('_')[0]
   
         else:          else:
             if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile              if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
                 if nf:                  if nf:
Line 1229  def splitatf(fh,dir=None): Line 1605  def splitatf(fh,dir=None):
                     filename=os.path.join(dir,filename)                      filename=os.path.join(dir,filename)
                 nf=file(filename,"w")                  nf=file(filename,"w")
             if nf:                  if nf:    
                 nf.write(line)              nf.write(line.replace("\n","")+"\n")
                   
     nf.close()      nf.close()
     fh.close()      fh.close()
     return ret,len(os.listdir(dir))      return ret,len(os.listdir(dir))
   
   
 class CDLIFileFolder(versionedFileFolder):  class CDLIFileFolder(extVersionedFileFolder):
     """CDLI File Folder"""      """CDLI File Folder"""
           
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
Line 1244  class CDLIFileFolder(versionedFileFolder Line 1620  class CDLIFileFolder(versionedFileFolder
     filesMetaType=['CDLI file']      filesMetaType=['CDLI file']
     folderMetaType=['CDLI Folder']      folderMetaType=['CDLI Folder']
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
           defaultFileCatalog=default_catalog #wenn dieses definiert ist, wird beim hinzufŸgen einer neuen version eines files dieser catalog neuiniziert
       #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
       tmpStore2={}
     def setTemp(self,name,value):      def setTemp(self,name,value):
         """set tmp"""          """set tmp"""
   
Line 1285  class CDLIFileFolder(versionedFileFolder Line 1663  class CDLIFileFolder(versionedFileFolder
         """check if fn is in the catalog"""          """check if fn is in the catalog"""
         #TODO add checkCatalog          #TODO add checkCatalog
                     
     def refreshTxt(self,txt=""):  
         """txt fuer refresh"""  
     
         return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,self.threadName)  
   
       
     def getResult(self):  
        """result of thread"""  
        try:  
         return self._v_uploadATF.getResult()  
        except:  
         return "One moment, please"  
       
     def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):  
         """standard ausgabe"""  
         #self._v_uploadATF.returnValue=None  
   
         threadName=repeat  
         if not threadName or threadName=="":  
             tmpVar=False  
             thread=uploadATFThread()  
             self._v_uploadATF=thread  
             #self._xmltrans.start()  
             #thread=Thread(target=self._v_uploadATF)  
               
             self._v_uploadATF.set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])  
             #thread.start()  
             self._v_uploadATF.start()  
   
               
             self.threadName=self._v_uploadATF.getName()[0:]  
             wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])  
   
             if wait_template:  
                 return wait_template[0][1]()  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)  
             return pt(txt='/uploadATF')  
             #_v_xmltrans.run()  
               
         else:  
             #recover thread, if lost  
             if not hasattr(self,'_v_uploadATF'):  
                  for thread in threading.enumerate():  
                          if threadName == thread.getName():  
                                        self._v_uploadATF=thread  
   
             if not self._v_uploadATF.returnValue:  
           
   
                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])  
                 if wait_template:  
                         return wait_template[0][1]()  
                   
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)  
   
                 return pt(txt='/uploadATF')  
                                   
             else:  
   
                 tmp=self._v_uploadATF.returnValue  
                 self._v_uploadATF.continueVar=False  
                   
                 self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]  
                 self.REQUEST.SESSION['errors']=[x.getId() for x in tmp['errors']]  
                 self.REQUEST.SESSION['newPs']=tmp['newPs']  
                 self.REQUEST.SESSION['tmpdir']=tmp['dir']  
         
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)  
                 return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],  
                   basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])  
                                          
     def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):  
         """nowupload the files"""  
                 
       def findObjectsFromListWithVersion(self,list,author=None):
           """find objects from a list with versions
           @param list: list of tuples  (cdliFile,version)
           """
                 
                 
         threadName=repeat  
         if not threadName or threadName=="":  
               
              
             self._v_uploadATF=uploadATFfinallyThread()  
   
           
             self._v_uploadATF.set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])  
   
             self._v_uploadATF.start()  
   
               
             self.threadName=self._v_uploadATF.getName()[0:]  
             wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])  
   
             if wait_template:  
                 return wait_template[0][1]()  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)  
   
             return pt(txt='/uploadATFfinally')  
             #_v_xmltrans.run()  
           
         else:  
             #recover thread, if lost  
             if not hasattr(self,'_v_uploadATF'):  
                  for thread in threading.enumerate():  
                          if threadName == thread.getName():  
                                        self._v_uploadATF=thread  
                                          
             if hasattr(self,'_v_uploadATF') and (self._v_uploadATF is not None) and (not self._v_uploadATF.end) :  
   
                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])          #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
                 if wait_template:          #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                         return wait_template[0][1]()  
                                   
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)  
                 return pt(txt='/uploadATFfinally')  
             else:  
   
               if RESPONSE is not None:          pt=getattr(self,'filelistVersioned.html')
                   RESPONSE.redirect(self.aq_parent.absolute_url())  
                                   
           return pt(search=list,author=author)
                                                                         
   
   
     def findObjectsFromList(self,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)"""
                                                                                 
                   
         if upload: # list from file upload          if upload: # list from file upload
             txt=upload.read()              txt=upload.read()
                                          
           if enterList:
               txt=enterList
               
           if upload or enterList:
             txt=txt.replace(",","\n")              txt=txt.replace(",","\n")
             txt=txt.replace("\t","\n")              txt=txt.replace("\t","\n")
             txt=txt.replace("\r","\n")              txt=txt.replace("\r","\n")
Line 1438  class CDLIFileFolder(versionedFileFolder Line 1719  class CDLIFileFolder(versionedFileFolder
         if list is not None: # got already a list          if list is not None: # got already a list
             ret=[]              ret=[]
             for fileId in list:              for fileId in list:
                 if len(fileId.split("."))==1:                  if fileId.find("*"): #check for wildcards
                           fileId=fileId
                   elif len(fileId.split("."))==1:
                         fileId=fileId+".atf"                          fileId=fileId+".atf"
   
                 ret+=self.CDLICatalog({'title':fileId})                  ret+=self.CDLICatalog({'title':fileId})
             #TODO: get rid of one of these..              #TODO: get rid of one of these..
             self.REQUEST.SESSION['fileIds']=[x.getObject().getId() for x in ret]#store fieldIds in session for further usage              ids=[x.getObject().getId() for x in ret]
               self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
             self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']              self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
               
               if display:
                   pt=getattr(self,'filelist.html')
                   
                   return pt(search=ids)
               else:      
             return ret              return ret
                   
           
           
         if start:          if start:
             RESPONSE.redirect("filelist.html?start:int="+str(start))              RESPONSE.redirect("filelist.html?start:int="+str(start))
                                                                                 
   
   
     security.declareProtected('Manage','createAllFilesAsSingleFile')      security.declareProtected('Manage','createAllFilesAsSingleFile')
     def createAllFilesAsSingleFile(self,RESPONSE=None):      def createAllFilesAsSingleFile(self,RESPONSE=None):
         """download all files"""          """download all files"""
Line 1461  class CDLIFileFolder(versionedFileFolder Line 1752  class CDLIFileFolder(versionedFileFolder
                   
         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 getattr(self.temp_folder,'downloadCounter',0) > 5:
               return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
   
           self.temp_folder.downloadCounter+=1
           self._p_changed=1
           get_transaction().commit()
                   
         list=[(x.getId,x) for x in catalog()]          list=[(x.getId,x) for x in catalog()]
         list.sort(sortF)          list.sort(sortF)
                   
   
           
         RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")          RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
         RESPONSE.setHeader("Content-Type","application/octet-stream")          RESPONSE.setHeader("Content-Type","application/octet-stream")
                  tmp=""
         for l in list:          for l in list:
             obj=l[1].getObject()              obj=l[1].getObject()
                           
Line 1476  class CDLIFileFolder(versionedFileFolder Line 1777  class CDLIFileFolder(versionedFileFolder
                                   
                 #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._p_changed=1
           get_transaction().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 1509  class CDLIFileFolder(versionedFileFolder Line 1813  class CDLIFileFolder(versionedFileFolder
         return ret          return ret
           
                           
     def getFolders_OLD(self):      security.declareProtected('View','index_html')
         """get all subfolders"""  
         ret=[]  
         folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)  
         for folder in folders:  
             ret.append((folder[1],  
                         len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),  
                         len(getattr(self,self.default_catalog)({'path':folder[0]}))  
                         ))  
         return ret  
       
     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 1529  class CDLIFileFolder(versionedFileFolder Line 1823  class CDLIFileFolder(versionedFileFolder
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
         return pt()          return pt()
           
     def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):  
         """import files"""  
                   
   manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
   
       
   def manage_addCDLIFileFolder(self, id, title='',
                        createPublic=0,
                        createUserF=0,
                        REQUEST=None):
       """Add a new Folder object with id *id*.
   
       If the 'createPublic' and 'createUserF' parameters are set to any true
       value, an 'index_html' and a 'UserFolder' objects are created respectively
       in the new folder.
       """
       ob=CDLIFileFolder()
       ob.id=str(id)
       ob.title=title
       self._setObject(id, ob)
       ob=self._getOb(id)
   
       checkPermission=getSecurityManager().checkPermission
   
       if createUserF:
           if not checkPermission('Add User Folders', ob):
               raise Unauthorized, (
                     'You are not authorized to add User Folders.'
                     )
           ob.manage_addUserFolder()
   
     
       if REQUEST is not None:
           return self.manage_main(self, REQUEST, update_menu=1)
       
   class CDLIRoot(Folder):
       """main folder for cdli"""
       
       meta_type="CDLIRoot"
       downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible
       
       def showInLineIndex(self):
           """get the index for debug purposes"""
           print "show"
           for x in self.lineIndex.iterkeys():
               print "word:",x
               for y in self.lineIndex[x].iterkeys():
                   print "doc",y,self.lineIndex[x][y]
                   
           return self.lineIndex
           
       def searchInLineIndexDocs(self,word):
           """search occurences"""
           return list(self.lineIndex.get(word.upper()).keys())
   
       def getLinesFromIndex(self,word,doc):
           """get lines"""
           return self.lineIndex[word][doc]
   
       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]])):
                   li[key][value[0]].append(value[1]) # add it if now in the array
               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
        
           get_transaction().commit()
           
   
       def showFile(self,fileId):
           """show a file"""
           f=self.CDLICatalog({'title':fileId})
           if not f:
               return ""
           
           return f[0].getObject().getLastVersionFormattedData()
           
       def URLquote(self,str):
           """quote url"""
           return urllib.quote(str)
       
       def URLunquote(self,str):
           """unquote url"""
           return urllib.unquote(str)
       
       
       def forceunlock(self):
           "break all locks"
           ret=[]
           for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
              un=f[1].forceunlock()
   
              if un and un !="":
                  ret.append((f[0],un))
   
           return ret                       
       
       def getChangesByAuthor(self,author,n=100):
           """getChangesByAuthor"""
           zcat=self.CDLIObjectsCatalog
           res=zcat({'lastEditor':author,
                        'sort_on':'getTime',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
                          
           return res
       
       def getChangesByAuthor_html(self,author,n=100):
           """html output for changes by author"""
           tmp={}
           list=[]                         
           for x in self.getChangesByAuthor(author):
              nr=x.getObject().getVersionNumber()
              id=x.getObject().aq_parent.getId()
              #hinzufuegen, wenn Version neuer als die 
              if tmp.get(id,(0,0))[1] < nr:
                   tmp[id]=(x.getObject().aq_parent,nr)
   
        
           return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values(),author=author)           
           
       def getLastChanges(self,n=100):
           """get the last n changes""" 
           n=int(n)                   
           zcat=self.CDLICatalog
           return zcat({'sort_on':'getLastChangeDate',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
        
       
       def getLastChanges_html(self,n=100):
           """get the last n changes"""
           list = [x.getId for x in self.getLastChanges(n)]
           return self.cdli_main.findObjectsFromList(list=list,display=True)
                                          
       def refreshTxt(self,txt="",threadName=None):
           """txt fuer refresh"""
     
           return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
   
       
       def getResult(self,threadName=None):
          """result of thread"""
          try:
           return self._v_uploadATF[threadName].getResult()
          except:
           return "One moment, please"
       
           
       def checkThreads(self):
           """check threads"""
           ret="<html><body>"
           for thread in threading.enumerate():
              ret+="<p>%s (%s): %s</p>"%(repr(thread),thread.getName(),thread.isAlive())
          
           return ret
                                          
                                              
       
       def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
           """standard ausgabe"""
           #self._v_uploadATF.returnValue=None
   
           threadName=repeat
           if not threadName or threadName=="":
               tmpVar=False
          
               thread=uploadATFThread()
               threadName=thread.getName()[0:]                                
               if (not hasattr(self,'_v_uploadATF')):
                      self._v_uploadATF={}
                                          
               self._v_uploadATF[threadName]=thread
               #self._xmltrans.start()
               #thread=Thread(target=self._v_uploadATF)
               
               self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
               #thread.start()
               self._v_uploadATF[threadName].start()
   
               
               self.threadName=self._v_uploadATF[threadName].getName()[0:]
               wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
   
               if wait_template:
                   return wait_template[0][1]()
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
               return pt(txt='/uploadATF',threadName=threadName)
               #_v_xmltrans.run()
               
           else:
               #recover thread, if lost
               if (not hasattr(self,'_v_uploadATF')):
                  self._v_uploadATF={}
               if not self._v_uploadATF.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF[threadName]=thread
                                          
               if not self._v_uploadATF[threadName].returnValue:
           
   
                   wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   if wait_template:
                           return wait_template[0][1]()
                   
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
   
                   return pt(txt='/uploadATF',threadName=threadName)
                   
               else:
   #                tmp={}
   #                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)
   
                   return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                     basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                        
       def redoUpload(self,threadName):
          """redo the upload"""
          tmp=self.cdli_main.tmpStore2[threadName]
          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
          return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                     basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                    
       def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
           """nowupload the files"""
          
          
          
           threadName=repeat
           if not threadName or threadName=="":
               thread=uploadATFfinallyThread()
               threadName=thread.getName()[0:]
   
               if (not hasattr(self,'_v_uploadATF')):
                                   self._v_uploadATF={}
   
   
               self._v_uploadATF[threadName]=thread
   
           
               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'])
   
               self._v_uploadATF[threadName].start()
   
               
               
               wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
   
               if wait_template:
                   return wait_template[0][1]()
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
   
               return pt(txt='/uploadATFfinally',threadName=threadName)
               #_v_xmltrans.run()
           
           else:
               #recover thread, if lost
               if not hasattr(self,'_v_uploadATF'):
                  self._v_uploadATF={}
               if not self._v_uploadATF.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF[threadName]=thread
                                          
               if self._v_uploadATF.get(threadName,None) and (self._v_uploadATF[threadName] is not None) and (not self._v_uploadATF[threadName].end) :
   
                   wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   if wait_template:
                           return wait_template[0][1]()
                   
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                   return pt(txt='/uploadATFfinally',threadName=threadName)
               else:
   
                 if RESPONSE is not None:
                     RESPONSE.redirect(self.absolute_url())
   
       def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):
           """import files"""
           root=self.cdli_main
           count=0
         if not files:          if not files:
             files=os.listdir(folderName)              files=os.listdir(folderName)
                           
         for f in files:          for f in files:
             folder=f[0:3]              folder=f[0:3]
             f2=f[0:5]              f2=f[0:5]
             obj=self.ZopeFind(self,obj_ids=[folder])              obj=self.ZopeFind(root,obj_ids=[folder])
             if ext:              if ext:
       
                 ext.result+="<p>Adding: %s </p>"%f                  ext.result+="<p>adding: %s </p>"%f
             if not obj:              if not obj:
                 manage_addCDLIFileFolder(self,folder,folder)                  manage_addCDLIFileFolder(root,folder,folder)
                 fobj=getattr(self,folder)                  fobj=getattr(root,folder)
                           #get_transaction().commit()                           
             else:              else:
                 fobj=obj[0][1]                  fobj=obj[0][1]
                           
Line 1558  class CDLIFileFolder(versionedFileFolder Line 2174  class CDLIFileFolder(versionedFileFolder
             else:              else:
                 fobj2=obj2[0][1]                  fobj2=obj2[0][1]
                               
             file2=file(os.path.join(folderName,f))                 file2=os.path.join(folderName,f)  
             id=f              id=f
             manage_addCDLIFile(fobj2,f,'','')              manage_addCDLIFile(fobj2,f,'','')
             id=f              id=f
             ob=fobj2._getOb(f)              ob=fobj2._getOb(f)
             ob.title=id              ob.title=id
                           
             manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')              manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='',from_tmp=True)
             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"
           get_transaction().commit()
           count=0
       get_transaction().commit()
         return "ok"          return "ok"
           
 manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())  
   
   manage_addCDLIRootForm=DTMLFile('dtml/rootAdd', globals())
           
 def manage_addCDLIFileFolder(self, id, title='',      
   def manage_addCDLIRoot(self, id, title='',
                      createPublic=0,                       createPublic=0,
                      createUserF=0,                       createUserF=0,
                      REQUEST=None):                       REQUEST=None):
Line 1585  def manage_addCDLIFileFolder(self, id, t Line 2208  def manage_addCDLIFileFolder(self, id, t
     value, an 'index_html' and a 'UserFolder' objects are created respectively      value, an 'index_html' and a 'UserFolder' objects are created respectively
     in the new folder.      in the new folder.
     """      """
     ob=CDLIFileFolder()      ob=CDLIRoot()
     ob.id=str(id)      ob.id=str(id)
     ob.title=title      ob.title=title
     self._setObject(id, ob)      self._setObject(id, ob)

Removed from v.1.21  
changed lines
  Added in v.1.53


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