Class: Note

Inherits:
ApplicationRecord show all
Extended by:
ActiveModel::Naming, Gitlab::Utils::Override
Includes:
AfterCommitQueue, Awardable, CacheMarkdownField, EachBatch, Editable, FasterCacheKeys, FromUnion, Gitlab::SQL::Pattern, Gitlab::Utils::StrongMemoize, Import::HasImportSource, Importable, Mentionable, Notes::ActiveRecord, Notes::Discussion, Participable, Redactable, ResolvableNote, Sortable, Spammable, ThrottledTouch
Defined in:
app/models/note.rb

Overview

A note on the root of an issue, merge request, commit, or snippet.

A note of this type is never resolvable.

Constant Summary collapse

TYPES_RESTRICTED_BY_PROJECT_ABILITY = 
{
  branch: :download_code
}.freeze
TYPES_RESTRICTED_BY_GROUP_ABILITY = 
{
  contact: :read_crm_contact
}.freeze
NON_DIFF_NOTE_TYPES = 
['Note', 'DiscussionNote', nil].freeze

Constants included from ThrottledTouch

ThrottledTouch::TOUCH_INTERVAL

Constants included from Gitlab::SQL::Pattern

Gitlab::SQL::Pattern::MIN_CHARS_FOR_PARTIAL_MATCHING, Gitlab::SQL::Pattern::REGEX_QUOTED_TERM

Constants included from ResolvableNote

ResolvableNote::RESOLVABLE_TYPES

Constants included from CacheMarkdownField

CacheMarkdownField::INVALIDATED_BY

Constants included from Redactable

Redactable::UNSUBSCRIBE_PATTERN

Constants included from Import::HasImportSource

Import::HasImportSource::IMPORT_SOURCES

Constants inherited from ApplicationRecord

ApplicationRecord::MAX_PLUCK

Constants included from HasCheckConstraints

HasCheckConstraints::NOT_NULL_CHECK_PATTERN

Constants included from ResetOnColumnErrors

ResetOnColumnErrors::MAX_RESET_PERIOD

Instance Attribute Summary collapse

Attributes included from CacheMarkdownField

#skip_markdown_cache_validation

Attributes included from Importable

#importing, #user_contributions

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Gitlab::Utils::Override

extended, extensions, included, method_added, override, prepended, queue_verification, verify!

Methods included from Spammable

#allow_possible_spam?, #check_for_spam, #clear_spam_flags!, #invalidate_if_spam, #needs_recaptcha!, #recaptcha_error!, #render_recaptcha?, #spam, #spam!, #spam_description, #spam_title, #spammable_attribute_changed?, #spammable_entity_type, #spammable_text, #submittable_as_spam?, #submittable_as_spam_by?, #supports_recaptcha?, #unrecoverable_spam_error!

Methods included from Gitlab::SQL::Pattern

split_query_to_search_terms

Methods included from Editable

#last_edited_by

Methods included from ResolvableNote

#potentially_resolvable?, #resolvable?, #resolve!, #resolve_without_save, #resolved?, #to_be_resolved?, #unresolve!, #unresolve_without_save

Methods included from AfterCommitQueue

#run_after_commit, #run_after_commit_or_now

Methods included from CacheMarkdownField

#attribute_invalidated?, #cached_html_for, #cached_html_up_to_date?, #can_cache_field?, #invalidated_markdown_cache?, #latest_cached_markdown_version, #mentionable_attributes_changed?, #refresh_markdown_cache, #refresh_markdown_cache!, #rendered_field_content, #store_mentions!, #store_mentions?, #store_mentions_after_commit?, #updated_cached_html_for

Methods included from FasterCacheKeys

#cache_key

Methods included from Import::HasImportSource

#imported?

Methods included from Awardable

#awarded_emoji?, #downvotes, #grouped_awards, #upvotes, #user_authored?, #user_can_award?

Methods included from Mentionable

#all_references, #create_cross_references!, #create_new_cross_references!, #directly_addressed_users, #extractors, #gfm_reference, #local_reference, #matches_cross_reference_regex?, #referenced_group_users, #referenced_groups, #referenced_mentionables, #referenced_project_users, #referenced_projects, #referenced_users

