gitlab-org--gitlab-foss/app/models/event.rb

399 lines
7.7 KiB
Ruby
Raw Normal View History

2012-02-28 08:09:23 -05:00
class Event < ActiveRecord::Base
include Sortable
default_scope { reorder(nil).where.not(author_id: nil) }
2013-02-13 06:48:16 -05:00
CREATED = 1
UPDATED = 2
CLOSED = 3
REOPENED = 4
PUSHED = 5
COMMENTED = 6
MERGED = 7
JOINED = 8 # User joined project
LEFT = 9 # User left project
DESTROYED = 10
EXPIRED = 11 # User left project due to expiry
ACTIONS = HashWithIndifferentAccess.new(
created: CREATED,
updated: UPDATED,
closed: CLOSED,
reopened: REOPENED,
pushed: PUSHED,
commented: COMMENTED,
merged: MERGED,
joined: JOINED,
left: LEFT,
destroyed: DESTROYED,
expired: EXPIRED
).freeze
TARGET_TYPES = HashWithIndifferentAccess.new(
issue: Issue,
milestone: Milestone,
merge_request: MergeRequest,
note: Note,
project: Project,
snippet: Snippet,
user: User
).freeze
RESET_PROJECT_ACTIVITY_INTERVAL = 1.hour
delegate :name, :email, :public_email, :username, to: :author, prefix: true, allow_nil: true
2012-09-27 02:20:36 -04:00
delegate :title, to: :issue, prefix: true, allow_nil: true
delegate :title, to: :merge_request, prefix: true, allow_nil: true
delegate :title, to: :note, prefix: true, allow_nil: true
2012-09-27 02:20:36 -04:00
2012-09-27 16:23:11 -04:00
belongs_to :author, class_name: "User"
2012-02-28 08:09:23 -05:00
belongs_to :project
belongs_to :target, polymorphic: true # rubocop:disable Cop/PolymorphicAssociations
2012-04-03 19:49:58 -04:00
# For Hash only
serialize :data # rubocop:disable Cop/ActiveRecordSerialize
2014-06-17 14:23:43 -04:00
# Callbacks
after_create :reset_project_activity
after_create :set_last_repository_updated_at, if: :push?
2014-06-17 14:23:43 -04:00
2012-10-08 20:10:04 -04:00
# Scopes
scope :recent, -> { reorder(id: :desc) }
2013-02-13 06:48:16 -05:00
scope :code_push, -> { where(action: PUSHED) }
scope :in_projects, ->(projects) do
where(project_id: projects.pluck(:id)).recent
end
scope :with_associations, -> { includes(:author, :project, project: :namespace).preload(:target) }
scope :for_milestone_id, ->(milestone_id) { where(target_type: "Milestone", target_id: milestone_id) }
2012-10-08 20:10:04 -04:00
class << self
# Update Gitlab::ContributionsCalendar#activity_dates if this changes
def contributions
where("action = ? OR (target_type IN (?) AND action IN (?)) OR (target_type = ? AND action = ?)",
Event::PUSHED,
2017-02-22 12:46:57 -05:00
%w(MergeRequest Issue), [Event::CREATED, Event::CLOSED, Event::MERGED],
"Note", Event::COMMENTED)
end
Faster way of obtaining latest event update time Instead of using MAX(events.updated_at) we can simply sort the events in descending order by the "id" column and grab the first row. In other words, instead of this: SELECT max(events.updated_at) AS max_id FROM events LEFT OUTER JOIN projects ON projects.id = events.project_id LEFT OUTER JOIN namespaces ON namespaces.id = projects.namespace_id WHERE events.author_id IS NOT NULL AND events.project_id IN (13083); we can use this: SELECT events.updated_at AS max_id FROM events LEFT OUTER JOIN projects ON projects.id = events.project_id LEFT OUTER JOIN namespaces ON namespaces.id = projects.namespace_id WHERE events.author_id IS NOT NULL AND events.project_id IN (13083) ORDER BY events.id DESC LIMIT 1; This has the benefit that on PostgreSQL a backwards index scan can be used, which due to the "LIMIT 1" will at most process only a single row. This in turn greatly speeds up the process of grabbing the latest update time. This can be confirmed by looking at the query plans. The first query produces the following plan: Aggregate (cost=43779.84..43779.85 rows=1 width=12) (actual time=2142.462..2142.462 rows=1 loops=1) -> Index Scan using index_events_on_project_id on events (cost=0.43..43704.69 rows=30060 width=12) (actual time=0.033..2138.086 rows=32769 loops=1) Index Cond: (project_id = 13083) Filter: (author_id IS NOT NULL) Planning time: 1.248 ms Execution time: 2142.548 ms The second query in turn produces the following plan: Limit (cost=0.43..41.65 rows=1 width=16) (actual time=1.394..1.394 rows=1 loops=1) -> Index Scan Backward using events_pkey on events (cost=0.43..1238907.96 rows=30060 width=16) (actual time=1.394..1.394 rows=1 loops=1) Filter: ((author_id IS NOT NULL) AND (project_id = 13083)) Rows Removed by Filter: 2104 Planning time: 0.166 ms Execution time: 1.408 ms According to the above plans the 2nd query is around 1500 times faster. However, re-running the first query produces timings of around 80 ms, making the 2nd query "only" around 55 times faster.
2015-11-11 11:14:47 -05:00
def limit_recent(limit = 20, offset = nil)
recent.limit(limit).offset(offset)
end
def actions
ACTIONS.keys
end
def target_types
TARGET_TYPES.keys
end
end
def visible_to_user?(user = nil)
if push? || commit_note?
Ability.allowed?(user, :download_code, project)
elsif membership_changed?
true
elsif created_project?
true
elsif issue? || issue_note?
2016-08-08 14:55:13 -04:00
Ability.allowed?(user, :read_issue, note? ? note_target : target)
2016-10-04 08:52:08 -04:00
elsif merge_request? || merge_request_note?
Ability.allowed?(user, :read_merge_request, note? ? note_target : target)
else
2016-10-04 08:52:08 -04:00
milestone?
end
2012-03-01 13:47:57 -05:00
end
def project_name
if project
2013-06-22 09:00:39 -04:00
project.name_with_namespace
else
2012-09-30 09:04:43 -04:00
"(deleted project)"
end
end
def target_title
target.try(:title)
end
def created?
action == CREATED
end
def push?
action == PUSHED && valid_push?
end
def merged?
action == MERGED
end
def closed?
action == CLOSED
end
def reopened?
action == REOPENED
end
def joined?
action == JOINED
end
def left?
action == LEFT
end
def expired?
action == EXPIRED
end
def destroyed?
action == DESTROYED
end
def commented?
action == COMMENTED
end
def membership_changed?
joined? || left? || expired?
end
def created_project?
created? && !target && target_type.nil?
end
def created_target?
created? && target
end
def milestone?
target_type == "Milestone"
end
def note?
target.is_a?(Note)
end
def issue?
target_type == "Issue"
end
def merge_request?
target_type == "MergeRequest"
2012-03-05 17:29:40 -05:00
end
def milestone
target if milestone?
2012-09-09 16:18:28 -04:00
end
def issue
target if issue?
end
def merge_request
target if merge_request?
end
def note
target if note?
end
def action_name
if push?
if new_ref?
"pushed new"
elsif rm_ref?
"deleted"
else
"pushed to"
end
elsif closed?
"closed"
elsif merged?
"accepted"
2012-09-09 16:18:28 -04:00
elsif joined?
'joined'
2012-09-09 17:27:47 -04:00
elsif left?
'left'
elsif expired?
'removed due to membership expiration from'
elsif destroyed?
'destroyed'
elsif commented?
"commented on"
elsif created_project?
if project.external_import?
"imported"
else
"created"
end
else
"opened"
end
end
2013-01-02 16:35:11 -05:00
def valid_push?
data[:ref] && ref_name.present?
rescue
2013-01-02 16:35:11 -05:00
false
end
def tag?
Gitlab::Git.tag_ref?(data[:ref])
2013-01-02 16:35:11 -05:00
end
def branch?
Gitlab::Git.branch_ref?(data[:ref])
2013-01-02 16:35:11 -05:00
end
def new_ref?
Gitlab::Git.blank_ref?(commit_from)
2013-01-02 16:35:11 -05:00
end
def rm_ref?
Gitlab::Git.blank_ref?(commit_to)
2013-01-02 16:35:11 -05:00
end
def md_ref?
!(rm_ref? || new_ref?)
end
def commit_from
data[:before]
end
def commit_to
data[:after]
end
def ref_name
if tag?
tag_name
else
branch_name
end
end
def branch_name
@branch_name ||= Gitlab::Git.ref_name(data[:ref])
2013-01-02 16:35:11 -05:00
end
def tag_name
@tag_name ||= Gitlab::Git.ref_name(data[:ref])
2013-01-02 16:35:11 -05:00
end
# Max 20 commits from push DESC
def commits
@commits ||= (data[:commits] || []).reverse
2013-01-02 16:35:11 -05:00
end
def commits_count
data[:total_commits_count] || commits.count || 0
end
def ref_type
tag? ? "tag" : "branch"
end
def push_with_commits?
!commits.empty? && commit_from && commit_to
2013-01-02 16:35:11 -05:00
end
def last_push_to_non_root?
branch? && project.default_branch != branch_name
end
def target_iid
target.respond_to?(:iid) ? target.iid : target_id
end
def commit_note?
note? && target && target.for_commit?
2013-01-02 16:35:11 -05:00
end
def issue_note?
2016-05-08 14:46:43 -04:00
note? && target && target.for_issue?
end
2016-10-04 08:52:08 -04:00
def merge_request_note?
note? && target && target.for_merge_request?
end
def project_snippet_note?
note? && target && target.for_snippet?
2013-03-25 07:58:09 -04:00
end
2013-01-02 16:35:11 -05:00
def note_target
target.noteable
end
def note_target_id
if commit_note?
2013-01-02 16:35:11 -05:00
target.commit_id
else
target.noteable_id.to_s
end
end
def note_target_reference
return unless note_target
# Commit#to_reference returns the full SHA, but we want the short one here
if commit_note?
note_target.short_id
else
note_target.to_reference
end
end
2013-01-02 16:35:11 -05:00
def note_target_type
if target.noteable_type.present?
target.noteable_type.titleize
else
"Wall"
end.downcase
end
2013-08-20 14:31:37 -04:00
def body?
if push?
push_with_commits? || rm_ref?
2013-08-20 14:31:37 -04:00
elsif note?
true
else
target.respond_to? :title
end
end
2014-06-17 14:23:43 -04:00
def reset_project_activity
return unless project
# Don't bother updating if we know the project was updated recently.
return if recent_update?
# At this point it's possible for multiple threads/processes to try to
# update the project. Only one query should actually perform the update,
# hence we add the extra WHERE clause for last_activity_at.
2017-06-21 09:48:12 -04:00
Project.unscoped.where(id: project_id)
.where('last_activity_at <= ?', RESET_PROJECT_ACTIVITY_INTERVAL.ago)
.update_all(last_activity_at: created_at)
end
def authored_by?(user)
user ? author_id == user.id : false
end
private
def recent_update?
project.last_activity_at > RESET_PROJECT_ACTIVITY_INTERVAL.ago
end
def set_last_repository_updated_at
2017-06-21 09:48:12 -04:00
Project.unscoped.where(id: project_id)
.update_all(last_repository_updated_at: created_at)
end
2012-02-28 08:09:23 -05:00
end