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

Diff for /cdli/cdli_files.py between versions 1.8 and 1.108

version 1.8, 2006/02/28 15:17:52 version 1.108, 2009/06/21 09:45:16
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  
 import os.path  import os.path
 import os  import os
 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
   import logging
   import transaction
   import copy
   import codecs
   import sys
   from BTrees.IOBTree import IOBTree 
   from BTrees.OOBTree import OOBTree 
   import cdliSplitter
   from sets import Set
   import md5
   from DownloadBasket import DownloadBasketFinallyThread
   from types import *
   import pickle
   import tempfile
   
   from cdli_helpers import *
   
   class CDLIFileObject(CatalogAware,extVersionedFileObject):
       """CDLI file object"""
   
 class Basket_old(Folder):      meta_type="CDLI File Object"
     """shopping basket - alte fassung """      default_catalog='CDLIObjectsCatalog'
           
     meta_type="Basket"      security=ClassSecurityInfo()
     _v_stack={}  
   
     def getObjUrl(self,objId):      security.declareProtected('manage','index_html')
         """getUrl"""  
         founds=self.CDLICatalog.search({'path':objId})  
         if len(founds)>0:  
              return founds[0].getObject().absolute_url()  
            
         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):  
         """erzeuge link zum speicher aller results"""  
         nr=self.REQUEST['_ZopeId']  
                   
         if results:      security.declarePublic('view')
             self._v_stack[nr]=[x.getObject().getId() for x in results]      view = PageTemplateFile('zpt/viewCDLIFile.zpt', globals())
                   
         return self.absolute_url()+"/storeAll?id="+nr      security.declarePublic('editATF')
       editATF = PageTemplateFile('zpt/editATFFile.zpt', globals())
           
     def storeAll(self,id):      def PrincipiaSearchSource(self):
         """store all"""             """Return cataloguable key for ourselves."""
         try:             return str(self)
             results=self._v_stack[id]  
         except:  
             #TODO: write expired page  
             return "expired"  
                   
         return self.storeInBasketForm(results)      def setAuthor(self, author):
           """change the author"""
           self.author = author
                   
     def storeInBasketForm(self,ids):      def makeThisVersionCurrent_html(self):
         """ store an object form"""          """form for mthis version current"""
                   
         if type(ids) is not ListType:          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
             ids=[ids]          return pt()                 
         self.REQUEST.SESSION['ids']=ids[0:]  
                   
         self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']      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())
   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)          #if RESPONSE is not None:
         return pt()          #    RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
                   
     def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):          return True
         """store it"""  
                   
         if not ids:      def getFormattedData(self):
             ids=REQUEST.SESSION['ids']          """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
                           
         self.REQUEST.SESSION['basketUser']=username  
                   
         baskets=self.ZopeFind(self,obj_ids=[username])      security.declarePublic('getPNumber')
         if len(baskets)>0:      def getPNumber(self):
             basket=baskets[0][1]          """get the pnumber"""
         else:          try:
             manage_addBasketObject(self,username)                  txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
             basket=self._getOb(username)          except:
                   txt=self.getData()[0:]
                   
                   return "ERROR"
           try:
               return "P"+txt.group(1)
           except:
               return "ERROR"
                   
         basket.addObjects(ids)      security.declarePublic('getDesignation')
         back=self.REQUEST.SESSION.get('BACKLINK', None)      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:]
   
         if RESPONSE:                  return "ERROR"
             RESPONSE.redirect(back)          try:
               return txt.group(2)
           except:
               return "ERROR"
                           
   
   manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
           
     def showBasket(self,user=None,set=None,RESPONSE=None):  def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',versionNumber=0,
         """show the basket"""                               precondition='', content_type='',
                                from_tmp=False,REQUEST=None):
       """Add a new File object.
       Creates a new File object 'id' with the contents of 'file'"""
                   
         if user:      id=str(id)
             self.REQUEST.SESSION['basketUser']=user      title=str(title)
       content_type=str(content_type)
       precondition=str(precondition)
                   
         if not user and not set:      id, title = cookId(id, title, file)
             user=self.REQUEST.SESSION.get('basketUser',None)  
                   
         if not user:      self=self.this()
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)  
             return pt()  
         else:  
             baskets=self.ZopeFind(self,obj_ids=[user])  
                   
       # First, we create the file without data:
       self._setObject(id, CDLIFileObject(id,title,versionNumber=versionNumber,versionComment=vC,time=time.localtime(),author=author))
       fob = self._getOb(id)
   
         if len(baskets)>0:      # Now we "upload" the data.  By doing this in two steps, we
             RESPONSE.redirect(baskets[0][1].absolute_url())      # can use a database trick to make the upload more efficient.
             return True   
         else:  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)  
             return pt()  
                   
       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:
           fob.content_type=content_type
   
 def manage_addBasket_oldForm(self):      #logging.debug("manage_add: lastversion=%s"%self.getData())
     """add the basket form"""      logging.debug("reindex1: %s in %s"%(repr(self),repr(self.default_catalog)))
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)      self.reindex_object()
     return pt()      #logging.debug("manage_add: fob_data=%s"%fob.getData())
       logging.debug("reindex2: %s in %s"%(repr(fob), repr(fob.default_catalog)))
       fob.index_object()
   
 def manage_addBasket_old(self,id,title,RESPONSE=None):      self.CDLIRoot.updateOrAddToFileBTree(ob)
     """add the basket"""      if REQUEST is not None:
     ob=Basket()          REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
           
     ob.id=str(id)  
     ob.title=title  
     self._setObject(id, ob)  
     ob=self._getOb(id)  
           
     if RESPONSE is not None:  class CDLIFile(extVersionedFile,CatalogAware):
         RESPONSE.redirect('manage_main')      """CDLI file"""
   
       security=ClassSecurityInfo()
       meta_type="CDLI file"
       content_meta_type = ["CDLI File Object"]
           
 class BasketObject_old(Folder):      default_catalog='CDLICatalog'
     """Basket Object - alte fassung"""  
           
     meta_type="basketObject"      security.declareProtected('manage','index_html')
     def __init__(self):  
             """init basket object"""  
             self.contents=[]  
   
     def numberOfItems(self):  
         """return anzahl der elemente im basket"""  
         return len(self.contents)  
           
     def addObjects(self,ids):      def getLastVersionData(self):
         """addObjects"""          """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]
                   
         for id in ids:      #security.declarePublic('history')
             founds=self.CDLICatalog.search({'path':id})      def history(self):
             for found in founds:          """history"""  
                 if found.getObject() not in self.contents:  
                     tm=self.contents[0:]  
                     tm.append(found.getObject())  
                     self.contents=tm[0:]  
           
         return True          ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
           if ext:
               return getattr(self,ext[0][1].getId())()
   
     def index_html(self):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
             """view the basket"""  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)  
             return pt()              return pt()
   
     def deleteObjects(self,ids,RESPONSE=None):  
         """delete objects"""  
         list = self.contents[0:]  
         for content in list:  
                                 
                 if content.getId() in ids:      def getBasketFromId(self,basketid, context=None):
                     self.contents.remove(content)          """get basket from id"""
                   
           if not context:
               context=self
   
         if RESPONSE:          for basket in self.ZopeFind(context,obj_metatypes=["CDLIBasket"]):
                 RESPONSE.redirect(self.absolute_url())              if basket[0]==basketid:
                   return basket[1]
           else:
               None
   
   
     def unlockTest(self):      def isContainedInBaskets(self,context=None):
         """unlock all files of the testuser for debuggin"""          """check is this file is part of any basket
         for object in self.contents:          @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
                           has to exist.
           """
   
                 if str(object.lockedBy)=="test":          if not context:
                     object.lockedBy=""              context=self
                           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):          ret=[]
         """download all selected files in one file"""          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()})]
                   
         ret=""  
         lockedObjects={}  
                   
       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)
   
         if lock:  
                           
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':      def addCDLIFileObjectForm(self):
           """add a new version"""
                                   
           if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
                 return "please login first"                  return "please login first"
           if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
               out=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject',version=self.getVersion()).__of__(self)
               return out()
           else:
               return "Sorry file is locked by somebody else"
   
             #check if a locked object exist in the basket.      def manage_addCDLIFileObject(self,id,vC,author,
             lockedObjects={}                                   file='',title='',
             for object in self.contents:                                   precondition='', 
                                    content_type='',
                 if not object.lockedBy=="":                                   changeName='no',newName='', 
                     lockedObjects[object.title]=repr(object.lockedBy)                                   come_from=None,
                                                       from_tmp=False,RESPONSE=None):
                               """add"""
             keys=lockedObjects.keys()  
               
               
             if len(keys)>0 and (not procedure):  
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)  
                 return pt()  
                     
             elif not procedure: #keine fails gesperrt dann alle donwloaden          try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
                 procedure="downloadAll"               vC=self.REQUEST['vC']
           except:
               pass
                   
         print procedure              ob = self.addContentObject(id, vC, author, file, title, changeName=changeName, newName=newName, from_tmp=from_tmp,
         for object in self.contents:                                     precondition=precondition, content_type=content_type)
                           
                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):          try:
                     ret+=object.getLastVersion().data              #FIXME: wozu ist das gut?
               self.REQUEST.SESSION['objID_parent']=self.getId()
           except:
               pass
                                   
                 if lock and object.lockedBy=='':          #self.cdliRoot.updateOrAddToFileBTree(self)# now update the object in the cache
                     object.lockedBy=self.REQUEST['AUTHENTICATED_USER']  
   
   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())          if RESPONSE:
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")              if ob.getSize()==0:
         length=len(ret)                  self.REQUEST.SESSION['objID']=ob.getId()
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
         self.REQUEST.RESPONSE.write(ret)                      return pt()
               else:
                   if come_from and (come_from!=""):
                       RESPONSE.redirect(come_from+"?change="+self.getId())
                   else:
                       RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
           else:
               return ob
                   
                   
 def manage_addBasket_oldObjectForm(self):  def manage_addCDLIFileForm(self):
     """add form"""      """interface for adding the OSAS_root"""
     pass      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
       return pt()
   
 def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):  def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
     """add"""      """add the OSAS_root"""
       newObj=CDLIFile(id,title,lockedBy,author)
           
     ob=BasketObject()      tryToggle=True
       tryCount=0
           
     ob.id=str(id)      self._setObject(id,newObj)                  
     ob.title=title      getattr(self,id).reindex_object()
     self._setObject(id, ob)  
     ob=self._getOb(id)  
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
 class CDLIBasketContainer(OrderedFolder):  def checkUTF8(data):
     """contains the baskets"""      """check utf 8"""
           try:
           data.encode('utf-8')
               return True
     meta_type="CDLIBasketContainer"      except:
               return False
           
     def getBasketIdfromName(self,basketname):  
         """get id from name"""  
   
         for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):  def checkFile(filename,data,folder):
             if basket[1].title==basketname:      """check the files"""
                 return basket[0]      # first check the file name
         else:      fn=filename.split(".") # no extension
             None  
     def uploadBasket_html(self,basketId='0'):      if not fn[0][0]=="P":
         """upload an atf file, html form"""          return False,"P missing in the filename"
         basketId=str(basketId)      elif len(fn[0])!=7:
         if not basketId=='0':          return False,"P number has not the right length 6"
             basketName=getattr(self.basketContainer,basketId).title      elif not checkUTF8(data):
           return False,"not utf-8"
         else:          else:
             basketName=""          return True,""
               
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)  
         return pt(basketId=basketId,basketName=basketName)  
         
   
   def splitatf(fh,dir=None,ext=None):
       """split it"""
       ret=None
       nf=None
       i=0
                   
     def index_html(self):      #ROC: why split \n first and then \r???
         """stanadard ansicht"""      if (type(fh) is StringType) or (type(fh) is UnicodeType):
         ext=self.ZopeFind(self,obj_ids=["index.html"])          iter=fh.split("\n")
       else:
           iter=fh.readlines()
           
       for lineTmp in iter:
           lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..
           for line in lineTmp.split("\r"):
               #logging.log("Deal with: %s"%line)
         if ext:          if ext:
             return ext[0][1]()                  i+=1
                           if (i%100)==0:
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)                      ext.result+="."
         return pt()                  if i==10000:
                           i=0
     def getStorageFolderRoot(self):                      ext.result+="<br>"
         """root des storage folders"""              #check if basket name is in the first line
         return self.cdli_main              if line.find("#atf basket")>=0: #old convention
                       ret=line.replace('#atf basket ','')
     def __init__(self,id,title):                  ret=ret.split('_')[0]
         """ init basket container"""              elif line.find("#basket:")>=0: #new convention
         self.id=id                  ret=line.replace('#basket: ','')
         self.title=title                  ret=ret.split('_')[0]
        
        
     def getBaskets(self,sortField='title'):  
         """get all baskets files"""  
   
         def sortName(x,y):  
             return cmp(x[1].title.lower(),y[1].title.lower())  
   
         def sortDate(x,y):  
             return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())  
   
                   
         def sortComment(x,y):              else:
                   if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
                       if nf:
                           nf.close() #close last file
   
                   
                       filename=line[1:].split("=")[0].rstrip()+".atf"
                       if dir:
                           filename=os.path.join(dir,filename)
                       nf=file(filename,"w")
                       logging.info("open %s"%filename)
                   if nf:    
                       nf.write(line.replace("\n","")+"\n")
                           
              try:               try:
                 xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()          nf.close()
              except:  
                 xc='ZZZZZZZZZZZZZ'.lower()  
              try:  
                 yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()  
              except:               except:
                 yc='ZZZZZZZZZZZZZ'.lower()          pass
           
       if not((type(fh) is StringType) or (type(fh) is UnicodeType)):
           fh.close()
       return ret,len(os.listdir(dir))
           
              if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):  
                                     
                  try:  class CDLIFileFolder(extVersionedFileFolder):
                      xc=x[1].getLastVersion().getComment().lower()      """CDLI File Folder"""
                  except:  
                      xc='ZZZZZZZZZZZZZ'.lower()  
                                             
              if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):      security=ClassSecurityInfo()
                  try:      meta_type="CDLI Folder"
                      yc=y[1].getLastVersion().getComment().lower()      file_meta_type=['CDLI file']
                  except:      folder_meta_type=['CDLI Folder']
                      yc='ZZZZZZZZZZZZZ'.lower()  
           
       file_catalog='CDLICatalog'
                             
                  return cmp(xc,yc)      #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
       tmpStore2={}
                   
         def sortAuthor(x,y):      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)
                           
             return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())      def setTemp(self,name,value):
           """set tmp"""
                   
         baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])          setattr(self,name,value)
                   
       deleteFileForm = PageTemplateFile("zpt/doDeleteFile", globals())
                   
         if sortField=='title':      def delete(self,ids,REQUEST=None):
             baskets.sort(sortName)          """delete these files"""
         elif sortField=='date':          if type(ids) is not ListType:
             baskets.sort(sortDate)              ids=[ids]
         elif sortField=='author':  
             baskets.sort(sortAuthor)  
         elif sortField=='comment':  
             baskets.sort(sortComment)  
   
         return baskets          self.manage_delObjects(ids)
   
           if REQUEST is not None:
               return self.index_html()
   
                                                 
     def getNewId(self):      def getVersionNumbersFromIds(self,ids):
         """createIds"""          """get the numbers of the current versions of documents described by their ids"""
         last=getattr(self,'last',0)  
         last +=1  
         while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:  
             last+=1  
           
         self.last=last          ret=[]
         return last          searchStr=" OR ".join(ids)
           
     def setActiveBasket(self,basketId,REQUEST=None):          founds=self.CDLICatalog.search({'title':searchStr})
         """store active basketId in a cookie"""  
         self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")  
         if REQUEST:  
             REQUEST.RESPONSE.redirect(REQUEST['URL1'])  
                           
     def getActiveBasket(self):          for found in founds:
         """get active basket from cookie"""              lastVersion=found.getObject().getContentObject()
               ret.append((found.getId,lastVersion))
           
           return ret
                   
         id= self.REQUEST.cookies.get('CDLIActiveBasket',None)      def getFile(self,fn):
         if id:          """get the content of the file fn"""
             obj=getattr(self,str(id),None)          logging.debug("getFile: %s"%repr(fn))
           if not self.hasObject(fn):
               # search deeper
               founds=getattr(self, self.file_catalog).search({'textid':fn})
               if founds:
                   obj=founds[0].getObject().getContentObject()
         else:          else:
             obj=None                  return "" 
         return obj          else:
               obj = self[fn].getContentObject()
           
     def getActualUserName(self):          return obj.getData()[0:] 
         """get name of the actualuser"""  
         return str(self.REQUEST['AUTHENTICATED_USER'])  
           
           
     def addBasket(self,newBasketName):      def checkCatalog(self,fn):
         """add a new basket"""          """check if fn is in the catalog"""
           #TODO add checkCatalog
                   
         ob=manage_addCDLIBasket(self,newBasketName)  
         return ob  
           
     def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):      def findObjectsFromListWithVersion(self,list,author=None):
         """store it"""          """find objects from a list with versions
         if not ids:          @param list: list of tuples  (cdliFile,version)
             ids=self.REQUEST.SESSION['fileIds']          """
           #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
           #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                           
         if type(ids) is not ListType:          pt=getattr(self,'filelistVersioned.html')
             ids=[ids]  
                   
         if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):          return pt(search=list,author=author)
             basketRet=self.addBasket(newBasketName)  
             self.setActiveBasket(basketRet.getId())  
             basket=getattr(self,basketRet.getId())  
         elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):  
             basket=self.getActiveBasket()  
                   
         added=basket.addObjects(ids)  
         back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)  
                   
       def getAllPNumbers(self):
           """get a list of all files (resp their p-numbers) stored"""
                   
         if fromFileList:          ret=[x.getId for x in  self.CDLICatalog()]
   
             return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)          return ret
                 
         if RESPONSE:      def expandFile(self,fileId,fileTree):
           """wildcard in fileID suche alle Treffer"""
           founds=self.CDLICatalog({'title':fileId})
           for found in founds:
               fileTree.add(found.getId)
               logging.debug("ADDD:"+found.getId)
                           
             RESPONSE.redirect(back)      def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None,REQUEST=None,returnHash=False,hash=None):
           """findObjectsFromList (, TAB oder LINE separated)"""
                           
         return True          logging.debug("start: findObjectsFromList")
           #logging.debug("start: findObjectsFromList"+repr(list))
           
 def manage_addCDLIBasketContainerForm(self):  
     """add the CDLIBasketContainer form"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)  
     return pt()  
   
 def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):          if upload: # list from file upload
     """add the basket"""              txt=upload.read()
     ob=CDLIBasketContainer(id,title)  
           
     self._setObject(id, ob)          if enterList:
               txt=enterList
           
     if RESPONSE is not None:          if upload or enterList:
         RESPONSE.redirect('manage_main')              txt=txt.replace(",","\n")
               txt=txt.replace("\t","\n")
               txt=txt.replace("\r","\n")
               idsTmp=txt.split("\n")
               ids=[]
               for id in idsTmp: # make sure that no empty lines
                   idTmp=id.lstrip().rstrip()
                   if len(idTmp)>0:
   
 class CDLIBasket(Folder,CatalogAware):                      ids.append(idTmp)
     """basket"""  
           
     meta_type="CDLIBasket"              #self.REQUEST.SESSION['ids']=" OR ".join(ids)
     default_catalog="CDLIBasketCatalog"  
           
     def getFile(self,obj):              pt=getattr(self,'filelist.html')
         return obj[1]              self.REQUEST.SESSION['searchList']=ids
               return pt(search=ids)
           
     def getFileLastVersion(self,obj):          if basketName:
         return obj[0]              #TODO: get rid of one of these..
           
     def getFileNamesInLastVersion(self):              pt=getattr(self,'filelist.html')
         """get content of the last version as list"""              return pt(basketName=basketName,numberOfObjects=numberOfObjects)
                   
         return [x[1].getId() for x in self.getLastVersion().getContent()]  
           
     def isActual(self,obj):          result =self.CDLICache.retrieve(hash)
         """teste ob im basket die aktuelle version ist"""          if result:
         actualNo=obj[1].getLastVersion().getVersionNumber()             logging.debug("give result from storage2")
         storedNo=obj[0].getVersionNumber()             return hash,result
         if actualNo==storedNo:  
             return True  
         else:  
             return False  
                   
     def history(self):          if list is not None: # got already a list
         """history"""    
   
         ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])              logging.debug(" ----List version")
         if ext:              ret=[]
             return getattr(self,ext[0][1].getId())()              fileTree=Set()
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self)              for fileId in list:
         return pt()  
           
     def getStorageFolderRoot(self):                  if fileId.find("*")>-1: #check for wildcards
         """root des storage folders"""                          self.expandFile(fileId,fileTree)
         return self.aq_parent.cdli_main  
           
     def __init__(self,id,title,shortDescription="",comment=""):                  elif len(fileId.split("."))==1:
         """init a CDLIBasket"""                          fileId=fileId+".atf"
                           fileTree.add(fileId)
                   #logging.debug("   -----:"+fileId)
                   #ret+=self.CDLICatalog({'title':fileId})
                   #x =self.getFileObject(fileId)
                   #if x is not None:
                   #    ret.append(x)
                   
         self.id=id  
         self.title=title  
         self.shortDescription=shortDescription  
         self.comment=comment  
     
         
               ids = fileTree & self.v_file_ids
               #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
               l=makelist(fileTree)[0:]
               #logging.debug("l-list:"+repr(l))
               self.REQUEST.SESSION['fileIds']=l#store fieldIds in session for further usage
               self.REQUEST.SESSION['searchList']=l
               #self.REQUEST.SESSION['searchList']=['P000001.atf']
             
               
               hash = md5.new(repr(makelist(fileTree))).hexdigest() # erzeuge hash als identification
               self.REQUEST.SESSION['hash']=hash
               #TODO: do I need garbage collection for v_tmpStore ?
               
               #logging.debug("Hash:"+repr(hash))
   #        
   #            if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash): 
   #               logging.debug("asking for storage")
   #               res=self.cdliRoot.v_tmpStore[hash]
   #               if res:
   #                   if returnHash == True:
   #                       return hash,res
   #                   return res
                         
     def getLastVersion(self):              #TODO: get rid of one of these..
         """hole letzte version"""              #ids=[x.getObject().getId() for x in ret]
         ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])]              ret=[(self.getFileObject(x),self.getFileObjectLastVersion(x)) for x in ids]
         ids.sort()  
         if len(ids)==0:  
             return None  
         else:      
             ob=getattr(self,str(ids[-1]))  
             return ob  
         
     def getVersions(self):              #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
         """get versions"""              #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
         versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])  
         return versions  
   
               if display:
                   pt=getattr(self,'filelist.html')
         
                   return pt(search=ids)
               else:     
                   #self.REQUEST.SESSION['hash'] = ret # store in session 
           
     def addObjects(self,ids,deleteOld=None):                  #logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))
         """generate a new version of the basket with objects added"""                  #logging.debug("HHHHHHNEU:"+repr(hash))
                   self.CDLICache.store(hash,ret)
                 
         lastVersion=self.getLastVersion()                  if returnHash == True:
                       return hash,ret
                   return ret
                   
         if lastVersion is None:  
             oldContent=[]  
         else:  
             oldContent=lastVersion.basketContent[0:]  
   
         if deleteOld:  
             oldContent=[]  
   
         newContent=[]          if start:
         added=0              RESPONSE.redirect("filelist.html?start:int="+str(start))
         for id in ids:  
             founds=self.CDLICatalog.search({'title':id})  
   
             for found in founds:      security.declareProtected('Manage','createAllFilesAsSingleFile')
                 if found.getObject() not in oldContent:      def createAllFilesAsSingleFile(self,RESPONSE=None):
                     #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version          """download all files"""
                     newContent.append((found.getObject().getLastVersion(),found.getObject()))  
                     added+=1  
   
         content=oldContent+newContent          def sortF(x,y):
               return cmp(x[0],y[0])
                   
         user=self.getActualUserName()          catalog=getattr(self,self.file_catalog)
           #tf,tfilename=mkstemp()
           if not hasattr(self.temp_folder,'downloadCounter'):
               self.temp_folder.downloadCounter=0
                   
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)          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!"""
           
         return added          self.temp_folder.downloadCounter+=1
           self._p_changed=1
           transaction.get().commit()
           
     def deleteObjects(self,ids,RESPONSE=None):          list=[(x.getId,x) for x in catalog()]
         """delete objects"""          list.sort(sortF)
         #TODO: implement delete Objects  
                   
 def manage_addCDLIBasketForm(self):  
     """add the CDLIBasketContainer form"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)  
     return pt()  
   
 def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):  
     """add the basket"""  
           
     id=str(self.getNewId())          RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
           RESPONSE.setHeader("Content-Type","application/octet-stream")
           tmp=""
           for l in list:
               obj=l[1].getObject()
           
     ob=CDLIBasket(id,title,shortDescription,comment)              if obj.meta_type=="CDLI file":
           
     self._setObject(id, ob)                  #os.write(tf,obj.getLastVersion().data)
                   if RESPONSE:
                       RESPONSE.write(obj.getData()[0:])
                       RESPONSE.write("\n")
                   self.temp_folder.downloadCounter-=1 
                   self._p_changed=1
           transaction.get().commit()
           #os.close(tf)
           #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
           return True
           
     if RESPONSE is not None:      def downloadFile(self,fn):
         RESPONSE.redirect('manage_main')          """download fn - not used yet"""
     else:          self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
         return ob          self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
           self.REQUEST.RESPONSE.write(file(fn).read())
   
 class CDLIBasketVersion(SimpleItem):  
     """version of a basket"""  
           
     meta_type="CDLIBasketVersion"  
           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):      def hasParent(self):
         """download all selected files in one file"""          """returns true falls subfolder"""
                   
         ret=""          if self.aq_parent.meta_type in self.folder_meta_type:
         lockedObjects={}              return True
           else:
               return False
                   
       def getFolders(self):
           """get all subfolders"""
           ret=[]
           folders=self.ZopeFind(self,obj_metatypes=self.folder_meta_type)
           for folder in folders:
               ret.append((folder[1],
                           len(self.ZopeFind(folder[1],obj_metatypes=self.folder_meta_type)),
                           len(self.ZopeFind(folder[1],obj_metatypes=self.file_meta_type))
                           ))
           return ret
   
         if lock:  
                           
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':      security.declareProtected('manage','index_html')
       def index_html(self):
           """main"""
           ext=self.ZopeFind(self,obj_ids=["index.html"])
           if ext:
               return ext[0][1]()
                                   
                 return "please login first"          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
           return pt()
   
             #check if a locked object exist in the basket.  
             lockedObjects={}  
             for object in self.basketContent:  
   
                 if not object[1].lockedBy=="":  manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
                     lockedObjects[object[1].title]=repr(object[1].lockedBy)  
                                         
                                           
             keys=lockedObjects.keys()  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)
                           
             if len(keys)>0 and (not procedure):      checkPermission=getSecurityManager().checkPermission
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)  
                 return pt()  
                     
             elif not procedure: #keine fails gesperrt dann alle donwloaden      if createUserF:
                 procedure="downloadAll"           if not checkPermission('Add User Folders', ob):
               raise Unauthorized, (
                     'You are not authorized to add User Folders.'
                     )
           ob.manage_addUserFolder()
                   
   
         for object in self.basketContent:      if REQUEST is not None:
           return self.manage_main(self, REQUEST, update_menu=1)
                           
                 if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):  class CDLIRoot(Folder):
                     ret+=object[0].data      """main folder for cdli"""
                                   
                 if lock and object[1].lockedBy=='':      meta_type="CDLIRoot"
                     object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']      downloadCounterBaskets=0 # counts the current basket downloads if counter > 10 no downloads are possible
   
         basket_name=self.aq_parent.title+"_V"+self.getId()      file_catalog = 'CDLICatalog'
                   
         #write basketname to header of atf file      # word splitter for search
         ret="#atf basket %s\n"%basket_name+ret      splitter = {'words':cdliSplitter.wordSplitter(),
                   'graphemes':cdliSplitter.graphemeSplitter()}
       
       
       def unicodify(self,txt):
           return unicodify(txt)
       def invalidateOldCacheVersion(self):
           """loescht die alte Version des Cache"""
           del self.v_tmpStore
           return "done"
       
       def viewATF(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           logging.debug(ob[0].getObject().getLastVersion().absolute_url()+"/view")
           if len(ob)>0:
               RESPONSE.redirect(ob[0].getObject().getLastVersion().absolute_url()+"/view")
           return "not found"
       
       def history(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/history")
           return "not found"
       
   
       def downloadLocked(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/downloadLocked")
           return "not found"
       
       def download(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].getLastVersion().absolute_url())
           return "not found"
       def addCDLIFileObjectForm(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/addCDLIFileObjectForm")
           return "not found"
       
       def addVersionedFileObjectForm(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/addVersionedFileObjectForm")
           return "not found"
       
       def unlock(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/unlock")
           return "not found"
       
       def getFileObject(self,fileId):
           """get an object"""
       if isinstance(fileId,CDLIFileObject): # support for old baskets
           return fileId
           x=self.v_files.get(fileId)
           #logging.debug("getFileObj:"+repr(fileId))
           return x
       
       def getFileObjectLastVersion(self,fileId):
           """get an object"""
           x=self.v_files_lastVersion.get(fileId)
           #logging.debug("lastVersion: "+repr(x))
           return x
       
       def showFileIds(self):
           """showIds"""
           return self.v_file_ids
       
       def generateFileBTree(self):
           """erzeuge einen Btree aus allen Files"""
           self.v_files = OOBTree()
           self.v_files_lastVersion = OOBTree()
           self.v_file_ids = Set()
           
           for x in self.CDLICatalog.searchResults():
               
               self.v_files.update({x.getId:x.getObject()})
               self.v_files_lastVersion.update({x.getId:x.getObject().getLastVersion()})
               self.v_file_ids.add(x.getId)
               logging.debug("add:"+x.getId+"XXX"+repr(x.getObject()))
                   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)          return True
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")  
         length=len(ret)  
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)  
         self.REQUEST.RESPONSE.write(ret)      
           
    
     def numberOfItems(self):  
         """return anzahl der elemente im basket"""  
         return len(self.basketContent)  
       
     def getTime(self):  
         """getTime"""  
         #return self.bobobase_modification_time().ISO()  
         
         if hasattr(self,'time'):  
             return time.strftime("%Y-%m-%d %H:%M:%S",self.time)  
         elif hasattr(self,'timefixed'):  
             return self.timefixed  
         else:  
             setattr(self,'timefixed',self.bobobase_modification_time().ISO())  
             return self.bobobase_modification_time().ISO()  
       
     def getContent(self):  
         """get Basket Content"""  
         return self.basketContent  
   
       
     def __init__(self,id,user,comment="",basketContent=[]):  
         """ init a basket version"""  
         self.id=id  
         self.coment=comment  
         self.basketContent=basketContent[0:]  
         self.user=user  
         self.time=time.localtime()  
           
     def getUser(self):  
         """get user"""  
         return self.user  
       
     def getComment(self):  
         """get Comment"""  
         return self.comment  
     
     def index_html(self):  
             """view the basket"""  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)  
             return pt()  
             
     def getObjUrl(self,result):      def updateOrAddToFileBTree(self,obj):
         """getUrl of the version of the object"""          """update a BTree"""
         objId=result[1].getTitle()          self.v_files.update({obj.getId():obj})
         founds=self.CDLICatalog.search({'title':objId})          self.v_files_lastVersion.update({obj.getId():obj.getLastVersion()})
         if len(founds)>0:  
              return founds[0].getObject().absolute_url()  
                     
         else: #assume version number          self.v_file_ids.add(obj.getId())
             splitted=objId.split("_")          logging.debug("update:"+obj.getId()+"XXX"+repr(obj))
             founds=self.CDLICatalog.search({'path':splitted[1]})          
             return founds[0].getObject().absolute_url()+'/'+objId  
         
 def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):      def deleteFromBTree(self,objId):
     """add a version"""          """delete an obj"""
           self.v_files.pop(objId)
           self.v_files_lastVersion.pop(objId)
           self.v_file_ids.remove(objId)
           
     #check for already existing versions  
     
     lastVersion=self.getLastVersion()  
     if lastVersion is None:  
         newId=str(1)  
     else:  
         newId=str(int(lastVersion.getId())+1)  
           
     ob=CDLIBasketVersion(newId,user,comment,basketContent)      def deleteFiles(self,ids):
           """delete files"""
           for id in ids:
               founds=self.CDLICatalog.search({'title':id.split(".")[0]})
               if founds:
                   logging.debug("deleting %s"%founds)
                   folder=founds[0].getObject().aq_parent #get the parent folder of the object
                   logging.debug("deleting from %s"%folder)
                   cut=folder.delete([founds[0].getId]) #cut it out
           
     self._setObject(newId, ob)  
           
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
     else:  
         return ob  
           
 class CDLIFileObject(versionedFileObject):      def searchText(self, query, index='graphemes'):
     """CDLI file object"""          """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 ""
           
     meta_type="CDLI File Object"          if wholePage:
               logging.debug("show whole page")
               return f[0].getObject().getContentObject().view()
           else:
               return f[0].getObject().getLastVersionFormattedData()
           
                   
     def view(self):      def showWordInFile(self,fileId,word,indexName='graphemes',regExp=False,):
         """view file"""          """get lines with word from FileId"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)          logging.debug("showwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
         return pt()  
           
 manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')          file = formatAtfFullLineNum(self.getFile(fileId))
           ret=[]
   
 def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',          # add whitespace before and whitespace and line-end to splitter bounds expressions
                    REQUEST=None):          bounds = self.splitter[indexName].bounds
     """Add a new File object.          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
   
     Creates a new File object 'id' with the contents of 'file'"""          return ret
   
     id=str(id)  
     title=str(title)  
     content_type=str(content_type)  
     precondition=str(precondition)  
           
     id, title = cookId(id, title, file)      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))
   
     self=self.this()          return dict([(id,self.showWordInFile(id, word, indexName, regExp)) for id in fileIds])
   
     # First, we create the file without data:  
     self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))  
     self._getOb(id).versionComment=str(vC)  
     self._getOb(id).time=time.localtime()  
           
     setattr(self._getOb(id),'author',author)      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)) 
           
     # Now we "upload" the data.  By doing this in two steps, we          file=self.getFile(fileId)
     # can use a database trick to make the upload more efficient.          tagStart=u'<span class="found">'
     if file:          tagEnd=u'</span>'
         self._getOb(id).manage_upload(file)          tagStr=tagStart + u'%%s' + tagEnd
     if content_type:          ret=[]
         self._getOb(id).content_type=content_type  
   
     if REQUEST is not None:          # add whitespace to splitter bounds expressions and compile into regexp object
         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')          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)
           
 class CDLIFile(versionedFile,CatalogAware):              ret.append(line)
     """CDLI file"""  
           
     meta_type="CDLI file"          return u'<br>\n'.join(ret)
     default_catalog='CDLICatalog'  
           
           
           
     def isContainedInBaskets(self,context=None):      def tagWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
         """check is this file is part of any basket          """
         @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog          get texts with highlighted word from all ids in list FileIds.
                         has to exist.          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])
   
         if not context:  
             context=self  
                           
         return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]      def getFileVersionList(self, pnum):
           """get the version history as a list for the translit file with the given pnum"""
           f = getattr(self, self.file_catalog).search({'textid':pnum})
           if not f:
               return []
                   
           return f[0].getObject().getVersionList()
                   
     def addCDLIFileObjectForm(self):  
         """add a new version"""  
                   
         if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:      def URLquote(self,str):
             return "please login first"          """quote url"""
         if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):          return urllib.quote(str)
             out=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject',version=self.getVersion()).__of__(self)  
             return out()  
         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 URLunquote(self,str):
         """add"""          """unquote url"""
         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden          return urllib.unquote(str)
             vC=self.REQUEST['vC']  
         except:  
             pass  
                   
         author=self.REQUEST['author']      def URLquote_plus(self,str):
           """quote url"""
           return urllib.quote_plus(str)
                   
         if changeName=="yes":      def URLunquote_plus(self,str):
             filename=file.filename          """unquote url"""
             self.title=filename[max(filename.rfind('/'),          return urllib.unquote_plus(str)
                         filename.rfind('\\'),  
                         filename.rfind(':'),  
                         )+1:]  
   
       def changeUserForPObjectFromFile(self,user,fname):
           """aendere user fuer alle p in fiele"""
           pns = file(os.path.join(package_home(globals()),'inputs',fname),"r")
           for p in pns.readlines():
               p=p.lstrip().rstrip()
               logging.info(str(p+".atf"))
               pObj=self.getFileObject(p+".atf")
               if pObj is not None:  
                   logging.info(pObj)
                   lv=pObj.getContentObject()
                   logging.info("author:"+lv.author)
                   lv.author=user
                   lv.versionComment="XXXXXXX"
   
         if not newName=='':  
             self.title=newName[0:]  
                   
                   
   
       def forceunlock(self,REQUEST=None,user=None):
           "break all locks"
           ret=[]
                   
           for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
              un=f[1].forceunlock(user=user)
              logging.info("check:"+f[0])
              if un and un !="":
                  ret.append((f[0],un))
                   
         positionVersionNum=getattr(self,'positionVersionNum','front')          if REQUEST is not None:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','breakLockResponse.zpt')).__of__(self)
                   
         if positionVersionNum=='front':              return pt(ret=ret)
             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()  
                           
           return ret
                   
         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()  
   
         if RESPONSE:      def getLockedFiles(self,REQUEST=None,user=None):
             obj=self.ZopeFind(self,obj_ids=[id])[0][1]          """hole alle gesperrten files"""
             if obj.getSize()==0:          ret={}
                 self.REQUEST.SESSION['objID']=obj.getId()      
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)          for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
                 return pt()              lb = f[1].lockedBy
               add=False
               if (lb is not None) and (lb!=""):
                  
                   if user is None:
                       add=True
                   else:
                       if str(lb)==user:
                           add=True
                   if add==True:
                       if not ret.has_key(lb):
                           ret[lb]=[]
                       ret[lb].append(f[0])
   
             else:  
                 RESPONSE.redirect(self.REQUEST['URL2'])  
   
         else:          if REQUEST is not None:
             return self.ZopeFind(self,obj_ids=[id])[0][1]              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showlockResponse.zpt')).__of__(self)
                   
               return pt(ret=ret)
                   
 def manage_addCDLIFileForm(self):          return ret
     """interface for adding the OSAS_root"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)  
     return pt()  
   
 def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):      def getChangesByAuthor(self,author,n=100):
     """add the OSAS_root"""          """getChangesByAuthor"""
     newObj=CDLIFile(id,title,lockedBy,author)          zcat=self.CDLIObjectsCatalog
     self._setObject(id,newObj)          res=zcat({'lastEditor':author,
                        'sort_on':'getTime',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
         
     if RESPONSE is not None:          return res
         RESPONSE.redirect('manage_main')  
   
       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 splitatf(fh,dir=None):      def getLastChanges(self,n=100):
     """split it"""          """get the last n changes""" 
     ret=None          n=int(n)                   
     nf=None          zcat=self.CDLICatalog
     for line in fh.readlines():          return zcat({'sort_on':'getLastChangeDate',
         #check if basket name is in the first line                       'sort_order':'descending',
         if line.find("#atf basket")>=0:                       'sort_limit':n})[:n ]
             ret=line.replace('#atf basket ','')  
             ret=ret.split('_')[0]  
         else:  
             if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile  
                 if nf:  
                     nf.close() #close last file  
                           
                                   
                 filename=line[1:].split("=")[0].rstrip()+".atf"      def getLastChanges_html(self,n=100):
                 if dir:          """get the last n changes"""
                     filename=os.path.join(dir,filename)          list = [x.getId for x in self.getLastChanges(n)]
                 nf=file(filename,"w")          return self.cdli_main.findObjectsFromList(list=list,display=True)
             if nf:      
                 nf.write(line)  
                   
     nf.close()      def refreshTxt(self,txt="",threadName=None):
     fh.close()          """txt fuer refresh"""
     return ret,len(os.listdir(dir))  
   
 class CDLIFileFolder(versionedFileFolder):          return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
     """CDLI File Folder"""  
           
     meta_type="CDLI Folder"      def refreshTxtBasket(self,txt="",threadName=None):
     filesMetaType=['CDLI file']          """txt fuer refresh"""
     folderMetaType=['CDLI Folder']  
     default_catalog='CDLICatalog'  
           
     def getVersionNumbersFromIds(self,ids):          return """ 2;url=%s?repeat=%s """%(txt,threadName)
         """get the numbers of the current versions of documents described by their ids"""  
                   
         ret=[]  
         searchStr=" OR ".join(ids)  
                   
         founds=self.CDLICatalog.search({'path':searchStr})      def getResult(self,threadName=None):
          """result of thread"""
          try:
           return self._v_uploadATF[threadName].getResult()
          except:
           return "One moment, please"
       
                   
         for found in founds:      def checkThreads(self):
             lastVersion=found.getObject().getLastVersion()          """check threads"""
             ret.append((found.getId,lastVersion))          ret="<html><body>"
           for thread in threading.enumerate():
              ret+="<p>%s (%s): %s</p>"%(repr(thread),thread.getName(),thread.isAlive())
                   
         return ret          return ret
           
     
     def uploadATF(self,upload,basketId=0,RESPONSE=None):      def uploadATFRPC(self,data,username):
         """upload an atf file"""          """upload an atffile via xml-rpc"""
         #TODO: add comments          uploader=uploadATFThread()
         #TODO: finish uploadATF  
         basketId=str(basketId)  
           
                   
           #generate an random id for the upload object
           from random import randint
           if (not self.REQUEST.SESSION.get('idTmp',None)):
                   
         dir=mkdtemp()              idTmp=str(randint(0,1000000000))
         changed=[]              self.REQUEST.SESSION['idTmp']=idTmp
         errors=[]  
         newPs=[]  
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)  
         if basketId == '0':  
             basketNameFromId=""  
             basketLen=0  
         else:          else:
             basketNameFromId=getattr(self.basketContainer,basketId).title              idTmp=self.REQUEST.SESSION.get('idTmp',None)
             basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems()  
                           
                           
         for fn in os.listdir(dir):          uploader.set(data,0,username,idTmp)
             founds=self.CDLICatalog.search({'title':fn})      
               
             if len(founds)==0:          stObj=uploader.run()
                 newPs.append(fn)  
                                   
             for found in founds:          processor=uploadATFfinallyThread()
                 obj=found.getObject()  
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):          basketname=stObj.returnValue['basketNameFromFile']
                     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)          processor.set("uploadchanged",basketname=basketname,SESSION=stObj.returnValue,username=username,serverport=self.REQUEST['SERVER_PORT'])
         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):          processor.run()
         """upload the files"""  
                   
         if procedure=="uploadchanged":  
             uploadFns=self.REQUEST.SESSION['changed']+self.REQUEST.SESSION['newPs']  
           
         elif procedure=="uploadAll":  
             uploadFns=[]  
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                 if not x in self.REQUEST.SESSION['errors']:  
                     uploadFns.append(x)  
         else:  
             uploadFns=[]  
                           
         for fn in uploadFns:          return generateXMLReturn(stObj.returnValue)
             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 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)):
                                   
         newPs=self.REQUEST.SESSION['newPs']              idTmp=str(randint(0,1000000000))
         if len(newPs)>0:              self.REQUEST.SESSION['idTmp']=idTmp
             tmpDir=self.REQUEST.SESSION['tmpdir']          else:
                       idTmp=self.REQUEST.SESSION.get('idTmp',None)
             self.cdli_main.importFiles(comment=comment,author=str(self.REQUEST['AUTHENTICATED_USER']) ,folderName=tmpDir, files=newPs)  
                                   
                   
           threadName=repeat
           if not threadName or threadName=="":
               #new thread not called from the waiting page
               tmpVar=False
                   
         #unlock              thread=uploadATFThread()
         if unlock:              threadName=thread.getName()[0:]                                
             unlockFns=[]              if (not hasattr(self,'_v_uploadATF')):
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):                     self._v_uploadATF={}
                     if not x in self.REQUEST.SESSION['errors']:  
                         unlockFns.append(x)  
                           
             for fn in unlockFns:              self._v_uploadATF[threadName]=thread
                 founds=self.CDLICatalog.search({'path':fn})              #self._xmltrans.start()
                 if len(founds)>0:              #thread=Thread(target=self._v_uploadATF)
                     self.REQUEST['author']=str(self.REQUEST['AUTHENTICATED_USER'])              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()
                                         
                     founds[0].getObject().lockedBy=""  
                                           
         if not (basketname ==''):              self.threadName=self._v_uploadATF[threadName].getName()[0:]
             basketId=self.basketFolder.getBasketIdfromName(basketname)              wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                           
             basket=getattr(self.basketFolder,basketId)              if wait_template:
             ids=os.listdir(self.REQUEST.SESSION['tmpdir'])                  return wait_template[0][1]()
             basket.addObjects(ids,deleteOld=True)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
               return pt(txt='/uploadATF',threadName=threadName)
               #_v_xmltrans.run()
                                   
         if RESPONSE is not None:          else:
             RESPONSE.redirect(self.aq_parent.absolute_url())              #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):
   
     def findObjectsFromList(self,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):  
         """findObjectsFromList (, TAB oder LINE separated)"""  
         if upload: # list from file upload  
             txt=upload.read()  
             txt=txt.replace(",","\n")  
             txt=txt.replace("\t","\n")  
             idsTmp=txt.split("\n")  
             ids=[]  
             for id in idsTmp: # make sure that no empty lines  
                 idTmp=id.lstrip().rstrip()  
                 if len(idTmp)>0:  
                                           
                     ids.append(idTmp)                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   if wait_template:
                           return wait_template[0][1]()
                                           
             #self.REQUEST.SESSION['ids']=" OR ".join(ids)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                           
             pt=getattr(self,'filelist.html')                  return pt(txt='/uploadATF',threadName=threadName)
             self.REQUEST.SESSION['searchList']=ids  
             return pt(search=ids)  
                   
         if basketName:              else:
             #TODO: get rid of one of these..                  tmp=getattr(self.temp_folder,idTmp).returnValue
                           
             pt=getattr(self,'filelist.html')                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
             return pt(basketName=basketName,numberOfObjects=numberOfObjects)  
                   
         if list: # got already a list                  return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
             ret=[]                    basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
             for fileId in list:  
                 if len(fileId.split("."))==1:  
                         fileId=fileId+".atf"  
                                                   
                 ret+=self.CDLICatalog({'title':fileId})      def redoUpload(self,threadName):
             #TODO: get rid of one of these..         """redo the upload"""
             self.REQUEST.SESSION['fileIds']=[x.getObject().getId() for x in ret]#store fieldIds in session for further usage         tmp=self.cdli_main.tmpStore2[threadName]
             self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
             return ret         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'])
                   
         if start:      def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
             RESPONSE.redirect("filelist.html?start:int="+str(start))          """nowupload the files"""
           
     def createAllFilesAsSingleFile(self,RESPONSE=None):  
         """download all files"""  
                   
         def sortF(x,y):  
             return cmp(x[0],y[0])  
                   
         catalog=getattr(self,self.default_catalog)          threadName=repeat
         #tf,tfilename=mkstemp()          if not threadName or threadName=="":
               thread=uploadATFfinallyThread()
               threadName=thread.getName()[0:]
                   
               if (not hasattr(self,'_v_uploadATF')):
                                   self._v_uploadATF={}
                   
         list=[(x.getId,x) for x in catalog()]  
         list.sort(sortF)  
                   
         RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")              self._v_uploadATF[threadName]=thread
         RESPONSE.setHeader("Content-Type","application/octet-stream")  
                 
         for l in list:              idTmp=self.REQUEST.SESSION['idTmp']
             obj=l[1].getObject()              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'])
                           
             if obj.meta_type=="CDLI file":              self._v_uploadATF[threadName].start()
                                   
                 #os.write(tf,obj.getLastVersion().data)  
                 if RESPONSE:  
                     RESPONSE.write(obj.getLastVersion().data)  
         #os.close(tf)  
         #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)  
         return True  
           
     def downloadFile(self,fn):  
         """download fn - not used yet"""  
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())  
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")  
         self.REQUEST.RESPONSE.write(file(fn).read())  
                   
               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)
                                   
     def hasParent(self):              return pt(txt='/uploadATFfinally',threadName=threadName)
         """returns true falls subfolder"""              #_v_xmltrans.run()
               
         if self.aq_parent.meta_type in self.folderMetaType:  
             return True  
         else:          else:
             return False              #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
                   
     def getFolders(self):              if self._v_uploadATF.get(threadName,None) and (self._v_uploadATF[threadName] is not None) and (not self._v_uploadATF[threadName].end) :
         """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(self.ZopeFind(folder[1],obj_metatypes=self.filesMetaType))  
                         ))  
         return ret  
           
                   wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   if wait_template:
                           return wait_template[0][1]()
                           
     def getFolders_OLD(self):                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
         """get all subfolders"""                  return pt(txt='/uploadATFfinally',threadName=threadName)
         ret=[]              else:
         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):  
         """main"""  
         ext=self.ZopeFind(self,obj_ids=["index.html"])  
         if ext:  
             return ext[0][1]()  
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)                idTmp=self.REQUEST.SESSION['idTmp']
         return pt()                stObj=getattr(self.temp_folder,idTmp) 
                 self.REQUEST.SESSION['idTmp']=None
           
     def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None):                #update changed
         """import files"""                logging.debug("dir:"+repr(stObj.returnValue['changed']))
                 for x in stObj.returnValue['changed']:
                       ob=self.CDLICatalog.search({'title':x[0]})
                       try:
                           self.cdliRoot.updateOrAddToFileBTree(ob[0].getObject())
                       except:
                           logging.error("uploadATFfinally - cannot update Object %s Error: %s %s"%(ob[1],sys.exc_info()[0],sys.exc_info()[1]))
                 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])  
                           
             if not obj:              #check if main folder PXX already exists
                 manage_addCDLIFileFolder(self,folder,folder)              obj=self.ZopeFind(root,obj_ids=[folder])
                 fobj=getattr(self,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 create it
                   manage_addCDLIFileFolder(root,folder,folder)
                   fobj=getattr(root,folder)
                   #transaction.get().commit()                           
                   
             else:              else:
                 fobj=obj[0][1]                  fobj=obj[0][1]
                           
               #check IF PYYYYY already exist
             obj2=fobj.ZopeFind(fobj,obj_ids=[f2])              obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
               logging.debug("importFiles: fobj=%s obj2=%s"%(fobj,obj2)) 
                   
             if not obj2:              if not obj2:# if not create it
                 manage_addCDLIFileFolder(fobj,f2,f2)                  manage_addCDLIFileFolder(fobj,f2,f2)
                 fobj2=getattr(fobj,f2)                  fobj2=getattr(fobj,f2)
                   
             else:              else:
                 fobj2=obj2[0][1]                  fobj2=obj2[0][1]
                               
             file2=file(os.path.join(folderName,f))                 # not add the file
               file2=os.path.join(folderName,f)  
             id=f              id=f
             manage_addCDLIFile(fobj2,f,'','')              logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))
             id=f              fobj2.addFile(vC='',file=file(file2),author=author,newName=f)
             ob=fobj2._getOb(f)              count+=1
             ob.title=id              
                           #now add the file to the storage
             manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')              ob = getattr(fobj2,f)
             self.CDLICatalog.catalog_object(ob)              self.cdliRoot.updateOrAddToFileBTree(ob)
             #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)              
             #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])              if count%100==0:
                   logging.debug("importfiles: committing")
                   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 1154  def manage_addCDLIFileFolder(self, id, t Line 1403  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 1174  def manage_addCDLIFileFolder(self, id, t Line 1426  def manage_addCDLIFileFolder(self, id, t
         return self.manage_main(self, REQUEST, update_menu=1)          return self.manage_main(self, REQUEST, update_menu=1)
   
   
   import cdli_basket
   
   
   # Die folgenden Klassen sollte nicht mehr aus diesem Paket benutzt werden, sondern direkt aus
   # cdli_basket importiert werden.
   class uploadATFfinallyThread(cdli_basket.uploadATFfinallyThread):
       """depricates"""
       pass
   
   class tmpStore(cdli_basket.tmpStore):
       """depricated"""
       pass
   
   class uploadATFThread(cdli_basket.uploadATFThread):
       """depricated"""
       pass
   
   class CDLIBasketContainer(cdli_basket.CDLIBasketContainer):
       """depricated"""
       pass
   
   class CDLIBasket(cdli_basket.CDLIBasket):
       """depricated"""
       pass
   
   class CDLIBasketVersion(cdli_basket.CDLIBasketVersion):
       """depricated"""
       pass
   
   class BasketContent(cdli_basket.BasketContent):
       """depricated"""
       pass
       
Removed from v.1.8  
changed lines
  Added in v.1.108

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