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

Diff for /cdli/cdli_files.py between versions 1.18 and 1.44

version 1.18, 2006/06/12 16:46:48 version 1.44, 2006/08/24 09:28:29
Line 11  from OFS.SimpleItem import SimpleItem Line 11  from OFS.SimpleItem import SimpleItem
 import time  import time
 from OFS.Folder import manage_addFolder  from OFS.Folder import manage_addFolder
 import re  import re
   from AccessControl import ClassSecurityInfo
   from Acquisition import Implicit
   from Globals import Persistent
   from threading import Thread
   from ZPublisher.HTTPRequest import HTTPRequest
   from ZPublisher.HTTPResponse import HTTPResponse
   from ZPublisher.BaseRequest import RequestContainer
   import threading
       
   
   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 for adding uploaded filed (temporarily stored in the staging area at /tmp"""
       
       def __init__(self):
           """init for uploadATFfinallyThread"""
           self.continueVar=True
           self.returnValue=None
           self.end=False
           Thread.__init__(self)
              
       def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):
           """set start values for the thread"""
           self.procedure=procedure
           self.comment=comment
           self.basketname=basketname
           self.unlock=unlock
           self.SESSION=SESSION
           self.username=username
           self.serverport=serverport
           
       def __call__(self):
           """call of the thread (equals run)"""
           self.run()
           return True
       
       def getContext(self, app,serverport="8080"):
           """get the context within the ZODB"""
           
           resp = HTTPResponse(stdout=None)
           env = {
               'SERVER_NAME':'localhost',
               'SERVER_PORT':serverport,
               'REQUEST_METHOD':'GET'
               }
           req = HTTPRequest(None, env, resp)
           return app.__of__(RequestContainer(REQUEST = req))
             
           
       def run(self):
           """run"""
           
           self.result=""
           #find context within ZODB
           from Zope import DB
           conn = DB.open()
           root = conn.root()
           app  = root['Application']
           ctx = self.getContext(app,serverport=self.serverport)
   
           #add the files
           self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
           #commit the transactions
           get_transaction().commit()
           conn.close()
           #set flag for end of this method
           self.end=True
           return True
       
       def __del__(self):
           """delete"""
           
           
       
       def getResult(self):
           """method for accessing result"""
           
           return self.result
        
       def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
           """upload the files"""
           #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
           ctx2=ctx.cdliRoot
      
           self.result+="<h2>Start processing</h2>"
           
           #shall I only upload the changed files?
           if procedure=="uploadchanged":
         
               uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])
           
           #or all
           elif procedure=="uploadAll":
               uploadFns=[]
               for x in os.listdir(SESSION['tmpdir']):
                   if not x in SESSION['errors']:
                       uploadFns.append(x)
                       
           #or maybe nothing
           elif procedure=="noupload":
                           return True
           else:
               uploadFns=[]
               
           #do first the changed files    
           for fn in uploadFns:
               founds=ctx2.CDLICatalog.search({'title':fn})
               if len(founds)>0:
                   SESSION['author']=str(username)
                   self.result+="<p>Changing : %s"%fn
                   founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=file(os.path.join(SESSION['tmpdir'],fn)))
               
           
           #now add the new files        
           newPs=SESSION['newPs']
           if len(newPs)>0:
               tmpDir=SESSION['tmpdir']
               self.result+="<p>Adding files</p>"
               #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)
                   
           
           
           #unlock locked files?
           if unlock:
               self.result+="<p>Unlock files</p>"
               unlockFns=[]
               for x in os.listdir(SESSION['tmpdir']):
                       if not x in SESSION['errors']:
                           unlockFns.append(x)
               
               for fn in unlockFns:
                   founds=ctx2.CDLICatalog.search({'title':fn})
                   if len(founds)>0:
                       SESSION['author']=str(username)
                      
                       founds[0].getObject().lockedBy=""
                       
           #if a basketname is give, add files to the basket
           if not (basketname ==''):
               self.result+="<p>Add basket</p>"
               basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
               
               if not basketId: # create new basket
                   ob=ctx2.basketContainer.addBasket(basketname)
                   basketId=ob.getId()
               basket=getattr(ctx2.basketContainer,str(basketId))
               ids=os.listdir(SESSION['tmpdir'])
               basket.addObjects(ids,deleteOld=True,username=str(username))    
                  
           if RESPONSE is not None:
               RESPONSE.redirect(self.aq_parent.absolute_url())
           
   
          
           return True
       
   class uploadATFThread(Thread):
       """class for checking the files befor uploading"""
       
       def __init__(self):
           """initialise"""
           
           self.continueVar=True
           self.returnValue=None
           
           Thread.__init__(self)
           
           
       def set(self,upload,basketId,username,serverport="8080"):
           """set start values for the thread"""
           self.result=""
           self.upload=upload
           self.basketId=basketId
           self.username=username
           self.serverport=serverport
           
       def __call__(self):
           """call method """
           self.run()
           return True
       
       def getContext(self, app,serverport="8080"):
           """get the context within the ZODB"""
           resp = HTTPResponse(stdout=None)
           env = {
               'SERVER_NAME':'localhost',
               'SERVER_PORT':serverport,
               'REQUEST_METHOD':'GET'
               }
           req = HTTPRequest(None, env, resp)
           return app.__of__(RequestContainer(REQUEST = req))
           
       def run(self):
        
           self.result=""
           #find context within ZODB
           from Zope import DB
           conn = DB.open()
           root = conn.root()
           app  = root['Application']
           ctx = self.getContext(app,serverport=self.serverport)
           self.uploadATFThread(ctx,self.upload,self.basketId)
        
           #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
   
           get_transaction().commit()
           
           while self.continueVar:
               pass
           
           conn.close()
           
           
       def getResult(self):
           """method for accessing result"""
           return self.result
       
       def uploadATFThread(self,ctx,upload,basketId=0):
           """upload an atf file"""
           #TODO: add comments
           #TODO: finish uploadATF
           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
           basketId=str(basketId)
           
           #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
           ctx2=ctx.cdliRoot
           
           #get temporary file for staging the downloaded and splitted files
           dir=mkdtemp()
           
           
           changed=[] # changed files
           errors=[]  # files with errors
           newPs=[]   # new p filed
           psNotInCatalog=[] # files not in the catalog
           
           #split the uploadedd atf file
           basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)
           
           #find basketId if not set
           
           #get active abaket
           if basketId == '0':
               basketObj=ctx2.basketContainer.getActiveBasket()
               if basketObj:
                   basketId=basketObj.getId()
                   
           #if there is no active baske and no basketid given, id is empty, else get besketname and length
           if basketId == '0':
               basketNameFromId=""
               basketLen=0
           else:
               basketNameFromId=getattr(ctx2.basketContainer,basketId).title
               basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
               
           
           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
           for fn in os.listdir(dir):
               
               self.result+="<p>process:%s</p>"%fn
               
               # check if file is in the catalog
               #TODO: checkCatalog is not implemented yet
               if ctx2.cdli_main.checkCatalog(fn):
                   psNotInCatalog.append(fn)
                   
               #check if p-file already at the server  
               founds=ctx2.CDLICatalog.search({'title':fn})    
         
               #if not than add filename to the list of newfiles
               if len(founds)==0:
                   newPs.append(fn)
               
               #if p file alread at the server    
               for found in founds:
                   #analyse the differences to the actual file
                   obj=found.getObject()
   
                   if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
                       errors.append(obj)
                   else:
                       data=file(os.path.join(dir,fn)).read()
                       diffs=obj.diff(data)
                       if diffs[0]>0:
                           changed.append((obj,diffs))
                           #hochladen
           
           #ready, set the returnValues
           self.result+="<h3>Done</h3></body></html>"
           
           self.returnValue={}
           self.returnValue['changed']=changed
           self.returnValue['errors']=errors
           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):  class Basket_old(Folder):
     """shopping basket - alte fassung """      """shopping basket - alte fassung """
Line 136  class BasketObject_old(Folder): Line 467  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 250  class CDLIBasketContainer(OrderedFolder) Line 583  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 267  class CDLIBasketContainer(OrderedFolder) Line 609  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 276  class CDLIBasketContainer(OrderedFolder) Line 619  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 301  class CDLIBasketContainer(OrderedFolder) Line 646  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 471  class CDLIBasket(Folder,CatalogAware): Line 816  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 482  class CDLIBasket(Folder,CatalogAware): Line 828  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 522  class CDLIBasket(Folder,CatalogAware): Line 872  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 536  class CDLIBasket(Folder,CatalogAware): Line 896  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=[]
           
     def addObjects(self,ids,deleteOld=None):          #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):
         """generate a new version of the basket with objects added"""          """generate a new version of the basket with objects added"""
                 
         lastVersion=self.getLastVersion()          lastVersion=self.getLastVersion()
Line 545  class CDLIBasket(Folder,CatalogAware): Line 940  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 562  class CDLIBasket(Folder,CatalogAware): Line 957  class CDLIBasket(Folder,CatalogAware):
                     added+=1                      added+=1
   
         content=oldContent+newContent          content=oldContent+newContent
                   if not username:
         user=self.getActualUserName()          user=self.getActualUserName()
           else:
               user = username
                   
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)          ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
           
         return added          return added
           
       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 576  class CDLIBasket(Folder,CatalogAware): Line 980  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 610  def manage_addCDLIBasket(self,title,shor Line 1014  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 (check=="yes") and self.containsNonActualFiles():
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
               return pt(lock=lock)
               
         ret=""          ret=""
         lockedObjects={}          lockedObjects={}
                   
Line 630  class CDLIBasketVersion(SimpleItem): Line 1062  class CDLIBasketVersion(SimpleItem):
   
             #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 648  class CDLIBasketVersion(SimpleItem): Line 1080  class CDLIBasketVersion(SimpleItem):
                 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].data)+"\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().data)+"\n"
                                   
                 if lock and object[1].lockedBy=='':                  if lock and object[1].lockedBy=='':
                     object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']                      object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
Line 670  class CDLIBasketVersion(SimpleItem): Line 1108  class CDLIBasketVersion(SimpleItem):
     
     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 686  class CDLIBasketVersion(SimpleItem): Line 1124  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 705  class CDLIBasketVersion(SimpleItem): Line 1144  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 742  def manage_addCDLIBasketVersion(self,use Line 1188  def manage_addCDLIBasketVersion(self,use
     else:      else:
         return ob          return ob
           
 class CDLIFileObject(versionedFileObject):  class CDLIFileObject(CatalogAware,versionedFileObject):
     """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 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.data[0:])
           except:
                   txt=self.data[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"""
Line 808  class CDLIFile(versionedFile,CatalogAwar Line 1297  class CDLIFile(versionedFile,CatalogAwar
     meta_type="CDLI file"      meta_type="CDLI file"
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
           
       #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 841  class CDLIFile(versionedFile,CatalogAwar Line 1353  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,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']
Line 863  class CDLIFile(versionedFile,CatalogAwar Line 1380  class CDLIFile(versionedFile,CatalogAwar
                   
   
                   
           
         positionVersionNum=getattr(self,'positionVersionNum','front')          positionVersionNum=getattr(self,'positionVersionNum','front')
                   
         if positionVersionNum=='front':          if positionVersionNum=='front':
Line 878  class CDLIFile(versionedFile,CatalogAwar Line 1394  class CDLIFile(versionedFile,CatalogAwar
                   
         manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)          manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)
         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()))
           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 888  class CDLIFile(versionedFile,CatalogAwar Line 1409  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 902  def manage_addCDLIFileForm(self): Line 1426  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)
         
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   
   
 def splitatf(fh,dir=None):  def splitatf(fh,dir=None,ext=None):
     """split it"""      """split it"""
     ret=None      ret=None
     nf=None      nf=None
       i=0
     for line in fh.readlines():      for line in fh.readlines():
           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:
             ret=line.replace('#atf basket ','')              ret=line.replace('#atf basket ','')
Line 936  def splitatf(fh,dir=None): Line 1475  def splitatf(fh,dir=None):
     fh.close()      fh.close()
     return ret,len(os.listdir(dir))      return ret,len(os.listdir(dir))
   
   
 class CDLIFileFolder(versionedFileFolder):  class CDLIFileFolder(versionedFileFolder):
     """CDLI File Folder"""      """CDLI File Folder"""
           
       security=ClassSecurityInfo()
     meta_type="CDLI Folder"      meta_type="CDLI Folder"
     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
       
       tmpStore2={}
       def setTemp(self,name,value):
           """set tmp"""
   
           setattr(self,name,value)
                                           
           
     def delete(self,ids):      def delete(self,ids):
         """delete this file, i.e. move into a trash folder"""          """delete this file, i.e. move into a trash folder"""
Line 976  class CDLIFileFolder(versionedFileFolder Line 1525  class CDLIFileFolder(versionedFileFolder
           
     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
                     
                   
     def uploadATF(self,upload,basketId=0,RESPONSE=None):  
         """upload an atf file"""  
         #TODO: add comments  
         #TODO: finish uploadATF  
         basketId=str(basketId)  
           
           
           
         dir=mkdtemp()  
         changed=[]  
         errors=[]  
         newPs=[]  
         psNotInCatalog=[]  
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)  
           
         if basketId == '0':  
             basketObj=self.basketContainer.getActiveBasket()  
             if basketObj:  
                 basketId=basketObj.getId()  
                   
         if basketId == '0':  
             basketNameFromId=""  
             basketLen=0  
         else:  
             basketNameFromId=getattr(self.basketContainer,basketId).title  
             basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems()  
               
               
         for fn in os.listdir(dir):  
               
             if self.checkCatalog(fn):  
                 psNotInCatalog.append(fn)  
                   
                   
             founds=self.CDLICatalog.search({'title':fn})      
         
             if len(founds)==0:  
                 newPs.append(fn)  
                   
             for found in founds:  
                 obj=found.getObject()  
          
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     errors.append(obj)  
                 else:  
                     data=file(os.path.join(dir,fn)).read()  
                     diffs=obj.diff(data)  
                     if diffs[0]>0:  
                         changed.append((obj,diffs))  
                         #hochladen  
           
         self.REQUEST.SESSION['changed']=[x[0].getId() for x in changed]  
         self.REQUEST.SESSION['errors']=[x.getId() for x in errors]  
         self.REQUEST.SESSION['newPs']=newPs  
         self.REQUEST.SESSION['tmpdir']=dir  
         
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)  
         return pt(changed=changed,errors=errors,dir=dir,newPs=newPs,basketLen=basketLen,numberOfFiles=numberOfFiles,  
                    basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId)  
                       
     def uploadATFfinally(self,procedure,comment="",basketname='',unlock=None,RESPONSE=None):  
         """upload the files"""  
           
         if procedure=="uploadchanged":  
         
             uploadFns=self.REQUEST.SESSION.get('changed',[])+self.REQUEST.SESSION.get('newPs',[])  
           
         elif procedure=="uploadAll":  
             uploadFns=[]  
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                 if not x in self.REQUEST.SESSION['errors']:  
                     uploadFns.append(x)  
         elif procedure=="noupload":  
                 if RESPONSE is not None:  
                         RESPONSE.redirect(self.aq_parent.absolute_url())  
             return ""  
                 else:  
                         return ""  
         else:  
             uploadFns=[]  
               
         for fn in uploadFns:  
             founds=self.CDLICatalog.search({'title':fn})  
             if len(founds)>0:  
                 self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
           
                 founds[0].getObject().manage_addCDLIFileObject('',comment,self.REQUEST.SESSION['author'],file=file(os.path.join(self.REQUEST.SESSION['tmpdir'],fn)))  
               
           
                   
         newPs=self.REQUEST.SESSION['newPs']  
         if len(newPs)>0:  
             tmpDir=self.REQUEST.SESSION['tmpdir']  
           
             self.cdli_main.importFiles(comment=comment,author=str(self.REQUEST['AUTHENTICATED_USER']) ,folderName=tmpDir, files=newPs)  
                                   
       def findObjectsFromListWithVersion(self,list):
           """find objects from a list with versions
           @param list: list of tuples  (cdliFile,version)
           """
                   
                   
         #unlock  
         if unlock:  
             unlockFns=[]  
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                     if not x in self.REQUEST.SESSION['errors']:  
                         unlockFns.append(x)  
                           
             for fn in unlockFns:          #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
                 founds=self.CDLICatalog.search({'title':fn})          #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                 if len(founds)>0:  
                     self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                                         
                     founds[0].getObject().lockedBy=""  
                                           
         if not (basketname ==''):          pt=getattr(self,'filelistVersioned.html')
             basketId=self.basketContainer.getBasketIdfromName(basketname)  
                           
             if not basketId: # create new basket          return pt(search=list)
                 ob=self.basketContainer.addBasket(basketname)  
                 basketId=ob.getId()  
             basket=getattr(self.basketContainer,str(basketId))  
             ids=os.listdir(self.REQUEST.SESSION['tmpdir'])  
             basket.addObjects(ids,deleteOld=True)      
                                   
         if RESPONSE is not None:  
             RESPONSE.redirect(self.aq_parent.absolute_url())  
                   
   
     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 1136  class CDLIFileFolder(versionedFileFolder Line 1583  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))
                                                                                 
         print "nothing"  
   
     #security.declareProtected('View','createAllFilesAsSingleFile')  
       security.declareProtected('Manage','createAllFilesAsSingleFile')
     def createAllFilesAsSingleFile(self,RESPONSE=None):      def createAllFilesAsSingleFile(self,RESPONSE=None):
         """download all files"""          """download all files"""
                   
Line 1217  class CDLIFileFolder(versionedFileFolder Line 1675  class CDLIFileFolder(versionedFileFolder
                         len(getattr(self,self.default_catalog)({'path':folder[0]}))                          len(getattr(self,self.default_catalog)({'path':folder[0]}))
                         ))                          ))
         return ret          return ret
           security.declareProtected('View','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 1227  class CDLIFileFolder(versionedFileFolder Line 1685  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):      
   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"
       
       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))
           print ret
           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())           
           
       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</p>"%(repr(thread),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]
   #                        print 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['errors']=[x.getId() for x in 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'],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'],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/Documents/workspace/cdli/atf", files=None,ext=None):
         """import files"""          """import files"""
           root=self.cdli_main
                   
         if not files:          if not files:
             files=os.listdir(folderName)              files=os.listdir(folderName)
Line 1236  class CDLIFileFolder(versionedFileFolder Line 1955  class CDLIFileFolder(versionedFileFolder
         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:
                           
                   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 1268  class CDLIFileFolder(versionedFileFolder Line 1989  class CDLIFileFolder(versionedFileFolder
                           
         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 1281  def manage_addCDLIFileFolder(self, id, t Line 2003  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.18  
changed lines
  Added in v.1.44

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