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

Diff for /basket/basket.py between versions 1.1 and 1.6

version 1.1, 2006/01/19 16:25:49 version 1.6, 2006/04/05 16:54:59
Line 8  import cgi Line 8  import cgi
   
 from OFS.OrderedFolder import OrderedFolder  from OFS.OrderedFolder import OrderedFolder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
   from OFS.Image import File
   
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
 from AccessControl.User import UserFolder  from AccessControl.User import UserFolder
Line 21  from Globals import Persistent, package_ Line 22  from Globals import Persistent, package_
 from Acquisition import Implicit  from Acquisition import Implicit
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   
 refBasis="http://vlp.mpiwg-berlin.mpg.de/references?id=%s"   
 #basis url for references  
   
 publicationStatus=['private','restricted','open','published']   
 # private only access for the owner, restricted only for users in accessGroup, open open for everyone, published occurs in basket list  
   
 class Basket(OrderedFolder):  from groups import manage_addGroupFolder
     """Basket class"""  
       
     meta_type="basket"  
           
     security=ClassSecurityInfo()  refBasis="http://vlp.mpiwg-berlin.mpg.de/references?id=%s" 
           
     manage_options=OrderedFolder.manage_options+(  basketMetatypes=['BasketXRef','BasketInternalLink','BasketExternalLink','BasketText','BasketFile']
         {'label':'manage main','action':'changeBasketForm'},  
         )  
           
     def __init__(self,id,title,comment,owner,publicationStatus,shortDescription,accessGroups=None):  #basis url for references
         '''  
         init the basket  
         @param id: id  
         @param title: title of the basket  
         @param comment: description of the basket  
         @param shortDescription: short description of the basket for the overviewList  
         @param owner: user object describing the owner  
         @param publication_status: one of publicationStatus if restricted, optional parameter accessGroups has to be set  
         @param aaccessGroups: default value is none, contains list of groups which are allowed to access this basket  
         '''  
                   
         self.id=id  publicationStatusList=['private','hidden','open_intern','open','group'] 
         self.title=title  # private only access for the owner, restricted only for users in accessGroup, open open for everyone, published occurs in basket list
         self.comment=comment  
         self.owner=owner  
         self.publicationStatus=publicationStatus  
         self.accessGroups=accessGroups  
         self.shortDecription=shortDescription  
                   
     security.declareProtected('View','getOwner')  class BasketBasis(OrderedFolder):
       """Basis class for BasketFolder and Baskets"""
           
       security=ClassSecurityInfo()
     def getNewId(self):      def getNewId(self):
         """createIds"""          """createIds"""
         last=getattr(self,'last',0)          last=getattr(self,'last',0)
         last +=1          last +=1
         while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:          while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
             last+=1              last+=1
       
         return last          return last
                   
       def addBasketFile(self,REQUEST=None,fileUpload=None,comment=None,title=""):
           """add a file to the basket"""
           if fileUpload==None:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketFile.zpt')).__of__(self)
               pt.content_type="text/html"
               return pt()
           else:
               id=self.getNewId()
               if title=="":
                   title=fileUpload.filename
                   
               manage_addBasketFile(self,id,title,comment,fileUpload)
               if REQUEST:
                   REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
       
     def addBasketText(self,REQUEST=None):      def addBasketText(self,REQUEST=None):
         """add a text"""          """add a text"""
         id=self.getNewId()          id=self.getNewId()
Line 75  class Basket(OrderedFolder): Line 69  class Basket(OrderedFolder):
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
           
       def addBasketExternalLink(self,REQUEST=None):
           """add an external link"""
           id=self.getNewId()
           
           manage_addBasketExternalLink(self,str(id),"","","","",RESPONSE=None)
           if REQUEST:
               REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
           
     def deleteObject(self,id,REQUEST=None):      def deleteObject(self,id,REQUEST=None):
         """delete object"""          """delete object"""
         self.manage_delObjects([id])          self.manage_delObjects([id])
