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

Diff for /cdli/cdli_files.py between versions 1.53 and 1.119

version 1.53, 2006/12/22 11:56:08 version 1.119, 2011/07/20 09:33:35
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
   import logging
   import transaction
   import copy
   import codecs
   import sys
   from BTrees.IOBTree import IOBTree 
 from BTrees.OOBTree import OOBTree  from BTrees.OOBTree import OOBTree
   import cdliSplitter
   from sets import Set
   import md5
   from DownloadBasket import DownloadBasketFinallyThread
   from types import *
   import pickle
   import tempfile
   
 class BasketContent(SimpleItem):  from cdli_helpers import *
     """classe fuer den Inhalt eines Baskets"""  
       
     def __init__(self,content=[]):  
         """content"""  
         self.contentList=content[0:]  
       
     def getContent(self):  
         """get content"""  
   
         return self.contentList  
       
     def setContent(self,content):  
         self.contentList=content[0:]  
       
     def numberOfItems(self):  
         """number"""  
           
         return len(self.getContent())  
           
       
 class uploadATFfinallyThread(Thread):  
     """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""  
       
     def __init__(self):  
         """init for uploadATFfinallyThread"""  
         self.continueVar=True  
         self.returnValue=None  
         self.end=False  
         Thread.__init__(self)  
              
     def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):  
         """set start values for the thread"""  
         self.procedure=procedure  
         self.comment=comment  
         self.basketname=basketname  
         self.unlock=unlock  
         self.SESSION=SESSION  
         self.username=username  
         self.serverport=serverport  
           
     def __call__(self):  
         """call of the thread (equals run)"""  
         self.run()  
         return True  
       
     def getContext(self, app,serverport="8080"):  
         """get the context within the ZODB"""  
           
         resp = HTTPResponse(stdout=None)  
         env = {  
             'SERVER_NAME':'localhost',  
             'SERVER_PORT':serverport,  
             'REQUEST_METHOD':'GET'  
             }  
         req = HTTPRequest(None, env, resp)  
         return app.__of__(RequestContainer(REQUEST = req))  
             
           
     def run(self):  
         """run"""  
           
         self.result=""  
         #find context within ZODB  
         from Zope import DB  
         conn = DB.open()  
         root = conn.root()  
         app  = root['Application']  
         ctx = self.getContext(app,serverport=self.serverport)  
   
         #add the files  
         self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)  
         #commit the transactions  
         get_transaction().commit()  
         conn.close()  
         #set flag for end of this method  
         self.end=True  
     print "ended"  
     return True  
       
     def __del__(self):  
         """delete"""  
           
           
       
     def getResult(self):  
         """method for accessing result"""  
           
         return self.result  
        
     def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):  
         """upload the files"""  
         #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot  
         ctx2=ctx.cdliRoot  
      
         self.result+="<h2>Start processing</h2>"  
           
         #shall I only upload the changed files?  
         if procedure=="uploadchanged":  
         
             uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])  
           
         #or all  
         elif procedure=="uploadAll":  
             uploadFns=[]  
             for x in os.listdir(SESSION['tmpdir']):  
                 if not x in SESSION['lockerrors']:  
                     uploadFns.append(x)  
                       
         #or maybe nothing  
         elif procedure=="noupload":  
                         return True  
         else:  
             uploadFns=[]  
               
         #do first the changed files      
         for fn in uploadFns:  
             founds=ctx2.CDLICatalog.search({'title':fn})  
             if len(founds)>0:  
                 SESSION['author']=str(username)  
                 self.result+="<p>Changing : %s"%fn  
                 founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)  
               
           
         #now add the new files          
         newPs=SESSION['newPs']  
         if len(newPs)>0:  
             tmpDir=SESSION['tmpdir']  
             self.result+="<p>Adding files</p>"  
             #TODO: make this configurable, at the moment base folder for the files has to be cdli_main  
               
             ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)  
                   
           
           
         #unlock locked files?  
         if unlock:  
             self.result+="<p>Unlock files</p>"  
             unlockFns=[]  
             for x in os.listdir(SESSION['tmpdir']):  
                     if not x in SESSION['errors']:  
                         unlockFns.append(x)  
               
             for fn in unlockFns:  
                 founds=ctx2.CDLICatalog.search({'title':fn})  
                 if len(founds)>0:  
                     SESSION['author']=str(username)  
                      
                     founds[0].getObject().lockedBy=""  
                       
         #if a basketname is give, add files to the basket  
         if not (basketname ==''):  
             self.result+="<p>Add basket</p>"  
             basketId=ctx2.basketContainer.getBasketIdfromName(basketname)  
               
             if not basketId: # create new basket  
                 ob=ctx2.basketContainer.addBasket(basketname)  
                 basketId=ob.getId()  
             basket=getattr(ctx2.basketContainer,str(basketId))  
             ids=os.listdir(SESSION['tmpdir'])  
             basket.addObjects(ids,deleteOld=True,username=str(username))      
                  
         if RESPONSE is not None:  
             RESPONSE.redirect(self.aq_parent.absolute_url())  
           
   
          
         return True  
       
 class uploadATFThread(Thread):  
     """class for checking the files befor uploading"""  
       
     def __init__(self):  
         """initialise"""  
           
         self.continueVar=True  
         self.returnValue=None  
           
         Thread.__init__(self)  
           
           
     def set(self,upload,basketId,username,serverport="8080"):  
         """set start values for the thread"""  
         self.result=""  
         self.upload=upload  
         self.basketId=basketId  
         self.username=username  
         self.serverport=serverport  
           
     def __call__(self):  
         """call method """  
         self.run()  
         return True  
       
     def getContext(self, app,serverport="8080"):  
         """get the context within the ZODB"""  
         resp = HTTPResponse(stdout=None)  
         env = {  
             'SERVER_NAME':'localhost',  
             'SERVER_PORT':serverport,  
             'REQUEST_METHOD':'GET'  
             }  
         req = HTTPRequest(None, env, resp)  
         return app.__of__(RequestContainer(REQUEST = req))  
           
     def run(self):  
        
         self.result=""  
         #find context within ZODB  
         from Zope import DB  
         conn = DB.open()  
         root = conn.root()  
         app  = root['Application']  
         ctx = self.getContext(app,serverport=self.serverport)  
         self.uploadATFThread(ctx,self.upload,self.basketId)  
        
         #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue  
   
         get_transaction().commit()  
       
         while self.continueVar:  
             pass  
          
         conn.close()  
           
           
     def getResult(self):  
         """method for accessing result"""  
         return self.result  
       
     def uploadATFThread(self,ctx,upload,basketId=0):  
         """upload an atf file"""  
         #TODO: add comments  
         #TODO: finish uploadATF  
         self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"  
       
         #make sure that id is a string and not an integer  
         basketId=str(basketId)  
           
         #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot  
         ctx2=ctx.cdliRoot  
           
         #get temporary file for staging the downloaded and splitted files  
         dir=mkdtemp()  
           
           
         changed=[] # changed files  
         errors=[]  # files with errors  
         lockerrors=[]  # files with errors  
   
         newPs=[]   # new p filed  
         psNotInCatalog=[] # files not in the catalog  
           
         #split the uploadedd atf file  
         basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)  
           
         #find basketId if not set  
           
         #get active abaket  
         if basketId == '0':  
             basketObj=ctx2.basketContainer.getActiveBasket()  
             if basketObj:  
                 basketId=basketObj.getId()  
                   
         #if there is no active basket and no basketid given, id is empty, else get besketname and length  
         if basketId == '0':  
             basketNameFromId=""  
             basketLen=0  
         else:  
             basketNameFromId=getattr(ctx2.basketContainer,basketId).title  
             basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()  
               
           
         self.result+="""<html><body><h2>I got the files</h2><  
                         p>I am computing the differences to the exisiting files</p>"""  
                                      
         #start to check the files  
         for fn in os.listdir(dir):  
               
             self.result+="<p>process:%s</p>"%fn  
               
             # check if file is in the catalog  
             #TODO: checkCatalog is not implemented yet  
             if ctx2.cdli_main.checkCatalog(fn):  
                 psNotInCatalog.append(fn)  
                   
             #check if p-file already at the server    
             founds=ctx2.CDLICatalog.search({'title':fn})      
         
             #if not than add filename to the list of newfiles  
               
             data=file(os.path.join(dir,fn)).read()  
             #status,msg=checkFile(fn,data,dir)  
             status=True  
             msg=""  
             if not status: # error  
                 errors.append((fn,msg))  
             else:  
                 if len(founds)==0:  
                     newPs.append(fn)  
   
                 #if p file alread at the server      
                 for found in founds:  
                     #analyse the differences to the actual file  
                     obj=found.getObject()  
   
                     if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):  
                                 lockerrors.append(fn)  
                     else:  
                   
                         diffs=obj.diff(data)  
                         if diffs[0]>0:  
                             changed.append((obj,diffs)) #hochladen  
   
         #ready, set the returnValues  
         self.result+="<h3>Done</h3></body></html>"  
           
         self.returnValue={}  
         self.returnValue['changed']=changed  
         self.returnValue['errors']=errors  
         self.returnValue['lockerrors']=lockerrors  
         self.returnValue['newPs']=newPs  
         self.returnValue['tmpdir']=dir  
         self.returnValue['basketLen']=basketLen  
         self.returnValue['numberOfFiles']=numberOfFiles  
         self.returnValue['basketNameFromId']=basketNameFromId  
         self.returnValue['basketNameFromFile']=basketNameFromFile  
         self.returnValue['basketId']=basketId  
         self.returnValue['dir']=dir  
           
         #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)  
       
           
 class Basket_old(Folder):  
     """shopping basket - alte fassung """  
       
     meta_type="Basket"  
     _v_stack={}  
   
     def getObjUrl(self,objId):  
         """getUrl"""  
         founds=self.CDLICatalog.search({'title':objId})  
         if len(founds)>0:  
              return founds[0].getObject().absolute_url()  
            
         else: #assume version number  
             splitted=objId.split("_")  
             founds=self.CDLICatalog.search({'title':splitted[1]})          
             return founds[0].getObject().absolute_url()+'/'+objId  
           
     def storeAllLink(self,results):  
         """erzeuge link zum speicher aller results"""  
         nr=self.REQUEST['_ZopeId']  
           
         if results:  
             self._v_stack[nr]=[x.getObject().getId() for x in results]  
           
         return self.absolute_url()+"/storeAll?id="+nr  
       
     def storeAll(self,id):  
         """store all"""  
         try:  
             results=self._v_stack[id]  
         except:  
             #TODO: write expired page  
             return "expired"  
           
         return self.storeInBasketForm(results)  
           
     def storeInBasketForm(self,ids):  
         """ store an object form"""  
           
         if type(ids) is not ListType:  
             ids=[ids]  
         self.REQUEST.SESSION['ids']=ids[0:]  
           
         self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']  
   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)  
         return pt()  
           
     def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):  
         """store it"""  
           
         if not ids:  
             ids=REQUEST.SESSION['ids']  
               
         self.REQUEST.SESSION['basketUser']=username  
           
         baskets=self.ZopeFind(self,obj_ids=[username])  
         if len(baskets)>0:  
             basket=baskets[0][1]  
         else:  
             manage_addBasketObject(self,username)  
             basket=self._getOb(username)  
           
           
         basket.addObjects(ids)  
         back=self.REQUEST.SESSION.get('BACKLINK', None)  
   
         if RESPONSE:  
             RESPONSE.redirect(back)  
               
   
       
     def showBasket(self,user=None,set=None,RESPONSE=None):  
         """show the basket"""  
           
         if user:  
             self.REQUEST.SESSION['basketUser']=user  
           
         if not user and not set:  
             user=self.REQUEST.SESSION.get('basketUser',None)  
           
         if not user:  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)  
             return pt()  
         else:  
             baskets=self.ZopeFind(self,obj_ids=[user])  
           
   
         if len(baskets)>0:  
             RESPONSE.redirect(baskets[0][1].absolute_url())  
             return True   
         else:  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)  
             return pt()  
           
   
 def manage_addBasket_oldForm(self):  
     """add the basket form"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)  
     return pt()  
   
 def manage_addBasket_old(self,id,title,RESPONSE=None):  
     """add the basket"""  
     ob=Basket()  
       
     ob.id=str(id)  
     ob.title=title  
     self._setObject(id, ob)  
     ob=self._getOb(id)  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
       
 class BasketObject_old(Folder):  
     """Basket Object - alte fassung"""  
       
     meta_type="basketObject"  
     def __init__(self):  
                 """init basket object"""  
                 self.contents=[]  
   
     def numberOfItems(self):  
         """return anzahl der elemente im basket"""  
         num=len(self.contents)  
           
         return num  
       
     def addObjects(self,ids):  
         """addObjects"""  
           
         for id in ids:  
             founds=self.CDLICatalog.search({'title':id})  
             for found in founds:  
                 if found.getObject() not in self.contents:  
                     tm=self.contents[0:]  
                     tm.append(found.getObject())  
                     self.contents=tm[0:]  
       
         return True  
   
     def index_html(self):  
                 """view the basket"""  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)  
                 return pt()  
   
     def deleteObjects(self,ids,RESPONSE=None):  
         """delete objects"""  
         list = self.contents[0:]  
         for content in list:  
                  
                 if content.getId() in ids:  
                     self.contents.remove(content)  
           
   
         if RESPONSE:  
                     RESPONSE.redirect(self.absolute_url())  
   
   
     def unlockTest(self):  
         """unlock all files of the testuser for debuggin"""  
         for object in self.contents:  
   
                 if str(object.lockedBy)=="test":  
                     object.lockedBy=""  
               
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):  
         """download all selected files in one file"""  
           
         ret=""  
         lockedObjects={}  
       
         if self.temp_folder.downloadCounter > 10:  
             return """I am sorry, currently the server has to many requests for downloads, please come back later!"""  
   
   
         if lock:  
               
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':  
                   
                 return "please login first"  
   
             #check if a locked object exist in the basket.  
             lockedObjects={}  
             for object in self.contents:  
   
                 if not object.lockedBy=="":  
                     lockedObjects[object.title]=repr(object.lockedBy)  
                      
                       
             keys=lockedObjects.keys()  
               
               
             if len(keys)>0 and (not procedure):  
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)  
                 return pt()  
            
             elif not procedure: #keine fails gesperrt dann alle donwloaden  
                 procedure="downloadAll"   
           
         self.temp_folder.downloadCounter+=1   
         self._p_changed=1  
         get_transaction().commit()        
   
           
         for object in self.contents:  
               
                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     ret+=object.getLastVersion().getData()  
                   
                 if lock and object.lockedBy=='':  
                     object.lockedBy=self.REQUEST['AUTHENTICATED_USER']  
   
   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())  
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")  
         length=len(ret)  
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)  
         self.REQUEST.RESPONSE.write(ret)      
         self.temp_folder.downloadCounter-=1   
         self._p_changed=1  
         get_transaction().commit()        
           
           
 def manage_addBasket_oldObjectForm(self):  
     """add form"""  
     pass  
   
 def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):  
     """add"""  
       
     ob=BasketObject()  
       
     ob.id=str(id)  
     ob.title=title  
     self._setObject(id, ob)  
     ob=self._getOb(id)  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
   
 class CDLIBasketContainer(OrderedFolder):  
     """contains the baskets"""  
       
   
     security=ClassSecurityInfo()  
     meta_type="CDLIBasketContainer"  
       
     def upDateBaskets(self):  
         """update content in to objects"""  
           
         founds=self.ZopeFind(self,obj_metatypes=['CDLIBasketVersion'],search_sub=1)  
   
         for found in founds:  
             found[1].updateBasket()  
           
     security.declareProtected('manage','deleteBaskets')          
     def deleteBaskets(self,ids=None):  
         """delete baskets, i.e. move them into trash folder"""  
           
           
         found=self.ZopeFind(self,obj_ids=['trash'])  
           
         if len(found)<1:  
             manage_addFolder(self, 'trash')  
             trash=self._getOb('trash')  
         else:  
             trash=found[0][1]  
           
         if type(ids) is not ListType:  
             ids=[ids]  
         cut=self.manage_cutObjects(ids)  
         trash.manage_pasteObjects(cut)  
           
     security.declareProtected('manage','manageBaskets')         
     def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):  
         """manage baskets, delete or copy"""  
         if submit=="delete":  
             self.deleteBaskets(ids)  
           
          
               
         if RESPONSE:  
             RESPONSE.redirect(self.absolute_url())  
       
     security.declareProtected('View','getBasketIdfromName')         
     def getBasketIdfromName(self,basketname):  
         """get id from name"""  
   
         for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):  
             if basket[1].title==basketname:  
                 return basket[0]  
         else:  
             None  
       
     security.declareProtected('manage','uploadBasket_html')          
               
     def uploadBasket_html(self,basketId='0'):  
         """upload an atf file, html form"""  
           
   
         basketId=str(basketId)  
         if not basketId=='0':  
             basketName=getattr(self.basketContainer,basketId).title  
         else:  
             basketName=""  
               
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)  
         return pt(basketId=basketId,basketName=basketName)  
      
   
     security.declareProtected('View','index_html')      
     def index_html(self):  
         """stanadard ansicht"""  
           
   
   
         ext=self.ZopeFind(self,obj_ids=["index.html"])  
         if ext:  
             return ext[0][1]()  
           
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)  
         return pt()  
       
     def getStorageFolderRoot(self):  
         """root des storage folders"""  
         return self.cdli_main  
       
     def __init__(self,id,title):  
         """ init basket container"""  
         self.id=id  
         self.title=title  
        
    
     def getBasketsId(self):  
         """get all baskets als klartext"""  
           
         ret=""  
         baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])  
         for basket in baskets:  
             com,user,time,values = basket[1].getContentIds()  
             ret+= "BASKET:"+com+"\t"+user+"\t"+time+"\n"  
             for x in values:  
                 ret+= x[0]+"\t"+x[1]+"\n"  
         return ret  
   
     def getBaskets(self,sortField='title'):  
         """get all baskets files"""  
   
         def sortName(x,y):  
             return cmp(x[1].title.lower(),y[1].title.lower())  
   
         def sortDate(x,y):  
             return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())  
   
           
         def sortComment(x,y):  
   
           
               
              try:  
                 xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()  
              except:  
                 xc='ZZZZZZZZZZZZZ'.lower()  
              try:  
                 yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()  
              except:  
                 yc='ZZZZZZZZZZZZZ'.lower()  
       
       
              if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):  
                    
                  try:  
                      xc=x[1].getLastVersion().getComment().lower()  
                  except:  
                      xc='ZZZZZZZZZZZZZ'.lower()  
                        
              if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):  
                  try:  
                      yc=y[1].getLastVersion().getComment().lower()  
                  except:  
                      yc='ZZZZZZZZZZZZZ'.lower()  
       
                
                  return cmp(xc,yc)  
           
         def sortAuthor(x,y):  
               
             return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())  
           
         baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])  
           
           
         if sortField=='title':  
             baskets.sort(sortName)  
         elif sortField=='date':  
             baskets.sort(sortDate)  
         elif sortField=='author':  
             baskets.sort(sortAuthor)  
         elif sortField=='comment':  
             baskets.sort(sortComment)  
   
         return baskets  
   
   
                          
     def getNewId(self):  
         """createIds"""  
         last=getattr(self,'last',0)  
         last +=1  
         while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:  
             last+=1  
       
         self.last=last  
         return last  
       
     def setActiveBasket(self,basketId,REQUEST=None):  
         """store active basketId in a cookie"""  
         self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")  
     try:  
         qs=cgi.parse_qs(REQUEST['QUERY_STRING'])  
         del(qs['basketId'])  
     except:  
         qs={}  
         if REQUEST:  
             REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+urllib.urlencode(qs))  
               
     def getActiveBasket(self):  
         """get active basket from cookie"""  
           
         id= self.REQUEST.cookies.get('CDLIActiveBasket',None)  
         if id:  
             obj=getattr(self,str(id),None)  
         else:  
             obj=None  
         return obj  
       
     def getActualUserName(self):  
         """get name of the actualuser"""  
         return str(self.REQUEST['AUTHENTICATED_USER'])  
       
       
     def addBasket(self,newBasketName):  
         """add a new basket"""  
           
         ob=manage_addCDLIBasket(self,newBasketName)  
         return ob  
       
     def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):  
         """store it"""  
         if not ids:  
             ids=self.REQUEST.SESSION['fileIds']  
               
         if type(ids) is not ListType:  
             ids=[ids]  
           
         if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):  
             basketRet=self.addBasket(newBasketName)  
             self.setActiveBasket(basketRet.getId())  
             basket=getattr(self,basketRet.getId())  
         elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):  
             basket=self.getActiveBasket()  
           
         added=basket.addObjects(ids)  
         back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)  
           
           
         if fromFileList:  
   
             return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)  
          
         if RESPONSE:  
               
             RESPONSE.redirect(back)  
               
         return True  
       
 def manage_addCDLIBasketContainerForm(self):  
     """add the CDLIBasketContainer form"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)  
     return pt()  
   
 def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):  
     """add the basket"""  
     ob=CDLIBasketContainer(id,title)  
       
     self._setObject(id, ob)  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
 class CDLIBasket(Folder,CatalogAware):  
     """basket"""  
       
     meta_type="CDLIBasket"  
     default_catalog="CDLIBasketCatalog"  
       
   
     def getFile(self,obj):  
         return obj[1]  
       
     def getFileLastVersion(self,obj):  
         return obj[0]  
       
     def getFileNamesInLastVersion(self):  
         """get content of the last version as list"""  
           
         return [x[1].getId() for x in self.getLastVersion().getContent()]  
       
   
     def isActual(self,obj):  
         """teste ob im basket die aktuelle version ist"""  
         actualNo=obj[1].getLastVersion().getVersionNumber()  
         storedNo=obj[0].getVersionNumber()  
           
         founds=self.CDLICatalog.search({'title':obj[0].getId()})  
         if len(founds)>0:  
             actualNo=founds[0].getObject().getLastVersion().getVersionNumber()  
               
         if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":  
             return False, -1  
           
         if actualNo==storedNo:  
             return True , 0  
         else:  
             return False, actualNo  
           
     def history(self):  
         """history"""    
   
         ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])  
         if ext:  
             return getattr(self,ext[0][1].getId())()  
           
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self)  
         return pt()  
       
     def getStorageFolderRoot(self):  
         """root des storage folders"""  
         return self.aq_parent.cdli_main  
       
     def __init__(self,id,title,shortDescription="",comment=""):  
         """init a CDLIBasket"""  
           
         self.id=id  
         self.title=title  
         self.shortDescription=shortDescription  
         self.comment=comment  
    
      
              
     def getLastVersion(self):  
         """hole letzte version"""  
   
         ids=[]  
         idsTmp= self.objectIds()  
         for x in idsTmp:  
             try:  
                 ids.append(int(x))  
             except:  
                 pass  
         ids.sort()  
         
         if len(ids)==0:  
             return None  
         else:      
             ob=getattr(self,str(ids[-1]))  
   
               
             return ob  
      
     def getVersions(self):  
         """get versions"""  
         versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])  
         return versions  
   
      
     def updateObjects(self,ids,RESPONSE=None,REQUEST=None):  
         """update ids, ids not in the basket the add"""  
         if type(ids) is not ListType:  
             ids=[ids]  
          
         lastVersion=self.getLastVersion()   
         oldContent=lastVersion.content.getContent()  
         newContent=[]  
           
         #first copy the old  
         for obj in oldContent:  
             if obj[1].getId() not in ids:  
                 newContent.append(obj)  
         #now add the new  
                  
         for id in ids:  
             founds=self.CDLICatalog.search({'title':id})  
   
             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().getLastVersion(),found.getObject()))  
           
   
         content=newContent   
         user=self.getActualUserName()  
           
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)  
           
         obj=self._getOb(ob.getId())  
         if RESPONSE:  
              
             RESPONSE.redirect(obj.absolute_url())  
           
         return obj  
       
     def addObjects(self,ids,deleteOld=None,username=None):  
         """generate a new version of the basket with objects added"""  
          
         lastVersion=self.getLastVersion()  
           
         if lastVersion is None:  
             oldContent=[]  
         else:  
             oldContent=lastVersion.content.getContent()  
   
         if deleteOld:  
             oldContent=[]  
   
         newContent=[]  
         added=0  
         for id in ids:  
         try:  
         founds=self.CDLICatalog.search({'title':id})  
         except:  
         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().getLastVersion(),found.getObject()))  
                     added+=1  
   
         content=oldContent+newContent  
         if not username:  
             user=self.getActualUserName()  
         else:  
             user = username  
               
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)  
       
         return added  
       
       
                   
       
     def getContentIds(self):  
         """print basket content"""  
         ret=[]  
         lv=self.getLastVersion()  
         for obj in lv.content.getContent():  
             ret.append((obj[0].getId(),obj[1].getId()))  
           
           
         return lv.getComment(),lv.getUser(),lv.getTime(),ret  
   
     def changeBasket(self,ids,submit,RESPONSE=None,REQUEST=None):  
         """change a basket"""  
         if submit=="update":  
             return self.updateObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)  
         elif submit=="delete":  
             return self.deleteObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)  
               
     def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):  
         """delete objects"""  
           
         if type(ids) is not ListType:  
             ids=[ids]  
          
         lastVersion=self.getLastVersion()   
         oldContent=lastVersion.content.getContent()  
         newContent=[]  
         for obj in oldContent:  
             if obj[1].getId() not in ids:  
                 newContent.append(obj)  
           
                   
         user=self.getActualUserName()  
           
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)  
           
         if RESPONSE:  
             obj=self._getOb(ob.getId())  
             RESPONSE.redirect(obj.absolute_url())  
           
 def manage_addCDLIBasketForm(self):  
     """add the CDLIBasketContainer form"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)  
     return pt()  
   
 def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):  
     """add the basket"""  
       
     id=str(self.getNewId())  
       
     ob=CDLIBasket(id,title,shortDescription,comment)  
       
     self._setObject(id, ob)  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
     else:  
         return ob  
   
 class CDLIBasketVersion(Implicit,Persistent,Folder):  
     """version of a basket"""  
       
     meta_type="CDLIBasketVersion"  
     security=ClassSecurityInfo()  
       
     def updateBasket(self):  
         """update"""  
         try:  
             self._setObject('content',BasketContent(self.basketContent))  
         except:  
             try:  
                 if len(self.basketContent)>0:  
                     self.content.setContent(self.basketContent)  
             except:  
                 print "error",self.getId(),self.aq_parent.getId()  
         self.basketContent=[]  
   
           
     def containsNonActualFiles(self):  
         """returns True if basket contains one or more non current files"""  
           
         objs=self.getContent()  
         for obj in objs:  
             if not self.isActual(obj)[0]:  
                 return True  
         return False  
       
     security.declareProtected('View','downloadObjectsAsOneFile')  
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):  
         """download all selected files in one file"""  
           
         if self.temp_folder.downloadCounterBaskets > 10000:  
             return """I am sorry, currently the server has to many requests for downloads, please come back later!"""  
   
   
         if (check=="yes") and self.containsNonActualFiles():  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)  
               
             return pt(lock=lock)  
               
         else:  
               
             return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")  
           
     def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no"):  
         """print do the download"""  
   
         ret=""  
         lockedObjects={}  
   
         self.temp_folder.downloadCounterBaskets+=1   
         self._p_changed=1  
         get_transaction().commit()         
       
         if lock:  
               
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':  
                 self.temp_folder.downloadCounterBaskets-=1   
                 self._p_changed=1  
                 get_transaction().commit()        
                 self.temp_folder.downloadCounterBaskets-=1   
                 self._p_changed=1  
                 get_transaction().commit()        
                 return "please login first"  
   
             #check if a locked object exist in the basket.  
             lockedObjects={}  
             for object in self.content.getContent():  
   
                 if not object[1].lockedBy=="":  
                     lockedObjects[object[1].title]=repr(object[1].lockedBy)  
                      
                       
             keys=lockedObjects.keys()  
               
               
             if len(keys)>0 and (not procedure):  
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)  
                   
                 self.temp_folder.downloadCounterBaskets-=1   
                 self._p_changed=1  
                 get_transaction().commit()        
   
                 return pt()  
            
             elif not procedure: #keine fails gesperrt dann alle donwloaden  
                 procedure="downloadAll"   
           
           
   
   
         for object in self.content.getContent():  
       
                 if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     if current=="no": #version as they are in the basket  
                         ret+=str(object[0].getData())+"\n"  
                     elif current=="yes":  
                         #search current object  
                         founds=self.CDLICatalog.search({'title':object[0].getId()})  
                         if len(founds)>0:        
                             ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"  
                               
                 if lock and object[1].lockedBy=='':  
                     object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']  
         basket_name=self.aq_parent.title+"_V"+self.getId()  
           
         #write basketname to header of atf file  
         ret="#basket: %s\n"%basket_name+ret  
   
         self.temp_folder.downloadCounterBaskets-=1   
         self._p_changed=1  
         get_transaction().commit()        
           
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%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)      
         return True  
           
     def numberOfItems(self):  
         """return anzahl der elemente im basket"""  
         return self.content.numberOfItems()  
       
     def getTime(self):  
         """getTime"""  
         #return self.bobobase_modification_time().ISO()  
         
         if hasattr(self,'time'):  
             return time.strftime("%Y-%m-%d %H:%M:%S",self.time)  
         elif hasattr(self,'timefixed'):  
             return self.timefixed  
         else:  
             setattr(self,'timefixed',self.bobobase_modification_time().ISO())  
             return self.bobobase_modification_time().ISO()  
       
     def getContent(self):  
         """get Basket Content"""  
         return self.content.getContent()  
   
       
     def __init__(self,id,user,comment="",basketContent=[]):  
         """ init a basket version"""  
         self.id=id  
         self.coment=comment  
         self._setObject('content',BasketContent(basketContent))  
         #self.basketContent=basketContent[0:]a  
         self.user=user  
         self.time=time.localtime()  
           
     def getUser(self):  
         """get user"""  
         return self.user  
       
     def getComment(self):  
         """get Comment"""  
         return self.comment  
    
     security.declareProtected('View','index_html')  
     def index_html(self):  
             """view the basket"""  
   
             if self.REQUEST.get('change',False):  
                     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  
                                           
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)  
             return pt()  
        
     def getObjUrl(self,result):  
         """getUrl of the version of the object"""  
         objId=result[1].getTitle()  
         founds=self.CDLICatalog.search({'title':objId})  
         if len(founds)>0:  
              return founds[0].getObject().getLastVersion().absolute_url()  
            
         else: #assume version number  
             splitted=objId.split("_")  
             founds=self.CDLICatalog.search({'title':splitted[1]})          
             return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId  
      
 def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):  
     """add a version"""  
       
     #check for already existing versions  
    
     lastVersion=self.getLastVersion()  
     if lastVersion is None:  
         newId=str(1)  
     else:  
         newId=str(int(lastVersion.getId())+1)  
       
     ob=CDLIBasketVersion(newId,user,comment,basketContent)  
       
     self._setObject(newId, ob)  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
     else:  
         return ob  
           
 class CDLIFileObject(CatalogAware,extVersionedFileObject):  class CDLIFileObject(CatalogAware,extVersionedFileObject):
     """CDLI file object"""      """CDLI file object"""
