Project

General

Profile

Feature #4511 » 4511-add-group-to-watcher-v2.patch

Fixed RuboCop offences - Go MAEDA, 2020-01-31 07:55

View differences:

app/controllers/watchers_controller.rb
else
user_ids << params[:user_id]
end
users = User.active.visible.where(:id => user_ids.flatten.compact.uniq)
user_ids = user_ids.flatten.compact.uniq
users = User.active.visible.where(:id => user_ids).to_a
users += Group.givable.active.visible.where(:id => user_ids).to_a
users.each do |user|
@watchables.each do |watchable|
Watcher.create(:watchable => watchable, :user => user)
......
if params[:watcher]
user_ids = params[:watcher][:user_ids] || [params[:watcher][:user_id]]
@users = User.active.visible.where(:id => user_ids).to_a
@users += Group.givable.active.visible.where(:id => user_ids).to_a
end
if @users.blank?
head 200
......
end
def destroy
user = User.find(params[:user_id])
user = Principal.find(params[:user_id])
@watchables.each do |watchable|
watchable.set_watcher(user, false)
end
......
scope = User.all.limit(100)
end
users = scope.active.visible.sorted.like(params[:q]).to_a
users += Group.givable.active.visible.sorted.like(params[:q]).to_a
if @watchables && @watchables.size == 1
users -= @watchables.first.watcher_users
end
app/helpers/avatars_helper.rb
gravatar(email.to_s.downcase, options) rescue nil
elsif user.is_a?(AnonymousUser)
anonymous_avatar(options)
elsif user.is_a?(Group)
group_avatar(options)
else
nil
end
......
def anonymous_avatar(options={})
image_tag 'anonymous.png', GravatarHelper::DEFAULT_OPTIONS.except(:default, :rating, :ssl).merge(options)
end
def group_avatar(options={})
image_tag 'group.png', GravatarHelper::DEFAULT_OPTIONS.except(:default, :rating, :ssl).merge(options)
end
end
app/helpers/issues_helper.rb
# on the new issue form
def users_for_new_issue_watchers(issue)
users = issue.watcher_users.select{|u| u.status == User::STATUS_ACTIVE}
if issue.project.users.count <= 20
users = (users + issue.project.users.sort).uniq
if issue.project.users.count + Group.givable.count <= 20
users = (users + issue.project.users.sort + Group.givable.sort).uniq
end
users
end
app/helpers/watchers_helper.rb
def watchers_list(object)
remove_allowed = User.current.allowed_to?("delete_#{object.class.name.underscore}_watchers".to_sym, object.project)
content = ''.html_safe
lis = object.watcher_users.preload(:email_address).collect do |user|
lis = object.watcher_users.collect do |user|
s = ''.html_safe
s << avatar(user, :size => "16").to_s
s << link_to_user(user, :class => 'user')
app/models/group.rb
return if self.id.nil?
Issue.where(['assigned_to_id = ?', id]).update_all('assigned_to_id = NULL')
Watcher.where('user_id = ?', id).delete_all
end
end
app/models/query.rb
def watcher_values
watcher_values = [["<< #{l(:label_me)} >>", "me"]]
watcher_values += users.sort_by(&:status).collect{|s| [s.name, s.id.to_s, l("status_#{User::LABEL_BY_STATUS[s.status]}")] } if User.current.allowed_to?(:view_issue_watchers, self.project)
watcher_values += principals.sort_by(&:status).collect{|s| [s.name, s.id.to_s, l("status_#{User::LABEL_BY_STATUS[s.status]}")] } if User.current.allowed_to?(:view_issue_watchers, self.project)
watcher_values
end
......
if v.delete("me")
if User.current.logged?
v.push(User.current.id.to_s)
v += User.current.group_ids.map(&:to_s) if field == 'assigned_to_id'
v += User.current.group_ids.map(&:to_s) if %w(assigned_to_id watcher_id).include?(field)
else
v.push("0")
end
app/models/watcher.rb
class Watcher < ActiveRecord::Base
belongs_to :watchable, :polymorphic => true
belongs_to :user
belongs_to :user, :class_name => 'Principal'
validates_presence_of :user
validates_uniqueness_of :user_id, :scope => [:watchable_type, :watchable_id]
......
protected
def validate_user
errors.add :user_id, :invalid unless user.nil? || user.active?
errors.add :user_id, :invalid \
unless user.nil? || (user.is_a?(User) && user.active?) || (user.is_a?(Group) && user.givable?)
end
def self.prune_single_user(user, options={})
lib/plugins/acts_as_watchable/lib/acts_as_watchable.rb
# Returns an array of users that are proposed as watchers
def addable_watcher_users
users = self.project.users.sort - self.watcher_users
users = (self.project.users.sort + Group.givable.sort) - self.watcher_users
if respond_to?(:visible?)
users.reject! {|user| !visible?(user)}
users.reject! {|user| user.is_a?(User) && !visible?(user)}
end
users
end
......
# Removes user from the watchers list
def remove_watcher(user)
return nil unless user && user.is_a?(User)
return nil unless user && (user.is_a?(User) || user.is_a?(Group))
# Rails does not reset the has_many :through association
watcher_users.reset
watchers.where(:user_id => user.id).delete_all
......
def notified_watchers
notified = watcher_users.active.to_a
notified = notified.map {|n| n.is_a?(Group) ? n.users : n}.flatten
notified.uniq!
notified.reject! {|user| user.mail.blank? || user.mail_notification == 'none'}
if respond_to?(:visible?)
notified.reject! {|user| !visible?(user)}
test/functional/issues_controller_test.rb
def test_show_should_display_watchers
@request.session[:user_id] = 2
Issue.find(1).add_watcher User.find(2)
issue = Issue.find(1)
issue.add_watcher User.find(2)
issue.add_watcher Group.find(10)
get(:show, :params => {:id => 1})
assert_select 'div#watchers ul' do
assert_select 'li' do
assert_select 'li.user-2' do
assert_select 'a[href="/users/2"]'
assert_select 'a[class*=delete]'
end
assert_select "li.user-10" do
assert_select 'a[href="/users/10"]', false
assert_select 'a[class*=delete]'
end
end
end
def test_show_should_display_watchers_with_gravatars
@request.session[:user_id] = 2
Issue.find(1).add_watcher User.find(2)
issue = Issue.find(1)
issue.add_watcher User.find(2)
issue.add_watcher Group.find(10)
with_settings :gravatar_enabled => '1' do
get(:show, :params => {:id => 1})
end
assert_select 'div#watchers ul' do
assert_select 'li' do
assert_select 'img.gravatar'
assert_select 'li.user-2' do
assert_select 'img.gravatar[title=?]', 'John Smith'
assert_select 'a[href="/users/2"]'
assert_select 'a[class*=delete]'
end
assert_select "li.user-10" do
assert_select 'img.gravatar[title=?]', 'A Team'
assert_select 'a[href="/users/10"]', false
assert_select 'a[class*=delete]'
end
end
end
......
ActionMailer::Base.deliveries.clear
with_settings :notified_events => %w(issue_added) do
assert_difference 'Watcher.count', 2 do
assert_difference 'Watcher.count', 3 do
post(
:create,
:params => {
......
:subject => 'This is a new issue with watchers',
:description => 'This is the description',
:priority_id => 5,
:watcher_user_ids => ['2', '3']
:watcher_user_ids => ['2', '3', '10']
}
}
)
......
assert_redirected_to :controller => 'issues', :action => 'show', :id => issue
# Watchers added
assert_equal [2, 3], issue.watcher_user_ids.sort
assert_equal [2, 3, 10], issue.watcher_user_ids.sort
assert issue.watched_by?(User.find(3))
assert issue.watched_by?(Group.find(10))
# Watchers notified
mail = ActionMailer::Base.deliveries.last
assert_not_nil mail
assert_equal 3, ActionMailer::Base.deliveries.size
mail = ActionMailer::Base.deliveries[1]
assert [mail.bcc, mail.cc].flatten.include?(User.find(3).mail)
mail = ActionMailer::Base.deliveries[2]
assert [mail.bcc, mail.cc].flatten.include?(User.find(8).mail)
end
def test_post_create_subissue
......
def test_new_as_copy_should_preserve_watchers
@request.session[:user_id] = 2
issue = Issue.find(1)
user = User.generate!
Watcher.create!(:watchable => Issue.find(1), :user => user)
Watcher.create!(:watchable => issue, :user => user)
Watcher.create!(:watchable => issue, :user => Group.find(10))
get(
:new,
:params => {
......
:copy_from => 1
}
)
assert_select 'input[type=checkbox][name=?][checked=checked]', 'issue[watcher_user_ids][]', 1
assert_select 'input[type=checkbox][name=?][checked=checked]', 'issue[watcher_user_ids][]', 2
assert_select 'input[type=checkbox][name=?][checked=checked][value=?]', 'issue[watcher_user_ids][]', user.id.to_s
assert_select 'input[type=checkbox][name=?][checked=checked][value=?]', 'issue[watcher_user_ids][]', '10'
assert_select 'input[type=hidden][name=?][value=?]', 'issue[watcher_user_ids][]', '', 1
end
......
:copy_from => copied.id,
:issue => {
:subject => 'Copy cleared watchers',
:watcher_user_ids => ['', '3']
:watcher_user_ids => ['', '3', '10']
}
}
)
end
issue = Issue.order('id DESC').first
assert_equal [3], issue.watcher_user_ids
assert_equal [3, 10], issue.watcher_user_ids
end
def test_create_as_copy_without_watcher_user_ids_should_not_copy_watchers
......
end
test "issue bulk copy copy watcher" do
Watcher.create!(:watchable => Issue.find(1), :user => User.find(3))
issue = Issue.find(1)
Watcher.create!(:watchable => issue, :user => User.find(3))
Watcher.create!(:watchable => issue, :user => Group.find(10))
@request.session[:user_id] = 2
assert_difference 'Issue.count' do
post(
......
)
end
copy = Issue.order(:id => :desc).first
assert_equal 1, copy.watchers.count
assert_equal 2, copy.watchers.count
assert_equal [3, 10], copy.watcher_user_ids
end
def test_bulk_copy_should_not_copy_selected_subtasks_twice
test/functional/queries_controller_test.rb
assert_equal [["<< me >>", "me"]], json
end
def test_watcher_filter_with_permission_should_show_members
def test_watcher_filter_with_permission_should_show_members_and_groups
# This user has view_issue_watchers permission
@request.session[:user_id] = 1
......
assert_equal 'application/json', response.media_type
json = ActiveSupport::JSON.decode(response.body)
assert_equal 6, json.count
assert_equal 7, json.count
# "me" value should not be grouped
assert_include ["<< me >>", "me"], json
assert_include ["Dave Lopper", "3", "active"], json
assert_include ["Dave2 Lopper2", "5", "locked"], json
assert_include ["A Team", "10", "active"], json
end
end
test/functional/watchers_controller_test.rb
assert Issue.find(2).watched_by?(User.find(4))
end
def test_create_group_as_html
@request.session[:user_id] = 2
assert_difference('Watcher.count') do
post :create, :params => {
:object_type => 'issue', :object_id => '2',
:watcher => {:user_id => '10'}
}
assert_response :success
assert_include 'Watcher added', response.body
end
assert Issue.find(2).watched_by?(Group.find(10))
end
def test_create
@request.session[:user_id] = 2
assert_difference('Watcher.count') do
......
def test_create_with_mutiple_users
@request.session[:user_id] = 2
assert_difference('Watcher.count', 2) do
assert_difference('Watcher.count', 3) do
post :create, :params => {
:object_type => 'issue', :object_id => '2',
:watcher => {:user_ids => ['4', '7']}
:watcher => {:user_ids => ['4', '7', '10']}
}, :xhr => true
assert_response :success
assert_match /watchers/, response.body
assert_match /ajax-modal/, response.body
end
assert Issue.find(2).watched_by?(User.find(4))
assert Issue.find(2).watched_by?(User.find(7))
issue = Issue.find(2)
assert issue.watched_by?(User.find(4))
assert issue.watched_by?(User.find(7))
assert issue.watched_by?(Group.find(10))
end
def test_create_with_mutiple_objects
@request.session[:user_id] = 2
assert_difference('Watcher.count', 4) do
assert_difference('Watcher.count', 6) do
post :create, :params => {
:object_type => 'issue', :object_id => ['1', '2'],
:watcher => {:user_ids => ['4', '7']}
:watcher => {:user_ids => ['4', '7', '10']}
}, :xhr => true
assert_response :success
assert_match /watchers/, response.body
assert_match /ajax-modal/, response.body
end
assert Issue.find(1).watched_by?(User.find(4))
assert Issue.find(2).watched_by?(User.find(4))
assert Issue.find(1).watched_by?(User.find(7))
assert Issue.find(2).watched_by?(User.find(7))
issue1 = Issue.find(1)
issue2 = Issue.find(2)
user4 = User.find(4)
user7 = User.find(7)
group10 = Group.find(10)
assert issue1.watched_by?(user4)
assert issue2.watched_by?(user4)
assert issue1.watched_by?(user7)
assert issue2.watched_by?(user7)
assert issue1.watched_by?(group10)
assert issue2.watched_by?(group10)
end
def test_autocomplete_on_watchable_creation
@request.session[:user_id] = 2
group = Group.generate!(:name => 'Group Minimum')
get :autocomplete_for_user, :params => {:q => 'mi', :project_id => 'ecookbook'}, :xhr => true
assert_response :success
assert_select 'input', :count => 4
assert_select 'input', :count => 5
assert_select 'input[name=?][value="1"]', 'watcher[user_ids][]'
assert_select 'input[name=?][value="2"]', 'watcher[user_ids][]'
assert_select 'input[name=?][value="8"]', 'watcher[user_ids][]'
assert_select 'input[name=?][value="9"]', 'watcher[user_ids][]'
assert_select %(input[name=?][value="#{group.id}"]), 'watcher[user_ids][]'
end
def test_search_non_member_on_create
......
assert !Issue.find(2).watched_by?(User.find(3))
end
def test_destroy_group_as_html
@request.session[:user_id] = 2
issue = Issue.find(2)
group = Group.find(10)
issue.add_watcher(group)
assert issue.watched_by?(group)
assert_difference('Watcher.count', -1) do
delete :destroy, :params => {
:object_type => 'issue', :object_id => '2', :user_id => '10'
}
assert_response :success
assert_include 'Watcher removed', response.body
end
issue.reload
assert_not issue.watched_by?(group)
end
def test_destroy
@request.session[:user_id] = 2
assert_difference('Watcher.count', -1) do
test/helpers/avatars_helper_test.rb
end
def test_avatar_with_group
assert_nil avatar(Group.first)
assert_match %r{src="/images/group.png(\?\d+)?"}, avatar(Group.first)
end
def test_avatar_with_invalid_arg_should_return_nil
test/unit/group_test.rb
fixtures :projects, :trackers, :issue_statuses, :issues,
:enumerations, :users,
:projects_trackers,
:roles,
:member_roles,
:members,
:groups_users
:roles, :member_roles, :members,
:groups_users,
:watchers
include Redmine::I18n
......
assert !User.find(8).member_of?(Project.find(5))
end
def test_destroy_should_unassign_issues
def test_destroy_should_unassign_and_unwatch_issues
group = Group.find(10)
Issue.where(:id => 1).update_all(["assigned_to_id = ?", group.id])
issue = Issue.find(2)
issue.set_watcher(group)
issue.save
issue.reload
assert issue.watcher_user_ids.include?(10)
assert group.destroy
assert group.destroyed?
assert_nil Issue.find(1).assigned_to_id
issue.reload
assert_not issue.watcher_user_ids.include?(10)
end
def test_builtin_groups_should_be_created_if_missing
test/unit/query_test.rb
issues = find_issues_with_query(query)
assert issues.any?
assert_nil issues.detect {|issue| !issue.is_private?}
ensure
User.current = nil
end
def test_operator_is_not_on_is_private_field
......
issues = find_issues_with_query(query)
assert issues.any?
assert_nil issues.detect {|issue| issue.is_private?}
ensure
User.current = nil
end
def test_operator_greater_than
......
assert_not_nil result
assert !result.empty?
assert_equal Issue.visible.watched_by(User.current).sort_by(&:id), result.sort_by(&:id)
User.current = nil
end
def test_filter_watched_issues_with_groups_also
user = User.find(2)
group = Group.find(10)
group.users << user
Issue.find(3).add_watcher(user)
Issue.find(7).add_watcher(group)
User.current = user
query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '=', :values => ['me']}})
result = find_issues_with_query(query)
assert_not_nil result
assert_not result.empty?
assert_equal [3, 7], result.sort_by(&:id).pluck(:id)
end
def test_filter_unwatched_issues
......
assert_not_nil result
assert !result.empty?
assert_equal((Issue.visible - Issue.watched_by(User.current)).sort_by(&:id).size, result.sort_by(&:id).size)
User.current = nil
end
def test_filter_on_watched_issues_with_view_issue_watchers_permission
......
result = find_issues_with_query(query)
assert_includes result, Issue.find(1)
assert_includes result, Issue.find(3)
ensure
User.current.reload
User.current = nil
end
def test_filter_on_watched_issues_without_view_issue_watchers_permission
......
result = find_issues_with_query(query)
assert_includes result, Issue.find(1)
assert_not_includes result, Issue.find(3)
ensure
User.current.reload
User.current = nil
end
def test_filter_on_custom_field_should_ignore_projects_with_field_disabled
test/unit/watcher_test.rb
end
def test_watch
group = Group.find(10)
assert @issue.add_watcher(group)
assert @issue.add_watcher(@user)
@issue.reload
assert @issue.watchers.detect {|w| w.user == @user}
assert @issue.watchers.detect {|w| w.user == group}
end
def test_cant_watch_twice
......
def test_addable_watcher_users
addable_watcher_users = @issue.addable_watcher_users
assert_kind_of Array, addable_watcher_users
assert_kind_of User, addable_watcher_users.first
addable_watcher_users.each do |addable_watcher|
assert_equal true, addable_watcher.is_a?(User) || addable_watcher.is_a?(Group)
end
end
def test_addable_watcher_users_should_not_include_user_that_cannot_view_the_object
issue = Issue.new(:project => Project.find(1), :is_private => true)
assert_nil issue.addable_watcher_users.detect {|user| !issue.visible?(user)}
assert_nil issue.addable_watcher_users.detect {|user| user.is_a?(User) && !issue.visible?(user)}
end
def test_any_watched_should_return_false_if_no_object_is_watched
......
end
def test_unwatch
group = Group.find(10)
assert @issue.add_watcher(group)
assert @issue.add_watcher(@user)
@issue.reload
assert_equal 1, @issue.remove_watcher(@user)
assert_equal 1, @issue.remove_watcher(group)
end
def test_prune_with_user
(3-3/10)