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

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

version 1.1, 2006/01/19 16:25:49 version 1.13, 2007/08/14 18:28:17
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
   
   
   from groups import manage_addGroupFolder
   
 refBasis="http://vlp.mpiwg-berlin.mpg.de/references?id=%s"   refBasis="http://vlp.mpiwg-berlin.mpg.de/references?id=%s" 
   
   basketMetatypes=['BasketXRef','BasketInternalLink','BasketExternalLink','BasketText','BasketFile']
   
 #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+(      def content_html(self,type):
         {'label':'manage main','action':'changeBasketForm'},          """generische ausgabe des objectes als html"""
         )          if hasattr(self,type+"_template"):
                   obj=getattr(self,type+"_template")
     def __init__(self,id,title,comment,owner,publicationStatus,shortDescription,accessGroups=None):              return obj()
         '''          else:
         init the basket              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','%s_template_standard.zpt'%type)).__of__(self)
         @param id: id              pt.content_type="text/html"
         @param title: title of the basket              return pt()
         @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      def checkPermission(self,modus):
         self.title=title          """check permission"""
         self.comment=comment          if modus=='open':
         self.owner=owner              return True
         self.publicationStatus=publicationStatus          elif modus=='private':
         self.accessGroups=accessGroups              return self.groupFolder.isMemberOf('admin')
         self.shortDecription=shortDescription          elif modus=='admin':
               return self.groupFolder.isMemberOf('admin')
           elif modus=='edit':
               return (self.groupFolder.isMemberOf('editor') or self.groupFolder.isMemberOf('admin'))
           elif modus=='publish':
               return self.groupFolder.isMemberOf('publish')
           elif modus=='authorized':
               if self.getActualUserName().lower() == "anonymous user":
                   return False
               else:
                   return True
                   
     security.declareProtected('View','getOwner')  
           
     def getNewId(self):      def getNewId(self):
         """createIds"""          """createIds"""
Line 66  class Basket(OrderedFolder): Line 74  class Basket(OrderedFolder):
         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()
         manage_addBasketText(self,str(id),'','',RESPONSE=None)          manage_addBasketText(self,str(id),'','',RESPONSE=None)
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+str(id))
       
       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#"+str(id))
           
     def deleteObject(self,id,REQUEST=None):      def deleteObject(self,id,REQUEST=None):
         """delete object"""          """delete object"""
Line 85  class Basket(OrderedFolder): Line 117  class Basket(OrderedFolder):
         """move id one up"""          """move id one up"""
         self.moveObjectsUp([id], 1)          self.moveObjectsUp([id], 1)
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+id)
           
     def moveDown(self,id,REQUEST=None):      def moveDown(self,id,REQUEST=None):
         """move id one up"""          """move id one up"""
         self.moveObjectsDown([id], 1)          self.moveObjectsDown([id], 1)
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+id)
                           
     def moveTop(self,id,REQUEST=None):      def moveTop(self,id,REQUEST=None):
         """move to top"""          """move to top"""
         self.moveObjectsToTop([id])          self.moveObjectsToTop([id])
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+id)
       
     def moveBottom(self,id,REQUEST=None):      def moveBottom(self,id,REQUEST=None):
         """move to top"""          """move to top"""
         self.moveObjectsToBottom([id])          self.moveObjectsToBottom([id])
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+id)
       
       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 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.checkPermission('authorized'):
                   for object in self.getObjects():
                       if object.publicationStatus=='open_intern' or object.publicationStatus=='open':
                           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,"BasketFolder_template")
               return obj(mode=mode)
           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 saveButton(self,actualId):
           """return the save button"""
           ret="""
           <a class="editLink" style="cursor:pointer"
                       onClick="forms.changeSetContents.actualId.value='%s';forms.changeSetContents.submit();">save</a> -
       
           """%actualId
           return ret
       
       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 404  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 413  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#"+form.get('actualId',''))  
                               
   
     def selectThisBasketAsCurrent(self,REQUEST=None):      def selectThisBasketAsCurrent(self,REQUEST=None):
Line 204  class Basket(OrderedFolder): Line 427  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 452  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()
               urlSplit=REQUEST['HTTP_REFERER'].split("?")
               if len(urlSplit)>1:
                   parsed=cgi.parse_qs(urlSplit[1])
                   parsed['-link']=link
                   qs=urllib.urlencode(parsed,doseq=True)
                   
               else:
                   qs=""
                   
               REQUEST.RESPONSE.redirect(urlSplit[0]+"?"+qs)
         else:          else:
             return True              return True
   
Line 241  def manage_addBasketForm(self): Line 472  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)
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
             
 class BasketBasis(SimpleItem):  class BasketObject(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 537  class BasketBasis(SimpleItem):
             pt.content_type="text/html"              pt.content_type="text/html"
             return pt()              return pt()
           
 class BasketXRef(BasketBasis):  class BasketFile(BasketObject,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"
       try:
               self.REQUEST.RESPONSE.write(self.data)
           except:
           try:
               self.REQUEST.RESPONSE.write(str(self.data))
           except:
               self.REQUEST.RESPONSE.write(repr(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:
               
               if title=="":
                   title=fileUpload.filename
               
               self.title=title    
               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 BasketObject.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(BasketObject):
     """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 340  class BasketXRef(BasketBasis): Line 652  class BasketXRef(BasketBasis):
         """format object as html fragment"""          """format object as html fragment"""
                   
         type=self.xref[0:3]          type=self.xref[0:3]
         return BasketBasis.content_html(self,"BasketXRef_%s"%type)          return BasketObject.content_html(self,"BasketXRef_%s"%type)
           
 def manage_addBasketXRefForm(self):  def manage_addBasketXRefForm(self):
     """form for adding a basket"""      """form for adding a basket"""
Line 359  def manage_addBasketXRef(self,id,title,c Line 671  def manage_addBasketXRef(self,id,title,c
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                 
 class BasketInternalLink(BasketBasis):  class BasketInternalLink(BasketObject):
     """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=BasketObject.manage_options+(
         {'label':'manage internal link','action':'changeBasketInternalLinkForm'},          {'label':'manage internal link','action':'changeBasketInternalLinkForm'},
         )          )
     
Line 390  class BasketInternalLink(BasketBasis): Line 702  class BasketInternalLink(BasketBasis):
     def content_html(self):      def content_html(self):
         """format object as html fragment"""          """format object as html fragment"""
                   
         return BasketBasis.content_html(self,"BasketInternalLink")          return BasketObject.content_html(self,"BasketInternalLink")
           
     def linkToObject(self):      def linkToObject(self):
         """link to the object (internalLink)"""          """link to the object (internalLink)"""
Line 415  def manage_addBasketInternalLink(self,id Line 727  def manage_addBasketInternalLink(self,id
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                 
           
 class BasketExternalLink(BasketBasis):  class BasketExternalLink(BasketObject):
     """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=BasketObject.manage_options+(
         {'label':'manage internal link','action':'changeBasketExternalLinkForm'},          {'label':'manage internal link','action':'changeBasketExternalLinkForm'},
         )          )
     
Line 446  class BasketExternalLink(BasketBasis): Line 758  class BasketExternalLink(BasketBasis):
     def content_html(self):      def content_html(self):
         """format object as html fragment"""          """format object as html fragment"""
                   
         return BasketBasis.content_html(self,"BasketExternalLink")          return BasketObject.content_html(self,"BasketExternalLink")
           
     def linkToObject(self):      def linkToObject(self):
         """link to the object (externalLink)"""          """link to the object (externalLink)"""
Line 470  def manage_addBasketExternalLink(self,id Line 782  def manage_addBasketExternalLink(self,id
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                 
           
 class BasketText(BasketBasis):  class BasketText(BasketObject):
     """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.13

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