Line 1280  class CDLIFileObject(CatalogAware,extVer Line 44  class CDLIFileObject(CatalogAware,extVer
           
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
           
       security.declareProtected('manage','index_html')
     
     security.declarePublic('makeThisVersionCurrent')      security.declarePublic('view')
       view = PageTemplateFile('zpt/viewCDLIFile.zpt', globals())
   
       security.declarePublic('editATF')
       editATF = PageTemplateFile('zpt/editATFFile.zpt', globals())
           
     def PrincipiaSearchSource(self):      def PrincipiaSearchSource(self):
            """Return cataloguable key for ourselves."""             """Return cataloguable key for ourselves."""
            return str(self)             return str(self)
                 
       def setAuthor(self, author):
           """change the author"""
           self.author = author
          
     def makeThisVersionCurrent_html(self):      def makeThisVersionCurrent_html(self):
         """form for making this version current"""          """form for mthis version current"""
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
         return pt()                           return pt()                 
   
       security.declarePublic('makeThisVersionCurrent')
     def makeThisVersionCurrent(self,comment,author,RESPONSE=None):      def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
         """copy this version to current"""          """copy this version to current"""
         parent=self.aq_parent          parent=self.aq_parent
           parent.manage_addVersionedFileObject(id=None,vC=comment,author=author,file=self.getData(),RESPONSE=RESPONSE)
           #newversion=parent.manage_addCDLIFileObject('',comment,author)
           #newversion.manage_upload(self.getData())
                   
                   #if RESPONSE is not None:
         newversion=parent.manage_addCDLIFileObject('',comment,author)          #    RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
         newversion.data=self.data[0:]  
                                           
         if RESPONSE is not None:  
             RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')  
   
   
         return True          return True
           
     security.declarePublic('view')  
    
     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):  
         """view file"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)  
         return pt()  
           
     security.declarePublic('getPNumber')      security.declarePublic('getPNumber')
     def getPNumber(self):      def getPNumber(self):
         """get the pnumber"""          """get the pnumber"""
         try:          try:
                 txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])                  txt=re.match("&[PpSs](\d*)\s*=([^\r\n]*)",self.getData()[0:])
         except:          except:
                 txt=self.getData()[0:]                  txt=self.getData()[0:]
                                   
Line 1336  class CDLIFileObject(CatalogAware,extVer Line 104  class CDLIFileObject(CatalogAware,extVer
     def getDesignation(self):      def getDesignation(self):
         """get the designation out of the file"""          """get the designation out of the file"""
         try:          try:
                 txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])                  txt=re.match("&[PpSs](\d*)\s*=([^\r\n]*)",self.getData()[0:])
         except:          except:
                 txt=self.getData()[0:]                  txt=self.getData()[0:]
                                   
Line 1346  class CDLIFileObject(CatalogAware,extVer Line 114  class CDLIFileObject(CatalogAware,extVer
         except:          except:
             return "ERROR"              return "ERROR"
                   
           
 manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')  manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
   
 def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',  def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',versionNumber=0,
                                precondition='', content_type='',
                              from_tmp=False,REQUEST=None):                               from_tmp=False,REQUEST=None):
     """Add a new File object.      """Add a new File object.
   
     Creates a new File object 'id' with the contents of 'file'"""      Creates a new File object 'id' with the contents of 'file'"""
     
     id=str(id)      id=str(id)
Line 1364  def manage_addCDLIFileObject(self,id,vC= Line 133  def manage_addCDLIFileObject(self,id,vC=
     self=self.this()      self=self.this()
   
     # First, we create the file without data:      # First, we create the file without data:
     self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))      self._setObject(id, CDLIFileObject(id,title,versionNumber=versionNumber,versionComment=vC,time=time.localtime(),author=author))
     self._getOb(id).versionComment=str(vC)      fob = self._getOb(id)
     self._getOb(id).time=time.localtime()  
       
     setattr(self._getOb(id),'author',author)  
       
           
     # Now we "upload" the data.  By doing this in two steps, we      # Now we "upload" the data.  By doing this in two steps, we
     # can use a database trick to make the upload more efficient.      # can use a database trick to make the upload more efficient.
   
     if file and not from_tmp:      if file and not from_tmp:
         self._getOb(id).manage_upload(file)          fob.manage_upload(file)
     elif file and from_tmp:      elif file and from_tmp:
         self._getOb(id).manage_upload_from_tmp(file)          fob.manage_file_upload(file) # manage_upload_from_tmp doesn't exist in ExtFile2
       #    fob.manage_upload_from_tmp(file) # manage_upload_from_tmp doesn't exist in ExtFile2
     if content_type:      if content_type:
         self._getOb(id).content_type=content_type          fob.content_type=content_type
   
       #logging.debug("manage_add: lastversion=%s"%self.getData())
       logging.debug("reindex1: %s in %s"%(repr(self),repr(self.default_catalog)))
     self.reindex_object()      self.reindex_object()
     self._getOb(id).reindex_object()      #logging.debug("manage_add: fob_data=%s"%fob.getData())
       logging.debug("reindex2: %s in %s"%(repr(fob), repr(fob.default_catalog)))
       fob.index_object()
   
       self.CDLIRoot.updateOrAddToFileBTree(ob)
     if REQUEST is not None:      if REQUEST is not None:
         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')          REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
           
   
 class CDLIFile(extVersionedFile,CatalogAware):  class CDLIFile(extVersionedFile,CatalogAware):
     """CDLI file"""      """CDLI file"""
           
       security=ClassSecurityInfo()
     meta_type="CDLI file"      meta_type="CDLI file"
       content_meta_type = ["CDLI File Object"]
       
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
           
     #security.declarePublic('history')      security.declareProtected('manage','index_html')
       
     def getLastVersionData(self):      def getLastVersionData(self):
         """get last version data"""          """get last version data"""
         return self.getLastVersion().getData()          return self.getData()
   
     def getLastVersionFormattedData(self):      def getLastVersionFormattedData(self):
         """get last version data"""          """get last version data"""
         return self.getLastVersion().getFormattedData()          return self.getContentObject().getFormattedData()
   
     #security.declarePublic('history')  
           
       def getTextId(self):
           """returns P-number of text"""
           # assuming that its the beginning of the title
           return self.title[:7]
           
       #security.declarePublic('history')
     def history(self):      def history(self):
         """history"""            """history"""  
   
Line 1449  class CDLIFile(extVersionedFile,CatalogA Line 228  class CDLIFile(extVersionedFile,CatalogA
         #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]          #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]
                   
                   
       def _newContentObject(self, id, title='', versionNumber=0, versionComment=None, time=None, author=None):
           """factory for content objects. to be overridden in derived classes."""
           logging.debug("_newContentObject(CDLI)")
           return CDLIFileObject(id,title,versionNumber=versionNumber,versionComment=versionComment,time=time,author=author)
   
   
     def addCDLIFileObjectForm(self):      def addCDLIFileObjectForm(self):
         """add a new version"""          """add a new version"""
                   
Line 1474  class CDLIFile(extVersionedFile,CatalogA Line 259  class CDLIFile(extVersionedFile,CatalogA
         except:          except:
             pass              pass
                   
           ob = self.addContentObject(id, vC, author, file, title, changeName=changeName, newName=newName, from_tmp=from_tmp,
                                      precondition=precondition, content_type=content_type)
                   
         if changeName=="yes":  
             filename=file.filename  
             self.title=filename[max(filename.rfind('/'),  
                         filename.rfind('\\'),  
                         filename.rfind(':'),  
                         )+1:]  
   
   
         if not newName=='':  
             self.title=newName[0:]  
           
           
   
      
         positionVersionNum=getattr(self,'positionVersionNum','front')  
           
         if positionVersionNum=='front':  
             id="V%i"%self.getVersion()+"_"+self.title  
         else:  
             tmp=os.path.splitext(self.title)  
             if len(tmp)>1:  
                 id=tmp[0]+"_V%i"%self.getVersion()+tmp[1]  
             else:  
                 id=tmp[0]+"_V%i"%self.getVersion()  
               
         
         manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type,from_tmp=from_tmp)  
         #objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))  
         objs=getattr(self,id).setVersionNumber(int(self.getVersion()))  
         try:          try:
           #FIXME: wozu ist das gut?            #FIXME: wozu ist das gut?
           self.REQUEST.SESSION['objID_parent']=self.getId()            self.REQUEST.SESSION['objID_parent']=self.getId()
         except:          except:
           pass            pass
       
         if RESPONSE:          #self.cdliRoot.updateOrAddToFileBTree(self)# now update the object in the cache
           
             obj=self.ZopeFind(self,obj_ids=[id])[0][1]          
             if obj.getSize()==0:          if RESPONSE:
                 self.REQUEST.SESSION['objID']=obj.getId()              if ob.getSize()==0:
                   self.REQUEST.SESSION['objID']=ob.getId()
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
                 return pt()                  return pt()
   
             else:              else:
                 if come_from and (come_from!=""):                  if come_from and (come_from!=""):
                                         RESPONSE.redirect(come_from+"?change="+self.getId())                                          RESPONSE.redirect(come_from+"?change="+self.getId())
                 else:                  else:
                     RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)                      RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
   
         else:          else:
             return self.ZopeFind(self,obj_ids=[id])[0][1]              return ob
                   
                   
 def manage_addCDLIFileForm(self):  def manage_addCDLIFileForm(self):
Line 1540  def manage_addCDLIFile(self,id,title,loc Line 297  def manage_addCDLIFile(self,id,title,loc
     tryToggle=True      tryToggle=True
     tryCount=0      tryCount=0
           
     
   
     self._setObject(id,newObj)                        self._setObject(id,newObj)                  
     getattr(self,id).reindex_object()      getattr(self,id).reindex_object()
                   
Line 1549  def manage_addCDLIFile(self,id,title,loc Line 304  def manage_addCDLIFile(self,id,title,loc
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   def checkUTF8(data):
       """check utf 8"""
       if not isinstance(data, str):
           logging.error("checkUTF8 data is not string! (%s)"%repr(data))
   
       try:
           data.decode('utf-8')
           logging.debug("checkUTF8: ok!")
           return True
       except:
           logging.debug("checkUTF8: false!")
           return False
       
   
 def checkFile(filename,data,folder):  def checkFile(filename,data,folder):
     """check the files"""      """check the files"""
     # first check the file name      # first check the file name
     fn=filename.split(".") # no extension      fn=filename.split(".") # no extension
   
     if not fn[0][0]=="P":      if not (fn[0][0]=="P" or fn[0][0]=="S"):
         return False,"P missing in the filename"          return False,"P/S 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
     nf=None      nf=None
     i=0      i=0
   
     for lineTmp in fh.readlines():      #ROC: why split \n first and then \r???
       if isinstance(fh, basestring):
           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..
     for line in lineTmp.split("\r"):      for line in lineTmp.split("\r"):
               #logging.info("Deal with: %s"%line)
         if ext:          if ext:
         i+=1          i+=1
         if (i%100)==0:          if (i%100)==0:
Line 1604  def splitatf(fh,dir=None,ext=None): Line 374  def splitatf(fh,dir=None,ext=None):
             if dir:              if dir:
             filename=os.path.join(dir,filename)              filename=os.path.join(dir,filename)
             nf=file(filename,"w")              nf=file(filename,"w")
                       logging.debug("open %s"%filename)
         if nf:              if nf:    
             nf.write(line.replace("\n","")+"\n")              nf.write(line.replace("\n","")+"\n")
   
       try:        
     nf.close()      nf.close()
       except:
           pass
       
       if not isinstance(fh, basestring):
     fh.close()      fh.close()
           
     return ret,len(os.listdir(dir))      return ret,len(os.listdir(dir))
   
   
Line 1617  class CDLIFileFolder(extVersionedFileFol Line 394  class CDLIFileFolder(extVersionedFileFol
           
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type="CDLI Folder"      meta_type="CDLI Folder"
     filesMetaType=['CDLI file']      file_meta_type=['CDLI file']
     folderMetaType=['CDLI Folder']      folder_meta_type=['CDLI Folder']
     default_catalog='CDLICatalog'  
     defaultFileCatalog=default_catalog #wenn dieses definiert ist, wird beim hinzufŸgen einer neuen version eines files dieser catalog neuiniziert      file_catalog='CDLICatalog'
   
     #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.      #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
     tmpStore2={}      tmpStore2={}
   
       def _newVersionedFile(self, id, title='', lockedBy=None, author=None):
           """factory for versioned files. to be overridden in derived classes."""
           logging.debug("_newVersionedFile(CDLI)")
           return CDLIFile(id, title, lockedBy=lockedBy, author=author)
   
     def setTemp(self,name,value):      def setTemp(self,name,value):
         """set tmp"""          """set tmp"""
   
         setattr(self,name,value)          setattr(self,name,value)
                                                                                   
       deleteFileForm = PageTemplateFile("zpt/doDeleteFile", globals())
                                                                                 
     def delete(self,ids):      def delete(self,ids,REQUEST=None):
         """delete this file, i.e. move into a trash folder"""          """delete these files"""
           if type(ids) is not ListType:
               ids=[ids]
                             
         found=self.ZopeFind(self,obj_ids=['.trash'])          self.manage_delObjects(ids)
                   
         if len(found)<1:          if REQUEST is not None:
             manage_addCDLIFileFolder(self, '.trash',title="Trash")              return self.index_html()
             trash=self._getOb('.trash')  
         else:  
             trash=found[0][1]  
                   
         if type(ids) is not ListType:  
             ids=[ids]  
         cut=self.manage_cutObjects(ids)  
         trash.manage_pasteObjects(cut)  
                   
     def getVersionNumbersFromIds(self,ids):      def getVersionNumbersFromIds(self,ids):
         """get the numbers of the current versions of documents described by their ids"""          """get the numbers of the current versions of documents described by their ids"""
Line 1654  class CDLIFileFolder(extVersionedFileFol Line 434  class CDLIFileFolder(extVersionedFileFol
         founds=self.CDLICatalog.search({'title':searchStr})          founds=self.CDLICatalog.search({'title':searchStr})
                   
         for found in founds:          for found in founds:
             lastVersion=found.getObject().getLastVersion()              lastVersion=found.getObject().getContentObject()
             ret.append((found.getId,lastVersion))              ret.append((found.getId,lastVersion))
                   
         return ret          return ret
           
       def getFile(self,fn):
           """get the content of the file fn"""
           logging.debug("getFile: %s"%repr(fn))
           if not self.hasObject(fn):
               # search deeper
               founds=getattr(self, self.file_catalog).search({'textid':fn})
               if founds:
                   obj=founds[0].getObject().getContentObject()
               else:
                   return "" 
           else:
               obj = self[fn].getContentObject()
   
           return obj.getData()[0:] 
    
       
     def checkCatalog(self,fn):      def checkCatalog(self,fn):
         """check if fn is in the catalog"""          """check if fn is in the catalog"""
         #TODO add checkCatalog          #TODO add checkCatalog
                     
                   
                                      
     def findObjectsFromListWithVersion(self,list,author=None):      def findObjectsFromListWithVersion(self,list,author=None):
         """find objects from a list with versions          """find objects from a list with versions
         @param list: list of tuples  (cdliFile,version)          @param list: list of tuples  (cdliFile,version)
         """          """
           
          
          
         #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage          #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
         #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']          #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                   
           
         pt=getattr(self,'filelistVersioned.html')          pt=getattr(self,'filelistVersioned.html')
                           
         return pt(search=list,author=author)          return pt(search=list,author=author)
           
           
       def getAllPNumbers(self):
           """get a list of all files (resp their p-numbers) stored"""
           
           ret=[x.getId for x in  self.CDLICatalog()]
                           
     def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):          return ret
       
       def expandFile(self,fileId,fileTree):
           """wildcard in fileID suche alle Treffer"""
           founds=self.CDLICatalog({'title':fileId})
           for found in founds:
               fileTree.add(found.getId)
               logging.debug("ADDD:"+found.getId)
            
       def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None,REQUEST=None,returnHash=False,hash=None):
         """findObjectsFromList (, TAB oder LINE separated)"""          """findObjectsFromList (, TAB oder LINE separated)"""
                                                                                 
           logging.debug("start: findObjectsFromList")
           #logging.debug("start: findObjectsFromList"+repr(list))
           
                   
         if upload: # list from file upload          if upload: # list from file upload
             txt=upload.read()              txt=upload.read()
Line 1716  class CDLIFileFolder(extVersionedFileFol Line 523  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)
                   
           
           result =self.CDLICache.retrieve(hash)
           if result:
              logging.debug("give result from storage2")
              return hash,result
     
         if list is not None: # got already a list          if list is not None: # got already a list
               
               logging.debug(" ----List version")
             ret=[]              ret=[]
               fileTree=Set()
               
             for fileId in list:              for fileId in list:
                 if fileId.find("*"): #check for wildcards                 
                         fileId=fileId                  if fileId.find("*")>-1: #check for wildcards
                           self.expandFile(fileId,fileTree)
                           
                 elif len(fileId.split("."))==1:                  elif len(fileId.split("."))==1:
                         fileId=fileId+".atf"                          fileId=fileId+".atf"
                           fileTree.add(fileId)
                   #logging.debug("   -----:"+fileId)
                   #ret+=self.CDLICatalog({'title':fileId})
                   #x =self.getFileObject(fileId)
                   #if x is not None:
                   #    ret.append(x)
                   
               
               
               ids = fileTree & self.v_file_ids
               #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
               l=makelist(fileTree)[0:]
               #logging.debug("l-list:"+repr(l))
               self.REQUEST.SESSION['fileIds']=l#store fieldIds in session for further usage
               self.REQUEST.SESSION['searchList']=l
               #self.REQUEST.SESSION['searchList']=['P000001.atf']
             
               
               hash = md5.new(repr(makelist(fileTree))).hexdigest() # erzeuge hash als identification
               self.REQUEST.SESSION['hash']=hash
               #TODO: do I need garbage collection for v_tmpStore ?
               
               #logging.debug("Hash:"+repr(hash))
   #        
   #            if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash): 
   #               logging.debug("asking for storage")
   #               res=self.cdliRoot.v_tmpStore[hash]
   #               if res:
   #                   if returnHash == True:
   #                       return hash,res
   #                   return res
                                   
                 ret+=self.CDLICatalog({'title':fileId})  
             #TODO: get rid of one of these..              #TODO: get rid of one of these..
             ids=[x.getObject().getId() for x in ret]              #ids=[x.getObject().getId() for x in ret]
             self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage              ret=[(self.getFileObject(x),self.getFileObjectLastVersion(x)) for x in ids]
             self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']              
               #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
               #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                           
             if display:              if display:
                 pt=getattr(self,'filelist.html')                  pt=getattr(self,'filelist.html')
                                   
                 return pt(search=ids)                  return pt(search=ids)
             else:                    else:      
                   #self.REQUEST.SESSION['hash'] = ret # store in session 
                   
                   #logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))
                   #logging.debug("HHHHHHNEU:"+repr(hash))
                   self.CDLICache.store(hash,ret)
                   
                   if returnHash == True:
                       return hash,ret
                 return ret                  return ret
                   
                   
Line 1742  class CDLIFileFolder(extVersionedFileFol Line 601  class CDLIFileFolder(extVersionedFileFol
         if start:          if start:
             RESPONSE.redirect("filelist.html?start:int="+str(start))              RESPONSE.redirect("filelist.html?start:int="+str(start))
                                                                                 
   
     security.declareProtected('Manage','createAllFilesAsSingleFile')      security.declareProtected('Manage','createAllFilesAsSingleFile')
     def createAllFilesAsSingleFile(self,RESPONSE=None):      def createAllFilesAsSingleFile(self,RESPONSE=None):
         """download all files"""          """download all files"""
Line 1750  class CDLIFileFolder(extVersionedFileFol Line 608  class CDLIFileFolder(extVersionedFileFol
         def sortF(x,y):          def sortF(x,y):
             return cmp(x[0],y[0])              return cmp(x[0],y[0])
                   
         catalog=getattr(self,self.default_catalog)          catalog=getattr(self,self.file_catalog)
         #tf,tfilename=mkstemp()          #tf,tfilename=mkstemp()
     if not hasattr(self.temp_folder,'downloadCounter'):      if not hasattr(self.temp_folder,'downloadCounter'):
         self.temp_folder.downloadCounter=0          self.temp_folder.downloadCounter=0
Line 1760  class CDLIFileFolder(extVersionedFileFol Line 618  class CDLIFileFolder(extVersionedFileFol
   
         self.temp_folder.downloadCounter+=1          self.temp_folder.downloadCounter+=1
         self._p_changed=1          self._p_changed=1
         get_transaction().commit()          transaction.get().commit()
                 
         list=[(x.getId,x) for x in catalog()]          list=[(x.getId,x) for x in catalog()]
         list.sort(sortF)          list.sort(sortF)
Line 1777  class CDLIFileFolder(extVersionedFileFol Line 635  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.getData()[0:])
                       RESPONSE.write("\n")
                 self.temp_folder.downloadCounter-=1                   self.temp_folder.downloadCounter-=1 
                 self._p_changed=1                  self._p_changed=1
         get_transaction().commit()          transaction.get().commit()
         #os.close(tf)          #os.close(tf)
         #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)          #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
         return True          return True
Line 1796  class CDLIFileFolder(extVersionedFileFol Line 655  class CDLIFileFolder(extVersionedFileFol
     def hasParent(self):      def hasParent(self):
         """returns true falls subfolder"""          """returns true falls subfolder"""
               
         if self.aq_parent.meta_type in self.folderMetaType:          if self.aq_parent.meta_type in self.folder_meta_type:
             return True              return True
         else:          else:
             return False              return False
Line 1804  class CDLIFileFolder(extVersionedFileFol Line 663  class CDLIFileFolder(extVersionedFileFol
     def getFolders(self):      def getFolders(self):
         """get all subfolders"""          """get all subfolders"""
         ret=[]          ret=[]
         folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)          folders=self.ZopeFind(self,obj_metatypes=self.folder_meta_type)
         for folder in folders:          for folder in folders:
             ret.append((folder[1],              ret.append((folder[1],
                         len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),                          len(self.ZopeFind(folder[1],obj_metatypes=self.folder_meta_type)),
                         len(self.ZopeFind(folder[1],obj_metatypes=self.filesMetaType))                          len(self.ZopeFind(folder[1],obj_metatypes=self.file_meta_type))
                         ))                          ))
         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 1862  class CDLIRoot(Folder): Line 721  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 showInLineIndex(self):      file_catalog = 'CDLICatalog'
         """get the index for debug purposes"""  
         print "show"  
         for x in self.lineIndex.iterkeys():  
             print "word:",x  
             for y in self.lineIndex[x].iterkeys():  
                 print "doc",y,self.lineIndex[x][y]  
                   
         return self.lineIndex  
           
     def searchInLineIndexDocs(self,word):  
         """search occurences"""  
         return list(self.lineIndex.get(word.upper()).keys())  
   
     def getLinesFromIndex(self,word,doc):  
         """get lines"""  
         return self.lineIndex[word][doc]  
   
     def cleanInLineIndex(self):  
         """delete InlineIndex"""  
         for x in list(self.lineIndex.keys()):  
             del(self.lineIndex[x])  
         print [x for x in self.lineIndex.keys()]  
             
         return "ok"      # word splitter for search
       splitter = {'words':cdliSplitter.wordSplitter(),
                   'graphemes':cdliSplitter.graphemeSplitter()}
       
       def redirect(self,RESPONSE,url):
           """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
           
           timeStamp=time.time()
           
           if url.find("?")>-1: #giebt es schon parameter
               addStr="&time=%s"
           else:
               addStr="?time=%s"
               
           RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
           logging.error(email.Utils.formatdate()+' GMT')
           RESPONSE.redirect(url+addStr%timeStamp)
       
       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):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           logging.debug(ob[0].getObject().getLastVersion().absolute_url()+"/view")
           if len(ob)>0:
               RESPONSE.redirect(ob[0].getObject().getLastVersion().absolute_url()+"/view")
           return "not found"
       
       def history(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/history")
           return "not found"
       
   
       def downloadLocked(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/downloadLocked")
           return "not found"
       
       def download(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               logging.info("objekt:"+repr(ob[0]))
               #RESPONSE.redirect(ob[0].getLastVersion().absolute_url())
               RESPONSE.redirect(ob[0].absolute_url+"/download")
           return "not found"
       def addCDLIFileObjectForm(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/addCDLIFileObjectForm")
           return "not found"
       
       def addVersionedFileObjectForm(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/addVersionedFileObjectForm")
           return "not found"
       
       def unlock(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/unlock")
           return "not found"
       
       
       def getFileObject(self,fileId):
           """get an object"""
           logging.debug("getFileObj:"+repr(fileId))
           if isinstance(fileId,CDLIFileObject): # support for old baskets
                     return fileId
           x=self.v_files.get(fileId)
           logging.debug("obj: "+repr(x))
           if x is None:
               logging.debug("fileId"+repr(fileId))
               folder=fileId[0:3]
               f2=fileId[0:5]
               fObj = getattr(self.cdliRoot.cdli_main,folder);
               f2Obj = getattr(fObj,f2)
               
               o = getattr(f2Obj,fileId)
               logging.debug(o);
               self.updateOrAddToFileBTree(o)
               return o
           return x
       
       def getFileObjectLastVersion(self,fileId):
           """get an object"""
           x=self.v_files_lastVersion.get(fileId)
           logging.debug("lastVersion: "+repr(x))
           if x==None:
               folder=fileId[0:3]
               f2=fileId[0:5]
               fObj = getattr(self.cdliRoot.cdli_main,folder);
               f2Obj = getattr(fObj,f2)
   
               o =getattr(f2Obj,fileId)
               logging.debug(o);
               return o.getLastVersion()
           
   
           return x
       
       def showFileIds(self):
           """showIds"""
           return self.v_file_ids
       
       def generateFileBTree(self):
           """erzeuge einen Btree aus allen Files"""
           self.v_files = OOBTree()
           self.v_files_lastVersion = OOBTree()
           self.v_file_ids = Set()
           
           for x in self.CDLICatalog.searchResults():
               
               self.v_files.update({x.getId:x.getObject()})
               self.v_files_lastVersion.update({x.getId:x.getObject().getLastVersion()})
               self.v_file_ids.add(x.getId)
               logging.debug("add:"+x.getId+"XXX"+repr(x.getObject()))
           
           return True
           
     def storeInLineIndex(self,key,value):  
         """store in index"""  
             
         if (not hasattr(self,'lineIndex')) or (type(self.lineIndex) is DictType):      def updateOrAddToFileBTree(self,obj):
             self.lineIndex=OOBTree()          """update a BTree"""
         li=self.lineIndex          self.v_files.update({obj.getId():obj})
           self.v_files_lastVersion.update({obj.getId():obj.getLastVersion()})
                   
         if li.has_key(key):          self.v_file_ids.add(obj.getId())
           #change everthing around to make it persistent...
           tmp = self.v_files
           self.v_files=tmp
                           
             if li[key].has_key(value[0]) and (not (value[1] in li[key][value[0]])):          tmp2=self.v_file_ids
                 li[key][value[0]].append(value[1]) # add it if now in the array          self.v_file_ids=tmp2
             else:  
                 li[key][value[0]]=[value[1]] # new array for lines          self.CDLICache.cleanCache() #be sure that the cache is clean
           logging.debug("update:"+obj.getId()+"XXX"+repr(obj))
   
   
       def deleteFromBTree(self,objId):
           """delete an obj"""
           self.v_files.pop(objId)
           self.v_files_lastVersion.pop(objId)
           self.v_file_ids.remove(objId)
                                   
         else:  
                           
             li[key]=OOBTree()# new btree for lines   
             li[key][value[0]]=[value[1]]       def deleteFiles(self,ids):
           """delete files"""
           for id in ids:
               founds=self.CDLICatalog.search({'title':id.split(".")[0]})
               if founds:
                   logging.debug("deleting %s"%founds)
                   folder=founds[0].getObject().aq_parent #get the parent folder of the object
                   logging.debug("deleting from %s"%folder)
                   cut=folder.delete([founds[0].getId]) #cut it out
   
                                           
                   
         self.lineIndex=li      def searchText(self, query, index='graphemes', resultFilter=None):
           """searches query in the fulltext index and returns a list of file IDs/P-numbers
              resultFilter is matched against the beginning of the file ID"""
           # see also: http://www.plope.com/Books/2_7Edition/SearchingZCatalog.stx#2-13
           logging.debug("searchtext for '%s' in index %s"%(query,index))
           #import Products.ZCTextIndex.QueryParser
           #qp = QueryParser.QueryParser()
           #logging.debug()
           idxQuery = {index:{'query':query}}
           idx = getattr(self, self.file_catalog)
           # do search
           resultset = idx.search(query_request=idxQuery,sort_index='textid')
           # put only the P-Number in the result
           if resultFilter is None:
               results = [res.getId[:7] for res in resultset]
           else:
               results = [res.getId[:7] for res in resultset if res.getId.startswith(resultFilter)]
           logging.debug("searchtext: found %d texts"%len(results))
           return results
   
   
       def getFile(self, pnum):
           """get the translit file with the given pnum"""
           f = getattr(self, self.file_catalog).search({'textid':pnum})
           if not f:
               return ""
             
         get_transaction().commit()          return f[0].getObject().getData()
                   
   
     def showFile(self,fileId):      def showFile(self,fileId,wholePage=False):
         """show a file"""          """show a file
         f=self.CDLICatalog({'title':fileId})          @param fileId: P-Number of the document to be displayed
           """
           f=getattr(self, self.file_catalog).search({'textid':fileId})
         if not f:          if not f:
             return ""              return ""
                   
           if wholePage:
               logging.debug("show whole page")
               return f[0].getObject().getContentObject().view()
           else:
         return f[0].getObject().getLastVersionFormattedData()          return f[0].getObject().getLastVersionFormattedData()
                   
   
       def showWordInFile(self,fileId,word,indexName='graphemes',regExp=False,):
           """get lines with word from FileId"""
           logging.debug("showwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
           
           file = formatAtfFullLineNum(self.getFile(fileId))
           ret=[]
           
           # add whitespace before and whitespace and line-end to splitter bounds expressions
           bounds = self.splitter[indexName].bounds
           splitexp = "(%s|\s)(%%s)(%s|\s|\Z)"%(bounds,bounds)
           # clean word expression 
           # TODO: this should use QueryParser itself
           # take out double quotes
           word = word.replace('"','')
           # take out ignorable signs
           ignorable = self.splitter[indexName].ignorex
           word = ignorable.sub('', word)
           # compile into regexp objects and escape parens
           wordlist = [re.compile(splitexp%re.escape(w)) for w in word.split(' ')]
               
           for line in file.splitlines():
               for word in wordlist:
                   #logging.debug("showwordinfile: searching for %s in %s"%(word.pattern,ignoreable.sub('',line)))
                   if word.search(ignorable.sub('',line)):
                       line = formatAtfLineHtml(line)
                       ret.append(line)
                       break
                       
           return ret
   
       
       def showWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
           """
           get lines with word from all ids in list FileIds.
           returns dict with id:lines pairs.
           """
           logging.debug("showwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds))
           
           return dict([(id,self.showWordInFile(id, word, indexName, regExp)) for id in fileIds])
       
   
       def tagWordInFile(self,fileId,word,indexName='graphemes',regExp=False):
           """get text with word highlighted from FileId"""
           logging.debug("tagwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
           
           file=self.getFile(fileId)
           tagStart=u'<span class="found">'
           tagEnd=u'</span>'
           tagStr=tagStart + u'%%s' + tagEnd
           ret=[]
           
           # add whitespace to splitter bounds expressions and compile into regexp object
           bounds = self.splitter[indexName].bounds
           wordsplit = re.compile("(%s|\s)"%bounds)
           # clean word expression 
           # TODO: this should use QueryParser itself
           word = word.replace('"','') # take out double quotes
           # take out ignoreable signs
           ignorable = self.splitter[indexName].ignorex
           word = ignorable.sub('', word)
           # split search terms by blanks
           words = word.split(' ')
           # split search terms again (for grapheme search with words)
           splitwords = dict(((w,self.splitter[indexName].process([w])) for w in words))
               
           for line in file.splitlines():
               line = unicodify(line)
               # ignore lemma and other lines
               if line.lstrip().startswith('#lem:'):
                   continue
               # ignore p-num line
               if line.startswith('&P') or line.startswith('&S'):
                   continue
               # ignore version lines
               if line.startswith('#version'):
                   continue
               # ignore atf type lines
               if line.startswith('#atf:'):
                   continue
   
               # first scan
               hitwords = []
               for w in words:
                   if ignorable.sub('',line).find(w) > -1:
                       # word is in line
                       # append split word for grapheme search with words
                       hitwords.extend(splitwords[w])
                       #hitwords.extend(wordsplit.split(w))
                      
               # examine hits closer
               if hitwords:
                   # split line into words
                   parts = wordsplit.split(line)
                   line = ""
                   for p in parts:
                       #logging.debug("tagwordinfile: searching for %s in %s"%(p,hitwords))
                       # reassemble line
                       if ignorable.sub('', p) in hitwords:
                           #logging.debug("tagwordinfile: found %s in %s"%(p,hitwords))
                           # this part was found
                           line += tagStart + formatAtfHtml(p) + tagEnd
                       else:
                           line += formatAtfHtml(p)
                   
               else:
                   # no hits
                   line = formatAtfHtml(line)
               
               ret.append(line)
                           
           return u'<br>\n'.join(ret)
   
   
   
       def tagWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
           """
           get texts with highlighted word from all ids in list FileIds.
           returns dict with id:text pairs.
           """
           logging.debug("tagwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds)) 
           return dict([(id,self.tagWordInFile(id, word, indexName, regExp)) for id in fileIds])
       
   
       def getFileVersionList(self, pnum):
           """get the version history as a list for the translit file with the given pnum"""
           f = getattr(self, self.file_catalog).search({'textid':pnum})
           if not f:
               return []
           
           return f[0].getObject().getVersionList()
            
   
     def URLquote(self,str):      def URLquote(self,str):
         """quote url"""          """quote url"""
         return urllib.quote(str)          return urllib.quote(str)
Line 1929  class CDLIRoot(Folder): Line 1080  class CDLIRoot(Folder):
         """unquote url"""          """unquote url"""
         return urllib.unquote(str)          return urllib.unquote(str)
           
       def URLquote_plus(self,str):
           """quote url"""
           return urllib.quote_plus(str)
       
       def URLunquote_plus(self,str):
           """unquote url"""
           return urllib.unquote_plus(str)
           
     def forceunlock(self):      def changeUserForPObjectFromFile(self,user,fname):
           """aendere user fuer alle p in fiele"""
           pns = file(os.path.join(package_home(globals()),'inputs',fname),"r")
           for p in pns.readlines():
               p=p.lstrip().rstrip()
               logging.info(str(p+".atf"))
               pObj=self.getFileObject(p+".atf")
               if pObj is not None:  
                   logging.info(pObj)
                   lv=pObj.getContentObject()
                   logging.info("author:"+lv.author)
                   lv.author=user
                   lv.versionComment="XXXXXXX"
       
       def forceunlock(self,REQUEST=None,user=None,fid=None):
         "break all locks"          "break all locks"
           if fid is not None:
               self.getFileObject(fid).forceunlock()
               return fid
         ret=[]          ret=[]
         for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):  
            un=f[1].forceunlock()  
   
           for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
              un=f[1].forceunlock(user=user)
              logging.info("check:"+f[0])
            if un and un !="":             if un and un !="":
                ret.append((f[0],un))                 ret.append((f[0],un))
   
           if REQUEST is not None:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','breakLockResponse.zpt')).__of__(self)
              
               return pt(ret=ret)
           
           return ret
                                           
   
       def getLockedFiles(self,REQUEST=None,user=None):
           """hole alle gesperrten files"""
           ret={}
       
           for nm,f in self.v_files.items():
               lb = str(f.lockedBy)
               add=False
               if (lb is not None) and (lb!=""):
                  
                   if user is None:
                       add=True
                   else:
                       if str(lb)==user:
                           add=True
                   if add==True:
                       if not ret.has_key(lb):
                           ret[lb]=[]
                       ret[lb].append(nm)
           
           
           if REQUEST is not None:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showlockResponse.zpt')).__of__(self)
              
               return pt(ret=ret)
           
         return ret                                 return ret                       
           
     def getChangesByAuthor(self,author,n=100):      def getChangesByAuthor(self,author,n=100):
Line 1984  class CDLIRoot(Folder): Line 1193  class CDLIRoot(Folder):
       
         return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)          return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
   
       def refreshTxtBasket(self,txt="",threadName=None):
           """txt fuer refresh"""
     
           return """ 2;url=%s?repeat=%s """%(txt,threadName)
   
           
     def getResult(self,threadName=None):      def getResult(self,threadName=None):
        """result of thread"""         """result of thread"""
Line 2002  class CDLIRoot(Folder): Line 1216  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 uploadATFAsync(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
           """upload an atf file / basket file"""
           #self._v_uploadATF.returnValue=None
           
          
           idTmp=str(randint(0,1000000000))
           
           if upload is None:
               return "ERROR NO FILE!"
           
           tmpFile = File("/tmp/idTmp","w")
           # sicher basket in file
           for x in upload.read():
               tmpFile.write(x)
           
           tmpFile.close();
           uploadATFAsync(baskerId,idTmp,basketId,self.REQUEST['AUTHENTICATED_USER'],idTmp,serverport=self.REQUEST['SERVER_PORT'])
           
           return idTMP   
           
       def viewTicketAsync(self,ticketNr=1):
           """viewticket"""
           
           tmp = pickle.load(file("/tmp/"+str(ticketNr)+".result"))
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheckAsync.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'],
                     basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                  
           
           
     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
           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)
               
       
         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 2019  class CDLIRoot(Folder): Line 1304  class CDLIRoot(Folder):
             self._v_uploadATF[threadName]=thread              self._v_uploadATF[threadName]=thread
             #self._xmltrans.start()              #self._xmltrans.start()
             #thread=Thread(target=self._v_uploadATF)              #thread=Thread(target=self._v_uploadATF)
                           logging.info("set thread. extern")
             self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])              self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],idTmp,serverport=self.REQUEST['SERVER_PORT'])
             #thread.start()              #thread.start()
               logging.info("start thread. extern")
             self._v_uploadATF[threadName].start()              self._v_uploadATF[threadName].start()
   
                           
Line 2043  class CDLIRoot(Folder): Line 1329  class CDLIRoot(Folder):
                          if threadName == thread.getName():                           if threadName == thread.getName():
                                        self._v_uploadATF[threadName]=thread                                         self._v_uploadATF[threadName]=thread
                                                                                 
             if not self._v_uploadATF[threadName].returnValue:              if self._v_uploadATF.get(threadName,None) and (not self._v_uploadATF[threadName].returnValue):
                   
   
                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
Line 2055  class CDLIRoot(Folder): Line 1341  class CDLIRoot(Folder):
                 return pt(txt='/uploadATF',threadName=threadName)                  return pt(txt='/uploadATF',threadName=threadName)
                                   
             else:              else:
 #                tmp={}                  tmp=getattr(self.temp_folder,idTmp).returnValue
 #                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=self._v_uploadATF[threadName].returnValue  
                   
                 self._v_uploadATF[threadName].continueVar=False  
                   
                 self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]  
                 self.REQUEST.SESSION['lockerrors']=[x[0].getId() for x in tmp['lockerrors']]  
                 self.REQUEST.SESSION['errors']=tmp['errors']  
                 self.REQUEST.SESSION['newPs']=tmp['newPs']  
                 self.REQUEST.SESSION['tmpdir']=tmp['dir']  
                 #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'],
                   basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])                    basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                                             
             
     def redoUpload(self,threadName):      def redoUpload(self,threadName):
        """redo the upload"""         """redo the upload"""
        tmp=self.cdli_main.tmpStore2[threadName]         tmp=self.cdli_main.tmpStore2[threadName]
Line 2092  class CDLIRoot(Folder): Line 1358  class CDLIRoot(Folder):
                                     
     def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):      def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
         """nowupload the files"""          """nowupload the files"""
          
          
          
         threadName=repeat          threadName=repeat
         if not threadName or threadName=="":          if not threadName or threadName=="":
             thread=uploadATFfinallyThread()              thread=uploadATFfinallyThread()
