Redmine

    @issue = @journal.journalized

    # Only issue journals are handled by this controller for now

    @journal = Journal.where(:journalized_type => 'Issue').visible.find(params[:id])

    @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',

                      :permissions => {

                        :edit_notes => :edit_issue_notes,

                        :edit_own_notes => :edit_own_issue_notes,

                        :add_watchers => :add_issue_watchers

                      }

      journal_ids = Journal.joins_journalized(Issue).

        where(:journalized_id => issue_ids).

      journal_ids = Journal.joins_journalized(Issue).

        where(:journalized_id => issue_ids).

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

    "(#{visible_condition(user, options)}) AND #{Journal.visible_notes_condition(user, :skip_pre_condition => true)}"

  end

  def self.journal_activity_preload

    [{:journalized => [:project, :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)

    if (status = journal_new_status(journal))

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

    else

      'issue-note'

    end

  end

  def journal_relation_visible?(detail, user)

    Issue.find_by_id(detail.value || detail.old_value).try(:visible?, user)

  end

  def journal_new_status(journal)

    s = journal.new_value_for('status_id')

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

  end

  def journal_notify(journal)

    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)

    user = journal.user

    if user.is_a?(User) &&

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

       journal_valid_watcher?(user)

      set_watcher(user, true)

    end

    if assigned_to.is_a?(User) &&

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

       journal_valid_watcher?(assigned_to)

      set_watcher(assigned_to, true)

    end

  end

    Journal.joins_journalized(Issue).

      visible.

      joins("INNER JOIN #{IssueStatus.table_name} ON #{IssueStatus.table_name}.id = #{Issue.table_name}.status_id").

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

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

  # Returns journals of klass joined with the table of klass (and its project)

  def self.joins_journalized(klass)

    where(:journalized_type => klass.polymorphic_name).joins(*klass.journal_joins)

  end

  def self.activity_scope_for(klass)

    klass.journal_activity_scope(joins_journalized(klass).preload(*klass.journal_activity_preload))

  end

  def self.register_activity_provider(klass)

    # Resolve the class at runtime so that the scope survives code reloading

    class_name = klass.name

    acts_as_activity_provider(

      :type => klass.journalized_options[:activity_type],

      :author_key => :user_id,

      :scope => proc { activity_scope_for(class_name.constantize) }

    )

  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) }

    classes = Redmine::Acts::Journalized.journalized_classes

    # Only consider the types the current scope is restricted to (eg. activity)

    if (types = Array(where_values_hash['journalized_type'])).any?

      classes = classes.select {|klass| types.include?(klass.polymorphic_name)}

    end

    if classes.size == 1 && (condition = classes.first.journal_visible_join_condition(user, options))

      # Joining the journalized table lets the database use the same query

      # plans as before journals were decoupled from issues

      joins_journalized(classes.first).where(condition)

    elsif classes.any?

      where(classes.map {|klass| "(#{klass.journal_visible_condition(user, options)})"}.join(' OR '))

    else

      none

    end

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

  # @deprecated Use #journalized instead

  def issue

    Rails.application.deprecators[:redmine].warn "Journal#issue is deprecated and will be removed. Use Journal#journalized instead."

    journalized if journalized_type == 'Issue'

        journalized&.journal_relation_visible?(detail, user)

    journalized&.journal_new_status(self)

    journalized.present? && journalized.journal_editable_by?(self, usr)

    journalized&.journal_project

    journalized.present? && journalized.journal_visible?(*)

    notified = journalized.journal_notified_users

    select_journal_visible_user(notified)

    notified = journalized.journal_notified_watchers

      if journalized.respond_to?(:custom_field_values)

        @custom_values_before_change = journalized.custom_field_values.to_h do |c|

          [c.custom_field_id, c.value]

        end

    journalized.journal_process_watchers(self)

    journalized.journal_notify(self) if notify?

      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) %>

    issue = change.journalized

  $("#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

    # Makes a model journalized, i.e. its changes and notes are recorded

    # as Journal records.

    #

    #   acts_as_journalized(

    #     :activity_type => 'issues',

    #     :attributes => %w(subject description),

    #     :permissions => {

    #       :edit_notes => :edit_issue_notes,

    #       :edit_own_notes => :edit_own_issue_notes,

    #       :add_watchers => :add_issue_watchers

    #     }

    #   )

    #

    # Options:

    # * :activity_type - registers the journals of the model as activity

    #   provider of the given event type (optional)

    # * :attributes - names of the attributes to journalize, unless the model

    #   defines #journalized_attribute_names

    # * :permissions - permissions used by the default implementations, see

    #   DEFAULT_PERMISSIONS. A nil permission is never granted.

    #

    # The defaults assume that the model has a visible scope and a visible?

    # method, and optionally a project association. Every journal_* method

    # can be overridden by the model for specific behavior.

    module Journalized

      DEFAULT_PERMISSIONS = {

        :edit_notes => nil,

        :edit_own_notes => nil,

        :view_private_notes => :view_private_notes,

        :set_notes_private => :set_notes_private,

        :add_watchers => nil

      }.freeze

      @journalized_type_names = []

      class << self

        # Registers a journalized type by its name, so that journals of this

        # type are taken into account even if the class is not loaded yet

        def register(class_name)

          name = class_name.to_s

          @journalized_type_names << name unless @journalized_type_names.include?(name)

        end

        def unregister(class_name)

          @journalized_type_names.delete(class_name.to_s)

        end

        def journalized_type_names

          @journalized_type_names.dup

        end

        # Returns the classes of the registered journalized types

        def journalized_classes

          @journalized_type_names.filter_map do |name|

            klass = name.safe_constantize

            klass if klass.respond_to?(:journalized_options)

          end

        end

      end

      def self.included(base)

        base.extend ClassMethods

      end

      module ClassMethods

        def acts_as_journalized(options = {})

          options.assert_valid_keys(:activity_type, :attributes, :permissions)

          permissions = options[:permissions] || {}

          permissions.assert_valid_keys(*DEFAULT_PERMISSIONS.keys)

          class_attribute :journalized_options, :instance_writer => false

          self.journalized_options = {

            :activity_type => options[:activity_type]&.to_s,

            :attributes => Array(options[:attributes]).map(&:to_s),

            :permissions => DEFAULT_PERMISSIONS.merge(permissions)

          }

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

          extend SingletonMethods

          include InstanceMethods

          Redmine::Acts::Journalized.register(polymorphic_name)

          Journal.register_activity_provider(self) if journalized_options[:activity_type]

        end

      end

      module SingletonMethods

        # Returns a SQL condition on the tables joined by journal_joins that

        # restricts journals to the ones visible to user, including private

        # notes, or nil if the model does not provide one.

        #

        # Journal.visible uses it when only the journals of this type are

        # queried. Joins usually perform better than the EXISTS subquery of

        # journal_visible_condition, which is used otherwise.

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

          nil

        end

        # Returns a SQL condition that restricts journals to the journals

        # of this type that are visible to user, including private notes

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

          return '1=0' unless respond_to?(:visible)

          journals = Journal.table_name

          records = visible(user, options).

            where("#{table_name}.#{primary_key} = #{journals}.journalized_id").

            where(journal_private_notes_condition(user, options))

          "#{journals}.journalized_type = #{connection.quote(polymorphic_name)}" \

            " AND EXISTS (#{records.select('1').to_sql})"

        end

        # Returns a SQL condition to filter out journals with private notes

        # that are not visible to user

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

          journals = Journal.table_name

          permission = journalized_options[:permissions][:view_private_notes]

          allowed =

            if user.admin?

              '1=1'

            elsif permission && (reflection = journal_project_reflection)

              project_condition =

                Project.allowed_to_condition(user, permission, options.merge(:skip_pre_condition => true))

              "#{table_name}.#{reflection.foreign_key} IN" \

                " (SELECT #{Project.table_name}.id FROM #{Project.table_name} WHERE #{project_condition})"

            else

              '1=0'

            end

          sanitize_sql_for_conditions(

            ["(#{journals}.private_notes = ? OR #{journals}.user_id = ? OR (#{allowed}))", false, user.id]

          )

        end

        # Returns the SQL joins from the journals table to the table of this

        # type and, if any, to the projects table. The journals must also be

        # restricted to this type, see Journal.joins_journalized

        def journal_joins

          journals = Journal.table_name

          joins = ["INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{journals}.journalized_id"]

          if (reflection = journal_project_reflection)

            joins << "INNER JOIN #{Project.table_name} ON #{Project.table_name}.id = #{table_name}.#{reflection.foreign_key}"

          end

          joins

        end

        # Returns the scope of the activity events. The given scope contains

        # the journals of this type only, joined with journal_joins

        def journal_activity_scope(scope)

          scope

        end

        def journal_activity_preload

          journal_project_reflection ? [{:journalized => :project}, :user] : [:user]

        end

        def journal_project_reflection

          reflection = reflect_on_association(:project)

          reflection if reflection&.belongs_to?

        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)

          {:controller => self.class.model_name.plural, :action => 'show', :id => id, :anchor => "change-#{journal.id}"}

        end

        # Called after a journal is created, if notifications are enabled

        def journal_notify(journal)

        end

        # Called before a journal is created

        def journal_process_watchers(journal)

        end

        # Attributes whose changes are journalized

        def journalized_attribute_names

          journalized_options[:attributes]

        end

        def journal_notified_users

          respond_to?(:notified_users) ? notified_users : []

        end

        def journal_notified_watchers

          respond_to?(:notified_watchers) ? notified_watchers : []

        end

        def journal_visible?(user=User.current)

          respond_to?(:visible?) && visible?(user)

        end

        def journal_project

          respond_to?(:project) ? project : nil

        end

        def journal_editable_by?(journal, user)

          return false unless user&.logged?

          journal_allowed_to?(user, :edit_notes) ||

            (journal.user == user && journal_allowed_to?(user, :edit_own_notes))

        end

        def journal_user_can_view_private_notes?(user)

          journal_allowed_to?(user, :view_private_notes)

        end

        def journal_private_notes_allowed?(user)

          journal_allowed_to?(user, :set_notes_private)

        end

        def journal_valid_watcher?(user)

          user.active? &&

            journal_allowed_to?(user, :add_watchers) &&

            respond_to?(:valid_watcher?) && valid_watcher?(user) &&

            !watched_by?(user)

        end

        # Returns true if the relation of the given journal detail is visible to user

        def journal_relation_visible?(detail, user)

          false

        end

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

        def journal_new_status(journal)

          nil

        end

        private

        # Checks the permission configured for key (see DEFAULT_PERMISSIONS)

        # on the journalized project, or globally if there is no project

        def journal_allowed_to?(user, key)

          permission = journalized_options[:permissions][key]

          return false if permission.nil? || user.nil?

          if (project = journal_project)

            user.allowed_to?(permission, project)

          else

            user.allowed_to?(permission, nil, :global => true)

          end

        end

      end

    end

  end

