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

Diff for /cdli/cdli_files.py between versions 1.4 and 1.19

version 1.4, 2006/02/02 19:19:24 version 1.19, 2006/06/13 18:34:10
Line 9  import urlparse Line 9  import urlparse
 from OFS.OrderedFolder import OrderedFolder  from OFS.OrderedFolder import OrderedFolder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 import time  import time
   from OFS.Folder import manage_addFolder
   import re
   from AccessControl import ClassSecurityInfo
   from Acquisition import Implicit
   from threading import Thread
   from ZPublisher.HTTPRequest import HTTPRequest
   from ZPublisher.HTTPResponse import HTTPResponse
   from ZPublisher.BaseRequest import RequestContainer
   
   global tmpVar
   
   class uploadATFfinallyThread(Thread):
    
       def __init__(self):
           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 values"""
           self.procedure=procedure
           self.comment=comment
           self.basketname=basketname
           self.unlock=unlock
           self.SESSION=SESSION
           self.username=username
           self.serverport=serverport
           
       def __call__(self):
           """wait"""
           self.run()
           return True
       
       def getContext(self, app,serverport="8080"):
           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=""
           from Zope import DB
           conn = DB.open()
           root = conn.root()
           app  = root['Application']
           ctx = self.getContext(app,serverport=self.serverport)
   
           self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
           get_transaction().commit()
           conn.close()
           self.end=True
           return True
       
       def getResult(self):
           return self.result
        
       def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
           """upload the files"""
           ctx2=ctx.cdliRoot
      
           self.result+="<h2>Start processing</h2>"
           if procedure=="uploadchanged":
         
               uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])
           
           elif procedure=="uploadAll":
               uploadFns=[]
               for x in os.listdir(SESSION['tmpdir']):
                   if not x in SESSION['errors']:
                       uploadFns.append(x)
           elif procedure=="noupload":
                           return True
           else:
               uploadFns=[]
               
           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)))
               
           
                   
           newPs=SESSION['newPs']
           if len(newPs)>0:
               tmpDir=SESSION['tmpdir']
               self.result+="<p>Adding files</p>"
               ctx2.cdli_main.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
                   
           
           
           #unlock
           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 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):
       
       def __init__(self):
           self.continueVar=True
           self.returnValue=None
           
           Thread.__init__(self)
           
           
       def set(self,upload,basketId,username,serverport="8080"):
           self.result=""
           self.upload=upload
           self.basketId=basketId
           self.username=username
           self.serverport=serverport
           
       def __call__(self):
           """wait"""
           self.run()
           return True
       
       def getContext(self, app,serverport="8080"):
           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=""
           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)
           
           while self.continueVar:
               pass
           get_transaction().abort()
           conn.close()
   
           
       def getResult(self):
           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 am loading your file...</h2>"
           basketId=str(basketId)
           
           
           ctx2=ctx.cdliRoot
           dir=mkdtemp()
           changed=[]
           errors=[]
           newPs=[]
           psNotInCatalog=[]
           basketNameFromFile, numberOfFiles=splitatf(upload,dir)
           
           if basketId == '0':
               basketObj=ctx2.basketContainer.getActiveBasket()
               if basketObj:
                   basketId=basketObj.getId()
                   
           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 checking now the files</p>"
                                          
           for fn in os.listdir(dir):
               
               self.result+="<p>check:%s</p>"%fn
               
               if ctx2.cdli_main.checkCatalog(fn):
                   psNotInCatalog.append(fn)
                   
                   
               founds=ctx2.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.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
           
         
           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):
Line 20  class Basket_old(Folder): Line 273  class Basket_old(Folder):
   
     def getObjUrl(self,objId):      def getObjUrl(self,objId):
         """getUrl"""          """getUrl"""
         founds=self.CDLICatalog.search({'path':objId})          founds=self.CDLICatalog.search({'title':objId})
         if len(founds)>0:          if len(founds)>0:
              return founds[0].getObject().absolute_url()               return founds[0].getObject().absolute_url()
                     
         else: #assume version number          else: #assume version number
             splitted=objId.split("_")              splitted=objId.split("_")
             founds=self.CDLICatalog.search({'path':splitted[1]})                      founds=self.CDLICatalog.search({'title':splitted[1]})        
             return founds[0].getObject().absolute_url()+'/'+objId              return founds[0].getObject().absolute_url()+'/'+objId
                   
     def storeAllLink(self,results):      def storeAllLink(self,results):
Line 142  class BasketObject_old(Folder): Line 395  class BasketObject_old(Folder):
         """addObjects"""          """addObjects"""
                   
         for id in ids:          for id in ids:
             founds=self.CDLICatalog.search({'path':id})              founds=self.CDLICatalog.search({'title':id})
             for found in founds:              for found in founds:
                 if found.getObject() not in self.contents:                  if found.getObject() not in self.contents:
                     tm=self.contents[0:]                      tm=self.contents[0:]
Line 208  class BasketObject_old(Folder): Line 461  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" 
                   
         print procedure      
         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']):
Line 247  class CDLIBasketContainer(OrderedFolder) Line 500  class CDLIBasketContainer(OrderedFolder)
     """contains the baskets"""      """contains the baskets"""
           
   
           security=ClassSecurityInfo()
     meta_type="CDLIBasketContainer"      meta_type="CDLIBasketContainer"
           
       def deleteBaskets(self,ids=None):
           """delete baskets, i.e. move them into trash folder"""
           
           
           found=self.ZopeFind(self,obj_ids=['trash'])
           
           if len(found)<1:
               manage_addFolder(self, 'trash')
               trash=self._getOb('trash')
           else:
               trash=found[0][1]
           
           if type(ids) is not ListType:
               ids=[ids]
           cut=self.manage_cutObjects(ids)
           trash.manage_pasteObjects(cut)
           
       def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):
           """manage baskets, delete or copy"""
           if submit=="delete":
               self.deleteBaskets(ids)
           
          
               
           if RESPONSE:
               RESPONSE.redirect(self.absolute_url())
       def getBasketIdfromName(self,basketname):
           """get id from name"""
   
           for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):
               if basket[1].title==basketname:
                   return basket[0]
           else:
               None
       
       security.declareProtected('manage','uploadBasket_html')        
           
     def uploadBasket_html(self,basketId='0'):      def uploadBasket_html(self,basketId='0'):
         """upload an atf file, html form"""          """upload an atf file, html form"""
           
   
         basketId=str(basketId)          basketId=str(basketId)
         if not basketId=='0':          if not basketId=='0':
             basketName=getattr(self.basketContainer,basketId).title              basketName=getattr(self.basketContainer,basketId).title
Line 266  class CDLIBasketContainer(OrderedFolder) Line 557  class CDLIBasketContainer(OrderedFolder)
                   
     def index_html(self):      def index_html(self):
         """stanadard ansicht"""          """stanadard ansicht"""
           
   
   
         ext=self.ZopeFind(self,obj_ids=["index.html"])          ext=self.ZopeFind(self,obj_ids=["index.html"])
         if ext:          if ext:
             return ext[0][1]()              return ext[0][1]()
Line 353  class CDLIBasketContainer(OrderedFolder) Line 647  class CDLIBasketContainer(OrderedFolder)
         self.last=last          self.last=last
         return last          return last
           
     def setActiveBasket(self,basketId):      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="/")
                   
           if REQUEST:
               REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+REQUEST['QUERY_STRING'])
               
     def getActiveBasket(self):      def getActiveBasket(self):
         """get active basket from cookie"""          """get active basket from cookie"""
                   
         id= self.REQUEST.cookies.get('CDLIActiveBasket',None)          id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
         obj=getattr(self,id,None)          if id:
               obj=getattr(self,str(id),None)
           else:
               obj=None
         return obj          return obj
       
     def getActualUserName(self):      def getActualUserName(self):
         """get name of the actualuser"""          """get name of the actualuser"""
         return str(self.REQUEST['AUTHENTICATED_USER'])          return str(self.REQUEST['AUTHENTICATED_USER'])
Line 374  class CDLIBasketContainer(OrderedFolder) Line 675  class CDLIBasketContainer(OrderedFolder)
         ob=manage_addCDLIBasket(self,newBasketName)          ob=manage_addCDLIBasket(self,newBasketName)
         return ob          return ob
           
     def storeInBasket(self,ids,submit,newBasketName=None,RESPONSE=None,REQUEST=None):      def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):
         """store it"""          """store it"""
           if not ids:
               ids=self.REQUEST.SESSION['fileIds']
                   
         if type(ids) is not ListType:          if type(ids) is not ListType:
             ids=[ids]              ids=[ids]
                   
         if submit=="store in new basket":          if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
             basketRet=self.addBasket(newBasketName)              basketRet=self.addBasket(newBasketName)
             self.setActiveBasket(basketRet.getId())              self.setActiveBasket(basketRet.getId())
             basket=getattr(self,basketRet.getId())              basket=getattr(self,basketRet.getId())
         elif submit=="store in active basket":          elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):
             basket=self.getActiveBasket()              basket=self.getActiveBasket()
                     
         basket.addObjects(ids)          added=basket.addObjects(ids)
         back=self.REQUEST['HTTP_REFERER']          back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)
           
           
           if fromFileList:
   
               return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)
   
         if RESPONSE:          if RESPONSE:
               
             RESPONSE.redirect(back)              RESPONSE.redirect(back)
                           
           return True
                   
 def manage_addCDLIBasketContainerForm(self):  def manage_addCDLIBasketContainerForm(self):
     """add the CDLIBasketContainer form"""      """add the CDLIBasketContainer form"""
Line 408  def manage_addCDLIBasketContainer(self,i Line 718  def manage_addCDLIBasketContainer(self,i
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
 class CDLIBasket(Folder):  class CDLIBasket(Folder,CatalogAware):
     """basket"""      """basket"""
           
     meta_type="CDLIBasket"      meta_type="CDLIBasket"
       default_catalog="CDLIBasketCatalog"
           
     def getFile(self,obj):      def getFile(self,obj):
         return obj[1]          return obj[1]
Line 419  class CDLIBasket(Folder): Line 730  class CDLIBasket(Folder):
     def getFileLastVersion(self,obj):      def getFileLastVersion(self,obj):
         return obj[0]          return obj[0]
           
       def getFileNamesInLastVersion(self):
           """get content of the last version as list"""
           
           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()})
           if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
               return False, -1
           
         if actualNo==storedNo:          if actualNo==storedNo:
             return True              return True , 0
         else:          else:
             return False              return False, actualNo
                   
     def history(self):      def history(self):
         """history"""            """history"""  
Line 469  class CDLIBasket(Folder): Line 790  class CDLIBasket(Folder):
   
         
           
     def addObjects(self,ids,deleteOld=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"""
                 
         lastVersion=self.getLastVersion()          lastVersion=self.getLastVersion()