Line 2106  class CDLIRoot(Folder): Line 1369  class CDLIRoot(Folder):
   
             self._v_uploadATF[threadName]=thread              self._v_uploadATF[threadName]=thread
   
                       idTmp=self.REQUEST.SESSION['idTmp']
             self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])              stObj=getattr(self.temp_folder,idTmp)
               self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=stObj.returnValue,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
   
             self._v_uploadATF[threadName].start()              self._v_uploadATF[threadName].start()
   
Line 2141  class CDLIRoot(Folder): Line 1405  class CDLIRoot(Folder):
                 return pt(txt='/uploadATFfinally',threadName=threadName)                  return pt(txt='/uploadATFfinally',threadName=threadName)
             else:              else:
   
                
                 idTmp=self.REQUEST.SESSION['idTmp']
                 stObj=getattr(self.temp_folder,idTmp) 
                 self.REQUEST.SESSION['idTmp']=None
                
                 #update changed
                 logging.debug("dir:"+repr(stObj.returnValue['changed']))
                 for x in stObj.returnValue['changed']:
                       ob=self.CDLICatalog.search({'title':x[0]})
                       try:
                           self.cdliRoot.updateOrAddToFileBTree(ob[0].getObject())
                       except:
                  
                           logging.error("uploadATFfinally - cannot update Object %s Error: %s %s"%(ob[1],sys.exc_info()[0],sys.exc_info()[1]))
                 for x in stObj.returnValue['newPs']:
                     obj=self.getFileObject(x) #updates the object in the cache
                     logging.debug("Got:"+repr(obj))
               if RESPONSE is not None:                if RESPONSE is not None:
                   RESPONSE.redirect(self.absolute_url())                    RESPONSE.redirect(self.absolute_url())
   
     def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):      def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):
         """import files"""          """import files"""
           logging.debug("importFiles folderName=%s files=%s ext=%s"%(folderName,files,ext))
         root=self.cdli_main          root=self.cdli_main
         count=0          count=0
         if not files:          if not files:
