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

Diff for /cdli/cdli_files.py between versions 1.37 and 1.80.2.3

version 1.37, 2006/07/14 19:08:30 version 1.80.2.3, 2007/10/22 16:26:40
Line 1 Line 1
 """CDLI extensions of the filearchive"""      """CDLI extensions of the filearchive"""    
 from Products.versionedFile.versionedFile import *  from Products.versionedFile.extVersionedFile import *
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
 from tempfile import mkstemp,mkdtemp      from tempfile import mkstemp,mkdtemp    
 import os.path  import os.path
 import os  import os
 from types import *  from types import *
 import urlparse  import urlparse
   import urllib
   import cgi
 from OFS.OrderedFolder import OrderedFolder  from OFS.OrderedFolder import OrderedFolder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 import time  import time
Line 13  from OFS.Folder import manage_addFolder Line 15  from OFS.Folder import manage_addFolder
 import re  import re
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
 from Acquisition import Implicit  from Acquisition import Implicit
   from Globals import Persistent
 from threading import Thread  from threading import Thread
 from ZPublisher.HTTPRequest import HTTPRequest  from ZPublisher.HTTPRequest import HTTPRequest
 from ZPublisher.HTTPResponse import HTTPResponse  from ZPublisher.HTTPResponse import HTTPResponse
 from ZPublisher.BaseRequest import RequestContainer  from ZPublisher.BaseRequest import RequestContainer
 import threading  import threading
   from BTrees.OOBTree import OOBTree
   import logging
   import transaction
   import copy
   import codecs
   import sys
   
   def unicodify(s):
       """decode str (utf-8 or latin-1 representation) into unicode object"""
       if not s:
           return u""
       if isinstance(s, str):
           try:
               return s.decode('utf-8')
           except:
               return s.decode('latin-1')
       else:
           return s
   
   def utf8ify(s):
       """encode unicode object or string into byte string in utf-8 representation.
          assumes string objects to be utf-8"""
       if not s:
           return ""
       if isinstance(s, str):
           return s
       else:
           return s.encode('utf-8')
   
   
   def generateXMLReturn(hash):
       """erzeugt das xml file als returnwert fuer uploadATFRPC"""
   
       ret="<return>"
       
       ret+="<errors>"
       for error in hash['errors']:
           ret+="""<error atf="%s">%s</error>"""%error
       
       ret+="</errors>"
       
       ret+="<changes>"
       for changed in hash['changed']:
           ret+="""<change atf="%s">%s</change>"""%changed
       ret+="</changes>"
       
       ret+="<newPs>"
       for new in hash['newPs']:
           ret+="""<new atf="%s"/>"""%new
       ret+="</newPs>"
       
       ret+="</return>"
       return ret
       
       
       
           
   
   
       
       
       
       
   def unique(s):
       """Return a list of the elements in s, but without duplicates.
   
       For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
       unique("abcabc") some permutation of ["a", "b", "c"], and
       unique(([1, 2], [2, 3], [1, 2])) some permutation of
       [[2, 3], [1, 2]].
   
       For best speed, all sequence elements should be hashable.  Then
       unique() will usually work in linear time.
   
       If not possible, the sequence elements should enjoy a total
       ordering, and if list(s).sort() doesn't raise TypeError it's
       assumed that they do enjoy a total ordering.  Then unique() will
       usually work in O(N*log2(N)) time.
   
       If that's not possible either, the sequence elements must support
       equality-testing.  Then unique() will usually work in quadratic
       time.
       (from the python cookbook)
       """
   
       n = len(s)
       if n == 0:
           return []
   
       # Try using a dict first, as that's the fastest and will usually
       # work.  If it doesn't work, it will usually fail quickly, so it
       # usually doesn't cost much to *try* it.  It requires that all the
       # sequence elements be hashable, and support equality comparison.
       u = {}
       try:
           for x in s:
               u[x] = 1
       except TypeError:
           del u  # move on to the next method
       else:
           return u.keys()
   
       # We can't hash all the elements.  Second fastest is to sort,
       # which brings the equal elements together; then duplicates are
       # easy to weed out in a single pass.
       # NOTE:  Python's list.sort() was designed to be efficient in the
       # presence of many duplicate elements.  This isn't true of all
       # sort functions in all languages or libraries, so this approach
       # is more effective in Python than it may be elsewhere.
       try:
           t = list(s)
           t.sort()
       except TypeError:
           del t  # move on to the next method
       else:
           assert n > 0
           last = t[0]
           lasti = i = 1
           while i < n:
               if t[i] != last:
                   t[lasti] = last = t[i]
                   lasti += 1
               i += 1
           return t[:lasti]
   
       # Brute force is all that's left.
       u = []
       for x in s:
           if x not in u:
               u.append(x)
       return u
   
   
   class BasketContent(SimpleItem):
       """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 uploadATFfinallyThread(Thread):
     """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""      """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
           
Line 41  class uploadATFfinallyThread(Thread): Line 195  class uploadATFfinallyThread(Thread):
         self.username=username          self.username=username
         self.serverport=serverport          self.serverport=serverport
                   
           
     def __call__(self):      def __call__(self):
         """call of the thread (equals run)"""          """call of the thread (equals run)"""
         self.run()          self.run()
Line 73  class uploadATFfinallyThread(Thread): Line 228  class uploadATFfinallyThread(Thread):
         #add the files          #add the files
         self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)          self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
         #commit the transactions          #commit the transactions
         get_transaction().commit()          transaction.get().commit()
         conn.close()          conn.close()
         #set flag for end of this method          #set flag for end of this method
         self.end=True          self.end=True
           logging.info("ended")
         return True          return True
           
     def __del__(self):      def __del__(self):
Line 97  class uploadATFfinallyThread(Thread): Line 253  class uploadATFfinallyThread(Thread):
         self.result+="<h2>Start processing</h2>"          self.result+="<h2>Start processing</h2>"
                   
         #shall I only upload the changed files?          #shall I only upload the changed files?
           logging.info("uploadATFfinally procedure: %s"%procedure)
         if procedure=="uploadchanged":          if procedure=="uploadchanged":
                     changed=[x[0] for x in SESSION.get('changed',[])]
             uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])              uploadFns=changed+SESSION.get('newPs',[])
                   
         #or all          #or all
         elif procedure=="uploadAll":          elif procedure=="uploadAll":
             uploadFns=[]              uploadFns=[]
             for x in os.listdir(SESSION['tmpdir']):              for x in os.listdir(SESSION['tmpdir']):
                 if not x in SESSION['errors']:                  if not x in SESSION['lockerrors']:
                     uploadFns.append(x)                      uploadFns.append(x)
                                           
         #or maybe nothing          #or maybe nothing
Line 115  class uploadATFfinallyThread(Thread): Line 272  class uploadATFfinallyThread(Thread):
             uploadFns=[]              uploadFns=[]
                           
         #do first the changed files              #do first the changed files    
           i=0
         for fn in uploadFns:          for fn in uploadFns:
               i+=1
             founds=ctx2.CDLICatalog.search({'title':fn})              founds=ctx2.CDLICatalog.search({'title':fn})
             if len(founds)>0:              if len(founds)>0:
                 SESSION['author']=str(username)                  SESSION['author']=str(username)
                 self.result+="<p>Changing : %s"%fn                  self.result="<p>Changing : %s"%fn+self.result
                 founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=file(os.path.join(SESSION['tmpdir'],fn)))                  founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
               if i==200:
                           i=0
                           transaction.get().commit()
                           logging.info("changing: do commit")
                           
           transaction.get().commit()
           logging.info("changing: last commit")
                   
         #now add the new files                  #now add the new files        
         newPs=SESSION['newPs']          newPs=SESSION['newPs']
         if len(newPs)>0:          if len(newPs)>0:
             tmpDir=SESSION['tmpdir']              tmpDir=SESSION['tmpdir']
             self.result+="<p>Adding files</p>"              logging.info("adding start")
               self.result="<p>Adding files</p>"+self.result
             #TODO: make this configurable, at the moment base folder for the files has to be cdli_main              #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)              ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
                               logging.info("adding finished")
                   
                   
         #unlock locked files?          #unlock locked files?
         if unlock:          if unlock:
             self.result+="<p>Unlock files</p>"              logging.info("unlocking start")
               self.result="<p>Unlock files</p>"+self.result
             unlockFns=[]              unlockFns=[]
             for x in os.listdir(SESSION['tmpdir']):              for x in os.listdir(SESSION['tmpdir']):
                     if not x in SESSION['errors']:                      if not x in SESSION['errors']:
                         unlockFns.append(x)                          unlockFns.append(x)
               logging.info("unlocking have now what to unlock")
                           
             for fn in unlockFns:              for fn in unlockFns:
                   #logging.info("will unlock: %s"%fn)
                 founds=ctx2.CDLICatalog.search({'title':fn})                  founds=ctx2.CDLICatalog.search({'title':fn})
                   #logging.info("found it: %s"%repr(founds))
                 if len(founds)>0:                  if len(founds)>0:
                       #logging.info("unlock: %s"%founds[0].getObject().getId())
                     SESSION['author']=str(username)                      SESSION['author']=str(username)
                                         
                     founds[0].getObject().lockedBy=""                      founds[0].getObject().lockedBy=""
               logging.info("unlocking done")
                                           
         #if a basketname is give, add files to the basket          #if a basketname is given, add files to the basket
         if not (basketname ==''):          if not (basketname ==''):
             self.result+="<p>Add basket</p>"              logging.info("add to basket %s"%basketname)
               self.result="<p>Add to basket</p>"+self.result
             basketId=ctx2.basketContainer.getBasketIdfromName(basketname)              basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
                           
             if not basketId: # create new basket              if not basketId: # create new basket
                   logging.info("create basket %s"%basketname)
                   self.result="<p>Create a new basket</p>"+self.result
                 ob=ctx2.basketContainer.addBasket(basketname)                  ob=ctx2.basketContainer.addBasket(basketname)
                 basketId=ob.getId()                  basketId=ob.getId()
             basket=getattr(ctx2.basketContainer,str(basketId))              basket=getattr(ctx2.basketContainer,str(basketId))
Line 165  class uploadATFfinallyThread(Thread): Line 340  class uploadATFfinallyThread(Thread):
             RESPONSE.redirect(self.aq_parent.absolute_url())              RESPONSE.redirect(self.aq_parent.absolute_url())
                   
   
                  logging.info("uploadfinally done")
         return True          return True
           
   class tmpStore(SimpleItem):
       """simple item"""
       meta_type="cdli_upload"
       
       def __init__(self,id):
           """init tmp"""
           self.id=id
           
 class uploadATFThread(Thread):  class uploadATFThread(Thread):
     """class for checking the files befor uploading"""      """class for checking the files befor uploading"""
           
Line 180  class uploadATFThread(Thread): Line 363  class uploadATFThread(Thread):
         Thread.__init__(self)          Thread.__init__(self)
                   
                   
     def set(self,upload,basketId,username,serverport="8080"):      def set(self,upload,basketId,username,idTmp,serverport="8080"):
         """set start values for the thread"""          """set start values for the thread"""
         self.result=""          self.result=""
         self.upload=upload          self.upload=upload
         self.basketId=basketId          self.basketId=basketId
         self.username=username          self.username=username
         self.serverport=serverport          self.serverport=serverport
           self.idTmp=idTmp
                   
     def __call__(self):      def __call__(self):
         """call method """          """call method """
Line 205  class uploadATFThread(Thread): Line 389  class uploadATFThread(Thread):
         return app.__of__(RequestContainer(REQUEST = req))          return app.__of__(RequestContainer(REQUEST = req))
                   
     def run(self):      def run(self):
                idTmp=self.idTmp
         self.result=""          self.result=""
         #find context within ZODB          #find context within ZODB
         from Zope import DB          from Zope import DB
Line 213  class uploadATFThread(Thread): Line 397  class uploadATFThread(Thread):
         root = conn.root()          root = conn.root()
         app  = root['Application']          app  = root['Application']
         ctx = self.getContext(app,serverport=self.serverport)          ctx = self.getContext(app,serverport=self.serverport)
         self.uploadATFThread(ctx,self.upload,self.basketId)          logging.info("run intern")
           try:
               logging.info("created: %s"%idTmp)
               ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
           except:
               logging.error("thread upload: %s %s"%sys.exc_info()[0:2])
               
           logging.info("call thread intern")
           self.uploadATFThread(ctx,self.upload,idTmp,self.basketId)
             
         #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue          #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
   
         get_transaction().commit()  
                   
         while self.continueVar:          transaction.get().commit()
             pass  
                   
         conn.close()          conn.close()
                   
           return getattr(ctx.temp_folder,idTmp)
                   
     def getResult(self):      def getResult(self):
         """method for accessing result"""          """method for accessing result"""
         return self.result          return self.result
           
     def uploadATFThread(self,ctx,upload,basketId=0):      def uploadATFThread(self,ctx,upload,idTmp,basketId=0):
         """upload an atf file"""          """upload an atf file"""
         #TODO: add comments          #TODO: add comments
         #TODO: finish uploadATF          #TODO: finish uploadATF
           
           stObj=getattr(ctx.temp_folder,idTmp)
           logging.info("start, upload thread")
         self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"          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          #make sure that id is a string and not an integer
Line 247  class uploadATFThread(Thread): Line 441  class uploadATFThread(Thread):
                   
         changed=[] # changed files          changed=[] # changed files
         errors=[]  # files with errors          errors=[]  # files with errors
           lockerrors=[]  # files with errors
   
         newPs=[]   # new p filed          newPs=[]   # new p filed
         psNotInCatalog=[] # files not in the catalog          psNotInCatalog=[] # files not in the catalog
                   
Line 261  class uploadATFThread(Thread): Line 457  class uploadATFThread(Thread):
             if basketObj:              if basketObj:
                 basketId=basketObj.getId()                  basketId=basketObj.getId()
                                   
         #if there is no active baske and no basketid given, id is empty, else get besketname and length          #if there is no active basket and no basketid given, id is empty, else get besketname and length
         if basketId == '0':          if basketId == '0':
             basketNameFromId=""              basketNameFromId=""
             basketLen=0              basketLen=0
Line 269  class uploadATFThread(Thread): Line 465  class uploadATFThread(Thread):
             basketNameFromId=getattr(ctx2.basketContainer,basketId).title              basketNameFromId=getattr(ctx2.basketContainer,basketId).title
             basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()              basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
                           
                   logging.info("got the file, upload thread")
         self.result+="""<html><body><h2>I got the files</h2><          self.result+="""<html><body><h2>I got the files</h2><
                         p>I am computing the differences to the exisiting files</p>"""                          p>I am computing the differences to the exisiting files</p>"""
                                                                         
         #start to check the files          #start to check the files
         for fn in os.listdir(dir):          for fn in os.listdir(dir):
                           
             self.result+="<p>process:%s</p>"%fn              self.result="<p>process:%s</p>"%fn+self.result
                           
             # check if file is in the catalog              # check if file is in the catalog
             #TODO: checkCatalog is not implemented yet              #TODO: checkCatalog is not implemented yet
Line 287  class uploadATFThread(Thread): Line 483  class uploadATFThread(Thread):
             founds=ctx2.CDLICatalog.search({'title':fn})                  founds=ctx2.CDLICatalog.search({'title':fn})    
               
             #if not than add filename to the list of newfiles              #if not than add filename to the list of newfiles
               
               data=file(os.path.join(dir,fn)).read()
               status,msg=checkFile(fn,data,dir)
               #status=True
               
               
               if not status: # error
                   errors.append((fn,msg))
               
               else:
             if len(founds)==0:              if len(founds)==0:
                 newPs.append(fn)                  newPs.append(fn)
                           
Line 296  class uploadATFThread(Thread): Line 502  class uploadATFThread(Thread):
                 obj=found.getObject()                  obj=found.getObject()
   
                 if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):                  if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
                     errors.append(obj)                                  lockerrors.append((fn,str(obj.lockedBy)))
                 else:                  else:
                     data=file(os.path.join(dir,fn)).read()                  
                     diffs=obj.diff(data)                      diffs=obj.diff(data)
                     if diffs[0]>0:                      if diffs[0]>0:
                         changed.append((obj,diffs))                              changed.append((obj,diffs)) #hochladen
                         #hochladen  
                   
         #ready, set the returnValues          #ready, set the returnValues
         self.result+="<h3>Done</h3></body></html>"          self.result+="<h3>Done</h3></body></html>"
                   
         self.returnValue={}          stObj.returnValue={}
         self.returnValue['changed']=changed  
         self.returnValue['errors']=errors  
         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"""  
         return len(self.contents)  
       
     def addObjects(self,ids):  
         """addObjects"""  
                   
         for id in ids:          stObj.returnValue['errors']=errors
             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          stObj.returnValue['newPs']=newPs
           stObj.returnValue['tmpdir']=dir
     def index_html(self):          stObj.returnValue['basketLen']=basketLen
                 """view the basket"""          stObj.returnValue['numberOfFiles']=numberOfFiles
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)          stObj.returnValue['basketNameFromId']=basketNameFromId
                 return pt()          stObj.returnValue['basketNameFromFile']=basketNameFromFile
           stObj.returnValue['basketId']=basketId
           stObj.returnValue['dir']=dir
           #stObj.returnValue['changed']=copy.copy(changed)
           stObj.returnValue['changed']=[(x[0].getId(),x[1][0]) for x in changed]
           #stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors]
           stObj.returnValue['lockerrors']=[x for x in lockerrors]
           self.returnValue=True
           #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
   
     def deleteObjects(self,ids,RESPONSE=None):  
         """delete objects"""  
         list = self.contents[0:]  
         for content in list:  
                                 
                 if content.getId() in ids:  class CDLIBasketContainer(OrderedFolder):
                     self.contents.remove(content)      """contains the baskets"""
                   
   
         if RESPONSE:      security=ClassSecurityInfo()
                     RESPONSE.redirect(self.absolute_url())      meta_type="CDLIBasketContainer"
   
       def getPNumbersOfBasket(self,basketName):
           """get all pnumbers of a basket as a list, returns an empty list if basket not found
           @param basketName: name of the basket
           """
           ret=[]
           basketId=self.getBasketIdfromName(basketName)
           if not basketId:
               return []
   
     def unlockTest(self):          ob=getattr(self,basketId).getContent()
         """unlock all files of the testuser for debuggin"""  
         for object in self.contents:  
   
                 if str(object.lockedBy)=="test":          ret=[x[0].split(".")[0] for x in ob]
                     object.lockedBy=""  
                           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):          return ret
         """download all selected files in one file"""  
                   
       security.declareProtected('manage','getBasketAsOneFile')       
       def getBasketAsOneFile(self,basketName,current="no"):
           """returns all files of the basket combined in one file
           @param basketName: Name of the basket
           @param current: (optional) if current is set to "yes" then the most current version of 
                           all files are downloaded and not the versions of the files as stored in the basket
           """
         ret=""          ret=""
         lockedObjects={}          basketId=self.getBasketIdfromName(basketName)
                   if not basketId:
               return ""
         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"   
           
   
         for object in self.contents:  
               
                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     ret+=object.getLastVersion().data  
                   
                 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)      
           
           
 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:          ob=getattr(self,basketId).getLastVersion()
         RESPONSE.redirect('manage_main')          for object in ob.getContent():
               if current=="no": #version as they are in the basket
                               ret+=str(object[0].getData())+"\n"
               elif current=="yes":
                               #search current object
                               logging.info("crrent: %s"%object[1].getId().split(".")[0])
                               founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
                               if len(founds)>0:      
                                   ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
           return ret
   
       security.declareProtected('manage','upDateBaskets') 
       def upDateBaskets(self):
           """update content in to objects"""
   
 class CDLIBasketContainer(OrderedFolder):          founds=self.ZopeFind(self,obj_metatypes=['CDLIBasketVersion'],search_sub=1)
     """contains the baskets"""  
       
   
     security=ClassSecurityInfo()          for found in founds:
     meta_type="CDLIBasketContainer"              found[1].updateBasket()
           
     security.declareProtected('manage','deleteBaskets')              security.declareProtected('manage','deleteBaskets')        
     def deleteBaskets(self,ids=None):      def deleteBaskets(self,ids=None):
