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

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

version 1.3, 2005/12/08 17:11:31 version 1.5, 2006/02/13 20:35:35
Line 6  import os.path Line 6  import os.path
 import os  import os
 from types import *  from types import *
 import urlparse  import urlparse
   from OFS.OrderedFolder import OrderedFolder
   from OFS.SimpleItem import SimpleItem
   import time
   
 class Basket(Folder):  
     """shopping basket"""  
   class Basket_old(Folder):
       """shopping basket - alte fassung """
           
     meta_type="Basket"      meta_type="Basket"
     _v_stack={}      _v_stack={}
Line 19  class Basket(Folder): Line 24  class Basket(Folder):
         if len(founds)>0:          if len(founds)>0:
              return founds[0].getObject().absolute_url()               return founds[0].getObject().absolute_url()
                     
         else: #assume version          else: #assume version number
             splitted=objId.split("_")              splitted=objId.split("_")
             founds=self.CDLICatalog.search({'path':splitted[1]})                      founds=self.CDLICatalog.search({'path':splitted[1]})        
             return founds[0].getObject().absolute_url()+'/'+objId              return founds[0].getObject().absolute_url()+'/'+objId
Line 89  class Basket(Folder): Line 94  class Basket(Folder):
             user=self.REQUEST.SESSION.get('basketUser',None)              user=self.REQUEST.SESSION.get('basketUser',None)
                   
         if not user:          if not user:
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','authorizeBasketUser.zpt')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)
             return pt()              return pt()
         else:          else:
             baskets=self.ZopeFind(self,obj_ids=[user])              baskets=self.ZopeFind(self,obj_ids=[user])
Line 103  class Basket(Folder): Line 108  class Basket(Folder):
             return pt()              return pt()
                   
   
 def manage_addBasketForm(self):  def manage_addBasket_oldForm(self):
     """add the basket form"""      """add the basket form"""
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_addBasket(self,id,title,RESPONSE=None):  def manage_addBasket_old(self,id,title,RESPONSE=None):
     """add the basket"""      """add the basket"""
     ob=Basket()      ob=Basket()
           