Methods included from Participable

#participant?, #participants, #visible_participants

Methods included from Notes::Discussion

#derive_discussion_id, #discussion, #discussion=, #discussion_class, #discussion_id, #ensure_discussion_id, #in_reply_to?, #part_of_discussion?, #start_of_discussion?, #to_discussion

Methods included from Notes::ActiveRecord

#last_edited_by

Methods inherited from ApplicationRecord

===, cached_column_list, #create_or_load_association, current_transaction, declarative_enum, default_select_columns, delete_all_returning, #deleted_from_database?, id_in, id_not_in, iid_in, nullable_column?, primary_key_in, #readable_by?, safe_ensure_unique, safe_find_or_create_by, safe_find_or_create_by!, #to_ability_name, underscore, where_exists, where_not_exists, with_fast_read_statement_timeout, without_order

Methods included from ResetOnColumnErrors

#reset_on_union_error, #reset_on_unknown_attribute_error

Methods included from Gitlab::SensitiveSerializableHash

#serializable_hash

Instance Attribute Details

#commands_changes ⇒ Object 



671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
 
# File 'app/models/note.rb', line 671

def commands_changes
  @commands_changes&.slice(
    :due_date,
    :label_ids,
    :remove_label_ids,
    :add_label_ids,
    :canonical_issue_id,
    :clone_with_notes,
    :confidential,
    :create_merge_request,
    :add_contacts,
    :remove_contacts,
    :assignee_ids,
    :milestone_id,
    :time_estimate,
    :spend_time,
    :discussion_locked,
    :merge,
    :rebase,
    :wip_event,
    :target_branch,
    :reviewer_ids,
    :health_status,
    :promote_to_epic,
    :weight,
    :emoji_award,
    :todo_event,
    :subscription_event,
    :state_event,
    :title,
    :tag_message,
    :tag_name
  )
end

#quick_actions_status ⇒ Object

Attribute used to store the status of quick actions.



60
61
62
 
# File 'app/models/note.rb', line 60

def quick_actions_status
  @quick_actions_status
end

#redacted_note_html ⇒ Object

Attribute containing rendered and redacted Markdown as generated by Banzai::ObjectRenderer.



48
49
50
 
# File 'app/models/note.rb', line 48

def redacted_note_html
  @redacted_note_html
end

#skip_keep_around_commits ⇒ Object

Attribute used to determine whether keep_around_commits will be skipped for diff notes.



63
64
65
 
# File 'app/models/note.rb', line 63

def skip_keep_around_commits
  @skip_keep_around_commits
end

#skip_touch_noteable ⇒ Object

