Redmine

    else

      user_ids << params[:user_id]

    end

    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

    end

    if @users.blank?

      head 200

  end

  def destroy

    @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

    if @watchables && @watchables.size == 1

      users -= @watchables.first.watcher_users

    end

        gravatar(email.to_s.downcase, options) rescue nil

      elsif user.is_a?(AnonymousUser)

        anonymous_avatar(options)

      else

        nil

      end

  def anonymous_avatar(options={})

    image_tag 'anonymous.png', GravatarHelper::DEFAULT_OPTIONS.except(:default, :rating, :ssl).merge(options)

  end

end

  # on the new issue form

  def users_for_new_issue_watchers(issue)

    users = issue.watcher_users.select{|u| u.status == User::STATUS_ACTIVE}

    end

    users

  end

  def watchers_list(object)

    remove_allowed = User.current.allowed_to?("delete_#{object.class.name.underscore}_watchers".to_sym, object.project)

    content = ''.html_safe

      s = ''.html_safe

      s << avatar(user, :size => "16").to_s

      s << link_to_user(user, :class => 'user')

    return if self.id.nil?

    Issue.where(['assigned_to_id = ?', id]).update_all('assigned_to_id = NULL')

  end

end

  def watcher_values

    watcher_values = [["<< #{l(:label_me)} >>", "me"]]

    watcher_values

  end

        if v.delete("me")

          if User.current.logged?

            v.push(User.current.id.to_s)

          else

            v.push("0")

          end

class Watcher < ActiveRecord::Base

  belongs_to :watchable, :polymorphic => true

  validates_presence_of :user

  validates_uniqueness_of :user_id, :scope => [:watchable_type, :watchable_id]

  protected

  def validate_user

  end

  def self.prune_single_user(user, options={})

        # Returns an array of users that are proposed as watchers

        def addable_watcher_users

          if respond_to?(:visible?)

          end

          users

        end

        # Removes user from the watchers list

        def remove_watcher(user)

          # 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.reject! {|user| user.mail.blank? || user.mail_notification == 'none'}

          if respond_to?(:visible?)

            notified.reject! {|user| !visible?(user)}

  def test_show_should_display_watchers

    @request.session[:user_id] = 2

    get(:show, :params => {:id => 1})

    assert_select 'div#watchers ul' do

        assert_select 'a[href="/users/2"]'

        assert_select 'a[class*=delete]'

      end

    end

  end

  def test_show_should_display_watchers_with_gravatars

    @request.session[:user_id] = 2

    with_settings :gravatar_enabled => '1' do

      get(:show, :params => {:id => 1})

    end

    assert_select 'div#watchers ul' do

        assert_select 'a[href="/users/2"]'

        assert_select 'a[class*=delete]'

      end

    end

  end

    ActionMailer::Base.deliveries.clear

    with_settings :notified_events => %w(issue_added) do

        post(

          :create,

          :params => {

              :subject => 'This is a new issue with watchers',

              :description => 'This is the description',

              :priority_id => 5,

            }

          }

        )

    assert_redirected_to :controller => 'issues', :action => 'show', :id => issue

    # Watchers added

    assert issue.watched_by?(User.find(3))

    # Watchers notified

    assert [mail.bcc, mail.cc].flatten.include?(User.find(3).mail)

  end

  def test_post_create_subissue

  def test_new_as_copy_should_preserve_watchers

    @request.session[:user_id] = 2

    user = User.generate!

    get(

      :new,

      :params => {

        :copy_from => 1

      }

    )

    assert_select 'input[type=checkbox][name=?][checked=checked][value=?]', 'issue[watcher_user_ids][]', user.id.to_s

    assert_select 'input[type=hidden][name=?][value=?]', 'issue[watcher_user_ids][]', '', 1

  end

          :copy_from => copied.id,

          :issue => {

            :subject => 'Copy cleared watchers',

          }

        }

      )

    end

    issue = Issue.order('id DESC').first

  end

  def test_create_as_copy_without_watcher_user_ids_should_not_copy_watchers

  end

  test "issue bulk copy copy watcher" do

    @request.session[:user_id] = 2

    assert_difference 'Issue.count' do

      post(

      )

    end

    copy = Issue.order(:id => :desc).first

  end

  def test_bulk_copy_should_not_copy_selected_subtasks_twice

    assert_equal [["<< me >>", "me"]], json

  end

    # 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)

    # "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

  end

end

    assert Issue.find(2).watched_by?(User.find(4))

  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

      post :create, :params => {

        :object_type => 'issue', :object_id => '2',

      }, :xhr => true

      assert_response :success

      assert_match /watchers/, response.body

      assert_match /ajax-modal/, response.body

    end

  end

  def test_create_with_mutiple_objects

    @request.session[:user_id] = 2

      post :create, :params => {

        :object_type => 'issue', :object_id => ['1', '2'],

      }, :xhr => true

      assert_response :success

      assert_match /watchers/, response.body

      assert_match /ajax-modal/, response.body

    end

  end

  def test_autocomplete_on_watchable_creation

    @request.session[:user_id] = 2

    get :autocomplete_for_user, :params => {:q => 'mi', :project_id => 'ecookbook'}, :xhr => true

    assert_response :success

    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_search_non_member_on_create

    assert !Issue.find(2).watched_by?(User.find(3))

  end

  def test_destroy

    @request.session[:user_id] = 2

    assert_difference('Watcher.count', -1) do

  end

  def test_avatar_with_group

  end

  def test_avatar_with_invalid_arg_should_return_nil

  fixtures :projects, :trackers, :issue_statuses, :issues,

           :enumerations, :users,

           :projects_trackers,

  include Redmine::I18n

    assert !User.find(8).member_of?(Project.find(5))

  end

    group = Group.find(10)

    Issue.where(:id => 1).update_all(["assigned_to_id = ?", group.id])

    assert group.destroy

    assert group.destroyed?

    assert_nil Issue.find(1).assigned_to_id

  end

  def test_builtin_groups_should_be_created_if_missing

    issues = find_issues_with_query(query)

    assert issues.any?

    assert_nil issues.detect {|issue| !issue.is_private?}

  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?}

  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)

  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)

  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)

  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)

  end

  def test_filter_on_custom_field_should_ignore_projects_with_field_disabled

  end

  def test_watch

    assert @issue.add_watcher(@user)

    @issue.reload

    assert @issue.watchers.detect {|w| w.user == @user}

  end

  def test_cant_watch_twice

  def test_addable_watcher_users

    addable_watcher_users = @issue.addable_watcher_users

    assert_kind_of Array, addable_watcher_users

  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)

  end

  def test_any_watched_should_return_false_if_no_object_is_watched

  end

  def test_unwatch

    assert @issue.add_watcher(@user)

    @issue.reload

    assert_equal 1, @issue.remove_watcher(@user)

  end

  def test_prune_with_user