Line 579  class CDLIBasketContainer(OrderedFolder) Line 606  class CDLIBasketContainer(OrderedFolder)
         trash.manage_pasteObjects(cut)          trash.manage_pasteObjects(cut)
                   
     security.declareProtected('manage','manageBaskets')             security.declareProtected('manage','manageBaskets')       
     def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):      def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):
         """manage baskets, delete or copy"""          """manage baskets, delete or copy"""
         if submit=="delete":          if submit=="delete":
             self.deleteBaskets(ids)              self.deleteBaskets(ids)
                   
                  elif submit=="join":
               flag,msg=self.joinBasket(joinBasket, ids)
               logging.info("joining %s %s"%(flag,msg))
               
           elif submit=="subtract":
               logging.info("BBBb %s %s"%(basket1,basket2))
               flag,msg=self.subtractBasket(subtractBasket, basket1,basket2)
               logging.info("subtract %s %s"%(flag,msg))
                           
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect(self.absolute_url())              RESPONSE.redirect(self.absolute_url())
Line 615  class CDLIBasketContainer(OrderedFolder) Line 649  class CDLIBasketContainer(OrderedFolder)
         return pt(basketId=basketId,basketName=basketName)          return pt(basketId=basketId,basketName=basketName)
         
   
     security.declareProtected('View','index_html')          security.declareProtected('manage','index_html')    
     def index_html(self):      def index_html(self):
         """stanadard ansicht"""          """stanadard ansicht"""
                   
