Redmine

    journal_notes_columns = query.journal_notes_columns

      if journal_notes_columns.present?

        without_journal_notes_columns = query.without_journal_notes_columns

        items.each do |item|

          if item.journals_with_notes.blank?

            csv << without_journal_notes_columns.map {|c| csv_content(c, item)}

            next

          end

          item.journals_with_notes.each_with_index do |journal, index|

            if index == 0

              csv << without_journal_notes_columns.map {|c| csv_content(c, item)} + journal_notes_columns.map {|c| csv_content(c, journal)}

            else

              csv << without_journal_notes_columns.map {|c| csv_content(c, item) if c.name == :id } + journal_notes_columns.map {|c| csv_content(c, journal)}

            end

          end

        end

      else

        items.each do |item|

          csv << columns.map {|c| csv_content(c, item)}

        end

      # Replace journal_notes params

      if params[:journal_notes] && params[:format] == 'csv'

        params['c'] ||= []

        params['c'] += IssueQuery.journal_column_names.map(&:to_s)

      end

    @journals_with_notes = nil

    elsif @journals_with_notes && @journals_with_notes.first.notes

      @journals_with_notes.first.notes

  def journals_with_notes

    if @journals_with_notes

      @journals_with_notes

    else

      journals.where.not(notes: '').reorder(:id => :asc)

    end

  end

  def self.load_visible_last_notes(issues, user=User.current, has_notes=false)

      if has_notes

        issues.each do |issue|

          issue.instance_variable_set(:@last_notes, issue.journals_with_notes.last.notes)

        end

        return

      end

  # Preloads visible journals_with_notes for a collection of issues

  def self.load_visible_journals_with_notes(issues, user=User.current)

    return unless issues.any?

    issue_ids = issues.map(&:id)

    journals = Journal.joins(issue: :project).

      where(:journalized_type => 'Issue', :journalized_id => issue_ids).

      where(Journal.visible_notes_condition(user, :skip_pre_condition => true)).

      where.not(notes: '').

      reorder(id: :asc)

    issues.each do |issue|

      issue.instance_variable_set(:@journals_with_notes, journals.where(journalized_id: issue.id))

    end

  end

    QueryColumn.new(:last_notes, :caption => :label_last_notes, :inline => false),

    QueryJournalsColumn.new(:id, :caption => :label_notes_id),

    QueryJournalsColumn.new(:notes, :caption => :field_notes),

    QueryJournalsColumn.new(:user, :caption => :label_notes_author),

    QueryJournalsColumn.new(:created_on, :caption => :label_notes_created_on),

    QueryJournalsColumn.new(:private_notes, :caption => :field_private_notes)

  def self.journal_column_names

    available_columns.select{|c| c.is_a?(QueryJournalsColumn)}.map(&:name)

  end

    if IssueQuery.journal_column_names.any?{|name| has_column?(name)}

      Issue.load_visible_journals_with_notes(issues)

    end

      Issue.load_visible_last_notes(issues, User.current, IssueQuery.journal_column_names.any?{|name| has_column?(name)})

  def journal_notes?

    false

  end

class QueryJournalsColumn < QueryColumn

  def initialize(name, options={})

    @attribute = name

    @inline = false

    name_with_assoc = "journals.#{name}".to_sym

    super(name_with_assoc, options)

  end

  def value_object(object)

    return nil unless object.is_a?(Journal)

    object.send @attribute

  end

  def journal_notes?

    true

  end

end

  def journal_notes_columns

    columns.select(&:journal_notes?)

  end

  def without_journal_notes_columns

    columns.reject(&:journal_notes?)

  end

    available_columns.reject(&:inline?).reject(&:journal_notes?)

  def available_journal_notes_columns

    available_columns.select(&:journal_notes?)

  end

  <% if @query.available_block_columns.any? || @query.available_journal_notes_columns.any? %>

    <fieldset id="csv-export-other-columns">

        <%= toggle_checkboxes_link('#csv-export-other-columns input[type=checkbox]') %>

      <% if @query.available_block_columns.any? %>

        <% @query.available_block_columns.each do |column| %>

          <label><%= check_box_tag 'c[]', column.name, @query.has_column?(column), :id => nil %> <%= column.caption %></label>

        <% end %>

      <% end %>

      <% if @query.available_journal_notes_columns.any? %>

        <label><%= check_box_tag 'journal_notes', 1, params[:journal_notes], :id => nil %> <%= l(:label_all_notes) %></label>

  def test_index_csv_with_journal_notes_params

    get(

      :index,

      :params => {

        :format => 'csv',

        :c => ['subject'],

        :project => 'ecookbook',

        :journal_notes => 1

      }

    )

    assert_response :success

    lines = @response.body.chomp.split("\n")

    assert_equal 7, lines.first.split(',').count

    journal1 = Journal.find(1)

    assert_equal "1,Cannot print recipes,#{journal1.id},#{journal1.notes},#{journal1.user},#{format_time(journal1.created_on)},No", lines[-2]

    journal2 = Journal.find(2)

    assert_equal "1,,#{journal2.id},\"#{journal2.notes}\",#{journal2.user},#{format_time(journal2.created_on)},No", lines[-1]

  end

  def test_query_should_preload_journals_with_notes

    q = IssueQuery.new(:name => '_', :column_names => [:subject, :'journals.notes'])

    assert q.has_column?(:'journals.notes')

    issues = q.issues

    assert_not_nil issues.first.instance_variable_get(:@journals_with_notes)

  end