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

Diff for /cdli/cdli_files.py between versions 1.93 and 1.103

version 1.93, 2008/10/07 06:53:57 version 1.103, 2008/11/05 19:53:32
Line 1 Line 1
 """CDLI extensions of the filearchive"""      """CDLI extensions of the filearchive"""    
 from Products.versionedFile.extVersionedFile import *  from Products.versionedFile.extVersionedFile import *
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
 from tempfile import mkstemp,mkdtemp      
 import os.path  import os.path
 import os  import os
 from types import *  
 import urlparse  import urlparse
 import urllib  import urllib
 import cgi  import cgi
Line 21  from ZPublisher.HTTPRequest import HTTPR Line 19  from ZPublisher.HTTPRequest import HTTPR
 from ZPublisher.HTTPResponse import HTTPResponse  from ZPublisher.HTTPResponse import HTTPResponse
 from ZPublisher.BaseRequest import RequestContainer  from ZPublisher.BaseRequest import RequestContainer
 import threading  import threading
 from BTrees.OOBTree import OOBTree, OOTreeSet  
 import logging  import logging
 import transaction  import transaction
 import copy  import copy
Line 32  import cdliSplitter Line 29  import cdliSplitter
 from sets import Set  from sets import Set
 import md5  import md5
 from DownloadBasket import DownloadBasketFinallyThread  from DownloadBasket import DownloadBasketFinallyThread
   from types import *
   import pickle
                                                                                 
 def makelist(mySet):  def makelist(mySet):
         x = list(mySet)          x = list(mySet)
Line 224  def unique(s): Line 223  def unique(s):
 class BasketContent(SimpleItem):  class BasketContent(SimpleItem):
     """classe fuer den Inhalt eines Baskets"""      """classe fuer den Inhalt eines Baskets"""
         
       def getFileAndVersionFromId(self,pnum,versionNr):
          
           obj=self.cdliRoot.getFileObject(pnum)
           logging.debug("obj : %s"%obj)
           version=obj.getVersionNr(versionNr)
           logging.debug("-------vs: %s"%version.getFileName())
           return version,obj
       
     def __init__(self,content=[]):      def __init__(self,content=[]):
         """content"""          """content"""
         self.contentList=content[0:]  
           
     def getContent(self):          self.setContent(content[0:])
         """get content"""  
                   
       def getContent(self,filtered=True):
         return self.contentList          return self.contentList
           
       def getContentOld(self,filtered=True):
           """get content"""
           logging.debug("content object: content List %s"%self.contentList)
           ret=[]
           
           return [self.getFileAndVersionFromId(x[0],x[1]) for x in self.contentList]
   #            
   #       if filtered:
   #           for x in self.contentList:
   #                    if not((x[0] is None) or (x[1] is None)):
   #                            ret.append(x)
   #            logging.debug("content object: content List -done filtered")
   #            return ret
   #           
   #       else:
   #            logging.debug("content object: content List -done  not filtered")
   #           return self.contentList
   
       def allContent(self):
           """get all content"""
           return self.getContent(filtered=False)
   
     def setContent(self,content):      def setContent(self,content):
         self.contentList=content[0:]          contentList=[]
           for x in content:
               if not((x[0] is None) or (x[1] is None)):
               
                   contentList.append((x[1].getId(),x[0].getVersionNumber()))
           logging.debug("cl: %s"%contentList)
           self.contentList=contentList[0:]
           
     def numberOfItems(self):      def numberOfItems(self):
         """number"""          """number"""
Line 607  class CDLIBasketContainer(OrderedFolder) Line 641  class CDLIBasketContainer(OrderedFolder)
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type="CDLIBasketContainer"      meta_type="CDLIBasketContainer"
           
       def getResultHash(self):
           """get the result hash for debug purposes"""
           return self.resultHash.keys()
       
     def getPNumbersOfBasket(self,basketName):      def getPNumbersOfBasket(self,basketName):
         """get all pnumbers of a basket as a list, returns an empty list if basket not found          """get all pnumbers of a basket as a list, returns an empty list if basket not found
         @param basketName: name of the basket          @param basketName: name of the basket