Line 638  class CDLIBasketContainer(OrderedFolder) Line 672  class CDLIBasketContainer(OrderedFolder)
         self.title=title          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'):      def getBaskets(self,sortField='title'):
         """get all baskets files"""          """get all baskets files"""
   
Line 693  class CDLIBasketContainer(OrderedFolder) Line 739  class CDLIBasketContainer(OrderedFolder)
             baskets.sort(sortAuthor)              baskets.sort(sortAuthor)
         elif sortField=='comment':          elif sortField=='comment':
             baskets.sort(sortComment)              baskets.sort(sortComment)
         print "got the baskets"  
         return baskets          return baskets
   
   
       def subtractBasket(self,newBasket,basket1,basket2):
           """subtract basket2 from basket1 
           (i.e. newbasket will contain alle elements of basket1 which are not in basket2), 
           if basket2 contains files which are not in basket1, then theses files fill be ignored
                  
           @param newbasket: name of the new basket
           @param basket1: basket where basket2 will be subtracted from
           @param basket2: see above
         
           """
           logging.info("CCCCC %s %s"%(basket1,basket2))
      
           try:
               newB=self.addBasket(newBasket)
           except:
               return False, "cannot create the new basket"
           
           
   
          
        
           bas2= getattr(self,basket2)            
           bas2content=bas2.getContent()
           bas2ids=[x[0] for x in bas2content]
           
          
               
           bas1= getattr(self,basket1)   
           bas1content=bas1.getContent()
           
           
           newBasketContent={}
           
           for id,version in bas1content:
               if not (id in bas2ids):
                   newBasketContent[id]=version
           
           username=self.getActualUserName()
           
           logging.info("sbc %s"%newBasketContent)
           newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
           
           return True, ""
       
               
       def joinBasket(self,newBasket,oldBaskets):
           """join two baskets
           @param newbasket: name of the new basket
           @param oldbaskets: list of baskets to be joined
           """
           try:
               newB=self.addBasket(newBasket)
           except:
               return False, "cannot create the new basket"
           
           newBasketContent={}
           for ob in oldBaskets:
               x= getattr(self,ob,None)
               if x is None:
                   return False, "cannot find basket: %s"%ob
               
               ids=x.getContent() # hole den Inhalt
               
               for id,version in ids:
                   if newBasketContent.has_key(id): # p number gibt's schon
                       newBasketContent[id]=max(newBasketContent[id],version) # speichere die groessere Versionsnumber
                   else:
                       newBasketContent[id]=version
           username=self.getActualUserName()
           
           logging.info("nbc %s"%newBasketContent)
           newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
           
           return True, ""
                                                 
     def getNewId(self):      def getNewId(self):
         """createIds"""          """createIds"""
