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

      wiki_pages: auto_complete_wiki_pages_path(:project_id => project, :q => ''),

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

  acts_as_mentionable :attributes => ['description']

  acts_as_mentionable :attributes => ['notes']

    notified = select_journal_visible_user(notified)

    notified

  end

  def notified_mentions

    notified = super

    notified = select_journal_visible_user(notified)

  def select_journal_visible_user(notified)

    if private_notes?

      notified = notified.select {|user| user.allowed_to?(:view_private_notes, journalized.project)}

    end

    notified

  end

    users = issue.notified_users | issue.notified_watchers | issue.notified_mentions

    users  = journal.notified_users | journal.notified_watchers | journal.notified_mentions | journal.journalized.notified_mentions

    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 => ['description']

  acts_as_mentionable :attributes => ['text']

  # Auto complete routes

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

# frozen_string_literal: true

# Redmine - project management software

# Copyright (C) 2006-2022 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'}

          if respond_to?(:visible?)

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

          end

          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)

          self.mentioned_users = []

          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' || text_formatting == 'common_mark'

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

          end

          users = content.scan(MentionPattern).flatten

        end

        MentionPattern = /

          (?:^|\W)                    # beginning of string or non-word char

          @((?>[a-z0-9][a-z0-9-]*))   # @username

          (?!\/)                      # without a trailing slash

          (?=

            \.+[ \t\W]|               # dots followed by space or non-word character

            \.+$|                     # dots at end of line

            [^0-9a-zA-Z_.]|           # non-word character except dot

            $                         # end of line

          )

        /ix

      end

    end

  end

