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

Diff for /cdli/cdli_files.py between versions 1.5 and 1.81

version 1.5, 2006/02/13 20:35:35 version 1.81, 2008/01/21 17:19:01
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
   from OFS.Folder import manage_addFolder
   import re
   from AccessControl import ClassSecurityInfo
   from Acquisition import Implicit
   from Globals import Persistent
   from threading import Thread
   from ZPublisher.HTTPRequest import HTTPRequest
   from ZPublisher.HTTPResponse import HTTPResponse
   from ZPublisher.BaseRequest import RequestContainer
   import threading
   from BTrees.OOBTree import OOBTree
   import logging
   import transaction
   import copy
   import codecs
   import sys
   
   import cdliSplitter
   
   
   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 formatAtfHtml(l):
       """escape special ATF characters for HTML"""
       if not l:
           return ""
   
       # replace &
       l = l.replace('&','&')
       # replace angular brackets
       l = l.replace('<','&lt;')
       l = l.replace('>','&gt;')
       return l
   
   def formatAtfLineHtml(l, nolemma=True):
       """format ATF line for HTML"""
       if not l:
           return ""
   
       if nolemma:
           # ignore lemma lines
           if l.lstrip().startswith('#lem:'):
               return ""
       
       return formatAtfHtml(l)
   
   
 class Basket_old(Folder):  
     """shopping basket - alte fassung """  
           
     meta_type="Basket"  def formatAtfFullLineNum(txt, nolemma=True):
     _v_stack={}      """format full line numbers in ATF text"""
       # surface codes
       surfaces = {'@obverse':'obv',
                   '@reverse':'rev',
                   '@surface':'surface',
                   '@edge':'edge',
                   '@left':'left',
                   '@right':'right',
                   '@top':'top',
                   '@bottom':'bottom',
                   '@face':'face',
                   '@seal':'seal'}
   
     def getObjUrl(self,objId):      if not txt:
         """getUrl"""          return ""
         founds=self.CDLICatalog.search({'path':objId})      
         if len(founds)>0:      ret = []
              return founds[0].getObject().absolute_url()      surf = ""
       col = ""
       for line in txt.splitlines():
           line = unicodify(line)
           if line and line[0] == '@':
               # surface or column
               words = line.split(' ')
               if words[0] in surfaces:
                   surf = line.replace(words[0],surfaces[words[0]]).strip()
               
               elif words[0] == '@column':
                   col = ' '.join(words[1:])
               
           elif line and line[0] in '123456789':
               # ordinary line -> add line number
               line = "%s:%s:%s"%(surf,col,line)
               
           ret.append(line)
       
       return '\n'.join(ret)
                     
         else: #assume version number  
             splitted=objId.split("_")  
             founds=self.CDLICatalog.search({'path':splitted[1]})          
             return founds[0].getObject().absolute_url()+'/'+objId  
                   
     def storeAllLink(self,results):  def generateXMLReturn(hash):
         """erzeuge link zum speicher aller results"""      """erzeugt das xml file als returnwert fuer uploadATFRPC"""
         nr=self.REQUEST['_ZopeId']  
                   
         if results:      ret="<return>"
             self._v_stack[nr]=[x.getObject().getId() for x in results]  
                   
         return self.absolute_url()+"/storeAll?id="+nr      ret+="<errors>"
       for error in hash['errors']:
           ret+="""<error atf="%s">%s</error>"""%error
           
     def storeAll(self,id):      ret+="</errors>"
         """store all"""      
       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:          try:
             results=self._v_stack[id]          for x in s:
         except:              u[x] = 1
             #TODO: write expired page      except TypeError:
             return "expired"          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:]
                   
         return self.storeInBasketForm(results)      def getContent(self):
           """get content"""
                   
     def storeInBasketForm(self,ids):          return self.contentList
         """ store an object form"""  
                   
         if type(ids) is not ListType:      def setContent(self,content):
             ids=[ids]          self.contentList=content[0:]
         self.REQUEST.SESSION['ids']=ids[0:]  
                   
         self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']      def numberOfItems(self):
           """number"""
   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)          return len(self.getContent())
         return pt()  
                   
     def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):  
         """store it"""  
                   
         if not ids:  class uploadATFfinallyThread(Thread):
             ids=REQUEST.SESSION['ids']      """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
                           
         self.REQUEST.SESSION['basketUser']=username      def __init__(self):
           """init for uploadATFfinallyThread"""
           self.continueVar=True
           self.returnValue=None
           self.end=False
           Thread.__init__(self)
              
       def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):
           """set start values for the thread"""
           self.procedure=procedure
           self.comment=comment
           self.basketname=basketname
           self.unlock=unlock
           self.SESSION=SESSION
           self.username=username
           self.serverport=serverport
                   
         baskets=self.ZopeFind(self,obj_ids=[username])  
         if len(baskets)>0:  
             basket=baskets[0][1]  
         else:  
             manage_addBasketObject(self,username)  
             basket=self._getOb(username)  
                   
       def __call__(self):
           """call of the thread (equals run)"""
           self.run()
           return True
                   
         basket.addObjects(ids)      def getContext(self, app,serverport="8080"):
         back=self.REQUEST.SESSION.get('BACKLINK', None)          """get the context within the ZODB"""
   
         if RESPONSE:          resp = HTTPResponse(stdout=None)
             RESPONSE.redirect(back)          env = {
               'SERVER_NAME':'localhost',
               'SERVER_PORT':serverport,
               'REQUEST_METHOD':'GET'
               }
           req = HTTPRequest(None, env, resp)
           return app.__of__(RequestContainer(REQUEST = req))
             
           
       def run(self):
           """run"""
           
           self.result=""
           #find context within ZODB
           from Zope import DB
           conn = DB.open()
           root = conn.root()
           app  = root['Application']
           ctx = self.getContext(app,serverport=self.serverport)
   
           #add the files
           self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
           #commit the transactions
           transaction.get().commit()
           conn.close()
           #set flag for end of this method
           self.end=True
           logging.info("ended")
           return True
                           
       def __del__(self):
           """delete"""
   
           
     def showBasket(self,user=None,set=None,RESPONSE=None):  
         """show the basket"""  
                   
         if user:      def getResult(self):
             self.REQUEST.SESSION['basketUser']=user          """method for accessing result"""
                   
         if not user and not set:          return self.result
             user=self.REQUEST.SESSION.get('basketUser',None)  
                   
         if not user:      def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)          """upload the files"""
             return pt()          #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
         else:          ctx2=ctx.cdliRoot
             baskets=self.ZopeFind(self,obj_ids=[user])     
           self.result+="<h2>Start processing</h2>"
                   
           #shall I only upload the changed files?
           logging.debug("uploadATFfinally procedure: %s"%procedure)
           if procedure=="uploadchanged":
               changed=[x[0] for x in SESSION.get('changed',[])]
               uploadFns=changed+SESSION.get('newPs',[])
           
           #or all
           elif procedure=="uploadAll":
               uploadFns=[]
               for x in os.listdir(SESSION['tmpdir']):
                   if not x in SESSION['lockerrors']:
                       uploadFns.append(x)
   
         if len(baskets)>0:          #or maybe nothing
             RESPONSE.redirect(baskets[0][1].absolute_url())          elif procedure=="noupload":
             return True               return True 
         else:          else:
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)              uploadFns=[]
             return pt()  
                   
           #do first the changed files    
           i=0
           for fn in uploadFns:
               logging.debug("uploadATFfinally uploadFn=%s"%fn)
               i+=1
               founds=ctx2.CDLICatalog.search({'title':fn})
               if len(founds)>0:
                   SESSION['author']=str(username)
                   self.result="<p>Changing : %s"%fn+self.result
                   logging.debug("uploadatffinallythread changing:%s"%fn+self.result)
                   founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
               if i%200==0:
                   transaction.get().commit()
                   logging.debug("uploadatffinallythread changing: do commit")
   
 def manage_addBasket_oldForm(self):          transaction.get().commit()
     """add the basket form"""          logging.debug("uploadatffinallythread changing: last commit")
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)  
     return pt()  
   
 def manage_addBasket_old(self,id,title,RESPONSE=None):          #now add the new files        
     """add the basket"""          newPs=SESSION['newPs']
     ob=Basket()          if len(newPs)>0:
               tmpDir=SESSION['tmpdir']
               logging.debug("uploadatffinallythread 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
               ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
               logging.debug("uploadatffinallythread adding finished")
           
     ob.id=str(id)          #unlock locked files?
     ob.title=title          if unlock:
     self._setObject(id, ob)              logging.debug("uploadatffinallythread unlocking start")
     ob=self._getOb(id)              self.result="<p>Unlock files</p>"+self.result
               unlockFns=[]
               for x in os.listdir(SESSION['tmpdir']):
                       if not x in SESSION['errors']:
                           unlockFns.append(x)
                           
               logging.debug("unlocking have now what to unlock")
                           
               for fn in unlockFns:
                   #logging.info("will unlock: %s"%fn)
                   founds=ctx2.CDLICatalog.search({'title':fn})
                   #logging.info("found it: %s"%repr(founds))
                   if len(founds)>0:
                       #logging.info("unlock: %s"%founds[0].getObject().getId())
                       SESSION['author']=str(username)
                       founds[0].getObject().lockedBy=""
   
               logging.debug("uploadatffinallythread unlocking done")
                       
           #if a basketname is given, add files to the basket
           if not (basketname ==''):
               logging.debug("uploadatffinallythread add to basket %s"%basketname)
               self.result="<p>Add to basket</p>"+self.result
               basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
               
               if not basketId: # create new basket
                   logging.debug("uploadatffinallythread create basket %s"%basketname)
                   self.result="<p>Create a new basket</p>"+self.result
                   ob=ctx2.basketContainer.addBasket(basketname)
                   basketId=ob.getId()
               basket=getattr(ctx2.basketContainer,str(basketId))
               ids=os.listdir(SESSION['tmpdir'])
               basket.addObjects(ids,deleteOld=True,username=str(username))    
                  
           logging.debug("uploadatffinallythread uploadfinally done")
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')              RESPONSE.redirect(self.aq_parent.absolute_url())
           
           return True
   
   class tmpStore(SimpleItem):
       """simple item"""
       meta_type="cdli_upload"
   
       def __init__(self,id):
           """init tmp"""
           self.id=id
           
 class BasketObject_old(Folder):  class uploadATFThread(Thread):
     """Basket Object - alte fassung"""      """class for checking the files befor uploading"""
           
     meta_type="basketObject"  
     def __init__(self):      def __init__(self):
             """init basket object"""          """initialise"""
             self.contents=[]  
   
     def numberOfItems(self):          self.continueVar=True
         """return anzahl der elemente im basket"""          self.returnValue=None
         return len(self.contents)  
           
     def addObjects(self,ids):          Thread.__init__(self)
         """addObjects"""  
                   
         for id in ids:  
             founds=self.CDLICatalog.search({'path':id})  
             for found in founds:  
                 if found.getObject() not in self.contents:  
                     tm=self.contents[0:]  
                     tm.append(found.getObject())  
                     self.contents=tm[0:]  
           
       def set(self,upload,basketId,username,idTmp,serverport="8080"):
           """set start values for the thread"""
           self.result=""
           self.upload=upload
           self.basketId=basketId
           self.username=username
           self.serverport=serverport
           self.idTmp=idTmp
           
       def __call__(self):
           """call method """
           self.run()
         return True          return True
   
     def index_html(self):      def getContext(self, app,serverport="8080"):
             """view the basket"""          """get the context within the ZODB"""
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)          resp = HTTPResponse(stdout=None)
             return pt()          env = {
               'SERVER_NAME':'localhost',
               'SERVER_PORT':serverport,
               'REQUEST_METHOD':'GET'
               }
           req = HTTPRequest(None, env, resp)
           return app.__of__(RequestContainer(REQUEST = req))
           
       def run(self):
           idTmp=self.idTmp
           self.result=""
           #find context within ZODB
           from Zope import DB
           conn = DB.open()
           root = conn.root()
           app  = root['Application']
           ctx = self.getContext(app,serverport=self.serverport)
           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])
   
     def deleteObjects(self,ids,RESPONSE=None):          logging.info("call thread intern")
         """delete objects"""          self.uploadATFThread(ctx,self.upload,idTmp,self.basketId)
         list = self.contents[0:]  
         for content in list:  
                                 
                 if content.getId() in ids:          #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
                     self.contents.remove(content)  
                   
   
         if RESPONSE:          transaction.get().commit()
                 RESPONSE.redirect(self.absolute_url())  
   
           conn.close()
   
     def unlockTest(self):          return getattr(ctx.temp_folder,idTmp)
         """unlock all files of the testuser for debuggin"""  
         for object in self.contents:  
   
                 if str(object.lockedBy)=="test":      def getResult(self):
                     object.lockedBy=""          """method for accessing result"""
           return self.result
                           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):      def uploadATFThread(self,ctx,upload,idTmp,basketId=0):
         """download all selected files in one file"""          """upload an atf file"""
           #TODO: add comments
           #TODO: finish uploadATF
                   
         ret=""          stObj=getattr(ctx.temp_folder,idTmp)
         lockedObjects={}          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>"
                   
           #make sure that id is a string and not an integer
           basketId=str(basketId)
   
         if lock:          #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
           ctx2=ctx.cdliRoot
                           
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':          #get temporary file for staging the downloaded and splitted files
           dir=mkdtemp()
                                   
                 return "please login first"  
   
             #check if a locked object exist in the basket.          changed=[] # changed files
             lockedObjects={}          errors=[]  # files with errors
             for object in self.contents:          lockerrors=[]  # files with errors
   
                 if not object.lockedBy=="":          newPs=[]   # new p filed
                     lockedObjects[object.title]=repr(object.lockedBy)          psNotInCatalog=[] # files not in the catalog
                                         
           #split the uploadedd atf file
           basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)
                                           
             keys=lockedObjects.keys()          #find basketId if not set
                           
           #get active abaket
           if basketId == '0':
               basketObj=ctx2.basketContainer.getActiveBasket()
               if basketObj:
                   basketId=basketObj.getId()
                           
             if len(keys)>0 and (not procedure):          #if there is no active basket and no basketid given, id is empty, else get besketname and length
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects          if basketId == '0':
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)              basketNameFromId=""
                 return pt()              basketLen=0
           else:
               basketNameFromId=getattr(ctx2.basketContainer,basketId).title
               basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
                     
             elif not procedure: #keine fails gesperrt dann alle donwloaden          logging.info("got the file, upload thread")
                 procedure="downloadAll"           self.result+="""<html><body><h2>I got the files</h2><
                           p>I am computing the differences to the exisiting files</p>"""
                   
         print procedure              #start to check the files
         for object in self.contents:          for fn in os.listdir(dir):
                           
                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):              self.result="<p>process:%s</p>"%fn+self.result
                     ret+=object.getLastVersion().data  
                                   
                 if lock and object.lockedBy=='':              # check if file is in the catalog
                     object.lockedBy=self.REQUEST['AUTHENTICATED_USER']              #TODO: checkCatalog is not implemented yet
               if ctx2.cdli_main.checkCatalog(fn):
                   psNotInCatalog.append(fn)
   
               #check if p-file already at the server  
               founds=ctx2.CDLICatalog.search({'title':fn})    
   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())              #if not than add filename to the list of newfiles
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")  
         length=len(ret)  
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)  
         self.REQUEST.RESPONSE.write(ret)      
                   
               data=file(os.path.join(dir,fn)).read()
               status,msg=checkFile(fn,data,dir)
               #status=True
                   
 def manage_addBasket_oldObjectForm(self):  
     """add form"""  
     pass  
   
 def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):              if not status: # error
     """add"""                  errors.append((fn,msg))
           
     ob=BasketObject()              else:
                   if len(founds)==0:
                       newPs.append(fn)
           
     ob.id=str(id)                  #if p file alread at the server    
     ob.title=title                  for found in founds:
     self._setObject(id, ob)                      #analyse the differences to the actual file
     ob=self._getOb(id)                      obj=found.getObject()
           
     if RESPONSE is not None:                      if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
         RESPONSE.redirect('manage_main')                                  lockerrors.append((fn,str(obj.lockedBy)))
                       else:
                   
                           diffs=obj.diff(data)
                           if diffs[0]>0:
                               changed.append((obj,diffs)) #hochladen
   
           #ready, set the returnValues
           self.result+="<h3>Done</h3></body></html>"
           
           stObj.returnValue={}
           
           stObj.returnValue['errors']=errors
           
           stObj.returnValue['newPs']=newPs
           stObj.returnValue['tmpdir']=dir
           stObj.returnValue['basketLen']=basketLen
           stObj.returnValue['numberOfFiles']=numberOfFiles
           stObj.returnValue['basketNameFromId']=basketNameFromId
           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)
   
   
 class CDLIBasketContainer(OrderedFolder):  class CDLIBasketContainer(OrderedFolder):
     """contains the baskets"""      """contains the baskets"""
           
   
           security=ClassSecurityInfo()
     meta_type="CDLIBasketContainer"      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 []
           
           ob=getattr(self,basketId).getContent()
           
           ret=[x[0].split(".")[0] for x in ob]
           
           return ret
       
       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=""
           basketId=self.getBasketIdfromName(basketName)
           if not basketId:
               return ""
           
           ob=getattr(self,basketId).getLastVersion()
           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.debug("current: %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"""
           
           founds=self.ZopeFind(self,obj_metatypes=['CDLIBasketVersion'],search_sub=1)
   
           for found in founds:
               found[1].updateBasket()
           
       security.declareProtected('manage','deleteBaskets')        
       def deleteBaskets(self,ids=None):
           """delete baskets, i.e. move them into trash folder"""
           
           
           found=self.ZopeFind(self,obj_ids=['trash'])
           
           if len(found)<1:
               manage_addFolder(self, 'trash')
               trash=self._getOb('trash')
           else:
               trash=found[0][1]
           
           if type(ids) is not ListType:
               ids=[ids]
           cut=self.manage_cutObjects(ids)
           trash.manage_pasteObjects(cut)
           
       security.declareProtected('manage','manageBaskets')       
       def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):
           """manage baskets, delete or copy"""
           if submit=="delete":
               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:
               RESPONSE.redirect(self.absolute_url())
       
       security.declareProtected('View','getBasketIdfromName')       
     def getBasketIdfromName(self,basketname):      def getBasketIdfromName(self,basketname):
         """get id from name"""          """get id from name"""
   