Line 483  class CDLIBasket(Folder): Line 804  class CDLIBasket(Folder):
             oldContent=[]              oldContent=[]
   
         newContent=[]          newContent=[]
                added=0
         for id in ids:          for id in ids:
             founds=self.CDLICatalog.search({'title':id})              founds=self.CDLICatalog.search({'title':id})
             print id,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
                     newContent.append((found.getObject().getLastVersion(),found.getObject()))                      newContent.append((found.getObject().getLastVersion(),found.getObject()))
                           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
           
           def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
     def deleteObjects(self,ids,RESPONSE=None):  
         """delete objects"""          """delete objects"""
         #TODO: implement delete Objects          
           if type(ids) is not ListType:
               ids=[ids]
          
           lastVersion=self.getLastVersion() 
           oldContent=lastVersion.basketContent[0:]
           newContent=[]
           for obj in oldContent:
               if obj[1].getId() not in ids:
                   newContent.append(obj)
           
                   
           user=self.getActualUserName()
           
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
           
           if RESPONSE:
               obj=self._getOb(ob.getId())
               RESPONSE.redirect(obj.absolute_url())
                   
 def manage_addCDLIBasketForm(self):  def manage_addCDLIBasketForm(self):
     """add the CDLIBasketContainer form"""      """add the CDLIBasketContainer form"""
