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

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 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
               def create
                 user_ids = []
                 if params[:watcher].is_a?(Hash)
                   user_ids << (params[:watcher][:user_ids] || params[:watcher][:user_id])
                 else
                   user_ids << params[:user_id]
                 end
                 user_ids.flatten.compact.uniq.each do |user_id|
                   Watcher.create(:watchable => @watched, :user_id => user_id)
                 end
                 respond_to do |format|
                   format.html { redirect_to_referer_or {render :text => 'Watcher added.', :layout => true}}
                   format.js
                   format.api { render_api_ok }
                 end
               end
               def append
                 if params[:watcher].is_a?(Hash)
                   user_ids = params[:watcher][:user_ids] || [params[:watcher][:user_id]]
                   @users = User.active.find_all_by_id(user_ids)
                 end
               end
               def destroy
                 @watched.set_watcher(User.find(params[:user_id]), false)
                 respond_to do |format|
                   format.html { redirect_to :back }
                   format.js
                   format.api { render_api_ok }
                 end
               end
               def autocomplete_for_user
                 @users = User.active.sorted.like(params[:q]).limit(100).all
                 if @watched
                   @users -= @watched.watcher_users
                 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)
                   return false unless klass.respond_to?('watched_by')
                   @watched = klass.find(params[:object_id])
                   @project = @watched.project
                 elsif params[:project_id]
                   @project = Project.visible.find_by_param(params[:project_id])
                 end
               rescue
                 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

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2013  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.
             module WatchersHelper
               def watcher_tag(object, user, options={})
                 ActiveSupport::Deprecation.warn "#watcher_tag is deprecated and will be removed in Redmine 3.0. Use #watcher_link instead."
                 watcher_link(object, user)
               end
-              def watcher_link(object, user)
+              def watcher_link(objects, user)
-                return '' unless user && user.logged? && object.respond_to?('watched_by?')
+                return '' unless user && user.logged?
-                watched = object.watched_by?(user)
+                objects = Array.wrap(objects)
-                css = [watcher_css(object), watched ? 'icon icon-fav' : 'icon icon-fav-off'].join(' ')
-                url = {:controller => 'watchers',
+                watched = objects.any? {|object| object.watched_by?(user)}
-                       :action => (watched ? 'unwatch' : 'watch'),
+                css = [watcher_css(objects), watched ? 'icon icon-fav' : 'icon icon-fav-off'].join(' ')
-                       :object_type => object.class.to_s.underscore,
+                text = watched ? l(:button_unwatch) : l(:button_watch)
-                       :object_id => object.id}
+                url = {
-                link_to((watched ? l(:button_unwatch) : l(:button_watch)), url,
+                  :controller => 'watchers',
-                        :remote => true, :method => 'post', :class => css)
+                  :action => (watched ? 'unwatch' : 'watch'),
+                  :object_type => objects.first.class.to_s.underscore,
+                  :object_id => (objects.size == 1 ? objects.first.id : objects.map(&:id).sort)
+                }
+                link_to text, url, :remote => true, :method => 'post', :class => css
               end
               # Returns the css class used to identify watch links for a given +object+