end

      # Journalized types, registered before their classes are loaded

      Redmine::Acts::Journalized.register 'Issue'

      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)

# 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 '../../../../test_helper'

class Redmine::Acts::JournalizedTest < ActiveSupport::TestCase

  def setup

    User.current = nil

    # Use News as a second journalized type

    News.acts_as_journalized unless News.respond_to?(:journalized_options)

    Redmine::Acts::Journalized.register('News')

    @news = News.find(1)

  end

  def teardown

    Redmine::Acts::Journalized.unregister('News')

  end

  def test_issue_should_be_registered

    assert_include 'Issue', Redmine::Acts::Journalized.journalized_type_names

    assert_include Issue, Redmine::Acts::Journalized.journalized_classes

  end

  def test_acts_as_journalized_should_reject_invalid_options

    assert_raise ArgumentError do

      Class.new(ApplicationRecord) { acts_as_journalized :foo => 'bar' }

    end

  end

  def test_visible_should_include_journals_of_each_journalized_type

    journal = Journal.create!(:journalized => @news, :user => User.find(2), :notes => 'News note')

    journals = Journal.visible(User.anonymous)

    assert_include journal, journals

    assert journals.where(:journalized_type => 'Issue').exists?

    assert_equal Journal.where(:journalized_type => 'Issue').visible(User.anonymous).sort,

                 journals.where(:journalized_type => 'Issue').sort

  end

  def test_visible_should_not_include_journals_of_invisible_records

    journal = Journal.create!(:journalized => @news, :user => User.find(2), :notes => 'News note')

    Role.anonymous.remove_permission!(:view_news)

    assert_not_include journal, Journal.visible(User.anonymous)

    assert_not journal.visible?(User.anonymous)

  end

  def test_visible_should_not_include_private_notes_without_permission

    journal = Journal.create!(:journalized => @news, :user => User.find(2), :notes => 'Private', :private_notes => true)

    assert_not_include journal, Journal.visible(User.anonymous)

    assert_include journal, Journal.visible(User.find(2))

    assert_include journal, Journal.visible(User.find(1))

  end

  def test_notified_users_should_exclude_users_not_allowed_to_view_private_notes

    journal = Journal.new(:journalized => @news, :user => User.find(2), :notes => 'Private', :private_notes => true)

    Role.find(1).remove_permission!(:view_private_notes)

    assert journal.notified_users.none? {|user| user.roles_for_project(@news.project).include?(Role.find(1)) && !user.admin?}

  end

  def test_editable_by_should_be_false_without_configured_permission

    journal = Journal.create!(:journalized => @news, :user => User.find(2), :notes => 'News note')

    assert_not journal.editable_by?(User.find(2))

  end

  def test_visible_should_join_journalized_table_when_restricted_to_one_type

    sql = Journal.where(:journalized_type => 'Issue').visible(User.anonymous).to_sql

    assert_include 'INNER JOIN issues', sql

    assert_not_include 'EXISTS (SELECT 1 FROM "issues"', sql

  end

  def test_visible_should_use_exists_conditions_for_several_types

    sql = Journal.visible(User.anonymous).to_sql

    assert_not_include 'INNER JOIN issues', sql

    assert_include "journals.journalized_type = 'News' AND EXISTS", sql

  end

  def test_visible_with_join_and_exists_conditions_should_return_the_same_issue_journals

    user = User.find(2)

    assert_equal Journal.where(:journalized_type => 'Issue').visible(user).ids.sort,

                 Journal.where(:journalized_type => 'Issue').where(Issue.journal_visible_condition(user)).ids.sort

  end

  def test_joins_journalized_should_join_journalized_table_and_project

    journals = Journal.joins_journalized(Issue).where(:issues => {:project_id => 1})

    assert journals.any?

    assert journals.all? {|journal| journal.journalized.is_a?(Issue) && journal.project.id == 1}

  end

end

    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)