Redmine

  def users

    users = []

    q = (params[:q] || params[:term]).to_s.strip

    scope = nil

    if params[:q].blank? && @project.present?

      scope = @project.users

    else

      scope = User.all.limit(10)

    end

    users = scope.active.visible.sorted.like(params[:q]).to_a

    render :json => format_users_json(users)

  end

  def format_users_json(users)

    users.map {|user| {

        'firstname' => user.firstname,

        'lastname' => user.lastname,

        'name' => user.name,

        'login' => user.login

      }

    }

  end

  acts_as_mentionable :attributes => ['description']

  acts_as_mentionable :attributes => ['notes']

  def issue_add(user, issue, reason = nil)

    @reason = reason

    mentions = issue.notified_mentions

    users.each do |user|

      issue_add(user, issue, 'mentioned').deliver_later

    end

  def issue_edit(user, journal, reason = nil)

    @reason = reason

    notified_mentions = journal.journalized.notified_mentions | journal.notified_mentions

    notified_mentions.each do |user|

      issue_edit(user, journal, 'mentioned').deliver_later

    end

    users = news.notified_users | news.notified_watchers_for_added_news | news.notified_mentions

    users = wiki_content.notified_users | wiki_content.page.wiki.notified_watchers | wiki_content.notified_mentions

    users |= wiki_content.notified_mentions

  acts_as_mentionable :attributes => ['text']

                      :issues_url => auto_complete_issues_path(:project_id => @project, :q => ''),

                      :users_url => auto_complete_users_path(:project_id => @project, :q => '')

                :issues_url => auto_complete_issues_path(:project_id => @issue.project, :q => ''),

                :users_url => auto_complete_users_path(:project_id => @issue.project, :q => '')

                       :issues_url => auto_complete_issues_path(:project_id => @issue.project, :q => ''),

                       :users_url => auto_complete_users_path(:project_id => @issue.project, :q => '')

                      :issues_url => auto_complete_issues_path(:project_id => @project, :q => ''),

                      :users_url => auto_complete_users_path(:project_id => @project, :q => '')

              :issues_url => auto_complete_issues_path(:project_id => @project, :q => ''),

              :users_url => auto_complete_users_path(:project_id => @project, :q => '')

<% unless @reason.nil? %>

  You have been mentioned in it.

<% end %>

<% unless @reason.nil? %>

  You have been mentioned in it.

<% end %>

                    :issues_url => auto_complete_issues_path(:project_id => @project, :q => ''),

                    :users_url => auto_complete_users_path(:project_id => @project, :q => '')

                       :issues_url => auto_complete_issues_path(:project_id => @project, :q => ''),

                       :users_url => auto_complete_users_path(:project_id => @project, :q => '')

                    :issues_url => auto_complete_issues_path(:project_id => @project, :q => ''),

                    :users_url => auto_complete_users_path(:project_id => @project, :q => '')

                      :issues_url => auto_complete_issues_path(:project_id => @project, :q => ''),

                      :users_url => auto_complete_users_path(:project_id => @project, :q => '')

  match '/users/auto_complete', :to => 'auto_completes#users', :via => :get, :as => 'auto_complete_users'

require 'redmine/acts/mentionable'

# frozen_string_literal: true

# Redmine - project management software

# Copyright (C) 2006-2019  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 Redmine

  module Acts

    module Mentionable

      def self.included(base)

        base.extend ClassMethods

      end

      module ClassMethods

        def acts_as_mentionable(options = {})

          class_attribute :mentionable_attributes

          self.mentionable_attributes = options[:attributes]

          attr_accessor :mentioned_users

          send :include, Redmine::Acts::Mentionable::InstanceMethods

          after_save :parse_mentions

        end

      end

      module InstanceMethods

        def self.included(base)

          base.extend ClassMethods

        end

        def notified_mentions

          notified = mentioned_users.to_a

          notified.reject! {|user| user.mail.blank? || user.mail_notification == 'none'}

          notified

        end

        private

        def parse_mentions

          mentionable_attrs = self.mentionable_attributes

          saved_mentionable_attrs = self.saved_changes.select{|a| mentionable_attrs.include?(a)}

          saved_mentionable_attrs.each do |key, attr|

            old_value, new_value =  attr

            get_mentioned_users(old_value, new_value)

          end

        end

        def get_mentioned_users(old_content, new_content)

          previous_matches =  scan_for_mentioned_users(old_content)

          current_matches = scan_for_mentioned_users(new_content)

          new_matches = (current_matches - previous_matches).flatten

          if new_matches.any?

            self.mentioned_users = User.visible.active.where(:login => new_matches)

          end

        end

        def scan_for_mentioned_users(content)

          return [] if content.nil?

          # remove quoted text

          content = content.gsub(%r{\r\n(?:\>\s)+(.*?)\r\n}m, '')

          text_formatting = Setting.text_formatting

          # Remove text wrapped in pre tags based on text formatting

          if text_formatting == 'textile'

            content = content.gsub(%r{<pre>(.*?)</pre>}m, '')

          elsif text_formatting == 'markdown'

            content = content.gsub(%r{(~~~|```)(.*?)(~~~|```)}m, '')

          end

          content.scan(/@([a-z0-9_\-@\.]*)/i)

        end

      end

    end

  end

end

ActiveRecord::Base.send :include, Redmine::Acts::Mentionable

        collection: [

            {

                trigger: '#',

                values: function (text, cb) {

                  if (event.target.type === 'text' && $(element).attr('autocomplete') != 'off') {

                    $(element).attr('autocomplete', 'off');

                  }

                  remoteSearch(issuesUrl + text, function (issues) {

                    return cb(issues);

                  });

                },

                lookup: 'label',

                fillAttr: 'label',

                requireLeadingSpace: true,

                selectTemplate: function (issue) {

                  return '#' + issue.original.id;

                },

            },

            {

                trigger: '@',

                lookup: function (user, mentionText) {

                  return user.name + user.firstname + user.lastname + user.login;

                },

                values: function (text, cb) {

                  remoteSearch(usersUrl + text, function (users) {

                    return cb(users);

                  });

                },

                menuItemTemplate: function (user) {

                  return user.original.name;

                },

                selectTemplate: function (user) {

                  return '@' + user.original.login;

                }

            }

        ]

  def test_issues_with_scope_all_should_search_other_projects

  def test_issues_without_project_should_search_all_projects

  def test_issues_without_scope_all_should_not_search_other_projects

  def test_issues_with_status_o_should_return_open_issues_only

  def test_issues_with_status_c_should_return_closed_issues_only

  def test_issues_with_issue_id_should_not_return_that_issue

  def test_issue_without_term_should_return_last_10_issues

  def test_users_should_accept_case_insensitive_term_param

    get :users, :params => {

        :q => 'JoHN'

    }

    assert_response :success

    assert_include "John Smith", response.body

  end

  def test_users_should_return_json

    get :users, :params => {

        :q => 'john'

    }

    assert_response :success

    json = ActiveSupport::JSON.decode(response.body)

    assert_kind_of Array, json

    user = json.first

    assert_kind_of Hash, user

    assert_equal 'John', user['firstname']

    assert_equal 'Smith', user['lastname']

    assert_equal 'John Smith', user['name']

    assert_equal 'jsmith', user['login']

  end

  def test_users_with_project_and_without_term_should_return_project_users

    get :users, :params => {

        :project_id => 'onlinestore'

    }

    assert_response :success

    json = ActiveSupport::JSON.decode(response.body)

    assert_equal 2, json.count

    assert_equal 'jsmith', json.first['login']

    assert_equal 'miscuser8', json.last['login']

  end

  def test_users_without_project_and_with_term_should_search_in_all_users

    get :users, :params => {

        :q => 'm'

    }

    assert_response :success

    assert_include "Redmine Admin", response.body

    assert_include "Dave Lopper", response.body

  end