Attribute used to skip updates of ‘updated_at` for the noteable when it could impact database health.



66
67
68
 
# File 'app/models/note.rb', line 66

def skip_touch_noteable
  @skip_touch_noteable
end

#total_reference_count ⇒ Object

Total of all references as generated by Banzai::ObjectRenderer



51
52
53
 
# File 'app/models/note.rb', line 51

def total_reference_count
  @total_reference_count
end

#user_visible_reference_count ⇒ Object

Number of user visible references as generated by Banzai::ObjectRenderer



54
55
56
 
# File 'app/models/note.rb', line 54

def user_visible_reference_count
  @user_visible_reference_count
end

Class Method Details

.cherry_picked_merge_requests(shas) ⇒ Object 



311
312
313
 
# File 'app/models/note.rb', line 311

def cherry_picked_merge_requests(shas)
  where(noteable_type: 'MergeRequest', commit_id: shas).select(:noteable_id)
end

.count_for_collection(ids, type, count_column = 'COUNT(*) as count') ⇒ Object 



294
295
296
297
298
 
# File 'app/models/note.rb', line 294

def count_for_collection(ids, type, count_column = 'COUNT(*) as count')
  user.select(:noteable_id, count_column)
    .group(:noteable_id)
    .where(noteable_type: type, noteable_id: ids)
end

.grouped_diff_discussions(diff_refs = nil) ⇒ Object

Group diff discussions by line code or file path. It is not needed to group by line code when comment is on an image.



268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'app/models/note.rb', line 268

def grouped_diff_discussions(diff_refs = nil)
  groups = {}

  diff_notes.order_created_at_id_asc.discussions.each do |discussion|
    group_key =
      if discussion.on_image?
        discussion.file_new_path
      else
        discussion.line_code_in_diffs(diff_refs)
      end

    if group_key
      discussions = groups[group_key] ||= []
      discussions << discussion
    end
  end

  groups
end

.model_name ⇒ Object 



257
258
259
 
# File 'app/models/note.rb', line 257

def model_name
  ActiveModel::Name.new(self, nil, 'note')
end

.parent_object_field ⇒ Object 



261
262
263
 
# File 'app/models/note.rb', line 261

def parent_object_field
  :noteable
end

.positions ⇒ Object 



288
289
290
291
292
 
# File 'app/models/note.rb', line 288

def positions
  where.not(position: nil)
    .select(:id, :type, :position) # ActiveRecord needs id and type for typecasting.
    .map(&:position)
end

.search(query) ⇒ Object 



300
301
302
 
# File 'app/models/note.rb', line 300

def search(query)
  fuzzy_search(query, [:note])
end

.simple_sorts ⇒ Object 



307
308
309
 
# File 'app/models/note.rb', line 307

def simple_sorts
  super.except('name_asc', 'name_desc')
end

.with_web_entity_associations ⇒ Object 



315
316
317
 
# File 'app/models/note.rb', line 315

def with_web_entity_associations
  preload(:project, :author, :noteable)
end

Instance Method Details

#active? ⇒ Boolean

Returns:

  • (Boolean) 


336
337
338
 
# File 'app/models/note.rb', line 336

def active?
  true
end

#attribute_names_for_serialization ⇒ Object

Use attributes.keys instead of attribute_names to filter out the fields that are skipped during export:

  • note_html

  • cached_markdown_version



749
750
751
 
# File 'app/models/note.rb', line 749

def attribute_names_for_serialization
  attributes.keys
end

#award_emoji? ⇒ Boolean

Returns:

  • (Boolean) 


489
490
491
 
# File 'app/models/note.rb', line 489

def award_emoji?
  can_be_award_emoji? && contains_emoji_only?
end

#banzai_render_context(field) ⇒ Object 



603
604
605
606
607
608
 
# File 'app/models/note.rb', line 603

def banzai_render_context(field)
  additional_attributes = { noteable: noteable, system_note: system?, label_url_method: noteable_label_url_method }
  additional_attributes[:group] = namespace if namespace.is_a?(Group)

  super.merge(additional_attributes)
end

#broadcast_noteable_notes_changed ⇒ Object 



555
556
557
 
# File 'app/models/note.rb', line 555

def broadcast_noteable_notes_changed
  noteable&.broadcast_notes_changed
end

#bump_updated_at ⇒ Object 



540
541
542
543
544
545
546
547
548
549
550
551
552
553
 
# File 'app/models/note.rb', line 540

def bump_updated_at
  # Instead of calling touch which is throttled via ThrottledTouch concern,
  # we bump the updated_at column directly. This also prevents executing
  # after_commit callbacks that we don't need.
  attributes_to_update = { updated_at: Time.current }

  # Notes that were edited before the `last_edited_at` column was added, fall back to `updated_at` for the edit time.
  # We copy this over to the correct column so we don't erroneously change the edit timestamp.
  if updated_by_id.present? && read_attribute(:last_edited_at).blank?
    attributes_to_update[:last_edited_at] = updated_at
  end

  update_columns(attributes_to_update)
end

#can_be_award_emoji? ⇒ Boolean

Returns:

  • (Boolean) 


497
498
499
 
# File 'app/models/note.rb', line 497

def can_be_award_emoji?
  noteable.is_a?(Awardable) && !part_of_discussion?
end

#can_be_discussion_note? ⇒ Boolean

Returns:

  • (Boolean) 


521
522
523
 
# File 'app/models/note.rb', line 521

def can_be_discussion_note?
  self.noteable.supports_discussions? && !part_of_discussion? && !system?
end

#can_create_todo? ⇒ Boolean

Returns:

  • (Boolean) 


525
526
527
528
 
# File 'app/models/note.rb', line 525

def can_create_todo?
  # Skip system notes, and notes on snippets
  !system? && !for_snippet?
end

#check_for_spam? ⇒ Boolean

Override method defined in Spammable Wildcard argument because user: argument is not used

Returns:

  • (Boolean) 


737
738
739
740
741
742
743
 
# File 'app/models/note.rb', line 737

def check_for_spam?(*)
  return false if system? || !spammable_attribute_changed? || confidential?
  return false if noteable.try(:confidential?) == true || noteable.try(:public?) == false
  return false if noteable.try(:group)&.public? == false || project&.public? == false

  true
end

#commit ⇒ Object 



416
417
418
 
# File 'app/models/note.rb', line 416

def commit
  @commit ||= project.commit(commit_id) if commit_id.present?
end

#confidential?(include_noteable: false) ⇒ Boolean

Returns:

  • (Boolean) 


465
466
467
468
469
 
# File 'app/models/note.rb', line 465

def confidential?(include_noteable: false)
  return true if confidential

  include_noteable && noteable.try(:confidential?)
end

#contains_emoji_only? ⇒ Boolean

Returns:

  • (Boolean) 


501
502
503
 
# File 'app/models/note.rb', line 501

def contains_emoji_only?
  note =~ /\A#{Banzai::Filter::EmojiFilter.emoji_pattern}\s?\Z/
end

#contributor? ⇒ Boolean

Returns:

  • (Boolean) 


448
449
450
 
# File 'app/models/note.rb', line 448

def contributor?
  project&.team&.contributor?(self.author_id)
end

#diff_note? ⇒ Boolean

rubocop: enable CodeReuse/ServiceClass

Returns:

  • (Boolean) 


332
333
334
 
# File 'app/models/note.rb', line 332

def diff_note?
  false
end

#editable? ⇒ Boolean

Returns:

  • (Boolean) 


471
472
473
 
# File 'app/models/note.rb', line 471

def editable?
  !system?
end

#edited? ⇒ Boolean

Since we used ‘updated_at` as `last_edited_at`, it could be touched by transforming / resolving a note. This makes sure it is only marked as edited when the note body is updated.

