jro_apps/redmine Commit - r3053:f33231181f95

Makes user unwatch what he can no longer view after its permissions have changed (#3589)....

Jean-Philippe Lang -

r3053:f33231181f95

parent child

Context file:

r3053:f33231181f95

Collapse all files

lib/tasks/watchers.rake created 644 +9 0

@@ -0,0 +1,9
	1	desc 'Removes watchers from what they can no longer view.'
	2
	3	namespace :redmine do
	4	namespace :watchers do
	5	task :prune => :environment do
	6	Watcher.prune
	7	end
	8	end
	9	end

app/models/board.rb +4 0

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class Board < ActiveRecord::Base
               belongs_to :project
               has_many :topics, :class_name => 'Message', :conditions => "#{Message.table_name}.parent_id IS NULL", :order => "#{Message.table_name}.created_on DESC"
               has_many :messages, :dependent => :delete_all, :order => "#{Message.table_name}.created_on DESC"
               belongs_to :last_message, :class_name => 'Message', :foreign_key => :last_message_id
               acts_as_list :scope => :project_id
               acts_as_watchable
               validates_presence_of :name, :description
               validates_length_of :name, :maximum => 30
               validates_length_of :description, :maximum => 255
+              def visible?(user=User.current)
+                !user.nil? && user.allowed_to?(:view_messages, project)
+              end
               def to_s
                 name
               end
               def reset_counters!
                 self.class.reset_counters!(id)
               end
               # Updates topics_count, messages_count and last_message_id attributes for +board_id+
               def self.reset_counters!(board_id)
                 board_id = board_id.to_i
                 update_all("topics_count = (SELECT COUNT(*) FROM #{Message.table_name} WHERE board_id=#{board_id} AND parent_id IS NULL)," +
                            " messages_count = (SELECT COUNT(*) FROM #{Message.table_name} WHERE board_id=#{board_id})," +
                            " last_message_id = (SELECT MAX(id) FROM #{Message.table_name} WHERE board_id=#{board_id})",
                            ["id = ?", board_id])
               end
             end

app/models/member.rb +16 -1

             # Redmine - project management software
             # Copyright (C) 2006-2009  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class Member < ActiveRecord::Base
               belongs_to :user
               belongs_to :principal, :foreign_key => 'user_id'
               has_many :member_roles, :dependent => :destroy
               has_many :roles, :through => :member_roles
               belongs_to :project
               validates_presence_of :principal, :project
               validates_uniqueness_of :user_id, :scope => :project_id
+              after_destroy :unwatch_from_permission_change
               def name
                 self.user.name
               end
               alias :base_role_ids= :role_ids=
               def role_ids=(arg)
                 ids = (arg || []).collect(&:to_i) - [0]
                 # Keep inherited roles
                 ids += member_roles.select {|mr| !mr.inherited_from.nil?}.collect(&:role_id)
                 new_role_ids = ids - role_ids
                 # Add new roles
                 new_role_ids.each {|id| member_roles << MemberRole.new(:role_id => id) }
                 # Remove roles (Rails' #role_ids= will not trigger MemberRole#on_destroy)
-                member_roles.select {|mr| !ids.include?(mr.role_id)}.each(&:destroy)
+                member_roles_to_destroy = member_roles.select {|mr| !ids.include?(mr.role_id)}
+                if member_roles_to_destroy.any?
+                  member_roles_to_destroy.each(&:destroy)
+                  unwatch_from_permission_change
+                end
               end
               def <=>(member)
                 a, b = roles.sort.first, member.roles.sort.first
                 a == b ? (principal <=> member.principal) : (a <=> b)
               end
               def deletable?
                 member_roles.detect {|mr| mr.inherited_from}.nil?
               end
               def before_destroy
                 if user
                   # remove category based auto assignments for this member
                   IssueCategory.update_all "assigned_to_id = NULL", ["project_id = ? AND assigned_to_id = ?", project.id, user.id]
                 end
               end
               protected
               def validate
                 errors.add_to_base "Role can't be blank" if member_roles.empty? && roles.empty?
               end
+              private
+              # Unwatch things that the user is no longer allowed to view inside project
+              def unwatch_from_permission_change
+                if user
+                  Watcher.prune(:user => user, :project => project)
+                end
+              end
             end

app/models/member_role.rb +6 -1

             # Redmine - project management software
             # Copyright (C) 2006-2009  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class MemberRole < ActiveRecord::Base
               belongs_to :member
               belongs_to :role
               after_destroy :remove_member_if_empty
               after_create :add_role_to_group_users
               after_destroy :remove_role_from_group_users
               validates_presence_of :role
               def validate
                 errors.add :role_id, :invalid if role && !role.member?
               end
               private
               def remove_member_if_empty
                 if member.roles.empty?
                   member.destroy
                 end
               end
               def add_role_to_group_users
                 if member.principal.is_a?(Group)
                   member.principal.users.each do |user|
                     user_member = Member.find_by_project_id_and_user_id(member.project_id, user.id) || Member.new(:project_id => member.project_id, :user_id => user.id)
                     user_member.member_roles << MemberRole.new(:role => role, :inherited_from => id)
                     user_member.save!
                   end
                 end
               end
               def remove_role_from_group_users
-                MemberRole.find(:all, :conditions => { :inherited_from => id }).each(&:destroy)
+                MemberRole.find(:all, :conditions => { :inherited_from => id }).group_by(&:member).each do |member, member_roles|
+                  member_roles.each(&:destroy)
+                  if member && member.user
+                    Watcher.prune(:user => member.user, :project => member.project)
+                  end
+                end
               end
             end

app/models/message.rb +4 0

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class Message < ActiveRecord::Base
               belongs_to :board
               belongs_to :author, :class_name => 'User', :foreign_key => 'author_id'
               acts_as_tree :counter_cache => :replies_count, :order => "#{Message.table_name}.created_on ASC"
               acts_as_attachable
               belongs_to :last_reply, :class_name => 'Message', :foreign_key => 'last_reply_id'
               acts_as_searchable :columns => ['subject', 'content'],
                                  :include => {:board => :project},
                                  :project_key => 'project_id',
                                  :date_column => "#{table_name}.created_on"
               acts_as_event :title => Proc.new {|o| "#{o.board.name}: #{o.subject}"},
                             :description => :content,
                             :type => Proc.new {|o| o.parent_id.nil? ? 'message' : 'reply'},
                             :url => Proc.new {|o| {:controller => 'messages', :action => 'show', :board_id => o.board_id}.merge(o.parent_id.nil? ? {:id => o.id} :
                                                                                                                                                    {:id => o.parent_id, :anchor => "message-#{o.id}"})}
               acts_as_activity_provider :find_options => {:include => [{:board => :project}, :author]},
                                         :author_key => :author_id
               acts_as_watchable
               attr_protected :locked, :sticky
               validates_presence_of :board, :subject, :content
               validates_length_of :subject, :maximum => 255
               after_create :add_author_as_watcher
+              def visible?(user=User.current)
+                !user.nil? && user.allowed_to?(:view_messages, project)
+              end
               def validate_on_create
                 # Can not reply to a locked topic
                 errors.add_to_base 'Topic is locked' if root.locked? && self != root
               end
               def after_create
                 if parent
                   parent.reload.update_attribute(:last_reply_id, self.id)
                 end
                 board.reset_counters!
               end
               def after_update
                 if board_id_changed?
                   Message.update_all("board_id = #{board_id}", ["id = ? OR parent_id = ?", root.id, root.id])
                   Board.reset_counters!(board_id_was)
                   Board.reset_counters!(board_id)
                 end
               end
               def after_destroy
                 board.reset_counters!
               end
               def sticky=(arg)
                 write_attribute :sticky, (arg == true || arg.to_s == '1' ? 1 : 0)
               end
               def sticky?
                 sticky == 1
               end
               def project
                 board.project
               end
               def editable_by?(usr)
                 usr && usr.logged? && (usr.allowed_to?(:edit_messages, project) || (self.author == usr && usr.allowed_to?(:edit_own_messages, project)))
               end
               def destroyable_by?(usr)
                 usr && usr.logged? && (usr.allowed_to?(:delete_messages, project) || (self.author == usr && usr.allowed_to?(:delete_own_messages, project)))
               end
               private
               def add_author_as_watcher
                 Watcher.create(:watchable => self.root, :user => author)
               end
             end

app/models/watcher.rb +35 0

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class Watcher < ActiveRecord::Base
               belongs_to :watchable, :polymorphic => true
               belongs_to :user
               validates_presence_of :user
               validates_uniqueness_of :user_id, :scope => [:watchable_type, :watchable_id]
+              # Unwatch things that users are no longer allowed to view
+              def self.prune(options={})
+                if options.has_key?(:user)
+                  prune_single_user(options[:user], options)
+                else
+                  pruned = 0
+                  User.find(:all, :conditions => "id IN (SELECT DISTINCT user_id FROM #{table_name})").each do |user|
+                    pruned += prune_single_user(user, options)
+                  end
+                  pruned
+                end
+              end
               protected
               def validate
                 errors.add :user_id, :invalid unless user.nil? || user.active?
               end
+              private
+              def self.prune_single_user(user, options={})
+                return unless user.is_a?(User)
+                pruned = 0
+                find(:all, :conditions => {:user_id => user.id}).each do |watcher|
+                  next if watcher.watchable.nil?
+                  if options.has_key?(:project)
+                    next unless watcher.watchable.respond_to?(:project) && watcher.watchable.project == options[:project]
+                  end
+                  if watcher.watchable.respond_to?(:visible?)
+                    unless watcher.watchable.visible?(user)
+                      watcher.destroy
+                      pruned += 1
+                    end
+                  end
+                end
+                pruned
+              end
             end

app/models/wiki.rb +4 0

             # Redmine - project management software
             # Copyright (C) 2006-2009  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class Wiki < ActiveRecord::Base
               belongs_to :project
               has_many :pages, :class_name => 'WikiPage', :dependent => :destroy, :order => 'title'
               has_many :redirects, :class_name => 'WikiRedirect', :dependent => :delete_all
               acts_as_watchable
               validates_presence_of :start_page
               validates_format_of :start_page, :with => /^[^,\.\/\?\;\|\:]*$/
+              def visible?(user=User.current)
+                !user.nil? && user.allowed_to?(:view_wiki_pages, project)
+              end
               # find the page with the given title
               # if page doesn't exist, return a new page
               def find_or_new_page(title)
                 title = start_page if title.blank?
                 find_page(title) || WikiPage.new(:wiki => self, :title => Wiki.titleize(title))
               end
               # find the page with the given title
               def find_page(title, options = {})
                 title = start_page if title.blank?
                 title = Wiki.titleize(title)
                 page = pages.find_by_title(title)
                 if !page && !(options[:with_redirect] == false)
                   # search for a redirect
                   redirect = redirects.find_by_title(title)
                   page = find_page(redirect.redirects_to, :with_redirect => false) if redirect
                 end
                 page
               end
               # Finds a page by title
               # The given string can be of one of the forms: "title" or "project:title"
               # Examples:
               #   Wiki.find_page("bar", project => foo)
               #   Wiki.find_page("foo:bar")
               def self.find_page(title, options = {})
                 project = options[:project]
                 if title.to_s =~ %r{^([^\:]+)\:(.*)$}
                   project_identifier, title = $1, $2
                   project = Project.find_by_identifier(project_identifier) || Project.find_by_name(project_identifier)
                 end
                 if project && project.wiki
                   page = project.wiki.find_page(title)
                   if page && page.content
                     page
                   end
                 end
               end
               # turn a string into a valid page title
               def self.titleize(title)
                 # replace spaces with _ and remove unwanted caracters
                 title = title.gsub(/\s+/, '_').delete(',./?;|:') if title
                 # upcase the first letter
                 title = (title.slice(0..0).upcase + (title.slice(1..-1) || '')) if title
                 title
               end
             end

app/models/wiki_page.rb +4 0

             # Redmine - project management software
             # Copyright (C) 2006-2009  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'diff'
             require 'enumerator'
             class WikiPage < ActiveRecord::Base
               belongs_to :wiki
               has_one :content, :class_name => 'WikiContent', :foreign_key => 'page_id', :dependent => :destroy
               acts_as_attachable :delete_permission => :delete_wiki_pages_attachments
               acts_as_tree :dependent => :nullify, :order => 'title'
               acts_as_watchable
               acts_as_event :title => Proc.new {|o| "#{l(:label_wiki)}: #{o.title}"},
                             :description => :text,
                             :datetime => :created_on,
                             :url => Proc.new {|o| {:controller => 'wiki', :id => o.wiki.project_id, :page => o.title}}
               acts_as_searchable :columns => ['title', 'text'],
                                  :include => [{:wiki => :project}, :content],
                                  :project_key => "#{Wiki.table_name}.project_id"
               attr_accessor :redirect_existing_links
               validates_presence_of :title
               validates_format_of :title, :with => /^[^,\.\/\?\;\|\s]*$/
               validates_uniqueness_of :title, :scope => :wiki_id, :case_sensitive => false
               validates_associated :content
+              def visible?(user=User.current)
+                !user.nil? && user.allowed_to?(:view_wiki_pages, project)
+              end
               def title=(value)
                 value = Wiki.titleize(value)
                 @previous_title = read_attribute(:title) if @previous_title.blank?
                 write_attribute(:title, value)
               end
               def before_save
                 self.title = Wiki.titleize(title)
                 # Manage redirects if the title has changed
                 if !@previous_title.blank? && (@previous_title != title) && !new_record?
                   # Update redirects that point to the old title
                   wiki.redirects.find_all_by_redirects_to(@previous_title).each do |r|
                     r.redirects_to = title
                     r.title == r.redirects_to ? r.destroy : r.save
                   end
                   # Remove redirects for the new title
                   wiki.redirects.find_all_by_title(title).each(&:destroy)
                   # Create a redirect to the new title
                   wiki.redirects << WikiRedirect.new(:title => @previous_title, :redirects_to => title) unless redirect_existing_links == "0"
                   @previous_title = nil
                 end
               end
               def before_destroy
                 # Remove redirects to this page
                 wiki.redirects.find_all_by_redirects_to(title).each(&:destroy)
               end
               def pretty_title
                 WikiPage.pretty_title(title)
               end
               def content_for_version(version=nil)
                 result = content.versions.find_by_version(version.to_i) if version
                 result ||= content
                 result
               end
               def diff(version_to=nil, version_from=nil)
                 version_to = version_to ? version_to.to_i : self.content.version
                 version_from = version_from ? version_from.to_i : version_to - 1
                 version_to, version_from = version_from, version_to unless version_from < version_to
                 content_to = content.versions.find_by_version(version_to)
                 content_from = content.versions.find_by_version(version_from)
                 (content_to && content_from) ? WikiDiff.new(content_to, content_from) : nil
               end
               def annotate(version=nil)
                 version = version ? version.to_i : self.content.version
                 c = content.versions.find_by_version(version)
                 c ? WikiAnnotate.new(c) : nil
               end
               def self.pretty_title(str)
                 (str && str.is_a?(String)) ? str.tr('_', ' ') : str
               end
               def project
                 wiki.project
               end
               def text
                 content.text if content
               end
               # Returns true if usr is allowed to edit the page, otherwise false
               def editable_by?(usr)
                 !protected? || usr.allowed_to?(:protect_wiki_pages, wiki.project)
               end
               def attachments_deletable?(usr=User.current)
                 editable_by?(usr) && super(usr)
               end
               def parent_title
                 @parent_title || (self.parent && self.parent.pretty_title)
               end
               def parent_title=(t)
                 @parent_title = t
                 parent_page = t.blank? ? nil : self.wiki.find_page(t)
                 self.parent = parent_page
               end
               protected
               def validate
                 errors.add(:parent_title, :invalid) if !@parent_title.blank? && parent.nil?
                 errors.add(:parent_title, :circular_dependency) if parent && (parent == self || parent.ancestors.include?(self))
                 errors.add(:parent_title, :not_same_project) if parent && (parent.wiki_id != wiki_id)
               end
             end
             class WikiDiff
               attr_reader :diff, :words, :content_to, :content_from
               def initialize(content_to, content_from)
                 @content_to = content_to
                 @content_from = content_from
                 @words = content_to.text.split(/(\s+)/)
                 @words = @words.select {|word| word != ' '}
                 words_from = content_from.text.split(/(\s+)/)
                 words_from = words_from.select {|word| word != ' '}
                 @diff = words_from.diff @words
               end
             end
             class WikiAnnotate
               attr_reader :lines, :content
               def initialize(content)
                 @content = content
                 current = content
                 current_lines = current.text.split(/\r?\n/)
                 @lines = current_lines.collect {|t| [nil, nil, t]}
                 positions = []
                 current_lines.size.times {|i| positions << i}
                 while (current.previous)
                   d = current.previous.text.split(/\r?\n/).diff(current.text.split(/\r?\n/)).diffs.flatten
                   d.each_slice(3) do |s|
                     sign, line = s[0], s[1]
                     if sign == '+' && positions[line] && positions[line] != -1
                       if @lines[positions[line]][0].nil?
                         @lines[positions[line]][0] = current.version
                         @lines[positions[line]][1] = current.author
                       end
                     end
                   end
                   d.each_slice(3) do |s|
                     sign, line = s[0], s[1]
                     if sign == '-'
                       positions.insert(line, -1)
                     else
                       positions[line] = nil
                     end
                   end
                   positions.compact!
                   # Stop if every line is annotated
                   break unless @lines.detect { |line| line[0].nil? }
                   current = current.previous
                 end
                 @lines.each { |line| line[0] ||= current.version }
               end
             end

test/fixtures/enabled_modules.yml +4 0

             ---
             enabled_modules_001:
               name: issue_tracking
               project_id: 1
               id: 1
             enabled_modules_002:
               name: time_tracking
               project_id: 1
               id: 2
             enabled_modules_003:
               name: news
               project_id: 1
               id: 3
             enabled_modules_004:
               name: documents
               project_id: 1
               id: 4
             enabled_modules_005:
               name: files
               project_id: 1
               id: 5
             enabled_modules_006:
               name: wiki
               project_id: 1
               id: 6
             enabled_modules_007:
               name: repository
               project_id: 1
               id: 7
             enabled_modules_008:
               name: boards
               project_id: 1
               id: 8
             enabled_modules_009:
               name: repository
               project_id: 3
               id: 9
             enabled_modules_010:
               name: wiki
               project_id: 3
               id: 10
             enabled_modules_011:
               name: issue_tracking
               project_id: 2
               id: 11
             enabled_modules_012:
               name: time_tracking
               project_id: 3
               id: 12
             enabled_modules_013:
               name: issue_tracking
               project_id: 3
               id: 13
             enabled_modules_014:
               name: issue_tracking
               project_id: 5
               id: 14
             enabled_modules_015:
               name: wiki
               project_id: 2
               id: 15
+            enabled_modules_016:
+              name: boards
+              project_id: 2
+              id: 16

test/fixtures/messages.yml +11 0

             ---
             messages_001:
               created_on: 2007-05-12 17:15:32 +02:00
               updated_on: 2007-05-12 17:15:32 +02:00
               subject: First post
               id: 1
               replies_count: 2
               last_reply_id: 3
               content: "This is the very first post\n\
                 in the forum"
               author_id: 1
               parent_id:
               board_id: 1
             messages_002:
               created_on: 2007-05-12 17:18:00 +02:00
               updated_on: 2007-05-12 17:18:00 +02:00
               subject: First reply
               id: 2
               replies_count: 0
               last_reply_id:
               content: "Reply to the first post"
               author_id: 1
               parent_id: 1
               board_id: 1
             messages_003:
               created_on: 2007-05-12 17:18:02 +02:00
               updated_on: 2007-05-12 17:18:02 +02:00
               subject: "RE: First post"
               id: 3
               replies_count: 0
               last_reply_id:
               content: "An other reply"
               author_id: 2
               parent_id: 1
               board_id: 1
             messages_004:
               created_on: 2007-08-12 17:15:32 +02:00
               updated_on: 2007-08-12 17:15:32 +02:00
               subject: Post 2
               id: 4
               replies_count: 2
               last_reply_id: 6
               content: "This is an other post"
               author_id:
               parent_id:
               board_id: 1
             messages_005:
               created_on: <%= 3.days.ago.to_date.to_s(:db) %>
               updated_on: <%= 3.days.ago.to_date.to_s(:db) %>
               subject: 'RE: post 2'
               id: 5
               replies_count: 0
               last_reply_id:
               content: "Reply to the second post"
               author_id: 1
               parent_id: 4
               board_id: 1
             messages_006:
               created_on: <%= 2.days.ago.to_date.to_s(:db) %>
               updated_on: <%= 2.days.ago.to_date.to_s(:db) %>
               subject: 'RE: post 2'
               id: 6
               replies_count: 0
               last_reply_id:
               content: "Another reply to the second post"
               author_id: 3
               parent_id: 4
               board_id: 1
+            messages_007:
+              created_on: <%= 2.days.ago.to_date.to_s(:db) %>
+              updated_on: <%= 2.days.ago.to_date.to_s(:db) %>
+              subject: 'Message on a private project'
+              id: 7
+              replies_count: 0
+              last_reply_id:
+              content: "This is a private message"
+              author_id: 1
+              parent_id:
+              board_id: 3

test/unit/member_test.rb +67 -1

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.dirname(__FILE__) + '/../test_helper'
             class MemberTest < ActiveSupport::TestCase
-              fixtures :users, :projects, :roles, :members, :member_roles
+              fixtures :all
               def setup
                 @jsmith = Member.find(1)
               end
               def test_create
                 member = Member.new(:project_id => 1, :user_id => 4, :role_ids => [1, 2])
                 assert member.save
                 member.reload
                 assert_equal 2, member.roles.size
                 assert_equal Role.find(1), member.roles.sort.first
               end
               def test_update
                 assert_equal "eCookbook", @jsmith.project.name
                 assert_equal "Manager", @jsmith.roles.first.name
                 assert_equal "jsmith", @jsmith.user.login
                 @jsmith.mail_notification = !@jsmith.mail_notification
                 assert @jsmith.save
               end
               def test_update_roles
                 assert_equal 1, @jsmith.roles.size
                 @jsmith.role_ids = [1, 2]
                 assert @jsmith.save
                 assert_equal 2, @jsmith.reload.roles.size
               end
               def test_validate
                 member = Member.new(:project_id => 1, :user_id => 2, :role_ids => [2])
                 # same use can't have more than one membership for a project
                 assert !member.save
                 member = Member.new(:project_id => 1, :user_id => 2, :role_ids => [])
                 # must have one role at least
                 assert !member.save
               end
               def test_destroy
                 assert_difference 'Member.count', -1 do
                   assert_difference 'MemberRole.count', -1 do
                     @jsmith.destroy
                   end
                 end
                 assert_raise(ActiveRecord::RecordNotFound) { Member.find(@jsmith.id) }
               end
+              context "removing permissions" do
+                setup do
+                  Watcher.delete_all("user_id = 9")
+                  user = User.find(9)
+                  # public
+                  Watcher.create!(:watchable => Issue.find(1), :user_id => user)
+                  # private
+                  Watcher.create!(:watchable => Issue.find(4), :user => user)
+                  Watcher.create!(:watchable => Message.find(7), :user => user)
+                  Watcher.create!(:watchable => Wiki.find(2), :user => user)
+                  Watcher.create!(:watchable => WikiPage.find(3), :user => user)
+                end
+                context "of user" do
+                  setup do
+                    @member = Member.create!(:project => Project.find(2), :principal => User.find(9), :role_ids => [1, 2])
+                  end
+                  context "by deleting membership" do
+                    should "prune watchers" do
+                      assert_difference 'Watcher.count', -4 do
+                        @member.destroy
+                      end
+                    end
+                  end
+                  context "by updating roles" do
+                    should "prune watchers" do
+                      Role.find(2).remove_permission! :view_wiki_pages
+                      member = Member.first(:order => 'id desc')
+                      assert_difference 'Watcher.count', -2 do
+                        member.role_ids = [2]
+                        member.save
+                      end
+                      assert !Message.find(7).watched_by?(@user)
+                    end
+                  end
+                end
+                context "of group" do
+                  setup do
+                    group = Group.find(10)
+                    @member = Member.create!(:project => Project.find(2), :principal => group, :role_ids => [1, 2])
+                    group.users << User.find(9)
+                  end
+                  context "by deleting membership" do
+                    should "prune watchers" do
+                      assert_difference 'Watcher.count', -4 do
+                        @member.destroy
+                      end
+                    end
+                  end
+                  context "by updating roles" do
+                    should "prune watchers" do
+                      Role.find(2).remove_permission! :view_wiki_pages
+                      assert_difference 'Watcher.count', -2 do
+                        @member.role_ids = [2]
+                        @member.save
+                      end
+                    end
+                  end
+                end
+              end
             end

test/unit/watcher_test.rb +39 -3

-            # redMine - project management software
+            # Redmine - project management software
-            # Copyright (C) 2006-2007  Jean-Philippe Lang
+            # Copyright (C) 2006-2009  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.dirname(__FILE__) + '/../test_helper'
             class WatcherTest < ActiveSupport::TestCase
-              fixtures :issues, :users
+              fixtures :projects, :users, :members, :member_roles, :roles, :enabled_modules,
+                       :issues,
+                       :boards, :messages,
+                       :wikis, :wiki_pages,
+                       :watchers
               def setup
                 @user = User.find(1)
                 @issue = Issue.find(1)
               end
               def test_watch
                 assert @issue.add_watcher(@user)
                 @issue.reload
                 assert @issue.watchers.detect { |w| w.user == @user }
               end
               def test_cant_watch_twice
                 assert @issue.add_watcher(@user)
                 assert !@issue.add_watcher(@user)
               end
               def test_watched_by
                 assert @issue.add_watcher(@user)
                 @issue.reload
                 assert @issue.watched_by?(@user)
                 assert Issue.watched_by(@user).include?(@issue)
               end
               def test_recipients
                 @issue.watchers.delete_all
                 @issue.reload
                 assert @issue.watcher_recipients.empty?
                 assert @issue.add_watcher(@user)
                 @user.mail_notification = true
                 @user.save
                 @issue.reload
                 assert @issue.watcher_recipients.include?(@user.mail)
                 @user.mail_notification = false
                 @user.save
                 @issue.reload
                 assert @issue.watcher_recipients.include?(@user.mail)
               end
               def test_unwatch
                 assert @issue.add_watcher(@user)
                 @issue.reload
                 assert_equal 1, @issue.remove_watcher(@user)
               end
+              def test_prune
+                Watcher.delete_all("user_id = 9")
+                user = User.find(9)
+                # public
+                Watcher.create!(:watchable => Issue.find(1), :user => user)
+                Watcher.create!(:watchable => Issue.find(2), :user => user)
+                Watcher.create!(:watchable => Message.find(1), :user => user)
+                Watcher.create!(:watchable => Wiki.find(1), :user => user)
+                Watcher.create!(:watchable => WikiPage.find(2), :user => user)
+                # private project (id: 2)
+                Member.create!(:project => Project.find(2), :principal => user, :role_ids => [1])
+                Watcher.create!(:watchable => Issue.find(4), :user => user)
+                Watcher.create!(:watchable => Message.find(7), :user => user)
+                Watcher.create!(:watchable => Wiki.find(2), :user => user)
+                Watcher.create!(:watchable => WikiPage.find(3), :user => user)
+                assert_no_difference 'Watcher.count' do
+                  Watcher.prune(:user => User.find(9))
+                end
+                Member.delete_all
+                assert_difference 'Watcher.count', -4 do
+                  Watcher.prune(:user => User.find(9))
+                end
+                assert Issue.find(1).watched_by?(user)
+                assert !Issue.find(4).watched_by?(user)
+              end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages