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

Diff for /cdli/cdli_files.py between versions 1.6 and 1.120

version 1.6, 2006/02/15 21:57:39 version 1.120, 2011/12/05 12:39:31
Line 1 Line 1
 """CDLI extensions of the filearchive"""  """CDLI extensions of the filearchive"""
 from Products.versionedFile.versionedFile import *  from Products.versionedFile.extVersionedFile import *
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
 from tempfile import mkstemp,mkdtemp  
 import os.path  import os.path
 import os  import os
 from types import *  
 import urlparse  import urlparse
   import urllib
   import cgi
 from OFS.OrderedFolder import OrderedFolder  from OFS.OrderedFolder import OrderedFolder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 import time  import time
   from OFS.Folder import manage_addFolder
   import re
   from AccessControl import ClassSecurityInfo
   from Acquisition import Implicit
   from Globals import Persistent
   from threading import Thread
   from ZPublisher.HTTPRequest import HTTPRequest
   from ZPublisher.HTTPResponse import HTTPResponse
   from ZPublisher.BaseRequest import RequestContainer
   import threading
   import logging
   import transaction
   import copy
   import codecs
   import sys
   from BTrees.IOBTree import IOBTree 
   from BTrees.OOBTree import OOBTree 
   import cdliSplitter
   from sets import Set
   import md5
   from DownloadBasket import DownloadBasketFinallyThread
   from types import *
   import pickle
   import tempfile
   
   from cdli_helpers import *
   
   class CDLIFileObject(CatalogAware,extVersionedFileObject):
       """CDLI file object"""
   
 class Basket_old(Folder):      meta_type="CDLI File Object"
     """shopping basket - alte fassung """      default_catalog='CDLIObjectsCatalog'
           
     meta_type="Basket"      security=ClassSecurityInfo()
     _v_stack={}  
   
     def getObjUrl(self,objId):      security.declareProtected('manage','index_html')
         """getUrl"""  
         founds=self.CDLICatalog.search({'path':objId})  
         if len(founds)>0:  
              return founds[0].getObject().absolute_url()  
            
         else: #assume version number  
             splitted=objId.split("_")  
             founds=self.CDLICatalog.search({'path':splitted[1]})          
             return founds[0].getObject().absolute_url()+'/'+objId  
           
     def storeAllLink(self,results):  
         """erzeuge link zum speicher aller results"""  
         nr=self.REQUEST['_ZopeId']  
                   
         if results:      security.declarePublic('view')
             self._v_stack[nr]=[x.getObject().getId() for x in results]      view = PageTemplateFile('zpt/viewCDLIFile.zpt', globals())
                   
         return self.absolute_url()+"/storeAll?id="+nr      security.declarePublic('editATF')
       editATF = PageTemplateFile('zpt/editATFFile.zpt', globals())
           
     def storeAll(self,id):      def PrincipiaSearchSource(self):
         """store all"""             """Return cataloguable key for ourselves."""
         try:             return str(self)
             results=self._v_stack[id]  
         except:  
             #TODO: write expired page  
             return "expired"  
           
         return self.storeInBasketForm(results)  
                   
     def storeInBasketForm(self,ids):      def setAuthor(self, author):
         """ store an object form"""          """change the author"""
           self.author = author
                   
         if type(ids) is not ListType:      def makeThisVersionCurrent_html(self):
             ids=[ids]          """form for mthis version current"""
         self.REQUEST.SESSION['ids']=ids[0:]  
                   
         self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.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)
           #newversion.manage_upload(self.getData())
                           
         self.REQUEST.SESSION['basketUser']=username          #if RESPONSE is not None:
           #    RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
                   
         baskets=self.ZopeFind(self,obj_ids=[username])          return True
         if len(baskets)>0:  
             basket=baskets[0][1]  
         else:  
             manage_addBasketObject(self,username)  
             basket=self._getOb(username)  
                   
       def getFormattedData(self):
           """fromat text"""
           data=self.getData()
   #        return re.sub("\s\#lem"," #lem",data) #remove return vor #lem
           return re.sub("#lem","       #lem",data) #remove return vor #lem
                   
         basket.addObjects(ids)  
         back=self.REQUEST.SESSION.get('BACKLINK', None)  
   
         if RESPONSE:      security.declarePublic('getPNumber')
             RESPONSE.redirect(back)      def getPNumber(self):
           """get the pnumber"""
           try:
                   txt=re.match("&[PpSs](\d*)\s*=([^\r\n]*)",self.getData()[0:])
           except:
                   txt=self.getData()[0:]
                           
                   return "ERROR"
           try:
               return "P"+txt.group(1)
           except:
               return "ERROR"
   
       security.declarePublic('getDesignation')
       def getDesignation(self):
           """get the designation out of the file"""
           try:
                   txt=re.match("&[PpSs](\d*)\s*=([^\r\n]*)",self.getData()[0:])
           except:
                   txt=self.getData()[0:]
           
     def showBasket(self,user=None,set=None,RESPONSE=None):                  return "ERROR"
         """show the basket"""          try:
               return txt.group(2)
           except:
               return "ERROR"
                   
         if user:  
             self.REQUEST.SESSION['basketUser']=user  
                   
         if not user and not set:  manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
             user=self.REQUEST.SESSION.get('basketUser',None)  
                   
         if not user:  def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',versionNumber=0,
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)                               precondition='', content_type='',
             return pt()                               from_tmp=False,REQUEST=None):
         else:      """Add a new File object.
             baskets=self.ZopeFind(self,obj_ids=[user])      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 len(baskets)>0:      id, title = cookId(id, title, file)
             RESPONSE.redirect(baskets[0][1].absolute_url())  
             return True   
         else:  
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)  
             return pt()  
                   
       self=self.this()
   
 def manage_addBasket_oldForm(self):      # First, we create the file without data:
     """add the basket form"""      self._setObject(id, CDLIFileObject(id,title,versionNumber=versionNumber,versionComment=vC,time=time.localtime(),author=author))
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)      fob = self._getOb(id)
     return pt()  
   
 def manage_addBasket_old(self,id,title,RESPONSE=None):      # Now we "upload" the data.  By doing this in two steps, we
     """add the basket"""      # can use a database trick to make the upload more efficient.
     ob=Basket()  
           
     ob.id=str(id)      if file and not from_tmp:
     ob.title=title          fob.manage_upload(file)
     self._setObject(id, ob)      elif file and from_tmp:
     ob=self._getOb(id)          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
           
     if RESPONSE is not None:      #logging.debug("manage_add: lastversion=%s"%self.getData())
         RESPONSE.redirect('manage_main')      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')
           
 class BasketObject_old(Folder):  
     """Basket Object - alte fassung"""  
           
     meta_type="basketObject"  class CDLIFile(extVersionedFile,CatalogAware):
     def __init__(self):      """CDLI file"""
             """init basket object"""  
             self.contents=[]  
   
     def numberOfItems(self):  
         """return anzahl der elemente im basket"""  
         return len(self.contents)  
           
     def addObjects(self,ids):      security=ClassSecurityInfo()
         """addObjects"""      meta_type="CDLI file"
       content_meta_type = ["CDLI File Object"]
                   
         for id in ids:      default_catalog='CDLICatalog'
             founds=self.CDLICatalog.search({'path':id})  
             for found in founds:  
                 if found.getObject() not in self.contents:  
                     tm=self.contents[0:]  
                     tm.append(found.getObject())  
                     self.contents=tm[0:]  
           
         return True      security.declareProtected('manage','index_html')
   
     def index_html(self):      def getLastVersionData(self):
             """view the basket"""          """get last version data"""
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)          return self.getData()
             return pt()  
       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]
   
     def deleteObjects(self,ids,RESPONSE=None):      #security.declarePublic('history')
         """delete objects"""      def history(self):
         list = self.contents[0:]          """history"""  
         for content in list:  
                                 
                 if content.getId() in ids:          ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
                     self.contents.remove(content)          if ext:
               return getattr(self,ext[0][1].getId())()
                   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
           return pt()
   
         if RESPONSE:  
                 RESPONSE.redirect(self.absolute_url())  
   
       def historyXML(self):
           """history"""  
   
     def unlockTest(self):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistoryXML')).__of__(self)
         """unlock all files of the testuser for debuggin"""          return pt()
         for object in self.contents:  
   
                 if str(object.lockedBy)=="test":      def getBasketFromId(self,basketid, context=None):
                     object.lockedBy=""          """get basket from id"""
                           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):          if not context:
         """download all selected files in one file"""              context=self
                   
         ret=""          for basket in self.ZopeFind(context,obj_metatypes=["CDLIBasket"]):
         lockedObjects={}              if basket[0]==basketid:
                   return basket[1]
           else:
               None
                   
   
         if lock:      def isContainedInBaskets(self,context=None):
           """check is this file is part of any basket
           @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
                           has to exist.
           """
                           
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':          if not context:
               context=self
                                   
                 return "please login first"          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()})]
   
             #check if a locked object exist in the basket.  
             lockedObjects={}  
             for object in self.contents:  
   
                 if not object.lockedBy=="":      def _newContentObject(self, id, title='', versionNumber=0, versionComment=None, time=None, author=None):
                     lockedObjects[object.title]=repr(object.lockedBy)          """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)
                                         
                                           
             keys=lockedObjects.keys()      def addCDLIFileObjectForm(self):
           """add a new version"""
                           
           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"
                           
             if len(keys)>0 and (not procedure):      def manage_addCDLIFileObject(self,id,vC,author,
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects                                   file='',title='',
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)                                   precondition='', 
                 return pt()                                   content_type='',
                                    changeName='no',newName='', 
                                    come_from=None,
                                    from_tmp=False,RESPONSE=None):
           """add"""
                     
             elif not procedure: #keine fails gesperrt dann alle donwloaden          try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
                 procedure="downloadAll"               vC=self.REQUEST['vC']
           except:
               pass
                   
         print procedure              ob = self.addContentObject(id, vC, author, file, title, changeName=changeName, newName=newName, from_tmp=from_tmp,
         for object in self.contents:                                     precondition=precondition, content_type=content_type)
                           
                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):          try:
                     ret+=object.getLastVersion().data              #FIXME: wozu ist das gut?
               self.REQUEST.SESSION['objID_parent']=self.getId()
           except:
               pass
                                   
                 if lock and object.lockedBy=='':          #self.cdliRoot.updateOrAddToFileBTree(self)# now update the object in the cache
                     object.lockedBy=self.REQUEST['AUTHENTICATED_USER']  
   
   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())          if RESPONSE:
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")              if ob.getSize()==0:
         length=len(ret)                  self.REQUEST.SESSION['objID']=ob.getId()
         self.REQUEST.RESPONSE.setHeader("Content-Length",length)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
         self.REQUEST.RESPONSE.write(ret)                      return pt()
               else:
                   if come_from and (come_from!=""):
                       RESPONSE.redirect(come_from+"?change="+self.getId())
                   else:
                       RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
           else:
               return ob
                   
                   
 def manage_addBasket_oldObjectForm(self):  def manage_addCDLIFileForm(self):
     """add form"""      """interface for adding the OSAS_root"""
     pass      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
       return pt()
   
 def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):  def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
     """add"""      """add the OSAS_root"""
       newObj=CDLIFile(id,title,lockedBy,author)
           
     ob=BasketObject()      tryToggle=True
       tryCount=0
           
     ob.id=str(id)      self._setObject(id,newObj)                  
     ob.title=title      getattr(self,id).reindex_object()
     self._setObject(id, ob)  
     ob=self._getOb(id)  
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
 class CDLIBasketContainer(OrderedFolder):  def checkUTF8(data):
     """contains the baskets"""      """check utf 8"""
       if not isinstance(data, str):
           logging.error("checkUTF8 data is not string! (%s)"%repr(data))
           
       try:
           data.decode('utf-8')
           logging.debug("checkUTF8: ok!")
           return True
       except:
           logging.debug("checkUTF8: false!")
           return False
   
           
     meta_type="CDLIBasketContainer"  def checkFile(filename,data,folder):
       """check the files"""
       # first check the file name
       fn=filename.split(".") # no extension
   
       if not (fn[0][0]=="P" or fn[0][0]=="S"):
           return False,"P/S 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 getBasketIdfromName(self,basketname):  
         """get id from name"""  
   
         for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):  def splitatf(fh,dir=None,ext=None):
             if basket[1].title==basketname:      """split it"""
                 return basket[0]      ret=None
         else:      nf=None
             None      i=0
     def uploadBasket_html(self,basketId='0'):  
         """upload an atf file, html form"""      #ROC: why split \n first and then \r???
         basketId=str(basketId)      if isinstance(fh, basestring):
         if not basketId=='0':          iter=fh.split("\n")
             basketName=getattr(self.basketContainer,basketId).title      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.info("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]
   
         else:          else:
             basketName=""                  if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
                       if nf:
                           nf.close() #close last file
                           
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)  
         return pt(basketId=basketId,basketName=basketName)  
         
                       filename=line[1:].split("=")[0].rstrip()+".atf"
                       if dir:
                           filename=os.path.join(dir,filename)
                       nf=file(filename,"w")
                       logging.debug("open %s"%filename)
                   if nf:    
                       nf.write(line.replace("\n","")+"\n")
   
       try:        
           nf.close()
       except:
           pass
                   
     def index_html(self):      if not isinstance(fh, basestring):
         """stanadard ansicht"""          fh.close()
         ext=self.ZopeFind(self,obj_ids=["index.html"])  
         if ext:  
             return ext[0][1]()  
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)      return ret,len(os.listdir(dir))
         return pt()  
           
     def getStorageFolderRoot(self):  
         """root des storage folders"""  
         return self.cdli_main  
           
     def __init__(self,id,title):  class CDLIFileFolder(extVersionedFileFolder):
         """ init basket container"""      """CDLI File Folder"""
         self.id=id  
         self.title=title  
             
       security=ClassSecurityInfo()
       meta_type="CDLI Folder"
       file_meta_type=['CDLI file']
       folder_meta_type=['CDLI Folder']
             
     def getBaskets(self,sortField='title'):      file_catalog='CDLICatalog'
         """get all baskets files"""  
   
         def sortName(x,y):      #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
             return cmp(x[1].title.lower(),y[1].title.lower())      tmpStore2={}
   
         def sortDate(x,y):      def _newVersionedFile(self, id, title='', lockedBy=None, author=None):
             return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())          """factory for versioned files. to be overridden in derived classes."""
           logging.debug("_newVersionedFile(CDLI)")
           return CDLIFile(id, title, lockedBy=lockedBy, author=author)
   
       def setTemp(self,name,value):
           """set tmp"""
                   
         def sortComment(x,y):          setattr(self,name,value)
   
       deleteFileForm = PageTemplateFile("zpt/doDeleteFile", globals())
                   
       def delete(self,ids,REQUEST=None):
           """delete these files"""
           if type(ids) is not ListType:
               ids=[ids]
                           
              try:          self.manage_delObjects(ids)
                 xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()  
              except:  
                 xc='ZZZZZZZZZZZZZ'.lower()  
              try:  
                 yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()  
              except:  
                 yc='ZZZZZZZZZZZZZ'.lower()  
           
           if REQUEST is not None:
               return self.index_html()
           
              if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):  
                                     
                  try:      def getVersionNumbersFromIds(self,ids):
                      xc=x[1].getLastVersion().getComment().lower()          """get the numbers of the current versions of documents described by their ids"""
                  except:  
                      xc='ZZZZZZZZZZZZZ'.lower()  
                                             
              if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):          ret=[]
                  try:          searchStr=" OR ".join(ids)
                      yc=y[1].getLastVersion().getComment().lower()  
                  except:  
                      yc='ZZZZZZZZZZZZZ'.lower()  
           
           founds=self.CDLICatalog.search({'title':searchStr})
           
           for found in founds:
               lastVersion=found.getObject().getContentObject()
               ret.append((found.getId,lastVersion))
                             
                  return cmp(xc,yc)          return ret
                   
         def sortAuthor(x,y):      def getFile(self,fn):
           """get the content of the file fn"""
           logging.debug("getFile: %s"%repr(fn))
           if not self.hasObject(fn):
               # search deeper
               founds=getattr(self, self.file_catalog).search({'textid':fn})
               if founds:
                   obj=founds[0].getObject().getContentObject()
               else:
                   return "" 
           else:
               obj = self[fn].getContentObject()
                           
             return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())          return obj.getData()[0:] 
                   
         baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])  
                   
       def checkCatalog(self,fn):
           """check if fn is in the catalog"""
           #TODO add checkCatalog
                   
         if sortField=='title':  
             baskets.sort(sortName)  
         elif sortField=='date':  
             baskets.sort(sortDate)  
         elif sortField=='author':  
             baskets.sort(sortAuthor)  
         elif sortField=='comment':  
             baskets.sort(sortComment)  
   
         return baskets      def findObjectsFromListWithVersion(self,list,author=None):
           """find objects from a list with versions
           @param list: list of tuples  (cdliFile,version)
           """
           #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
           #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
   
           pt=getattr(self,'filelistVersioned.html')
   
           return pt(search=list,author=author)
                                                 
     def getNewId(self):  
         """createIds"""  
         last=getattr(self,'last',0)  
         last +=1  
         while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:  
             last+=1  
           
         self.last=last      def getAllPNumbers(self):
         return last          """get a list of all files (resp their p-numbers) stored"""
           
     def setActiveBasket(self,basketId,REQUEST=None):          ret=[x.getId for x in  self.CDLICatalog()]
         """store active basketId in a cookie"""  
         self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")  
         if REQUEST:  
             REQUEST.RESPONSE.redirect(REQUEST['URL1'])  
                           
     def getActiveBasket(self):          return ret
         """get active basket from cookie"""  
                   
         id= self.REQUEST.cookies.get('CDLIActiveBasket',None)      def expandFile(self,fileId,fileTree):
         if id:          """wildcard in fileID suche alle Treffer"""
             obj=getattr(self,str(id),None)          founds=self.CDLICatalog({'title':fileId})
         else:          for found in founds:
             obj=None              fileTree.add(found.getId)
         return obj              logging.debug("ADDD:"+found.getId)
           
     def getActualUserName(self):      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):
         """get name of the actualuser"""          """findObjectsFromList (, TAB oder LINE separated)"""
         return str(self.REQUEST['AUTHENTICATED_USER'])  
           
           logging.debug("start: findObjectsFromList")
           #logging.debug("start: findObjectsFromList"+repr(list))
           
     def addBasket(self,newBasketName):  
         """add a new basket"""  
                   
         ob=manage_addCDLIBasket(self,newBasketName)          if upload: # list from file upload
         return ob              txt=upload.read()
           
     def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):          if enterList:
         """store it"""              txt=enterList
         if not ids:  
             ids=self.REQUEST.SESSION['fileIds']  
                           
         if type(ids) is not ListType:          if upload or enterList:
             ids=[ids]              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:
                   
         if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):                      ids.append(idTmp)
             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)              #self.REQUEST.SESSION['ids']=" OR ".join(ids)
         back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)  
                   
               pt=getattr(self,'filelist.html')
               self.REQUEST.SESSION['searchList']=ids
               return pt(search=ids)
                   
         if fromFileList:          if basketName:
             return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)              #TODO: get rid of one of these..
                 
         if RESPONSE:              pt=getattr(self,'filelist.html')
               return pt(basketName=basketName,numberOfObjects=numberOfObjects)
                           
             RESPONSE.redirect(back)  
                           
         return True          result =self.CDLICache.retrieve(hash)
           if result:
              logging.debug("give result from storage2")
              return hash,result
           
 def manage_addCDLIBasketContainerForm(self):          if list is not None: # got already a list
     """add the CDLIBasketContainer form"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)  
     return pt()  
   
 def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):              logging.debug(" ----List version")
     """add the basket"""              ret=[]
     ob=CDLIBasketContainer(id,title)              fileTree=Set()
           
     self._setObject(id, ob)              for fileId in list:
           
     if RESPONSE is not None:                  if fileId.find("*")>-1: #check for wildcards
         RESPONSE.redirect('manage_main')                          self.expandFile(fileId,fileTree)
   
 class CDLIBasket(Folder,CatalogAware):                  elif len(fileId.split("."))==1:
     """basket"""                          fileId=fileId+".atf"
                           fileTree.add(fileId)
                   #logging.debug("   -----:"+fileId)
                   #ret+=self.CDLICatalog({'title':fileId})
                   #x =self.getFileObject(fileId)
                   #if x is not None:
                   #    ret.append(x)
           
     meta_type="CDLIBasket"  
     default_catalog="CDLIBasketCatalog"  
           
     def getFile(self,obj):  
         return obj[1]  
           
     def getFileLastVersion(self,obj):              ids = fileTree & self.v_file_ids
         return obj[0]              #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
               l=makelist(fileTree)[0:]
               #logging.debug("l-list:"+repr(l))
               self.REQUEST.SESSION['fileIds']=l#store fieldIds in session for further usage
               self.REQUEST.SESSION['searchList']=l
               #self.REQUEST.SESSION['searchList']=['P000001.atf']
             
               
               hash = md5.new(repr(makelist(fileTree))).hexdigest() # erzeuge hash als identification
               self.REQUEST.SESSION['hash']=hash
               #TODO: do I need garbage collection for v_tmpStore ?
               
               #logging.debug("Hash:"+repr(hash))
   #        
   #            if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash): 
   #               logging.debug("asking for storage")
   #               res=self.cdliRoot.v_tmpStore[hash]
   #               if res:
   #                   if returnHash == True:
   #                       return hash,res
   #                   return res
             
               #TODO: get rid of one of these..
               #ids=[x.getObject().getId() for x in ret]
               ret=[(self.getFileObject(x),self.getFileObjectLastVersion(x)) for x in ids]
           
     def getFileNamesInLastVersion(self):              #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
         """get content of the last version as list"""              #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                   
         return [x[1].getId() for x in self.getLastVersion().getContent()]              if display:
                   pt=getattr(self,'filelist.html')
           
     def isActual(self,obj):                  return pt(search=ids)
         """teste ob im basket die aktuelle version ist"""  
         actualNo=obj[1].getLastVersion().getVersionNumber()  
         storedNo=obj[0].getVersionNumber()  
         if actualNo==storedNo:  
             return True  
         else:          else:
             return False                  #self.REQUEST.SESSION['hash'] = ret # store in session 
                   
     def history(self):                  #logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))
         """history"""                    #logging.debug("HHHHHHNEU:"+repr(hash))
                   self.CDLICache.store(hash,ret)
   
         ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])                  if returnHash == True:
         if ext:                      return hash,ret
             return getattr(self,ext[0][1].getId())()                  return ret
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self)  
         return pt()  
           
     def getStorageFolderRoot(self):  
         """root des storage folders"""  
         return self.aq_parent.cdli_main  
           
     def __init__(self,id,title,shortDescription="",comment=""):          if start:
         """init a CDLIBasket"""              RESPONSE.redirect("filelist.html?start:int="+str(start))
                   
         self.id=id      security.declareProtected('Manage','createAllFilesAsSingleFile')
         self.title=title      def createAllFilesAsSingleFile(self,RESPONSE=None):
         self.shortDescription=shortDescription          """download all files"""
         self.comment=comment  
     
           def sortF(x,y):
               return cmp(x[0],y[0])
         
           catalog=getattr(self,self.file_catalog)
           #tf,tfilename=mkstemp()
           if not hasattr(self.temp_folder,'downloadCounter'):
               self.temp_folder.downloadCounter=0
                         
     def getLastVersion(self):          if getattr(self.temp_folder,'downloadCounter',0) > 5:
         """hole letzte version"""              return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
         ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])]  
         ids.sort()  
         if len(ids)==0:  
             return None  
         else:      
             ob=getattr(self,str(ids[-1]))  
             return ob  
         
     def getVersions(self):          self.temp_folder.downloadCounter+=1
         """get versions"""          self._p_changed=1
         versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])          transaction.get().commit()
         return versions  
   
           list=[(x.getId,x) for x in catalog()]
           list.sort(sortF)
         
           
     def addObjects(self,ids,deleteOld=None):  
         """generate a new version of the basket with objects added"""  
                 
         lastVersion=self.getLastVersion()          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()
                   
         if lastVersion is None:              if obj.meta_type=="CDLI file":
             oldContent=[]  
         else:  
             oldContent=lastVersion.basketContent[0:]  
   
         if deleteOld:                  #os.write(tf,obj.getLastVersion().data)
             oldContent=[]                  if RESPONSE:
                       RESPONSE.write(obj.getData()[0:])
                       RESPONSE.write("\n")
                   self.temp_folder.downloadCounter-=1 
                   self._p_changed=1
           transaction.get().commit()
           #os.close(tf)
           #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
           return True
   
         newContent=[]      def downloadFile(self,fn):
         added=0          """download fn - not used yet"""
         for id in ids:          self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
             founds=self.CDLICatalog.search({'title':id})          self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
           self.REQUEST.RESPONSE.write(file(fn).read())
   
             for found in founds:  
                 if found.getObject() not in oldContent:  
                     #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version  
                     newContent.append((found.getObject().getLastVersion(),found.getObject()))  
                     added+=1  
   
         content=oldContent+newContent  
                   
         user=self.getActualUserName()      def hasParent(self):
           """returns true falls subfolder"""
                   
         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)          if self.aq_parent.meta_type in self.folder_meta_type:
               return True
           else:
               return False
           
         return added      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
           
     def deleteObjects(self,ids,RESPONSE=None):  
         """delete objects"""  
         #TODO: implement delete Objects  
                   
 def manage_addCDLIBasketForm(self):      security.declareProtected('manage','index_html')
     """add the CDLIBasketContainer form"""      def index_html(self):
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)          """main"""
     return pt()          ext=self.ZopeFind(self,obj_ids=["index.html"])
           if ext:
               return ext[0][1]()
   
 def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
     """add the basket"""          return pt()
           
     id=str(self.getNewId())  
           
     ob=CDLIBasket(id,title,shortDescription,comment)  manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
           
     self._setObject(id, ob)  
           
     if RESPONSE is not None:  def manage_addCDLIFileFolder(self, id, title='',
         RESPONSE.redirect('manage_main')                       createPublic=0,
     else:                       createUserF=0,
         return ob                       REQUEST=None):
       """Add a new Folder object with id *id*.
   
 class CDLIBasketVersion(SimpleItem):      If the 'createPublic' and 'createUserF' parameters are set to any true
     """version of a basket"""      value, an 'index_html' and a 'UserFolder' objects are created respectively
       in the new folder.
       """
       ob=CDLIFileFolder()
       ob.id=str(id)
       ob.title=title
       self._setObject(id, ob)
       ob=self._getOb(id)
           
     meta_type="CDLIBasketVersion"      checkPermission=getSecurityManager().checkPermission
           
     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):      if createUserF:
         """download all selected files in one file"""          if not checkPermission('Add User Folders', ob):
               raise Unauthorized, (
                     'You are not authorized to add User Folders.'
                     )
           ob.manage_addUserFolder()
                   
         ret=""  
         lockedObjects={}  
                   
       if REQUEST is not None:
           return self.manage_main(self, REQUEST, update_menu=1)
   
         if lock:  class CDLIRoot(Folder):
       """main folder for cdli"""
                           
             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':      meta_type="CDLIRoot"
       downloadCounterBaskets=0 # counts the current basket downloads if counter > 10 no downloads are possible
                                   
                 return "please login first"      file_catalog = 'CDLICatalog'
   
             #check if a locked object exist in the basket.      # word splitter for search
             lockedObjects={}      splitter = {'words':cdliSplitter.wordSplitter(),
             for object in self.basketContent:                  '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 historyXML(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/historyXML")
           return "not found"
       
   
       def downloadLocked(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/downloadLocked")
           return "not found"
       
       def download(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               logging.info("objekt:"+repr(ob[0]))
               #RESPONSE.redirect(ob[0].getLastVersion().absolute_url())
               RESPONSE.redirect(ob[0].absolute_url+"/download")
           return "not found"
       def addCDLIFileObjectForm(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/addCDLIFileObjectForm")
           return "not found"
       
       def addVersionedFileObjectForm(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/addVersionedFileObjectForm")
           return "not found"
       
       def unlock(self,id,RESPONSE):
           """view an Object"""
           ob = self.CDLICatalog({'title':id})
           if len(ob)>0:
               RESPONSE.redirect(ob[0].absolute_url+"/unlock")
           return "not found"
       
       
       def getFileObject(self,fileId):
           """get an object"""
           logging.debug("getFileObj:"+repr(fileId))
           if isinstance(fileId,CDLIFileObject): # support for old baskets
                     return fileId
           x=self.v_files.get(fileId)
           logging.debug("obj: "+repr(x))
           if x is None:
               logging.debug("fileId"+repr(fileId))
               folder=fileId[0:3]
               f2=fileId[0:5]
               fObj = getattr(self.cdliRoot.cdli_main,folder);
               f2Obj = getattr(fObj,f2)
               
               o = getattr(f2Obj,fileId)
               logging.debug(o);
               self.updateOrAddToFileBTree(o)
               return o
           return x
       
       def getFileObjectLastVersion(self,fileId):
           """get an object"""
           x=self.v_files_lastVersion.get(fileId)
           logging.debug("lastVersion: "+repr(x))
           if x==None:
               folder=fileId[0:3]
               f2=fileId[0:5]
               fObj = getattr(self.cdliRoot.cdli_main,folder);
               f2Obj = getattr(fObj,f2)
   
               o =getattr(f2Obj,fileId)
               logging.debug(o);
               return o.getLastVersion()
           
   
           return x
       
       def showFileIds(self):
           """showIds"""
           return self.v_file_ids
       
       def generateFileBTree(self):
           """erzeuge einen Btree aus allen Files"""
           self.v_files = OOBTree()
           self.v_files_lastVersion = OOBTree()
           self.v_file_ids = Set()
           
           for x in self.CDLICatalog.searchResults():
               
               self.v_files.update({x.getId:x.getObject()})
               self.v_files_lastVersion.update({x.getId:x.getObject().getLastVersion()})
               self.v_file_ids.add(x.getId)
               logging.debug("add:"+x.getId+"XXX"+repr(x.getObject()))
   
                 if not object[1].lockedBy=="":          return True
                     lockedObjects[object[1].title]=repr(object[1].lockedBy)  
                                         
                                           
             keys=lockedObjects.keys()      def updateOrAddToFileBTree(self,obj):
           """update a BTree"""
           self.v_files.update({obj.getId():obj})
           self.v_files_lastVersion.update({obj.getId():obj.getLastVersion()})
                           
           self.v_file_ids.add(obj.getId())
           #change everthing around to make it persistent...
           tmp = self.v_files
           self.v_files=tmp
                           
             if len(keys)>0 and (not procedure):          tmp2=self.v_file_ids
                 self.REQUEST.SESSION['lockedObjects']=lockedObjects          self.v_file_ids=tmp2
                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)  
                 return pt()  
                     
             elif not procedure: #keine fails gesperrt dann alle donwloaden          self.CDLICache.cleanCache() #be sure that the cache is clean
                 procedure="downloadAll"           logging.debug("update:"+obj.getId()+"XXX"+repr(obj))
                   
   
         for object in self.basketContent:      def deleteFromBTree(self,objId):
           """delete an obj"""
           self.v_files.pop(objId)
           self.v_files_lastVersion.pop(objId)
           self.v_file_ids.remove(objId)
                           
                 if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):  
                     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()      def deleteFiles(self,ids):
           """delete files"""
           for id in ids:
               founds=self.CDLICatalog.search({'title':id.split(".")[0]})
               if founds:
                   logging.debug("deleting %s"%founds)
                   folder=founds[0].getObject().aq_parent #get the parent folder of the object
                   logging.debug("deleting from %s"%folder)
                   cut=folder.delete([founds[0].getId]) #cut it out
                   
         #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):      def searchText(self, query, index='graphemes', resultFilter=None):
             """view the basket"""          """searches query in the fulltext index and returns a list of file IDs/P-numbers
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)             resultFilter is matched against the beginning of the file ID"""
             return pt()          # see also: http://www.plope.com/Books/2_7Edition/SearchingZCatalog.stx#2-13
           logging.debug("searchtext for '%s' in index %s"%(query,index))
           #import Products.ZCTextIndex.QueryParser
           #qp = QueryParser.QueryParser()
           #logging.debug()
           idxQuery = {index:{'query':query}}
           idx = getattr(self, self.file_catalog)
           # do search
           resultset = idx.search(query_request=idxQuery,sort_index='textid')
           # put only the P-Number in the result
           if resultFilter is None:
               results = [res.getId[:7] for res in resultset]
           else:
               results = [res.getId[:7] for res in resultset if res.getId.startswith(resultFilter)]
           logging.debug("searchtext: found %d texts"%len(results))
           return results
   
   
       def getFile(self, pnum):
           """get the translit file with the given pnum"""
           f = getattr(self, self.file_catalog).search({'textid':pnum})
           if not f:
               return ""
           
           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 ""
             
     def getObjUrl(self,result):          if wholePage:
         """getUrl of the version of the object"""              logging.debug("show whole page")
         objId=result[1].getTitle()              return f[0].getObject().getContentObject().view()
         founds=self.CDLICatalog.search({'title':objId})          else:
         if len(founds)>0:              return f[0].getObject().getLastVersionFormattedData()
              return founds[0].getObject().absolute_url()  
                     
         else: #assume version number  
             splitted=objId.split("_")  
             founds=self.CDLICatalog.search({'path':splitted[1]})          
             return founds[0].getObject().absolute_url()+'/'+objId  
         
 def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):      def showWordInFile(self,fileId,word,indexName='graphemes',regExp=False,):
     """add a version"""          """get lines with word from FileId"""
           logging.debug("showwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
           
     #check for already existing versions          file = formatAtfFullLineNum(self.getFile(fileId))
           ret=[]
     
     lastVersion=self.getLastVersion()          # add whitespace before and whitespace and line-end to splitter bounds expressions
     if lastVersion is None:          bounds = self.splitter[indexName].bounds
         newId=str(1)          splitexp = "(%s|\s)(%%s)(%s|\s|\Z)"%(bounds,bounds)
     else:          # clean word expression 
         newId=str(int(lastVersion.getId())+1)          # 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
           
     ob=CDLIBasketVersion(newId,user,comment,basketContent)          return ret
           
     self._setObject(newId, ob)  
           
     if RESPONSE is not None:      def showWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
         RESPONSE.redirect('manage_main')          """
     else:          get lines with word from all ids in list FileIds.
         return ob          returns dict with id:lines pairs.
           """
           logging.debug("showwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds))
           
 class CDLIFileObject(versionedFileObject):          return dict([(id,self.showWordInFile(id, word, indexName, regExp)) for id in fileIds])
     """CDLI file object"""  
           
     meta_type="CDLI File Object"  
           
       def tagWordInFile(self,fileId,word,indexName='graphemes',regExp=False):
           """get text with word highlighted from FileId"""
           logging.debug("tagwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
                   
     def view(self):          file=self.getFile(fileId)
         """view file"""          tagStart=u'<span class="found">'
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)          tagEnd=u'</span>'
         return pt()          tagStr=tagStart + u'%%s' + tagEnd
           ret=[]
           
 manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')          # add whitespace to splitter bounds expressions and compile into regexp object
           bounds = self.splitter[indexName].bounds
           wordsplit = re.compile("(%s|\s)"%bounds)
           # clean word expression 
           # TODO: this should use QueryParser itself
           word = word.replace('"','') # take out double quotes
           # take out ignoreable signs
           ignorable = self.splitter[indexName].ignorex
           word = ignorable.sub('', word)
           # split search terms by blanks
           words = word.split(' ')
           # split search terms again (for grapheme search with words)
           splitwords = dict(((w,self.splitter[indexName].process([w])) for w in words))
               
           for line in file.splitlines():
               line = unicodify(line)
               # ignore lemma and other lines
               if line.lstrip().startswith('#lem:'):
                   continue
               # ignore p-num line
               if line.startswith('&P') or line.startswith('&S'):
                   continue
               # ignore version lines
               if line.startswith('#version'):
                   continue
               # ignore atf type lines
               if line.startswith('#atf:'):
                   continue
   
               # first scan
               hitwords = []
               for w in words:
                   if ignorable.sub('',line).find(w) > -1:
                       # word is in line
                       # append split word for grapheme search with words
                       hitwords.extend(splitwords[w])
                       #hitwords.extend(wordsplit.split(w))
                      
               # examine hits closer
               if hitwords:
                   # split line into words
                   parts = wordsplit.split(line)
                   line = ""
                   for p in parts:
                       #logging.debug("tagwordinfile: searching for %s in %s"%(p,hitwords))
                       # reassemble line
                       if ignorable.sub('', p) in hitwords:
                           #logging.debug("tagwordinfile: found %s in %s"%(p,hitwords))
                           # this part was found
                           line += tagStart + formatAtfHtml(p) + tagEnd
                       else:
                           line += formatAtfHtml(p)
                   
               else:
                   # no hits
                   line = formatAtfHtml(line)
   
 def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',              ret.append(line)
                    REQUEST=None):  
     """Add a new File object.  
   
     Creates a new File object 'id' with the contents of 'file'"""          return u'<br>\n'.join(ret)
   
     id=str(id)  
     title=str(title)  
     content_type=str(content_type)  
     precondition=str(precondition)  
           
     id, title = cookId(id, title, file)  
   
     self=self.this()      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])
   
     # First, we create the file without data:  
     self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))  
     self._getOb(id).versionComment=str(vC)  
     self._getOb(id).time=time.localtime()  
           
     setattr(self._getOb(id),'author',author)      def 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"
       
       def forceunlock(self,REQUEST=None,user=None,fid=None):
           "break all locks"
           if fid is not None:
               self.getFileObject(fid).forceunlock()
               return fid
           ret=[]
           
     # Now we "upload" the data.  By doing this in two steps, we          for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
     # can use a database trick to make the upload more efficient.             un=f[1].forceunlock(user=user)
     if file:             logging.info("check:"+f[0])
         self._getOb(id).manage_upload(file)             if un and un !="":
     if content_type:                 ret.append((f[0],un))
         self._getOb(id).content_type=content_type  
   
     if REQUEST is not None:      if REQUEST is not None:
         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','breakLockResponse.zpt')).__of__(self)
           
 class CDLIFile(versionedFile,CatalogAware):              return pt(ret=ret)
     """CDLI file"""  
           
     meta_type="CDLI file"          return ret
     default_catalog='CDLICatalog'  
           
     def isContainedInBaskets(self):  
         """check is this file is part of any basket"""  
               
         return [x.getObject() for x in self.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]      def getLockedFiles(self,REQUEST=None,user=None):
           """hole alle gesperrten files"""
           ret={}
       
           for nm,f in self.v_files.items():
               lb = str(f.lockedBy)
               add=False
               if (lb is not None) and (lb!=""):
                  
                   if user is None:
                       add=True
                   else:
                       if str(lb)==user:
                           add=True
                   if add==True:
                       if not ret.has_key(lb):
                           ret[lb]=[]
                       ret[lb].append(nm)
                   
                   
     def addCDLIFileObjectForm(self):          if REQUEST is not None:
         """add a new version"""              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showlockResponse.zpt')).__of__(self)
                   
         if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:              return pt(ret=ret)
             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"  
                   
     def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):          return ret
         """add"""  
         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden  
             vC=self.REQUEST['vC']  
         except:  
             pass  
                   
         author=self.REQUEST['author']      def getChangesByAuthor(self,author,n=100):
           """getChangesByAuthor"""
           zcat=self.CDLIObjectsCatalog
           res=zcat({'lastEditor':author,
                        'sort_on':'getTime',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
                   
         if changeName=="yes":          return res
             filename=file.filename  
             self.title=filename[max(filename.rfind('/'),  
                         filename.rfind('\\'),  
                         filename.rfind(':'),  
                         )+1:]  
   
       def getChangesByAuthor_html(self,author,n=100):
           """html output for changes by author"""
           tmp={}
           list=[]                         
           for x in self.getChangesByAuthor(author):
              nr=x.getObject().getVersionNumber()
              id=x.getObject().aq_parent.getId()
              #hinzufuegen, wenn Version neuer als die 
              if tmp.get(id,(0,0))[1] < nr:
                   tmp[id]=(x.getObject().aq_parent,nr)
   
         if not newName=='':  
             self.title=newName[0:]  
                   
           return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values(),author=author)           
                   
       def getLastChanges(self,n=100):
           """get the last n changes""" 
           n=int(n)                   
           zcat=self.CDLICatalog
           return zcat({'sort_on':'getLastChangeDate',
                        'sort_order':'descending',
                        'sort_limit':n})[:n ]
   
                   
       def getLastChanges_html(self,n=100):
           """get the last n changes"""
           list = [x.getId for x in self.getLastChanges(n)]
           return self.cdli_main.findObjectsFromList(list=list,display=True)
                   
         positionVersionNum=getattr(self,'positionVersionNum','front')      def refreshTxt(self,txt="",threadName=None):
           """txt fuer refresh"""
                   
         if positionVersionNum=='front':          return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
             id="V%i"%self.getVersion()+"_"+self.title  
         else:  
             tmp=os.path.splitext(self.title)  
             if len(tmp)>1:  
                 id=tmp[0]+"_V%i"%self.getVersion()+tmp[1]  
             else:  
                 id=tmp[0]+"_V%i"%self.getVersion()  
                           
       def refreshTxtBasket(self,txt="",threadName=None):
           """txt fuer refresh"""
                   
         manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)          return """ 2;url=%s?repeat=%s """%(txt,threadName)
         objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))  
         self.REQUEST.SESSION['objID_parent']=self.getId()  
   
         if RESPONSE:  
             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:  
                 RESPONSE.redirect(self.REQUEST['URL2'])  
   
         else:  
             return self.ZopeFind(self,obj_ids=[id])[0][1]  
                   
       def getResult(self,threadName=None):
          """result of thread"""
          try:
           return self._v_uploadATF[threadName].getResult()
          except:
           return "One moment, please"
                   
 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):      def checkThreads(self):
     """add the OSAS_root"""          """check threads"""
     newObj=CDLIFile(id,title,lockedBy,author)          ret="<html><body>"
     self._setObject(id,newObj)          for thread in threading.enumerate():
              ret+="<p>%s (%s): %s</p>"%(repr(thread),thread.getName(),thread.isAlive())
         
     if RESPONSE is not None:          return ret
         RESPONSE.redirect('manage_main')  
   
   
       def uploadATFRPC(self,data,username):
           """upload an atffile via xml-rpc"""
           uploader=uploadATFThread()
   
           #generate an random id for the upload object
           from random import randint
           if (not self.REQUEST.SESSION.get('idTmp',None)):
   
 def splitatf(fh,dir=None):              idTmp=str(randint(0,1000000000))
     """split it"""              self.REQUEST.SESSION['idTmp']=idTmp
     ret=None  
     nf=None  
     for line in fh.readlines():  
         #check if basket name is in the first line  
         if line.find("#atf basket")>=0:  
             ret=line.replace('#atf basket ','')  
             ret=ret.split('_')[0]  
         else:          else:
             if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile              idTmp=self.REQUEST.SESSION.get('idTmp',None)
                 if nf:  
                     nf.close() #close last file  
                           
                                   
                 filename=line[1:].split("=")[0].rstrip()+".atf"          uploader.set(data,0,username,idTmp)
                 if dir:  
                     filename=os.path.join(dir,filename)  
                 nf=file(filename,"w")  
             if nf:      
                 nf.write(line)  
           
     nf.close()  
     fh.close()  
     return ret,len(os.listdir(dir))  
   
 class CDLIFileFolder(versionedFileFolder):          stObj=uploader.run()
     """CDLI File Folder"""  
           
     meta_type="CDLI Folder"          processor=uploadATFfinallyThread()
     filesMetaType=['CDLI file']  
     folderMetaType=['CDLI Folder']  
     default_catalog='CDLICatalog'  
           
     def getVersionNumbersFromIds(self,ids):          basketname=stObj.returnValue['basketNameFromFile']
         """get the numbers of the current versions of documents described by their ids"""  
                   
         ret=[]          processor.set("uploadchanged",basketname=basketname,SESSION=stObj.returnValue,username=username,serverport=self.REQUEST['SERVER_PORT'])
         searchStr=" OR ".join(ids)  
                   
         founds=self.CDLICatalog.search({'path':searchStr})          processor.run()
                   
         for found in founds:  
             lastVersion=found.getObject().getLastVersion()  
             ret.append((found.getId,lastVersion))  
                   
         return ret          return generateXMLReturn(stObj.returnValue)
           
       def uploadATFAsync(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
           """upload an atf file / basket file"""
           #self._v_uploadATF.returnValue=None
     
     def uploadATF(self,upload,basketId=0,RESPONSE=None):  
         """upload an atf file"""  
         #TODO: add comments  
         #TODO: finish uploadATF  
         basketId=str(basketId)  
                   
           idTmp=str(randint(0,1000000000))
                   
           if upload is None:
               return "ERROR NO FILE!"
                   
         dir=mkdtemp()          tmpFile = File("/tmp/idTmp","w")
         changed=[]          # sicher basket in file
         errors=[]          for x in upload.read():
         newPs=[]              tmpFile.write(x)
         basketNameFromFile, numberOfFiles=splitatf(upload,dir)  
         if basketId == '0':  
             basketNameFromId=""  
             basketLen=0  
         else:  
             basketNameFromId=getattr(self.basketContainer,basketId).title  
             basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems()  
                           
           tmpFile.close();
           uploadATFAsync(baskerId,idTmp,basketId,self.REQUEST['AUTHENTICATED_USER'],idTmp,serverport=self.REQUEST['SERVER_PORT'])
                           
         for fn in os.listdir(dir):          return idTMP   
             founds=self.CDLICatalog.search({'title':fn})      
               
             if len(founds)==0:      def viewTicketAsync(self,ticketNr=1):
                 newPs.append(fn)          """viewticket"""
                                   
             for found in founds:          tmp = pickle.load(file("/tmp/"+str(ticketNr)+".result"))
                 obj=found.getObject()  
                 
                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheckAsync.zpt')).__of__(self)
                     errors.append(obj)  
                 else:  
                     data=file(os.path.join(dir,fn)).read()  
                     diffs=obj.diff(data)  
                     if diffs[0]>0:  
                         changed.append((obj,diffs))  
                         #hochladen  
           
         self.REQUEST.SESSION['changed']=[x[0].getId() for x in changed]  
         self.REQUEST.SESSION['errors']=[x.getId() for x in errors]  
         self.REQUEST.SESSION['newPs']=newPs  
         self.REQUEST.SESSION['tmpdir']=dir  
               
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)          return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
         return pt(changed=changed,errors=errors,dir=dir,newPs=newPs,basketLen=basketLen,numberOfFiles=numberOfFiles,                    basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                    basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId)  
                                           
     def uploadATFfinally(self,procedure,comment="",basketname='',unlock=None,RESPONSE=None):  
         """upload the files"""  
                   
         if procedure=="uploadchanged":  
             uploadFns=self.REQUEST.SESSION['changed']+self.REQUEST.SESSION['newPs']  
                   
         elif procedure=="uploadAll":      def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
             uploadFns=[]          """upload an atf file / basket file"""
             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):          #self._v_uploadATF.returnValue=None
                 if not x in self.REQUEST.SESSION['errors']:  
                     uploadFns.append(x)  
         else:  
             uploadFns=[]  
                           
         for fn in uploadFns:          #generate an random id for the upload thread
             founds=self.CDLICatalog.search({'path':fn})          from random import randint
             if len(founds)>0:          if (not self.REQUEST.SESSION.get('idTmp',None)):
                 self.REQUEST['author']=str(self.REQUEST['AUTHENTICATED_USER'])  
                 founds[0].getObject().manage_addCDLIFileObject('',comment,self.REQUEST['author'],file=file(os.path.join(self.REQUEST.SESSION['tmpdir'],fn)))  
                           
               idTmp=str(randint(0,1000000000))
               self.REQUEST.SESSION['idTmp']=idTmp
           else:
               idTmp=self.REQUEST.SESSION.get('idTmp',None)
                   
                                   
         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({'path':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['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 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 not (basketname ==''):              if self._v_uploadATF.get(threadName,None) and (not self._v_uploadATF[threadName].returnValue):
             basketId=self.basketFolder.getBasketIdfromName(basketname)  
                           
             basket=getattr(self.basketFolder,basketId)  
             ids=os.listdir(self.REQUEST.SESSION['tmpdir'])  
             basket.addObjects(ids,deleteOld=True)      
                                   
         if RESPONSE is not None:                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
             RESPONSE.redirect(self.aq_parent.absolute_url())                  if wait_template:
                           return wait_template[0][1]()
                   
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
   
     def findObjectsFromList(self,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):                  return pt(txt='/uploadATF',threadName=threadName)
         """findObjectsFromList (, TAB oder LINE separated)"""  
         if upload: # list from file upload  
             txt=upload.read()  
             txt=txt.replace(",","\n")  
             txt=txt.replace("\t","\n")  
             idsTmp=txt.split("\n")  
             ids=[]  
             for id in idsTmp: # make sure that no empty lines  
                 idTmp=id.lstrip().rstrip()  
                 if len(idTmp)>0:  
                                           
                     ids.append(idTmp)              else:
                   tmp=getattr(self.temp_folder,idTmp).returnValue
                                           
             #self.REQUEST.SESSION['ids']=" OR ".join(ids)                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
                           
             pt=getattr(self,'filelist.html')                  return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
             return pt(search=ids)                    basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
         if basketName:  
             pt=getattr(self,'filelist.html')  
             return pt(search=list,basketName=basketName,numberOfObjects=numberOfObjects)  
                   
         if list: # got already a list  
             ret=[]  
             for fileId in list:  
                 if len(fileId.split("."))==1:  
                         fileId=fileId+".atf"  
                                                   
                 ret+=self.CDLICatalog({'title':fileId})      def redoUpload(self,threadName):
             self.REQUEST.SESSION['fileIds']=[x.getObject().getId() for x in ret]#store fieldIds in session for further usage         """redo the upload"""
             return ret         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'])
                   
         #RESPONSE.redirect("filelist.html?path=%s"%" OR ".join(ids))      def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
           """nowupload the files"""
           threadName=repeat
           if not threadName or threadName=="":
               thread=uploadATFfinallyThread()
               threadName=thread.getName()[0:]
           
     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)              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  
           
                 idTmp=self.REQUEST.SESSION['idTmp']
                 stObj=getattr(self.temp_folder,idTmp) 
                 self.REQUEST.SESSION['idTmp']=None
                           
     def getFolders_OLD(self):                #update changed
         """get all subfolders"""                logging.debug("dir:"+repr(stObj.returnValue['changed']))
         ret=[]                for x in stObj.returnValue['changed']:
         folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)                      ob=self.CDLICatalog.search({'title':x[0]})
         for folder in folders:                      try:
             ret.append((folder[1],                          self.cdliRoot.updateOrAddToFileBTree(ob[0].getObject())
                         len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),                      except:
                         len(getattr(self,self.default_catalog)({'path':folder[0]}))  
                         ))  
         return ret  
       
     def index_html(self):  
         """main"""  
         ext=self.ZopeFind(self,obj_ids=["index.html"])  
         if ext:  
             return ext[0][1]()  
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)                          logging.error("uploadATFfinally - cannot update Object %s Error: %s %s"%(ob[1],sys.exc_info()[0],sys.exc_info()[1]))
         return pt()                for x in stObj.returnValue['newPs']:
                     obj=self.getFileObject(x) #updates the object in the cache
                     logging.debug("Got:"+repr(obj))
                 if RESPONSE is not None:
                     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:
                   
                   if type(ext.result) is types.FileType:
                       ext.result.write("<p>adding: %s </p>\n"%f)
                   else:
                       ext.result="<p>adding: %s </p>"%f+ext.result
   
               
               if not obj: # if not create it
                   manage_addCDLIFileFolder(root,folder,folder)
                   fobj=getattr(root,folder)
                   #transaction.get().commit()                           
                   
             else:              else:
                 fobj=obj[0][1]                  fobj=obj[0][1]
                           
               #check IF PYYYYY already exist
             obj2=fobj.ZopeFind(fobj,obj_ids=[f2])              obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
               logging.debug("importFiles: fobj=%s obj2=%s"%(fobj,obj2)) 
                   
             if not obj2:              if not obj2:# if not create it
                 manage_addCDLIFileFolder(fobj,f2,f2)                  manage_addCDLIFileFolder(fobj,f2,f2)
                 fobj2=getattr(fobj,f2)                  fobj2=getattr(fobj,f2)
                   
             else:              else:
                 fobj2=obj2[0][1]                  fobj2=obj2[0][1]
                               
             file2=file(os.path.join(folderName,f))                 # not add the file
               file2=os.path.join(folderName,f)  
             id=f              id=f
             manage_addCDLIFile(fobj2,f,'','')              logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))
             id=f              fobj2.addFile(vC='',file=file(file2),author=author,newName=f)
             ob=fobj2._getOb(f)              logging.debug("importfiles: fobj2.add")
             ob.title=id              count+=1
                           
             manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')              #now add the file to the storage
             self.CDLICatalog.catalog_object(ob)              ob = getattr(fobj2,f)
             #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)              logging.debug("importfiles: btree_start")
             #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])              #self.cdliRoot.updateOrAddToFileBTree(ob)
                           logging.debug("importfiles: btree_end")
               if count%100==0:
                   logging.debug("importfiles: committing")
                   transaction.get().commit()
   
           logging.debug("importfiles: committing")
           transaction.get().commit()
           logging.debug("importfiles: committing done")
         return "ok"          return "ok"
           
 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 1137  def manage_addCDLIFileFolder(self, id, t Line 1516  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 1157  def manage_addCDLIFileFolder(self, id, t Line 1539  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.6  
changed lines
  Added in v.1.120

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