Line 616  class CDLIBasketContainer(OrderedFolder) Line 654  class CDLIBasketContainer(OrderedFolder)
         if not basketId:          if not basketId:
             return []              return []
                   
         ob=getattr(self,basketId).getContent()          ob=getattr(self,basketId).getContent() #get the content of a basket
                   
         ret=[x[0].split(".")[0] for x in ob]          ret=[x[0].split(".")[0] for x in ob]
                   
Line 635  class CDLIBasketContainer(OrderedFolder) Line 673  class CDLIBasketContainer(OrderedFolder)
             return ""              return ""
                   
         ob=getattr(self,basketId).getLastVersion()          ob=getattr(self,basketId).getLastVersion()
         for object in ob.getContent():          for pnum,versionNr in ob.getContent():
               obj=self.cdliRoot.getFileObject(pnum)
          # logging.debug("obj : %s"%obj)
          # version=obj.getVersionNr(versionNr)
         
             if current=="no": #version as they are in the basket              if current=="no": #version as they are in the basket
                             ret+=str(object[0].getData())+"\n"                              cur= obj.getVersionNr(versionNr)
                               ret+=str(cur.getData())+"\n"
             elif current=="yes":              elif current=="yes":
                             #search current object                              #search current object
                             #logging.debug("current: %s"%object[1].getId().split(".")[0])                              #logging.debug("current: %s"%object[1].getId().split(".")[0])
                             founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})                              obj.getData()
                             if len(founds)>0:        
                                 ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"  
         return ret          return ret
           
     security.declareProtected('manage','upDateBaskets')       security.declareProtected('manage','upDateBaskets') 
Line 659  class CDLIBasketContainer(OrderedFolder) Line 700  class CDLIBasketContainer(OrderedFolder)
     def deleteBaskets(self,ids=None):      def deleteBaskets(self,ids=None):
         """delete baskets, i.e. move them into trash folder"""          """delete baskets, i.e. move them into trash folder"""
                   
           if ids is None:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
               txt="Sorry, no basket selected!"
               return pt(txt=txt)
                   
         found=self.ZopeFind(self,obj_ids=['trash'])          found=self.ZopeFind(self,obj_ids=['trash'])
                   
Line 670  class CDLIBasketContainer(OrderedFolder) Line 715  class CDLIBasketContainer(OrderedFolder)
                   
         if type(ids) is not ListType:          if type(ids) is not ListType:
             ids=[ids]              ids=[ids]
           logging.error("XERXON:"+repr(ids))
           if len(ids)==0:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
               txt="Sorry, no basket selected!"
               return pt(txt=txt)
      
         cut=self.manage_cutObjects(ids)          cut=self.manage_cutObjects(ids)
         trash.manage_pasteObjects(cut)          trash.manage_pasteObjects(cut)
                   return None
     security.declareProtected('manage','manageBaskets')             security.declareProtected('manage','manageBaskets')       
     def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",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)              ret= self.deleteBaskets(ids)
                       if ret:
                   return ret
         elif submit=="join":          elif submit=="join":
             flag,msg=self.joinBasket(joinBasket, ids)              flag,msg=self.joinBasket(joinBasket, ids)
             logging.info("joining %s %s"%(flag,msg))              logging.info("joining %s %s"%(flag,msg))
               if not flag:
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
                   
                   return pt(txt=msg)
                           
         elif submit=="subtract":          elif submit=="subtract":
             logging.info("BBBb %s %s"%(basket1,basket2))              logging.info("BBBb %s %s"%(basket1,basket2))
Line 821  class CDLIBasketContainer(OrderedFolder) Line 877  class CDLIBasketContainer(OrderedFolder)
         @param basket2: see above          @param basket2: see above
               
         """          """
           
         logging.info("CCCCC %s %s"%(basket1,basket2))          logging.info("CCCCC %s %s"%(basket1,basket2))
         
         try:          try:
Line 861  class CDLIBasketContainer(OrderedFolder) Line 918  class CDLIBasketContainer(OrderedFolder)
         @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
         """          """
           if oldBaskets is None:
               return False, "No Baskets selected!"
           
         try:          try:
             newB=self.addBasket(newBasket)              newB=self.addBasket(newBasket)
         except:          except:
             return False, "cannot create the new basket"              return False, "cannot create the new basket"
                   
         newBasketContent={}          newBasketContent={}
        
         for ob in oldBaskets:          for ob in oldBaskets:
             x= getattr(self,ob,None)              x= getattr(self,ob,None)
             if x is None:              if x is None:
Line 1029  class CDLIBasket(Folder,CatalogAware): Line 1090  class CDLIBasket(Folder,CatalogAware):
         return [x[1].getId() for x in self.getLastVersion().getContent()]          return [x[1].getId() for x in self.getLastVersion().getContent()]
           
   
     def isActual(self,obj):      def isActual(self,obj,nummer):
           """teste ob im basket die aktuelle version ist, obj kann entweder ein CDLIFile sein oder eine 
           eine pnummer, die auf ein CDLIFile verweist"""
           try:
               #logging.debug("isActual:"+repr(obj))
               if isinstance(obj, CDLIFile):
                   actualNo=obj.getLastVersion().getVersionNumber()
               else:
                   actualNo=self.cdliRoot.getFileObjectLastVersion(obj).getVersionNumber()
               
               if actualNo==nummer:
                   return True , 0
               else:
                   return False, actualNo
           except:
               logging.error( """is actual: %s (%s %s)"""%(repr(obj),sys.exc_info()[0],sys.exc_info()[1]))
               logging.error("""         PARAMS: %s %s"""%(obj,nummer))
               return False, -1
       def isActualOld(self,obj):
         """teste ob im basket die aktuelle version ist"""          """teste ob im basket die aktuelle version ist"""
         try:          try:
             #logging.debug("isActual:"+repr(obj))              #logging.debug("isActual:"+repr(obj))
Line 1197  class CDLIBasket(Folder,CatalogAware): Line 1276  class CDLIBasket(Folder,CatalogAware):
         def swap(x):          def swap(x):
             return (x[1],x[0])              return (x[1],x[0])
                           
           logging.info("add to basket (%s)"%(repr(ids)))
         logging.info("add to basket (%s)"%(self.getId()))          logging.info("add to basket (%s)"%(self.getId()))
         lastVersion=self.getLastVersion()          lastVersion=self.getLastVersion()
                   
Line 1225  class CDLIBasket(Folder,CatalogAware): Line 1305  class CDLIBasket(Folder,CatalogAware):
         hash = md5.new(repr(makelist(ids))).hexdigest() # erzeuge hash als identification          hash = md5.new(repr(makelist(ids))).hexdigest() # erzeuge hash als identification
         #logging.debug("JJJJJJJ:"+repr(self.makelist(ids)))          #logging.debug("JJJJJJJ:"+repr(self.makelist(ids)))
                 
                                 retrieved = self.CDLICache.retrieve(hash)
         if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key("hash"):           if retrieved:
             logging.debug("from store!")              newContent=Set(map(swap,retrieved))
             newContent=Set(map(swap,self.cdliRoot.v_tmpStore[hash]))  
            
         else:          else:
             logging.debug("not from store!")  
             newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])              newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])
                   
                   
           
           #remove all Elements which are not stored
           if (None,None) in newContent:   
               newContent.remove((None,None))
         content=Set(oldContent).union(newContent)          content=Set(oldContent).union(newContent)
         added = len(content)-len(oldContent)          added = len(content)-len(oldContent)
         if not username:          if not username:
