debian-mirror-gitlab/app/controllers/concerns/notes_actions.rb

349 lines
9.5 KiB
Ruby
Raw Normal View History

2018-12-05 23:21:45 +05:30
# frozen_string_literal: true
2017-08-17 22:00:37 +05:30
module NotesActions
include RendersNotes
2018-03-17 18:26:18 +05:30
include Gitlab::Utils::StrongMemoize
2017-08-17 22:00:37 +05:30
extend ActiveSupport::Concern
2020-07-28 23:09:34 +05:30
# last_fetched_at is an integer number of microseconds, which is the same
# precision as PostgreSQL "timestamp" fields. It's important for them to have
# identical precision for accurate pagination
MICROSECOND = 1_000_000
2017-08-17 22:00:37 +05:30
included do
2018-03-17 18:26:18 +05:30
before_action :set_polling_interval_header, only: [:index]
before_action :require_noteable!, only: [:index, :create]
2017-08-17 22:00:37 +05:30
before_action :authorize_admin_note!, only: [:update, :destroy]
2017-09-10 17:25:29 +05:30
before_action :note_project, only: [:create]
2022-01-26 12:08:38 +05:30
before_action -> {
check_rate_limit!(:notes_create,
scope: current_user,
users_allowlist: Gitlab::CurrentSettings.current_application_settings.notes_create_limit_allowlist)
}, only: [:create]
2017-08-17 22:00:37 +05:30
end
def index
2020-07-28 23:09:34 +05:30
notes, meta = gather_notes
2018-03-17 18:26:18 +05:30
notes = prepare_notes_for_rendering(notes)
2020-04-08 14:13:33 +05:30
notes = notes.select { |n| n.readable_by?(current_user) }
2020-07-28 23:09:34 +05:30
notes =
2018-03-27 19:54:05 +05:30
if use_note_serializer?
2018-03-17 18:26:18 +05:30
note_serializer.represent(notes)
else
notes.map { |note| note_json(note) }
end
2017-08-17 22:00:37 +05:30
2020-07-28 23:09:34 +05:30
# We know there's more data, so tell the frontend to poll again after 1ms
set_polling_interval_header(interval: 1) if meta[:more]
2021-04-17 20:07:23 +05:30
# Only present an ETag for the empty response to ensure pagination works
# as expected
::Gitlab::EtagCaching::Middleware.skip!(response) if notes.present?
2021-01-29 00:20:46 +05:30
2020-07-28 23:09:34 +05:30
render json: meta.merge(notes: notes)
2017-08-17 22:00:37 +05:30
end
2018-03-17 18:26:18 +05:30
# rubocop:disable Gitlab/ModuleWithInstanceVariables
2017-08-17 22:00:37 +05:30
def create
2019-07-07 11:18:12 +05:30
@note = Notes::CreateService.new(note_project, current_user, create_note_params).execute
2017-08-17 22:00:37 +05:30
respond_to do |format|
2018-12-05 23:21:45 +05:30
format.json do
json = {
2019-03-21 23:56:56 +05:30
commands_changes: @note.commands_changes&.slice(:emoji_award, :time_estimate, :spend_time)
2018-12-05 23:21:45 +05:30
}
if @note.persisted? && return_discussion?
json[:valid] = true
discussion = @note.discussion
prepare_notes_for_rendering(discussion.notes)
json[:discussion] = discussion_serializer.represent(discussion, context: self)
else
prepare_notes_for_rendering([@note])
json.merge!(note_json(@note))
end
2021-11-18 22:05:49 +05:30
if @note.errors.present? && @note.errors.attribute_names != [:commands_only]
2020-01-01 13:55:28 +05:30
render json: json, status: :unprocessable_entity
else
render json: json
end
2018-12-05 23:21:45 +05:30
end
2017-08-17 22:00:37 +05:30
format.html { redirect_back_or_default }
end
end
2018-03-17 18:26:18 +05:30
# rubocop:enable Gitlab/ModuleWithInstanceVariables
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
# rubocop:disable Gitlab/ModuleWithInstanceVariables
2017-08-17 22:00:37 +05:30
def update
2019-05-03 19:53:19 +05:30
@note = Notes::UpdateService.new(project, current_user, update_note_params).execute(note)
2019-12-04 20:38:33 +05:30
unless @note
head :gone
return
end
2018-12-05 23:21:45 +05:30
prepare_notes_for_rendering([@note])
2017-08-17 22:00:37 +05:30
respond_to do |format|
format.json { render json: note_json(@note) }
format.html { redirect_back_or_default }
end
end
2018-03-17 18:26:18 +05:30
# rubocop:enable Gitlab/ModuleWithInstanceVariables
2017-08-17 22:00:37 +05:30
def destroy
if note.editable?
Notes::DestroyService.new(project, current_user).execute(note)
end
respond_to do |format|
format.js { head :ok }
end
end
private
2020-07-28 23:09:34 +05:30
# Lower bound (last_fetched_at as specified in the request) is already set in
# the finder. Here, we select between returning all notes since then, or a
# page's worth of notes.
def gather_notes
2020-11-24 15:15:51 +05:30
if Feature.enabled?(:paginated_notes, noteable.try(:resource_parent))
2020-07-28 23:09:34 +05:30
gather_some_notes
else
gather_all_notes
end
end
def gather_all_notes
now = Time.current
notes = merge_resource_events(notes_finder.execute.inc_relations_for_view)
[notes, { last_fetched_at: (now.to_i * MICROSECOND) + now.usec }]
end
def gather_some_notes
2021-01-29 00:20:46 +05:30
paginator = ::Gitlab::UpdatedNotesPaginator.new(
2020-07-28 23:09:34 +05:30
notes_finder.execute.inc_relations_for_view,
last_fetched_at: last_fetched_at
)
notes = paginator.notes
# Fetch all the synthetic notes in the same time range as the real notes.
# Although we don't limit the number, their text is under our control so
# should be fairly cheap to process.
notes = merge_resource_events(notes, fetch_until: paginator.next_fetched_at)
[notes, paginator.metadata]
end
def merge_resource_events(notes, fetch_until: nil)
return notes if notes_filter == UserPreference::NOTES_FILTERS[:only_comments]
ResourceEvents::MergeIntoNotesService
.new(noteable, current_user, last_fetched_at: last_fetched_at, fetch_until: fetch_until)
.execute(notes)
end
2017-08-17 22:00:37 +05:30
def note_html(note)
render_to_string(
"shared/notes/_note",
layout: false,
formats: [:html],
locals: { note: note }
)
end
def note_json(note)
2018-12-05 23:21:45 +05:30
attrs = {}
2017-08-17 22:00:37 +05:30
if note.persisted?
2018-03-17 18:26:18 +05:30
attrs[:valid] = true
2017-08-17 22:00:37 +05:30
2018-12-05 23:21:45 +05:30
if return_discussion?
discussion = note.discussion
prepare_notes_for_rendering(discussion.notes)
attrs[:discussion] = discussion_serializer.represent(discussion, context: self)
elsif use_note_serializer?
2018-03-17 18:26:18 +05:30
attrs.merge!(note_serializer.represent(note))
else
2017-08-17 22:00:37 +05:30
attrs.merge!(
2018-03-17 18:26:18 +05:30
id: note.id,
discussion_id: note.discussion_id(noteable),
html: note_html(note),
note: note.note,
on_image: note.try(:on_image?)
2017-08-17 22:00:37 +05:30
)
2018-03-17 18:26:18 +05:30
discussion = note.to_discussion(noteable)
unless discussion.individual_note?
attrs.merge!(
discussion_resolvable: discussion.resolvable?,
diff_discussion_html: diff_discussion_html(discussion),
discussion_html: discussion_html(discussion)
)
attrs[:discussion_line_code] = discussion.line_code if discussion.diff_discussion?
end
2017-08-17 22:00:37 +05:30
end
else
attrs.merge!(
valid: false,
errors: note.errors
)
end
attrs
end
def diff_discussion_html(discussion)
return unless discussion.diff_discussion?
2018-03-17 18:26:18 +05:30
on_image = discussion.on_image?
if params[:view] == 'parallel' && !on_image
2017-08-17 22:00:37 +05:30
template = "discussions/_parallel_diff_discussion"
locals =
if params[:line_type] == 'old'
{ discussions_left: [discussion], discussions_right: nil }
else
{ discussions_left: nil, discussions_right: [discussion] }
end
else
template = "discussions/_diff_discussion"
2018-03-17 18:26:18 +05:30
@fresh_discussion = true # rubocop:disable Gitlab/ModuleWithInstanceVariables
locals = { discussions: [discussion], on_image: on_image }
2017-08-17 22:00:37 +05:30
end
render_to_string(
template,
layout: false,
formats: [:html],
locals: locals
)
end
def discussion_html(discussion)
return if discussion.individual_note?
render_to_string(
"discussions/_discussion",
layout: false,
formats: [:html],
locals: { discussion: discussion }
)
end
def authorize_admin_note!
return access_denied! unless can?(current_user, :admin_note, note)
end
2019-07-07 11:18:12 +05:30
def create_note_params
2017-08-17 22:00:37 +05:30
params.require(:note).permit(
:type,
:note,
2019-07-07 11:18:12 +05:30
:line_code, # LegacyDiffNote
2021-03-11 19:13:27 +05:30
:position, # DiffNote
:confidential
2019-07-07 11:18:12 +05:30
).tap do |create_params|
create_params.merge!(
params.permit(:merge_request_diff_head_sha, :in_reply_to_discussion_id)
)
2019-05-30 16:15:17 +05:30
2019-07-07 11:18:12 +05:30
# These params are also sent by the client but we need to set these based on
# target_type and target_id because we're checking permissions based on that
create_params[:noteable_type] = noteable.class.name
case noteable
when Commit
create_params[:commit_id] = noteable.id
when MergeRequest
create_params[:noteable_id] = noteable.id
# Notes on MergeRequest can have an extra `commit_id` context
create_params[:commit_id] = params.dig(:note, :commit_id)
else
create_params[:noteable_id] = noteable.id
end
end
2017-08-17 22:00:37 +05:30
end
2019-05-03 19:53:19 +05:30
def update_note_params
2020-07-28 23:09:34 +05:30
params.require(:note).permit(:note, :position)
2019-05-03 19:53:19 +05:30
end
2020-07-28 23:09:34 +05:30
def set_polling_interval_header(interval: 6000)
Gitlab::PollingInterval.set_header(response, interval: interval)
2018-03-17 18:26:18 +05:30
end
2017-08-17 22:00:37 +05:30
def noteable
2018-03-17 18:26:18 +05:30
@noteable ||= notes_finder.target || @note&.noteable # rubocop:disable Gitlab/ModuleWithInstanceVariables
end
def require_noteable!
render_404 unless noteable
2017-08-17 22:00:37 +05:30
end
def last_fetched_at
2020-07-28 23:09:34 +05:30
strong_memoize(:last_fetched_at) do
microseconds = request.headers['X-Last-Fetched-At'].to_i
seconds = microseconds / MICROSECOND
frac = microseconds % MICROSECOND
Time.zone.at(seconds, frac)
end
2017-08-17 22:00:37 +05:30
end
2018-12-13 13:39:08 +05:30
def notes_filter
current_user&.notes_filter_for(params[:target_type])
end
2017-08-17 22:00:37 +05:30
def notes_finder
2019-10-12 21:52:04 +05:30
@notes_finder ||= NotesFinder.new(current_user, finder_params)
2017-08-17 22:00:37 +05:30
end
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
def note_serializer
2018-05-09 12:01:36 +05:30
ProjectNoteSerializer.new(project: project, noteable: noteable, current_user: current_user)
2018-03-17 18:26:18 +05:30
end
2018-12-05 23:21:45 +05:30
def discussion_serializer
DiscussionSerializer.new(project: project, noteable: noteable, current_user: current_user, note_entity: ProjectNoteEntity)
end
2017-09-10 17:25:29 +05:30
def note_project
2018-03-17 18:26:18 +05:30
strong_memoize(:note_project) do
2018-10-15 14:42:47 +05:30
next nil unless project
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
note_project_id = params[:note_project_id]
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
the_project =
if note_project_id.present?
Project.find(note_project_id)
else
project
end
2017-09-10 17:25:29 +05:30
2018-10-15 14:42:47 +05:30
next access_denied! unless can?(current_user, :create_note, the_project)
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
the_project
end
2017-09-10 17:25:29 +05:30
end
2018-03-27 19:54:05 +05:30
2018-12-05 23:21:45 +05:30
def return_discussion?
Gitlab::Utils.to_boolean(params[:return_discussion])
end
2018-03-27 19:54:05 +05:30
def use_note_serializer?
return false if params['html']
2018-11-08 19:23:39 +05:30
noteable.discussions_rendered_on_frontend?
2018-03-27 19:54:05 +05:30
end
2017-08-17 22:00:37 +05:30
end
2022-01-26 12:08:38 +05:30
NotesActions.prepend_mod_with('NotesActions')