Redmine

        css_classes = options[:class] ? "#{user.css_classes} #{options[:class]}" : user.css_classes

        link_to name, user_url(user, :only_path => only_path), :class => css_classes

          end

          if link.nil? && $~

            user = User.mentioned_user($~.named_captures.symbolize_keys)

            if user

              css_classes = (user.notify_mentioned_user?(obj) ? 'notified' : nil)

              link = link_to_user(user, :only_path => only_path, :class => css_classes)

            end

  acts_as_mentionable :attributes => ['content']

    project.notified_users.select {|user| user.allowed_to_view_notify_target?(self) }

  acts_as_mentionable :attributes => ['description']

    notified.select {|user| user.allowed_to_view_notify_target?(self)}

  acts_as_mentionable :attributes => ['notes']

    notified.select{ |u| u.allowed_to_view_notify_target?(self) }

    users -= issue.mentioned_users_with_latest_changes

    users -= journal.mentioned_users_with_latest_changes

    users -= journal.issue.mentioned_users_with_latest_changes

    users -= news.mentioned_users_with_latest_changes

    users -= comment.mentioned_users_with_latest_changes

    users -= message.mentioned_users_with_latest_changes

  def mail_to_mentioned_users(user, obj, contents)

    @contents = contents

    mail :to => user,

         :subject => "You are mentioned by #{obj.try(:author) || obj.user} in #{obj.class}##{obj.id}"

  end

  # Notifies mentioned users.

  #

  # Example:

  #   Mailer.deliver_mail_to_mentioned_users(users, obj, content)

  def self.deliver_mail_to_mentioned_users(users, obj, content)

    users.each do |user|

      mail_to_mentioned_users(user, obj, content).deliver_later

    end

  end

    project.notified_users.select {|user| user.allowed_to_view_notify_target?(self) }

  acts_as_mentionable :attributes => ['description']

    project.users.select {|user| user.notify_about?(self) && user.allowed_to_view_notify_target?(self)}

  # Return the mentioned user to based on the match data

  #  of ApplicationHelper::LINKS_RE.

  #     user:jsmith -> Link to user with login jsmith

  #     @jsmith -> Link to user with login jsmith

  #     user#2 -> Link to user with id 2

  def self.mentioned_user(match_data)

    return nil if match_data[:esc]

    sep = match_data[:sep1] || match_data[:sep2] || match_data[:sep3] || match_data[:sep4]

    identifier = match_data[:identifier1] || match_data[:identifier2] || match_data[:identifier3]

    prefix = match_data[:prefix]

    if ['#', '##'].include?(sep) && prefix == 'user'

      User.visible.find_by(:id => identifier.to_i, :type => 'User')

    elsif sep == '@' || (sep == ':' && prefix == 'user')

      name = identifier.gsub(%r{^"(.*)"$}, "\\1")

      User.find_by_login(CGI.unescapeHTML(name).downcase)

    end

  end

  # Return true if notify the mentioned user.

  def notify_mentioned_user?(object)

    self.active? &&

      self.mail.present? &&

      self.mail_notification.present? && self.mail_notification != 'none' &&

      self.allowed_to_view_notify_target?(object)

  end

  # Return true if the user is allowed to view the notify target.

  def allowed_to_view_notify_target?(object)

    case object

    when Journal

      self.allowed_to_view_notify_target?(object.journalized) &&

        (!object.private_notes? || self.allowed_to?(:view_private_notes, object.journalized.project))

    when Comment

      self.allowed_to_view_notify_target?(object.commented)

    when nil

      false

    else

      object.visible?(self)

    end

  end

    project.notified_users.select {|user| user.allowed_to_view_notify_target?(self) }

<% @contents.each do |key, content| %>

<p><%= textilizable content %></p>

<% end %>

<% @contents.each do |key, content| %>

<%= textilizable content %>

<% end %>

# frozen_string_literal: true

# Include hook code here

require File.dirname(__FILE__) + '/lib/acts_as_mentionable'

ActiveRecord::Base.send(:include, 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 = {})

          return if self.included_modules.include?(Redmine::Acts::Mentionable::InstanceMethods)

          cattr_accessor :mentionable_attributes

          self.mentionable_attributes = options[:attributes]

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

          before_save :was_new_record?

          after_save :notify_mentioned_users

        end

      end

      module InstanceMethods

        def self.included(base)

          base.extend ClassMethods

        end

        def was_new_record?

          @was_new_record = self.new_record?

        end

        def notify_mentioned_users

          attribute_values = mentionable_attributes.map{|attr| [attr, self.saved_changes[attr][1]] if self.saved_changes[attr] }.compact.to_h

          users = mentioned_users_with_latest_changes

          Mailer.deliver_mail_to_mentioned_users(users, self, attribute_values) if users.present?

        end

        def mentioned_users_with_latest_changes

          changes = self.saved_changes

          if @was_new_record

            values = mentionable_attributes.map{|attr| changes[attr] && changes[attr][1] }.compact

            users = mentioned_users(values)

          else

            new_values = mentionable_attributes.map{|attr| changes[attr] && changes[attr][1] }.compact

            old_values = mentionable_attributes.map{|attr| changes[attr] && changes[attr][0] }.compact

            users = mentioned_users(new_values) - mentioned_users(old_values)

          end

          users

        end

        def mentioned_users(values)

          users = []

          values.each do |value|

            value.scan(ApplicationHelper::LINKS_RE) do |_|

              target = User.mentioned_user($~.named_captures.symbolize_keys)

              next if target.blank? || users.include?(target)

              users << target if target.notify_mentioned_user?(self)

            end

          end

          users.uniq

        end

        module ClassMethods

        end

      end

    end

  end

end

a.user.notified, a.user.notified:link, a.user.notified:visited {padding: 2px; border-radius: 3px; background-color: #bae9f5}