Line 258  class CDLIBasketContainer(OrderedFolder) Line 692  class CDLIBasketContainer(OrderedFolder)
                 return basket[0]                  return basket[0]
         else:          else:
             None              None
       
       security.declareProtected('manage','uploadBasket_html')        
               
     def uploadBasket_html(self,basketId='0'):      def uploadBasket_html(self,basketId='0'):
         """upload an atf file, html form"""          """upload an atf file, html form"""
           
   
         basketId=str(basketId)          basketId=str(basketId)
         if not basketId=='0':          if not basketId=='0':
             basketName=getattr(self.basketContainer,basketId).title              basketName=getattr(self.basketContainer,basketId).title
Line 270  class CDLIBasketContainer(OrderedFolder) Line 709  class CDLIBasketContainer(OrderedFolder)
         return pt(basketId=basketId,basketName=basketName)          return pt(basketId=basketId,basketName=basketName)
         
   
               security.declareProtected('manage','index_html')    
     def index_html(self):      def index_html(self):
         """stanadard ansicht"""          """stanadard ansicht"""
           
   
   
         ext=self.ZopeFind(self,obj_ids=["index.html"])          ext=self.ZopeFind(self,obj_ids=["index.html"])
         if ext:          if ext:
             return ext[0][1]()              return ext[0][1]()
