Redmine

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

  def autocomplete_for_mention

    users = users_for_mention

    render :json => format_users_json(users)

  end

  def users_for_mention

    users = []

    q = params[:q].to_s.strip

    scope = nil

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

      scope = @project.principals.assignable_watchers

    else

      scope = Principal.assignable_watchers.limit(10)

    end

    # Exclude Group principal for now

    scope = scope.where(:type => ['User'])

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

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

      object = @watchables.first

      if object.respond_to?(:visible?)

        users.reject! {|user| user.is_a?(User) && !object.visible?(user)}

      end

    end

    users

  end

  def format_users_json(users)

    users.map do |user|

      {

        'firstname' => user.firstname,

        'lastname' => user.lastname,

        'name' => user.name,

        'login' => user.login

      }

    end

  end

      "rm.AutoComplete.dataSources = JSON.parse('#{data_sources.to_json}');"

    )

  end

  def update_data_sources_for_auto_complete(data_sources)

    javascript_tag(

      "const currentDataSources = rm.AutoComplete.dataSources;" \

      "const newDataSources = JSON.parse('#{data_sources.to_json}'); " \

      "rm.AutoComplete.dataSources = Object.assign(currentDataSources, newDataSources);"

  def autocomplete_data_sources(project)

    {

      issues: auto_complete_issues_path(project_id: project, q: ''),

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

    }

  end

  acts_as_mentionable :attributes => ['description']

  acts_as_mentionable :attributes => ['notes']

    select_journal_visible_user(notified)

  end

  def notified_mentions

    notified = super

    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 = wiki_content.notified_users | wiki_content.page.wiki.notified_watchers | wiki_content.notified_mentions

    users |= wiki_content.notified_mentions

  acts_as_mentionable :attributes => ['text']

<% if User.current.allowed_to?(:add_issue_watchers, @issue.project)%>

  <%= update_data_sources_for_auto_complete({users: watchers_autocomplete_for_mention_path(project_id: @issue.project, q: '', object_type: 'issue',

   object_id: @issue.id)}) %>

<% end %>

<% if User.current.allowed_to?(:add_wiki_page_watchers, @project)%>

  <%= update_data_sources_for_auto_complete({users: watchers_autocomplete_for_mention_path(project_id: @project, q: '', object_type: 'wiki_page', object_id: @page.id)}) %>

  <% end %>

  # Auto complete routes

  get 'watchers/autocomplete_for_mention', to: 'watchers#autocomplete_for_mention', via: [:get]

# 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.select! {|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

          case text_formatting

          when 'textile'

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

          when 'markdown', 'common_mark'

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

          end

          users = content.scan(MENTION_PATTERN).flatten

        end

        MENTION_PATTERN = /

          (?:^|\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

          map.permission :mention_users, {}

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

          map.permission :add_wiki_page_watchers, {:watchers => [:new, :create, :autocomplete_for_user, :autocomplete_for_mention]}

          map.permission :add_message_watchers, {:watchers => [:new, :create, :autocomplete_for_user, :autocomplete_for_mention]}

      const dataSources = rm.AutoComplete.dataSources;

      if (dataSources[entity]) {

        return dataSources[entity];

      } else {

        return false;

      }

        },

        {

          trigger: '@',

          lookup: function (user, mentionText) {

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

          },

          values: function (text, cb) {

            const url = getDataSource('users');

            if (url) {

              remoteSearch(url + 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_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_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