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

Diff for /cdli/cdli_files.py between versions 1.67 and 1.72

version 1.67, 2007/03/19 18:34:01 version 1.72, 2007/03/22 19:56:22
Line 425  class uploadATFThread(Thread): Line 425  class uploadATFThread(Thread):
             #if not than add filename to the list of newfiles              #if not than add filename to the list of newfiles
                           
             data=file(os.path.join(dir,fn)).read()              data=file(os.path.join(dir,fn)).read()
             #status,msg=checkFile(fn,data,dir)              status,msg=checkFile(fn,data,dir)
             status=True              #status=True
             msg=""              
               
             if not status: # error              if not status: # error
                 errors.append((fn,msg))                  errors.append((fn,msg))
               
             else:              else:
                 if len(founds)==0:                  if len(founds)==0:
                     newPs.append(fn)                      newPs.append(fn)
Line 504  class CDLIBasketContainer(OrderedFolder) Line 506  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="",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("joinedBasket", ids)
               logging.info("joining %s %s"%(flag,msg))
               
           elif submit=="subtract":
               logging.info("BBBb %s %s"%(basket1,basket2))
               flag,msg=self.subtractBasket("subtractedBasket", basket1,basket2)
               logging.info("subtract %s %s"%(flag,msg))
                           
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect(self.absolute_url())              RESPONSE.redirect(self.absolute_url())
Line 634  class CDLIBasketContainer(OrderedFolder) Line 643  class CDLIBasketContainer(OrderedFolder)
         return baskets          return baskets
   
   
       def subtractBasket(self,newBasket,basket1,basket2):
           """subtract basket2 from basket1 
           (i.e. newbasket will contain alle elements of basket1 which are not in basket2), 
           if basket2 contains files which are not in basket1, then theses files fill be ignored
                  
           @param newbasket: name of the new basket
           @param basket1: basket where basket2 will be subtracted from
           @param basket2: see above
         
           """
           logging.info("CCCCC %s %s"%(basket1,basket2))
      
           try:
               newB=self.addBasket(newBasket)
           except:
               return False, "cannot create the new basket"
           
           
   
          
        
           bas2= getattr(self,basket2)            
           bas2content=bas2.getContent()
           bas2ids=[x[0] for x in bas2content]
           
          
               
           bas1= getattr(self,basket1)   
           bas1content=bas1.getContent()
           
           
           newBasketContent={}
           
           for id,version in bas1content:
               if not (id in bas2ids):
                   newBasketContent[id]=version
           
           username=self.getActualUserName()
           
           logging.info("sbc %s"%newBasketContent)
           newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
           
           return True, ""
       
               
       def joinBasket(self,newBasket,oldBaskets):
           """join two baskets
           @param newbasket: name of the new basket
           @param oldbaskets: list of baskets to be joined
           """
           try:
               newB=self.addBasket(newBasket)
           except:
               return False, "cannot create the new basket"
           
           newBasketContent={}
           for ob in oldBaskets:
               x= getattr(self,ob,None)
               if x is None:
                   return False, "cannot find basket: %s"%ob
               
               ids=x.getContent() # hole den Inhalt
               
               for id,version in ids:
                   if newBasketContent.has_key(id): # p number gibt's schon
                       newBasketContent[id]=max(newBasketContent[id],version) # speichere die groessere Versionsnumber
                   else:
                       newBasketContent[id]=version
           username=self.getActualUserName()
           
           logging.info("nbc %s"%newBasketContent)
           newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
           
           return True, ""
                                                 
     def getNewId(self):      def getNewId(self):
         """createIds"""          """createIds"""