Line 711  class CDLIBasketContainer(OrderedFolder) Line 831  class CDLIBasketContainer(OrderedFolder)
     def setActiveBasket(self,basketId,REQUEST=None):      def setActiveBasket(self,basketId,REQUEST=None):
         """store active basketId in a cookie"""          """store active basketId in a cookie"""
         self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")          self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
                   try:
               qs=cgi.parse_qs(REQUEST['QUERY_STRING'])
               del(qs['basketId'])
           except:
               qs={}
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+REQUEST['QUERY_STRING'])              REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+urllib.urlencode(qs))
                           
     def getActiveBasket(self):      def getActiveBasket(self):
         """get active basket from cookie"""          """get active basket from cookie"""
Line 729  class CDLIBasketContainer(OrderedFolder) Line 853  class CDLIBasketContainer(OrderedFolder)
         """get name of the actualuser"""          """get name of the actualuser"""
         return str(self.REQUEST['AUTHENTICATED_USER'])          return str(self.REQUEST['AUTHENTICATED_USER'])
           
           security.declareProtected('manage','addBasket') 
     def addBasket(self,newBasketName):      def addBasket(self,newBasketName):
         """add a new basket"""          """add a new basket"""
                   
Line 785  class CDLIBasket(Folder,CatalogAware): Line 909  class CDLIBasket(Folder,CatalogAware):
     meta_type="CDLIBasket"      meta_type="CDLIBasket"
     default_catalog="CDLIBasketCatalog"      default_catalog="CDLIBasketCatalog"
           
       def searchInBasket(self,indexName,searchStr,regExp=False):
           """searchInBasket"""
   
           lst=self.searchInLineIndexDocs(indexName,searchStr,uniq=True,regExp=regExp) #TODO: fix this
           ret={}
           
           lv=self.getLastVersion()
   
   
           for obj in lv.content.getContent():
               id=obj[1].getId().split(".")[0]
               if id in lst:
           
                   ret[id]=self.showWordInFile(id,searchStr,lineList=self.getLinesFromIndex(indexName,searchStr,id,regExp=regExp),regExp=regExp,indexName=indexName)
           
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','searchResultsInBasket')).__of__(self)
           return pt(result=ret,indexName=indexName,regExp=regExp,word=searchStr)
           
            
    
           
       def searchInBasket_v1(self,searchStr):
           """search occurences of searchStr in files im basket"""
           ret=[]
           lv=self.getLastVersion()
           logging.info("searching")
           for obj in lv.content.getContent():
               txt=obj[0].getData()
               for x in txt.split("\n"):
                   logging.info("search %s"%x)
                   if re.match(searchStr,x):
                       ret.append(x)
           
           return "\n".join(ret)
                   
               
     def getFile(self,obj):      def getFile(self,obj):
         return obj[1]          return obj[1]
           
Line 836  class CDLIBasket(Folder,CatalogAware): Line 997  class CDLIBasket(Folder,CatalogAware):
         self.shortDescription=shortDescription          self.shortDescription=shortDescription
         self.comment=comment          self.comment=comment
     
       def getActualUserName(self):
           """get name of the actualuser"""
          
           return str(self.REQUEST['AUTHENTICATED_USER'])
         
                         
     def getLastVersion(self):      def getLastVersion(self):
         """hole letzte version"""          """hole letzte version"""
         ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])]  
           ids=[]
           idsTmp= self.objectIds()
           for x in idsTmp:
               try:
                   ids.append(int(x))
               except:
                   pass
         ids.sort()          ids.sort()
         
         if len(ids)==0:          if len(ids)==0:
             return None              return None
         else:              else:    
             ob=getattr(self,str(ids[-1]))              ob=getattr(self,str(ids[-1]))
   
               
             return ob              return ob
         
     def getVersions(self):      def getVersions(self):
Line 860  class CDLIBasket(Folder,CatalogAware): Line 1035  class CDLIBasket(Folder,CatalogAware):
             ids=[ids]              ids=[ids]
                 
         lastVersion=self.getLastVersion()           lastVersion=self.getLastVersion() 
         oldContent=lastVersion.basketContent[0:]          oldContent=lastVersion.content.getContent()
         newContent=[]          newContent=[]
                   
         #first copy the old          #first copy the old
