Class: TodoService

Inherits:
Object
  • Object
show all
Includes:
Gitlab::Utils::UsageData
Defined in:
app/services/todo_service.rb

Overview

TodoService class

Used for creating/updating todos after certain user actions

Ex.

TodoService.new.new_issue(issue, current_user)

Constant Summary collapse

BATCH_SIZE = 
100

Constants included from Gitlab::Utils::UsageData

Gitlab::Utils::UsageData::DISTRIBUTED_HLL_FALLBACK, Gitlab::Utils::UsageData::FALLBACK, Gitlab::Utils::UsageData::HISTOGRAM_FALLBACK, Gitlab::Utils::UsageData::MAX_BUCKET_SIZE

Instance Method Summary collapse

Methods included from Gitlab::Utils::UsageData

#add, #add_metric, #alt_usage_data, #average, #count, #distinct_count, #estimate_batch_distinct_count, #histogram, #maximum_id, #measure_duration, #metrics_collection_metadata, #minimum_id, #redis_usage_data, #sum, #track_usage_event, #with_finished_at, #with_metadata, #with_prometheus_client

Instance Method Details

#close_issue(issue, current_user) ⇒ Object

When close an issue we should:

* mark all pending todos related to the target for the current user as done



36
37
38
 
# File 'app/services/todo_service.rb', line 36

def close_issue(issue, current_user)
  resolve_todos_for_target(issue, current_user)
end

#close_merge_request(merge_request, current_user) ⇒ Object

When close a merge request we should:

* mark all pending todos related to the target for the current user as done



93
94
95
 
# File 'app/services/todo_service.rb', line 93

def close_merge_request(merge_request, current_user)
  resolve_todos_for_target(merge_request, current_user)
end

#create_member_access_request_todos(member) ⇒ Object 



283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
 
# File 'app/services/todo_service.rb', line 283

def create_member_access_request_todos(member)
  source = member.source
  attributes = attributes_for_access_request_todos(source, member.user, Todo::MEMBER_ACCESS_REQUESTED)

  approvers = source.access_request_approvers_to_be_notified.map(&:user)
  return true if approvers.empty?

  if source.instance_of? Project
    project = source
    namespace = project.namespace
  else
    project = nil
    namespace = source
  end

  create_todos(approvers, attributes, namespace, project)
end

#create_request_review_todo(target, author, reviewers) ⇒ Object 



277
278
279
280
281
 
# File 'app/services/todo_service.rb', line 277

def create_request_review_todo(target, author, reviewers)
  project = target.project
  attributes = attributes_for_todo(project, target, author, Todo::REVIEW_REQUESTED)
  create_todos(reviewers, attributes, project.namespace, project)
end

#create_review_submitted_todo(target, review_author) ⇒ Object 



301
302
303
304
305
306
307
 
# File 'app/services/todo_service.rb', line 301

def create_review_submitted_todo(target, review_author)
  users = (target.assignees | [target.author]).reject { |u| u.id == review_author.id }
  project = target.project
  attributes = attributes_for_todo(project, target, review_author, Todo::REVIEW_SUBMITTED)

  create_todos(users, attributes, project.namespace, project)
end

#destroy_target(target) {|target| ... } ⇒ Object

When we destroy a todo target we should:

* refresh the todos count cache for all users with todos on the target

This needs to yield back to the caller to destroy the target, because it collects the todo users before the todos themselves are deleted, then updates the todo counts for those users.

Yields:

  • (target) 


48
49
50
51
52
53
54
 
# File 'app/services/todo_service.rb', line 48

def destroy_target(target)
  todo_user_ids = target.todos.distinct_user_ids

  yield target

  Users::UpdateTodoCountCacheService.new(todo_user_ids).execute if todo_user_ids.present?
end

#mark_todo(target, current_user) ⇒ Object

When user marks a target as todo



204
205
206
207
208
209
210
211
212
 
# File 'app/services/todo_service.rb', line 204

def mark_todo(target, current_user)
  project = target.project
  attributes = attributes_for_todo(project, target, current_user, Todo::MARKED)

  todos = create_todos(current_user, attributes, target_namespace(target), project)
  work_item_activity_counter.track_work_item_mark_todo_action(author: current_user) if target.is_a?(WorkItem)

  todos
end

#merge_merge_request(merge_request, current_user) ⇒ Object

When merge a merge request we should:

* mark all pending todos related to the target for the current user as done



101
102
103
 
# File 'app/services/todo_service.rb', line 101