Line 121  def manage_addBasket(self,id,title,RESPO Line 126  def manage_addBasket(self,id,title,RESPO
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
           
 class BasketObject(Folder):  class BasketObject_old(Folder):
     """Basket Object"""      """Basket Object - alte fassung"""
           
     meta_type="basketObject"      meta_type="basketObject"
     def __init__(self):      def __init__(self):
Line 220  class BasketObject(Folder): Line 225  class BasketObject(Folder):
         self.REQUEST.RESPONSE.write(ret)              self.REQUEST.RESPONSE.write(ret)    
                   
                   
 def manage_addBasketObjectForm(self):  def manage_addBasket_oldObjectForm(self):
     """add form"""      """add form"""
     pass      pass
   
 def manage_addBasketObject(self,id,title='',RESPONSE=None):  def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):
     """add"""      """add"""
           
     ob=BasketObject()      ob=BasketObject()
Line 237  def manage_addBasketObject(self,id,title Line 242  def manage_addBasketObject(self,id,title
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   class CDLIBasketContainer(OrderedFolder):
       """contains the baskets"""
       
   
       
       meta_type="CDLIBasketContainer"
       
       def getBasketIdfromName(self,basketname):
           """get id from name"""
   
           for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):
               if basket[1].title==basketname:
                   return basket[0]
           else:
               None
       def uploadBasket_html(self,basketId='0'):
           """upload an atf file, html form"""
           basketId=str(basketId)
           if not basketId=='0':
               basketName=getattr(self.basketContainer,basketId).title
           else:
               basketName=""
               
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)
           return pt(basketId=basketId,basketName=basketName)
      
   
           
       def index_html(self):
           """stanadard ansicht"""
           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 pt()
       
       def getStorageFolderRoot(self):
           """root des storage folders"""
           return self.cdli_main
       
       def __init__(self,id,title):
           """ init basket container"""
           self.id=id
           self.title=title
        
        
       def getBaskets(self,sortField='title'):
           """get all baskets files"""
   
           def sortName(x,y):
               return cmp(x[1].title.lower(),y[1].title.lower())
   
           def sortDate(x,y):
               return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
   
           
           def sortComment(x,y):
   
           
               
                try:
                   xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
                except:
                   xc='ZZZZZZZZZZZZZ'.lower()
                try:
                   yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
                except:
                   yc='ZZZZZZZZZZZZZ'.lower()
       
       
                if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
                    
                    try:
                        xc=x[1].getLastVersion().getComment().lower()
                    except:
                        xc='ZZZZZZZZZZZZZ'.lower()
                        
                if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
                    try:
                        yc=y[1].getLastVersion().getComment().lower()
                    except:
                        yc='ZZZZZZZZZZZZZ'.lower()
       
                
                    return cmp(xc,yc)
           
           def sortAuthor(x,y):
               
               return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())
           
           baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
           
           
           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 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
           return last
       
       def setActiveBasket(self,basketId):
           """store active basketId in a cookie"""
           self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
           
       def getActiveBasket(self):
           """get active basket from cookie"""
           
           id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
           obj=getattr(self,id,None)
           return obj
       def getActualUserName(self):
           """get name of the actualuser"""
           return str(self.REQUEST['AUTHENTICATED_USER'])
       
       
       def addBasket(self,newBasketName):
           """add a new basket"""
           
           ob=manage_addCDLIBasket(self,newBasketName)
           return ob
       
       def storeInBasket(self,ids,submit,newBasketName=None,RESPONSE=None,REQUEST=None):
           """store it"""
           
           if type(ids) is not ListType:
               ids=[ids]
           
           if submit=="store in new basket":
               basketRet=self.addBasket(newBasketName)
               self.setActiveBasket(basketRet.getId())
               basket=getattr(self,basketRet.getId())
           elif submit=="store in active basket":
               basket=self.getActiveBasket()
            
           basket.addObjects(ids)
           back=self.REQUEST['HTTP_REFERER']
   
           if RESPONSE:
               RESPONSE.redirect(back)
               
           
   def manage_addCDLIBasketContainerForm(self):
       """add the CDLIBasketContainer form"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)
       return pt()
   
   def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):
       """add the basket"""
       ob=CDLIBasketContainer(id,title)
       
       self._setObject(id, ob)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   class CDLIBasket(Folder,CatalogAware):
       """basket"""
       
       meta_type="CDLIBasket"
       default_catalog="CDLIBasketCatalog"
       
       def getFile(self,obj):
           return obj[1]
       
       def getFileLastVersion(self,obj):
           return obj[0]
       
       def getFileNamesInLastVersion(self):
           """get content of the last version as list"""
           
           return [x[1].getId() for x in self.getLastVersion().getContent()]
       
       def isActual(self,obj):
           """teste ob im basket die aktuelle version ist"""
           actualNo=obj[1].getLastVersion().getVersionNumber()
           storedNo=obj[0].getVersionNumber()
           if actualNo==storedNo:
               return True
           else:
               return False
           
       def history(self):
           """history"""  
   
           ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
           if ext:
               return getattr(self,ext[0][1].getId())()
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','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=""):
           """init a CDLIBasket"""
           
           self.id=id
           self.title=title
           self.shortDescription=shortDescription
           self.comment=comment
    
      
              
       def getLastVersion(self):
           """hole letzte version"""
           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):
           """get versions"""
           versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])
           return versions
   
      
       
       def addObjects(self,ids,deleteOld=None):
           """generate a new version of the basket with objects added"""
          
           lastVersion=self.getLastVersion()
           
           if lastVersion is None:
               oldContent=[]
           else:
               oldContent=lastVersion.basketContent[0:]
   
           if deleteOld:
               oldContent=[]
   
           newContent=[]
        
           for id in ids:
               founds=self.CDLICatalog.search({'title':id})
               print id,founds
               for found in founds:
                   if found.getObject() not in oldContent:
                       #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
                       newContent.append((found.getObject().getLastVersion(),found.getObject()))
       
   
           content=oldContent+newContent
           
           user=self.getActualUserName()
           
           ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
   
       
       
       def deleteObjects(self,ids,RESPONSE=None):
           """delete objects"""
           #TODO: implement delete Objects
           
   def manage_addCDLIBasketForm(self):
       """add the CDLIBasketContainer form"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)
       return pt()
   
   def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):
       """add the basket"""
       
       id=str(self.getNewId())
       
       ob=CDLIBasket(id,title,shortDescription,comment)
       
       self._setObject(id, ob)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
       else:
           return ob
   
   class CDLIBasketVersion(SimpleItem):
       """version of a basket"""
       
       meta_type="CDLIBasketVersion"
       
       def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
           """download all selected files in one file"""
           
           ret=""
           lockedObjects={}
           
   
           if lock:
               
               if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
                   
                   return "please login first"
   
               #check if a locked object exist in the basket.
               lockedObjects={}
               for object in self.basketContent:
   
                   if not object[1].lockedBy=="":
                       lockedObjects[object[1].title]=repr(object[1].lockedBy)
                      
                       
               keys=lockedObjects.keys()
               
               
               if len(keys)>0 and (not procedure):
                   self.REQUEST.SESSION['lockedObjects']=lockedObjects
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
                   return pt()
            
               elif not procedure: #keine fails gesperrt dann alle donwloaden
                   procedure="downloadAll" 
           
   
           for object in self.basketContent:
               
                   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()
           
           #write basketname to header of atf file
           ret="#atf basket %s\n"%basket_name+ret
           
           self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
           self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
           length=len(ret)
           self.REQUEST.RESPONSE.setHeader("Content-Length",length)
           self.REQUEST.RESPONSE.write(ret)    
           
    
       def numberOfItems(self):
           """return anzahl der elemente im basket"""
           return len(self.basketContent)
       
       def getTime(self):
           """getTime"""
           #return self.bobobase_modification_time().ISO()
         
           if hasattr(self,'time'):
               return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
           elif hasattr(self,'timefixed'):
               return self.timefixed
           else:
               setattr(self,'timefixed',self.bobobase_modification_time().ISO())
               return self.bobobase_modification_time().ISO()
       
       def getContent(self):
           """get Basket Content"""
           return self.basketContent
   
       
       def __init__(self,id,user,comment="",basketContent=[]):
           """ init a basket version"""
           self.id=id
           self.coment=comment
           self.basketContent=basketContent[0:]
           self.user=user
           self.time=time.localtime()
           
       def getUser(self):
           """get user"""
           return self.user
       
       def getComment(self):
           """get Comment"""
           return self.comment
    
       def index_html(self):
               """view the basket"""
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
               return pt()
        
       def getObjUrl(self,result):
           """getUrl of the version of the object"""
           objId=result[1].getTitle()
           founds=self.CDLICatalog.search({'title':objId})
           if len(founds)>0:
                return founds[0].getObject().absolute_url()
            
           else: #assume version number
               splitted=objId.split("_")
               founds=self.CDLICatalog.search({'path':splitted[1]})        
               return founds[0].getObject().absolute_url()+'/'+objId
      
   def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
       """add a version"""
       
       #check for already existing versions
    
       lastVersion=self.getLastVersion()
       if lastVersion is None:
           newId=str(1)
       else:
           newId=str(int(lastVersion.getId())+1)
       
       ob=CDLIBasketVersion(newId,user,comment,basketContent)
       
       self._setObject(newId, ob)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
       else:
           return ob
       
 class CDLIFileObject(versionedFileObject):  class CDLIFileObject(versionedFileObject):
     """CDLI file object"""      """CDLI file object"""
           
