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

Diff for /cdli/cdli_files.py between versions 1.71 and 1.78

version 1.71, 2007/03/21 19:29:23 version 1.78, 2007/04/27 14:42:28
Line 26  import logging Line 26  import logging
 import transaction  import transaction
 import copy  import copy
 import codecs  import codecs
   import sys
   
   def generateXMLReturn(hash):
       """erzeugt das xml file als returnwert fuer uploadATFRPC"""
   
       ret="<return>"
       
       ret+="<errors>"
       for error in hash['errors']:
           ret+="""<error atf="%s">%s</error>"""%error
       
       ret+="</errors>"
       
       ret+="<changes>"
       for changed in hash['changed']:
           ret+="""<change atf="%s">%s</change>"""%changed
       ret+="</changes>"
       
       ret+="<newPs>"
       for new in hash['newPs']:
           ret+="""<new atf="%s"/>"""%new
       ret+="</newPs>"
       
       ret+="</return>"
       return ret
       
       
       
       
       
       
       
       
       
   
 def unique(s):  def unique(s):
     """Return a list of the elements in s, but without duplicates.      """Return a list of the elements in s, but without duplicates.
Line 196  class uploadATFfinallyThread(Thread): Line 230  class uploadATFfinallyThread(Thread):
         self.result+="<h2>Start processing</h2>"          self.result+="<h2>Start processing</h2>"
                   
         #shall I only upload the changed files?          #shall I only upload the changed files?
           logging.info("uploadATFfinally procedure: %s"%procedure)
         if procedure=="uploadchanged":          if procedure=="uploadchanged":
             changed=[x[0] for x in SESSION.get('changed',[])]              changed=[x[0] for x in SESSION.get('changed',[])]
             uploadFns=changed+SESSION.get('newPs',[])              uploadFns=changed+SESSION.get('newPs',[])
Line 341  class uploadATFThread(Thread): Line 376  class uploadATFThread(Thread):
         ctx = self.getContext(app,serverport=self.serverport)          ctx = self.getContext(app,serverport=self.serverport)
         logging.info("run intern")          logging.info("run intern")
         try:          try:
               logging.info("created: %s"%idTmp)
             ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))              ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
         except:          except:
             logging.error("thread upload: %s %s"%sys.exc_info()[0:2])              logging.error("thread upload: %s %s"%sys.exc_info()[0:2])
Line 355  class uploadATFThread(Thread): Line 391  class uploadATFThread(Thread):
                 
         conn.close()          conn.close()
                   
           return getattr(ctx.temp_folder,idTmp)
                   
     def getResult(self):      def getResult(self):
         """method for accessing result"""          """method for accessing result"""
Line 479  class CDLIBasketContainer(OrderedFolder) Line 516  class CDLIBasketContainer(OrderedFolder)
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type="CDLIBasketContainer"      meta_type="CDLIBasketContainer"
           
       def getPNumbersOfBasket(self,basketName):
           """get all pnumbers of a basket as a list, returns an empty list if basket not found
           @param basketName: name of the basket
           """
           ret=[]
           basketId=self.getBasketIdfromName(basketName)
           if not basketId:
               return []
           
           ob=getattr(self,basketId).getContent()
           
           ret=[x[0].split(".")[0] for x in ob]
           
           return ret
       
       security.declareProtected('manage','getBasketAsOneFile')       
       def getBasketAsOneFile(self,basketName,current="no"):
           """returns all files of the basket combined in one file
           @param basketName: Name of the basket
           @param current: (optional) if current is set to "yes" then the most current version of 
                           all files are downloaded and not the versions of the files as stored in the basket
           """
           ret=""
           basketId=self.getBasketIdfromName(basketName)
           if not basketId:
               return ""
           
           ob=getattr(self,basketId).getLastVersion()
           for object in ob.getContent():
               if current=="no": #version as they are in the basket
                               ret+=str(object[0].getData())+"\n"
               elif current=="yes":
                               #search current object
                               logging.info("crrent: %s"%object[1].getId().split(".")[0])
                               founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
                               if len(founds)>0:      
                                   ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
           return ret
       
       security.declareProtected('manage','upDateBaskets') 
     def upDateBaskets(self):      def upDateBaskets(self):
         """update content in to objects"""          """update content in to objects"""
                   