def merge_merge_request(merge_request, current_user)
  resolve_todos_for_target(merge_request, current_user)
end

#merge_request_became_unmergeable(merge_request) ⇒ Object

When a merge request could not be merged due to its unmergeable state we should:

* create a todo for each merge participant



137
138
139
140
141
 
# File 'app/services/todo_service.rb', line 137

def merge_request_became_unmergeable(merge_request)
  merge_request.merge_participants.each do |user|
    create_unmergeable_todo(merge_request, user)
  end
end

#merge_request_build_failed(merge_request) ⇒ Object

When a build fails on the HEAD of a merge request we should:

* create a todo for each merge participant



109
110
111
112
113
 
# File 'app/services/todo_service.rb', line 109

def merge_request_build_failed(merge_request)
  merge_request.merge_participants.each do |user|
    create_build_failed_todo(merge_request, user)
  end
end

#merge_request_build_retried(merge_request) ⇒ Object

When a build is retried to a merge request we should:

* mark all pending todos related to the merge request as done for each merge participant



127
128
129
130
131
 
# File 'app/services/todo_service.rb', line 127

def merge_request_build_retried(merge_request)
  merge_request.merge_participants.each do |user|
    resolve_todos_for_target(merge_request, user)
  end
end

#merge_request_push(merge_request, current_user) ⇒ Object

When a new commit is pushed to a merge request we should:

* mark all pending todos related to the merge request for that user as done



119
120
121
 
# File 'app/services/todo_service.rb', line 119

def merge_request_push(merge_request, current_user)
  resolve_todos_for_target(merge_request, current_user)
end

#new_award_emoji(awardable, current_user) ⇒ Object

When an emoji is awarded we should:

* mark all pending todos related to the awardable for the current user as done



165
166
167
 
# File 'app/services/todo_service.rb', line 165

def new_award_emoji(awardable, current_user)
  resolve_todos_for_target(awardable, current_user)
end

#new_issue(issue, current_user) ⇒ Object

When create an issue we should:

* create a todo for assignee if issue is assigned
* create a todo for each mentioned user on issue



20
21
22
 
# File 'app/services/todo_service.rb', line 20

def new_issue(issue, current_user)
  new_issuable(issue, current_user)
end

#new_merge_request(merge_request, current_user) ⇒ Object

When create a merge request we should:

* creates a pending todo for assignee if merge request is assigned
* create a todo for each mentioned user on merge request



77
78
79
 
# File 'app/services/todo_service.rb', line 77

def new_merge_request(merge_request, current_user)
  new_issuable(merge_request, current_user)
end

#new_note(note, current_user) ⇒ Object

When create a note we should:

* mark all pending todos related to the noteable for the note author as done
* create a todo for each mentioned user on note



148
149
150
 
# File 'app/services/todo_service.rb', line 148

def new_note(note, current_user)
  handle_note(note, current_user)
end

#new_review(merge_request, current_user) ⇒ Object

When a merge request receives a review

* Mark all outstanding todos on this MR for the current user as done



196
197
198
199
200
201
 
# File 'app/services/todo_service.rb', line 196

def new_review(merge_request, current_user)
  resolve_todos_for_target(merge_request, current_user)

  # Create a new todo for assignees and author
  create_review_submitted_todo(merge_request, current_user)
end

#reassigned_assignable(issuable, current_user, old_assignees = []) ⇒ Object

When we reassign an assignable object (issuable, alert) we should:

* create a pending todo for new assignee if object is assigned



60
61
62
 
# File 'app/services/todo_service.rb', line 60

def reassigned_assignable(issuable, current_user, old_assignees = [])
  create_assignment_todo(issuable, current_user, old_assignees)
end

#reassigned_reviewable(issuable, current_user, old_reviewers = []) ⇒ Object

When we reassign an reviewable object (merge request) we should:

* create a pending todo for new reviewer if object is assigned



68
69
70
 
# File 'app/services/todo_service.rb', line 68

def reassigned_reviewable(issuable, current_user, old_reviewers = [])
  create_reviewer_todo(issuable, current_user, old_reviewers)
end

#resolve_access_request_todos(member) ⇒ Object 



245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'app/services/todo_service.rb', line 245

def resolve_access_request_todos(member)
  return if member.nil?

  # Group or Project
  target = member.source

  todos_params = {
    state: :pending,
    author_id: member.user_id,
    action: ::Todo::MEMBER_ACCESS_REQUESTED,
    type: target.class.polymorphic_name
  }

  resolve_todos_with_attributes_for_target(target, todos_params)