Returns:

  • (Boolean) 


483
484
485
486
487
 
# File 'app/models/note.rb', line 483

def edited?
  return false if read_attribute(:last_edited_at).blank? && updated_by.blank?

  super
end

#emoji_awardable? ⇒ Boolean

Returns:

  • (Boolean) 


493
494
495
 
# File 'app/models/note.rb', line 493

def emoji_awardable?
  !system?
end

#exportable_record?(user) ⇒ Boolean

Returns:

  • (Boolean) 


729
730
731
732
733
 
# File 'app/models/note.rb', line 729

def exportable_record?(user)
  return true unless system?

  readable_by?(user)
end

#for_abuse_report? ⇒ Boolean

Returns:

  • (Boolean) 


408
409
410
 
# File 'app/models/note.rb', line 408

def for_abuse_report?
  noteable_type == AbuseReport.name
end

#for_alert_mangement_alert? ⇒ Boolean

Returns:

  • (Boolean) 


368
369
370
 
# File 'app/models/note.rb', line 368

def for_alert_mangement_alert?
  noteable_type == 'AlertManagement::Alert'
end

#for_commit? ⇒ Boolean

Returns:

  • (Boolean) 


348
349
350
 
# File 'app/models/note.rb', line 348

def for_commit?
  noteable_type == "Commit"
end

#for_compliance_violation? ⇒ Boolean

Returns:

  • (Boolean) 


376
377
378
 
# File 'app/models/note.rb', line 376

def for_compliance_violation?
  noteable_type == 'ComplianceManagement::Projects::ComplianceViolation'
end

#for_design? ⇒ Boolean

Returns:

  • (Boolean) 


400
401
402
 
# File 'app/models/note.rb', line 400

def for_design?
  noteable_type == DesignManagement::Design.name
end

#for_issuable? ⇒ Boolean

Returns:

  • (Boolean) 


404
405
406
 
# File 'app/models/note.rb', line 404

def for_issuable?
  for_issue? || for_merge_request?
end

#for_issue? ⇒ Boolean

Returns:

  • (Boolean) 


352
353
354
 
# File 'app/models/note.rb', line 352

def for_issue?
  noteable_type == "Issue"
