Redmine

  before_action :find_journal, :only => [:edit, :update, :diff, :rollback]

  before_action :authorize, :only => [:new, :edit, :update, :diff, :rollback]

  def rollback

    (render_403; return false) unless @journal.can_rollback?(User.current)

    if @journal.rollback

      flash[:notice] = l(:notice_successful_update)

    else

      # can't seem to bring in the helper method 'error_messages_for'

      # and injecting it into show.rhtml doesn't seem to work, since

      # the @issue loses the errors on redirect (due to issue reload)

      flash[:error] = "<ul>" + @journal.errors.full_messages.map {|msg| "<li>" + ERB::Util.html_escape(msg) + "</li>"}.join + "</ul>"

    end

    respond_to do |format|

      format.html { redirect_to :controller => 'issues', :action => 'show', :id => @journal.journalized_id, :anchor => "note-#{@journal.issue.journals.index(@journal) + 1}" }

      format.api  { render_validation_errors(@issue) }

    end

  end

    if journal.last_valid_journal?(issue.journals) & journal.can_rollback?

      links << link_to(l(:button_cancel),

                       rollback_journal_path(journal),

                       :method => 'post', :data => {:confirm => l(:text_are_you_sure)},

                       :title => l(:button_rollback),

                       :class => 'icon-only icon-cancel'

                      )

    end

    if journal.notes.present? & !journal.rolled_back?

                         :method => 'put', :data => {:confirm => l(:text_are_you_sure)},

  # rollback the changes in a journal, the journal is destroyed on success

  def rollback(journal)

    # only allow rollback of journal details for the last journal

    (errors.add :base, l(:notice_locking_conflict); return) if !journal.last_valid_journal?(journals)

    # avoid the creation of journals during rollback (see 'attachment removed')

    @rolling_back = true

    # roll back each change detailed by the journal

    journal.details.each do |d|

      case d.property

        # issue attribute change

        when 'attr'; send "#{d.prop_key}=", d.old_value

        # rollback custom field change

        when 'cf'; custom_field_values.each {|v| v.value = d.old_value if v.custom_field_id == d.prop_key.to_i}

        # remove any added attachments (we can't recover removed attachments)

        when 'attachment'; attachments.each {|v| attachments.delete(v) if v.id == d.prop_key.to_i}

      end

    end

    # allow the creation of journals again

    remove_instance_variable(:@rolling_back)

    # destroy the journal once we save the issue changes

    if save(:validate => false)

      journal.rolled_back = true

      journal.save

    end

  end

  def last_valid_journal?(journals)

    self == journals.reject{|j| j.rolled_back}.sort_by(&:id).last

  end

  def can_rollback?(user = nil)

    user ||= User.current

    editable_by?(user) && (details.empty? || user.allowed_to?(:rollback_issue_notes, project))

  end

  def show?

    !self.rolled_back || User.current.pref.hide_rolled_back_issue_notes == '0'

  end

  # rollback the changes in a journal, the journal is destroyed on success

  def rollback

    # we could have details to rollback, so let the issue take care of this more complicated task

    journalized.rollback(self) ||

    # on failure, collect the error messages from the issue on failure

      (journalized.errors.full_messages.each {|msg| errors.add :base, msg}; false)

  end

    'hide_rolled_back_issue_notes',

  def hide_rolled_back_issue_notes; self[:hide_rolled_back_issue_notes] || '0'; end

  def hide_rolled_back_issue_notes=(value); self[:hide_rolled_back_issue_notes]=value; end

      <% if journal.show? %>

        <% if journal.rolled_back? %>

          <strike>

        <% end %>

        <div class="contextual">

          <span class="journal-actions"><%= render_journal_actions(issue, journal, :reply_links => reply_links) %></span>

          <a href="#note-<%= journal.indice %>" class="journal-link">#<%= journal.indice %></a>

        </div>

        <h4>

          <%= avatar(journal.user, :size => "24") %>

          <%= authoring journal.created_on, journal.user, :label => :label_updated_time_by %>

          <%= render_private_notes_indicator(journal) %>

        </h4>

        <% if journal.details.any? %>

          <ul class="details">

            <% details_to_strings(journal.visible_details).each do |string| %>

              <li><%= string %></li>

            <% end %>

          </ul>

          <% if Setting.thumbnails_enabled? && (thumbnail_attachments = journal_thumbnail_attachments(journal)).any? %>

            <div class="thumbnails">

              <% thumbnail_attachments.each do |attachment| %>

                <div><%= thumbnail_tag(attachment) %></div>

              <% end %>

            </div>

          <% end %>

        <%= render_notes(issue, journal, :reply_links => reply_links) unless journal.notes.blank? %>

        <% if journal.rolled_back? %>

          </strike>

        <% end %>

      <% end %>

<%= call_hook(:view_issues_history_journal_bottom, { :journal => journal }) %>

<p><%= pref_fields.check_box :hide_rolled_back_issue_notes %></p>

  field_hide_rolled_back_issue_notes: Hide rolled-back issue notes

  permission_rollback_issue_notes: Rollback issue notes

  button_rollback: Rollback

  permission_rollback_issue_notes: Desfazer mudanças nas tarefas

  button_rollback: Desfazer

  field_hide_rolled_back_issue_notes: Esconder mudanças desfeitas

      post 'rollback'

class AddJournalsRolledBack < ActiveRecord::Migration[4.2]

  def up

    add_column :journals, :rolled_back, :boolean, :default => false

  end

  def down

    remove_column :journals, :rolled_back

  end

end

    map.permission :edit_issue_notes, {:journals => [:edit, :update, :rollback]}, :require => :loggedin

    map.permission :edit_own_issue_notes, {:journals => [:edit, :update, :rollback]}, :require => :loggedin

    map.permission :rollback_issue_notes, {:journals => [:rollback]}