Line 288  class CDLIFile(versionedFile,CatalogAwar Line 720  class CDLIFile(versionedFile,CatalogAwar
     meta_type="CDLI file"      meta_type="CDLI file"
     default_catalog='CDLICatalog'      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 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"
           
     def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):      def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
         """add"""          """add"""
         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden          try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
Line 360  def manage_addCDLIFile(self,id,title,loc Line 809  def manage_addCDLIFile(self,id,title,loc
   
 def splitatf(fh,dir=None):  def splitatf(fh,dir=None):
     """split it"""      """split it"""
           ret=None
     nf=None      nf=None
     for line in fh.readlines():      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:
         if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile          if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
             if nf:              if nf:
                 nf.close() #close last file                  nf.close() #close last file
Line 373  def splitatf(fh,dir=None): Line 826  def splitatf(fh,dir=None):
             if dir:              if dir:
                 filename=os.path.join(dir,filename)                  filename=os.path.join(dir,filename)
             nf=file(filename,"w")              nf=file(filename,"w")
                           if nf:    
         nf.write(line)          nf.write(line)
           
     nf.close()      nf.close()
     fh.close()      fh.close()
       return ret,len(os.listdir(dir))
           
 class CDLIFileFolder(versionedFileFolder):  class CDLIFileFolder(versionedFileFolder):
     """CDLI folder"""      """CDLI File Folder"""
           
     meta_type="CDLI Folder"      meta_type="CDLI Folder"
     filesMetaType=['CDLI file']      filesMetaType=['CDLI file']
     folderMetaType=['CDLI Folder']      folderMetaType=['CDLI Folder']
     default_catalog='CDLICatalog'      default_catalog='CDLICatalog'
           
     def uploadATF(self,upload,RESPONSE=None):      def getVersionNumbersFromIds(self,ids):
           """get the numbers of the current versions of documents described by their ids"""
           
           ret=[]
           searchStr=" OR ".join(ids)
           
           founds=self.CDLICatalog.search({'path':searchStr})
           
           for found in founds:
               lastVersion=found.getObject().getLastVersion()
               ret.append((found.getId,lastVersion))
           
           return ret
       
    
       def uploadATF(self,upload,basketId=0,RESPONSE=None):
         """upload an atf file"""          """upload an atf file"""
         #TODO: add comments          #TODO: add comments
         #TODO: finish uploadATF          #TODO: finish uploadATF
           basketId=str(basketId)
           
           
           
         dir=mkdtemp()          dir=mkdtemp()
         changed=[]          changed=[]
         errors=[]          errors=[]
         newPs=[]          newPs=[]
         splitatf(upload,dir)          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()
               
   
         for fn in os.listdir(dir):          for fn in os.listdir(dir):
             founds=self.CDLICatalog.search({'path':fn})                  founds=self.CDLICatalog.search({'title':fn})    
         
             if len(founds)==0:              if len(founds)==0:
                 newPs.append(fn)                  newPs.append(fn)
                                   
Line 420  class CDLIFileFolder(versionedFileFolder Line 901  class CDLIFileFolder(versionedFileFolder
         self.REQUEST.SESSION['tmpdir']=dir          self.REQUEST.SESSION['tmpdir']=dir
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
         return pt(changed=changed,errors=errors,dir=dir,newPs=newPs)          return pt(changed=changed,errors=errors,dir=dir,newPs=newPs,basketLen=basketLen,numberOfFiles=numberOfFiles,
                      basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId)
                                           
     def uploadATFfinally(self,procedure,comment="",unlock=None,RESPONSE=None):      def uploadATFfinally(self,procedure,comment="",basketname='',unlock=None,RESPONSE=None):
         """upload the files"""          """upload the files"""
                   
         if procedure=="uploadchanged":          if procedure=="uploadchanged":
Line 466  class CDLIFileFolder(versionedFileFolder Line 948  class CDLIFileFolder(versionedFileFolder
                                         
                     founds[0].getObject().lockedBy=""                      founds[0].getObject().lockedBy=""
                                           
           if not (basketname ==''):
               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:          if RESPONSE is not None:
             RESPONSE.redirect(self.aq_parent.absolute_url())              RESPONSE.redirect(self.aq_parent.absolute_url())
                   
Removed from v.1.3  
changed lines
  Added in v.1.5

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