end

#for_merge_request? ⇒ Boolean

Returns:

  • (Boolean) 


360
361
362
 
# File 'app/models/note.rb', line 360

def for_merge_request?
  noteable_type == "MergeRequest"
end

#for_personal_snippet? ⇒ Boolean

Returns:

  • (Boolean) 


384
385
386
 
# File 'app/models/note.rb', line 384

def for_personal_snippet?
  noteable.is_a?(PersonalSnippet)
end

#for_project_noteable? ⇒ Boolean

Returns:

  • (Boolean) 


392
393
394
 
# File 'app/models/note.rb', line 392

def for_project_noteable?
  !(for_personal_snippet? || for_abuse_report? || group_level_issue?)
end

#for_project_snippet? ⇒ Boolean

Returns:

  • (Boolean) 


380
381
382
 
# File 'app/models/note.rb', line 380

def for_project_snippet?
  noteable.is_a?(ProjectSnippet)
end

#for_snippet? ⇒ Boolean

Returns:

  • (Boolean) 


364
365
366
 
# File 'app/models/note.rb', line 364

def for_snippet?
  noteable_type == "Snippet"
end

#for_vulnerability? ⇒ Boolean

Returns:

  • (Boolean) 


372
373
374
 
# File 'app/models/note.rb', line 372

def for_vulnerability?
  noteable_type == "Vulnerability"
end

#for_wiki_page? ⇒ Boolean

Returns:

  • (Boolean) 


388
389
390
 
# File 'app/models/note.rb', line 388

def for_wiki_page?
  noteable_type == "WikiPage::Meta"
end

#for_work_item? ⇒ Boolean

Returns:

  • (Boolean) 


356
357
358
 
# File 'app/models/note.rb', line 356

def for_work_item?
  noteable.is_a?(WorkItem)
end

#group_level_issue? ⇒ Boolean

Returns:

  • (Boolean) 


396
397
398
 
# File 'app/models/note.rb', line 396

def group_level_issue?
  (for_issue? || for_work_item?) && noteable&.project_id.blank?
end

#hook_attrs ⇒ Object 



340
341
342
 
# File 'app/models/note.rb', line 340

def hook_attrs
  Gitlab::HookData::NoteBuilder.new(self).build
end

#human_max_access ⇒ Object

overridden in ee



453
454
455
 
# File 'app/models/note.rb', line 453

def human_max_access
  project&.team&.human_max_access(self.author_id)
end

#issuable_ability_name ⇒ Object 



725
726
727
 
# File 'app/models/note.rb', line 725

def issuable_ability_name
  confidential? ? :read_internal_note : :read_note
end

#last_edited_at ⇒ Object