Line 506  class CDLIBasketContainer(OrderedFolder) Line 583  class CDLIBasketContainer(OrderedFolder)
         trash.manage_pasteObjects(cut)          trash.manage_pasteObjects(cut)
                   
     security.declareProtected('manage','manageBaskets')             security.declareProtected('manage','manageBaskets')       
     def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):      def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):
         """manage baskets, delete or copy"""          """manage baskets, delete or copy"""
         if submit=="delete":          if submit=="delete":
             self.deleteBaskets(ids)              self.deleteBaskets(ids)
                   
                  elif submit=="join":
               flag,msg=self.joinBasket(joinBasket, ids)
               logging.info("joining %s %s"%(flag,msg))
               
           elif submit=="subtract":
               logging.info("BBBb %s %s"%(basket1,basket2))
               flag,msg=self.subtractBasket(subtractBasket, basket1,basket2)
               logging.info("subtract %s %s"%(flag,msg))
                           
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect(self.absolute_url())              RESPONSE.redirect(self.absolute_url())
Line 542  class CDLIBasketContainer(OrderedFolder) Line 626  class CDLIBasketContainer(OrderedFolder)
         return pt(basketId=basketId,basketName=basketName)          return pt(basketId=basketId,basketName=basketName)
         
   
     security.declareProtected('View','index_html')          security.declareProtected('manage','index_html')    
     def index_html(self):      def index_html(self):
         """stanadard ansicht"""          """stanadard ansicht"""
                   
Line 635  class CDLIBasketContainer(OrderedFolder) Line 719  class CDLIBasketContainer(OrderedFolder)
   
         return baskets          return baskets
   
     def joinBasket(self,newbasket,oldbaskets,delete=False):          
       def subtractBasket(self,newBasket,basket1,basket2):
           """subtract basket2 from basket1 
           (i.e. newbasket will contain alle elements of basket1 which are not in basket2), 
           if basket2 contains files which are not in basket1, then theses files fill be ignored
                  
           @param newbasket: name of the new basket
           @param basket1: basket where basket2 will be subtracted from
           @param basket2: see above
         
           """
           logging.info("CCCCC %s %s"%(basket1,basket2))
      
           try:
               newB=self.addBasket(newBasket)
           except:
               return False, "cannot create the new basket"
           
           
   
          
        
           bas2= getattr(self,basket2)            
           bas2content=bas2.getContent()
           bas2ids=[x[0] for x in bas2content]
           
          
               
           bas1= getattr(self,basket1)   
           bas1content=bas1.getContent()
           
           
           newBasketContent={}
           
           for id,version in bas1content:
               if not (id in bas2ids):
                   newBasketContent[id]=version
           
           username=self.getActualUserName()
           
           logging.info("sbc %s"%newBasketContent)
           newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
           
           return True, ""
       
               
       def joinBasket(self,newBasket,oldBaskets):
         """join two baskets          """join two baskets
         @param newbasket: name of the new basket          @param newbasket: name of the new basket
         @param oldbaskets: list of baskets to be joined          @param oldbaskets: list of baskets to be joined
         @param delete: (optional) delete the old baskets  
         """          """
           try:
               newB=self.addBasket(newBasket)
           except:
               return False, "cannot create the new basket"
           
           newBasketContent={}
           for ob in oldBaskets:
               x= getattr(self,ob,None)
               if x is None:
                   return False, "cannot find basket: %s"%ob
               
               ids=x.getContent() # hole den Inhalt
               
               for id,version in ids:
                   if newBasketContent.has_key(id): # p number gibt's schon
                       newBasketContent[id]=max(newBasketContent[id],version) # speichere die groessere Versionsnumber
                   else:
                       newBasketContent[id]=version
           username=self.getActualUserName()
           
           logging.info("nbc %s"%newBasketContent)
           newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
                                                 
           return True, ""
                                                 
     def getNewId(self):      def getNewId(self):
         """createIds"""          """createIds"""
