summaryrefslogtreecommitdiff
path: root/app/presenters/merge_request_presenter.rb
blob: 6deafd310a71a8775d73f7619691d58bd6af9e0a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
class MergeRequestPresenter < Gitlab::View::Presenter::Delegated
  include GitlabMarkdownHelper
  include TreeHelper

  presents :merge_request

  def ci_status
    pipeline = merge_request.head_pipeline

    if pipeline
      status = pipeline.status
      status = "success_with_warnings" if pipeline.success? && pipeline.has_warnings?

      status || "preparing"
    else
      ci_service = merge_request.source_project.try(:ci_service)
      ci_service&.commit_status(merge_request.diff_head_sha, merge_request.source_branch)
    end
  end

  def cancel_merge_when_pipeline_succeeds_path
    if merge_request.can_cancel_merge_when_pipeline_succeeds?(current_user)
      cancel_merge_when_pipeline_succeeds_namespace_project_merge_request_path(
        merge_request.project.namespace,
        merge_request.project,
        merge_request)
    end
  end

  def create_issue_to_resolve_discussions_path
    if can?(current_user, :create_issue, merge_request.project) &&
        merge_request.project.issues_enabled?

      new_namespace_project_issue_path(merge_request.project.namespace,
                                       merge_request.project,
                                       merge_request_to_resolve_discussions_of: merge_request.iid)
    end
  end

  def remove_wip_path
    if merge_request.project.merge_requests_enabled? &&
        can?(current_user, :update_merge_request, merge_request.project)

      remove_wip_namespace_project_merge_request_path(merge_request.project.namespace,
                                                      merge_request.project,
                                                      merge_request)
    end
  end

  def merge_path
    if merge_request.can_be_merged_by?(current_user)
      merge_namespace_project_merge_request_path(merge_request.project.namespace,
                                                 merge_request.project,
                                                 merge_request)
    end
  end

  def revert_in_fork_path
    if user_can_fork_project? && can_be_reverted?
      continue_params = {
        to: mr_path,
        notice: "#{edit_in_new_fork_notice} Try to cherry-pick this commit again.",
        notice_now: edit_in_new_fork_notice_now
      }

      namespace_project_forks_path(merge_request.project.namespace, merge_request.project,
                                   namespace_key: current_user.namespace.id,
                                   continue: continue_params)
    end
  end

  def cherry_pick_in_fork_path
    if user_can_fork_project? && merge_request.can_be_cherry_picked?
      continue_params = {
        to: mr_path,
        notice: "#{edit_in_new_fork_notice} Try to revert this commit again.",
        notice_now: edit_in_new_fork_notice_now
      }

      namespace_project_forks_path(merge_request.project.namespace, merge_request.project,
                                   namespace_key: current_user.namespace.id,
                                   continue: continue_params)
    end
  end

  def conflict_resolution_path
    if merge_request.conflicts_can_be_resolved_in_ui? &&
        merge_request.conflicts_can_be_resolved_by?(current_user)

      conflicts_namespace_project_merge_request_path(merge_request.project.namespace,
                                                     merge_request.project,
                                                     merge_request)

    end
  end

  def target_branch_path
    if merge_request.target_branch_exists?
      namespace_project_branch_path(merge_request.project.namespace,
                                    merge_request.project,
                                    merge_request.target_branch)
    end
  end

  def source_branch_path
    if merge_request.source_branch_exists?
      namespace_project_branch_path(merge_request.source_project.namespace,
                                    merge_request.source_project,
                                    merge_request.source_branch)
    end
  end

  def closing_issues_links
    closes_issues = merge_request.closes_issues(current_user)

    markdown issues_sentence(merge_request.project, closes_issues),
              pipeline: :gfm,
              author: merge_request.author,
              project: merge_request.project
  end

  def mentioned_issues_links
    mentioned_but_not_closing_issues = merge_request
      .issues_mentioned_but_not_closing(current_user)

    markdown issues_sentence(merge_request.project, mentioned_but_not_closing_issues),
              pipeline: :gfm,
              author: merge_request.author,
              project: merge_request.project
  end

  def can_revert_on_current_merge_request?
    user_can_collaborate_with_project? && can_be_reverted?
  end

  def can_cherry_pick_on_current_merge_request?
    user_can_collaborate_with_project? && merge_request.can_be_cherry_picked?
  end

  private

  def mr_path
    namespace_project_merge_request_path(merge_request.project.namespace,
                                         merge_request.project,
                                         merge_request)
  end

  def issues_sentence(project, issues)
    # Sorting based on the `#123` or `group/project#123` reference will sort
    # local issues first.
    issues.map do |issue|
      issue.to_reference(project)
    end.sort.to_sentence
  end

  def can_be_reverted?
    merge_request.can_be_reverted?(current_user)
  end

  def user_can_collaborate_with_project?
    can?(current_user, :push_code, merge_request.project) ||
      (current_user && current_user.already_forked?(merge_request.project))
  end

  def user_can_fork_project?
    can?(current_user, :fork_project, merge_request.project)
  end
end