Line 105  class Basket(OrderedFolder): Line 107  class Basket(OrderedFolder):
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
                       
       security.declareProtected('View','getOwner')
             
     def getOwner(self):      def getOwner(self):
         """get Owner as string"""          """get Owner as string"""
         return self.owner          return self.owner
           
       def isAuthorized(self,role="read"):
           """check whether actual user is authorized"""
           #TODO replace occurences with checkPermission
           return True
       
       def getActualUserName(self):
           """get username of actual user"""
           return self.REQUEST['AUTHENTICATED_USER'].getUserName()
           
       def getObjects(self):
           """"get objects"""
           return [getattr(self,x['id']) for x in self._objects]
      
       def numberOfObjects(self):
           """anzahl der elemente im basket"""
           return len(self._objects)
       
   class BasketFolder(BasketBasis):
       """Folder for Baskets"""
       
       meta_type="Basket Folder"
       
       #security=ClassSecurityInfo()
       
       def getSets(self,mode='open'):
           """get sets, depending on mode selected"""
           ret=[]
           
           if mode=='open':
               for object in self.getObjects():
              
                   if object.publicationStatus=='open':
                       ret.append(object)
               return ret
           elif mode=='open_intern':
               print "open_intern"
               if self.groupFolder.isMemberOf('user'):
                   print "---public"
                   for object in self.getObjects():
                       print object.getId(),object.publicationStatus
                       if object.publicationStatus=='open_intern':
                           ret.append(object)
                   return ret
               else:
                   return ret
           elif mode=='private':
               for object in self.getObjects():
                   if object.groupFolder.isMemberOf('admin') or object.groupFolder.isMemberOf('editor'):
                       ret.append(object)
               return ret
           elif mode=='groups':
               for object in self.getObjects():
                   if object.groupFolder.isMemberOf('reader') or object.groupFolder.isMemberOf('editor') or object.groupFolder.isMemberOf('admin'):
                       ret.append(object)
                   return ret
   
       def getCurrentBasket(self):
           """select this basket for further work"""
        
           id=self.REQUEST.cookies.get('vlp_basket',None)
       if id:  
           return getattr(self,id,None)
       else:
           return None
           
            
       def index_html(self,mode='open'):
           """generische ansicht"""
   
           #check if user has right for other modi
           
           if hasattr(self,"BasketFolder_template"):
               obj=getattr(self,"BaskeFolder_template")
               return obj()
           else:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketFolder_template_standard.zpt')).__of__(self)
               pt.content_type="text/html"
               return pt(mode=mode)
     
       def __init__(self,id,title):
           """init basket folder"""
           
           self.id=id
           self.title=title
           
       def manageBasketFolder(self):
           """manage the basket"""
           
           if hasattr(self,"BasketFolder_manage_template"):
               obj=getattr(self,"BasketFolder_manage_template")
               return obj()
           else:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketFolder_manage_template_standard.zpt')).__of__(self)
               pt.content_type="text/html"
               return pt()
       
       def addBasket(self,title,RESPONSE=None):
           """add a new basket"""
           id=self.getNewId()
           username=self.getActualUserName()
           publicationStatus="private"
           manage_addBasket(self,str(id),title,"",username,publicationStatus,RESPONSE=None)
           newObj=getattr(self,str(id))
           #create a groupfolder
           
           manage_addGroupFolder(newObj,'groupFolder')
           
           #add current user to admin group of the new set
           
           newObj.groupFolder.addUserToGroups(str(self.REQUEST['AUTHENTICATED_USER']),['admin'])
           if RESPONSE:
               RESPONSE.redirect(newObj.absolute_url()+'/manageBasket')
           
   
   def manage_addBasketFolderForm(self):
       """form for adding a basket"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketFolder.zpt')).__of__(self)
       return pt()
   
   def manage_addBasketFolder(self,id,title,RESPONSE=None):
       """add a basket folder object"""
   
     
       newObj=BasketFolder(id,title)
       
       self._setObject(id,newObj)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
        
   class Basket(BasketBasis):
       """Basket class"""
       
       meta_type="basket"
       
       security=ClassSecurityInfo()
       
       publicationStatusList=publicationStatusList
       
       manage_options=OrderedFolder.manage_options+(
           {'label':'manage main','action':'changeBasketForm'},
           )
       
       def checkPermission(self,modus):
           """check permission"""
           if modus=='open':
               return True
           elif modus=='private':
               return self.groupFolder.isMemberOf('admin')
           elif modus=='admin':
               return self.groupFolder.isMemberOf('admin')
           elif modus=='edit':
               return self.groupFolder.isMemberOf('edit')
           elif modus=='publish':
               return self.groupFolder.isMemberOf('publish')
        
       def manageUserRights_html(self):
           """manage user rights"""
           if hasattr(self,"Basket_manageUserRights_template"):
               obj=getattr(self,"Basket_manageUserRights_template")
               return obj()
           else:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_Basket_manageUserRights_standard.zpt')).__of__(self)
               pt.content_type="text/html"
               return pt()
       
    
       def getBasketObjects(self):
           """get all basket objects"""
           
           objs=self.getObjects()
           ret=[]
           for x in objs:
               if x.meta_type in basketMetatypes:
                  ret.append(x)
           return ret
       
       def checkRef(self,xref):
           """check if XRef is already in Basket"""
           
           founds=self.ZopeFind(self,obj_metatypes=["BasketXRef"])
           for found in founds:
               if self.xref==xref:
                   return True
           return False
               
       def __init__(self,id,title,comment,owner,publicationStatus,shortDescription):
           '''
           init the basket
           @param id: id
           @param title: title of the basket
           @param comment: description of the basket
           @param shortDescription: short description of the basket for the overviewList
           @param owner: user object describing the owner
           @param publication_status: one of publicationStatus if restricted, optional parameter accessGroups has to be set
           '''
           
           self.id=id
           self.title=title
           self.comment=comment
           self.owner=owner
           self.publicationStatus=publicationStatus
           self.shortDescription=shortDescription
           
           
    
       def getTitle(self):
           """print name"""
           return self.title
           
       security.declareProtected('Manage','changeBasketForm')
     def changeBasketForm(self):      def changeBasketForm(self):
         """form for changing the basket"""          """form for changing the basket"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasket.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasket.zpt')).__of__(self)
         return pt()          return pt()
   
   
     def changeBasket(self,title,comment,shortDescription,publicationStatus=None,username=None,accessGroups=None,RESPONSE=None,target=None):      def changeBasket(self,title,comment,shortDescription,publicationStatus=None,username=None,accessGroups=None,RESPONSE=None,target=None):
         '''          '''
         init the basket          init the basket
