jro_apps/redmine Commit - r11109:856ef810b485

Bulk watch/unwatch issues from the context menu (#7159)....

Jean-Philippe Lang -

r11109:856ef810b485

parent child

Context file:

r11109:856ef810b485

Collapse all files

test/unit/helpers/watchers_helper_test.rb created 644 +69 0

@@ -0,0 +1,69
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2013 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	require File.expand_path('../../../test_helper', __FILE__)
	19
	20	class WatchersHelperTest < ActionView::TestCase
	21	include WatchersHelper
	22	include Redmine::I18n
	23
	24	fixtures :users, :issues
	25
	26	def setup
	27	super
	28	set_language_if_valid('en')
	29	User.current = nil
	30	end
	31
	32	test '#watcher_link with a non-watched object' do
	33	expected = link_to(
	34	"Watch",
	35	"/watchers/watch?object_id=1&object_type=issue",
	36	:remote => true, :method => 'post', :class => "issue-1-watcher icon icon-fav-off"
	37	)
	38	assert_equal expected, watcher_link(Issue.find(1), User.find(1))
	39	end
	40
	41	test '#watcher_link with a single objet array' do
	42	expected = link_to(
	43	"Watch",
	44	"/watchers/watch?object_id=1&object_type=issue",
	45	:remote => true, :method => 'post', :class => "issue-1-watcher icon icon-fav-off"
	46	)
	47	assert_equal expected, watcher_link([Issue.find(1)], User.find(1))
	48	end
	49
	50	test '#watcher_link with a multiple objets array' do
	51	expected = link_to(
	52	"Watch",
	53	"/watchers/watch?object_id%5B%5D=1&object_id%5B%5D=3&object_type=issue",
	54	:remote => true, :method => 'post', :class => "issue-bulk-watcher icon icon-fav-off"
	55	)
	56	assert_equal expected, watcher_link([Issue.find(1), Issue.find(3)], User.find(1))
	57	end
	58
	59	test '#watcher_link with a watched object' do
	60	Watcher.create!(:watchable => Issue.find(1), :user => User.find(1))
	61
	62	expected = link_to(
	63	"Unwatch",
	64	"/watchers/unwatch?object_id=1&object_type=issue",
	65	:remote => true, :method => 'post', :class => "issue-1-watcher icon icon-fav"
	66	)
	67	assert_equal expected, watcher_link(Issue.find(1), User.find(1))
	68	end
	69	end

app/controllers/watchers_controller.rb +22 -14

             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class WatchersController < ApplicationController
-              before_filter :find_project
+              before_filter :require_login, :find_watchables, :only => [:watch, :unwatch]
-              before_filter :require_login, :check_project_privacy, :only => [:watch, :unwatch]
-              before_filter :authorize, :only => [:new, :destroy]
-              accept_api_auth :create, :destroy
               def watch
-                if @watched.respond_to?(:visible?) && !@watched.visible?(User.current)
+                set_watcher(@watchables, User.current, true)
-                  render_403
-                else
-                  set_watcher(User.current, true)
-                end
               end
               def unwatch
-                set_watcher(User.current, false)
+                set_watcher(@watchables, User.current, false)
               end
+              before_filter :find_project, :authorize, :only => [:new, :create, :append, :destroy, :autocomplete_for_user]
+              accept_api_auth :create, :destroy
               def new
               end
                 render :layout => false
               end
-            private
+              private
               def find_project
                 if params[:object_type] && params[:object_id]
                   klass = Object.const_get(params[:object_type].camelcase)
                 render_404
               end
-              def set_watcher(user, watching)
+              def find_watchables
-                @watched.set_watcher(user, watching)
+                klass = Object.const_get(params[:object_type].camelcase) rescue nil
+                if klass && klass.respond_to?('watched_by')
+                  @watchables = klass.find_all_by_id(Array.wrap(params[:object_id]))
+                  raise Unauthorized if @watchables.any? {|w| w.respond_to?(:visible?) && !w.visible?}
+                end
+                render_404 unless @watchables.present?
+              end
+              def set_watcher(watchables, user, watching)
+                watchables.each do |watchable|
+                  watchable.set_watcher(user, watching)
+                end
                 respond_to do |format|
                   format.html { redirect_to_referer_or {render :text => (watching ? 'Watcher added.' : 'Watcher removed.'), :layout => true}}
-                  format.js { render :partial => 'set_watcher', :locals => {:user => user, :watched => @watched} }
+                  format.js { render :partial => 'set_watcher', :locals => {:user => user, :watched => watchables} }
                 end
               end
             end

app/helpers/watchers_helper.rb +19 -12

@@ -24,21 +24,28 module WatchersHelper
24	watcher_link(object, user)	24	watcher_link(object, user)
25	end	25	end
26		26
27	def watcher_link(object, user)	27	def watcher_link(objects, user)
28	return '' unless user && user.logged? && ~~object~~.~~respond_to?~~(~~'watched_by?'~~)	28	return '' unless user && user.logged?
29	watched = object.watched_by?(user)	29	objects = Array.wrap(objects)
30	css = [watcher_css(object), watched ? 'icon icon-fav' : 'icon icon-fav-off'].join(' ')	30
31	url = {:controller => 'watchers',	31	watched = objects.any? {\|object\| object.watched_by?(user)}
32	:action => (watched ? 'unwatch' : 'watch'),	32	css = [watcher_css(objects), watched ? 'icon icon-fav' : 'icon icon-fav-off'].join(' ')
33	:object_type => object.class.to_s.underscore,	33	text = watched ? l(:button_unwatch) : l(:button_watch)
34	:object_id => object.id}	34	url = {
35	link_to((watched ? l(:button_unwatch) : l(:button_watch)), url,	35	:controller => 'watchers',
36	:remote => true, :method => 'post', :class => css)	36	:action => (watched ? 'unwatch' : 'watch'),
		37	:object_type => objects.first.class.to_s.underscore,
		38	:object_id => (objects.size == 1 ? objects.first.id : objects.map(&:id).sort)
		39	}
		40
		41	link_to text, url, :remote => true, :method => 'post', :class => css
37	end	42	end
38		43
39	# Returns the css class used to identify watch links for a given +object+	44	# Returns the css class used to identify watch links for a given +object+
40	def watcher_css(object)	45	def watcher_css(objects)
41	"#{object.class.to_s.underscore}-#{object.id}-watcher"	46	objects = Array.wrap(objects)
		47	id = (objects.size == 1 ? objects.first.id : 'bulk')
		48	"#{objects.first.class.to_s.underscore}-#{id}-watcher"
42	end	49	end
43		50
44	# Returns a comma separated list of users watching the given object	51	# Returns a comma separated list of users watching the given object

app/views/context_menus/issues.html.erb +4 -3

                 </li>
               <% end %>
+            <% if User.current.logged? %>
+              <li><%= watcher_link(@issues, User.current) %></li>
+            <% end %>
             <% if @issue.present? %>
-              <% if User.current.logged? %>
-              <li><%= watcher_link(@issue, User.current) %></li>
-              <% end %>
               <% if @can[:log_time] -%>
               <li><%= context_menu_link l(:button_log_time), new_issue_time_entry_path(@issue),
                       :class => 'icon-time-add' %></li>

app/views/watchers/_new.html.erb +6 -4

             <%= form_tag({:controller => 'watchers',
                           :action => (watched ? 'create' : 'append'),
-                          :object_type => watched.class.name.underscore,
+                          :object_type => (watched && watched.class.name.underscore),
-                          :object_id => watched},
+                          :object_id => watched,
+                          :project_id => @project},
                          :remote => true,
                          :method => :post,
                          :id => 'new-watcher-form') do %>
               <p><%= label_tag 'user_search', l(:label_user_search) %><%= text_field_tag 'user_search', nil %></p>
               <%= javascript_tag "observeSearchfield('user_search', 'users_for_watcher', '#{ escape_javascript url_for(:controller => 'watchers',
                              :action => 'autocomplete_for_user',