Line 883  class CDLIBasket(Folder,CatalogAware): Line 1058  class CDLIBasket(Folder,CatalogAware):
                   
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)          ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
                   
         if RESPONSE:  
             obj=self._getOb(ob.getId())              obj=self._getOb(ob.getId())
           if RESPONSE:
              
             RESPONSE.redirect(obj.absolute_url())              RESPONSE.redirect(obj.absolute_url())
                           
           return obj
       
       def addObjectsWithVersion(self,ids,deleteOld=None,username=None,catalog=None):
           """generate a new version of the basket with objects added, 
           hier wird jedoch nicht die letzte Version jedes Files hinzugefuegt, s
           ondern ids is ein Tupel mit der Id (d.h. der p-number) und der Versionsnummer.
           """
           logging.info("add to basket (%s)"%(self.getId()))
           lastVersion=self.getLastVersion()
           
           if not catalog:
               catalog=self.CDLICatalog
               
           if lastVersion is None:
               oldContent=[]
           else:
               oldContent=lastVersion.content.getContent()
   
           if deleteOld:
               oldContent=[]
   
           newContent=[]
           added=0
          
           for id,version in ids.iteritems():
               logging.info("adding %s %s"%(id,version))
               id=id.split(".")[0] # title nur die pnumber ohne atf
              
               try:
                   founds=catalog.search({'title':id})
               except:
                   founds=[]
               logging.info(" found %s "%(founds))
               for found in founds:
                   if found.getObject() not in oldContent:
                    
                       #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
                       newContent.append((found.getObject().getVersions()[version-1][1],found.getObject()))
                       added+=1
   
           content=oldContent+newContent
           if not username:
               logging.error("XXXXXXXXXXX %s"%repr(self))
               user=self.getActualUserName()
           else:
               user = username
               
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
           logging.info("add to basket (%s) done"%(self.getId()))
           return added
       
       
     def addObjects(self,ids,deleteOld=None,username=None):      def addObjects(self,ids,deleteOld=None,username=None):
         """generate a new version of the basket with objects added"""          """generate a new version of the basket with objects added"""
                  logging.info("add to basket (%s)"%(self.getId()))
         lastVersion=self.getLastVersion()          lastVersion=self.getLastVersion()
                   
         if lastVersion is None:          if lastVersion is None:
             oldContent=[]              oldContent=[]
         else:          else:
             oldContent=lastVersion.basketContent[0:]              oldContent=lastVersion.content.getContent()
   
         if deleteOld:          if deleteOld:
             oldContent=[]              oldContent=[]
Line 903  class CDLIBasket(Folder,CatalogAware): Line 1131  class CDLIBasket(Folder,CatalogAware):
         newContent=[]          newContent=[]
         added=0          added=0
         for id in ids:          for id in ids:
               try:
             founds=self.CDLICatalog.search({'title':id})              founds=self.CDLICatalog.search({'title':id})
               except:
                   founds=[]
   
             for found in founds:              for found in founds:
                 if found.getObject() not in oldContent:                  if found.getObject() not in oldContent:
Line 918  class CDLIBasket(Folder,CatalogAware): Line 1149  class CDLIBasket(Folder,CatalogAware):
             user = username              user = username
                           
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)          ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
               logging.info("add to basket (%s) done"%(self.getId()))
         return added          return added
           
       
                   
       def getContent(self):
           """print content"""
           ret=[]
           
           lv=self.getLastVersion()
           for obj in lv.content.getContent():
               logging.info("XXXXXXXXXX %s"%repr(obj))
               ret.append((obj[1].getId(),obj[0].versionNumber))
               
           return ret
           
       def getContentIds(self):
           """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):      def changeBasket(self,ids,submit,RESPONSE=None,REQUEST=None):
         """change a basket"""          """change a basket"""
         if submit=="update":          if submit=="update":
Line 935  class CDLIBasket(Folder,CatalogAware): Line 1189  class CDLIBasket(Folder,CatalogAware):
             ids=[ids]              ids=[ids]
                 
         lastVersion=self.getLastVersion()           lastVersion=self.getLastVersion() 
         oldContent=lastVersion.basketContent[0:]          oldContent=lastVersion.content.getContent()
         newContent=[]          newContent=[]
         for obj in oldContent:          for obj in oldContent:
             if obj[1].getId() not in ids:              if obj[1].getId() not in ids:
Line 969  def manage_addCDLIBasket(self,title,shor Line 1223  def manage_addCDLIBasket(self,title,shor
     else:      else:
         return ob          return ob
   
 class CDLIBasketVersion(SimpleItem):  class CDLIBasketVersion(Implicit,Persistent,Folder):
     """version of a basket"""      """version of a basket"""
           
     meta_type="CDLIBasketVersion"      meta_type="CDLIBasketVersion"
     security=ClassSecurityInfo()      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):      def containsNonActualFiles(self):
         """returns True if basket contains one or more non current files"""          """returns True if basket contains one or more non current files"""
                   
Line 984  class CDLIBasketVersion(SimpleItem): Line 1251  class CDLIBasketVersion(SimpleItem):
                 return True                  return True
         return False          return False
           
     security.declareProtected('View','downloadObjectsAsOneFile')      def downloadListOfPnumbers(self):
           """download pnumbers of the basket as list"""
           
           basket_name=self.aq_parent.title
           
           ids=self.getContent() # get the list of objects
           logging.error(ids)
           ret="\n".join([x[1].getId().split(".")[0] for x in ids])
           
           self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.txt" """%basket_name)
           self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
           length=len(ret)
           self.REQUEST.RESPONSE.setHeader("Content-Length",length)
           self.REQUEST.RESPONSE.write(ret)    
           
       security.declareProtected('manage','downloadObjectsAsOneFile')
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):      def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):
         """download all selected files in one file"""          """download all selected files in one file"""
                         
           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():          if (check=="yes") and self.containsNonActualFiles():
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
               
             return pt(lock=lock)              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=""          ret=""
         lockedObjects={}          lockedObjects={}
                   
           self.temp_folder.downloadCounterBaskets+=1 
           self._p_changed=1
           transaction.get().commit()       
   
         if lock:          if lock:
                           
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':              if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
                                   self.temp_folder.downloadCounterBaskets-=1 
                   self._p_changed=1
                   transaction.get().commit()      
                   self.temp_folder.downloadCounterBaskets-=1 
                   self._p_changed=1
                   transaction.get().commit()      
                 return "please login first"                  return "please login first"
   
             #check if a locked object exist in the basket.              #check if a locked object exist in the basket.
             lockedObjects={}              lockedObjects={}
             for object in self.basketContent:              for object in self.content.getContent():
   
                 if not object[1].lockedBy=="":                  if (not str(object[1].lockedBy)=="") and (not (str(object[1].lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):
                     lockedObjects[object[1].title]=repr(object[1].lockedBy)                      lockedObjects[object[1].title]=repr(object[1].lockedBy)
                                         
                                           
Line 1016  class CDLIBasketVersion(SimpleItem): Line 1318  class CDLIBasketVersion(SimpleItem):
             if len(keys)>0 and (not procedure):              if len(keys)>0 and (not procedure):
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects                  self.REQUEST.SESSION['lockedObjects']=lockedObjects
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
                   
                   self.temp_folder.downloadCounterBaskets-=1 
                   self._p_changed=1
                   transaction.get().commit()      
   
                 return pt()                  return pt()
                     
             elif not procedure: #keine fails gesperrt dann alle donwloaden              elif not procedure: #keine fails gesperrt dann alle donwloaden
                 procedure="downloadAll"                   procedure="downloadAll" 
                   
   
         for object in self.basketContent:  
   
           for object in self.content.getContent():
                           
                 if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):                  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                      if current=="no": #version as they are in the basket
                         ret+=str(object[0].data)+"\n"                          ret+=str(object[0].getData())+"\n"
                     elif current=="yes":                      elif current=="yes":
                         #search current object                          #search current object
                         founds=self.CDLICatalog.search({'title':object[0].getId()})                          founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
                         if len(founds)>0:                                if len(founds)>0:      
                             ret+=str(founds[0].getObject().getLastVersion().data)+"\n"                              ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
                                                           
                 if lock and object[1].lockedBy=='':                  if lock and object[1].lockedBy=='':
                     object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']                      object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
                       
         basket_name=self.aq_parent.title+"_V"+self.getId()          basket_name=self.aq_parent.title+"_V"+self.getId()
                   
         #write basketname to header of atf file          #write basketname to header of atf file
         ret="#atf basket %s\n"%basket_name+ret          ret="#basket: %s\n"%basket_name+ret
   
           self.temp_folder.downloadCounterBaskets-=1 
           self._p_changed=1
           transaction.get().commit()      
                   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)          self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")          self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
         length=len(ret)          length=len(ret)
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)          self.REQUEST.RESPONSE.setHeader("Content-Length",length)
         self.REQUEST.RESPONSE.write(ret)              self.REQUEST.RESPONSE.write(ret)    
                   return True
     
     def numberOfItems(self):      def numberOfItems(self):
         """return anzahl der elemente im basket"""          """return anzahl der elemente im basket"""
         return len(self.basketContent)          return self.content.numberOfItems()
           
     def getTime(self):      def getTime(self):
         """getTime"""          """getTime"""
