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

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

version 1.69, 2007/03/20 10:49:15 version 1.72, 2007/03/22 19:56:22
Line 506  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 636  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 780  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 844  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 883  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 970  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 1185  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 1445  def checkFile(filename,data,folder): Line 1606  def checkFile(filename,data,folder):
     else:      else:
         return True,""          return True,""
           
 #    else:  
 #        fn=os.path.join(folder,filename)  
 #        stin,out=os.popen4("/usr/bin/atfcheck.plx %s"%fn)  
 #        value=out.read()  
 #        ret= out.close()  
 #  
 #        if value:  
 #       
 #            return False,"atf checker error: %s"%value  
 #        else:  
 #            return True,""  
           
 def splitatf(fh,dir=None,ext=None):  def splitatf(fh,dir=None,ext=None):
     """split it"""      """split it"""
Line 1686  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 1770  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 1859  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)  
         #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):      def showWordInFile(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)
   
         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 1913  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 1963  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 2040  class CDLIRoot(Folder): Line 2214  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):
         """upload an atf file / basket file"""          """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 2048  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 2097  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.69  
changed lines
  Added in v.1.72

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