Line 166  class Basket(OrderedFolder): Line 382  class Basket(OrderedFolder):
             pt.content_type="text/html"              pt.content_type="text/html"
             return pt()              return pt()
           
     def isAuthorized(self,role="read"):  
         """check whether actual user is authorized"""  
         #TODO implement isAuthorized to do type, read or edit  
         return True  
         
     def getActualUserName(self):  
         """get username of actual user"""  
         return self.REQUEST['AUTHENTICATED_USER'].getUserName()  
           
     def getObjects(self):  
         """"get objects"""  
         return [getattr(self,x['id']) for x in self._objects]  
      
     def numberOfObjects(self):  
         """anzahl der elemente im basket"""  
         return len(self._objects)  
           
     def changeBasketComments(self,REQUEST):      def changeBasketComments(self,REQUEST):
         """Change comment of basket elements"""          """Change comment of basket elements"""
Line 191  class Basket(OrderedFolder): Line 391  class Basket(OrderedFolder):
             splitted=key.split("_")              splitted=key.split("_")
             objects=self.ZopeFind(self,obj_ids=[splitted[0]])              objects=self.ZopeFind(self,obj_ids=[splitted[0]])
             if len(objects)>0:              if len(objects)>0:
                 objects[0][1].comment=form[key]                  setattr(objects[0][1],splitted[1],form[key])
   
         
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")                REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")  
Line 204  class Basket(OrderedFolder): Line 405  class Basket(OrderedFolder):
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
                   
     def getCurrentBasket(self):  
         """select this basket for further work"""  
         return self.REQUEST.cookies.get('vlp_basket',None)  
           
     def generateNewObject(self,type,link,title='',comment='',REQUEST=None):      def generateNewObject(self,type,link,title='',comment='',REQUEST=None):
         """generate a new object in the basket"""          """generate a new object in the basket"""
Line 232  class Basket(OrderedFolder): Line 430  class Basket(OrderedFolder):
             manage_addBasketXRef(self,str(id),title,comment,xref)              manage_addBasketXRef(self,str(id),title,comment,xref)
                   
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(REQUEST['HTTP_REFERER'])              import random
               rd=random.random()
               REQUEST.RESPONSE.redirect(REQUEST['HTTP_REFERER']+'&-dummy='+str(rd))
         else:          else:
             return True              return True
   
Line 241  def manage_addBasketForm(self): Line 441  def manage_addBasketForm(self):
     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,comment,username,publicationStatus,accessGroups=None,RESPONSE=None):  def manage_addBasket(self,id,title,comment,username,publicationStatus,shortDescription="",accessGroups=None,RESPONSE=None):
     """add a basket object"""      """add a basket object"""
     #TODO:what happens in username does not exists      #TODO:what happens in username does not exists
     #find username      #find username
     owner=username      owner=username
           
     newObj=Basket(id,title,comment,owner,publicationStatus,accessGroups=None)      newObj=Basket(id,title,comment,owner,publicationStatus,shortDescription)
           
     self._setObject(id,newObj)      self._setObject(id,newObj)
           