-              def watcher_css(object)
+              def watcher_css(objects)
-                "#{object.class.to_s.underscore}-#{object.id}-watcher"
+                objects = Array.wrap(objects)
+                id = (objects.size == 1 ? objects.first.id : 'bulk')
+                "#{objects.first.class.to_s.underscore}-#{id}-watcher"
               end
               # Returns a comma separated list of users watching the given object
               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.collect do |user|
                   s = ''.html_safe
                   s << avatar(user, :size => "16").to_s
                   s << link_to_user(user, :class => 'user')
                   if remove_allowed
                     url = {:controller => 'watchers',
                            :action => 'destroy',
                            :object_type => object.class.to_s.underscore,
                            :object_id => object.id,
                            :user_id => user}
                     s << ' '
                     s << link_to(image_tag('delete.png'), url,
                                  :remote => true, :method => 'post', :style => "vertical-align: middle", :class => "delete")
                   end
                   content << content_tag('li', s)
                 end
                 content.present? ? content_tag('ul', content) : content
               end
               def watchers_checkboxes(object, users, checked=nil)
                 users.map do |user|
                   c = checked.nil? ? object.watched_by?(user) : checked
                   tag = check_box_tag 'issue[watcher_user_ids][]', user.id, c, :id => nil
                   content_tag 'label', "#{tag} #{h(user)}".html_safe,
                               :id => "issue_watcher_user_ids_#{user.id}",
                               :class => "floating"
                 end.join.html_safe
               end
             end

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

             <ul>
               <%= call_hook(:view_issues_context_menu_start, {:issues => @issues, :can => @can, :back => @back }) %>
               <% if @issue -%>
                 <li><%= context_menu_link l(:button_edit), edit_issue_path(@issue),
                         :class => 'icon-edit', :disabled => !@can[:edit] %></li>
               <% else %>
                 <li><%= context_menu_link l(:button_edit), bulk_edit_issues_path(:ids => @issue_ids),
                         :class => 'icon-edit', :disabled => !@can[:edit] %></li>
               <% end %>
               <% if @allowed_statuses.present? %>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_status) %></a>
                 <ul>
                 <% @allowed_statuses.each do |s| -%>
                     <li><%= context_menu_link h(s.name), bulk_update_issues_path(:ids => @issue_ids, :issue => {:status_id => s}, :back_url => @back), :method => :post,
                                               :selected => (@issue && s == @issue.status), :disabled => !@can[:update] %></li>
                 <% end -%>
                 </ul>
               </li>
               <% end %>
               <% if @trackers.present? %>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_tracker) %></a>
                 <ul>
                 <% @trackers.each do |t| -%>
                     <li><%= context_menu_link h(t.name), bulk_update_issues_path(:ids => @issue_ids, :issue => {'tracker_id' => t}, :back_url => @back), :method => :post,
                                               :selected => (@issue && t == @issue.tracker), :disabled => !@can[:edit] %></li>
                 <% end -%>
                 </ul>
               </li>
               <% end %>
               <% if @safe_attributes.include?('priority_id') && @priorities.present? -%>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_priority) %></a>
                 <ul>
                 <% @priorities.each do |p| -%>
                     <li><%= context_menu_link h(p.name), bulk_update_issues_path(:ids => @issue_ids, :issue => {'priority_id' => p}, :back_url => @back), :method => :post,
                                               :selected => (@issue && p == @issue.priority), :disabled => (!@can[:edit] || @issues.detect {|i| !i.leaf?}) %></li>
                 <% end -%>
                 </ul>
               </li>
               <% end %>
               <% if @safe_attributes.include?('fixed_version_id') && @versions.present? -%>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_fixed_version) %></a>
                 <ul>
                 <% @versions.sort.each do |v| -%>
                     <li><%= context_menu_link format_version_name(v), bulk_update_issues_path(:ids => @issue_ids, :issue => {'fixed_version_id' => v}, :back_url => @back), :method => :post,
                                               :selected => (@issue && v == @issue.fixed_version), :disabled => !@can[:update] %></li>
                 <% end -%>
                     <li><%= context_menu_link l(:label_none), bulk_update_issues_path(:ids => @issue_ids, :issue => {'fixed_version_id' => 'none'}, :back_url => @back), :method => :post,
                                               :selected => (@issue && @issue.fixed_version.nil?), :disabled => !@can[:update] %></li>
                 </ul>
               </li>
               <% end %>
               <% if @safe_attributes.include?('assigned_to_id') && @assignables.present? -%>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_assigned_to) %></a>
                 <ul>
                 <% if @assignables.include?(User.current) %>
                     <li><%= context_menu_link "<< #{l(:label_me)} >>", bulk_update_issues_path(:ids => @issue_ids, :issue => {'assigned_to_id' => User.current}, :back_url => @back), :method => :post,
                                               :disabled => !@can[:update] %></li>
                 <% end %>
                 <% @assignables.each do |u| -%>
                     <li><%= context_menu_link h(u.name), bulk_update_issues_path(:ids => @issue_ids, :issue => {'assigned_to_id' => u}, :back_url => @back), :method => :post,
                                               :selected => (@issue && u == @issue.assigned_to), :disabled => !@can[:update] %></li>
                 <% end -%>
                     <li><%= context_menu_link l(:label_nobody), bulk_update_issues_path(:ids => @issue_ids, :issue => {'assigned_to_id' => 'none'}, :back_url => @back), :method => :post,
                                               :selected => (@issue && @issue.assigned_to.nil?), :disabled => !@can[:update] %></li>
                 </ul>
               </li>
               <% end %>
               <% if @safe_attributes.include?('category_id') && @project && @project.issue_categories.any? -%>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_category) %></a>
                 <ul>
                 <% @project.issue_categories.each do |u| -%>
                     <li><%= context_menu_link h(u.name), bulk_update_issues_path(:ids => @issue_ids, :issue => {'category_id' => u}, :back_url => @back), :method => :post,
                                               :selected => (@issue && u == @issue.category), :disabled => !@can[:update] %></li>
                 <% end -%>
                     <li><%= context_menu_link l(:label_none), bulk_update_issues_path(:ids => @issue_ids, :issue => {'category_id' => 'none'}, :back_url => @back), :method => :post,
                                               :selected => (@issue && @issue.category.nil?), :disabled => !@can[:update] %></li>
                 </ul>
               </li>
               <% end -%>
               <% if @safe_attributes.include?('done_ratio') && Issue.use_field_for_done_ratio? %>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_done_ratio) %></a>
                 <ul>
                 <% (0..10).map{|x|x*10}.each do |p| -%>
                     <li><%= context_menu_link "#{p}%", bulk_update_issues_path(:ids => @issue_ids, :issue => {'done_ratio' => p}, :back_url => @back), :method => :post,
                                                   :selected => (@issue && p == @issue.done_ratio), :disabled => (!@can[:edit] || @issues.detect {|i| !i.leaf?}) %></li>
                 <% end -%>
                 </ul>
               </li>
               <% end %>
               <% @options_by_custom_field.each do |field, options| %>
                 <li class="folder cf_<%= field.id %>">
                   <a href="#" class="submenu"><%= h(field.name) %></a>
                   <ul>
                   <% options.each do |text, value| %>
                     <li><%= bulk_update_custom_field_context_menu_link(field, text, value || text) %></li>
                   <% end %>
                   <% unless field.is_required? %>
                     <li><%= bulk_update_custom_field_context_menu_link(field, l(:label_none), '__none__') %></li>
                   <% end %>
                   </ul>
                 </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>
               <% end %>
               <li><%= context_menu_link l(:button_copy), project_copy_issue_path(@project, @issue),
                       :class => 'icon-copy', :disabled => !@can[:copy] %></li>
             <% else %>
               <li><%= context_menu_link l(:button_copy), bulk_edit_issues_path(:ids => @issue_ids, :copy => '1'),
                                       :class => 'icon-copy', :disabled => !@can[:move] %></li>
             <% end %>
               <li><%= context_menu_link l(:button_delete), issues_path(:ids => @issue_ids, :back_url => @back),
                                         :method => :delete, :data => {:confirm => issues_destroy_confirmation_message(@issues)}, :class => 'icon-del', :disabled => !@can[:delete] %></li>
               <%= call_hook(:view_issues_context_menu_end, {:issues => @issues, :can => @can, :back => @back }) %>
             </ul>

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

             <h3 class="title"><%= l(:permission_add_issue_watchers) %></h3>
             <%= 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)) %>
               </div>
               <p class="buttons">
                 <%= submit_tag l(:button_add), :name => nil, :onclick => "hideModal(this);" %>
                 <%= submit_tag l(:button_cancel), :name => nil, :onclick => "hideModal(this);", :type => 'button' %>
               </p>
             <% end %>