Line 290  class CDLIBasketContainer(OrderedFolder) Line 732  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 349  class CDLIBasketContainer(OrderedFolder) Line 803  class CDLIBasketContainer(OrderedFolder)
         return baskets          return baskets
   
   
       def subtractBasket(self,newBasket,basket1,basket2):
           """subtract basket2 from basket1 
           (i.e. newbasket will contain alle elements of basket1 which are not in basket2), 
           if basket2 contains files which are not in basket1, then theses files fill be ignored
                  
           @param newbasket: name of the new basket
           @param basket1: basket where basket2 will be subtracted from
           @param basket2: see above
         
           """
           logging.info("CCCCC %s %s"%(basket1,basket2))
      
           try:
               newB=self.addBasket(newBasket)
           except:
               return False, "cannot create the new basket"
           
           
   
          
        
           bas2= getattr(self,basket2)            
           bas2content=bas2.getContent()
           bas2ids=[x[0] for x in bas2content]
           
          
               
           bas1= getattr(self,basket1)   
           bas1content=bas1.getContent()
           
           
           newBasketContent={}
           
           for id,version in bas1content:
               if not (id in bas2ids):
                   newBasketContent[id]=version
           
           username=self.getActualUserName()
           
           logging.info("sbc %s"%newBasketContent)
           newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
           
           return True, ""
       
               
       def joinBasket(self,newBasket,oldBaskets):
           """join two baskets
           @param newbasket: name of the new basket
           @param oldbaskets: list of baskets to be joined
           """
           try:
               newB=self.addBasket(newBasket)
           except:
               return False, "cannot create the new basket"
           
           newBasketContent={}
           for ob in oldBaskets:
               x= getattr(self,ob,None)
               if x is None:
                   return False, "cannot find basket: %s"%ob
               
               ids=x.getContent() # hole den Inhalt
               
               for id,version in ids:
                   if newBasketContent.has_key(id): # p number gibt's schon
                       newBasketContent[id]=max(newBasketContent[id],version) # speichere die groessere Versionsnumber
                   else:
                       newBasketContent[id]=version
           username=self.getActualUserName()
           
           logging.info("nbc %s"%newBasketContent)
           newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
           
           return True, ""
                                                 
     def getNewId(self):      def getNewId(self):
         """createIds"""          """createIds"""
