2018-07-05 10:18:17 +00:00
|
|
|
# frozen_string_literal: true
|
|
|
|
|
2021-05-12 03:10:21 +00:00
|
|
|
class IssuableBaseService < ::BaseProjectService
|
2014-10-07 14:09:28 +00:00
|
|
|
private
|
|
|
|
|
2021-05-12 03:10:21 +00:00
|
|
|
def self.constructor_container_arg(value)
|
|
|
|
# TODO: Dynamically determining the type of a constructor arg based on the class is an antipattern,
|
|
|
|
# but the root cause is that Epics::BaseService has some issues that inheritance may not be the
|
|
|
|
# appropriate pattern. See more details in comments at the top of Epics::BaseService#initialize.
|
|
|
|
# Follow on issue to address this:
|
|
|
|
# https://gitlab.com/gitlab-org/gitlab/-/issues/328438
|
|
|
|
|
|
|
|
{ project: value }
|
|
|
|
end
|
|
|
|
|
2018-11-02 16:29:32 +00:00
|
|
|
attr_accessor :params, :skip_milestone_email
|
|
|
|
|
2021-05-12 03:10:21 +00:00
|
|
|
def initialize(project:, current_user: nil, params: {})
|
2018-11-02 16:29:32 +00:00
|
|
|
super
|
|
|
|
|
|
|
|
@skip_milestone_email = @params.delete(:skip_milestone_email)
|
|
|
|
end
|
|
|
|
|
2020-02-10 18:09:00 +00:00
|
|
|
def can_admin_issuable?(issuable)
|
2016-12-14 21:39:53 +00:00
|
|
|
ability_name = :"admin_#{issuable.to_ability_name}"
|
2015-11-17 11:42:43 +00:00
|
|
|
|
2020-02-10 18:09:00 +00:00
|
|
|
can?(current_user, ability_name, issuable)
|
|
|
|
end
|
|
|
|
|
2021-06-11 18:10:13 +00:00
|
|
|
def can_set_issuable_metadata?(issuable)
|
|
|
|
ability_name = :"set_#{issuable.to_ability_name}_metadata"
|
|
|
|
|
|
|
|
can?(current_user, ability_name, issuable)
|
|
|
|
end
|
|
|
|
|
2020-02-10 18:09:00 +00:00
|
|
|
def filter_params(issuable)
|
2021-06-11 18:10:13 +00:00
|
|
|
unless can_set_issuable_metadata?(issuable)
|
2020-10-01 18:10:20 +00:00
|
|
|
params.delete(:milestone)
|
2015-06-25 14:17:48 +00:00
|
|
|
params.delete(:milestone_id)
|
2016-08-18 10:24:44 +00:00
|
|
|
params.delete(:labels)
|
2016-04-29 16:38:07 +00:00
|
|
|
params.delete(:add_label_ids)
|
2020-05-12 09:09:31 +00:00
|
|
|
params.delete(:add_labels)
|
2016-04-29 16:38:07 +00:00
|
|
|
params.delete(:remove_label_ids)
|
2020-05-12 09:09:31 +00:00
|
|
|
params.delete(:remove_labels)
|
2015-06-25 14:17:48 +00:00
|
|
|
params.delete(:label_ids)
|
2017-05-04 12:11:15 +00:00
|
|
|
params.delete(:assignee_ids)
|
2015-06-25 14:17:48 +00:00
|
|
|
params.delete(:assignee_id)
|
2021-03-16 09:11:17 +00:00
|
|
|
params.delete(:add_assignee_ids)
|
|
|
|
params.delete(:remove_assignee_ids)
|
2016-09-27 09:29:06 +00:00
|
|
|
params.delete(:due_date)
|
2017-07-20 14:42:33 +00:00
|
|
|
params.delete(:canonical_issue_id)
|
2017-08-09 15:37:06 +00:00
|
|
|
params.delete(:project)
|
2017-08-30 14:57:50 +00:00
|
|
|
params.delete(:discussion_locked)
|
2015-06-25 14:17:48 +00:00
|
|
|
end
|
2016-12-14 21:39:53 +00:00
|
|
|
|
2021-08-25 09:10:52 +00:00
|
|
|
# confidential attribute is a special type of metadata and needs to be allowed to be set
|
|
|
|
# by non-members on issues in public projects so that security issues can be reported as confidential.
|
|
|
|
params.delete(:confidential) unless can?(current_user, :set_confidentiality, issuable)
|
2021-12-14 00:14:57 +00:00
|
|
|
params.delete(:add_contacts) unless can?(current_user, :set_issue_crm_contacts, issuable)
|
|
|
|
params.delete(:remove_contacts) unless can?(current_user, :set_issue_crm_contacts, issuable)
|
2021-08-25 09:10:52 +00:00
|
|
|
|
2021-03-16 09:11:17 +00:00
|
|
|
filter_assignees(issuable)
|
2016-12-14 21:39:53 +00:00
|
|
|
filter_milestone
|
|
|
|
filter_labels
|
2021-07-01 18:07:29 +00:00
|
|
|
filter_severity(issuable)
|
2021-12-20 18:13:27 +00:00
|
|
|
filter_escalation_status(issuable)
|
2015-06-25 14:17:48 +00:00
|
|
|
end
|
2015-11-17 11:42:43 +00:00
|
|
|
|
2021-03-16 09:11:17 +00:00
|
|
|
def filter_assignees(issuable)
|
2022-10-13 06:10:27 +00:00
|
|
|
filter_assignees_using_checks(issuable, :assignee_ids)
|
|
|
|
filter_assignees_using_checks(issuable, :add_assignee_ids)
|
|
|
|
filter_assignees_using_checks(issuable, :remove_assignee_ids)
|
2021-03-16 09:11:17 +00:00
|
|
|
end
|
|
|
|
|
2022-10-13 06:10:27 +00:00
|
|
|
def filter_assignees_using_checks(issuable, id_key)
|
2021-03-16 09:11:17 +00:00
|
|
|
return if params[id_key].blank?
|
|
|
|
|
2019-04-07 18:35:16 +00:00
|
|
|
unless issuable.allows_multiple_assignees?
|
2021-03-16 09:11:17 +00:00
|
|
|
params[id_key] = params[id_key].first(1)
|
2019-04-07 18:35:16 +00:00
|
|
|
end
|
|
|
|
|
2021-03-16 09:11:17 +00:00
|
|
|
assignee_ids = params[id_key].select { |assignee_id| user_can_read?(issuable, assignee_id) }
|
2016-12-14 21:39:53 +00:00
|
|
|
|
2021-03-16 09:11:17 +00:00
|
|
|
if params[id_key].map(&:to_s) == [IssuableFinder::Params::NONE]
|
|
|
|
params[id_key] = []
|
2019-04-07 18:35:16 +00:00
|
|
|
elsif assignee_ids.any?
|
2021-03-16 09:11:17 +00:00
|
|
|
params[id_key] = assignee_ids
|
2016-12-14 21:39:53 +00:00
|
|
|
else
|
2021-03-16 09:11:17 +00:00
|
|
|
params.delete(id_key)
|
2016-04-21 10:20:05 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-09-07 12:08:27 +00:00
|
|
|
def user_can_read?(issuable, user_id)
|
|
|
|
user = User.find_by_id(user_id)
|
2016-12-14 21:39:53 +00:00
|
|
|
|
2020-09-07 12:08:27 +00:00
|
|
|
return false unless user
|
2016-12-14 21:39:53 +00:00
|
|
|
|
|
|
|
ability_name = :"read_#{issuable.to_ability_name}"
|
|
|
|
resource = issuable.persisted? ? issuable : project
|
|
|
|
|
2020-09-07 12:08:27 +00:00
|
|
|
can?(user, ability_name, resource)
|
2016-12-14 21:39:53 +00:00
|
|
|
end
|
|
|
|
|
2016-04-21 10:20:05 +00:00
|
|
|
def filter_milestone
|
2016-04-21 11:40:52 +00:00
|
|
|
milestone_id = params[:milestone_id]
|
|
|
|
return unless milestone_id
|
2016-04-21 10:20:05 +00:00
|
|
|
|
2020-03-30 21:08:01 +00:00
|
|
|
params[:milestone_id] = '' if milestone_id == IssuableFinder::Params::NONE
|
2019-01-11 14:58:18 +00:00
|
|
|
groups = project.group&.self_and_ancestors&.select(:id)
|
2017-07-07 15:08:49 +00:00
|
|
|
|
|
|
|
milestone =
|
2019-01-11 14:58:18 +00:00
|
|
|
Milestone.for_projects_and_groups([project.id], groups).find_by_id(milestone_id)
|
2017-07-07 15:08:49 +00:00
|
|
|
|
|
|
|
params[:milestone_id] = '' unless milestone
|
2016-04-21 10:20:05 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def filter_labels
|
2019-08-30 19:28:19 +00:00
|
|
|
label_ids_to_filter(:add_label_ids, :add_labels, false)
|
|
|
|
label_ids_to_filter(:remove_label_ids, :remove_labels, true)
|
|
|
|
label_ids_to_filter(:label_ids, :labels, false)
|
|
|
|
end
|
2019-02-12 08:35:34 +00:00
|
|
|
|
2019-08-30 19:28:19 +00:00
|
|
|
def label_ids_to_filter(label_id_key, label_key, find_only)
|
|
|
|
if params[label_id_key]
|
|
|
|
params[label_id_key] = labels_service.filter_labels_ids_in_param(label_id_key)
|
|
|
|
elsif params[label_key]
|
|
|
|
params[label_id_key] = labels_service.find_or_create_by_titles(label_key, find_only: find_only).map(&:id)
|
2019-02-12 08:35:34 +00:00
|
|
|
end
|
2020-04-28 18:09:35 +00:00
|
|
|
|
|
|
|
params.delete(label_key) if params[label_key].nil?
|
2016-04-29 16:38:07 +00:00
|
|
|
end
|
|
|
|
|
2019-02-12 08:35:34 +00:00
|
|
|
def labels_service
|
|
|
|
@labels_service ||= ::Labels::AvailableLabelsService.new(current_user, parent, params)
|
|
|
|
end
|
|
|
|
|
2021-07-01 18:07:29 +00:00
|
|
|
def filter_severity(issuable)
|
|
|
|
severity = params.delete(:severity)
|
|
|
|
return unless severity && issuable.supports_severity?
|
2021-10-28 18:14:18 +00:00
|
|
|
return unless can_admin_issuable?(issuable)
|
2021-07-01 18:07:29 +00:00
|
|
|
|
|
|
|
severity = IssuableSeverity::DEFAULT unless IssuableSeverity.severities.key?(severity)
|
|
|
|
return if severity == issuable.severity
|
|
|
|
|
|
|
|
params[:issuable_severity_attributes] = { severity: severity }
|
|
|
|
end
|
|
|
|
|
2021-12-20 18:13:27 +00:00
|
|
|
def filter_escalation_status(issuable)
|
2022-10-12 15:09:17 +00:00
|
|
|
status_params = params.delete(:escalation_status) || {}
|
|
|
|
status_params.permit! if status_params.respond_to?(:permit!)
|
|
|
|
|
2021-12-20 18:13:27 +00:00
|
|
|
result = ::IncidentManagement::IssuableEscalationStatuses::PrepareUpdateService.new(
|
|
|
|
issuable,
|
|
|
|
current_user,
|
2022-10-12 15:09:17 +00:00
|
|
|
status_params
|
2021-12-20 18:13:27 +00:00
|
|
|
).execute
|
|
|
|
|
2022-02-23 03:17:13 +00:00
|
|
|
return unless result.success? && result[:escalation_status].present?
|
2021-12-20 18:13:27 +00:00
|
|
|
|
|
|
|
params[:incident_management_issuable_escalation_status_attributes] = result[:escalation_status]
|
|
|
|
end
|
|
|
|
|
2019-04-02 10:48:20 +00:00
|
|
|
def process_label_ids(attributes, existing_label_ids: nil, extra_label_ids: [])
|
2016-08-09 17:26:45 +00:00
|
|
|
label_ids = attributes.delete(:label_ids)
|
|
|
|
add_label_ids = attributes.delete(:add_label_ids)
|
|
|
|
remove_label_ids = attributes.delete(:remove_label_ids)
|
2016-06-30 15:34:19 +00:00
|
|
|
|
2020-06-05 15:08:23 +00:00
|
|
|
new_label_ids = label_ids || existing_label_ids || []
|
2019-04-02 10:48:20 +00:00
|
|
|
new_label_ids |= extra_label_ids
|
2016-08-17 00:59:55 +00:00
|
|
|
|
2020-06-05 15:08:23 +00:00
|
|
|
new_label_ids |= add_label_ids if add_label_ids
|
|
|
|
new_label_ids -= remove_label_ids if remove_label_ids
|
2016-06-30 15:34:19 +00:00
|
|
|
|
2019-04-01 09:09:49 +00:00
|
|
|
new_label_ids.uniq
|
2016-06-30 15:34:19 +00:00
|
|
|
end
|
|
|
|
|
2021-03-16 09:11:17 +00:00
|
|
|
def process_assignee_ids(attributes, existing_assignee_ids: nil, extra_assignee_ids: [])
|
|
|
|
process = Issuable::ProcessAssignees.new(assignee_ids: attributes.delete(:assignee_ids),
|
|
|
|
add_assignee_ids: attributes.delete(:add_assignee_ids),
|
|
|
|
remove_assignee_ids: attributes.delete(:remove_assignee_ids),
|
|
|
|
existing_assignee_ids: existing_assignee_ids,
|
|
|
|
extra_assignee_ids: extra_assignee_ids)
|
|
|
|
process.execute
|
|
|
|
end
|
|
|
|
|
2020-06-29 15:08:56 +00:00
|
|
|
def handle_quick_actions(issuable)
|
2018-03-01 14:32:39 +00:00
|
|
|
merge_quick_actions_into_params!(issuable)
|
|
|
|
end
|
|
|
|
|
2018-11-07 12:33:42 +00:00
|
|
|
def merge_quick_actions_into_params!(issuable, only: nil)
|
2017-12-08 13:34:54 +00:00
|
|
|
original_description = params.fetch(:description, issuable.description)
|
|
|
|
|
2016-08-13 01:17:18 +00:00
|
|
|
description, command_params =
|
2020-06-29 15:08:56 +00:00
|
|
|
QuickActions::InterpretService.new(project, current_user, quick_action_options)
|
2018-11-07 12:33:42 +00:00
|
|
|
.execute(original_description, issuable, only: only)
|
2016-06-30 15:34:19 +00:00
|
|
|
|
2016-10-26 21:21:50 +00:00
|
|
|
# Avoid a description already set on an issuable to be overwritten by a nil
|
2020-06-29 15:08:56 +00:00
|
|
|
params[:description] = description if description && description != original_description
|
2016-08-13 01:17:18 +00:00
|
|
|
|
|
|
|
params.merge!(command_params)
|
2016-06-30 15:34:19 +00:00
|
|
|
end
|
|
|
|
|
2020-06-29 15:08:56 +00:00
|
|
|
def quick_action_options
|
|
|
|
{}
|
|
|
|
end
|
|
|
|
|
2020-09-08 21:08:53 +00:00
|
|
|
def create(issuable, skip_system_notes: false)
|
2020-06-29 15:08:56 +00:00
|
|
|
handle_quick_actions(issuable)
|
2016-12-14 21:39:53 +00:00
|
|
|
filter_params(issuable)
|
2016-04-29 16:38:07 +00:00
|
|
|
|
2016-08-17 00:59:55 +00:00
|
|
|
params.delete(:state_event)
|
|
|
|
params[:author] ||= current_user
|
2019-04-02 10:48:20 +00:00
|
|
|
params[:label_ids] = process_label_ids(params, extra_label_ids: issuable.label_ids.to_a)
|
2016-08-17 00:59:55 +00:00
|
|
|
|
2021-03-16 09:11:17 +00:00
|
|
|
if issuable.respond_to?(:assignee_ids)
|
|
|
|
params[:assignee_ids] = process_assignee_ids(params, extra_assignee_ids: issuable.assignee_ids.to_a)
|
|
|
|
end
|
|
|
|
|
2021-12-14 00:14:57 +00:00
|
|
|
params.delete(:remove_contacts)
|
|
|
|
add_crm_contact_emails = params.delete(:add_contacts)
|
|
|
|
|
2021-05-25 09:10:54 +00:00
|
|
|
issuable.assign_attributes(allowed_create_params(params))
|
2016-08-17 00:59:55 +00:00
|
|
|
|
|
|
|
before_create(issuable)
|
|
|
|
|
2019-12-10 15:07:52 +00:00
|
|
|
issuable_saved = issuable.with_transaction_returning_status do
|
2022-07-08 15:08:58 +00:00
|
|
|
transaction_create(issuable)
|
2019-12-10 15:07:52 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
if issuable_saved
|
2020-09-08 21:08:53 +00:00
|
|
|
create_system_notes(issuable, is_update: false) unless skip_system_notes
|
2021-05-25 09:10:54 +00:00
|
|
|
handle_changes(issuable, { params: params })
|
2018-12-17 04:35:59 +00:00
|
|
|
|
2016-08-17 00:59:55 +00:00
|
|
|
after_create(issuable)
|
2021-12-14 00:14:57 +00:00
|
|
|
set_crm_contacts(issuable, add_crm_contact_emails)
|
2016-06-30 15:34:19 +00:00
|
|
|
execute_hooks(issuable)
|
2021-01-11 18:10:43 +00:00
|
|
|
|
|
|
|
users_to_invalidate = issuable.allows_reviewers? ? issuable.assignees | issuable.reviewers : issuable.assignees
|
|
|
|
invalidate_cache_counts(issuable, users: users_to_invalidate)
|
2017-09-19 11:55:56 +00:00
|
|
|
issuable.update_project_counter_caches
|
2016-06-30 15:34:19 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
issuable
|
|
|
|
end
|
2016-04-29 16:38:07 +00:00
|
|
|
|
2021-12-14 00:14:57 +00:00
|
|
|
def set_crm_contacts(issuable, add_crm_contact_emails, remove_crm_contact_emails = [])
|
|
|
|
return unless add_crm_contact_emails.present? || remove_crm_contact_emails.present?
|
|
|
|
|
|
|
|
::Issues::SetCrmContactsService.new(project: project, current_user: current_user, params: { add_emails: add_crm_contact_emails, remove_emails: remove_crm_contact_emails }).execute(issuable)
|
|
|
|
end
|
|
|
|
|
2016-08-17 00:59:55 +00:00
|
|
|
def before_create(issuable)
|
|
|
|
# To be overridden by subclasses
|
|
|
|
end
|
|
|
|
|
|
|
|
def after_create(issuable)
|
|
|
|
# To be overridden by subclasses
|
|
|
|
end
|
2016-04-29 16:38:07 +00:00
|
|
|
|
2019-07-09 15:21:10 +00:00
|
|
|
def before_update(issuable, skip_spam_check: false)
|
2016-09-20 19:52:20 +00:00
|
|
|
# To be overridden by subclasses
|
|
|
|
end
|
|
|
|
|
2022-10-06 03:08:18 +00:00
|
|
|
def prepare_update_params(issuable)
|
|
|
|
# To be overridden by subclasses
|
|
|
|
end
|
|
|
|
|
2022-10-12 15:09:17 +00:00
|
|
|
def after_update(issuable, old_associations)
|
2022-10-05 03:09:43 +00:00
|
|
|
handle_description_updated(issuable)
|
2022-10-12 15:09:17 +00:00
|
|
|
handle_label_changes(issuable, old_associations[:labels])
|
2022-09-24 00:14:11 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def handle_description_updated(issuable)
|
|
|
|
return unless issuable.previous_changes.include?('description')
|
|
|
|
|
|
|
|
GraphqlTriggers.issuable_description_updated(issuable)
|
2016-04-21 10:20:05 +00:00
|
|
|
end
|
|
|
|
|
2015-11-17 11:42:43 +00:00
|
|
|
def update(issuable)
|
2022-10-06 03:08:18 +00:00
|
|
|
prepare_update_params(issuable)
|
2020-06-29 15:08:56 +00:00
|
|
|
handle_quick_actions(issuable)
|
|
|
|
filter_params(issuable)
|
|
|
|
|
2020-09-09 12:08:22 +00:00
|
|
|
change_additional_attributes(issuable)
|
2017-11-21 17:13:07 +00:00
|
|
|
old_associations = associations_before_update(issuable)
|
2015-11-17 11:42:43 +00:00
|
|
|
|
2021-02-01 09:09:28 +00:00
|
|
|
assign_requested_labels(issuable)
|
2021-03-16 09:11:17 +00:00
|
|
|
assign_requested_assignees(issuable)
|
2021-12-14 00:14:57 +00:00
|
|
|
assign_requested_crm_contacts(issuable)
|
2022-07-07 15:08:37 +00:00
|
|
|
widget_params = filter_widget_params
|
2016-08-17 00:59:55 +00:00
|
|
|
|
2022-07-07 15:08:37 +00:00
|
|
|
if issuable.changed? || params.present? || widget_params.present?
|
2021-05-25 09:10:54 +00:00
|
|
|
issuable.assign_attributes(allowed_update_params(params))
|
2017-02-14 19:07:11 +00:00
|
|
|
|
2022-09-15 18:10:36 +00:00
|
|
|
if issuable.description_changed?
|
2020-05-19 06:08:03 +00:00
|
|
|
issuable.assign_attributes(last_edited_at: Time.current, last_edited_by: current_user)
|
2017-05-03 05:32:21 +00:00
|
|
|
end
|
|
|
|
|
2017-02-14 19:07:11 +00:00
|
|
|
before_update(issuable)
|
2016-08-15 16:50:41 +00:00
|
|
|
|
2019-06-28 09:47:54 +00:00
|
|
|
# Do not touch when saving the issuable if only changes position within a list. We should call
|
|
|
|
# this method at this point to capture all possible changes.
|
|
|
|
should_touch = update_timestamp?(issuable)
|
|
|
|
|
|
|
|
issuable.updated_by = current_user if should_touch
|
2017-09-19 11:55:56 +00:00
|
|
|
# We have to perform this check before saving the issuable as Rails resets
|
|
|
|
# the changed fields upon calling #save.
|
2017-11-09 19:34:21 +00:00
|
|
|
update_project_counters = issuable.project && update_project_counter_caches?(issuable)
|
2019-09-04 16:19:31 +00:00
|
|
|
ensure_milestone_available(issuable)
|
2017-09-19 11:55:56 +00:00
|
|
|
|
2019-12-10 15:07:52 +00:00
|
|
|
issuable_saved = issuable.with_transaction_returning_status do
|
2022-07-07 15:08:37 +00:00
|
|
|
transaction_update(issuable, { save_with_touch: should_touch })
|
2019-12-10 15:07:52 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
if issuable_saved
|
2020-09-08 21:08:53 +00:00
|
|
|
create_system_notes(
|
|
|
|
issuable, old_labels: old_associations[:labels], old_milestone: old_associations[:milestone]
|
|
|
|
)
|
2017-02-14 19:07:11 +00:00
|
|
|
|
2021-05-25 09:10:54 +00:00
|
|
|
handle_changes(issuable, old_associations: old_associations, params: params)
|
2017-05-04 12:11:15 +00:00
|
|
|
|
2017-07-11 16:12:33 +00:00
|
|
|
new_assignees = issuable.assignees.to_a
|
2017-11-21 17:13:07 +00:00
|
|
|
affected_assignees = (old_associations[:assignees] + new_assignees) - (old_associations[:assignees] & new_assignees)
|
2017-05-10 20:54:10 +00:00
|
|
|
|
2017-08-31 11:21:39 +00:00
|
|
|
invalidate_cache_counts(issuable, users: affected_assignees.compact)
|
2022-10-12 15:09:17 +00:00
|
|
|
after_update(issuable, old_associations)
|
2017-02-14 19:07:11 +00:00
|
|
|
issuable.create_new_cross_references!(current_user)
|
2017-11-14 17:55:00 +00:00
|
|
|
execute_hooks(
|
|
|
|
issuable,
|
|
|
|
'update',
|
2017-11-21 17:13:07 +00:00
|
|
|
old_associations: old_associations
|
|
|
|
)
|
2017-09-19 11:55:56 +00:00
|
|
|
|
|
|
|
issuable.update_project_counter_caches if update_project_counters
|
2017-02-14 19:07:11 +00:00
|
|
|
end
|
2015-11-17 11:42:43 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
issuable
|
|
|
|
end
|
|
|
|
|
2022-07-07 15:08:37 +00:00
|
|
|
def transaction_update(issuable, opts = {})
|
|
|
|
touch = opts[:save_with_touch] || false
|
|
|
|
|
|
|
|
issuable.save(touch: touch)
|
|
|
|
end
|
|
|
|
|
2022-07-08 15:08:58 +00:00
|
|
|
def transaction_create(issuable)
|
|
|
|
issuable.save
|
|
|
|
end
|
|
|
|
|
2019-01-23 00:05:38 +00:00
|
|
|
def update_task(issuable)
|
|
|
|
filter_params(issuable)
|
2019-01-24 23:48:09 +00:00
|
|
|
|
2019-01-23 00:05:38 +00:00
|
|
|
if issuable.changed? || params.present?
|
2019-01-31 15:33:38 +00:00
|
|
|
issuable.assign_attributes(params.merge(updated_by: current_user,
|
2020-05-19 06:08:03 +00:00
|
|
|
last_edited_at: Time.current,
|
2019-01-31 15:33:38 +00:00
|
|
|
last_edited_by: current_user))
|
2019-01-23 00:05:38 +00:00
|
|
|
|
2019-07-09 15:21:10 +00:00
|
|
|
before_update(issuable, skip_spam_check: true)
|
2019-01-23 00:05:38 +00:00
|
|
|
|
|
|
|
if issuable.with_transaction_returning_status { issuable.save }
|
2020-09-08 21:08:53 +00:00
|
|
|
create_system_notes(issuable, old_labels: nil)
|
2019-01-23 00:05:38 +00:00
|
|
|
|
|
|
|
handle_task_changes(issuable)
|
|
|
|
invalidate_cache_counts(issuable, users: issuable.assignees.to_a)
|
2022-10-12 15:09:17 +00:00
|
|
|
# not passing old_associations here to keep `update_task` as fast as possible
|
|
|
|
after_update(issuable, {})
|
2019-01-25 15:41:21 +00:00
|
|
|
execute_hooks(issuable, 'update', old_associations: nil)
|
2021-02-15 15:08:59 +00:00
|
|
|
|
|
|
|
if issuable.is_a?(MergeRequest)
|
|
|
|
Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter
|
|
|
|
.track_task_item_status_changed(user: current_user)
|
|
|
|
end
|
2019-01-23 00:05:38 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
issuable
|
|
|
|
end
|
|
|
|
|
2019-01-24 23:48:09 +00:00
|
|
|
# Handle the `update_task` event sent from UI. Attempts to update a specific
|
|
|
|
# line in the markdown and cached html, bypassing any unnecessary updates or checks.
|
2019-01-29 16:46:04 +00:00
|
|
|
def update_task_event(issuable)
|
2019-01-24 23:48:09 +00:00
|
|
|
update_task_params = params.delete(:update_task)
|
|
|
|
return unless update_task_params
|
|
|
|
|
2019-01-29 19:11:04 +00:00
|
|
|
tasklist_toggler = TaskListToggleService.new(issuable.description, issuable.description_html,
|
|
|
|
line_source: update_task_params[:line_source],
|
2019-01-31 15:33:38 +00:00
|
|
|
line_number: update_task_params[:line_number].to_i,
|
2019-01-31 08:58:23 +00:00
|
|
|
toggle_as_checked: update_task_params[:checked])
|
2019-01-29 19:11:04 +00:00
|
|
|
|
2019-01-31 15:33:38 +00:00
|
|
|
unless tasklist_toggler.execute
|
2019-01-24 23:48:09 +00:00
|
|
|
# if we make it here, the data is much newer than we thought it was - fail fast
|
|
|
|
raise ActiveRecord::StaleObjectError
|
|
|
|
end
|
2019-01-31 15:33:38 +00:00
|
|
|
|
|
|
|
# by updating the description_html field at the same time,
|
|
|
|
# the markdown cache won't be considered invalid
|
|
|
|
params[:description] = tasklist_toggler.updated_markdown
|
|
|
|
params[:description_html] = tasklist_toggler.updated_markdown_html
|
|
|
|
|
|
|
|
# since we're updating a very specific line, we don't care whether
|
|
|
|
# the `lock_version` sent from the FE is the same or not. Just
|
|
|
|
# make sure the data hasn't changed since we queried it
|
|
|
|
params[:lock_version] = issuable.lock_version
|
|
|
|
|
|
|
|
update_task(issuable)
|
2019-01-24 23:48:09 +00:00
|
|
|
end
|
|
|
|
|
2020-09-09 12:08:22 +00:00
|
|
|
def change_additional_attributes(issuable)
|
|
|
|
change_state(issuable)
|
|
|
|
change_subscription(issuable)
|
|
|
|
change_todo(issuable)
|
|
|
|
toggle_award(issuable)
|
|
|
|
end
|
|
|
|
|
2015-11-17 11:42:43 +00:00
|
|
|
def change_state(issuable)
|
|
|
|
case params.delete(:state_event)
|
|
|
|
when 'reopen'
|
2021-05-12 03:10:21 +00:00
|
|
|
service_class = reopen_service
|
2015-11-17 11:42:43 +00:00
|
|
|
when 'close'
|
2021-05-12 03:10:21 +00:00
|
|
|
service_class = close_service
|
|
|
|
end
|
|
|
|
|
|
|
|
if service_class
|
|
|
|
service_class.new(**service_class.constructor_container_arg(project), current_user: current_user).execute(issuable)
|
2015-11-17 11:42:43 +00:00
|
|
|
end
|
|
|
|
end
|
2015-10-22 15:18:59 +00:00
|
|
|
|
2016-07-12 23:18:13 +00:00
|
|
|
def change_subscription(issuable)
|
|
|
|
case params.delete(:subscription_event)
|
|
|
|
when 'subscribe'
|
2016-11-04 18:19:08 +00:00
|
|
|
issuable.subscribe(current_user, project)
|
2016-07-12 23:18:13 +00:00
|
|
|
when 'unsubscribe'
|
2016-11-04 18:19:08 +00:00
|
|
|
issuable.unsubscribe(current_user, project)
|
2016-07-12 23:18:13 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-08-27 15:31:01 +00:00
|
|
|
# rubocop: disable CodeReuse/ActiveRecord
|
2016-06-30 15:34:19 +00:00
|
|
|
def change_todo(issuable)
|
|
|
|
case params.delete(:todo_event)
|
2016-08-09 20:47:29 +00:00
|
|
|
when 'add'
|
2016-06-30 15:34:19 +00:00
|
|
|
todo_service.mark_todo(issuable, current_user)
|
|
|
|
when 'done'
|
2017-12-11 14:21:06 +00:00
|
|
|
todo = TodosFinder.new(current_user).find_by(target: issuable)
|
2020-05-28 18:08:37 +00:00
|
|
|
todo_service.resolve_todo(todo, current_user) if todo
|
2016-06-30 15:34:19 +00:00
|
|
|
end
|
|
|
|
end
|
2018-08-27 15:31:01 +00:00
|
|
|
# rubocop: enable CodeReuse/ActiveRecord
|
2016-06-30 15:34:19 +00:00
|
|
|
|
2021-02-01 09:09:28 +00:00
|
|
|
def assign_requested_labels(issuable)
|
|
|
|
label_ids = process_label_ids(params, existing_label_ids: issuable.label_ids)
|
|
|
|
return unless ids_changing?(issuable.label_ids, label_ids)
|
|
|
|
|
|
|
|
params[:label_ids] = label_ids
|
|
|
|
issuable.touch
|
|
|
|
end
|
|
|
|
|
2021-12-14 00:14:57 +00:00
|
|
|
def assign_requested_crm_contacts(issuable)
|
|
|
|
add_crm_contact_emails = params.delete(:add_contacts)
|
|
|
|
remove_crm_contact_emails = params.delete(:remove_contacts)
|
|
|
|
set_crm_contacts(issuable, add_crm_contact_emails, remove_crm_contact_emails)
|
|
|
|
end
|
|
|
|
|
2021-03-16 09:11:17 +00:00
|
|
|
def assign_requested_assignees(issuable)
|
|
|
|
return if issuable.is_a?(Epic)
|
|
|
|
|
|
|
|
assignee_ids = process_assignee_ids(params, existing_assignee_ids: issuable.assignee_ids)
|
|
|
|
if ids_changing?(issuable.assignee_ids, assignee_ids)
|
|
|
|
params[:assignee_ids] = assignee_ids
|
|
|
|
issuable.touch
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-02-01 09:09:28 +00:00
|
|
|
# Arrays of ids are used, but we should really use sets of ids, so
|
|
|
|
# let's have an helper to properly check if some ids are changing
|
|
|
|
def ids_changing?(old_array, new_array)
|
|
|
|
old_array.sort != new_array.sort
|
|
|
|
end
|
|
|
|
|
2017-02-28 20:38:19 +00:00
|
|
|
def toggle_award(issuable)
|
|
|
|
award = params.delete(:emoji_award)
|
2019-06-18 01:44:43 +00:00
|
|
|
AwardEmojis::ToggleService.new(issuable, award, current_user).execute if award
|
2017-02-28 20:38:19 +00:00
|
|
|
end
|
|
|
|
|
2020-09-08 21:08:53 +00:00
|
|
|
def create_system_notes(issuable, **options)
|
2021-05-12 03:10:21 +00:00
|
|
|
Issuable::CommonSystemNotesService.new(project: project, current_user: current_user).execute(issuable, **options)
|
2020-09-08 21:08:53 +00:00
|
|
|
end
|
|
|
|
|
2017-11-21 17:13:07 +00:00
|
|
|
def associations_before_update(issuable)
|
|
|
|
associations =
|
|
|
|
{
|
|
|
|
labels: issuable.labels.to_a,
|
2019-10-29 00:06:10 +00:00
|
|
|
mentioned_users: issuable.mentioned_users(current_user).to_a,
|
2020-05-14 15:08:14 +00:00
|
|
|
assignees: issuable.assignees.to_a,
|
|
|
|
milestone: issuable.try(:milestone)
|
2017-11-21 17:13:07 +00:00
|
|
|
}
|
|
|
|
associations[:total_time_spent] = issuable.total_time_spent if issuable.respond_to?(:total_time_spent)
|
2021-06-11 09:09:58 +00:00
|
|
|
associations[:time_change] = issuable.time_change if issuable.respond_to?(:time_change)
|
2019-07-20 09:06:19 +00:00
|
|
|
associations[:description] = issuable.description
|
2020-09-21 12:09:34 +00:00
|
|
|
associations[:reviewers] = issuable.reviewers.to_a if issuable.allows_reviewers?
|
2021-07-01 18:07:29 +00:00
|
|
|
associations[:severity] = issuable.severity if issuable.supports_severity?
|
2022-02-23 03:17:13 +00:00
|
|
|
|
|
|
|
if issuable.supports_escalation? && issuable.escalation_status
|
|
|
|
associations[:escalation_status] = issuable.escalation_status.status_name
|
|
|
|
end
|
2017-11-21 17:13:07 +00:00
|
|
|
|
|
|
|
associations
|
|
|
|
end
|
|
|
|
|
2021-03-23 12:09:33 +00:00
|
|
|
def handle_move_between_ids(issuable_position)
|
|
|
|
return unless params[:move_between_ids]
|
|
|
|
|
2022-02-09 18:16:19 +00:00
|
|
|
before_id, after_id = params.delete(:move_between_ids)
|
2021-03-23 12:09:33 +00:00
|
|
|
|
2022-02-04 15:15:34 +00:00
|
|
|
positioning_scope = issuable_position.class.relative_positioning_query_base(issuable_position)
|
|
|
|
|
|
|
|
issuable_before = issuable_for_positioning(before_id, positioning_scope)
|
|
|
|
issuable_after = issuable_for_positioning(after_id, positioning_scope)
|
2021-03-23 12:09:33 +00:00
|
|
|
|
|
|
|
raise ActiveRecord::RecordNotFound unless issuable_before || issuable_after
|
|
|
|
|
|
|
|
issuable_position.move_between(issuable_before, issuable_after)
|
|
|
|
end
|
|
|
|
|
2020-09-09 12:08:22 +00:00
|
|
|
def has_changes?(issuable, old_labels: [], old_assignees: [], old_reviewers: [])
|
|
|
|
valid_attrs = [:title, :description, :assignee_ids, :reviewer_ids, :milestone_id, :target_branch]
|
2016-02-17 16:33:30 +00:00
|
|
|
|
|
|
|
attrs_changed = valid_attrs.any? do |attr|
|
|
|
|
issuable.previous_changes.include?(attr.to_s)
|
|
|
|
end
|
|
|
|
|
2016-03-01 16:33:13 +00:00
|
|
|
labels_changed = issuable.labels != old_labels
|
2016-02-17 16:33:30 +00:00
|
|
|
|
2017-05-04 12:11:15 +00:00
|
|
|
assignees_changed = issuable.assignees != old_assignees
|
|
|
|
|
2020-09-09 12:08:22 +00:00
|
|
|
reviewers_changed = issuable.reviewers != old_reviewers if issuable.allows_reviewers?
|
|
|
|
|
|
|
|
attrs_changed || labels_changed || assignees_changed || reviewers_changed
|
2016-02-17 16:33:30 +00:00
|
|
|
end
|
|
|
|
|
2022-04-01 18:08:46 +00:00
|
|
|
def has_label_changes?(issuable, old_labels)
|
2022-10-12 15:09:17 +00:00
|
|
|
return false if old_labels.nil?
|
|
|
|
|
2022-04-01 18:08:46 +00:00
|
|
|
Set.new(issuable.labels) != Set.new(old_labels)
|
|
|
|
end
|
|
|
|
|
2017-08-31 11:21:39 +00:00
|
|
|
def invalidate_cache_counts(issuable, users: [])
|
2017-05-15 12:04:09 +00:00
|
|
|
users.each do |user|
|
2022-02-01 00:14:06 +00:00
|
|
|
user.public_send("invalidate_#{issuable.noteable_target_type_name}_cache_counts") # rubocop:disable GitlabSecurity/PublicSend
|
2017-05-15 12:04:09 +00:00
|
|
|
end
|
|
|
|
end
|
2017-11-01 17:35:14 +00:00
|
|
|
|
2022-04-01 18:08:46 +00:00
|
|
|
# override if needed
|
|
|
|
def handle_label_changes(issuable, old_labels)
|
2022-10-12 15:09:17 +00:00
|
|
|
return false unless has_label_changes?(issuable, old_labels)
|
2022-04-01 18:08:46 +00:00
|
|
|
|
2022-04-06 06:08:32 +00:00
|
|
|
# reset to preserve the label sort order (title ASC)
|
|
|
|
issuable.labels.reset
|
|
|
|
|
2022-04-01 18:08:46 +00:00
|
|
|
GraphqlTriggers.issuable_labels_updated(issuable)
|
2022-10-12 15:09:17 +00:00
|
|
|
|
|
|
|
# return true here to avoid checking for label changes in sub classes
|
|
|
|
true
|
2022-04-01 18:08:46 +00:00
|
|
|
end
|
|
|
|
|
2017-11-01 17:35:14 +00:00
|
|
|
# override if needed
|
|
|
|
def handle_changes(issuable, options)
|
|
|
|
end
|
|
|
|
|
2019-01-23 00:05:38 +00:00
|
|
|
# override if needed
|
|
|
|
def handle_task_changes(issuable)
|
|
|
|
end
|
|
|
|
|
2017-11-01 17:35:14 +00:00
|
|
|
# override if needed
|
|
|
|
def execute_hooks(issuable, action = 'open', params = {})
|
|
|
|
end
|
2017-11-09 19:34:21 +00:00
|
|
|
|
|
|
|
def update_project_counter_caches?(issuable)
|
2019-11-19 12:06:00 +00:00
|
|
|
issuable.state_id_changed?
|
2017-11-09 19:34:21 +00:00
|
|
|
end
|
2018-02-26 16:23:19 +00:00
|
|
|
|
|
|
|
def parent
|
|
|
|
project
|
|
|
|
end
|
2019-01-14 10:46:39 +00:00
|
|
|
|
|
|
|
# we need to check this because milestone from milestone_id param is displayed on "new" page
|
|
|
|
# where private project milestone could leak without this check
|
|
|
|
def ensure_milestone_available(issuable)
|
2021-04-08 18:09:32 +00:00
|
|
|
return unless issuable.supports_milestone? && issuable.milestone_id.present?
|
|
|
|
|
2019-01-14 10:46:39 +00:00
|
|
|
issuable.milestone_id = nil unless issuable.milestone_available?
|
|
|
|
end
|
2019-06-28 09:47:54 +00:00
|
|
|
|
|
|
|
def update_timestamp?(issuable)
|
|
|
|
issuable.changes.keys != ["relative_position"]
|
|
|
|
end
|
2021-05-25 09:10:54 +00:00
|
|
|
|
|
|
|
def allowed_create_params(params)
|
|
|
|
params
|
|
|
|
end
|
|
|
|
|
|
|
|
def allowed_update_params(params)
|
|
|
|
params
|
|
|
|
end
|
2021-08-05 15:09:46 +00:00
|
|
|
|
|
|
|
def update_issuable_sla(issuable)
|
|
|
|
return unless issuable_sla = issuable.issuable_sla
|
|
|
|
|
|
|
|
issuable_sla.update(issuable_closed: issuable.closed?)
|
|
|
|
end
|
2022-07-07 15:08:37 +00:00
|
|
|
|
|
|
|
def filter_widget_params
|
|
|
|
params.delete(:widget_params)
|
|
|
|
end
|
2014-10-07 14:09:28 +00:00
|
|
|
end
|
2019-09-13 13:26:31 +00:00
|
|
|
|
2021-05-11 21:10:21 +00:00
|
|
|
IssuableBaseService.prepend_mod_with('IssuableBaseService')
|