Line 678  class CDLIBasketContainer(OrderedFolder) Line 830  class CDLIBasketContainer(OrderedFolder)
         """get name of the actualuser"""          """get name of the actualuser"""
         return str(self.REQUEST['AUTHENTICATED_USER'])          return str(self.REQUEST['AUTHENTICATED_USER'])
           
           security.declareProtected('manage','addBasket') 
     def addBasket(self,newBasketName):      def addBasket(self,newBasketName):
         """add a new basket"""          """add a new basket"""
                   
Line 734  class CDLIBasket(Folder,CatalogAware): Line 886  class CDLIBasket(Folder,CatalogAware):
     meta_type="CDLIBasket"      meta_type="CDLIBasket"
     default_catalog="CDLIBasketCatalog"      default_catalog="CDLIBasketCatalog"
           
       def searchInBasket(self,indexName,searchStr,regExp=False):
           """searchInBasket"""
   
           lst=self.searchInLineIndexDocs(indexName,searchStr,uniq=True,regExp=regExp)
           ret={}
           
           lv=self.getLastVersion()
   
   
           for obj in lv.content.getContent():
               id=obj[1].getId().split(".")[0]
               if id in lst:
           
                   ret[id]=self.showWordInFile(id,searchStr,lineList=self.getLinesFromIndex(indexName,searchStr,id,regExp=regExp),regExp=regExp,indexName=indexName)
           
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','searchResultsInBasket')).__of__(self)
           return pt(result=ret,indexName=indexName,regExp=regExp,word=searchStr)
           
            
    
           
       def searchInBasket_v1(self,searchStr):
           """search occurences of searchStr in files im basket"""
           ret=[]
           lv=self.getLastVersion()
           logging.info("searching")
           for obj in lv.content.getContent():
               txt=obj[0].getData()
               for x in txt.split("\n"):
                   logging.info("search %s"%x)
                   if re.match(searchStr,x):
                       ret.append(x)
           
           return "\n".join(ret)
                   
   
     def getFile(self,obj):      def getFile(self,obj):
         return obj[1]          return obj[1]
Line 786  class CDLIBasket(Folder,CatalogAware): Line 974  class CDLIBasket(Folder,CatalogAware):
         self.shortDescription=shortDescription          self.shortDescription=shortDescription
         self.comment=comment          self.comment=comment
     
       def getActualUserName(self):
           """get name of the actualuser"""
          
           return str(self.REQUEST['AUTHENTICATED_USER'])
         
                         
     def getLastVersion(self):      def getLastVersion(self):
Line 850  class CDLIBasket(Folder,CatalogAware): Line 1042  class CDLIBasket(Folder,CatalogAware):
                   
         return obj          return obj
           
       def addObjectsWithVersion(self,ids,deleteOld=None,username=None,catalog=None):
           """generate a new version of the basket with objects added, 
           hier wird jedoch nicht die letzte Version jedes Files hinzugefuegt, s
           ondern ids is ein Tupel mit der Id (d.h. der p-number) und der Versionsnummer.
           """
           logging.info("add to basket (%s)"%(self.getId()))
           lastVersion=self.getLastVersion()
           
           if not catalog:
               catalog=self.CDLICatalog
               
           if lastVersion is None:
               oldContent=[]
           else:
               oldContent=lastVersion.content.getContent()
   
           if deleteOld:
               oldContent=[]
   
           newContent=[]
           added=0
          
           for id,version in ids.iteritems():
               logging.info("adding %s %s"%(id,version))
               id=id.split(".")[0] # title nur die pnumber ohne atf
              
               try:
                   founds=catalog.search({'title':id})
               except:
                   founds=[]
               logging.info(" found %s "%(founds))
               for found in founds:
                   if found.getObject() not in oldContent:
                    
                       #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
                       newContent.append((found.getObject().getVersions()[version-1][1],found.getObject()))
                       added+=1
   
           content=oldContent+newContent
           if not username:
               logging.error("XXXXXXXXXXX %s"%repr(self))
               user=self.getActualUserName()
           else:
               user = username
               
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
           logging.info("add to basket (%s) done"%(self.getId()))
           return added
       
       
     def addObjects(self,ids,deleteOld=None,username=None):      def addObjects(self,ids,deleteOld=None,username=None):
         """generate a new version of the basket with objects added"""          """generate a new version of the basket with objects added"""
         logging.info("add to basket (%s)"%(self.getId()))          logging.info("add to basket (%s)"%(self.getId()))
