Redmine

    @issue = @journal.journalized

    @project = @journal.project

    indice = journal.indice || journal.journalized.visible_journals_with_index.find{|j| j.id == journal.id}&.indice

  acts_as_journalized :activity_type => 'issues'

      journals = journal_visibility_scope(Journal.where(journalized_type: 'Issue', journalized_id: issue_ids))

      journal_ids = journal_notes_visibility_scope(journals, user, skip_pre_condition: true).

      journals = journal_visibility_scope(Journal.where(journalized_type: 'Issue', journalized_id: issue_ids))

      journal_ids = journal_notes_visibility_scope(journals, user, skip_pre_condition: true).

  def self.journal_activity_preload

    [{ journalized: :project }, { journalized: :tracker }, :user]

  end

  def self.journal_activity_scope(scope)

    scope.joins("LEFT OUTER JOIN #{JournalDetail.table_name} ON #{JournalDetail.table_name}.journal_id = #{Journal.table_name}.id").

          where("#{JournalDetail.table_name}.prop_key = 'status_id' OR #{Journal.table_name}.notes <> ''").distinct

  end

  def journal_event_title(journal)

    status = (s = journal_new_status(journal)) ? " (#{s})" : nil

    "#{tracker} ##{id}#{status}: #{subject}"

  end

  def journal_event_type(journal)

    status = journal_new_status(journal)

    if status

      status.is_closed? ? 'issue-closed' : 'issue-edit'

    else

      'issue-note'

    end

  end

  def journal_event_url(journal)

    {controller: 'issues', action: 'show', id: id, anchor: "change-#{journal.id}"}

  end

  def self.journal_visibility_scope(scope)

    scope.joins("INNER JOIN #{Issue.table_name} ON #{Issue.table_name}.id = #{Journal.table_name}.journalized_id").

          joins("INNER JOIN #{Project.table_name} ON #{Project.table_name}.id = #{Issue.table_name}.project_id")

  end

  def self.journal_notes_visibility_scope(scope, user, options = {})

    scope.where(Journal.visible_notes_condition(user, options))

  end

  def journal_editable_by?(journal, usr)

    usr && usr.logged? && (usr.allowed_to?(:edit_issue_notes, project) || (journal.user == usr && usr.allowed_to?(:edit_own_issue_notes, project)))

  end

  def journal_relation_visible?(detail, user)

    Issue.find_by(id: detail.value || detail.old_value)&.visible?(user)

  end

  def journal_notify(journal)

    return unless journal.notify?

    if Setting.notified_events.include?('issue_updated') ||

       (Setting.notified_events.include?('issue_note_added') && journal.notes.present?) ||

       (Setting.notified_events.include?('issue_status_updated') && journal_new_status(journal).present?) ||

       (Setting.notified_events.include?('issue_assigned_to_updated') && journal.detail_for_attribute('assigned_to_id').present?) ||

       (Setting.notified_events.include?('issue_priority_updated') && journal.new_value_for('priority_id').present?) ||

       (Setting.notified_events.include?('issue_fixed_version_updated') && journal.detail_for_attribute('fixed_version_id').present?) ||

       (Setting.notified_events.include?('issue_attachment_added') &&

         journal.details.any? {|d| d.property == 'attachment' && d.value })

      Mailer.deliver_issue_edit(journal)

    end

  end

  def journal_process_watchers(journal)

    usr = journal.user

    if usr.is_a?(User) &&

       usr.pref.auto_watch_on?('issue_contributed_to') &&

       journal.valid_watcher?(usr)

      set_watcher(usr, true)

    end

    assignee = assigned_to

    if assignee.is_a?(User) &&

       assignee.pref.auto_watch_on?('issue_assigned_to_me') &&

       journal.valid_watcher?(assignee)

      set_watcher(assignee, true)

    end

  end

  def self.journal_visible_scope(user = User.current, options = {})

    joins(:project).where(visible_condition(user, options))

  end

  def journal_user_can_view_private_notes?(user)

    user.allowed_to?(:view_private_notes, project)

  end

  def journal_private_notes_allowed?(user)

    user.allowed_to?(:set_notes_private, project)

  end

  def journal_valid_watcher?(user)

    user.active? &&

      user.allowed_to?(:add_issue_watchers, project) &&

      valid_watcher?(user) &&

      !watched_by?(user)

  end

  # Returns the new status if the journal contains a status change, otherwise nil

  def journal_new_status(journal)

    s = journal.new_value_for('status_id')

    s ? IssueStatus.find_by_id(s.to_i) : nil

  end

    Issue.journal_visibility_scope(

      Journal.visible.where(journalized_type: 'Issue')).

      preload(:details, :user, {:journalized => [:project, :author, :tracker, :status]}).

  belongs_to :journalized, :polymorphic => true, :inverse_of => :journals

  cattr_accessor :journalized_types

  def self.register_journalized_type(klass)

    self.journalized_types ||= []

    self.journalized_types << klass unless journalized_types.include?(klass)

  end

  def self.activity_scope_for(klass)

    scope = where(journalized_type: klass.name)

    scope = scope.preload(*klass.journal_activity_preload)

    klass.journal_activity_scope(scope)

  end

  def self.register_activity_provider(klass)

    return if klass.journal_activity_type.blank?

    acts_as_activity_provider(

      type: klass.journal_activity_type,

      author_key: :user_id,

      scope: proc { activity_scope_for(klass) }

    )

  end

    title: proc {|o|  o.journalized.journal_event_title(o) },

    description: :notes,

    author: :user,

    group: :journalized,

    type: proc {|o| o.journalized.journal_event_type(o) },

    url: proc {|o| o.journalized.journal_event_url(o) }

    visible_scope = none

    journalized_types.each do |klass|

      relation = where(journalized_type: klass.name)

      relation = klass.journal_visibility_scope(relation)

      relation = relation.where(journalized_id: klass.journal_visible_scope(user, options).select(:id))

      relation = klass.journal_notes_visibility_scope(relation, user, options)

      visible_scope = visible_scope.or(relation)

    end

    visible_scope

    :if => lambda {|journal, user| journal.journalized.journal_private_notes_allowed?(user)})

        journalized.journal_relation_visible?(detail, user)

    journalized.journal_new_status(self)

    journalized.journal_editable_by?(self, usr)

    journalized.journal_project

    journalized.journal_visible?(*)

    notified = journalized.journal_notified_users

      notified = select_journal_visible_user(notified)

    notified = journalized.journal_notified_watchers

  def valid_watcher?(user)

    journalized.journal_valid_watcher?(user)

  end

    journalized.journal_process_watchers(self)

    journalized.journal_notify(self)

      notified = notified.select {|user| journalized.journal_user_can_view_private_notes?(user)}