-                             :object_type => watched.class.name.underscore,
+                             :object_type => (watched && watched.class.name.underscore),
-                             :object_id => watched) }')" %>
+                             :object_id => watched,
+                             :project_id => @project) }')" %>
               <div id="users_for_watcher">
                 <%= principals_check_box_tags 'watcher[user_ids][]', (watched ? watched.addable_watcher_users : User.active.all(:limit => 100)) %>

lib/redmine.rb +1 -1

                 map.permission :save_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :loggedin
                 # Watchers
                 map.permission :view_issue_watchers, {}, :read => true
-                map.permission :add_issue_watchers, {:watchers => :new}
+                map.permission :add_issue_watchers, {:watchers => [:new, :create, :append, :autocomplete_for_user]}
                 map.permission :delete_issue_watchers, {:watchers => :destroy}
               end

test/functional/watchers_controller_test.rb +43 -6

                 User.current = nil
               end
-              def test_watch
+              def test_watch_a_single_object
                 @request.session[:user_id] = 3
                 assert_difference('Watcher.count') do
                   xhr :post, :watch, :object_type => 'issue', :object_id => '1'
                 assert Issue.find(1).watched_by?(User.find(3))
               end
+              def test_watch_a_collection_with_a_single_object
+                @request.session[:user_id] = 3
+                assert_difference('Watcher.count') do
+                  xhr :post, :watch, :object_type => 'issue', :object_id => ['1']
+                  assert_response :success
+                  assert_include '$(".issue-1-watcher")', response.body
+                end
+                assert Issue.find(1).watched_by?(User.find(3))
+              end
+              def test_watch_a_collection_with_multiple_objects
+                @request.session[:user_id] = 3
+                assert_difference('Watcher.count', 2) do
+                  xhr :post, :watch, :object_type => 'issue', :object_id => ['1', '3']
+                  assert_response :success
+                  assert_include '$(".issue-bulk-watcher")', response.body
+                end
+                assert Issue.find(1).watched_by?(User.find(3))
+                assert Issue.find(3).watched_by?(User.find(3))
+              end
               def test_watch_should_be_denied_without_permission
                 Role.find(2).remove_permission! :view_issues
                 @request.session[:user_id] = 3
                 assert !Issue.find(1).watched_by?(User.find(3))
               end