Line 629  class CDLIBasketVersion(SimpleItem): Line 970  class CDLIBasketVersion(SimpleItem):
         objId=result[1].getTitle()          objId=result[1].getTitle()
         founds=self.CDLICatalog.search({'title':objId})          founds=self.CDLICatalog.search({'title':objId})
         if len(founds)>0:          if len(founds)>0:
              return founds[0].getObject().absolute_url()               return founds[0].getObject().getLastVersion().absolute_url()
                     
         else: #assume version number          else: #assume version number
             splitted=objId.split("_")              splitted=objId.split("_")
             founds=self.CDLICatalog.search({'path':splitted[1]})                      founds=self.CDLICatalog.search({'title':splitted[1]})        
             return founds[0].getObject().absolute_url()+'/'+objId              return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId
         
 def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):  def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
     """add a version"""      """add a version"""
Line 661  class CDLIFileObject(versionedFileObject Line 1002  class CDLIFileObject(versionedFileObject
           
     meta_type="CDLI File Object"      meta_type="CDLI File Object"
           
       security=ClassSecurityInfo()
                   
     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('getDesignation')
       def getDesignation(self):
           """get the designation out of the file"""
           try:
                   txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.data[0:])
           except:
                   txt=self.data[0:]
                   
                   return "ERROR"
           try:
               return txt.group(2)
           except:
               return "ERROR"
           
 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='',
Line 707  class CDLIFile(versionedFile,CatalogAwar Line 1063  class CDLIFile(versionedFile,CatalogAwar
     meta_type="CDLI file"      meta_type="CDLI file"
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
   
       
    
       def isContainedInBaskets(self,context=None):
           """check is this file is part of any basket
           @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
                           has to exist.
           """
   
           if not context:
               context=self
           
           ret=[]
           for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()}):
               #if the basket x is deleted it seemes to be that x is sometimes still in the Catalog, why?
               try:
                   ret.append(x.getObject())
               except:
                   pass
           return ret
           #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]
           
           
       def addCDLIFileObjectForm(self):
           """add a new version"""
           
           if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
               return "please login first"
           if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
               out=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject',version=self.getVersion()).__of__(self)
               return out()
           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='', RESPONSE=None):
         """add"""          """add"""
         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden          try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