Line 2154  class CDLIRoot(Folder): Line 1436  class CDLIRoot(Folder):
         for f in files:          for f in files:
             folder=f[0:3]              folder=f[0:3]
             f2=f[0:5]              f2=f[0:5]
               
               #check if main folder PXX already exists
             obj=self.ZopeFind(root,obj_ids=[folder])              obj=self.ZopeFind(root,obj_ids=[folder])
               logging.debug("importFiles: folder=%s f2=%s obj=%s"%(folder,f2,obj)) 
             if ext:              if ext:
       
                 ext.result+="<p>adding: %s </p>"%f                  if type(ext.result) is types.FileType:
             if not obj:                      ext.result.write("<p>adding: %s </p>\n"%f)
                   else:
                       ext.result="<p>adding: %s </p>"%f+ext.result
   
               
               if not obj: # if not create it
                 manage_addCDLIFileFolder(root,folder,folder)                  manage_addCDLIFileFolder(root,folder,folder)
                 fobj=getattr(root,folder)                  fobj=getattr(root,folder)
                 #get_transaction().commit()                                             #transaction.get().commit()                           
   
             else:              else:
                 fobj=obj[0][1]                  fobj=obj[0][1]
                           
               #check IF PYYYYY already exist
             obj2=fobj.ZopeFind(fobj,obj_ids=[f2])              obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
               logging.debug("importFiles: fobj=%s obj2=%s"%(fobj,obj2)) 
                   
             if not obj2:              if not obj2:# if not create it
                 manage_addCDLIFileFolder(fobj,f2,f2)                  manage_addCDLIFileFolder(fobj,f2,f2)
                 fobj2=getattr(fobj,f2)                  fobj2=getattr(fobj,f2)
                   
             else:              else:
                 fobj2=obj2[0][1]                  fobj2=obj2[0][1]
                               
               # not add the file
             file2=os.path.join(folderName,f)                file2=os.path.join(folderName,f)  
             id=f              id=f
             manage_addCDLIFile(fobj2,f,'','')              logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))
             id=f              fobj2.addFile(vC='',file=file(file2),author=author,newName=f)
             ob=fobj2._getOb(f)              logging.debug("importfiles: fobj2.add")
             ob.title=id  
               
             manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='',from_tmp=True)  
             self.CDLICatalog.catalog_object(ob)  
             #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)  
             #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])  
         count+=1          count+=1
   
         if count > 1000:              #now add the file to the storage
         print "committing"              ob = getattr(fobj2,f)
         get_transaction().commit()              logging.debug("importfiles: btree_start")
         count=0              #self.cdliRoot.updateOrAddToFileBTree(ob)
     get_transaction().commit()              logging.debug("importfiles: btree_end")
               if count%100==0:
                   logging.debug("importfiles: committing")
                   transaction.get().commit()
   
           logging.debug("importfiles: committing")
           transaction.get().commit()
           logging.debug("importfiles: committing done")
         return "ok"          return "ok"
                     
   
Line 2211  def manage_addCDLIRoot(self, id, title=' Line 1506  def manage_addCDLIRoot(self, id, title='
     ob=CDLIRoot()      ob=CDLIRoot()
     ob.id=str(id)      ob.id=str(id)
     ob.title=title      ob.title=title
       try:
     self._setObject(id, ob)      self._setObject(id, ob)
       except:
           pass
     ob=self._getOb(id)      ob=self._getOb(id)
   
     checkPermission=getSecurityManager().checkPermission      checkPermission=getSecurityManager().checkPermission
Line 2227  def manage_addCDLIRoot(self, id, title=' Line 1525  def manage_addCDLIRoot(self, id, title='
     if REQUEST is not None:      if REQUEST is not None:
         return self.manage_main(self, REQUEST, update_menu=1)              return self.manage_main(self, REQUEST, update_menu=1)    
     
    
   import cdli_basket
   
   
   # Die folgenden Klassen sollte nicht mehr aus diesem Paket benutzt werden, sondern direkt aus
   # cdli_basket importiert werden.
   class uploadATFfinallyThread(cdli_basket.uploadATFfinallyThread):
       """depricates"""
       pass
   
   class tmpStore(cdli_basket.tmpStore):
       """depricated"""
       pass
   
   class uploadATFThread(cdli_basket.uploadATFThread):
       """depricated"""
       pass
   
   class CDLIBasketContainer(cdli_basket.CDLIBasketContainer):
       """depricated"""
       pass
   
   class CDLIBasket(cdli_basket.CDLIBasket):
       """depricated"""
       pass
   
   class CDLIBasketVersion(cdli_basket.CDLIBasketVersion):
       """depricated"""
       pass
   
   class BasketContent(cdli_basket.BasketContent):
       """depricated"""
       pass
       
Removed from v.1.53  
changed lines
  Added in v.1.119

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