<%= wikitoolbar_for "journal_#{@journal.id}_notes", preview_issue_path(:project_id => @project, :issue_id => @journal.journalized) %>

    journalized = change.journalized

      xml.title   journalized.journal_event_title(change)

      xml.link    "rel" => "alternate", "href" => issue_url(journalized)

      xml.id      issue_url(journalized, :journal_id => change)

  $("#change-<%= @journal.id %> .journal-actions").html('<%= escape_javascript(render_journal_actions(@journal.journalized, @journal, :reply_links => authorize_for('issues', 'edit'))) %>');

  $("#journal-<%= @journal.id %>-notes").replaceWith('<%= escape_javascript(render_notes(@journal.journalized, @journal, :reply_links => authorize_for('issues', 'edit'))) %>');

# frozen_string_literal: true

# Redmine - project management software

# Copyright (C) 2006-  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_relative 'lib/acts_as_journalized'

Rails.application.reloader.to_prepare do

  ApplicationRecord.send(:include, Redmine::Acts::Journalized)

end

# frozen_string_literal: true

# Redmine - project management software

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

      def self.included(base)

        base.extend ClassMethods

      end

      module ClassMethods

        def acts_as_journalized(options = {})

          class_attribute :journal_activity_type

          has_many :journals, as: :journalized, dependent: :destroy, inverse_of: :journalized

          Journal.register_journalized_type(self)

          self.journal_activity_type = options[:activity_type]

          Journal.register_activity_provider(self) if journal_activity_type.present?

          include InstanceMethods

        end

        # Visibility

        # Returns journalized records visible for the given user.

        # Default implementation simply returns all records.

        def journal_visible_scope(user = User.current, options = {})

          all

        end

        def journal_notes_visibility_scope(scope, user, options = {})

          scope

        end

        def journal_visibility_scope(scope)

          scope

        end

        # scope contains journals of the current journalized class only

        def journal_activity_scope(scope)

          scope

        end

        def journal_activity_preload

          []

        end

      end

      module InstanceMethods

        # Event API

        def journal_event_title(journal)

          "#{self.class.model_name.human} ##{id}"

        end

        def journal_event_type(journal)

          'journal-update'

        end

        def journal_event_url(journal)

          {}

        end

        # Notification API

        def journal_notify(journal)

          # no-op

        end

        # Watcher API

        def journal_process_watchers(journal)

          # no-op

        end

        # Journal detail tracking API

        def journalized_attribute_names

          []

        end

        # Recipient API

        def journal_notified_users

          respond_to?(:notified_users) ? notified_users : []

        end

        def journal_notified_watchers

          respond_to?(:notified_watchers) ? notified_watchers : []

        end

        # Visibility API

        def journal_visible?(user = User.current)

          respond_to?(:visible?) ? visible?(user) : true

        end

        def journal_project

          respond_to?(:project) ? project : nil

        end

        def journal_editable_by?(journal, user)

          false

        end

        def journal_relation_visible?(detail, user)

          true

        end

        def journal_user_can_view_private_notes?(user)

          true

        end

        def journal_private_notes_allowed?(user)

          false

        end

        def journal_valid_watcher?(user)

          false

        end

        def journal_new_status(journal)

          nil

        end

      end

    end

  end

end

      assert_equal issue, journal.journalized

    issue = @journal.journalized

    assert_nil journals.detect {|journal| !journal.project.is_public?}

    assert_nil journals.detect {|journal| !journal.project.is_public?}

    assert_nil journals.detect {|journal| journal.journalized.project_id != 1}

    assert journals.detect {|journal| !journal.project.is_public?}

    journal = Journal.new(journalized: issue)

    assert_equal 'Feature request', journal.journalized.tracker.name

    issue = Issue.find(journal.journalized.id)

    assert_equal 'Feature request', journal.journalized.tracker.name

    assert_equal 'Feature request', journal.journalized.tracker.name

    assert_equal 'Normal', journal.journalized.priority.name

    journal.journalized = Issue.find(2)