end

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

        },

        {

          trigger: '@',

          lookup: function (user, mentionText) {

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

          },

          values: function (text, cb) {

            remoteSearch(getDataSource('users') + 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

  def test_notified_mentions_should_not_include_users_who_cannot_view_private_notes

    journal = Journal.generate!(journalized: Issue.find(2), user: User.find(1), private_notes: true, notes: 'Hello @dlopper, @jsmith and @admin.')

    # User "dlopper" has "Developer" role on project "eCookbook"

    # Role "Developer" does not have the "View private notes" permission

    assert_equal [1, 2], journal.notified_mentions.map(&:id)

  end

# frozen_string_literal: true

# Redmine - project management software

# Copyright (C) 2006-2022  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 Redmine::Acts::MentionableTest < ActiveSupport::TestCase

  fixtures :projects, :users, :email_addresses, :members, :member_roles, :roles,

         :groups_users,

         :trackers, :projects_trackers,

         :enabled_modules,

         :issue_statuses, :issue_categories, :issue_relations, :workflows,

         :enumerations,

         :issues

  def test_mentioned_users_with_user_mention

    issue = Issue.generate!(project_id: 1, description: '@dlopper')

    assert_equal [User.find(3)], issue.mentioned_users

  end

  def test_mentioned_users_with_multiple_mentions

    issue = Issue.generate!(project_id: 1, description: 'Hello @dlopper, @jsmith.')

    assert_equal [User.find(2), User.find(3)], issue.mentioned_users

  end

  def test_mentioned_users_should_not_mention_same_user_multiple_times

    issue = Issue.generate!(project_id: 1, description: '@dlopper @jsmith @dlopper')

    assert_equal [User.find(2), User.find(3)], issue.mentioned_users

  end

  def test_mentioned_users_should_include_only_active_users

    # disable dlopper account

    user = User.find(3)

    user.status = User::STATUS_LOCKED

    user.save

    issue = Issue.generate!(project_id: 1, description: '@dlopper @jsmith')

    assert_equal [User.find(2)], issue.mentioned_users

  end

  def test_mentioned_users_should_include_only_visible_users

    User.current = nil

    Role.non_member.update! users_visibility: 'members_of_visible_projects'

    Role.anonymous.update! users_visibility: 'members_of_visible_projects'

    user = User.generate!

    issue = Issue.generate!(project_id: 1, description: "@jsmith @#{user.login}")

    assert_equal [User.find(2)], issue.mentioned_users

  end

  def test_mentioned_users_should_not_include_mentioned_users_in_existing_content

    issue = Issue.generate!(project_id: 1, description: 'Hello @dlopper')

    assert issue.save

    assert_equal [User.find(3)], issue.mentioned_users

    issue.description = 'Hello @dlopper and @jsmith'

    issue.save

    assert_equal [User.find(2)], issue.mentioned_users

  end

  def test_mentioned_users_should_not_include_users_wrapped_in_pre_tags_for_textile

    description = <<~STR

      <pre>

      Hello @jsmith

      </pre>

    STR

    with_settings text_formatting: 'textile' do

      issue = Issue.generate!(project_id: 1, description: description)

      assert_equal [], issue.mentioned_users

    end

  end

  def test_mentioned_users_should_not_include_users_wrapped_in_pre_tags_for_markdown

    description = <<~STR

      ```

      Hello @jsmith

      ```

    STR

    with_settings text_formatting: 'markdown' do

      issue = Issue.generate!(project_id: 1, description: description)

      assert_equal [], issue.mentioned_users

    end

  end

  def test_mentioned_users_should_not_include_users_wrapped_in_pre_tags_for_common_mark

    description = <<~STR

      ```

      Hello @jsmith

      ```

    STR

    with_settings text_formatting: 'common_mark' do

      issue = Issue.generate!(project_id: 1, description: description)

      assert_equal [], issue.mentioned_users

    end

  end

  def test_notified_mentions

    issue = Issue.generate!(project_id: 1, description: 'Hello @dlopper, @jsmith.')

    assert_equal [User.find(2), User.find(3)], issue.notified_mentions

  end

  def test_notified_mentions_should_not_include_users_who_out_of_all_email

    User.find(3).update!(mail_notification: :none)

    issue = Issue.generate!(project_id: 1, description: "Hello @dlopper, @jsmith.")

    assert_equal [User.find(2)], issue.notified_mentions

  end

  def test_notified_mentions_should_not_include_users_who_cannot_view_the_object

    user = User.find(3)

    # User dlopper does not have access to project "Private child of eCookbook"

    issue = Issue.generate!(project_id: 5, description: "Hello @dlopper, @jsmith.")

    assert !issue.notified_mentions.include?(user)

  end

end

  def test_issue_add_should_notify_mentioned_users_in_issue_description

    User.find(1).mail_notification = 'only_my_events'

    issue = Issue.generate!(project_id: 1, description: 'Hello @dlopper and @admin.')

    assert Mailer.deliver_issue_add(issue)

    # @jsmith and @dlopper are members of the project

    # admin is mentioned

    # @dlopper won't receive duplicated notifications

    assert_equal 3, ActionMailer::Base.deliveries.size

    assert_include User.find(1).mail, recipients

  end

  def test_issue_edit_should_notify_mentioned_users_in_issue_updated_description

    User.find(1).mail_notification = 'only_my_events'

    issue = Issue.find(3)

    issue.init_journal(User.current)

    issue.update(description: "Hello @admin")

    journal = issue.journals.last

    ActionMailer::Base.deliveries.clear

    Mailer.deliver_issue_edit(journal)

    # @jsmith and @dlopper are members of the project

    # admin is mentioned in the updated description

    # @dlopper won't receive duplicated notifications

    assert_equal 3, ActionMailer::Base.deliveries.size

    assert_include User.find(1).mail, recipients

  end

  def test_issue_edit_should_notify_mentioned_users_in_notes

    User.find(1).mail_notification = 'only_my_events'

    journal = Journal.generate!(journalized: Issue.find(3), user: User.find(1), notes: 'Hello @admin.')

    ActionMailer::Base.deliveries.clear

    Mailer.deliver_issue_edit(journal)

    # @jsmith and @dlopper are members of the project

    # admin is mentioned in the notes

    # @dlopper won't receive duplicated notifications

    assert_equal 3, ActionMailer::Base.deliveries.size

    assert_include User.find(1).mail, recipients

  end

  def test_news_added_should_notify_mentioned_users_in_news_description

    news = News.new(title: 'Test news', description: 'Hello @admin.', author: User.first, project_id: 1)

    news.save!

    ActionMailer::Base.deliveries.clear

    Mailer.deliver_news_added(news)

    # @jsmith and @dlopper are members of the project

    # admin is mentioned in the notes

    # @dlopper won't receive duplicated notifications

    assert_equal 3, ActionMailer::Base.deliveries.size

    assert_include User.find(1).mail, recipients

  end

  def test_wiki_content_added_should_notify_mentioned_users_in_content

    content = WikiContent.new(text: 'Hello @admin.', author_id: 1, page_id: 1)

    content.save!

    ActionMailer::Base.deliveries.clear

    Mailer.deliver_wiki_content_added(content)

    # @jsmith and @dlopper are members of the project

    # admin is mentioned in the notes

    # @dlopper won't receive duplicated notifications

    assert_equal 3, ActionMailer::Base.deliveries.size

    assert_include User.find(1).mail, recipients

  end

  def test_wiki_content_updated_should_notify_mentioned_users_in_updated_content

    content = WikiContent.find(1)

    content.update(text: 'Hello @admin.')

    content.save!

    ActionMailer::Base.deliveries.clear

    Mailer.deliver_wiki_content_updated(content)

    # @jsmith and @dlopper are members of the project

    # admin is mentioned in the notes

    # @dlopper won't receive duplicated notifications

    assert_equal 3, ActionMailer::Base.deliveries.size

    assert_include User.find(1).mail, recipients

  end