Line 1254  class CDLIBasket(Folder,CatalogAware): Line 1335  class CDLIBasket(Folder,CatalogAware):
         ret=[]          ret=[]
                   
         lv=self.getLastVersion()          lv=self.getLastVersion()
         for obj in lv.content.getContent():          #for obj in lv.content.getContent():
             #logging.info("XXXXXXXXXX %s"%repr(obj))              #logging.info("XXXXXXXXXX %s"%repr(obj))
             ret.append((obj[1].getId(),obj[0].versionNumber))          #    ret.append((obj[1].getId(),obj[0].versionNumber))
                           
         return ret          return lv
                   
     def getContentIds(self):      def getContentIds(self):
         """print basket content"""          """print basket content"""
Line 1342  class CDLIBasketVersion(Implicit,Persist Line 1423  class CDLIBasketVersion(Implicit,Persist
                   
         objs=self.getContent()          objs=self.getContent()
         for obj in objs:          for obj in objs:
             if not self.isActual(obj)[0]:              if not self.isActual(obj[0],obj[1])[0]:
                 return True                  return True
         return False          return False
           
Line 1369  class CDLIBasketVersion(Implicit,Persist Line 1450  class CDLIBasketVersion(Implicit,Persist
             return """I am sorry, currently the server has to many requests for downloads, please come back later!"""              return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
   
   
         if (check=="yes") and self.containsNonActualFiles():          #if (check=="yes") and self.containsNonActualFiles():
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)          #    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
           #    
           #    return pt(lock=lock)
           
           # neue Version aus Performancegruenden, es wird nicht mehr getestet, ob es nicht aktuelle Objekte gibt
           # sondern lediglich gefragt.
           if (check=="yes"):
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_ask.zpt')).__of__(self)
                           
             return pt(lock=lock)              return pt(lock=lock)
                           
Line 1396  class CDLIBasketVersion(Implicit,Persist Line 1484  class CDLIBasketVersion(Implicit,Persist
             #check if a locked object exist in the basket.              #check if a locked object exist in the basket.
             lockedObjects={}              lockedObjects={}
             for object in self.content.getContent():              for object in self.content.getContent():
                   obj=self.getFileObject(object[0])
                 if (not str(object[1].lockedBy)=="") and (not (str(object[1].lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):                  if (not str(obj.lockedBy)=="") and (not (str(obj.lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):
                     lockedObjects[object[1].title]=repr(object[1].lockedBy)                      lockedObjects[obj.title]=repr(obj.lockedBy)
                                         
                                           
             keys=lockedObjects.keys()              keys=lockedObjects.keys()
Line 1428  class CDLIBasketVersion(Implicit,Persist Line 1516  class CDLIBasketVersion(Implicit,Persist
   
             self._v_downloadBasket[threadName]=thread              self._v_downloadBasket[threadName]=thread
             logging.debug("dwonloadfinally:"+repr(self))              logging.debug("dwonloadfinally:"+repr(self))
             basketID=self.aq_parent.aq_parent.getId()  
             versionNumber=self.aq_parent.getId()              if isinstance(self,CDLIBasketVersion):
                   obj=self
               else:
                   obj=self.aq_parent
               logging.debug("dwonloadfinally2:"+repr(obj))
               logging.debug("dwonloadfinally2:"+repr(obj.aq_parent))
   
               obj2=obj.aq_parent
               if not isinstance(obj2,CDLIBasket):
                   obj2=obj2.aq_parent
   
               basketID=obj2.getId()
               versionNumber=obj.getId()
               logging.debug("dwonloadfinally2:"+repr(basketID))
               logging.debug("dwonloadfinally2:"+repr(versionNumber))
   
                     
             if lock:              if lock:
                 logging.debug("-----start locking")                  logging.debug("-----start locking")
                 for object in self.content.getContent():                  for object in self.content.getContent():
                          if object[1].lockedBy =='':                           obj=self.ctx.getFileObject(object[0])
                              object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']                           if obj.lockedBy =='':
                                obj.lockedBy=self.REQUEST['AUTHENTICATED_USER']
                 logging.debug("-----finished locking")                  logging.debug("-----finished locking")
                                   
                     #obj.lockedBy=user                      #obj.lockedBy=user
Line 1485  class CDLIBasketVersion(Implicit,Persist Line 1589  class CDLIBasketVersion(Implicit,Persist
                                        self._v_downloadBasket[threadName]=thread                                         self._v_downloadBasket[threadName]=thread
                                                                                 
               #files = self._v_downloadBasket[threadName].result                #files = self._v_downloadBasket[threadName].result
               files=self.basketContainer.resultHash[threadName]                # lade die files und die locked files, bei grossen Baskets muss u.U. gewartet werden
               lockedFiles=self.basketContainer.resultLockedHash[threadName]                # bis das Commit aus dem Thread alles geschrieben hat, in dem Falle existiert resultHash[threadName]
                 # noch nicht.
                 o1 = file("/tmp/"+threadName,'r')
                 files=pickle.load(o1)
                 os.remove("/tmp/"+threadName)
                 o2 = file("/tmp/"+threadName+'_lockedFiles','r')
                 
                 lockedFiles=pickle.load(o2)
                 os.remove("/tmp/"+threadName+'_lockedFiles')
   #              try:
   #                  files=self.basketContainer.resultHash[threadName]
   #              except:
   #                  i=0
   #                  while (not self.basketContainer.resultHash.has_key(threadName)) and (i<100):
   #                      logging.debug(" downloadFinally: I am waiting for thread %s to write the resultHashfile: %s"%(threadName,i))
   #                      time.sleep(5)
   #                      i+=1
   #                  files=self.basketContainer.resultHash[threadName]  
   #              
   #              try:
   #                  lockedFiles=self.basketContainer.resultLockedHash[threadName]
   #              except:
   #                  i=0
   #                  while (not self.basketContainer.resultLockedHash.has_key(threadName)) and (i<100):
   #                      logging.debug(" downloadFinally: I am waiting for thread %s to write the LockedHashfile: %s"%(threadName,i))
   #                      time.sleep(5)
   #                      i+=1
   #                  lockedFiles=self.basketContainer.resultLockedHash[threadName]
             
              # fh=file("/var/tmp/test")               # fh=file("/var/tmp/test")
               #ret =fh.read()                #ret =fh.read()
Line 1510  class CDLIBasketVersion(Implicit,Persist Line 1641  class CDLIBasketVersion(Implicit,Persist
               self.REQUEST.RESPONSE.write(ret)                 self.REQUEST.RESPONSE.write(ret) 
                                     
               for fileName in files:                for fileName in files:
                   logging.debug("download: %s"%fileName)
                 try:                  try:
                   self.REQUEST.RESPONSE.write(file(fileName).read())                    self.REQUEST.RESPONSE.write(file(fileName).read())
                 except:                  except:
Line 1543  class CDLIBasketVersion(Implicit,Persist Line 1675  class CDLIBasketVersion(Implicit,Persist
           
     def getContent(self):      def getContent(self):
         """get Basket Content"""          """get Basket Content"""
         return self.content.getContent()          logging.debug("retrieving content A")
           cnt = self.content
           logging.debug("retrieving content: obj %s"%cnt)
           tmp = self.content.getContent()
           logging.debug("got content")
           return tmp
   
           
     def __init__(self,id,user,comment="",basketContent=[]):      def __init__(self,id,user,comment="",basketContent=[]):
Line 1566  class CDLIBasketVersion(Implicit,Persist Line 1703  class CDLIBasketVersion(Implicit,Persist
     security.declareProtected('manage','index_html')      security.declareProtected('manage','index_html')
     def index_html(self):      def index_html(self):
             """view the basket"""              """view the basket"""
               logging.debug("start index_html - Basket version")    
             if self.REQUEST.get('change',False):              if self.REQUEST.get('change',False):
                     ob=self.aq_parent.updateObjects(self.REQUEST['change'])                      ob=self.aq_parent.updateObjects(self.REQUEST['change'])
                                         
                     self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket                      self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket
                                                       logging.debug("start index_html - Basket version:template")    
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
             return pt()              return pt()
             
     def getObjUrl(self,result):      def getObjUrl(self,result):
         """getUrl of the version of the object"""          """getUrl of the version of the object"""
         objId=result[1].getTitle()        
         founds=self.CDLICatalog.search({'title':objId})          founds=self.CDLICatalog.search({'title':result})
         if len(founds)>0:          if len(founds)>0:
              return founds[0].getObject().getLastVersion().absolute_url()               return founds[0].getObject().getLastVersion().absolute_url()
                     
         else: #assume version number          else: #assume version number
             splitted=objId.split("_")              splitted=result.split("_")
             founds=self.CDLICatalog.search({'title':splitted[1]})                      founds=self.CDLICatalog.search({'title':splitted[1]})        
             return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId              return founds[0].getObject().getLastVersion().absolute_url()+'/'+result
         
 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 2088  class CDLIFileFolder(extVersionedFileFol Line 2225  class CDLIFileFolder(extVersionedFileFol
             pt=getattr(self,'filelist.html')              pt=getattr(self,'filelist.html')
             return pt(basketName=basketName,numberOfObjects=numberOfObjects)              return pt(basketName=basketName,numberOfObjects=numberOfObjects)
                   
         if hash is not None and hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash):   
                                 
                logging.debug("asking for storage2")          result =self.CDLICache.retrieve(hash)
                result =self.cdliRoot.v_tmpStore[hash]  
                if result:                 if result:
                    logging.debug("give result from storage2")                     logging.debug("give result from storage2")
                    return hash,self.cdliRoot.v_tmpStore[hash]             return hash,result
                       
         if list is not None: # got already a list          if list is not None: # got already a list
                           
Line 2154  class CDLIFileFolder(extVersionedFileFol Line 2289  class CDLIFileFolder(extVersionedFileFol
                 return pt(search=ids)                  return pt(search=ids)
             else:                   else:     
                 #self.REQUEST.SESSION['hash'] = ret # store in session                   #self.REQUEST.SESSION['hash'] = ret # store in session 
                 if not hasattr(self,'v_tmpStore'):                  
                     self.cdliRoot.v_tmpStore={}  
                 #logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))                  #logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))
                 #logging.debug("HHHHHHNEU:"+repr(hash))                  #logging.debug("HHHHHHNEU:"+repr(hash))
                 self.cdliRoot.v_tmpStore[hash] = ret # store in session                   self.CDLICache.store(hash,ret)
                   
                 if returnHash == True:                  if returnHash == True:
                     return hash,ret                      return hash,ret
                 return ret                  return ret
Line 2295  class CDLIRoot(Folder): Line 2430  class CDLIRoot(Folder):
                 'graphemes':cdliSplitter.graphemeSplitter()}                  'graphemes':cdliSplitter.graphemeSplitter()}
           
           
       def unicodify(self,txt):
           return unicodify(txt)
       def invalidateOldCacheVersion(self):
           """loescht die alte Version des Cache"""
           del self.v_tmpStore
           return "done"
       
     def viewATF(self,id,RESPONSE):      def viewATF(self,id,RESPONSE):
         """view an Object"""          """view an Object"""
         ob = self.CDLICatalog({'title':id})          ob = self.CDLICatalog({'title':id})
Line 2354  class CDLIRoot(Folder): Line 2496  class CDLIRoot(Folder):
     def getFileObjectLastVersion(self,fileId):      def getFileObjectLastVersion(self,fileId):
         """get an object"""          """get an object"""
         x=self.v_files_lastVersion.get(fileId)          x=self.v_files_lastVersion.get(fileId)
         l#ogging.debug("lastVersion: "+repr(x))          #logging.debug("lastVersion: "+repr(x))
         return x          return x
           
     def showFileIds(self):      def showFileIds(self):
Removed from v.1.93  
changed lines
  Added in v.1.103

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