end

#resolve_todo(todo, current_user, resolution: :done, resolved_by_action: :system_done) ⇒ Object 



235
236
237
238
239
240
241
242
243
 
# File 'app/services/todo_service.rb', line 235

def resolve_todo(todo, current_user, resolution: :done, resolved_by_action: :system_done)
  return if todo.done?

  todo.update(state: resolution, resolved_by_action: resolved_by_action, snoozed_until: nil)

  GraphqlTriggers.issuable_todo_updated(todo.target)

  current_user.update_todos_count_cache
end

#resolve_todos(todos, current_user, resolution: :done, resolved_by_action: :system_done) ⇒ Object 



227
228
229
230
231
232
233
 
# File 'app/services/todo_service.rb', line 227

def resolve_todos(todos, current_user, resolution: :done, resolved_by_action: :system_done)
  todos_ids = todos.batch_update(state: resolution, resolved_by_action: resolved_by_action, snoozed_until: nil)

  current_user.update_todos_count_cache

  todos_ids
end

#resolve_todos_for_target(target, current_user) ⇒ Object

Resolves all todos related to target for the current_user



219
220
221
222
223
224
225
 
# File 'app/services/todo_service.rb', line 219

def resolve_todos_for_target(target, current_user)
  attributes = attributes_for_target(target)

  resolve_todos(pending_todos([current_user], attributes), current_user)

  GraphqlTriggers.issuable_todo_updated(target)
end

#restore_todo(todo, current_user) ⇒ Object 



269
270
271
272
273
274
275
 
# File 'app/services/todo_service.rb', line 269

def restore_todo(todo, current_user)
  return if todo.pending?

  todo.update(state: :pending)

  current_user.update_todos_count_cache
end

#restore_todos(todos, current_user) ⇒ Object 



261
262
263
264
265
266
267
 
# File 'app/services/todo_service.rb', line 261

def restore_todos(todos, current_user)
  todos_ids = todos.batch_update(state: :pending)

  current_user.update_todos_count_cache

  todos_ids
end

#ssh_key_expired(ssh_keys) ⇒ Object

When a SSH key expired we should:

  • resolve any corresponding “expiring soon” todo

  • create a todo for the user owning that SSH key



182
183
184
185
186
187
188
189
190
 
# File 'app/services/todo_service.rb', line 182

def ssh_key_expired(ssh_keys)
  ssh_keys = Array(ssh_keys)

  # Resolve any pending "expiring soon" todos for these keys
  expiring_key_todos = ::Todo.pending_for_expiring_ssh_keys(ssh_keys.map(&:id))
  expiring_key_todos.batch_update(state: :done, resolved_by_action: :system_done)

  create_ssh_key_todos(ssh_keys, ::Todo::SSH_KEY_EXPIRED)
end

#ssh_key_expiring_soon(ssh_keys) ⇒ Object

When a SSH key is expiring soon we should:

  • create a todo for the user owning that SSH key



173
174
175
 
# File 'app/services/todo_service.rb', line 173

def ssh_key_expiring_soon(ssh_keys)
  create_ssh_key_todos(Array(ssh_keys), ::Todo::SSH_KEY_EXPIRING_SOON)
end

#todo_exist?(issuable, current_user) ⇒ Boolean

Returns:

  • (Boolean) 


214
215
216
 
# File 'app/services/todo_service.rb', line 214

def todo_exist?(issuable, current_user)
  current_user.todos.any_for_target?(issuable, :pending)
end

#update_issue(issue, current_user, skip_users = []) ⇒ Object

When update an issue we should:

* mark all pending todos related to the issue for the current user as done



28
29
30
 
# File 'app/services/todo_service.rb', line 28

def update_issue(issue, current_user, skip_users = [])
  update_issuable(issue, current_user, skip_users)
end

#update_merge_request(merge_request, current_user, skip_users = []) ⇒ Object

When update a merge request we should:

* create a todo for each mentioned user on merge request



85
86
87
 
# File 'app/services/todo_service.rb', line 85

def update_merge_request(merge_request, current_user, skip_users = [])
  update_issuable(merge_request, current_user, skip_users)
end

#update_note(note, current_user, skip_users = []) ⇒ Object

When update a note we should:

* mark all pending todos related to the noteable for the current user as done
* create a todo for each new user mentioned on note



157
158
159
 
# File 'app/services/todo_service.rb', line 157

def update_note(note, current_user, skip_users = [])
  handle_note(note, current_user, skip_users)
end