Line 889  class CDLIBasket(Folder,CatalogAware): Line 1131  class CDLIBasket(Folder,CatalogAware):
           
           
                                   
       def getContent(self):
           """print content"""
           ret=[]
           
           lv=self.getLastVersion()
           for obj in lv.content.getContent():
               logging.info("XXXXXXXXXX %s"%repr(obj))
               ret.append((obj[1].getId(),obj[0].versionNumber))
               
           return ret
           
     def getContentIds(self):      def getContentIds(self):
         """print basket content"""          """print basket content"""
Line 976  class CDLIBasketVersion(Implicit,Persist Line 1228  class CDLIBasketVersion(Implicit,Persist
                 return True                  return True
         return False          return False
           
     security.declareProtected('View','downloadObjectsAsOneFile')      def downloadListOfPnumbers(self):
           """download pnumbers of the basket as list"""
           
           basket_name=self.aq_parent.title
           
           ids=self.getContent() # get the list of objects
           logging.error(ids)
           ret="\n".join([x[1].getId().split(".")[0] for x in ids])
           
           self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.txt" """%basket_name)
           self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
           length=len(ret)
           self.REQUEST.RESPONSE.setHeader("Content-Length",length)
           self.REQUEST.RESPONSE.write(ret)    
           
       security.declareProtected('manage','downloadObjectsAsOneFile')
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):      def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):
         """download all selected files in one file"""          """download all selected files in one file"""
                   