Line 714  class CDLIFile(versionedFile,CatalogAwar Line 1103  class CDLIFile(versionedFile,CatalogAwar
         except:          except:
             pass              pass
                   
         author=self.REQUEST['author']  
                   
         if changeName=="yes":          if changeName=="yes":
             filename=file.filename              filename=file.filename
Line 755  class CDLIFile(versionedFile,CatalogAwar Line 1143  class CDLIFile(versionedFile,CatalogAwar
                 return pt()                  return pt()
   
             else:              else:
                 RESPONSE.redirect(self.REQUEST['URL2'])                  RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
   
         else:          else:
             return self.ZopeFind(self,obj_ids=[id])[0][1]              return self.ZopeFind(self,obj_ids=[id])[0][1]
Line 785  def splitatf(fh,dir=None): Line 1173  def splitatf(fh,dir=None):
         #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 ','')
               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 800  def splitatf(fh,dir=None): Line 1189  def splitatf(fh,dir=None):
                   
     nf.close()      nf.close()
     fh.close()      fh.close()
     return ret.split('_')[0],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'
           
       def setTemp(self,name,value):
           """set tmp"""
   
           setattr(self,name,value)
                                           
                                          
       def delete(self,ids):
           """delete this file, i.e. move into a trash folder"""
                
           found=self.ZopeFind(self,obj_ids=['.trash'])
           
           if len(found)<1:
               manage_addCDLIFileFolder(self, '.trash',title="Trash")
               trash=self._getOb('.trash')
           else:
               trash=found[0][1]
           
           if type(ids) is not ListType:
               ids=[ids]
           cut=self.manage_cutObjects(ids)
           trash.manage_pasteObjects(cut)
           
     def getVersionNumbersFromIds(self,ids):      def getVersionNumbersFromIds(self,ids):
         """get the numbers of the current versions of documents described by their ids"""          """get the numbers of the current versions of documents described by their ids"""
                   
         ret=[]          ret=[]
         searchStr=" OR ".join(ids)          searchStr=" OR ".join(ids)
                   
         founds=self.CDLICatalog.search({'path':searchStr})          founds=self.CDLICatalog.search({'title':searchStr})
                   
         for found in founds:          for found in founds:
             lastVersion=found.getObject().getLastVersion()              lastVersion=found.getObject().getLastVersion()
Line 824  class CDLIFileFolder(versionedFileFolder Line 1237  class CDLIFileFolder(versionedFileFolder
                   
         return ret          return ret
           
       def checkCatalog(self,fn):
           """check if fn is in the catalog"""
           #TODO add checkCatalog
     
     def uploadATF(self,upload,basketId=0,RESPONSE=None):      def refreshTxt(self,txt=""):
         """upload an atf file"""          """txt fuer refresh"""
         #TODO: add comments  
         #TODO: finish uploadATF  
         basketId=str(basketId)  
                   
           return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,self.threadName)
                   
                   
         dir=mkdtemp()      def getResult(self):
         changed=[]         """result of thread"""
         errors=[]         try:
         newPs=[]          return self._v_uploadATF.getResult()
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)         except:
         if basketId == '0':          return "One moment, please"
             basketNameFromId=""      
             basketLen=0      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
   
               self._v_uploadATF=uploadATFThread()
              
               #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:          else:
             basketNameFromId=getattr(self.basketContainer,basketId).title  
             basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems()  
                           
               if not self._v_uploadATF.returnValue:
                           
         for fn in os.listdir(dir):  
             founds=self.CDLICatalog.search({'title':fn})      
               
             if len(founds)==0:                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                 newPs.append(fn)                  if wait_template:
                           return wait_template[0][1]()
                                   
             for found in founds:                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                 obj=found.getObject()  
                   return pt(txt='/uploadATF')
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     errors.append(obj)  
                 else:                  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]                  tmp=self._v_uploadATF.returnValue
         self.REQUEST.SESSION['errors']=[x.getId() for x in errors]                  self._v_uploadATF.continueVar=False
         self.REQUEST.SESSION['newPs']=newPs                  
         self.REQUEST.SESSION['tmpdir']=dir                  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)          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,                  return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                    basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId)                    basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                                           
     def uploadATFfinally(self,procedure,comment="",basketId='0',unlock=None,RESPONSE=None):      def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
         """upload the files"""          """nowupload the files"""
                   
         if procedure=="uploadchanged":  
             uploadFns=self.REQUEST.SESSION['changed']+self.REQUEST.SESSION['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)  
         else:  
             uploadFns=[]  
                           
         for fn in uploadFns:          threadName=repeat
             founds=self.CDLICatalog.search({'path':fn})          if not threadName or threadName=="":
             if len(founds)>0:  
                 self.REQUEST['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                 founds[0].getObject().manage_addCDLIFileObject('',comment,self.REQUEST['author'],file=file(os.path.join(self.REQUEST.SESSION['tmpdir'],fn)))  
                           
                   
               self._v_uploadATF=uploadATFfinallyThread()
                                   
         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)              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()
                   
                   
         #unlock              self.threadName=self._v_uploadATF.getName()[0:]
         if unlock:              wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
             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:              if wait_template:
                 founds=self.CDLICatalog.search({'path':fn})                  return wait_template[0][1]()
                 if len(founds)>0:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                     self.REQUEST['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                                         
                     founds[0].getObject().lockedBy=""              return pt(txt='/uploadATFfinally')
               #_v_xmltrans.run()
           
           else:
               
               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'])
                   if wait_template:
                           return wait_template[0][1]()
                                           
         if not (basketId =='0'):                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
             basket=getattr(self.basketFolder,basketId)                  return pt(txt='/uploadATFfinally')
             ids=os.listdir(self.REQUEST.SESSION['tmpdir'])              else:
             basket.addObjects(ids,deleteOld=True)      
                                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect(self.aq_parent.absolute_url())              RESPONSE.redirect(self.aq_parent.absolute_url())
                   
   
     def findObjectsFromList(self,upload,RESPONSE):  
   
       def findObjectsFromList(self,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
         txt=upload.read()          txt=upload.read()
         txt=txt.replace(",","\n")          txt=txt.replace(",","\n")
         txt=txt.replace("\t","\n")          txt=txt.replace("\t","\n")
               txt=txt.replace("\r","\n")
         idsTmp=txt.split("\n")          idsTmp=txt.split("\n")
         ids=[]          ids=[]
         for id in idsTmp: # make sure that no empty lines          for id in idsTmp: # make sure that no empty lines
             idTmp=id.lstrip().rstrip()              idTmp=id.lstrip().rstrip()
             if len(idTmp)>0:              if len(idTmp)>0:
                       
                 ids.append(idTmp)                  ids.append(idTmp)
                       
         #self.REQUEST.SESSION['ids']=" OR ".join(ids)          #self.REQUEST.SESSION['ids']=" OR ".join(ids)
                   
         RESPONSE.redirect("filelist.html?path=%s"%" OR ".join(ids))              pt=getattr(self,'filelist.html')
               self.REQUEST.SESSION['searchList']=ids
               return pt(search=ids)
           
           if basketName:
               #TODO: get rid of one of these..
               
               pt=getattr(self,'filelist.html')
               return pt(basketName=basketName,numberOfObjects=numberOfObjects)
           
           if list is not None: # got already a list
               ret=[]
               for fileId in list:
                   if len(fileId.split("."))==1:
                           fileId=fileId+".atf"
   
                   ret+=self.CDLICatalog({'title':fileId})
               #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
               self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
               return ret
           
           if start:
               RESPONSE.redirect("filelist.html?start:int="+str(start))
                                          
   
   
       security.declareProtected('Manage','createAllFilesAsSingleFile')
     def createAllFilesAsSingleFile(self,RESPONSE=None):      def createAllFilesAsSingleFile(self,RESPONSE=None):
         """download all files"""          """download all files"""
                   
Line 964  class CDLIFileFolder(versionedFileFolder Line 1423  class CDLIFileFolder(versionedFileFolder
                                   
                 #os.write(tf,obj.getLastVersion().data)                  #os.write(tf,obj.getLastVersion().data)
                 if RESPONSE:                  if RESPONSE:
                     RESPONSE.write(obj.getLastVersion().data)                      RESPONSE.write(obj.getLastVersion().data[0:])
         #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 1017  class CDLIFileFolder(versionedFileFolder Line 1476  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):      def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):
         """import files"""          """import files"""
                   
         if not files:          if not files:
Line 1027  class CDLIFileFolder(versionedFileFolder Line 1486  class CDLIFileFolder(versionedFileFolder
             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(self,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(self,folder,folder)
                 fobj=getattr(self,folder)                  fobj=getattr(self,folder)
Line 1090  def manage_addCDLIFileFolder(self, id, t Line 1551  def manage_addCDLIFileFolder(self, id, t
     if REQUEST is not None:      if REQUEST is not None:
         return self.manage_main(self, REQUEST, update_menu=1)          return self.manage_main(self, REQUEST, update_menu=1)
   
   
Removed from v.1.4  
changed lines
  Added in v.1.19

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