We used ‘last_edited_at` as an alias of `updated_at` before. This makes it compatible with the previous way without data migration.



477
478
479
 
# File 'app/models/note.rb', line 477

def last_edited_at
  super || updated_at
end

#mentioned_filtered_user_ids_for(references) ⇒ Object 



714
715
716
717
718
719
720
721
722
723
 
# File 'app/models/note.rb', line 714

def mentioned_filtered_user_ids_for(references)
  return super unless confidential?

  user_ids = references.mentioned_user_ids.presence

  return [] if user_ids.blank?

  users = User.where(id: user_ids)
  Ability.users_that_can_read_internal_notes(users, resource_parent).pluck(:id)
end

#mentioned_users(current_user = nil) ⇒ Object 



706
707
708
709
710
711
712
 
# File 'app/models/note.rb', line 706

def mentioned_users(current_user = nil)
  users = super

  return users unless confidential?

  Ability.users_that_can_read_internal_notes(users, resource_parent)
end

#merge_requests ⇒ Object

Notes on merge requests and commits can be traced back to one or several MRs. This method returns a relation if the note is for one of these types, or nil if it is a note on some other object.



423
424
425
426
427
428
429
 
# File 'app/models/note.rb', line 423

def merge_requests
  if for_commit?
    project.merge_requests.by_commit_sha(commit_id)
  elsif for_merge_request?
    MergeRequest.id_in(noteable_id)
  end
end

#noteable ⇒ Object

override to return commits, which are not active record



432
433
434
435
436
437
438
439
440
 
# File 'app/models/note.rb', line 432

def noteable
  return commit if for_commit?

  super
rescue StandardError
  # Temp fix to prevent app crash
  # if note commit id doesn't exist
  nil
end

#noteable_ability_name ⇒ Object 



505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
 
# File 'app/models/note.rb', line 505

def noteable_ability_name
  if for_snippet?
    'snippet'
  elsif for_alert_mangement_alert?
    'alert_management_alert'
  elsif for_vulnerability?
    'security_resource'
  elsif for_wiki_page?
    'wiki_page'
  elsif for_compliance_violation?
    'compliance_violations_report'
  else
    noteable_type.demodulize.underscore
  end
end

#noteable_author?(noteable) ⇒ Boolean

Returns:

  • (Boolean) 


457
458
459
 
# File 'app/models/note.rb', line 457

def noteable_author?(noteable)
  noteable.author == self.author
end

#noteable_type=(noteable_type) ⇒ Object

FIXME: Hack for polymorphic associations with STI

For more information visit http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#label-Polymorphic+Associations



444
445
446
 
# File 'app/models/note.rb', line 444

def noteable_type=(noteable_type)
  super(noteable_type.to_s.classify.constantize.base_class.to_s)
end

#notify_after_create ⇒ Object 



595
596
597
 
# File 'app/models/note.rb', line 595

def notify_after_create
  noteable&.after_note_created(self)
end

#notify_after_destroy ⇒ Object 



599
600
601
 
# File 'app/models/note.rb', line 599

def notify_after_destroy
  noteable&.after_note_destroyed(self)
end

#parent_user ⇒ Object 



630
631
632
 
# File 'app/models/note.rb', line 630

def parent_user
  noteable.author if for_personal_snippet?
end

#post_processed_cache_key ⇒ Object 



638
639
640
641
642
643
644
 
# File 'app/models/note.rb', line 638

def post_processed_cache_key
  cache_key_items = [cache_key, author&.cache_key]
  cache_key_items << project.team.human_max_access(author&.id) if author.present?
  cache_key_items << Digest::SHA1.hexdigest(redacted_note_html) if redacted_note_html.present?

  cache_key_items.join(':')
end

#project_name ⇒ Object 



461
462
463
 
# File 'app/models/note.rb', line 461

def project_name
  project&.name
end

#references ⇒ Object 



530
531
532
533
534
535
536
537
538
 
# File 'app/models/note.rb', line 530

def references
  refs = [noteable]

  if part_of_discussion?
    refs += discussion.notes.take_while { |n| n.id < id }
  end

  refs
end

#resource_parent ⇒ Object 



614
615
616
 
# File 'app/models/note.rb', line 614

def resource_parent
  noteable.try(:resource_parent) || project
end

#retrieve_upload(_identifier, paths) ⇒ Object 



610
611
612
 
# File 'app/models/note.rb', line 610

def retrieve_upload(_identifier, paths)
  Upload.find_by(model: self, path: paths)
end

#show_outdated_changes? ⇒ Boolean

Returns:

  • (Boolean) 


662
663
664
665
666
667
668
669
 
# File 'app/models/note.rb', line 662

def show_outdated_changes?
  return false unless for_merge_request?
  return false unless system?
  return false if change_position&.on_file?
  return false unless change_position&.line_range

  change_position.line_range["end"] || change_position.line_range["start"]
end

#skip_notification? ⇒ Boolean

Returns:

  • (Boolean) 


634
635
636
 
# File 'app/models/note.rb', line 634

def skip_notification?
  review.present? || !author.can_trigger_notifications?
end

#skip_project_check? ⇒ Boolean

Returns:

  • (Boolean) 


412
413
414
 
# File 'app/models/note.rb', line 412

def skip_project_check?
  !for_project_noteable?
end

#supports_suggestion? ⇒ Boolean

Returns:

  • (Boolean) 


344
345
346
 
# File 'app/models/note.rb', line 344

def supports_suggestion?
  false
end

#system_note_visible_for?(user) ⇒ Boolean

Returns:

  • (Boolean) 


624
625
626
627
628
 
# File 'app/models/note.rb', line 624

def system_note_visible_for?(user)
  return true unless system?

  system_note_viewable_by?(user) && all_referenced_mentionables_allowed?(user)
end

#system_note_with_references? ⇒ Boolean

rubocop: disable CodeReuse/ServiceClass

Returns:

  • (Boolean) 


321
322
323
324
325
326
327
328
329
 
# File 'app/models/note.rb', line 321

def system_note_with_references?
  return unless system?

  if force_cross_reference_regex_check?
    matches_cross_reference_regex?
  else
    ::SystemNotes::IssuablesService.cross_reference?(note)
  end
end

#touch(*args, **kwargs) ⇒ Object 



559
560
561
562
563
564
565
566
567
568
 
# File 'app/models/note.rb', line 559

def touch(*args, **kwargs)
  # We're not using an explicit transaction here because this would in all
  # cases result in all future queries going to the primary, even if no writes
  # are performed.
  #
  # We touch the noteable first so its SELECT query can run before our writes,
  # ensuring it runs on a secondary (if no prior write took place).
  touch_noteable
  super
end

#touch_noteable ⇒ Object

By default Rails will issue an “SELECT *” for the relation, which is overkill for just updating the timestamps. To work around this we manually touch the data so we can SELECT only the columns we need.



573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
 
# File 'app/models/note.rb', line 573

def touch_noteable
  # Commits are not stored in the DB so we can't touch them.
  # Vulnerabilities should not be touched as they are tracked in the same manner as other issuable types
  return if for_vulnerability? || for_commit?

  assoc = association(:noteable)

  noteable_object =
    if assoc.loaded?
      noteable
    else
      # If the object is not loaded (e.g. when notes are loaded async) we
      # _only_ want the data we actually need.
      assoc.scope.select(:id, :updated_at).take
    end

  noteable_object&.touch

  # We return the noteable object so we can re-use it in EE for Elasticsearch.
  noteable_object
end

#trigger_note_subscription_create ⇒ Object 



218
219
220
221
222
 
# File 'app/models/note.rb', line 218

def trigger_note_subscription_create
  return unless trigger_note_subscription?

  GraphqlTriggers.work_item_note_created(noteable.to_work_item_global_id, self)
end

#trigger_note_subscription_destroy ⇒ Object 



230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
 
# File 'app/models/note.rb', line 230

def trigger_note_subscription_destroy
  return unless trigger_note_subscription?

  # when deleting a note, we cannot pass it on as a Note instance, as GitlabSchema.object_from_id
  # would try to resolve the given Note and fetch it from DB which would raise NotFound exception.
  # So instead we just pass over the string representations of the note and discussion IDs,
  # so that the subscriber can identify the discussion and the note.
  deleted_note_data = {
    id: self.id,
    model_name: self.class.name,
    discussion_id: self.discussion_id,
    last_discussion_note: discussion.notes == [self]
  }

  GraphqlTriggers.work_item_note_deleted(noteable.to_work_item_global_id, deleted_note_data)
end

#trigger_note_subscription_update ⇒ Object 



224
225
226
227
228
 
# File 'app/models/note.rb', line 224

def trigger_note_subscription_update
  return unless trigger_note_subscription?

  GraphqlTriggers.work_item_note_updated(noteable.to_work_item_global_id, self)
end

#trigger_work_item_updated_subscription ⇒ Object 



247
248
249
250
251
252
 
# File 'app/models/note.rb', line 247

def trigger_work_item_updated_subscription
  return unless trigger_note_subscription?
  return unless system_note_work_item_reference?

  GraphqlTriggers.work_item_updated(noteable)
end

#user_mention_class ⇒ Object 



647
648
649
650
651
 
# File 'app/models/note.rb', line 647

def user_mention_class
  return if noteable.blank?

  noteable.user_mention_class
end

#user_mention_identifier ⇒ Object 



654
655
656
657
658
659
660
 
# File 'app/models/note.rb', line 654

def user_mention_identifier
  return if noteable.blank?

  noteable.user_mention_identifier.merge({
    note_id: id
  })
end

#user_mentions ⇒ Object 



618
619
620
621
622
 
# File 'app/models/note.rb', line 618

def user_mentions
  return Note.none unless noteable.present?

  noteable.user_mentions.where(note: self)
end