Redmine

  before_action :find_relation, :only => [:show, :update, :destroy]

  accept_api_auth :index, :show, :create, :update, :destroy

  def update

    raise Unauthorized unless @relation.editable?

    @issue =

      [@relation.issue_from, @relation.issue_to].compact.detect do |issue|

        issue.id.to_s == params[:issue_id].to_s

      end || @relation.issue_from

    @project = @issue.project

    @relation.init_journals(User.current)

    # Only the delay can be updated, other attributes require the relation

    # to be recreated

    @relation.safe_attributes = params.expect(:relation => [:delay])

    saved = @relation.save

    respond_to do |format|

      format.html {redirect_to issue_path(@issue)}

      format.js do

        @relations = select_relations(@issue)

      end

      format.api do

        if saved

          render_api_ok

        else

          render_validation_errors(@relation)

        end

      end

    end

  end

      buttons = "".html_safe

      if manage_relations

        if relation.relation_type == IssueRelation::TYPE_PRECEDES

          buttons << link_to_function(

            sprite_icon('edit', l(:label_relation_edit_delay)),

            "$('.edit-relation-form').hide();" \

            "$('#edit-relation-#{relation.id}-form').show();" \

            "$('#relation_#{relation.id}_delay').focus();",

            :title => l(:label_relation_edit_delay),

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

        buttons << link_to(

          sprite_icon('link-break', l(:label_relation_remove)),

          relation_path(relation, issue_id: issue.id),

          :remote => true,

          :method => :delete,

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

          :title => l(:label_relation_remove),

          :class => 'icon-only icon-link-break'

        )

      end

  def editable?(user=User.current)

    visible?(user) &&

      ((issue_from.nil? || user.allowed_to?(:manage_issue_relations, issue_from.project)) ||

        (issue_to.nil? || user.allowed_to?(:manage_issue_relations, issue_to.project)))

  end

<% if @relation.errors.any? %>

alert('<%= escape_javascript(@relation.errors.full_messages.join("\n")) %>');

<% else %>

$('#relations').html('<%= escape_javascript(render :partial => 'issues/relations') %>');

$('#relation_delay').val('');

$('#relation_issue_to_id').val('');

<% end %>

<% if User.current.allowed_to?(:manage_issue_relations, @project) %>

  <% @relations.each do |relation| %>

    <% next unless relation.relation_type == IssueRelation::TYPE_PRECEDES && relation.other_issue(@issue) %>

    <%= form_for relation, {

                     :as => :relation, :remote => true,

                     :url => relation_path(relation, :issue_id => @issue.id),

                     :method => :put,

                     :html => {:id => "edit-relation-#{relation.id}-form",

                               :class => 'edit-relation-form',

                               :style => 'display: none;'}

                   } do |f| %>

      <p>

        <%= relation.to_s(@issue) {|other| "##{other.id}"} %>:

        <%= l(:field_delay) %> <%= f.text_field :delay, :size => 3, :id => "relation_#{relation.id}_delay" %> <%= l(:label_day_plural) %>

        <%= submit_tag l(:button_save) %>

        <%= link_to_function l(:button_cancel), "$('#edit-relation-#{relation.id}-form').hide();" %>

      </p>

    <% end %>

  <% end %>

<% end %>

  label_relation_edit_delay: Edit delay

  label_relation_edit_delay: 遅延を変更

      resources :relations, :controller => 'issue_relations', :only => [:index, :show, :create, :update, :destroy]

  def test_update

    relation = IssueRelation.create!(

      :issue_from => Issue.find(1), :issue_to => Issue.find(2),

      :relation_type => IssueRelation::TYPE_PRECEDES, :delay => 2

    )

    assert_no_difference 'IssueRelation.count' do

      put(

        :update,

        :params => {

          :id => relation.id,

          :relation => {:delay => '5'}

        }

      )

    end

    assert_redirected_to '/issues/1'

    assert_equal 5, relation.reload.delay

  end

  def test_update_xhr

    relation = IssueRelation.create!(

      :issue_from => Issue.find(1), :issue_to => Issue.find(2),

      :relation_type => IssueRelation::TYPE_PRECEDES, :delay => 2

    )

    put(

      :update,

      :params => {

        :id => relation.id,

        :issue_id => 1,

        :relation => {:delay => '5'}

      },

      :xhr => true

    )

    assert_response :success

    assert_equal 'text/javascript', response.media_type

    assert_include '#relations', response.body

    assert_include "id=\\\"edit-relation-#{relation.id}-form\\\"", response.body

    assert_equal 5, relation.reload.delay

  end

  def test_update_xhr_with_failure

    relation = IssueRelation.create!(

      :issue_from => Issue.find(1), :issue_to => Issue.find(2),

      :relation_type => IssueRelation::TYPE_PRECEDES, :delay => 2

    )

    put(

      :update,

      :params => {

        :id => relation.id,

        :issue_id => 1,

        :relation => {:delay => 'foo'}

      },

      :xhr => true

    )

    assert_response :success

    assert_equal 'text/javascript', response.media_type

    assert_include 'Delay is not a number', response.body

    assert_equal 2, relation.reload.delay

  end

  def test_update_should_not_change_attributes_other_than_delay

    relation = IssueRelation.create!(

      :issue_from => Issue.find(1), :issue_to => Issue.find(2),

      :relation_type => IssueRelation::TYPE_PRECEDES, :delay => 2

    )

    put(

      :update,

      :params => {

        :id => relation.id,

        :relation => {

          :delay => '5',

          :relation_type => 'blocks',

          :issue_to_id => '3'

        }

      }

    )

    relation.reload

    assert_equal 5, relation.delay

    assert_equal IssueRelation::TYPE_PRECEDES, relation.relation_type

    assert_equal 2, relation.issue_to_id

  end

  def test_update_should_reschedule_following_issue

    issue1 = Issue.generate!(:start_date => Date.parse('2026-07-01'),

                             :due_date => Date.parse('2026-07-02'))

    issue2 = Issue.generate!

    relation = IssueRelation.create!(

      :issue_from => issue1, :issue_to => issue2,

      :relation_type => IssueRelation::TYPE_PRECEDES, :delay => 0

    )

    with_settings :non_working_week_days => [] do

      put(

        :update,

        :params => {

          :id => relation.id,

          :relation => {:delay => '2'}

        }

      )

    end

    assert_equal 2, relation.reload.delay

    assert_equal Date.parse('2026-07-05'), issue2.reload.start_date

  end

  def test_update_without_permission_should_fail

    relation = IssueRelation.create!(

      :issue_from => Issue.find(1), :issue_to => Issue.find(2),

      :relation_type => IssueRelation::TYPE_PRECEDES, :delay => 2

    )

    Role.all.each {|r| r.remove_permission! :manage_issue_relations}

    put(

      :update,

      :params => {

        :id => relation.id,

        :relation => {:delay => '5'}

      }

    )

    assert_response :forbidden

    assert_equal 2, relation.reload.delay

  end

  test "PUT /relations/:id.xml should update the delay" do

    relation = IssueRelation.create!(

      :issue_from => Issue.find(1), :issue_to => Issue.find(2),

      :relation_type => IssueRelation::TYPE_PRECEDES, :delay => 2

    )

    put(

      "/relations/#{relation.id}.xml",

      :params => {:relation => {:delay => 5}},

      :headers => credentials('jsmith')

    )

    assert_response :no_content

    assert_equal 5, relation.reload.delay

  end

  test "PUT /relations/:id.xml with invalid delay should return errors" do

    relation = IssueRelation.create!(

      :issue_from => Issue.find(1), :issue_to => Issue.find(2),

      :relation_type => IssueRelation::TYPE_PRECEDES, :delay => 2

    )

    put(

      "/relations/#{relation.id}.xml",

      :params => {:relation => {:delay => 'foo'}},

      :headers => credentials('jsmith')

    )

    assert_response :unprocessable_content

    assert_select 'errors error', :text => /Delay is not a number/

    assert_equal 2, relation.reload.delay

  end