Line 360  class CDLIBasketContainer(OrderedFolder) Line 888  class CDLIBasketContainer(OrderedFolder)
         self.last=last          self.last=last
         return last          return last
           
     def setActiveBasket(self,basketId):      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:
               REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+urllib.urlencode(qs))
                   
     def getActiveBasket(self):      def getActiveBasket(self):
         """get active basket from cookie"""          """get active basket from cookie"""
                   
         id= self.REQUEST.cookies.get('CDLIActiveBasket',None)          id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
         obj=getattr(self,id,None)          if id:
               obj=getattr(self,str(id),None)
           else:
               obj=None
         return obj          return obj
       
     def getActualUserName(self):      def getActualUserName(self):
         """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"""
                   
         ob=manage_addCDLIBasket(self,newBasketName)          ob=manage_addCDLIBasket(self,newBasketName)
         return ob          return ob
           
     def storeInBasket(self,ids,submit,newBasketName=None,RESPONSE=None,REQUEST=None):      def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):
         """store it"""          """store it"""
           if not ids:
               ids=self.REQUEST.SESSION['fileIds']
                   
         if type(ids) is not ListType:          if type(ids) is not ListType:
             ids=[ids]              ids=[ids]
                   
         if submit=="store in new basket":          if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
             basketRet=self.addBasket(newBasketName)              basketRet=self.addBasket(newBasketName)
             self.setActiveBasket(basketRet.getId())              self.setActiveBasket(basketRet.getId())
             basket=getattr(self,basketRet.getId())              basket=getattr(self,basketRet.getId())
         elif submit=="store in active basket":          elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):
             basket=self.getActiveBasket()              basket=self.getActiveBasket()
                     
         basket.addObjects(ids)          added=basket.addObjects(ids)
         back=self.REQUEST['HTTP_REFERER']          back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)
           
           
           if fromFileList:
   
               return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)
   
         if RESPONSE:          if RESPONSE:
               
             RESPONSE.redirect(back)              RESPONSE.redirect(back)
                           
           return True
                   
 def manage_addCDLIBasketContainerForm(self):  def manage_addCDLIBasketContainerForm(self):
     """add the CDLIBasketContainer form"""      """add the CDLIBasketContainer form"""
Line 421  class CDLIBasket(Folder,CatalogAware): Line 969  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 432  class CDLIBasket(Folder,CatalogAware): Line 1017  class CDLIBasket(Folder,CatalogAware):
                   
         return [x[1].getId() for x in self.getLastVersion().getContent()]          return [x[1].getId() for x in self.getLastVersion().getContent()]
           
   
     def isActual(self,obj):      def isActual(self,obj):
         """teste ob im basket die aktuelle version ist"""          """teste ob im basket die aktuelle version ist"""
         actualNo=obj[1].getLastVersion().getVersionNumber()          actualNo=obj[1].getLastVersion().getVersionNumber()
         storedNo=obj[0].getVersionNumber()          storedNo=obj[0].getVersionNumber()
           
           founds=self.CDLICatalog.search({'title':obj[0].getId()})
           if len(founds)>0:
               actualNo=founds[0].getObject().getLastVersion().getVersionNumber()
               
           if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
               return False, -1
           
         if actualNo==storedNo:          if actualNo==storedNo:
             return True              return True , 0
         else:          else:
             return False              return False, actualNo
                   
     def history(self):      def history(self):
         """history"""            """history"""  
Line 463  class CDLIBasket(Folder,CatalogAware): Line 1057  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 481  class CDLIBasket(Folder,CatalogAware): Line 1089  class CDLIBasket(Folder,CatalogAware):
         return versions          return versions
   
         
       def updateObjects(self,ids,RESPONSE=None,REQUEST=None):
           """update ids, ids not in the basket the add"""
           if type(ids) is not ListType:
               ids=[ids]
          
           lastVersion=self.getLastVersion() 
           oldContent=lastVersion.content.getContent()
           newContent=[]
           
     def addObjects(self,ids,deleteOld=None):          #first copy the old
         """generate a new version of the basket with objects added"""          for obj in oldContent:
               if obj[1].getId() not in ids:
                   newContent.append(obj)
           #now add the new
                 
           for id in ids:
               founds=self.CDLICatalog.search({'title':id})
   
               for found in founds:
                   if found.getObject() not in oldContent:
                       #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
                       newContent.append((found.getObject().getLastVersion(),found.getObject()))
           
   
           content=newContent 
           user=self.getActualUserName()
           
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
           
           obj=self._getOb(ob.getId())
           if RESPONSE:
              
               RESPONSE.redirect(obj.absolute_url())
           
           return obj
       
       def 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()          lastVersion=self.getLastVersion()
                   
           if not catalog:
               catalog=self.CDLICatalog
               
         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=[]
   
         newContent=[]          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):
           """generate a new version of the basket with objects added"""
           logging.info("add to basket (%s)"%(self.getId()))
           lastVersion=self.getLastVersion()
           
           if lastVersion is None:
               oldContent=[]
           else:
               oldContent=lastVersion.content.getContent()
   
           if deleteOld:
               oldContent=[]
             
           newContent=[]
           added=0
         for id in ids:          for id in ids:
               try:
             founds=self.CDLICatalog.search({'title':id})              founds=self.CDLICatalog.search({'title':id})
             print id,founds              except:
                   founds=[]
              
             for found in founds:              for found in founds:
                 if found.getObject() not in oldContent:                  if found.getObject() not in oldContent:
                     #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version                      #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
                     newContent.append((found.getObject().getLastVersion(),found.getObject()))                      newContent.append((found.getObject().getLastVersion(),found.getObject()))
                           added+=1
   
         content=oldContent+newContent          content=oldContent+newContent
                   if not username:
         user=self.getActualUserName()          user=self.getActualUserName()
           else:
               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
   
           
           
     def deleteObjects(self,ids,RESPONSE=None):      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):
           """change a basket"""
           if submit=="update":
               return self.updateObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
           elif submit=="delete":
               return self.deleteObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
               
       def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
         """delete objects"""          """delete objects"""
         #TODO: implement delete Objects          
           if type(ids) is not ListType:
               ids=[ids]
          
           lastVersion=self.getLastVersion() 
           oldContent=lastVersion.content.getContent()
           newContent=[]
           for obj in oldContent:
               if obj[1].getId() not in ids:
                   newContent.append(obj)
           
                   
           user=self.getActualUserName()
           
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
           
           if RESPONSE:
               obj=self._getOb(ob.getId())
               RESPONSE.redirect(obj.absolute_url())
                   
 def manage_addCDLIBasketForm(self):  def manage_addCDLIBasketForm(self):
     """add the CDLIBasketContainer form"""      """add the CDLIBasketContainer form"""
Line 537  def manage_addCDLIBasket(self,title,shor Line 1283  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()
           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):      def updateBasket(self):
           """update"""
           try:
               self._setObject('content',BasketContent(self.basketContent))
           except:
               try:
                   if len(self.basketContent)>0:
                       self.content.setContent(self.basketContent)
               except:
                   print "error",self.getId(),self.aq_parent.getId()
           self.basketContent=[]
   
           
       def containsNonActualFiles(self):
           """returns True if basket contains one or more non current files"""
           
           objs=self.getContent()
           for obj in objs:
               if not self.isActual(obj)[0]:
                   return True
           return False
       
       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"):
         """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():
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
               
               return pt(lock=lock)
               
           else:
               
               return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")
           
       def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no"):
           """print do the download"""
   
         ret=""          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 569  class CDLIBasketVersion(SimpleItem): Line 1378  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']):
                     ret+=object[0].data                      if current=="no": #version as they are in the basket
                           ret+=str(object[0].getData())+"\n"
                       elif current=="yes":
                           #search current object
                           founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
                           if len(founds)>0:      
                               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 613  class CDLIBasketVersion(SimpleItem): Line 1438  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 632  class CDLIBasketVersion(SimpleItem): Line 1458  class CDLIBasketVersion(SimpleItem):
         """get Comment"""          """get Comment"""
         return self.comment          return self.comment
     
       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):
                       ob=self.aq_parent.updateObjects(self.REQUEST['change'])
                      
                       self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket
                                           
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
             return pt()              return pt()
             
Line 642  class CDLIBasketVersion(SimpleItem): Line 1475  class CDLIBasketVersion(SimpleItem):
         objId=result[1].getTitle()          objId=result[1].getTitle()
         founds=self.CDLICatalog.search({'title':objId})          founds=self.CDLICatalog.search({'title':objId})
         if len(founds)>0:          if len(founds)>0:
              return founds[0].getObject().absolute_url()               return founds[0].getObject().getLastVersion().absolute_url()
                     
         else: #assume version number          else: #assume version number
             splitted=objId.split("_")              splitted=objId.split("_")
             founds=self.CDLICatalog.search({'path':splitted[1]})                      founds=self.CDLICatalog.search({'title':splitted[1]})        
             return founds[0].getObject().absolute_url()+'/'+objId              return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId
         
 def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):  def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
     """add a version"""      """add a version"""
Line 669  def manage_addCDLIBasketVersion(self,use Line 1502  def manage_addCDLIBasketVersion(self,use
     else:      else:
         return ob          return ob
           
 class CDLIFileObject(versionedFileObject):  class CDLIFileObject(CatalogAware,extVersionedFileObject):
     """CDLI file object"""      """CDLI file object"""
           
     meta_type="CDLI File Object"      meta_type="CDLI File Object"
       default_catalog='CDLIObjectsCatalog'
       
       security=ClassSecurityInfo()
       
       security.declareProtected('manage','index_html')
           
       security.declarePublic('view')
       view = PageTemplateFile('zpt/viewCDLIFile.zpt', globals())
                   
     def view(self):      security.declarePublic('editATF')
         """view file"""      editATF = PageTemplateFile('zpt/editATFFile.zpt', globals())
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)  
       def PrincipiaSearchSource(self):
              """Return cataloguable key for ourselves."""
              return str(self)
          
       def makeThisVersionCurrent_html(self):
           """form for making this version current"""
           
           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):
           """copy this version to current"""
           parent=self.aq_parent
           parent.manage_addVersionedFileObject(id=None,vC=comment,author=author,file=self.getData(),RESPONSE=RESPONSE)
           #newversion=parent.manage_addCDLIFileObject('',comment,author)
           #newversion.manage_upload(self.getData())
                                           
           #if RESPONSE is not None:
           #    RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
   
           return True
       
       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('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')
       def getDesignation(self):
           """get the designation out of the file"""
           try:
                   txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
           except:
                   txt=self.getData()[0:]
                   
                   return "ERROR"
           try:
               return txt.group(2)
           except:
               return "ERROR"
   
           
 manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')  manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
   
 def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',  def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',versionNumber=0,
                    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 698  def manage_addCDLIFileObject(self,id,vC= Line 1595  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'
           
     def isContainedInBaskets(self):      security.declareProtected('manage','index_html')
         """check is this file is part of any basket"""      
       def getLastVersionData(self):
           """get last version data"""
           return self.getData()
   
       def getLastVersionFormattedData(self):
           """get last version data"""
           return self.getContentObject().getFormattedData()
   
       def getTextId(self):
           """returns P-number of text"""
           # assuming that its the beginning of the title
           return self.title[:7]
   
       #security.declarePublic('history')
       def history(self):
           """history"""  
   
           ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
           if ext:
               return getattr(self,ext[0][1].getId())()
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
           return pt()
   
               
         return [x.getObject() for x in self.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]      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):
           """check is this file is part of any basket
           @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
                           has to exist.
           """
   
           if not context:
               context=self
           
           ret=[]
           for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()}):
               #if the basket x is deleted it seemes to be that x is sometimes still in the Catalog, why?
               try:
                   ret.append(x.getObject())
               except:
                   pass
           return ret
           #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]
           
           
       def _newContentObject(self, id, title='', versionNumber=0, versionComment=None, time=None, author=None):
           """factory for content objects. to be overridden in derived classes."""
           logging.debug("_newContentObject(CDLI)")
           return CDLIFileObject(id,title,versionNumber=versionNumber,versionComment=versionComment,time=time,author=author)
                   
                   
     def addCDLIFileObjectForm(self):      def addCDLIFileObjectForm(self):
Line 737  class CDLIFile(versionedFile,CatalogAwar Line 1706  class CDLIFile(versionedFile,CatalogAwar
         else:          else:
             return "Sorry file is locked by somebody else"              return "Sorry file is locked by somebody else"
                   
     def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):      def manage_addCDLIFileObject(self,id,vC,author,
                                    file='',title='',
                                    precondition='', 
                                    content_type='',
                                    changeName='no',newName='', 
                                    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
                   
         author=self.REQUEST['author']          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":          try:
             filename=file.filename              #FIXME: wozu ist das gut?
             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()))  
         self.REQUEST.SESSION['objID_parent']=self.getId()          self.REQUEST.SESSION['objID_parent']=self.getId()
           except:
               pass
   
         if RESPONSE:          if RESPONSE:
             obj=self.ZopeFind(self,obj_ids=[id])[0][1]              if ob.getSize()==0:
             if obj.getSize()==0:                  self.REQUEST.SESSION['objID']=ob.getId()
                 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:
                 RESPONSE.redirect(self.REQUEST['URL2'])                  if come_from and (come_from!=""):
                       RESPONSE.redirect(come_from+"?change="+self.getId())
                   else:
                       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 799  def manage_addCDLIFileForm(self): Line 1751  def manage_addCDLIFileForm(self):
 def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):  def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
     """add the OSAS_root"""      """add the OSAS_root"""
     newObj=CDLIFile(id,title,lockedBy,author)      newObj=CDLIFile(id,title,lockedBy,author)
                                           
       tryToggle=True
       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):  def splitatf(fh,dir=None,ext=None):
     """split it"""      """split it"""
     ret=None      ret=None
     nf=None      nf=None
     for line in fh.readlines():      i=0
   
       #ROC: why split \n first and then \r???
       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:
                   i+=1
                   if (i%100)==0:
                       ext.result+="."
                   if i==10000:
                       i=0
                       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 826  def splitatf(fh,dir=None): Line 1827  def splitatf(fh,dir=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()
     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'  
           
     def getVersionNumbersFromIds(self,ids):      file_catalog='CDLICatalog'
         """get the numbers of the current versions of documents described by their ids"""  
                   
         ret=[]      #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
         searchStr=" OR ".join(ids)      tmpStore2={}
                   
         founds=self.CDLICatalog.search({'path':searchStr})      def _newVersionedFile(self, id, title='', lockedBy=None, author=None):
           """factory for versioned files. to be overridden in derived classes."""
           logging.debug("_newVersionedFile(CDLI)")
           return CDLIFile(id, title, lockedBy=lockedBy, author=author)
                   
         for found in founds:      def setTemp(self,name,value):
             lastVersion=found.getObject().getLastVersion()          """set tmp"""
             ret.append((found.getId,lastVersion))  
                   
         return ret          setattr(self,name,value)
           
       deleteFileForm = PageTemplateFile("zpt/doDeleteFile", globals())
     
     def uploadATF(self,upload,basketId=0,RESPONSE=None):      def delete(self,ids,REQUEST=None):
         """upload an atf file"""          """delete these files"""
         #TODO: add comments          if type(ids) is not ListType:
         #TODO: finish uploadATF              ids=[ids]
         basketId=str(basketId)  
                   
           self.manage_delObjects(ids)
                   
           if REQUEST is not None:
               return self.index_html()
                   
         dir=mkdtemp()  
         changed=[]  
         errors=[]  
         newPs=[]  
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)  
         if basketId == '0':  
             basketNameFromId=""  
             basketLen=0  
         else:  
             basketNameFromId=getattr(self.basketContainer,basketId).title  
             basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems()  
                           
       def getVersionNumbersFromIds(self,ids):
           """get the numbers of the current versions of documents described by their ids"""
                           
         for fn in os.listdir(dir):          ret=[]
             founds=self.CDLICatalog.search({'title':fn})              searchStr=" OR ".join(ids)
               
             if len(founds)==0:          founds=self.CDLICatalog.search({'title':searchStr})
                 newPs.append(fn)  
                                   
             for found in founds:              for found in founds:
                 obj=found.getObject()              lastVersion=found.getObject().getContentObject()
                      ret.append((found.getId,lastVersion))
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     errors.append(obj)  
                 else:  
                     data=file(os.path.join(dir,fn)).read()  
                     diffs=obj.diff(data)  
                     if diffs[0]>0:  
                         changed.append((obj,diffs))  
                         #hochladen  
           
         self.REQUEST.SESSION['changed']=[x[0].getId() for x in changed]  
         self.REQUEST.SESSION['errors']=[x.getId() for x in errors]  
         self.REQUEST.SESSION['newPs']=newPs  
         self.REQUEST.SESSION['tmpdir']=dir  
         
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)  
         return pt(changed=changed,errors=errors,dir=dir,newPs=newPs,basketLen=basketLen,numberOfFiles=numberOfFiles,  
                    basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId)  
                       
     def uploadATFfinally(self,procedure,comment="",basketname='',unlock=None,RESPONSE=None):  
         """upload the files"""  
                   
         if procedure=="uploadchanged":          return ret
             uploadFns=self.REQUEST.SESSION['changed']+self.REQUEST.SESSION['newPs']  
                   
         elif procedure=="uploadAll":      def getFile(self,fn):
             uploadFns=[]          """get the content of the file fn"""
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):          logging.debug("getFile: %s"%repr(fn))
                 if not x in self.REQUEST.SESSION['errors']:          if not self.hasObject(fn):
                     uploadFns.append(x)              # search deeper
               founds=getattr(self, self.file_catalog).search({'textid':fn})
               if founds:
                   obj=founds[0].getObject().getContentObject()
         else:          else:
             uploadFns=[]                  return "" 
           else:
               obj = self[fn].getContentObject()
                           
         for fn in uploadFns:          return obj.getData()[0:] 
             founds=self.CDLICatalog.search({'path':fn})  
             if len(founds)>0:  
                 self.REQUEST['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                 founds[0].getObject().manage_addCDLIFileObject('',comment,self.REQUEST['author'],file=file(os.path.join(self.REQUEST.SESSION['tmpdir'],fn)))  
                           
                   
       def checkCatalog(self,fn):
           """check if fn is in the catalog"""
           #TODO add checkCatalog
                                   
         newPs=self.REQUEST.SESSION['newPs']  
         if len(newPs)>0:  
             tmpDir=self.REQUEST.SESSION['tmpdir']  
                   
             self.cdli_main.importFiles(comment=comment,author=str(self.REQUEST['AUTHENTICATED_USER']) ,folderName=tmpDir, files=newPs)      def findObjectsFromListWithVersion(self,list,author=None):
           """find objects from a list with versions
           @param list: list of tuples  (cdliFile,version)
           """
           #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
           #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                                   
           pt=getattr(self,'filelistVersioned.html')
                   
           return pt(search=list,author=author)
                   
         #unlock  
         if unlock:  
             unlockFns=[]  
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                     if not x in self.REQUEST.SESSION['errors']:  
                         unlockFns.append(x)  
                           
             for fn in unlockFns:      def getAllPNumbers(self):
                 founds=self.CDLICatalog.search({'path':fn})          """get a list of all files (resp their p-numbers) stored"""
                 if len(founds)>0:  
                     self.REQUEST['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                                         
                     founds[0].getObject().lockedBy=""          ret=[x.getId for x in  self.CDLICatalog()]
                       
         if not (basketname ==''):  
             basketId=self.basketFolder.getBasketIdfromName(basketname)  
                           
             basket=getattr(self.basketFolder,basketId)          return ret
             ids=os.listdir(self.REQUEST.SESSION['tmpdir'])  
             basket.addObjects(ids,deleteOld=True)      
                                   
         if RESPONSE is not None:      def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
             RESPONSE.redirect(self.aq_parent.absolute_url())          """findObjectsFromList (, TAB oder LINE separated)"""
                   
   
     def findObjectsFromList(self,upload,RESPONSE):          if upload: # list from file upload
         """findObjectsFromList (, TAB oder LINE separated)"""  
         txt=upload.read()          txt=upload.read()
                                          
           if enterList:
               txt=enterList
               
           if upload or enterList:
         txt=txt.replace(",","\n")          txt=txt.replace(",","\n")
         txt=txt.replace("\t","\n")          txt=txt.replace("\t","\n")
               txt=txt.replace("\r","\n")
         idsTmp=txt.split("\n")          idsTmp=txt.split("\n")
         ids=[]          ids=[]
         for id in idsTmp: # make sure that no empty lines          for id in idsTmp: # make sure that no empty lines
             idTmp=id.lstrip().rstrip()              idTmp=id.lstrip().rstrip()
             if len(idTmp)>0:              if len(idTmp)>0:
                       
                 ids.append(idTmp)                  ids.append(idTmp)
                       
         #self.REQUEST.SESSION['ids']=" OR ".join(ids)          #self.REQUEST.SESSION['ids']=" OR ".join(ids)
                   
         RESPONSE.redirect("filelist.html?path=%s"%" OR ".join(ids))              pt=getattr(self,'filelist.html')
               self.REQUEST.SESSION['searchList']=ids
               return pt(search=ids)
           
           if basketName:
               #TODO: get rid of one of these..
               
               pt=getattr(self,'filelist.html')
               return pt(basketName=basketName,numberOfObjects=numberOfObjects)
           
           if list is not None: # got already a list
               ret=[]
               for fileId in list:
                   if fileId.find("*"): #check for wildcards
                           fileId=fileId
                   elif len(fileId.split("."))==1:
                           fileId=fileId+".atf"
                   
                   ret+=self.CDLICatalog({'title':fileId})
               #TODO: get rid of one of these..
               ids=[x.getObject().getId() for x in ret]
               self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
               self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
               
               if display:
                   pt=getattr(self,'filelist.html')
                   
                   return pt(search=ids)
               else:      
                   return ret
           
           
           
           if start:
               RESPONSE.redirect("filelist.html?start:int="+str(start))
                                          
   
       security.declareProtected('Manage','createAllFilesAsSingleFile')
     def createAllFilesAsSingleFile(self,RESPONSE=None):      def createAllFilesAsSingleFile(self,RESPONSE=None):
         """download all files"""          """download all files"""
                   
         def sortF(x,y):          def sortF(x,y):
             return cmp(x[0],y[0])              return cmp(x[0],y[0])
                   
         catalog=getattr(self,self.default_catalog)          catalog=getattr(self,self.file_catalog)
         #tf,tfilename=mkstemp()          #tf,tfilename=mkstemp()
           if not hasattr(self.temp_folder,'downloadCounter'):
               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 997  class CDLIFileFolder(versionedFileFolder Line 2026  class CDLIFileFolder(versionedFileFolder
                                   
                 #os.write(tf,obj.getLastVersion().data)                  #os.write(tf,obj.getLastVersion().data)
                 if RESPONSE:                  if RESPONSE:
                     RESPONSE.write(obj.getLastVersion().data)                      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 1013  class CDLIFileFolder(versionedFileFolder Line 2046  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 1021  class CDLIFileFolder(versionedFileFolder Line 2054  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  
       
     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 1050  class CDLIFileFolder(versionedFileFolder Line 2073  class CDLIFileFolder(versionedFileFolder
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
         return pt()          return pt()
           
     def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None):  
         """import files"""  
                   
   manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
   
       
   def manage_addCDLIFileFolder(self, id, title='',
                        createPublic=0,
                        createUserF=0,
                        REQUEST=None):
       """Add a new Folder object with id *id*.
   
       If the 'createPublic' and 'createUserF' parameters are set to any true
       value, an 'index_html' and a 'UserFolder' objects are created respectively
       in the new folder.
       """
       ob=CDLIFileFolder()
       ob.id=str(id)
       ob.title=title
       self._setObject(id, ob)
       ob=self._getOb(id)
   
       checkPermission=getSecurityManager().checkPermission
   
       if createUserF:
           if not checkPermission('Add User Folders', ob):
               raise Unauthorized, (
                     'You are not authorized to add User Folders.'
                     )
           ob.manage_addUserFolder()
   
     
       if REQUEST is not None:
           return self.manage_main(self, REQUEST, update_menu=1)
       
   class CDLIRoot(Folder):
       """main folder for cdli"""
       
       meta_type="CDLIRoot"
       downloadCounterBaskets=0 # counts the current basket downloads if counter > 10 no downloads are possible
       
       file_catalog = 'CDLICatalog'
       
       # word splitter for search
       splitter = {'words':cdliSplitter.wordSplitter(),
                   'graphemes':cdliSplitter.graphemeSplitter()}
       
       
       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 searchText(self, query, index='graphemes'):
           """searches query in the fulltext index and returns a list of file ids/P-numbers"""
           # see also: http://www.plope.com/Books/2_7Edition/SearchingZCatalog.stx#2-13
           logging.debug("searchtext for '%s' in index %s"%(query,index))
           #import Products.ZCTextIndex.QueryParser
           #qp = QueryParser.QueryParser()
           #logging.debug()
           idxQuery = {index:{'query':query}}
           idx = getattr(self, self.file_catalog)
           # do search
           resultset = idx.search(query_request=idxQuery,sort_index='textid')
           # put only the P-Number in the result 
           results = [res.getId[:7] for res in resultset]
           logging.debug("searchtext: found %d texts"%len(results))
           return results
   
   
       def getFile(self, pnum):
           """get the translit file with the given pnum"""
           f = getattr(self, self.file_catalog).search({'textid':pnum})
           if not f:
               return ""
           
           return f[0].getObject().getData()
            
   
   
       def showFile(self,fileId,wholePage=False):
           """show a file
           @param fileId: P-Number of the document to be displayed
           """
           f=getattr(self, self.file_catalog).search({'textid':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,indexName='graphemes',regExp=False,):
           """get lines with word from FileId"""
           logging.debug("showwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
           
           file = formatAtfFullLineNum(self.getFile(fileId))
           ret=[]
           
           # add whitespace before and whitespace and line-end to splitter bounds expressions
           bounds = self.splitter[indexName].bounds
           splitexp = "(%s|\s)(%%s)(%s|\s|\Z)"%(bounds,bounds)
           # clean word expression 
           # TODO: this should use QueryParser itself
           # take out double quotes
           word = word.replace('"','')
           # take out ignorable signs
           ignorable = self.splitter[indexName].ignorex
           word = ignorable.sub('', word)
           # compile into regexp objects and escape parens
           wordlist = [re.compile(splitexp%re.escape(w)) for w in word.split(' ')]
               
           for line in file.splitlines():
               for word in wordlist:
                   #logging.debug("showwordinfile: searching for %s in %s"%(word.pattern,ignoreable.sub('',line)))
                   if word.search(ignorable.sub('',line)):
                       line = formatAtfLineHtml(line)
                       ret.append(line)
                       break
                       
           return ret
   
       
       def showWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
           """
           get lines with word from all ids in list FileIds.
           returns dict with id:lines pairs.
           """
           logging.debug("showwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds))
           
           return dict([(id,self.showWordInFile(id, word, indexName, regExp)) for id in fileIds])
       
   
       def tagWordInFile(self,fileId,word,indexName='graphemes',regExp=False):
           """get text with word highlighted from FileId"""
           logging.debug("tagwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
           
           file=self.getFile(fileId)
           tagStart=u'<span class="found">'
           tagEnd=u'</span>'
           tagStr=tagStart + u'%%s' + tagEnd
           ret=[]
           
           # add whitespace to splitter bounds expressions and compile into regexp object
           bounds = self.splitter[indexName].bounds
           wordsplit = re.compile("(%s|\s)"%bounds)
           # clean word expression 
           # TODO: this should use QueryParser itself
           word = word.replace('"','') # take out double quotes
           # take out ignoreable signs
           ignorable = self.splitter[indexName].ignorex
           word = ignorable.sub('', word)
           # split search terms by blanks
           words = word.split(' ')
           # split search terms again (for grapheme search with words)
           splitwords = dict(((w,self.splitter[indexName].process([w])) for w in words))
               
           for line in file.splitlines():
               line = unicodify(line)
               # ignore lemma and other lines
               if line.lstrip().startswith('#lem:'):
                   continue
               # ignore p-num line
               if line.startswith('&P'):
                   continue
               # ignore version lines
               if line.startswith('#version'):
                   continue
               # ignore atf type lines
               if line.startswith('#atf:'):
                   continue
   
               # first scan
               hitwords = []
               for w in words:
                   if ignorable.sub('',line).find(w) > -1:
                       # word is in line
                       # append split word for grapheme search with words
                       hitwords.extend(splitwords[w])
                       #hitwords.extend(wordsplit.split(w))
                      
               # examine hits closer
               if hitwords:
                   # split line into words
                   parts = wordsplit.split(line)
                   line = ""
                   for p in parts:
                       #logging.debug("tagwordinfile: searching for %s in %s"%(p,hitwords))
                       # reassemble line
                       if ignorable.sub('', p) in hitwords:
                           #logging.debug("tagwordinfile: found %s in %s"%(p,hitwords))
                           # this part was found
                           line += tagStart + formatAtfHtml(p) + tagEnd
                       else:
                           line += formatAtfHtml(p)
                   
               else:
                   # no hits
                   line = formatAtfHtml(line)
               
               ret.append(line)
                           
           return u'<br>\n'.join(ret)
   
   
   
       def tagWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
           """
           get texts with highlighted word from all ids in list FileIds.
           returns dict with id:text pairs.
           """
           logging.debug("tagwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds)) 
           return dict([(id,self.tagWordInFile(id, word, indexName, regExp)) for id in fileIds])
       
   
       def URLquote(self,str):
           """quote url"""
           return urllib.quote(str)
       
       def URLunquote(self,str):
           """unquote url"""
           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):
           "break all locks"
           ret=[]
           for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
              un=f[1].forceunlock()
   
              if un and un !="":
                  ret.append((f[0],un))
   
           return ret
                                           
   
       def getChangesByAuthor(self,author,n=100):
           """getChangesByAuthor"""
           zcat=self.CDLIObjectsCatalog
           res=zcat({'lastEditor':author,
                        'sort_on':'getTime',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
                          
           return res
       
       def getChangesByAuthor_html(self,author,n=100):
           """html output for changes by author"""
           tmp={}
           list=[]                         
           for x in self.getChangesByAuthor(author):
              nr=x.getObject().getVersionNumber()
              id=x.getObject().aq_parent.getId()
              #hinzufuegen, wenn Version neuer als die 
              if tmp.get(id,(0,0))[1] < nr:
                   tmp[id]=(x.getObject().aq_parent,nr)
   
        
           return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values(),author=author)           
           
       def getLastChanges(self,n=100):
           """get the last n changes""" 
           n=int(n)                   
           zcat=self.CDLICatalog
           return zcat({'sort_on':'getLastChangeDate',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
        
       
       def getLastChanges_html(self,n=100):
           """get the last n changes"""
           list = [x.getId for x in self.getLastChanges(n)]
           return self.cdli_main.findObjectsFromList(list=list,display=True)
                                          
       def refreshTxt(self,txt="",threadName=None):
           """txt fuer refresh"""
     
           return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
   
       
       def getResult(self,threadName=None):
          """result of thread"""
          try:
           return self._v_uploadATF[threadName].getResult()
          except:
           return "One moment, please"
       
           
       def checkThreads(self):
           """check threads"""
           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):
           """upload an atf file / basket file"""
           #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
           if not threadName or threadName=="":
               #new thread not called from the waiting page
               tmpVar=False
          
               thread=uploadATFThread()
               threadName=thread.getName()[0:]                                
               if (not hasattr(self,'_v_uploadATF')):
                      self._v_uploadATF={}
                                          
               self._v_uploadATF[threadName]=thread
               #self._xmltrans.start()
               #thread=Thread(target=self._v_uploadATF)
               logging.info("set thread. extern")
               self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],idTmp,serverport=self.REQUEST['SERVER_PORT'])
               #thread.start()
               logging.info("start thread. extern")
               self._v_uploadATF[threadName].start()
   
               
               self.threadName=self._v_uploadATF[threadName].getName()[0:]
               wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
   
               if wait_template:
                   return wait_template[0][1]()
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
               return pt(txt='/uploadATF',threadName=threadName)
               #_v_xmltrans.run()
               
           else:
               #recover thread, if lost
               if (not hasattr(self,'_v_uploadATF')):
                  self._v_uploadATF={}
               if not self._v_uploadATF.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF[threadName]=thread
                                          
               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'])
                   if wait_template:
                           return wait_template[0][1]()
                   
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
   
                   return pt(txt='/uploadATF',threadName=threadName)
                   
               else:
                   tmp=getattr(self.temp_folder,idTmp).returnValue
    
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
   
                   return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                     basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                        
       def redoUpload(self,threadName):
          """redo the upload"""
          tmp=self.cdli_main.tmpStore2[threadName]
          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
          return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                     basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                    
       def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
           """nowupload the files"""
          
          
          
           threadName=repeat
           if not threadName or threadName=="":
               thread=uploadATFfinallyThread()
               threadName=thread.getName()[0:]
   
               if (not hasattr(self,'_v_uploadATF')):
                                   self._v_uploadATF={}
   
   
               self._v_uploadATF[threadName]=thread
   
               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()
   
               
               
               wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
   
               if wait_template:
                   return wait_template[0][1]()
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
   
               return pt(txt='/uploadATFfinally',threadName=threadName)
               #_v_xmltrans.run()
           
           else:
               #recover thread, if lost
               if not hasattr(self,'_v_uploadATF'):
                  self._v_uploadATF={}
               if not self._v_uploadATF.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF[threadName]=thread
                                          
               if self._v_uploadATF.get(threadName,None) and (self._v_uploadATF[threadName] is not None) and (not self._v_uploadATF[threadName].end) :
   
                   wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   if wait_template:
                           return wait_template[0][1]()
                   
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                   return pt(txt='/uploadATFfinally',threadName=threadName)
               else:
                 self.REQUEST.SESSION['idTmp']=None
                 if RESPONSE is not None:
                     RESPONSE.redirect(self.absolute_url())
   
       def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):
           """import files"""
           logging.debug("importFiles folderName=%s files=%s ext=%s"%(folderName,files,ext))
           root=self.cdli_main
           count=0
         if not files:          if not files:
             files=os.listdir(folderName)              files=os.listdir(folderName)
                           
         for f in files:          for f in files:
             folder=f[0:3]              folder=f[0:3]
             f2=f[0:5]              f2=f[0:5]
             obj=self.ZopeFind(self,obj_ids=[folder])              obj=self.ZopeFind(root,obj_ids=[folder])
               logging.debug("importFiles: folder=%s f2=%s obj=%s"%(folder,f2,obj)) 
               if ext:
                   ext.result="<p>adding: %s </p>"%f+ext.result
                           
             if not obj:              if not obj:
                 manage_addCDLIFileFolder(self,folder,folder)                  manage_addCDLIFileFolder(root,folder,folder)
                 fobj=getattr(self,folder)                  fobj=getattr(root,folder)
                   #transaction.get().commit()                           
                   
             else:              else:
                 fobj=obj[0][1]                  fobj=obj[0][1]
                           
             obj2=fobj.ZopeFind(fobj,obj_ids=[f2])              obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
               logging.debug("importFiles: fobj=%s obj2=%s"%(fobj,obj2)) 
                   
             if not obj2:              if not obj2:
                 manage_addCDLIFileFolder(fobj,f2,f2)                  manage_addCDLIFileFolder(fobj,f2,f2)
Line 1077  class CDLIFileFolder(versionedFileFolder Line 2582  class CDLIFileFolder(versionedFileFolder
             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  
             manage_addCDLIFile(fobj2,f,'','')  
             id=f              id=f
             ob=fobj2._getOb(f)              logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))
             ob.title=id              fobj2.addFile(vC='',file=file(file2),author=author,newName=f)
                           count+=1
             manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')  
             self.CDLICatalog.catalog_object(ob)              if count%100==0:
             #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)                  logging.debug("importfiles: committing")
             #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])                  transaction.get().commit()
                           
           transaction.get().commit()
         return "ok"          return "ok"
           
 manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())  
   
   manage_addCDLIRootForm=DTMLFile('dtml/rootAdd', globals())
           
 def manage_addCDLIFileFolder(self, id, title='',      
   def manage_addCDLIRoot(self, id, title='',
                      createPublic=0,                       createPublic=0,
                      createUserF=0,                       createUserF=0,
                      REQUEST=None):                       REQUEST=None):
Line 1104  def manage_addCDLIFileFolder(self, id, t Line 2609  def manage_addCDLIFileFolder(self, id, t
     value, an 'index_html' and a 'UserFolder' objects are created respectively      value, an 'index_html' and a 'UserFolder' objects are created respectively
     in the new folder.      in the new folder.
     """      """
     ob=CDLIFileFolder()      ob=CDLIRoot()
     ob.id=str(id)      ob.id=str(id)
     ob.title=title      ob.title=title
       try:
     self._setObject(id, ob)      self._setObject(id, ob)
       except:
           pass
     ob=self._getOb(id)      ob=self._getOb(id)
   
     checkPermission=getSecurityManager().checkPermission      checkPermission=getSecurityManager().checkPermission
Line 1123  def manage_addCDLIFileFolder(self, id, t Line 2631  def manage_addCDLIFileFolder(self, id, t
     if REQUEST is not None:      if REQUEST is not None:
         return self.manage_main(self, REQUEST, update_menu=1)          return self.manage_main(self, REQUEST, update_menu=1)
   
   
Removed from v.1.5  
changed lines
  Added in v.1.81

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