Line 257  def manage_addBasket(self,id,title,comme Line 457  def manage_addBasket(self,id,title,comme
 class BasketBasis(SimpleItem):  class BasketBasis(SimpleItem):
     """basic class for baskets"""      """basic class for baskets"""
           
     security=ClassSecurityInfo()      #security=ClassSecurityInfo()
           
     manage_options=SimpleItem.manage_options+(      manage_options=SimpleItem.manage_options+(
         {'label':'manage main','action':'changeBasketBasisForm'},          {'label':'manage main','action':'changeBasketBasisForm'},
Line 306  class BasketBasis(SimpleItem): Line 506  class BasketBasis(SimpleItem):
             pt.content_type="text/html"              pt.content_type="text/html"
             return pt()              return pt()
           
   class BasketFile(BasketBasis,File):
       """class for fileupload"""
       meta_type="BasketFile"
       
       def __init__(self,id,title,comment,content_type='',precondition=''):
           """init"""
           self.id=id
           self.title=title
           self.comment=comment
           self.content_type=content_type
           self.precondition=precondition
           
       
       def download(self):
           """download the file"""
           self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.title)
           self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
      
           self.content_type="application/octet-stream"
           self.REQUEST.RESPONSE.write(self.data)
           
       
       def upDateFile(self,fileUpload=None,comment=None,title="",REQUEST=None):
           """update file"""
           if fileUpload==None:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','upDateBasketFile.zpt')).__of__(self)
               pt.content_type="text/html"
               return pt()
           else:
               id=self.getNewId()
               if title=="":
                   title=fileUpload.filename
                   
               if fileUpload:
                   self.manage_upload(fileUpload)
       
               if comment:
                   self.comment=comment
                   
               if REQUEST:
                   REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
       
       def content_html(self):
           """format object as html fragment"""
           
           
           return BasketBasis.content_html(self,"BasketFile")
       
   def manage_addBasketFile(self,id,title,comment,fileUpload,content_type='',precondition='',REQUEST=None):
       """add a basket file"""
       
       id=str(id)
       title=str(title)
       content_type=str(content_type)
       precondition=str(precondition)
   
       #id, title = cookId(id, title, file)
   
       self=self.this()
   
       # First, we create the file without data:
       self._setObject(id, BasketFile(id,title,comment,content_type, precondition))
   
       # Now we "upload" the data.  By doing this in two steps, we
       # can use a database trick to make the upload more efficient.
       if fileUpload:
           self._getOb(id).manage_upload(fileUpload)
       if content_type:
           self._getOb(id).content_type=content_type
   
       if REQUEST is not None:
           REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
           
 class BasketXRef(BasketBasis):  class BasketXRef(BasketBasis):
     """class for internal references based on xrefs"""      """class for internal references based on xrefs"""
           
     security=ClassSecurityInfo()      #security=ClassSecurityInfo()
     meta_type="BasketXRef"      meta_type="BasketXRef"
   
     manage_options=BasketBasis.manage_options+(      manage_options=BasketBasis.manage_options+(
Line 362  def manage_addBasketXRef(self,id,title,c Line 635  def manage_addBasketXRef(self,id,title,c
 class BasketInternalLink(BasketBasis):  class BasketInternalLink(BasketBasis):
     """class for internal referencens based on links"""      """class for internal referencens based on links"""
           
     security=ClassSecurityInfo()      #security=ClassSecurityInfo()
     meta_type="BasketInternalLink"      meta_type="BasketInternalLink"
           
     manage_options=BasketBasis.manage_options+(      manage_options=BasketBasis.manage_options+(
Line 418  def manage_addBasketInternalLink(self,id Line 691  def manage_addBasketInternalLink(self,id
 class BasketExternalLink(BasketBasis):  class BasketExternalLink(BasketBasis):
     """class for external links"""      """class for external links"""
           
     security=ClassSecurityInfo()      #security=ClassSecurityInfo()
     meta_type="BasketExternalLink"      meta_type="BasketExternalLink"
           
     manage_options=BasketBasis.manage_options+(      manage_options=BasketBasis.manage_options+(
Line 473  def manage_addBasketExternalLink(self,id Line 746  def manage_addBasketExternalLink(self,id
 class BasketText(BasketBasis):  class BasketText(BasketBasis):
     """class for text elements in baskets"""      """class for text elements in baskets"""
           
     security=ClassSecurityInfo()      #security=ClassSecurityInfo()
     meta_type="BasketText"      meta_type="BasketText"
   
     def content_html(self):      def content_html(self):
Removed from v.1.1  
changed lines
  Added in v.1.6

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