Line 1066  class CDLIBasketVersion(SimpleItem): Line 1378  class CDLIBasketVersion(SimpleItem):
           
     def getContent(self):      def getContent(self):
         """get Basket Content"""          """get Basket Content"""
         return self.basketContent          return self.content.getContent()
   
           
     def __init__(self,id,user,comment="",basketContent=[]):      def __init__(self,id,user,comment="",basketContent=[]):
         """ init a basket version"""          """ init a basket version"""
         self.id=id          self.id=id
         self.coment=comment          self.comment=comment
         self.basketContent=basketContent[0:]          self._setObject('content',BasketContent(basketContent))
           #self.basketContent=basketContent[0:]a
         self.user=user          self.user=user
         self.time=time.localtime()          self.time=time.localtime()
                   
Line 1085  class CDLIBasketVersion(SimpleItem): Line 1398  class CDLIBasketVersion(SimpleItem):
         """get Comment"""          """get Comment"""
         return self.comment          return self.comment
     
     security.declareProtected('View','index_html')      security.declareProtected('manage','index_html')
     def index_html(self):      def index_html(self):
             """view the basket"""              """view the basket"""
   
             if self.REQUEST.get('change',False):              if self.REQUEST.get('change',False):
                       ob=self.aq_parent.updateObjects(self.REQUEST['change'])
   
                     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)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
             return pt()              return pt()
