Redmine

  before_filter :require_login, :find_watchables, :only => [:watch, :unwatch]

    set_watcher(@watchables, User.current, true)

    set_watcher(@watchables, User.current, false)

  before_filter :find_project, :authorize, :only => [:new, :create, :append, :destroy, :autocomplete_for_user]

  accept_api_auth :create, :destroy

  private

  def find_watchables

    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

      format.js { render :partial => 'set_watcher', :locals => {:user => user, :watched => watchables} }

  def watcher_link(objects, user)

    return '' unless user && user.logged?

    objects = Array.wrap(objects)

    watched = objects.any? {|object| object.watched_by?(user)}

    css = [watcher_css(objects), watched ? 'icon icon-fav' : 'icon icon-fav-off'].join(' ')

    text = watched ? l(:button_unwatch) : l(:button_watch)

    url = {

      :controller => 'watchers',

      :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

  def watcher_css(objects)

    objects = Array.wrap(objects)

    id = (objects.size == 1 ? objects.first.id : 'bulk')

    "#{objects.first.class.to_s.underscore}-#{id}-watcher"

<% if User.current.logged? %>

  <li><%= watcher_link(@issues, User.current) %></li>

<% end %>

              :object_type => (watched && watched.class.name.underscore),

              :object_id => watched,

              :project_id => @project},

                 :object_type => (watched && watched.class.name.underscore),

                 :object_id => watched,

                 :project_id => @project) }')" %>

    map.permission :add_issue_watchers, {:watchers => [:new, :create, :append, :autocomplete_for_user]}

  def test_watch_a_single_object

  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_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_for_new_record_with_project_id

  def test_new_for_new_record_with_project_identifier

    @request.session[:user_id] = 2

    xhr :get, :autocomplete_for_user, :q => 'mi', :project_id => 'ecookbook'

    @request.session[:user_id] = 2

    xhr :get, :autocomplete_for_user, :q => 'mi', :object_id => '2' , :object_type => 'issue', :project_id => 'ecookbook'

      xhr :post, :append, :watcher => {:user_ids => ['4', '7']}, :project_id => 'ecookbook'

# 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 WatchersHelperTest < ActionView::TestCase

  include WatchersHelper

  include Redmine::I18n

  fixtures :users, :issues

  def setup

    super

    set_language_if_valid('en')

    User.current = nil

  end

  test '#watcher_link with a non-watched object' do

    expected = link_to(

      "Watch",

      "/watchers/watch?object_id=1&object_type=issue",

      :remote => true, :method => 'post', :class => "issue-1-watcher icon icon-fav-off"

    )

    assert_equal expected, watcher_link(Issue.find(1), User.find(1))

  end

  test '#watcher_link with a single objet array' do

    expected = link_to(

      "Watch",

      "/watchers/watch?object_id=1&object_type=issue",

      :remote => true, :method => 'post', :class => "issue-1-watcher icon icon-fav-off"

    )

    assert_equal expected, watcher_link([Issue.find(1)], User.find(1))

  end

  test '#watcher_link with a multiple objets array' do

    expected = link_to(

      "Watch",

      "/watchers/watch?object_id%5B%5D=1&object_id%5B%5D=3&object_type=issue",

      :remote => true, :method => 'post', :class => "issue-bulk-watcher icon icon-fav-off"

    )

    assert_equal expected, watcher_link([Issue.find(1), Issue.find(3)], User.find(1))

  end

  test '#watcher_link with a watched object' do

    Watcher.create!(:watchable => Issue.find(1), :user => User.find(1))

    expected = link_to(

      "Unwatch",

      "/watchers/unwatch?object_id=1&object_type=issue",

      :remote => true, :method => 'post', :class => "issue-1-watcher icon icon-fav"

    )

    assert_equal expected, watcher_link(Issue.find(1), User.find(1))

  end

end