lib/redmine.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 'redmine/core_ext'
             begin
               require 'RMagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
             require 'redmine/scm/base'
             require 'redmine/access_control'
             require 'redmine/access_keys'
             require 'redmine/activity'
             require 'redmine/activity/fetcher'
             require 'redmine/ciphering'
             require 'redmine/codeset_util'
             require 'redmine/custom_field_format'
             require 'redmine/i18n'
             require 'redmine/menu_manager'
             require 'redmine/notifiable'
             require 'redmine/platform'
             require 'redmine/mime_type'
             require 'redmine/notifiable'
             require 'redmine/search'
             require 'redmine/syntax_highlighting'
             require 'redmine/thumbnail'
             require 'redmine/unified_diff'
             require 'redmine/utils'
             require 'redmine/version'
             require 'redmine/wiki_formatting'
             require 'redmine/default_data/loader'
             require 'redmine/helpers/calendar'
             require 'redmine/helpers/diff'
             require 'redmine/helpers/gantt'
             require 'redmine/helpers/time_report'
             require 'redmine/views/other_formats_builder'
             require 'redmine/views/labelled_form_builder'
             require 'redmine/views/builders'
             require 'redmine/themes'
             require 'redmine/hook'
             require 'redmine/plugin'
             if RUBY_VERSION < '1.9'
               require 'fastercsv'
             else
               require 'csv'
               FCSV = CSV
             end
             Redmine::Scm::Base.add "Subversion"
             Redmine::Scm::Base.add "Darcs"
             Redmine::Scm::Base.add "Mercurial"
             Redmine::Scm::Base.add "Cvs"
             Redmine::Scm::Base.add "Bazaar"
             Redmine::Scm::Base.add "Git"
             Redmine::Scm::Base.add "Filesystem"
             Redmine::CustomFieldFormat.map do |fields|
               fields.register 'string'
               fields.register 'text'
               fields.register 'int', :label => :label_integer
               fields.register 'float'
               fields.register 'list'
               fields.register 'date'
               fields.register 'bool', :label => :label_boolean
               fields.register 'user', :only => %w(Issue TimeEntry Version Project), :edit_as => 'list'
               fields.register 'version', :only => %w(Issue TimeEntry Version Project), :edit_as => 'list'
             end
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show], :activities => [:index]}, :public => true, :read => true
               map.permission :search_project, {:search => :index}, :public => true, :read => true
               map.permission :add_project, {:projects => [:new, :create]}, :require => :loggedin
               map.permission :edit_project, {:projects => [:settings, :edit, :update]}, :require => :member
               map.permission :close_project, {:projects => [:close, :reopen]}, :require => :member, :read => true
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :manage_members, {:projects => :settings, :members => [:index, :show, :create, :update, :destroy, :autocomplete]}, :require => :member
               map.permission :manage_versions, {:projects => :settings, :versions => [:new, :create, :edit, :update, :close_completed, :destroy]}, :require => :member
               map.permission :add_subprojects, {:projects => [:new, :create]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => :settings, :issue_categories => [:index, :show, :new, :create, :edit, :update, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:issues => [:index, :show],
                                               :auto_complete => [:issues],
                                               :context_menus => [:issues],
                                               :versions => [:index, :show, :status_by],
                                               :journals => [:index, :diff],
                                               :queries => :index,
                                               :reports => [:issue_report, :issue_report_details]},
                                               :read => true
                 map.permission :add_issues, {:issues => [:new, :create, :update_form], :attachments => :upload}
                 map.permission :edit_issues, {:issues => [:edit, :update, :bulk_edit, :bulk_update, :update_form], :journals => [:new], :attachments => :upload}
                 map.permission :manage_issue_relations, {:issue_relations => [:index, :show, :create, :destroy]}
                 map.permission :manage_subtasks, {}
                 map.permission :set_issues_private, {}
                 map.permission :set_own_issues_private, {}, :require => :loggedin
                 map.permission :add_issue_notes, {:issues => [:edit, :update], :journals => [:new], :attachments => :upload}
                 map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :view_private_notes, {}, :read => true, :require => :member
                 map.permission :set_notes_private, {}, :require => :member
                 map.permission :move_issues, {:issues => [:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 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
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => [:new, :create]}, :require => :loggedin
                 map.permission :view_time_entries, {:timelog => [:index, :report, :show]}, :read => true
                 map.permission :edit_time_entries, {:timelog => [:edit, :update, :destroy, :bulk_edit, :bulk_update]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :update, :destroy,:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :manage_project_activities, {:project_enumerations => [:update, :destroy]}, :require => :member
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :create, :edit, :update, :destroy], :comments => [:destroy]}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true, :read => true
                 map.permission :comment_news, {:comments => :create}
               end
               map.project_module :documents do |map|
                 map.permission :add_documents, {:documents => [:new, :create, :add_attachment]}, :require => :loggedin
                 map.permission :edit_documents, {:documents => [:edit, :update, :add_attachment]}, :require => :loggedin
                 map.permission :delete_documents, {:documents => [:destroy]}, :require => :loggedin
                 map.permission :view_documents, {:documents => [:index, :show, :download]}, :read => true
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:files => [:new, :create]}, :require => :loggedin
                 map.permission :view_files, {:files => :index, :versions => :download}, :read => true
               end
               map.project_module :wiki do |map|
                 map.permission :manage_wiki, {:wikis => [:edit, :destroy]}, :require => :member
                 map.permission :rename_wiki_pages, {:wiki => :rename}, :require => :member
                 map.permission :delete_wiki_pages, {:wiki => [:destroy, :destroy_version]}, :require => :member
                 map.permission :view_wiki_pages, {:wiki => [:index, :show, :special, :date_index]}, :read => true
                 map.permission :export_wiki_pages, {:wiki => [:export]}, :read => true
                 map.permission :view_wiki_edits, {:wiki => [:history, :diff, :annotate]}, :read => true
                 map.permission :edit_wiki_pages, :wiki => [:edit, :update, :preview, :add_attachment]
                 map.permission :delete_wiki_pages_attachments, {}
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:new, :create, :edit, :update, :committers, :destroy]}, :require => :member
                 map.permission :browse_repository, {:repositories => [:show, :browse, :entry, :raw, :annotate, :changes, :diff, :stats, :graph]}, :read => true
                 map.permission :view_changesets, {:repositories => [:show, :revisions, :revision]}, :read => true
                 map.permission :commit_access, {}
                 map.permission :manage_related_issues, {:repositories => [:add_related_issue, :remove_related_issue]}
               end
               map.project_module :boards do |map|
                 map.permission :manage_boards, {:boards => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true, :read => true
                 map.permission :add_messages, {:messages => [:new, :reply, :quote]}
                 map.permission :edit_messages, {:messages => :edit}, :require => :member
                 map.permission :edit_own_messages, {:messages => :edit}, :require => :loggedin
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
                 map.permission :delete_own_messages, {:messages => :destroy}, :require => :loggedin
               end
               map.project_module :calendar do |map|
                 map.permission :view_calendar, {:calendars => [:show, :update]}, :read => true
               end
               map.project_module :gantt do |map|
                 map.permission :view_gantt, {:gantts => [:show, :update]}, :read => true
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :if => Proc.new { User.current.admin? }, :last => true
               menu.push :help, Redmine::Info.help_url, :last => true
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :if => Proc.new { !User.current.logged? }
               menu.push :register, :register_path, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :html => {:method => 'post'}, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :admin_menu do |menu|
               menu.push :projects, {:controller => 'admin', :action => 'projects'}, :caption => :label_project_plural
               menu.push :users, {:controller => 'users'}, :caption => :label_user_plural
               menu.push :groups, {:controller => 'groups'}, :caption => :label_group_plural
               menu.push :roles, {:controller => 'roles'}, :caption => :label_role_and_permissions
               menu.push :trackers, {:controller => 'trackers'}, :caption => :label_tracker_plural
               menu.push :issue_statuses, {:controller => 'issue_statuses'}, :caption => :label_issue_status_plural,
                         :html => {:class => 'issue_statuses'}
               menu.push :workflows, {:controller => 'workflows', :action => 'edit'}, :caption => :label_workflow
               menu.push :custom_fields, {:controller => 'custom_fields'},  :caption => :label_custom_field_plural,
                         :html => {:class => 'custom_fields'}
               menu.push :enumerations, {:controller => 'enumerations'}
               menu.push :settings, {:controller => 'settings'}
               menu.push :ldap_authentication, {:controller => 'auth_sources', :action => 'index'},
                         :html => {:class => 'server_authentication'}
               menu.push :plugins, {:controller => 'admin', :action => 'plugins'}, :last => true
               menu.push :info, {:controller => 'admin', :action => 'info'}, :caption => :label_information_plural, :last => true
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'activities', :action => 'index' }
               menu.push :roadmap, { :controller => 'versions', :action => 'index' }, :param => :project_id,
                           :if => Proc.new { |p| p.shared_versions.any? }
               menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
               menu.push :new_issue, { :controller => 'issues', :action => 'new', :copy_from => nil }, :param => :project_id, :caption => :label_issue_new,
                           :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) }
               menu.push :gantt, { :controller => 'gantts', :action => 'show' }, :param => :project_id, :caption => :label_gantt
               menu.push :calendar, { :controller => 'calendars', :action => 'show' }, :param => :project_id, :caption => :label_calendar
               menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
               menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
               menu.push :wiki, { :controller => 'wiki', :action => 'show', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
               menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
               menu.push :files, { :controller => 'files', :action => 'index' }, :caption => :label_file_plural, :param => :project_id
               menu.push :repository, { :controller => 'repositories', :action => 'show', :repository_id => nil, :path => nil, :rev => nil },
                           :if => Proc.new { |p| p.repository && !p.repository.new_record? }
               menu.push :settings, { :controller => 'projects', :action => 'settings' }, :last => true
             end
             Redmine::Activity.map do |activity|
               activity.register :issues, :class_name => %w(Issue Journal)
               activity.register :changesets
               activity.register :news
               activity.register :documents, :class_name => %w(Document Attachment)
               activity.register :files, :class_name => 'Attachment'
               activity.register :wiki_edits, :class_name => 'WikiContent::Version', :default => false
               activity.register :messages, :default => false
               activity.register :time_entries, :default => false
             end
             Redmine::Search.map do |search|
               search.register :issues
               search.register :news
               search.register :documents
               search.register :changesets
               search.register :wiki_pages
               search.register :messages
               search.register :projects
             end
             Redmine::WikiFormatting.map do |format|
               format.register :textile, Redmine::WikiFormatting::Textile::Formatter, Redmine::WikiFormatting::Textile::Helper
             end
             ActionView::Template.register_template_handler :rsb, Redmine::Views::ApiTemplateHandler

test/functional/watchers_controller_test.rb +43 -6

             # Redmine - project management software
             # Copyright (C) 2006-2013  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.expand_path('../../test_helper', __FILE__)
             class WatchersControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles, :enabled_modules,
                        :issues, :trackers, :projects_trackers, :issue_statuses, :enumerations, :watchers
               def setup
                 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_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_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_no_difference('Watcher.count') do
                   xhr :post, :watch, :object_type => 'issue', :object_id => '1'
                   assert_response 403
                 end
               end
               def test_watch_invalid_class_should_respond_with_404
                 @request.session[:user_id] = 3
                 assert_no_difference('Watcher.count') do
                   xhr :post, :watch, :object_type => 'foo', :object_id => '1'
                   assert_response 404
                 end
               end
               def test_watch_invalid_object_should_respond_with_404
                 @request.session[:user_id] = 3
                 assert_no_difference('Watcher.count') do
                   xhr :post, :watch, :object_type => 'issue', :object_id => '999'
                   assert_response 404
                 end
               end
               def test_unwatch
                 @request.session[:user_id] = 3
                 assert_difference('Watcher.count', -1) do
                   xhr :post, :unwatch, :object_type => 'issue', :object_id => '2'
                   assert_response :success
                   assert_include '$(".issue-2-watcher")', response.body
                 end
                 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_response :success
                 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_equal Project.find(1), assigns(:project)
                 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
                 assert_equal Project.find(1), assigns(:project)
                 assert_match /ajax-modal/, response.body
               end
               def test_create
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count') do
                   xhr :post, :create, :object_type => 'issue', :object_id => '2', :watcher => {:user_id => '4'}
                   assert_response :success
                   assert_match /watchers/, response.body
                   assert_match /ajax-modal/, response.body
                 end
                 assert Issue.find(2).watched_by?(User.find(4))
               end
               def test_create_multiple
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count', 2) do
                   xhr :post, :create, :object_type => 'issue', :object_id => '2', :watcher => {:user_ids => ['4', '7']}
                   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))
               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][]'
                 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][]'
               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][]'
                 assert_select 'input[name=?][value=8]', 'watcher[user_ids][]'
                 assert_select 'input[name=?][value=9]', 'watcher[user_ids][]'
               end
               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
                 end
               end
               def test_remove_watcher
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count', -1) do
                   xhr :post, :destroy, :object_type => 'issue', :object_id => '2', :user_id => '3'
                   assert_response :success
                   assert_match /watchers/, response.body
                 end
                 assert !Issue.find(2).watched_by?(User.find(3))
               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