325 lines
11 KiB
Ruby
325 lines
11 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
# == Schema Information
|
|
#
|
|
# Table name: notifications
|
|
#
|
|
# id :bigint(8) not null, primary key
|
|
# activity_id :bigint(8) not null
|
|
# activity_type :string not null
|
|
# created_at :datetime not null
|
|
# updated_at :datetime not null
|
|
# account_id :bigint(8) not null
|
|
# from_account_id :bigint(8) not null
|
|
# type :string
|
|
# filtered :boolean default(FALSE), not null
|
|
# group_key :string
|
|
#
|
|
|
|
class Notification < ApplicationRecord
|
|
self.inheritance_column = nil
|
|
|
|
include Paginable
|
|
include Redisable
|
|
|
|
LEGACY_TYPE_CLASS_MAP = {
|
|
'Mention' => :mention,
|
|
'Status' => :reblog,
|
|
'Follow' => :follow,
|
|
'FollowRequest' => :follow_request,
|
|
'Favourite' => :favourite,
|
|
'Poll' => :poll,
|
|
}.freeze
|
|
|
|
# `set_group_key!` needs to be updated if this list changes
|
|
GROUPABLE_NOTIFICATION_TYPES = %i(favourite reblog follow).freeze
|
|
MAXIMUM_GROUP_SPAN_HOURS = 12
|
|
|
|
# Please update app/javascript/api_types/notification.ts if you change this
|
|
PROPERTIES = {
|
|
mention: {
|
|
filterable: true,
|
|
}.freeze,
|
|
status: {
|
|
filterable: false,
|
|
}.freeze,
|
|
reblog: {
|
|
filterable: true,
|
|
}.freeze,
|
|
follow: {
|
|
filterable: true,
|
|
}.freeze,
|
|
follow_request: {
|
|
filterable: true,
|
|
}.freeze,
|
|
favourite: {
|
|
filterable: true,
|
|
}.freeze,
|
|
poll: {
|
|
filterable: false,
|
|
}.freeze,
|
|
update: {
|
|
filterable: false,
|
|
}.freeze,
|
|
severed_relationships: {
|
|
filterable: false,
|
|
}.freeze,
|
|
moderation_warning: {
|
|
filterable: false,
|
|
}.freeze,
|
|
'admin.sign_up': {
|
|
filterable: false,
|
|
}.freeze,
|
|
'admin.report': {
|
|
filterable: false,
|
|
}.freeze,
|
|
}.freeze
|
|
|
|
TYPES = PROPERTIES.keys.freeze
|
|
|
|
TARGET_STATUS_INCLUDES_BY_TYPE = {
|
|
status: :status,
|
|
reblog: [status: :reblog],
|
|
mention: [mention: :status],
|
|
favourite: [favourite: :status],
|
|
poll: [poll: :status],
|
|
update: :status,
|
|
'admin.report': [report: :target_account],
|
|
}.freeze
|
|
|
|
belongs_to :account, optional: true
|
|
belongs_to :from_account, class_name: 'Account', optional: true
|
|
belongs_to :activity, polymorphic: true, optional: true
|
|
|
|
with_options foreign_key: 'activity_id', optional: true do
|
|
belongs_to :mention, inverse_of: :notification
|
|
belongs_to :status, inverse_of: :notification
|
|
belongs_to :follow, inverse_of: :notification
|
|
belongs_to :follow_request, inverse_of: :notification
|
|
belongs_to :favourite, inverse_of: :notification
|
|
belongs_to :poll, inverse_of: false
|
|
belongs_to :report, inverse_of: false
|
|
belongs_to :account_relationship_severance_event, inverse_of: false
|
|
belongs_to :account_warning, inverse_of: false
|
|
end
|
|
|
|
validates :type, inclusion: { in: TYPES }
|
|
|
|
scope :without_suspended, -> { joins(:from_account).merge(Account.without_suspended) }
|
|
|
|
def type
|
|
@type ||= (super || LEGACY_TYPE_CLASS_MAP[activity_type]).to_sym
|
|
end
|
|
|
|
def target_status
|
|
case type
|
|
when :status, :update
|
|
status
|
|
when :reblog
|
|
status&.reblog
|
|
when :favourite
|
|
favourite&.status
|
|
when :mention
|
|
mention&.status
|
|
when :poll
|
|
poll&.status
|
|
end
|
|
end
|
|
|
|
def set_group_key!
|
|
return if filtered? || Notification::GROUPABLE_NOTIFICATION_TYPES.exclude?(type)
|
|
|
|
type_prefix = case type
|
|
when :favourite, :reblog
|
|
[type, target_status&.id].join('-')
|
|
when :follow
|
|
type
|
|
else
|
|
raise NotImplementedError
|
|
end
|
|
redis_key = "notif-group/#{account.id}/#{type_prefix}"
|
|
hour_bucket = activity.created_at.utc.to_i / 1.hour.to_i
|
|
|
|
# Reuse previous group if it does not span too large an amount of time
|
|
previous_bucket = redis.get(redis_key).to_i
|
|
hour_bucket = previous_bucket if hour_bucket < previous_bucket + MAXIMUM_GROUP_SPAN_HOURS
|
|
|
|
# We do not concern ourselves with race conditions since we use hour buckets
|
|
redis.set(redis_key, hour_bucket, ex: MAXIMUM_GROUP_SPAN_HOURS.hours.to_i)
|
|
|
|
self.group_key = "#{type_prefix}-#{hour_bucket}"
|
|
end
|
|
|
|
class << self
|
|
def browserable(types: [], exclude_types: [], from_account_id: nil, include_filtered: false)
|
|
requested_types = if types.empty?
|
|
TYPES
|
|
else
|
|
types.map(&:to_sym) & TYPES
|
|
end
|
|
|
|
requested_types -= exclude_types.map(&:to_sym)
|
|
|
|
all.tap do |scope|
|
|
scope.merge!(where(filtered: false)) unless include_filtered || from_account_id.present?
|
|
scope.merge!(where(from_account_id: from_account_id)) if from_account_id.present?
|
|
scope.merge!(where(type: requested_types)) unless requested_types.size == TYPES.size
|
|
end
|
|
end
|
|
|
|
def paginate_groups(limit, pagination_order, grouped_types: nil)
|
|
raise ArgumentError unless %i(asc desc).include?(pagination_order)
|
|
|
|
query = reorder(id: pagination_order)
|
|
|
|
# Ideally `:types` would be a bind rather than part of the SQL itself, but that does not
|
|
# seem to be possible to do with Rails, considering that the expression would occur in
|
|
# multiple places, including in a `select`
|
|
group_key_sql = begin
|
|
if grouped_types.present?
|
|
# Normalize `grouped_types` so the number of different SQL query shapes remains small, and
|
|
# the queries can be analyzed in monitoring/telemetry tools
|
|
grouped_types = (grouped_types.map(&:to_sym) & GROUPABLE_NOTIFICATION_TYPES).sort
|
|
|
|
sanitize_sql_array([<<~SQL.squish, { types: grouped_types }])
|
|
COALESCE(
|
|
CASE
|
|
WHEN notifications.type IN (:types) THEN notifications.group_key
|
|
ELSE NULL
|
|
END,
|
|
'ungrouped-' || notifications.id
|
|
)
|
|
SQL
|
|
else
|
|
"COALESCE(notifications.group_key, 'ungrouped-' || notifications.id)"
|
|
end
|
|
end
|
|
|
|
unscoped
|
|
.with_recursive(
|
|
grouped_notifications: [
|
|
# Base case: fetching one notification and annotating it with visited groups
|
|
query
|
|
.select('notifications.*', "ARRAY[#{group_key_sql}] AS groups")
|
|
.limit(1),
|
|
# Recursive case, always yielding at most one annotated notification
|
|
unscoped
|
|
.from(
|
|
[
|
|
# Expose the working table as `wt`, but quit early if we've reached the limit
|
|
unscoped
|
|
.select('id', 'groups')
|
|
.from('grouped_notifications')
|
|
.where('array_length(grouped_notifications.groups, 1) < :limit', limit: limit)
|
|
.arel.as('wt'),
|
|
# Recursive query, using `LATERAL` so we can refer to `wt`
|
|
query
|
|
.where(pagination_order == :desc ? 'notifications.id < wt.id' : 'notifications.id > wt.id')
|
|
.where.not("#{group_key_sql} = ANY(wt.groups)")
|
|
.limit(1)
|
|
.arel.lateral('notifications'),
|
|
]
|
|
)
|
|
.select('notifications.*', "array_append(wt.groups, #{group_key_sql}) AS groups"),
|
|
]
|
|
)
|
|
.from('grouped_notifications AS notifications')
|
|
.order(id: pagination_order)
|
|
.limit(limit)
|
|
end
|
|
|
|
# This returns notifications from the request page, but with at most one notification per group.
|
|
# Notifications that have no `group_key` each count as a separate group.
|
|
def paginate_groups_by_max_id(limit, max_id: nil, since_id: nil, grouped_types: nil)
|
|
query = reorder(id: :desc)
|
|
query = query.where(id: ...(max_id.to_i)) if max_id.present?
|
|
query = query.where(id: (since_id.to_i + 1)...) if since_id.present?
|
|
query.paginate_groups(limit, :desc, grouped_types: grouped_types)
|
|
end
|
|
|
|
# Differs from :paginate_groups_by_max_id in that it gives the results immediately following min_id,
|
|
# whereas since_id gives the items with largest id, but with since_id as a cutoff.
|
|
# Results will be in ascending order by id.
|
|
def paginate_groups_by_min_id(limit, max_id: nil, min_id: nil, grouped_types: nil)
|
|
query = reorder(id: :asc)
|
|
query = query.where(id: (min_id.to_i + 1)...) if min_id.present?
|
|
query = query.where(id: ...(max_id.to_i)) if max_id.present?
|
|
query.paginate_groups(limit, :asc, grouped_types: grouped_types)
|
|
end
|
|
|
|
def to_a_grouped_paginated_by_id(limit, options = {})
|
|
if options[:min_id].present?
|
|
paginate_groups_by_min_id(limit, min_id: options[:min_id], max_id: options[:max_id], grouped_types: options[:grouped_types]).reverse
|
|
else
|
|
paginate_groups_by_max_id(limit, max_id: options[:max_id], since_id: options[:since_id], grouped_types: options[:grouped_types]).to_a
|
|
end
|
|
end
|
|
|
|
def preload_cache_collection_target_statuses(notifications, &_block)
|
|
notifications.group_by(&:type).each do |type, grouped_notifications|
|
|
associations = TARGET_STATUS_INCLUDES_BY_TYPE[type]
|
|
next unless associations
|
|
|
|
# Instead of using the usual `includes`, manually preload each type.
|
|
# If polymorphic associations are loaded with the usual `includes`, other types of associations will be loaded more.
|
|
ActiveRecord::Associations::Preloader.new(records: grouped_notifications, associations: associations).call
|
|
end
|
|
|
|
unique_target_statuses = notifications.filter_map(&:target_status).uniq
|
|
# Call cache_collection in block
|
|
cached_statuses_by_id = yield(unique_target_statuses).index_by(&:id)
|
|
|
|
notifications.each do |notification|
|
|
next if notification.target_status.nil?
|
|
|
|
cached_status = cached_statuses_by_id[notification.target_status.id]
|
|
|
|
case notification.type
|
|
when :status, :update
|
|
notification.status = cached_status
|
|
when :reblog
|
|
notification.status.reblog = cached_status
|
|
when :favourite
|
|
notification.favourite.status = cached_status
|
|
when :mention
|
|
notification.mention.status = cached_status
|
|
when :poll
|
|
notification.poll.status = cached_status
|
|
end
|
|
end
|
|
|
|
notifications
|
|
end
|
|
end
|
|
|
|
after_initialize :set_from_account
|
|
before_validation :set_from_account
|
|
|
|
after_destroy :remove_from_notification_request
|
|
|
|
private
|
|
|
|
def set_from_account
|
|
return unless new_record?
|
|
|
|
case activity_type
|
|
when 'Status', 'Follow', 'Favourite', 'FollowRequest', 'Poll', 'Report'
|
|
self.from_account_id = activity&.account_id
|
|
when 'Mention'
|
|
self.from_account_id = activity&.status&.account_id
|
|
when 'Account'
|
|
self.from_account_id = activity&.id
|
|
when 'AccountRelationshipSeveranceEvent', 'AccountWarning'
|
|
# These do not really have an originating account, but this is mandatory
|
|
# in the data model, and the recipient's account will by definition
|
|
# always exist
|
|
self.from_account_id = account_id
|
|
end
|
|
end
|
|
|
|
def remove_from_notification_request
|
|
notification_request = NotificationRequest.find_by(account_id: account_id, from_account_id: from_account_id)
|
|
notification_request&.reconsider_existence!
|
|
end
|
|
end
|