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

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

version 1.1, 2006/01/19 16:25:49 version 1.2, 2006/03/02 19:57:32
Line 24  from Products.ZCatalog.CatalogPathAwaren Line 24  from Products.ZCatalog.CatalogPathAwaren
 refBasis="http://vlp.mpiwg-berlin.mpg.de/references?id=%s"   refBasis="http://vlp.mpiwg-berlin.mpg.de/references?id=%s" 
 #basis url for references  #basis url for references
   
 publicationStatus=['private','restricted','open','published']   publicationStatusList=['private','hidden','open_intern','open','group'] 
 # private only access for the owner, restricted only for users in accessGroup, open open for everyone, published occurs in basket list  # private only access for the owner, restricted only for users in accessGroup, open open for everyone, published occurs in basket list
   
 class Basket(OrderedFolder):  class BasketBasis(OrderedFolder):
     """Basket class"""      """Basis class for BasketFolder and Baskets"""
       
     meta_type="basket"  
           
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
       
     manage_options=OrderedFolder.manage_options+(  
         {'label':'manage main','action':'changeBasketForm'},  
         )  
       
     def __init__(self,id,title,comment,owner,publicationStatus,shortDescription,accessGroups=None):  
         '''  
         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  
         self.title=title  
         self.comment=comment  
         self.owner=owner  
         self.publicationStatus=publicationStatus  
         self.accessGroups=accessGroups  
         self.shortDecription=shortDescription  
           
     security.declareProtected('View','getOwner')  
       
     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 addBasketText(self,REQUEST=None):      def addBasketText(self,REQUEST=None):
Line 75  class Basket(OrderedFolder): Line 47  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 85  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 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)
       
   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 checkPermission(self,modus):
           """check permission"""
           if modus=='open':
               return True
           elif modus=='private':
               return self.isMemberOf('admin')
           
       def getCurrentBasket(self):
           """select this basket for further work"""
        
           return self.REQUEST.cookies.get('vlp_basket',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()
           publicatonStatus="private"
           manage_addBasket(self,str(id),title,"",username,publicationStatus,RESPONSE=None)
           newObj=getattr(self,str(id))
           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()
       
       manage_options=OrderedFolder.manage_options+(
           {'label':'manage main','action':'changeBasketForm'},
           )
       
       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)
Line 166  class Basket(OrderedFolder): Line 319  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 328  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 342  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 367  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 378  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,accessGroups)
           
     self._setObject(id,newObj)      self._setObject(id,newObj)
           
Line 257  def manage_addBasket(self,id,title,comme Line 394  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 309  class BasketBasis(SimpleItem): Line 446  class BasketBasis(SimpleItem):
 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 499  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 555  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 610  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.2

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