Line 778  class CDLIBasket(Folder,CatalogAware): Line 861  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 842  class CDLIBasket(Folder,CatalogAware): Line 929  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 881  class CDLIBasket(Folder,CatalogAware): Line 1018  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 968  class CDLIBasketVersion(Implicit,Persist Line 1115  class CDLIBasketVersion(Implicit,Persist
                 return True                  return True
         return False          return False
           
       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('View','downloadObjectsAsOneFile')      security.declareProtected('View','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 1183  class CDLIFileObject(CatalogAware,extVer Line 1345  class CDLIFileObject(CatalogAware,extVer
     def getFormattedData(self):      def getFormattedData(self):
         """fromat text"""          """fromat text"""
         data=self.getData()          data=self.getData()
         return re.sub("\s\#lem"," #lem",data) #remove return vor #lem  #        return re.sub("\s\#lem"," #lem",data) #remove return vor #lem
           return re.sub("#lem","       #lem",data) #remove return vor #lem
                   
     def view(self):      def view(self):
         """view file"""          """view file"""
Line 1420  def manage_addCDLIFile(self,id,title,loc Line 1583  def manage_addCDLIFile(self,id,title,loc
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   def checkUTF8(data):
       """check utf 8"""
       try:
           data.encode('utf-8')
           return True
       except:
           return False
   
   
 def checkFile(filename,data,folder):  def checkFile(filename,data,folder):
Line 1431  def checkFile(filename,data,folder): Line 1601  def checkFile(filename,data,folder):
         return False,"P missing in the filename"          return False,"P missing in the filename"
     elif len(fn[0])!=7:      elif len(fn[0])!=7:
         return False,"P number has not the right length 6"          return False,"P number has not the right length 6"
     else:      elif not checkUTF8(data):
         fn=os.path.join(folder,filename)          return False,"not utf-8"
         stin,out=os.popen4("/usr/bin/atfcheck.plx %s"%fn)  
         value=out.read()  
         ret= out.close()  
   
         if value:  
        
             return False,"atf checker error: %s"%value  
         else:          else:
             return True,""              return True,""
           
       
 def splitatf(fh,dir=None,ext=None):  def splitatf(fh,dir=None,ext=None):
     """split it"""      """split it"""
     ret=None      ret=None
Line 1544  class CDLIFileFolder(extVersionedFileFol Line 1708  class CDLIFileFolder(extVersionedFileFol
             return []              return []
         else:          else:
             obj=founds[0].getObject().getLastVersion()              obj=founds[0].getObject().getLastVersion()
             logging.error(obj.getData())  
             return obj.getData()[0:]               return obj.getData()[0:] 
           
     def checkCatalog(self,fn):      def checkCatalog(self,fn):
Line 1672  class CDLIFileFolder(extVersionedFileFol Line 1836  class CDLIFileFolder(extVersionedFileFol
                 #os.write(tf,obj.getLastVersion().data)                  #os.write(tf,obj.getLastVersion().data)
                 if RESPONSE:                  if RESPONSE:
                     RESPONSE.write(obj.getLastVersion().getData()[0:])                      RESPONSE.write(obj.getLastVersion().getData()[0:])
                       RESPONSE.write("\n")
                 self.temp_folder.downloadCounter-=1                   self.temp_folder.downloadCounter-=1 
                 self._p_changed=1                  self._p_changed=1
         transaction.get().commit()          transaction.get().commit()
Line 1756  class CDLIRoot(Folder): Line 1921  class CDLIRoot(Folder):
     meta_type="CDLIRoot"      meta_type="CDLIRoot"
     downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible      downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible
           
     def findWordRegExp(self,searchTerm):      def 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 searchTerm: word to be searched"""
           
         ret=[]          ret=[]
         for x in self.lineIndex.iterkeys():          for x in self.lineIndexes[indexName].iterkeys():
             if re.match(searchTerm,x):              if re.match(searchTerm,x):
                 ret.append(x)                  ret.append(x)
         return ret          return ret
           
     def searchRegExpInLineIndexDocs(self,searchTerm):      def searchRegExpInLineIndexDocs(self,indexName,searchTerm):
         """search in inLineIndex with regexp"""          """search in inLineIndex with regexp
           @param indexName: name of the index to be searched in
           @param searchTerm: term to be searched
           """
         if not searchTerm:          if not searchTerm:
             return []              return []
         ret=[]          ret=[]
         words=self.findWordRegExp(searchTerm) # suche nach allen Treffern          words=self.findWordRegExp(indexName,searchTerm) # suche nach allen Treffern
         logging.info("wd:%s"%words)          logging.info("wd:%s"%words)
         for word in words:          for word in words:
             ret+=self.searchInLineIndexDocs(word)              ret+=self.searchInLineIndexDocs(indexName,word)
                   
         return unique(ret)          return unique(ret)
                   
     def showInLineIndex(self):      def showInLineIndex(self):
         """get the index for debug purposes"""          """get the index for debug purposes"""
         print "show"          print "show"
         for x in self.lineIndex.iterkeys():          for key in self.lineIndexes.keys():
               logging.info("index:%s"%key)
               for x in self.lineIndexes[key].iterkeys():
             logging.info("word:%s"%repr(x))              logging.info("word:%s"%repr(x))
             #for y in self.lineIndex[x].iterkeys():              #for y in self.lineIndex[x].iterkeys():
             #    print "doc",repr(y),repr(self.lineIndex[x][y])              #    print "doc",repr(y),repr(self.lineIndex[x][y])
                                   
         return self.lineIndex          return self.lineIndexes
                   
     def searchInLineIndexDocs(self,word,uniq=True,regExp=False):      def searchInLineIndexDocs(self,indexName,word,uniq=True,regExp=False):
         """search occurences"""          """search occurences in an index
           @param indexName: name of the index to be searched in
           @param word: word to be searched
           @param unique: (optional) unify the list of results
           @param regExp: (optional) use regular expressions
           """
   
         if regExp:          if regExp:
             return self.searchRegExpInLineIndexDocs(word)              return self.searchRegExpInLineIndexDocs(indexName,word)
                   
         try:              try:    
                 lst=list(self.lineIndex.get(word).keys())                  
                   lst=list(self.lineIndexes[indexName].get(word).keys())
         except:          except:
               logging.error("error: searchInLineIndexDocs (%s %s)"%(sys.exc_info()[0:2]))
             lst=[]              lst=[]
         if uniq:          if uniq:
             return unique(lst)              return unique(lst)
         else:          else:
             return lst              return lst
                   
     def getLinesFromIndex(self,word,doc,regExp=False):      def getLinesFromIndex(self,indexName,word,doc,regExp=False):
         """get lines"""          """return all lines from a document where word is found
           @param indexName: Name of the index
           @param word: word to be searched
           @param doc: name of the document (usuallay the p-number)
           @param regExp: (optional) use regExp       
           """
           
         if not regExp:          if not regExp:
             return self.lineIndex.get(word)[doc]              return self.lineIndexes[indexName].get(word)[doc]
         else: # wenn regexp, suche welches word          else: # wenn regexp, suche welches word
             for w in self.findWordRegExp(word):              for w in self.findWordRegExp(indexName,word):
                 if self.lineIndex.get(w): # ein word in im dex gefunden                  if self.lineIndexes[indexName].get(w): # ein word in im dex gefunden
                     try:                          try:    
                         dc=self.lineIndex.get(word)[doc]                          dc=self.lineIndex[indexName].get(word)[doc]
                         return dc # und ein document dann gib es zurueck                          return dc # und ein document dann gib es zurueck
                     except:                      except:
                          pass #andernfalls weiter                           pass #andernfalls weiter
                                             
     def cleanInLineIndex(self):      def cleanInLineIndex(self,indexName):
         """delete InlineIndex"""          """empty an InlineIndex
         for x in list(self.lineIndex.keys()):          @param indexName: name of the index
             del(self.lineIndex[x])          """
         print [x for x in self.lineIndex.keys()]          for x in list(self.lineIndexes[indexName].keys()):
               del(self.lineIndexes[indexName][x])
           print [x for x in self.lineIndexes[indexName].keys()]
             
         return "ok"          return "ok"
           
     def storeInLineIndex(self,key,value):      def storeInLineIndex(self,indexName,key,value):
         """store in index"""          """store in index, key is normally a word or grapheme 
           and value is a tuple (documentname, line) where the word can be found
           @param indexName: name of the index
           @param key: key in index
           @param value: value in index, value is a tuple (document name, line)
           """
           logging.error("indexing: %s %s"%(indexName,key))
           if (not hasattr(self,'lineIndexes')):
         
               self.lineIndexes={}
             
         if (not hasattr(self,'lineIndex')) or (type(self.lineIndex) is DictType):          if self.lineIndexes.get(indexName,None) is None:
             self.lineIndex=OOBTree()              #index exisitiert noch nicht dann anlegen
         li=self.lineIndex              
               self.lineIndexes[indexName]=OOBTree()
           lis=self.lineIndexes
           li=lis[indexName]
                   
         if li.has_key(key):          if li.has_key(key):
   
Line 1845  class CDLIRoot(Folder): Line 2045  class CDLIRoot(Folder):
             li[key][value[0]]=[value[1]]               li[key][value[0]]=[value[1]] 
                                           
                   
         self.lineIndex=li          self.lineIndexes=lis
             
         transaction.get().commit()          transaction.get().commit()
                   
   
     def showFile(self,fileId):      def showFile(self,fileId):
         """show a file"""          """show a file
           @param fileId: P-Number of the document to be displayed
           """
         f=self.CDLICatalog({'title':fileId})          f=self.CDLICatalog({'title':fileId})
         if not f:          if not f:
             return ""              return ""
                   
         return f[0].getObject().getLastVersionFormattedData()          return f[0].getObject().getLastVersionFormattedData()
           
     def showLineFromFile(self,fileId,lineNum,word):  
         """get line lineNum fromFileId"""  
                   
         file=self.showFile(fileId)      def showWordInFile(self,fileId,word,lineList=None,regExp=True,indexName=""):
         #str="^%s\.[^%s\.]*%s[^\n]*\n"%(lineNum,lineNum,word)  
         #str="^%s\..*?%s[^\n]*\n"%(lineNum,word)  
           
         #print str  
         #m=re.search(str,file,flags=re.M|re.DOTALL)  
         #if m:  
         #    return m.group()  
         #else:  
         #       return ""  
         #ret=lineNum+"."  
         #splitted=file.split(lineNum+".")  
         #if len(splitted)>1:  
                 #for part in splitted[1:]:  
                         #if part.find(word)>-1:  
                          # for x in part.split("\n"):  
                                 #ret+=x  
                                 #if x.find(word)>-1:  
                                         #break  
                           #break;  
         #return ret  
   
     def showWordInFile(self,fileId,word,lineList=None):  
         """get lines with word  fromFileId"""          """get lines with word  fromFileId"""
                   
         file=self.showFile(fileId)          file=self.showFile(fileId)
   
         ret=[]          ret=[]
           if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen
               wordlist=self.findWordRegExp(indexName,word)
           else:
               wordlist=[word]
           
         for line in file.split("\n"):          for line in file.split("\n"):
               found=False
               for word in wordlist:
                 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 1899  class CDLIRoot(Folder): Line 2084  class CDLIRoot(Folder):
                                         ret.append(line)                                          ret.append(line)
                         else: # nimm alles ohne line check                          else: # nimm alles ohne line check
                                 ret.append(line)                                  ret.append(line)
                           
                           break;
         return ret          return ret
   
     def tagWordInFile(self,fileId,word,lineList=None):      def tagWordInFile(self,fileId,word,lineList=None,regExp=True,indexName=""):
         """get lines with word  fromFileId"""          """get lines with word  fromFileId"""
                   
         file=self.showFile(fileId)          file=self.showFile(fileId)
         tagStr="""<span class="found">%s</span>"""          tagStr="""<span class="found">%s</span>"""
         ret=[]          ret=[]
           
           if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen
               wordlist=self.findWordRegExp(indexName,word)
           else:
               wordlist=[word]
               
         for line in file.split("\n"):          for line in file.split("\n"):
                 if line.find(word)>-1:              found=False
               for word in wordlist:
                   if line.find(word)>-1: #word ist gefunden dann makiere und breche die Schleife ab
                         if lineList: #liste of moeglichen Zeilennummern                          if lineList: #liste of moeglichen Zeilennummern
                                 num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile                                  num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
   
                                 if num in lineList:                                   if num in lineList: 
   
                                         ret.append(line.replace(word,tagStr%word))                                          ret.append(line.replace(word,tagStr%word))
                           
                         else: # nimm alles ohne line check                          else: # nimm alles ohne line check
                                 ret.append(line.replace(word,tagStr%word))                                  ret.append(line.replace(word,tagStr%word))
                 else:                          found=True
                           break
               if not found: #word wurde nicht gefunden keine makierung
                         ret.append(line)                          ret.append(line)
                           
         return "<br>\n".join(ret)          return "<br>\n".join(ret)
   
     def URLquote(self,str):      def URLquote(self,str):
Line 1949  class CDLIRoot(Folder): Line 2148  class CDLIRoot(Folder):
   
         return ret          return ret
                                                 
     def forceDahl(self):  
         "break all locks"  
         ret=[]  
         for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):  
            if str(f[1].lockedBy)=="dahl":  
                    un=f[1].forceunlock()  
   
                    if un and un !="":  
                       ret.append((f[0],un))  
   
         return ret                         
           
     def getChangesByAuthor(self,author,n=100):      def getChangesByAuthor(self,author,n=100):
         """getChangesByAuthor"""          """getChangesByAuthor"""
Line 2024  class CDLIRoot(Folder): Line 2212  class CDLIRoot(Folder):
                                                                                         
           
     def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):      def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
         """standard ausgabe"""          """upload an atf file / basket file"""
         #self._v_uploadATF.returnValue=None          #self._v_uploadATF.returnValue=None
           
           #generate an random id for the upload thread
         from random import randint          from random import randint
         if (not self.REQUEST.SESSION.get('idTmp',None)):          if (not self.REQUEST.SESSION.get('idTmp',None)):
   
Line 2034  class CDLIRoot(Folder): Line 2224  class CDLIRoot(Folder):
         else:          else:
             idTmp=self.REQUEST.SESSION.get('idTmp',None)              idTmp=self.REQUEST.SESSION.get('idTmp',None)
                           
       
         threadName=repeat          threadName=repeat
         if not threadName or threadName=="":          if not threadName or threadName=="":
               #new thread not called from the waiting page
             tmpVar=False              tmpVar=False
                 
             thread=uploadATFThread()              thread=uploadATFThread()
Line 2083  class CDLIRoot(Folder): Line 2275  class CDLIRoot(Folder):
                 return pt(txt='/uploadATF',threadName=threadName)                  return pt(txt='/uploadATF',threadName=threadName)
                                   
             else:              else:
 #                tmp={}  
 #                for key in self._v_uploadATF[threadName].returnValue.keys():  
 #                        t=self._v_uploadATF[threadName].returnValue[key]  
 #                        if type(t) is ListType:  
 #                                       tmp[key]=self._v_uploadATF[threadName].returnValue[key][0:]  
 #                        else:  
 #                                       tmp[key]=self._v_uploadATF[threadName].returnValue[key]  
 #                         repr(tmp[key]),repr(key)  
 #                                         
 #                #  
                 #tmp=self.cdli_main.tmpStore2[threadName]  
                   
                 tmp=getattr(self.temp_folder,idTmp).returnValue                  tmp=getattr(self.temp_folder,idTmp).returnValue
                                   
                   
                   
                  
                 #del(self.cdli_main.tmpStore2[threadName])  
   
                  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
   
                 return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],                  return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
Removed from v.1.67  
changed lines
  Added in v.1.72

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