Line 1048  class CDLIBasketVersion(Implicit,Persist Line 1315  class CDLIBasketVersion(Implicit,Persist
                         ret+=str(object[0].getData())+"\n"                          ret+=str(object[0].getData())+"\n"
                     elif current=="yes":                      elif current=="yes":
                         #search current object                          #search current object
                         founds=self.CDLICatalog.search({'title':object[0].getId()})                          founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
                         if len(founds)>0:                                if len(founds)>0:      
                             ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"                              ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
                                                           
Line 1094  class CDLIBasketVersion(Implicit,Persist Line 1361  class CDLIBasketVersion(Implicit,Persist
     def __init__(self,id,user,comment="",basketContent=[]):      def __init__(self,id,user,comment="",basketContent=[]):
         """ init a basket version"""          """ init a basket version"""
         self.id=id          self.id=id
         self.coment=comment          self.comment=comment
         self._setObject('content',BasketContent(basketContent))          self._setObject('content',BasketContent(basketContent))
         #self.basketContent=basketContent[0:]a          #self.basketContent=basketContent[0:]a
         self.user=user          self.user=user
Line 1108  class CDLIBasketVersion(Implicit,Persist Line 1375  class CDLIBasketVersion(Implicit,Persist
         """get Comment"""          """get Comment"""
         return self.comment          return self.comment
     
     security.declareProtected('View','index_html')      security.declareProtected('manage','index_html')
     def index_html(self):      def index_html(self):
             """view the basket"""              """view the basket"""
   
Line 1163  class CDLIFileObject(CatalogAware,extVer Line 1430  class CDLIFileObject(CatalogAware,extVer
     
     security.declarePublic('makeThisVersionCurrent')      security.declarePublic('makeThisVersionCurrent')
           
       security.declareProtected('manage','index_html')
     def PrincipiaSearchSource(self):      def PrincipiaSearchSource(self):
            """Return cataloguable key for ourselves."""             """Return cataloguable key for ourselves."""
            return str(self)             return str(self)
Line 1271  def manage_addCDLIFileObject(self,id,vC= Line 1539  def manage_addCDLIFileObject(self,id,vC=
 class CDLIFile(extVersionedFile,CatalogAware):  class CDLIFile(extVersionedFile,CatalogAware):
     """CDLI file"""      """CDLI file"""
           
       security=ClassSecurityInfo()
     meta_type="CDLI file"      meta_type="CDLI file"
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
           security.declareProtected('manage','index_html')
     #security.declarePublic('history')      #security.declarePublic('history')
     def getLastVersionData(self):      def getLastVersionData(self):
         """get last version data"""          """get last version data"""
Line 1459  def splitatf(fh,dir=None,ext=None): Line 1728  def splitatf(fh,dir=None,ext=None):
     nf=None      nf=None
     i=0      i=0
   
     for lineTmp in fh.readlines():      if (type(fh) is StringType) or (type(fh) is UnicodeType):
           iter=fh.split("\n")
       else:
           iter=fh.readlines()
           
       for lineTmp in iter:
         lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..          lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..
         for line in lineTmp.split("\r"):          for line in lineTmp.split("\r"):
             #logging.log("Deal with: %s"%line)              #logging.log("Deal with: %s"%line)
Line 1496  def splitatf(fh,dir=None,ext=None): Line 1770  def splitatf(fh,dir=None,ext=None):
         nf.close()          nf.close()
     except:      except:
         pass          pass
       
       if not((type(fh) is StringType) or (type(fh) is UnicodeType)):
     fh.close()      fh.close()
     return ret,len(os.listdir(dir))      return ret,len(os.listdir(dir))
   
Line 1551  class CDLIFileFolder(extVersionedFileFol Line 1827  class CDLIFileFolder(extVersionedFileFol
         """get the content of the file fn"""          """get the content of the file fn"""
         founds=self.CDLICatalog.search({'title':fn})          founds=self.CDLICatalog.search({'title':fn})
         if not founds:          if not founds:
             return []              return "" 
         else:          else:
             obj=founds[0].getObject().getLastVersion()              obj=founds[0].getObject().getLastVersion()
   
Line 1718  class CDLIFileFolder(extVersionedFileFol Line 1994  class CDLIFileFolder(extVersionedFileFol
         return ret          return ret
           
                           
     security.declareProtected('View','index_html')      security.declareProtected('manage','index_html')
     def index_html(self):      def index_html(self):
         """main"""          """main"""
         ext=self.ZopeFind(self,obj_ids=["index.html"])          ext=self.ZopeFind(self,obj_ids=["index.html"])
Line 1767  class CDLIRoot(Folder): Line 2043  class CDLIRoot(Folder):
     meta_type="CDLIRoot"      meta_type="CDLIRoot"
     downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible      downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible
           
       def deleteFiles(self,ids):
           """delete files (resp. move into .trash folder)"""
           # find or generete trash folder
           
           found=self.ZopeFind(self,obj_ids=['.trash'])
           
           if len(found)<1:
               manage_addCDLIFileFolder(self, '.trash',title="Trash")
               trash=self._getOb('.trash')
           else:
               logging.info(found)
               trash=found[0][1]
           
           
           for id in ids:
               founds=self.CDLICatalog.search({'title':id.split(".")[0]})
               if founds:
                   logging.info(founds)
                   folder=founds[0].getObject().aq_parent #get the parent folder of the object
                   logging.info(folder)
                   cut=folder.manage_cutObjects([founds[0].getId]) #cut it out
                   trash.manage_pasteObjects(cut)  #paste it in the trash
   
   
     def findWordRegExp(self,indexName,searchTerm):      def findWordRegExp(self,indexName,searchTerm):
         """find all words in index which match regexp in SearchTerm          """find all words in index which match regexp in SearchTerm
         @param indexName: name of the index to be searched in          @param indexName: name of the index to be searched in
Line 1789  class CDLIRoot(Folder): Line 2089  class CDLIRoot(Folder):
         words=self.findWordRegExp(indexName,searchTerm) # suche nach allen Treffern          words=self.findWordRegExp(indexName,searchTerm) # suche nach allen Treffern
         logging.info("wd:%s"%words)          logging.info("wd:%s"%words)
         for word in words:          for word in words:
   
             ret+=self.searchInLineIndexDocs(indexName,word)              ret+=self.searchInLineIndexDocs(indexName,word)
                   
         return unique(ret)  
           x= unique(ret)
       logging.info("words_done")
           return x
                   
     def showInLineIndex(self):      def showInLineIndex(self):
         """get the index for debug purposes"""          """get the index for debug purposes"""
Line 1896  class CDLIRoot(Folder): Line 2200  class CDLIRoot(Folder):
         transaction.get().commit()          transaction.get().commit()
                   
   
     def showFile(self,fileId):      def showFile(self,fileId,wholePage=False):
         """show a file          """show a file
         @param fileId: P-Number of the document to be displayed          @param fileId: P-Number of the document to be displayed
         """          """
Line 1904  class CDLIRoot(Folder): Line 2208  class CDLIRoot(Folder):
         if not f:          if not f:
             return ""              return ""
                   
           if wholePage:
               logging.info("whole")
               return f[0].getObject().getLastVersion().view()
           else:
         return f[0].getObject().getLastVersionFormattedData()          return f[0].getObject().getLastVersionFormattedData()
           
   
Line 1911  class CDLIRoot(Folder): Line 2219  class CDLIRoot(Folder):
         """get lines with word  fromFileId"""          """get lines with word  fromFileId"""
                   
         file=self.showFile(fileId)          file=self.showFile(fileId)
       logging.info("regEXP %s"%regExp)
         ret=[]          ret=[]
         if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen          if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen
             wordlist=self.findWordRegExp(indexName,word)              wordlist=self.findWordRegExp(indexName,word)
Line 1921  class CDLIRoot(Folder): Line 2229  class CDLIRoot(Folder):
         for line in file.split("\n"):          for line in file.split("\n"):
             found=False              found=False
             for word in wordlist:              for word in wordlist:
           try: # just a hack because of possible unicode errors in line
                 if line.find(word)>-1:                  if line.find(word)>-1:
                         if lineList: #liste of moeglichen Zeilennummern                          if lineList: #liste of moeglichen Zeilennummern
                                 num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile                                  num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
Line 1932  class CDLIRoot(Folder): Line 2241  class CDLIRoot(Folder):
                                 ret.append(line)                                  ret.append(line)
                                                   
                         break;                          break;
           except:
               pass
         return ret          return ret
   
     def tagWordInFile(self,fileId,word,lineList=None,regExp=True,indexName=""):      def tagWordInFile(self,fileId,word,lineList=None,regExp=True,indexName=""):
Line 2056  class CDLIRoot(Folder): Line 2367  class CDLIRoot(Folder):
         return ret          return ret
                                                                                 
                                                                                         
       def uploadATFRPC(self,data,username):
           """upload an atffile via xml-rpc"""
           uploader=uploadATFThread()
           
           #generate an random id for the upload object
           from random import randint
           if (not self.REQUEST.SESSION.get('idTmp',None)):
   
               idTmp=str(randint(0,1000000000))
               self.REQUEST.SESSION['idTmp']=idTmp
           else:
               idTmp=self.REQUEST.SESSION.get('idTmp',None)
               
           
           uploader.set(data,0,username,idTmp)
           
           stObj=uploader.run()
           
           processor=uploadATFfinallyThread()
           
           basketname=stObj.returnValue['basketNameFromFile']
           
           processor.set("uploadchanged",basketname=basketname,SESSION=stObj.returnValue,username=username,serverport=self.REQUEST['SERVER_PORT'])
           
           processor.run()
           
           
           return generateXMLReturn(stObj.returnValue)
           
     def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):      def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
         """upload an atf file / basket file"""          """upload an atf file / basket file"""
Removed from v.1.71  
changed lines
  Added in v.1.78

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