Line 1128  def manage_addCDLIBasketVersion(self,use Line 1442  def manage_addCDLIBasketVersion(self,use
     else:      else:
         return ob          return ob
           
 class CDLIFileObject(CatalogAware,versionedFileObject):  class CDLIFileObject(CatalogAware,extVersionedFileObject):
     """CDLI file object"""      """CDLI file object"""
           
     meta_type="CDLI File Object"      meta_type="CDLI File Object"
Line 1136  class CDLIFileObject(CatalogAware,versio Line 1450  class CDLIFileObject(CatalogAware,versio
           
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
           
        security.declareProtected('manage','index_html')
     security.declarePublic('makeThisVersionCurrent')  
           
     def PrincipiaSearchSource(self):      def PrincipiaSearchSource(self):
            """Return cataloguable key for ourselves."""             """Return cataloguable key for ourselves."""
Line 1148  class CDLIFileObject(CatalogAware,versio Line 1461  class CDLIFileObject(CatalogAware,versio
                   
         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
           
           
         newversion=parent.manage_addCDLIFileObject('',comment,author)          newversion=parent.manage_addCDLIFileObject('',comment,author)
         newversion.data=self.data[0:]          newversion.manage_upload(self.getData())
                                                                                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')              RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
   
   
         return True          return True
           
     security.declarePublic('view')      def getFormattedData(self):
           """fromat text"""
           data=self.getData()
   #        return re.sub("\s\#lem"," #lem",data) #remove return vor #lem
           return re.sub("#lem","       #lem",data) #remove return vor #lem
                                                                                   
       security.declarePublic('view')
     def view(self):      def view(self):
         """view file"""          """view file"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
         return pt()          return pt()
           
       security.declarePublic('getPNumber')
       def getPNumber(self):
           """get the pnumber"""
           try:
                   txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
           except:
                   txt=self.getData()[0:]
                   
                   return "ERROR"
           try:
               return "P"+txt.group(1)
           except:
               return "ERROR"
   
     security.declarePublic('getDesignation')      security.declarePublic('getDesignation')
     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.data[0:])                  txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
         except:          except:
                 txt=self.data[0:]                  txt=self.getData()[0:]
                                   
                 return "ERROR"                  return "ERROR"
         try:          try:
Line 1185  class CDLIFileObject(CatalogAware,versio Line 1516  class CDLIFileObject(CatalogAware,versio
                   
 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,
                    REQUEST=None):                               precondition='', content_type='',
                                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 1201  def manage_addCDLIFileObject(self,id,vC= Line 1532  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:  
         self._getOb(id).manage_upload(file)      if file and not from_tmp:
           fob.manage_upload(file)
       elif file and from_tmp:
           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()
       logging.debug("manage_add: fob_data=%s"%fob.getData())
       logging.debug("reindex2: %s in %s"%(repr(fob), repr(fob.default_catalog)))
       fob.index_object()
   
     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(versionedFile,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.declareProtected('manage','index_html')
       
       def getLastVersionData(self):
           """get last version data"""
           return self.getData()
   
       def getLastVersionFormattedData(self):
           """get last version data"""
           return self.getContentObject().getFormattedData()
           
     #security.declarePublic('history')      #security.declarePublic('history')
     def history(self):      def history(self):
Line 1235  class CDLIFile(versionedFile,CatalogAwar Line 1587  class CDLIFile(versionedFile,CatalogAwar
         return pt()          return pt()
   
   
       def getBasketFromId(self,basketid, context=None):
           """get basket from id"""
   
           if not context:
               context=self
               
           for basket in self.ZopeFind(context,obj_metatypes=["CDLIBasket"]):
               if basket[0]==basketid:
                   return basket[1]
           else:
               None
   
     
     def isContainedInBaskets(self,context=None):      def isContainedInBaskets(self,context=None):
         """check is this file is part of any basket          """check is this file is part of any basket
Line 1256  class CDLIFile(versionedFile,CatalogAwar Line 1620  class CDLIFile(versionedFile,CatalogAwar
         #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."""
           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 1272  class CDLIFile(versionedFile,CatalogAwar Line 1641  class CDLIFile(versionedFile,CatalogAwar
                                  precondition='',                                    precondition='', 
                                  content_type='',                                   content_type='',
                                  changeName='no',newName='',                                    changeName='no',newName='', 
                                  come_from=None,RESPONSE=None):                                   come_from=None,
                                    from_tmp=False,RESPONSE=None):
         """add"""          """add"""
         
         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden          try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
             vC=self.REQUEST['vC']              vC=self.REQUEST['vC']
         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)  
         objs=self.ZopeFind(self,obj_ids=[id])[0][1].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()
Line 1315  class CDLIFile(versionedFile,CatalogAwar Line 1660  class CDLIFile(versionedFile,CatalogAwar
           pass            pass
       
         if RESPONSE:          if RESPONSE:
                   if ob.getSize()==0:
             obj=self.ZopeFind(self,obj_ids=[id])[0][1]                  self.REQUEST.SESSION['objID']=ob.getId()
             if obj.getSize()==0:  
                 self.REQUEST.SESSION['objID']=obj.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 1344  def manage_addCDLIFile(self,id,title,loc Line 1685  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()
                   
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   def checkUTF8(data):
       """check utf 8"""
       try:
           data.encode('utf-8')
           return True
       except:
           return False
   
   
   def checkFile(filename,data,folder):
       """check the files"""
       # first check the file name
       fn=filename.split(".") # no extension
   
       if not fn[0][0]=="P":
           return False,"P missing in the filename"
       elif len(fn[0])!=7:
           return False,"P number has not the right length 6"
       elif not checkUTF8(data):
           return False,"not utf-8"
       else:
           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 line in fh.readlines():  
       if (type(fh) is StringType) or (type(fh) is UnicodeType):
           iter=fh.split("\n")
       else:
           iter=fh.readlines()
           
       for lineTmp in iter:
           lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..
           for line in lineTmp.split("\r"):
               #logging.log("Deal with: %s"%line)
         if ext:          if ext:
             i+=1              i+=1
             if (i%100)==0:              if (i%100)==0:
Line 1369  def splitatf(fh,dir=None,ext=None): Line 1738  def splitatf(fh,dir=None,ext=None):
                 i=0                  i=0
                 ext.result+="<br>"                  ext.result+="<br>"
         #check if basket name is in the first line          #check if basket name is in the first line
         if line.find("#atf basket")>=0:              if line.find("#atf basket")>=0: #old convention
             ret=line.replace('#atf basket ','')              ret=line.replace('#atf basket ','')
             ret=ret.split('_')[0]              ret=ret.split('_')[0]
               elif line.find("#basket:")>=0: #new convention
                   ret=line.replace('#basket: ','')
                   ret=ret.split('_')[0]
   
         else:          else:
             if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile              if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
                 if nf:                  if nf:
Line 1382  def splitatf(fh,dir=None,ext=None): Line 1755  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.info("open %s"%filename)
             if nf:                  if nf:    
                 nf.write(line)                      nf.write(line.replace("\n","")+"\n")
                   
       try:        
     nf.close()      nf.close()
       except:
           pass
       
       if not((type(fh) is StringType) or (type(fh) is UnicodeType)):
     fh.close()      fh.close()
     return ret,len(os.listdir(dir))      return ret,len(os.listdir(dir))
   
   
 class CDLIFileFolder(versionedFileFolder):  class CDLIFileFolder(extVersionedFileFolder):
     """CDLI File Folder"""      """CDLI File Folder"""
           
     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  
           
       default_catalog='CDLICatalog'
       defaultFileCatalog=default_catalog #wenn dieses definiert ist, wird beim hinzufuegen einer neuen version eines files dieser catalog neuindiziert
       #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
     tmpStore2={}      tmpStore2={}
   
     def setTemp(self,name,value):      def setTemp(self,name,value):
         """set tmp"""          """set tmp"""
   
Line 1408  class CDLIFileFolder(versionedFileFolder Line 1789  class CDLIFileFolder(versionedFileFolder
                                                                                   
                                                                                 
     def delete(self,ids):      def delete(self,ids):
         """delete this file, i.e. move into a trash folder"""          """delete these files"""
                
         found=self.ZopeFind(self,obj_ids=['.trash'])  
           
         if len(found)<1:  
             manage_addCDLIFileFolder(self, '.trash',title="Trash")  
             trash=self._getOb('.trash')  
         else:  
             trash=found[0][1]  
           
         if type(ids) is not ListType:          if type(ids) is not ListType:
             ids=[ids]              ids=[ids]
         cut=self.manage_cutObjects(ids)  
         trash.manage_pasteObjects(cut)          self.manage_delObjects(ids)
   
                   
     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 1432  class CDLIFileFolder(versionedFileFolder Line 1805  class CDLIFileFolder(versionedFileFolder
         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"""
           if not self.hasObject(fn):
               # search deeper
               founds=self.CDLICatalog.search({'title':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):  
         """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)          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()]
        
           return ret
                           
     def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):      def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
         """findObjectsFromList (, TAB oder LINE separated)"""          """findObjectsFromList (, TAB oder LINE separated)"""
Line 1521  class CDLIFileFolder(versionedFileFolder Line 1910  class CDLIFileFolder(versionedFileFolder
             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 1531  class CDLIFileFolder(versionedFileFolder Line 1919  class CDLIFileFolder(versionedFileFolder
                   
         catalog=getattr(self,self.default_catalog)          catalog=getattr(self,self.default_catalog)
         #tf,tfilename=mkstemp()          #tf,tfilename=mkstemp()
           if not hasattr(self.temp_folder,'downloadCounter'):
               self.temp_folder.downloadCounter=0
   
           if getattr(self.temp_folder,'downloadCounter',0) > 5:
               return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
                   
           self.temp_folder.downloadCounter+=1
           self._p_changed=1
           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)
                   
   
           
         RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")          RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
         RESPONSE.setHeader("Content-Type","application/octet-stream")          RESPONSE.setHeader("Content-Type","application/octet-stream")
                  tmp=""
         for l in list:          for l in list:
             obj=l[1].getObject()              obj=l[1].getObject()
                           
Line 1546  class CDLIFileFolder(versionedFileFolder Line 1944  class CDLIFileFolder(versionedFileFolder
                                   
                 #os.write(tf,obj.getLastVersion().data)                  #os.write(tf,obj.getLastVersion().data)
                 if RESPONSE:                  if RESPONSE:
                     RESPONSE.write(obj.getLastVersion().data[0:])                      RESPONSE.write(obj.getData()[0:])
                       RESPONSE.write("\n")
                   self.temp_folder.downloadCounter-=1 
                   self._p_changed=1
           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 1562  class CDLIFileFolder(versionedFileFolder Line 1964  class CDLIFileFolder(versionedFileFolder
     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 1570  class CDLIFileFolder(versionedFileFolder Line 1972  class CDLIFileFolder(versionedFileFolder
     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
           
                           
     def getFolders_OLD(self):      security.declareProtected('manage','index_html')
         """get all subfolders"""  
         ret=[]  
         folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)  
         for folder in folders:  
             ret.append((folder[1],  
                         len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),  
                         len(getattr(self,self.default_catalog)({'path':folder[0]}))  
                         ))  
         return ret  
     security.declareProtected('View','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 1636  class CDLIRoot(Folder): Line 2028  class CDLIRoot(Folder):
     """main folder for cdli"""      """main folder for cdli"""
           
     meta_type="CDLIRoot"      meta_type="CDLIRoot"
       downloadCounterBaskets=0 # counts the current basket downloads if counter > 10 no downloads are possible
       
       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
   
   
   
       def showFile(self,fileId,wholePage=False):
           """show a file
           @param fileId: P-Number of the document to be displayed
           """
           f=self.CDLICatalog({'title':fileId})
           if not f:
               return ""
           
           if wholePage:
               logging.debug("show whole page")
               return f[0].getObject().getContentObject().view()
           else:
               return f[0].getObject().getLastVersionFormattedData()
       
   
       def showWordInFile(self,fileId,word,lineList=None,regExp=False,indexName=""):
           """get lines with word from FileId"""
           
           file=self.showFile(fileId)
           logging.debug("show word regEXP %s"%regExp)
           ret=[]
           if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen
               wordlist=self.findWordRegExp(indexName,word)
           else:
               wordlist=[word]
           
           for line in file.split("\n"):
               found=False
               for word in wordlist:
           try: # just a hack because of possible unicode errors in line
                    if line.find(word)>-1:
                           if lineList: #liste of moeglichen Zeilennummern
                                   num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
   
                                   if num in lineList: 
   
                                           ret.append(line)
                           else: # nimm alles ohne line check
                                   ret.append(line)
                           
                           break;
           except:
               pass
           return ret
   
       def tagWordInFile(self,fileId,word,lineList=None,regExp=False,indexName=""):
           """get text with word highlighted from FileId"""
           
           file=self.showFile(fileId)
           tagStr=u'<span class="found">%s</span>'
           ret=[]
           
           if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen
               wordlist=self.findWordRegExp(indexName,word)
           else:
               wordlist=[word]
               
           for line in file.split("\n"):
               line = unicodify(line)
               found=False
               for word in wordlist:
                   if line.find(word)>-1: #word ist gefunden dann makiere und breche die Schleife ab
                           if lineList: #liste of moeglichen Zeilennummern
                                   num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
   
                                   if num in lineList: 
   
                                           ret.append(line.replace(word,tagStr%word))
                           
                           else: # nimm alles ohne line check
                                   ret.append(line.replace(word,tagStr%word))
                           found=True
                           break
               if not found: #word wurde nicht gefunden keine makierung
                           ret.append(line)
                           
           return u'<br>\n'.join(ret)
           
     def URLquote(self,str):      def URLquote(self,str):
         """quote url"""          """quote url"""
Line 1645  class CDLIRoot(Folder): Line 2128  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 forceunlock(self):
         "break all locks"          "break all locks"
         ret=[]          ret=[]
         for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):          for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
            un=f[1].forceunlock()             un=f[1].forceunlock()
            print un  
            if un and un !="":             if un and un !="":
                ret.append((f[0],un))                 ret.append((f[0],un))
         print ret  
         return ret                                 return ret                       
           
   
     def getChangesByAuthor(self,author,n=100):      def getChangesByAuthor(self,author,n=100):
         """getChangesByAuthor"""          """getChangesByAuthor"""
         zcat=self.CDLIObjectsCatalog          zcat=self.CDLIObjectsCatalog
Line 1679  class CDLIRoot(Folder): Line 2171  class CDLIRoot(Folder):
                 tmp[id]=(x.getObject().aq_parent,nr)                  tmp[id]=(x.getObject().aq_parent,nr)
   
             
         return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values())                     return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values(),author=author)           
                   
     def getLastChanges(self,n=100):      def getLastChanges(self,n=100):
         """get the last n changes"""           """get the last n changes""" 
Line 1711  class CDLIRoot(Folder): Line 2203  class CDLIRoot(Folder):
                   
     def checkThreads(self):      def checkThreads(self):
         """check threads"""          """check threads"""
         return threading.enumerate()          ret="<html><body>"
           for thread in threading.enumerate():
              ret+="<p>%s (%s): %s</p>"%(repr(thread),thread.getName(),thread.isAlive())
          
           return ret
                                          
                                              
       def uploadATFRPC(self,data,username):
           """upload an atffile via xml-rpc"""
           uploader=uploadATFThread()
           
           #generate an random id for the upload object
           from random import randint
           if (not self.REQUEST.SESSION.get('idTmp',None)):
   
               idTmp=str(randint(0,1000000000))
               self.REQUEST.SESSION['idTmp']=idTmp
           else:
               idTmp=self.REQUEST.SESSION.get('idTmp',None)
               
           
           uploader.set(data,0,username,idTmp)
           
           stObj=uploader.run()
           
           processor=uploadATFfinallyThread()
           
           basketname=stObj.returnValue['basketNameFromFile']
           
           processor.set("uploadchanged",basketname=basketname,SESSION=stObj.returnValue,username=username,serverport=self.REQUEST['SERVER_PORT'])
           
           processor.run()
           
           
           return generateXMLReturn(stObj.returnValue)
           
     def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):      def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
         """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 1729  class CDLIRoot(Folder): Line 2266  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 1753  class CDLIRoot(Folder): Line 2291  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 1765  class CDLIRoot(Folder): Line 2303  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]  
 #                        print 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['errors']=[x.getId() for x in tmp['errors']]  
                 self.REQUEST.SESSION['newPs']=tmp['newPs']  
                 self.REQUEST.SESSION['tmpdir']=tmp['dir']  
                 #del(self.cdli_main.tmpStore2[threadName])  
                 print "here the templates"  
                                 
                 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)
                 print "init p"  
                 return pt(changed=tmp['changed'],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]
        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'],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 uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):      def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
Line 1812  class CDLIRoot(Folder): Line 2330  class CDLIRoot(Folder):
             if (not hasattr(self,'_v_uploadATF')):              if (not hasattr(self,'_v_uploadATF')):
                 self._v_uploadATF={}                  self._v_uploadATF={}
   
             self._v_uploadATF[threadName]=thread  
   
               self._v_uploadATF[threadName]=thread
                   
             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'])              idTmp=self.REQUEST.SESSION['idTmp']
               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 1848  class CDLIRoot(Folder): Line 2368  class CDLIRoot(Folder):
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                 return pt(txt='/uploadATFfinally',threadName=threadName)                  return pt(txt='/uploadATFfinally',threadName=threadName)
             else:              else:
                 self.REQUEST.SESSION['idTmp']=None
               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/Documents/workspace/cdli/atf", files=None,ext=None):      def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):
         """import files"""          """import files"""
         root=self.cdli_main          root=self.cdli_main
                   count=0
         if not files:          if not files:
             files=os.listdir(folderName)              files=os.listdir(folderName)
                           
Line 1865  class CDLIRoot(Folder): Line 2385  class CDLIRoot(Folder):
             obj=self.ZopeFind(root,obj_ids=[folder])              obj=self.ZopeFind(root,obj_ids=[folder])
             if ext:              if ext:
       
                 ext.result+="<p>Adding: %s </p>"%f                  ext.result="<p>adding: %s </p>"%f+ext.result
             if not obj:              if not obj:
                 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]
                           
Line 1882  class CDLIRoot(Folder): Line 2402  class CDLIRoot(Folder):
             else:              else:
                 fobj2=obj2[0][1]                  fobj2=obj2[0][1]
                               
             file2=file(os.path.join(folderName,f))                 file2=os.path.join(folderName,f)  
             id=f              id=f
             manage_addCDLIFile(fobj2,f,'','')              manage_addCDLIFile(fobj2,f,'','')
             id=f              id=f
             ob=fobj2._getOb(f)              ob=fobj2._getOb(f)
             ob.title=id              ob.title=id
                           
             manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')              manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='',from_tmp=True)
             self.CDLICatalog.catalog_object(ob)              self.CDLICatalog.catalog_object(ob)
             #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)              #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])              #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])
               count+=1
                           
               if count > 1000:
                   print "committing"
                   transaction.get().commit()
                   count=0
               transaction.get().commit()
         return "ok"          return "ok"
                     
   
Line 1913  def manage_addCDLIRoot(self, id, title=' Line 2439  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
Removed from v.1.37  
changed lines
  Added in v.1.80.2.3

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