+              def test_unwatch_a_collection_with_multiple_objects
+                @request.session[:user_id] = 3
+                Watcher.create!(:user_id => 3, :watchable => Issue.find(1))
+                Watcher.create!(:user_id => 3, :watchable => Issue.find(3))
+                assert_difference('Watcher.count', -2) do
+                  xhr :post, :unwatch, :object_type => 'issue', :object_id => ['1', '3']
+                  assert_response :success
+                  assert_include '$(".issue-bulk-watcher")', response.body
+                end
+                assert !Issue.find(1).watched_by?(User.find(3))
+                assert !Issue.find(3).watched_by?(User.find(3))
+              end
               def test_new
                 @request.session[:user_id] = 2
                 xhr :get, :new, :object_type => 'issue', :object_id => '2'
                 assert_match /ajax-modal/, response.body
               end
-              def test_new_for_new_record_with_id
+              def test_new_for_new_record_with_project_id
                 @request.session[:user_id] = 2
                 xhr :get, :new, :project_id => 1
                 assert_response :success
                 assert_match /ajax-modal/, response.body
               end
-              def test_new_for_new_record_with_identifier
+              def test_new_for_new_record_with_project_identifier
                 @request.session[:user_id] = 2
                 xhr :get, :new, :project_id => 'ecookbook'
                 assert_response :success
               end
               def test_autocomplete_on_watchable_creation
-                xhr :get, :autocomplete_for_user, :q => 'mi'
+                @request.session[:user_id] = 2
+                xhr :get, :autocomplete_for_user, :q => 'mi', :project_id => 'ecookbook'
                 assert_response :success
                 assert_select 'input', :count => 4
                 assert_select 'input[name=?][value=1]', 'watcher[user_ids][]'
               end
               def test_autocomplete_on_watchable_update
-                xhr :get, :autocomplete_for_user, :q => 'mi', :object_id => '2' , :object_type => 'issue'
+                @request.session[:user_id] = 2
+                xhr :get, :autocomplete_for_user, :q => 'mi', :object_id => '2' , :object_type => 'issue', :project_id => 'ecookbook'
                 assert_response :success
                 assert_select 'input', :count => 3
                 assert_select 'input[name=?][value=2]', 'watcher[user_ids][]'
               def test_append
                 @request.session[:user_id] = 2
                 assert_no_difference 'Watcher.count' do
-                  xhr :post, :append, :watcher => {:user_ids => ['4', '7']}
+                  xhr :post, :append, :watcher => {:user_ids => ['4', '7']}, :project_id => 'ecookbook'
                   assert_response :success
                   assert_include 'watchers_inputs', response.body
                   assert_include 'issue[watcher_user_ids][]', response.body

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