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

Diff for /cdli/cdli_files.py between versions 1.15 and 1.110

version 1.15, 2006/05/04 14:40:09 version 1.110, 2009/06/21 11:28:37
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  from OFS.Folder import manage_addFolder
 import re  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
   
 class Basket_old(Folder):  from cdli_helpers import *
     """shopping basket - alte fassung """  
           
     meta_type="Basket"  class CDLIFileObject(CatalogAware,extVersionedFileObject):
     _v_stack={}      """CDLI file object"""
   
     def getObjUrl(self,objId):      meta_type="CDLI File Object"
         """getUrl"""      default_catalog='CDLIObjectsCatalog'
         founds=self.CDLICatalog.search({'title':objId})  
         if len(founds)>0:  
              return founds[0].getObject().absolute_url()  
            
         else: #assume version number  
             splitted=objId.split("_")  
             founds=self.CDLICatalog.search({'title':splitted[1]})          
             return founds[0].getObject().absolute_url()+'/'+objId  
           
     def storeAllLink(self,results):  
         """erzeuge link zum speicher aller results"""  
         nr=self.REQUEST['_ZopeId']  
                   
         if results:      security=ClassSecurityInfo()
             self._v_stack[nr]=[x.getObject().getId() for x in results]  
                   
         return self.absolute_url()+"/storeAll?id="+nr      security.declareProtected('manage','index_html')
           
     def storeAll(self,id):      security.declarePublic('view')
         """store all"""      view = PageTemplateFile('zpt/viewCDLIFile.zpt', globals())
         try:  
             results=self._v_stack[id]  
         except:  
             #TODO: write expired page  
             return "expired"  
                   
         return self.storeInBasketForm(results)      security.declarePublic('editATF')
       editATF = PageTemplateFile('zpt/editATFFile.zpt', globals())
                   
     def storeInBasketForm(self,ids):      def PrincipiaSearchSource(self):
         """ store an object form"""             """Return cataloguable key for ourselves."""
              return str(self)
                   
         if type(ids) is not ListType:      def setAuthor(self, author):
             ids=[ids]          """change the author"""
         self.REQUEST.SESSION['ids']=ids[0:]          self.author = author
                   
         self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']      def makeThisVersionCurrent_html(self):
           """form for mthis version current"""
   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
         return pt()          return pt()
                   
     def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):      security.declarePublic('makeThisVersionCurrent')
         """store it"""      def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
                   """copy this version to current"""
         if not ids:          parent=self.aq_parent
             ids=REQUEST.SESSION['ids']          parent.manage_addVersionedFileObject(id=None,vC=comment,author=author,file=self.getData(),RESPONSE=RESPONSE)
                       #newversion=parent.manage_addCDLIFileObject('',comment,author)
         self.REQUEST.SESSION['basketUser']=username          #newversion.manage_upload(self.getData())
           
         baskets=self.ZopeFind(self,obj_ids=[username])  
         if len(baskets)>0:  
             basket=baskets[0][1]  
         else:  
             manage_addBasketObject(self,username)  
             basket=self._getOb(username)  
           
           
         basket.addObjects(ids)  
         back=self.REQUEST.SESSION.get('BACKLINK', None)  
   
         if RESPONSE:  
             RESPONSE.redirect(back)  
               
   
       
     def showBasket(self,user=None,set=None,RESPONSE=None):  
         """show the basket"""  
                   
         if user:          #if RESPONSE is not None:
             self.REQUEST.SESSION['basketUser']=user          #    RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
                   
         if not user and not set:  
             user=self.REQUEST.SESSION.get('basketUser',None)  
           
         if not user:  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)  
             return pt()  
         else:  
             baskets=self.ZopeFind(self,obj_ids=[user])  
           
   
         if len(baskets)>0:  
             RESPONSE.redirect(baskets[0][1].absolute_url())  
             return True               return True 
         else:  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)  
             return pt()  
           
   
 def manage_addBasket_oldForm(self):  
     """add the basket form"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)  
     return pt()  
   
 def manage_addBasket_old(self,id,title,RESPONSE=None):      def getFormattedData(self):
     """add the basket"""          """fromat text"""
     ob=Basket()          data=self.getData()
       #        return re.sub("\s\#lem"," #lem",data) #remove return vor #lem
     ob.id=str(id)          return re.sub("#lem","       #lem",data) #remove return vor #lem
     ob.title=title  
     self._setObject(id, ob)  
     ob=self._getOb(id)  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
           
 class BasketObject_old(Folder):      security.declarePublic('getPNumber')
     """Basket Object - alte fassung"""      def getPNumber(self):
               """get the pnumber"""
     meta_type="basketObject"          try:
     def __init__(self):                  txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
             """init basket object"""          except:
             self.contents=[]                  txt=self.getData()[0:]
   
     def numberOfItems(self):  
         """return anzahl der elemente im basket"""  
         return len(self.contents)  
           
     def addObjects(self,ids):                  return "ERROR"
         """addObjects"""          try:
               return "P"+txt.group(1)
           except:
               return "ERROR"
                   
         for id in ids:      security.declarePublic('getDesignation')
             founds=self.CDLICatalog.search({'title':id})      def getDesignation(self):
             for found in founds:          """get the designation out of the file"""
                 if found.getObject() not in self.contents:          try:
                     tm=self.contents[0:]                  txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
                     tm.append(found.getObject())          except:
                     self.contents=tm[0:]                  txt=self.getData()[0:]
           
         return True                  return "ERROR"
           try:
               return txt.group(2)
           except:
               return "ERROR"
   
     def index_html(self):  
             """view the basket"""  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)  
             return pt()  
   
     def deleteObjects(self,ids,RESPONSE=None):  manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
         """delete objects"""  
         list = self.contents[0:]  
         for content in list:  
                                 
                 if content.getId() in ids:  def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',versionNumber=0,
                     self.contents.remove(content)                               precondition='', content_type='',
                                from_tmp=False,REQUEST=None):
       """Add a new File object.
       Creates a new File object 'id' with the contents of 'file'"""
                   
       id=str(id)
       title=str(title)
       content_type=str(content_type)
       precondition=str(precondition)
   
         if RESPONSE:      id, title = cookId(id, title, file)
                 RESPONSE.redirect(self.absolute_url())  
   
       self=self.this()
   
     def unlockTest(self):      # First, we create the file without data:
         """unlock all files of the testuser for debuggin"""      self._setObject(id, CDLIFileObject(id,title,versionNumber=versionNumber,versionComment=vC,time=time.localtime(),author=author))
         for object in self.contents:      fob = self._getOb(id)
   
                 if str(object.lockedBy)=="test":      # Now we "upload" the data.  By doing this in two steps, we
                     object.lockedBy=""      # can use a database trick to make the upload more efficient.
                           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):      if file and not from_tmp:
         """download all selected files in one file"""          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
                   
         ret=""      #logging.debug("manage_add: lastversion=%s"%self.getData())
         lockedObjects={}      logging.debug("reindex1: %s in %s"%(repr(self),repr(self.default_catalog)))
       self.reindex_object()
       #logging.debug("manage_add: fob_data=%s"%fob.getData())
       logging.debug("reindex2: %s in %s"%(repr(fob), repr(fob.default_catalog)))
       fob.index_object()
                   
       self.CDLIRoot.updateOrAddToFileBTree(ob)
       if REQUEST is not None:
           REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
   
         if lock:  
                           
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':  class CDLIFile(extVersionedFile,CatalogAware):
       """CDLI file"""
                                   
                 return "please login first"      security=ClassSecurityInfo()
       meta_type="CDLI file"
       content_meta_type = ["CDLI File Object"]
   
             #check if a locked object exist in the basket.      default_catalog='CDLICatalog'
             lockedObjects={}  
             for object in self.contents:  
   
                 if not object.lockedBy=="":      security.declareProtected('manage','index_html')
                     lockedObjects[object.title]=repr(object.lockedBy)  
                                         
       def getLastVersionData(self):
           """get last version data"""
           return self.getData()
   
       def getLastVersionFormattedData(self):
           """get last version data"""
           return self.getContentObject().getFormattedData()
   
       def getTextId(self):
           """returns P-number of text"""
           # assuming that its the beginning of the title
           return self.title[:7]
                                           
             keys=lockedObjects.keys()      #security.declarePublic('history')
       def history(self):
           """history"""  
                           
           ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
           if ext:
               return getattr(self,ext[0][1].getId())()
                           
             if len(keys)>0 and (not procedure):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)  
                 return pt()                  return pt()
                     
             elif not procedure: #keine fails gesperrt dann alle donwloaden  
                 procedure="downloadAll"   
                   
         print procedure          def getBasketFromId(self,basketid, context=None):
         for object in self.contents:          """get basket from id"""
                           
                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):          if not context:
                     ret+=object.getLastVersion().data              context=self
                                   
                 if lock and object.lockedBy=='':          for basket in self.ZopeFind(context,obj_metatypes=["CDLIBasket"]):
                     object.lockedBy=self.REQUEST['AUTHENTICATED_USER']              if basket[0]==basketid:
                   return basket[1]
           else:
               None
   
   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())      def isContainedInBaskets(self,context=None):
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")          """check is this file is part of any basket
         length=len(ret)          @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)                          has to exist.
         self.REQUEST.RESPONSE.write(ret)              """
                   
           if not context:
               context=self
                   
 def manage_addBasket_oldObjectForm(self):          ret=[]
     """add form"""          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      pass
           return ret
 def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):          #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]
     """add"""  
       
     ob=BasketObject()  
       
     ob.id=str(id)  
     ob.title=title  
     self._setObject(id, ob)  
     ob=self._getOb(id)  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
   
 class CDLIBasketContainer(OrderedFolder):      def _newContentObject(self, id, title='', versionNumber=0, versionComment=None, time=None, author=None):
     """contains the baskets"""          """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)
           
   
     security=ClassSecurityInfo()      def addCDLIFileObjectForm(self):
     meta_type="CDLIBasketContainer"          """add a new version"""
       
     def deleteBaskets(self,ids=None):  
         """delete baskets, i.e. move them into trash folder"""  
                   
           if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
               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"
                   
         found=self.ZopeFind(self,obj_ids=['trash'])      def manage_addCDLIFileObject(self,id,vC,author,
                                    file='',title='',
                                    precondition='', 
                                    content_type='',
                                    changeName='no',newName='', 
                                    come_from=None,
                                    from_tmp=False,RESPONSE=None):
           """add"""
                   
         if len(found)<1:          try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
             manage_addFolder(self, 'trash')              vC=self.REQUEST['vC']
             trash=self._getOb('trash')          except:
         else:              pass
             trash=found[0][1]  
                   
         if type(ids) is not ListType:          ob = self.addContentObject(id, vC, author, file, title, changeName=changeName, newName=newName, from_tmp=from_tmp,
             ids=[ids]                                     precondition=precondition, content_type=content_type)
         cut=self.manage_cutObjects(ids)  
         trash.manage_pasteObjects(cut)  
                   
     def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):          try:
         """manage baskets, delete or copy"""              #FIXME: wozu ist das gut?
         if submit=="delete":              self.REQUEST.SESSION['objID_parent']=self.getId()
             self.deleteBaskets(ids)          except:
               pass
                   
           #self.cdliRoot.updateOrAddToFileBTree(self)# now update the object in the cache
                 
                           
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect(self.absolute_url())              if ob.getSize()==0:
     def getBasketIdfromName(self,basketname):                  self.REQUEST.SESSION['objID']=ob.getId()
         """get id from name"""                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
                   return pt()
         for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):  
             if basket[1].title==basketname:  
                 return basket[0]  
         else:          else:
             None                  if come_from and (come_from!=""):
                           RESPONSE.redirect(come_from+"?change="+self.getId())
     security.declareProtected('manage','uploadBasket_html')          
               
     def uploadBasket_html(self,basketId='0'):  
         """upload an atf file, html form"""  
           
   
         basketId=str(basketId)  
         if not basketId=='0':  
             basketName=getattr(self.basketContainer,basketId).title  
         else:          else:
             basketName=""                      RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
                       else:
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)              return ob
         return pt(basketId=basketId,basketName=basketName)  
      
   
                   
     def index_html(self):  def manage_addCDLIFileForm(self):
         """stanadard ansicht"""      """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):
       """add the OSAS_root"""
       newObj=CDLIFile(id,title,lockedBy,author)
   
       tryToggle=True
       tryCount=0
   
         ext=self.ZopeFind(self,obj_ids=["index.html"])      self._setObject(id,newObj)                  
         if ext:      getattr(self,id).reindex_object()
             return ext[0][1]()  
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)      if RESPONSE is not None:
         return pt()          RESPONSE.redirect('manage_main')
           
     def getStorageFolderRoot(self):  
         """root des storage folders"""  
         return self.cdli_main  
           
     def __init__(self,id,title):  def checkUTF8(data):
         """ init basket container"""      """check utf 8"""
         self.id=id      try:
         self.title=title          data.encode('utf-8')
           return True
       except:
           return False
             
             
     def getBaskets(self,sortField='title'):  def checkFile(filename,data,folder):
         """get all baskets files"""      """check the files"""
       # first check the file name
       fn=filename.split(".") # no extension
   
       if not fn[0][0]=="P":
           return False,"P missing in the filename"
       elif len(fn[0])!=7:
           return False,"P number has not the right length 6"
       elif not checkUTF8(data):
           return False,"not utf-8"
       else:
           return True,""
   
         def sortName(x,y):  
             return cmp(x[1].title.lower(),y[1].title.lower())  
   
         def sortDate(x,y):  def splitatf(fh,dir=None,ext=None):
             return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())      """split it"""
       ret=None
       nf=None
       i=0
   
       #ROC: why split \n first and then \r???
       if (type(fh) is StringType) or (type(fh) is UnicodeType):
           iter=fh.split("\n")
       else:
           iter=fh.readlines()
           
       for lineTmp in iter:
           lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..
           for line in lineTmp.split("\r"):
               #logging.log("Deal with: %s"%line)
               if ext:
                   i+=1
                   if (i%100)==0:
                       ext.result+="."
                   if i==10000:
                       i=0
                       ext.result+="<br>"
               #check if basket name is in the first line
               if line.find("#atf basket")>=0: #old convention
                   ret=line.replace('#atf basket ','')
                   ret=ret.split('_')[0]
               elif line.find("#basket:")>=0: #new convention
                   ret=line.replace('#basket: ','')
                   ret=ret.split('_')[0]
                   
         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:          for found in founds:
             REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+REQUEST['QUERY_STRING'])              lastVersion=found.getObject().getContentObject()
               ret.append((found.getId,lastVersion))
                           
     def getActiveBasket(self):          return ret
         """get active basket from cookie"""  
                   
         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):  
         """get name of the actualuser"""  
         return str(self.REQUEST['AUTHENTICATED_USER'])  
       
       
     def addBasket(self,newBasketName):  
         """add a new basket"""  
                   
         ob=manage_addCDLIBasket(self,newBasketName)          return obj.getData()[0:] 
         return ob  
           
     def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):  
         """store it"""  
         if not ids:  
             ids=self.REQUEST.SESSION['fileIds']  
                           
         if type(ids) is not ListType:      def checkCatalog(self,fn):
             ids=[ids]          """check if fn is in the catalog"""
           #TODO add checkCatalog
                   
         if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):  
             basketRet=self.addBasket(newBasketName)  
             self.setActiveBasket(basketRet.getId())  
             basket=getattr(self,basketRet.getId())  
         elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):  
             basket=self.getActiveBasket()  
                   
         added=basket.addObjects(ids)      def findObjectsFromListWithVersion(self,list,author=None):
         back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)          """find objects from a list with versions
           @param list: list of tuples  (cdliFile,version)
           """
           #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
           #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                   
           pt=getattr(self,'filelistVersioned.html')
                   
         if fromFileList:          return pt(search=list,author=author)
   
             return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)  
                 
         if RESPONSE:      def getAllPNumbers(self):
           """get a list of all files (resp their p-numbers) stored"""
                           
             RESPONSE.redirect(back)          ret=[x.getId for x in  self.CDLICatalog()]
                           
         return True          return ret
           
 def manage_addCDLIBasketContainerForm(self):      def expandFile(self,fileId,fileTree):
     """add the CDLIBasketContainer form"""          """wildcard in fileID suche alle Treffer"""
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)          founds=self.CDLICatalog({'title':fileId})
     return pt()          for found in founds:
               fileTree.add(found.getId)
               logging.debug("ADDD:"+found.getId)
   
 def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):      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):
     """add the basket"""          """findObjectsFromList (, TAB oder LINE separated)"""
     ob=CDLIBasketContainer(id,title)  
           
     self._setObject(id, ob)          logging.debug("start: findObjectsFromList")
           #logging.debug("start: findObjectsFromList"+repr(list))
           
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
 class CDLIBasket(Folder,CatalogAware):          if upload: # list from file upload
     """basket"""              txt=upload.read()
           
     meta_type="CDLIBasket"          if enterList:
     default_catalog="CDLIBasketCatalog"              txt=enterList
           
     def getFile(self,obj):          if upload or enterList:
         return obj[1]              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:
           
     def getFileLastVersion(self,obj):                      ids.append(idTmp)
         return obj[0]  
           
     def getFileNamesInLastVersion(self):              #self.REQUEST.SESSION['ids']=" OR ".join(ids)
         """get content of the last version as list"""  
                   
         return [x[1].getId() for x in self.getLastVersion().getContent()]              pt=getattr(self,'filelist.html')
               self.REQUEST.SESSION['searchList']=ids
               return pt(search=ids)
           
     def isActual(self,obj):          if basketName:
         """teste ob im basket die aktuelle version ist"""              #TODO: get rid of one of these..
         actualNo=obj[1].getLastVersion().getVersionNumber()  
         storedNo=obj[0].getVersionNumber()  
                   
         founds=self.CDLICatalog.search({'title':obj[0].getId()})              pt=getattr(self,'filelist.html')
         if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":              return pt(basketName=basketName,numberOfObjects=numberOfObjects)
             return False, -1  
                   
         if actualNo==storedNo:  
             return True , 0  
         else:  
             return False, actualNo  
                   
     def history(self):          result =self.CDLICache.retrieve(hash)
         """history"""            if result:
              logging.debug("give result from storage2")
              return hash,result
   
         ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])          if list is not None: # got already a list
         if ext:  
             return getattr(self,ext[0][1].getId())()  
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self)              logging.debug(" ----List version")
         return pt()              ret=[]
               fileTree=Set()
           
     def getStorageFolderRoot(self):              for fileId in list:
         """root des storage folders"""  
         return self.aq_parent.cdli_main  
           
     def __init__(self,id,title,shortDescription="",comment=""):                  if fileId.find("*")>-1: #check for wildcards
         """init a CDLIBasket"""                          self.expandFile(fileId,fileTree)
                   
         self.id=id                  elif len(fileId.split("."))==1:
         self.title=title                          fileId=fileId+".atf"
         self.shortDescription=shortDescription                          fileTree.add(fileId)
         self.comment=comment                  #logging.debug("   -----:"+fileId)
                   #ret+=self.CDLICatalog({'title':fileId})
                   #x =self.getFileObject(fileId)
                   #if x is not None:
                   #    ret.append(x)
     
         
                         
     def getLastVersion(self):              ids = fileTree & self.v_file_ids
         """hole letzte version"""              #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
         ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])]              l=makelist(fileTree)[0:]
         ids.sort()              #logging.debug("l-list:"+repr(l))
         if len(ids)==0:              self.REQUEST.SESSION['fileIds']=l#store fieldIds in session for further usage
             return None              self.REQUEST.SESSION['searchList']=l
         else:                  #self.REQUEST.SESSION['searchList']=['P000001.atf']
             ob=getattr(self,str(ids[-1]))            
             return ob              
               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 getVersions(self):              #TODO: get rid of one of these..
         """get versions"""              #ids=[x.getObject().getId() for x in ret]
         versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])              ret=[(self.getFileObject(x),self.getFileObjectLastVersion(x)) for x in ids]
         return versions  
   
               #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
               #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
         
               if display:
                   pt=getattr(self,'filelist.html')
           
     def addObjects(self,ids,deleteOld=None):                  return pt(search=ids)
         """generate a new version of the basket with objects added"""              else:     
                   #self.REQUEST.SESSION['hash'] = ret # store in session 
                 
         lastVersion=self.getLastVersion()                  #logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))
                   #logging.debug("HHHHHHNEU:"+repr(hash))
                   self.CDLICache.store(hash,ret)
                   
         if lastVersion is None:                  if returnHash == True:
             oldContent=[]                      return hash,ret
         else:                  return ret
             oldContent=lastVersion.basketContent[0:]  
   
         if deleteOld:  
             oldContent=[]  
   
         newContent=[]  
         added=0  
         for id in ids:  
             founds=self.CDLICatalog.search({'title':id})  
   
             for found in founds:          if start:
                 if found.getObject() not in oldContent:              RESPONSE.redirect("filelist.html?start:int="+str(start))
                     #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version  
                     newContent.append((found.getObject().getLastVersion(),found.getObject()))  
                     added+=1  
   
         content=oldContent+newContent      security.declareProtected('Manage','createAllFilesAsSingleFile')
       def createAllFilesAsSingleFile(self,RESPONSE=None):
           """download all files"""
                   
         user=self.getActualUserName()          def sortF(x,y):
               return cmp(x[0],y[0])
                   
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)          catalog=getattr(self,self.file_catalog)
           #tf,tfilename=mkstemp()
           if not hasattr(self.temp_folder,'downloadCounter'):
               self.temp_folder.downloadCounter=0
           
         return added          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!"""
           
     def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):          self.temp_folder.downloadCounter+=1
         """delete objects"""          self._p_changed=1
           transaction.get().commit()
                   
         if type(ids) is not ListType:          list=[(x.getId,x) for x in catalog()]
             ids=[ids]          list.sort(sortF)
                 
         lastVersion=self.getLastVersion()   
         oldContent=lastVersion.basketContent[0:]  
         newContent=[]  
         for obj in oldContent:  
             if obj[1].getId() not in ids:  
                 newContent.append(obj)  
                   
                                   
         user=self.getActualUserName()          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=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)              if obj.meta_type=="CDLI file":
                   
                   #os.write(tf,obj.getLastVersion().data)
         if RESPONSE:          if RESPONSE:
             obj=self._getOb(ob.getId())                      RESPONSE.write(obj.getData()[0:])
             RESPONSE.redirect(obj.absolute_url())                      RESPONSE.write("\n")
                           self.temp_folder.downloadCounter-=1 
 def manage_addCDLIBasketForm(self):                  self._p_changed=1
     """add the CDLIBasketContainer form"""          transaction.get().commit()
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)          #os.close(tf)
     return pt()          #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
           return True
   
 def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):      def downloadFile(self,fn):
     """add the basket"""          """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())
           
     id=str(self.getNewId())  
           
     ob=CDLIBasket(id,title,shortDescription,comment)  
           
     self._setObject(id, ob)      def hasParent(self):
           """returns true falls subfolder"""
           
     if RESPONSE is not None:          if self.aq_parent.meta_type in self.folder_meta_type:
         RESPONSE.redirect('manage_main')              return True
     else:      else:
         return ob              return False
   
 class CDLIBasketVersion(SimpleItem):  
     """version of a basket"""  
       
     meta_type="CDLIBasketVersion"  
       
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):  
         """download all selected files in one file"""  
           
         ret=""  
         lockedObjects={}  
           
   
         if lock:  
               
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':  
                   
                 return "please login first"  
   
             #check if a locked object exist in the basket.  
             lockedObjects={}  
             for object in self.basketContent:  
   
                 if not object[1].lockedBy=="":  
                     lockedObjects[object[1].title]=repr(object[1].lockedBy)  
                                         
       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
                                           
             keys=lockedObjects.keys()  
                           
       security.declareProtected('manage','index_html')
       def index_html(self):
           """main"""
           ext=self.ZopeFind(self,obj_ids=["index.html"])
           if ext:
               return ext[0][1]()
                           
             if len(keys)>0 and (not procedure):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)  
                 return pt()                  return pt()
                     
             elif not procedure: #keine fails gesperrt dann alle donwloaden  
                 procedure="downloadAll"   
           
   
         for object in self.basketContent:  
                           
                 if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):  manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
                     ret+=object[0].data  
                   
                 if lock and object[1].lockedBy=='':  
                     object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']  
   
         basket_name=self.aq_parent.title+"_V"+self.getId()  
           
         #write basketname to header of atf file  
         ret="#atf basket %s\n"%basket_name+ret  
           
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)  
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")  
         length=len(ret)  
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)  
         self.REQUEST.RESPONSE.write(ret)      
           
    
     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 manage_addCDLIFileFolder(self, id, title='',
         """getUrl of the version of the object"""                       createPublic=0,
         objId=result[1].getTitle()                       createUserF=0,
         founds=self.CDLICatalog.search({'title':objId})                       REQUEST=None):
         if len(founds)>0:      """Add a new Folder object with id *id*.
              return founds[0].getObject().getLastVersion().absolute_url()  
                     
         else: #assume version number      If the 'createPublic' and 'createUserF' parameters are set to any true
             splitted=objId.split("_")      value, an 'index_html' and a 'UserFolder' objects are created respectively
             founds=self.CDLICatalog.search({'title':splitted[1]})              in the new folder.
             return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId      """
       ob=CDLIFileFolder()
       ob.id=str(id)
       ob.title=title
       self._setObject(id, ob)
       ob=self._getOb(id)
         
 def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):      checkPermission=getSecurityManager().checkPermission
     """add a version"""  
           
     #check for already existing versions      if createUserF:
           if not checkPermission('Add User Folders', ob):
               raise Unauthorized, (
                     'You are not authorized to add User Folders.'
                     )
           ob.manage_addUserFolder()
     
     lastVersion=self.getLastVersion()  
     if lastVersion is None:  
         newId=str(1)  
     else:  
         newId=str(int(lastVersion.getId())+1)  
           
     ob=CDLIBasketVersion(newId,user,comment,basketContent)      if REQUEST is not None:
           return self.manage_main(self, REQUEST, update_menu=1)
           
     self._setObject(newId, ob)  class CDLIRoot(Folder):
       """main folder for cdli"""
           
     if RESPONSE is not None:      meta_type="CDLIRoot"
         RESPONSE.redirect('manage_main')      downloadCounterBaskets=0 # counts the current basket downloads if counter > 10 no downloads are possible
     else:  
         return ob  
           
 class CDLIFileObject(versionedFileObject):      file_catalog = 'CDLICatalog'
     """CDLI file object"""  
           
     meta_type="CDLI File Object"      # word splitter for search
       splitter = {'words':cdliSplitter.wordSplitter(),
                   'graphemes':cdliSplitter.graphemeSplitter()}
       
       def redirect(self,RESPONSE,url):
           """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
           
           timeStamp=time.time()
           
           if url.find("?")>-1: #giebt es schon parameter
               addStr="&time=%s"
           else:
               addStr="?time=%s"
               
           RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
           logging.error(email.Utils.formatdate()+' GMT')
           RESPONSE.redirect(url+addStr%timeStamp)
       
       def unicodify(self,txt):
           return unicodify(txt)
       def invalidateOldCacheVersion(self):
           """loescht die alte Version des Cache"""
           del self.v_tmpStore
           return "done"
       
       def viewATF(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           logging.debug(ob[0].getObject().getLastVersion().absolute_url()+"/view")
           if len(ob)>0:
               RESPONSE.redirect(ob[0].getObject().getLastVersion().absolute_url()+"/view")
           return "not found"
       
       def history(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/history")
           return "not found"
       
   
       def downloadLocked(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/downloadLocked")
           return "not found"
       
       def download(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               logging.info("objekt:"+repr(ob[0]))
               #RESPONSE.redirect(ob[0].getLastVersion().absolute_url())
               RESPONSE.redirect(ob[0].absolute_url+"/download")
           return "not found"
       def addCDLIFileObjectForm(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/addCDLIFileObjectForm")
           return "not found"
       
       def addVersionedFileObjectForm(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/addVersionedFileObjectForm")
           return "not found"
       
       def unlock(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/unlock")
           return "not found"
       
       def getFileObject(self,fileId):
           """get an object"""
       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()))
           
     security=ClassSecurityInfo()          return True
           
     def view(self):  
         """view file"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)  
         return pt()  
           
     security.declarePublic('getDesignation')      def updateOrAddToFileBTree(self,obj):
     def getDesignation(self):          """update a BTree"""
         """get the designation out of the file"""          self.v_files.update({obj.getId():obj})
     try:          self.v_files_lastVersion.update({obj.getId():obj.getLastVersion()})
             txt=re.search("&[Pp](.*)= (.*)",self.data[0:])  
         except:  
         print self.getId()  
         txt=self.data[0:]  
         print str(txt)  
                   
         return "ERROR"          self.v_file_ids.add(obj.getId())
         try:          logging.debug("update:"+obj.getId()+"XXX"+repr(obj))
             return txt.group(2)  
         except:  
             return "ERROR"  
                   
 manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')      def deleteFromBTree(self,objId):
           """delete an obj"""
           self.v_files.pop(objId)
           self.v_files_lastVersion.pop(objId)
           self.v_file_ids.remove(objId)
   
 def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',  
                    REQUEST=None):  
     """Add a new File object.  
   
     Creates a new File object 'id' with the contents of 'file'"""  
   
     id=str(id)      def deleteFiles(self,ids):
     title=str(title)          """delete files"""
     content_type=str(content_type)          for id in ids:
     precondition=str(precondition)              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
           
     id, title = cookId(id, title, file)  
   
     self=self.this()  
   
     # First, we create the file without data:      def searchText(self, query, index='graphemes'):
     self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))          """searches query in the fulltext index and returns a list of file ids/P-numbers"""
     self._getOb(id).versionComment=str(vC)          # see also: http://www.plope.com/Books/2_7Edition/SearchingZCatalog.stx#2-13
     self._getOb(id).time=time.localtime()          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 ""
           
     setattr(self._getOb(id),'author',author)          if wholePage:
               logging.debug("show whole page")
               return f[0].getObject().getContentObject().view()
           else:
               return f[0].getObject().getLastVersionFormattedData()
           
     # Now we "upload" the data.  By doing this in two steps, we  
     # can use a database trick to make the upload more efficient.  
     if file:  
         self._getOb(id).manage_upload(file)  
     if content_type:  
         self._getOb(id).content_type=content_type  
   
     if REQUEST is not None:      def showWordInFile(self,fileId,word,indexName='graphemes',regExp=False,):
         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')          """get lines with word from FileId"""
           logging.debug("showwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
           
 class CDLIFile(versionedFile,CatalogAware):          file = formatAtfFullLineNum(self.getFile(fileId))
     """CDLI file"""          ret=[]
           
     meta_type="CDLI file"          # add whitespace before and whitespace and line-end to splitter bounds expressions
     default_catalog='CDLICatalog'          bounds = self.splitter[indexName].bounds
           splitexp = "(%s|\s)(%%s)(%s|\s|\Z)"%(bounds,bounds)
           # clean word expression 
           # TODO: this should use QueryParser itself
           # take out double quotes
           word = word.replace('"','')
           # take out ignorable signs
           ignorable = self.splitter[indexName].ignorex
           word = ignorable.sub('', word)
           # compile into regexp objects and escape parens
           wordlist = [re.compile(splitexp%re.escape(w)) for w in word.split(' ')]
               
           for line in file.splitlines():
               for word in wordlist:
                   #logging.debug("showwordinfile: searching for %s in %s"%(word.pattern,ignoreable.sub('',line)))
                   if word.search(ignorable.sub('',line)):
                       line = formatAtfLineHtml(line)
                       ret.append(line)
                       break
           
           return ret
           
     
     def isContainedInBaskets(self,context=None):      def showWordInFiles(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  
                         has to exist.  
         """          """
           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))
   
         if not context:          return dict([(id,self.showWordInFile(id, word, indexName, regExp)) for id in fileIds])
             context=self  
           
         ret=[]  
         for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()}):  
             #if the basket x is deleted it seemes to be that x is sometimes still in the Catalog, why?  
             try:  
                 ret.append(x.getObject())  
             except:  
                 pass  
         return ret  
         #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]  
                   
                   
     def addCDLIFileObjectForm(self):      def tagWordInFile(self,fileId,word,indexName='graphemes',regExp=False):
         """add a new version"""          """get text with word highlighted from FileId"""
           logging.debug("tagwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
                   
         if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:          file=self.getFile(fileId)
             return "please login first"          tagStart=u'<span class="found">'
         if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):          tagEnd=u'</span>'
             out=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject',version=self.getVersion()).__of__(self)          tagStr=tagStart + u'%%s' + tagEnd
             return out()          ret=[]
         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):          # add whitespace to splitter bounds expressions and compile into regexp object
         """add"""          bounds = self.splitter[indexName].bounds
         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden          wordsplit = re.compile("(%s|\s)"%bounds)
             vC=self.REQUEST['vC']          # clean word expression 
         except:          # TODO: this should use QueryParser itself
             pass          word = word.replace('"','') # take out double quotes
           # take out ignoreable signs
           ignorable = self.splitter[indexName].ignorex
           word = ignorable.sub('', word)
           # split search terms by blanks
           words = word.split(' ')
           # split search terms again (for grapheme search with words)
           splitwords = dict(((w,self.splitter[indexName].process([w])) for w in words))
               
           for line in file.splitlines():
               line = unicodify(line)
               # ignore lemma and other lines
               if line.lstrip().startswith('#lem:'):
                   continue
               # ignore p-num line
               if line.startswith('&P'):
                   continue
               # ignore version lines
               if line.startswith('#version'):
                   continue
               # ignore atf type lines
               if line.startswith('#atf:'):
                   continue
   
               # first scan
               hitwords = []
               for w in words:
                   if ignorable.sub('',line).find(w) > -1:
                       # word is in line
                       # append split word for grapheme search with words
                       hitwords.extend(splitwords[w])
                       #hitwords.extend(wordsplit.split(w))
                      
               # examine hits closer
               if hitwords:
                   # split line into words
                   parts = wordsplit.split(line)
                   line = ""
                   for p in parts:
                       #logging.debug("tagwordinfile: searching for %s in %s"%(p,hitwords))
                       # reassemble line
                       if ignorable.sub('', p) in hitwords:
                           #logging.debug("tagwordinfile: found %s in %s"%(p,hitwords))
                           # this part was found
                           line += tagStart + formatAtfHtml(p) + tagEnd
                       else:
                           line += formatAtfHtml(p)
                   
               else:
                   # no hits
                   line = formatAtfHtml(line)
                   
               ret.append(line)
                   
         if changeName=="yes":          return u'<br>\n'.join(ret)
             filename=file.filename  
             self.title=filename[max(filename.rfind('/'),  
                         filename.rfind('\\'),  
                         filename.rfind(':'),  
                         )+1:]  
   
   
         if not newName=='':  
             self.title=newName[0:]  
                   
       def tagWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
           """
           get texts with highlighted word from all ids in list FileIds.
           returns dict with id:text pairs.
           """
           logging.debug("tagwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds)) 
           return dict([(id,self.tagWordInFile(id, word, indexName, regExp)) for id in fileIds])
                   
   
       def getFileVersionList(self, pnum):
           """get the version history as a list for the translit file with the given pnum"""
           f = getattr(self, self.file_catalog).search({'textid':pnum})
           if not f:
               return []
           
           return f[0].getObject().getVersionList()
            
   
       def URLquote(self,str):
           """quote url"""
           return urllib.quote(str)
       
       def URLunquote(self,str):
           """unquote url"""
           return urllib.unquote(str)
       
       def URLquote_plus(self,str):
           """quote url"""
           return urllib.quote_plus(str)
       
       def URLunquote_plus(self,str):
           """unquote url"""
           return urllib.unquote_plus(str)
       
       def 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"
                   
                   
         positionVersionNum=getattr(self,'positionVersionNum','front')  
                   
         if positionVersionNum=='front':          gen
             id="V%i"%self.getVersion()+"_"+self.title      def forceunlock(self,REQUEST=None,user=None):
         else:          "break all locks"
             tmp=os.path.splitext(self.title)          ret=[]
             if len(tmp)>1:  
                 id=tmp[0]+"_V%i"%self.getVersion()+tmp[1]  
             else:  
                 id=tmp[0]+"_V%i"%self.getVersion()  
                           
           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))
                   
         manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)          if REQUEST is not None:
         objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','breakLockResponse.zpt')).__of__(self)
         self.REQUEST.SESSION['objID_parent']=self.getId()  
   
         if RESPONSE:              return pt(ret=ret)
             obj=self.ZopeFind(self,obj_ids=[id])[0][1]  
             if obj.getSize()==0:  
                 self.REQUEST.SESSION['objID']=obj.getId()  
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)  
                 return pt()  
   
             else:          return ret
                 RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)  
   
         else:  
             return self.ZopeFind(self,obj_ids=[id])[0][1]  
                   
       def getLockedFiles(self,REQUEST=None,user=None):
           """hole alle gesperrten files"""
           ret={}
       
           for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
               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])
                   
 def manage_addCDLIFileForm(self):  
     """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):          if REQUEST is not None:
     """add the OSAS_root"""              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showlockResponse.zpt')).__of__(self)
     newObj=CDLIFile(id,title,lockedBy,author)  
     self._setObject(id,newObj)  
         
     if RESPONSE is not None:              return pt(ret=ret)
         RESPONSE.redirect('manage_main')  
   
           return ret
   
       def getChangesByAuthor(self,author,n=100):
           """getChangesByAuthor"""
           zcat=self.CDLIObjectsCatalog
           res=zcat({'lastEditor':author,
                        'sort_on':'getTime',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
   
           return res
   
 def splitatf(fh,dir=None):      def getChangesByAuthor_html(self,author,n=100):
     """split it"""          """html output for changes by author"""
     ret=None          tmp={}
     nf=None          list=[]                         
     for line in fh.readlines():          for x in self.getChangesByAuthor(author):
         #check if basket name is in the first line             nr=x.getObject().getVersionNumber()
         if line.find("#atf basket")>=0:             id=x.getObject().aq_parent.getId()
             ret=line.replace('#atf basket ','')             #hinzufuegen, wenn Version neuer als die 
             ret=ret.split('_')[0]             if tmp.get(id,(0,0))[1] < nr:
         else:                  tmp[id]=(x.getObject().aq_parent,nr)
             if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile  
                 if nf:  
                     nf.close() #close last file  
                           
                                   
                 filename=line[1:].split("=")[0].rstrip()+".atf"          return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values(),author=author)           
                 if dir:  
                     filename=os.path.join(dir,filename)  
                 nf=file(filename,"w")  
             if nf:      
                 nf.write(line)  
                   
     nf.close()      def getLastChanges(self,n=100):
     fh.close()          """get the last n changes""" 
     return ret,len(os.listdir(dir))          n=int(n)                   
           zcat=self.CDLICatalog
           return zcat({'sort_on':'getLastChangeDate',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
   
 class CDLIFileFolder(versionedFileFolder):  
     """CDLI File Folder"""  
           
     meta_type="CDLI Folder"      def getLastChanges_html(self,n=100):
     filesMetaType=['CDLI file']          """get the last n changes"""
     folderMetaType=['CDLI Folder']          list = [x.getId for x in self.getLastChanges(n)]
     default_catalog='CDLICatalog'          return self.cdli_main.findObjectsFromList(list=list,display=True)
           
     def delete(self,ids):      def refreshTxt(self,txt="",threadName=None):
         """delete this file, i.e. move into a trash folder"""          """txt fuer refresh"""
                             
         found=self.ZopeFind(self,obj_ids=['.trash'])          return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
                   
         if len(found)<1:      def refreshTxtBasket(self,txt="",threadName=None):
             manage_addCDLIFileFolder(self, '.trash',title="Trash")          """txt fuer refresh"""
             trash=self._getOb('.trash')  
         else:  
             trash=found[0][1]  
                   
         if type(ids) is not ListType:          return """ 2;url=%s?repeat=%s """%(txt,threadName)
             ids=[ids]  
         cut=self.manage_cutObjects(ids)  
         trash.manage_pasteObjects(cut)  
                   
     def getVersionNumbersFromIds(self,ids):  
         """get the numbers of the current versions of documents described by their ids"""  
                   
         ret=[]      def getResult(self,threadName=None):
         searchStr=" OR ".join(ids)         """result of thread"""
          try:
           return self._v_uploadATF[threadName].getResult()
          except:
           return "One moment, please"
                   
         founds=self.CDLICatalog.search({'title':searchStr})  
                   
         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 checkCatalog(self,fn):  
         """check if fn is in the catalog"""  
            
           
     def uploadATF(self,upload,basketId=0,RESPONSE=None):  
         """upload an atf file"""  
         #TODO: add comments  
         #TODO: finish uploadATF  
         basketId=str(basketId)  
           
                   
       def uploadATFRPC(self,data,username):
           """upload an atffile via xml-rpc"""
           uploader=uploadATFThread()
                   
         dir=mkdtemp()          #generate an random id for the upload object
         changed=[]          from random import randint
         errors=[]          if (not self.REQUEST.SESSION.get('idTmp',None)):
         newPs=[]  
         psNotInCatalog=[]  
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)  
                   
         if basketId == '0':              idTmp=str(randint(0,1000000000))
             basketObj=self.basketContainer.getActiveBasket()              self.REQUEST.SESSION['idTmp']=idTmp
             if basketObj:  
                 basketId=basketObj.getId()  
                   
         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)
                           
             if self.checkCatalog(fn):          stObj=uploader.run()
                 psNotInCatalog.append(fn)  
                                   
           processor=uploadATFfinallyThread()
                                   
             founds=self.CDLICatalog.search({'title':fn})              basketname=stObj.returnValue['basketNameFromFile']
               
             if len(founds)==0:          processor.set("uploadchanged",basketname=basketname,SESSION=stObj.returnValue,username=username,serverport=self.REQUEST['SERVER_PORT'])
                 newPs.append(fn)  
                                   
             for found in founds:          processor.run()
                 obj=found.getObject()  
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     errors.append(obj)  
                 else:  
                     data=file(os.path.join(dir,fn)).read()  
                     diffs=obj.diff(data)  
                     if diffs[0]>0:  
                         changed.append((obj,diffs))  
                         #hochladen  
           
         self.REQUEST.SESSION['changed']=[x[0].getId() for x in changed]  
         self.REQUEST.SESSION['errors']=[x.getId() for x in errors]  
         self.REQUEST.SESSION['newPs']=newPs  
         self.REQUEST.SESSION['tmpdir']=dir  
               
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)          return generateXMLReturn(stObj.returnValue)
         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):      def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
         """upload the files"""          """upload an atf file / basket file"""
           #self._v_uploadATF.returnValue=None
                   
         if procedure=="uploadchanged":          #generate an random id for the upload thread
             uploadFns=self.REQUEST.SESSION['changed']+self.REQUEST.SESSION['newPs']          from random import randint
           if (not self.REQUEST.SESSION.get('idTmp',None)):
                   
         elif procedure=="uploadAll":              idTmp=str(randint(0,1000000000))
             uploadFns=[]              self.REQUEST.SESSION['idTmp']=idTmp
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                 if not x in self.REQUEST.SESSION['errors']:  
                     uploadFns.append(x)  
         else:          else:
             uploadFns=[]              idTmp=self.REQUEST.SESSION.get('idTmp',None)
               
         for fn in uploadFns:  
             founds=self.CDLICatalog.search({'title':fn})  
             if len(founds)>0:  
                 self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
   
                 founds[0].getObject().manage_addCDLIFileObject('',comment,self.REQUEST.SESSION['author'],file=file(os.path.join(self.REQUEST.SESSION['tmpdir'],fn)))  
               
                   
                                   
         newPs=self.REQUEST.SESSION['newPs']          threadName=repeat
         if len(newPs)>0:          if not threadName or threadName=="":
             tmpDir=self.REQUEST.SESSION['tmpdir']              #new thread not called from the waiting page
               tmpVar=False
                   
             self.cdli_main.importFiles(comment=comment,author=str(self.REQUEST['AUTHENTICATED_USER']) ,folderName=tmpDir, files=newPs)              thread=uploadATFThread()
               threadName=thread.getName()[0:]                                
               if (not hasattr(self,'_v_uploadATF')):
                      self._v_uploadATF={}
                                   
               self._v_uploadATF[threadName]=thread
               #self._xmltrans.start()
               #thread=Thread(target=self._v_uploadATF)
               logging.info("set thread. extern")
               self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],idTmp,serverport=self.REQUEST['SERVER_PORT'])
               #thread.start()
               logging.info("start thread. extern")
               self._v_uploadATF[threadName].start()
                   
                   
         #unlock              self.threadName=self._v_uploadATF[threadName].getName()[0:]
         if unlock:              wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
             unlockFns=[]  
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):  
                     if not x in self.REQUEST.SESSION['errors']:  
                         unlockFns.append(x)  
                           
             for fn in unlockFns:              if wait_template:
                 founds=self.CDLICatalog.search({'title':fn})                  return wait_template[0][1]()
                 if len(founds)>0:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                     self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])              return pt(txt='/uploadATF',threadName=threadName)
               #_v_xmltrans.run()
                                         
                     founds[0].getObject().lockedBy=""          else:
                                   #recover thread, if lost
         if not (basketname ==''):              if (not hasattr(self,'_v_uploadATF')):
             basketId=self.basketContainer.getBasketIdfromName(basketname)                 self._v_uploadATF={}
                           if not self._v_uploadATF.get(threadName,None):
             if not basketId: # create new basket                   for thread in threading.enumerate():
                 ob=self.basketContainer.addBasket(basketname)                           if threadName == thread.getName():
                 basketId=ob.getId()                                         self._v_uploadATF[threadName]=thread
             basket=getattr(self.basketContainer,str(basketId))  
             ids=os.listdir(self.REQUEST.SESSION['tmpdir'])  
             basket.addObjects(ids,deleteOld=True)      
                   
         if RESPONSE is not None:  
             RESPONSE.redirect(self.aq_parent.absolute_url())  
                   
               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)"""  
                                                                                 
                   wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   if wait_template:
                           return wait_template[0][1]()
                   
         if upload: # list from file upload                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
             txt=upload.read()  
             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:  
                                           
                     ids.append(idTmp)                  return pt(txt='/uploadATF',threadName=threadName)
                                           
             #self.REQUEST.SESSION['ids']=" OR ".join(ids)              else:
                   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)
             self.REQUEST.SESSION['searchList']=ids  
             return pt(search=ids)  
                   
         if basketName:                  return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
             #TODO: get rid of one of these..                    basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                           
             pt=getattr(self,'filelist.html')      def redoUpload(self,threadName):
             return pt(basketName=basketName,numberOfObjects=numberOfObjects)         """redo the upload"""
          tmp=self.cdli_main.tmpStore2[threadName]
          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
          return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
                     basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                   
         if list is not None: # got already a list      def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
             ret=[]          """nowupload the files"""
             for fileId in list:  
                 if len(fileId.split("."))==1:  
                         fileId=fileId+".atf"  
   
                 ret+=self.CDLICatalog({'title':fileId})  
             #TODO: get rid of one of these..  
             self.REQUEST.SESSION['fileIds']=[x.getObject().getId() for x in ret]#store fieldIds in session for further usage  
             self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']  
             return ret  
                   
         if start:  
             RESPONSE.redirect("filelist.html?start:int="+str(start))  
                                                                                 
         print "nothing"          threadName=repeat
           if not threadName or threadName=="":
               thread=uploadATFfinallyThread()
               threadName=thread.getName()[0:]
                   
     def createAllFilesAsSingleFile(self,RESPONSE=None):              if (not hasattr(self,'_v_uploadATF')):
         """download all files"""                                  self._v_uploadATF={}
                   
         def sortF(x,y):  
             return cmp(x[0],y[0])  
                   
         catalog=getattr(self,self.default_catalog)              self._v_uploadATF[threadName]=thread
         #tf,tfilename=mkstemp()  
                   
               idTmp=self.REQUEST.SESSION['idTmp']
               stObj=getattr(self.temp_folder,idTmp)
               self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=stObj.returnValue,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
                   
         list=[(x.getId,x) for x in catalog()]              self._v_uploadATF[threadName].start()
         list.sort(sortF)  
                   
         RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")  
         RESPONSE.setHeader("Content-Type","application/octet-stream")  
                 
         for l in list:  
             obj=l[1].getObject()  
                           
             if obj.meta_type=="CDLI file":              wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                                   
                 #os.write(tf,obj.getLastVersion().data)              if wait_template:
                 if RESPONSE:                  return wait_template[0][1]()
                     RESPONSE.write(obj.getLastVersion().data[0:])              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
         #os.close(tf)  
         #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)  
         return True  
           
     def downloadFile(self,fn):              return pt(txt='/uploadATFfinally',threadName=threadName)
         """download fn - not used yet"""              #_v_xmltrans.run()
         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())  
                   
           else:
               #recover thread, if lost
               if not hasattr(self,'_v_uploadATF'):
                  self._v_uploadATF={}
               if not self._v_uploadATF.get(threadName,None):
                    for thread in threading.enumerate():
                            if threadName == thread.getName():
                                          self._v_uploadATF[threadName]=thread
               
               if self._v_uploadATF.get(threadName,None) and (self._v_uploadATF[threadName] is not None) and (not self._v_uploadATF[threadName].end) :
                                   
     def hasParent(self):                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
         """returns true falls subfolder"""                  if wait_template:
                           return wait_template[0][1]()
               
         if self.aq_parent.meta_type in self.folderMetaType:                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
             return True                  return pt(txt='/uploadATFfinally',threadName=threadName)
         else:          else:
             return False  
           
     def getFolders(self):  
         """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  
           
                           
     def getFolders_OLD(self):                idTmp=self.REQUEST.SESSION['idTmp']
         """get all subfolders"""                stObj=getattr(self.temp_folder,idTmp) 
         ret=[]                self.REQUEST.SESSION['idTmp']=None
         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):                #update changed
         """main"""                logging.debug("dir:"+repr(stObj.returnValue['changed']))
         ext=self.ZopeFind(self,obj_ids=["index.html"])                for x in stObj.returnValue['changed']:
         if ext:                      ob=self.CDLICatalog.search({'title':x[0]})
             return ext[0][1]()                      try:
                                   self.cdliRoot.updateOrAddToFileBTree(ob[0].getObject())
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)                      except:
         return pt()                          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/Documents/workspace/cdli/atf", files=None):      def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):
         """import files"""          """import files"""
                   logging.debug("importFiles folderName=%s files=%s ext=%s"%(folderName,files,ext))
           root=self.cdli_main
           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
             id=f              file2=os.path.join(folderName,f)  
             manage_addCDLIFile(fobj2,f,'','')  
             id=f              id=f
             ob=fobj2._getOb(f)              logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))
             ob.title=id              fobj2.addFile(vC='',file=file(file2),author=author,newName=f)
                           count+=1
             manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')              
             self.CDLICatalog.catalog_object(ob)              #now add the file to the storage
             #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)              ob = getattr(fobj2,f)
             #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])              self.cdliRoot.updateOrAddToFileBTree(ob)
               
               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 1275  def manage_addCDLIFileFolder(self, id, t Line 1418  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 1295  def manage_addCDLIFileFolder(self, id, t Line 1441  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.15  
changed lines
  Added in v.1.110

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