mirror of
https://github.com/discourse/discourse.git
synced 2024-11-25 05:02:24 +08:00
1c67917367
This ensures we only ever store correct post and topic timing when the client notifies. Previous to this change we would blindly trust the client. Additionally this has error correction code that will correct the last seen post number when you visit a topic with incorrect timings.
597 lines
20 KiB
Ruby
597 lines
20 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
class TopicUser < ActiveRecord::Base
|
|
self.ignored_columns = [
|
|
:highest_seen_post_number, # Remove after 01 Jan 2022
|
|
]
|
|
|
|
belongs_to :user
|
|
belongs_to :topic
|
|
|
|
# used for serialization
|
|
attr_accessor :post_action_data
|
|
|
|
scope :level,
|
|
lambda { |topic_id, level|
|
|
where(topic_id: topic_id).where(
|
|
"COALESCE(topic_users.notification_level, :regular) >= :level",
|
|
regular: TopicUser.notification_levels[:regular],
|
|
level: TopicUser.notification_levels[level],
|
|
)
|
|
}
|
|
|
|
scope :tracking, lambda { |topic_id| level(topic_id, :tracking) }
|
|
|
|
scope :watching, lambda { |topic_id| level(topic_id, :watching) }
|
|
|
|
def topic_bookmarks
|
|
Bookmark.where(topic: topic, user: user)
|
|
end
|
|
|
|
# Class methods
|
|
class << self
|
|
# Enums
|
|
def notification_levels
|
|
NotificationLevels.topic_levels
|
|
end
|
|
|
|
def notification_reasons
|
|
@notification_reasons ||=
|
|
Enum.new(
|
|
created_topic: 1,
|
|
user_changed: 2,
|
|
user_interacted: 3,
|
|
created_post: 4,
|
|
auto_watch: 5,
|
|
auto_watch_category: 6,
|
|
auto_mute_category: 7,
|
|
auto_track_category: 8,
|
|
plugin_changed: 9,
|
|
auto_watch_tag: 10,
|
|
auto_mute_tag: 11,
|
|
auto_track_tag: 12,
|
|
)
|
|
end
|
|
|
|
def auto_notification(user_id, topic_id, reason, notification_level)
|
|
should_change =
|
|
TopicUser
|
|
.where(user_id: user_id, topic_id: topic_id)
|
|
.where(
|
|
"notifications_reason_id IS NULL OR (notification_level < :max AND notification_level > :min)",
|
|
max: notification_level,
|
|
min: notification_levels[:regular],
|
|
)
|
|
.exists?
|
|
|
|
if should_change
|
|
change(
|
|
user_id,
|
|
topic_id,
|
|
notification_level: notification_level,
|
|
notifications_reason_id: reason,
|
|
)
|
|
end
|
|
end
|
|
|
|
def auto_notification_for_staging(
|
|
user_id,
|
|
topic_id,
|
|
reason,
|
|
notification_level = notification_levels[:watching]
|
|
)
|
|
change(
|
|
user_id,
|
|
topic_id,
|
|
notification_level: notification_level,
|
|
notifications_reason_id: reason,
|
|
)
|
|
end
|
|
|
|
def unwatch_categories!(user, category_ids)
|
|
track_threshold = user.user_option.auto_track_topics_after_msecs
|
|
|
|
sql = <<~SQL
|
|
UPDATE topic_users tu
|
|
SET notification_level = CASE
|
|
WHEN t.user_id = :user_id THEN :watching
|
|
WHEN total_msecs_viewed > :track_threshold AND :track_threshold >= 0 THEN :tracking
|
|
ELSE :regular
|
|
end
|
|
FROM topics t
|
|
WHERE t.id = tu.topic_id AND tu.notification_level <> :muted AND category_id IN (:category_ids) AND tu.user_id = :user_id
|
|
SQL
|
|
|
|
DB.exec(
|
|
sql,
|
|
watching: notification_levels[:watching],
|
|
tracking: notification_levels[:tracking],
|
|
regular: notification_levels[:regular],
|
|
muted: notification_levels[:muted],
|
|
category_ids: category_ids,
|
|
user_id: user.id,
|
|
track_threshold: track_threshold,
|
|
)
|
|
end
|
|
|
|
# Find the information specific to a user in a forum topic
|
|
def lookup_for(user, topics)
|
|
# If the user isn't logged in, there's no last read posts
|
|
return {} if user.blank? || topics.blank?
|
|
|
|
topic_ids = topics.map(&:id)
|
|
create_lookup(TopicUser.where(topic_id: topic_ids, user_id: user.id))
|
|
end
|
|
|
|
def create_lookup(topic_users)
|
|
topic_users = topic_users.to_a
|
|
result = {}
|
|
return result if topic_users.blank?
|
|
topic_users.each { |ftu| result[ftu.topic_id] = ftu }
|
|
result
|
|
end
|
|
|
|
def get(topic, user)
|
|
topic = topic.id if topic.is_a?(Topic)
|
|
user = user.id if user.is_a?(User)
|
|
TopicUser.find_by(topic_id: topic, user_id: user)
|
|
end
|
|
|
|
# Change attributes for a user (creates a record when none is present). First it tries an update
|
|
# since there's more likely to be an existing record than not. If the update returns 0 rows affected
|
|
# it then creates the row instead.
|
|
def change(user_id, topic_id, attrs)
|
|
# For plugin compatibility, remove after 01 Jan 2022
|
|
attrs.delete(:highest_seen_post_number) if attrs[:highest_seen_post_number]
|
|
|
|
# Sometimes people pass objs instead of the ids. We can handle that.
|
|
topic_id = topic_id.id if topic_id.is_a?(::Topic)
|
|
user_id = user_id.id if user_id.is_a?(::User)
|
|
|
|
topic_id = topic_id.to_i
|
|
user_id = user_id.to_i
|
|
|
|
TopicUser.transaction do
|
|
attrs = attrs.dup
|
|
if attrs[:notification_level]
|
|
attrs[:notifications_changed_at] ||= DateTime.now
|
|
attrs[:notifications_reason_id] ||= TopicUser.notification_reasons[:user_changed]
|
|
end
|
|
attrs_array = attrs.to_a
|
|
|
|
attrs_sql = attrs_array.map { |t| "#{t[0]} = ?" }.join(", ")
|
|
vals = attrs_array.map { |t| t[1] }
|
|
|
|
rows = TopicUser.where(topic_id: topic_id, user_id: user_id).update_all([attrs_sql, *vals])
|
|
|
|
create_missing_record(user_id, topic_id, attrs) if rows == 0
|
|
end
|
|
|
|
if attrs[:notification_level]
|
|
notification_level_change(
|
|
user_id,
|
|
topic_id,
|
|
attrs[:notification_level],
|
|
attrs[:notifications_reason_id],
|
|
)
|
|
end
|
|
rescue ActiveRecord::RecordNotUnique
|
|
# In case of a race condition to insert, do nothing
|
|
end
|
|
|
|
def notification_level_change(user_id, topic_id, notification_level, reason_id)
|
|
message = { notification_level_change: notification_level }
|
|
message[:notifications_reason_id] = reason_id if reason_id
|
|
MessageBus.publish("/topic/#{topic_id}", message, user_ids: [user_id])
|
|
|
|
DiscourseEvent.trigger(
|
|
:topic_notification_level_changed,
|
|
notification_level,
|
|
user_id,
|
|
topic_id,
|
|
)
|
|
end
|
|
|
|
def create_missing_record(user_id, topic_id, attrs)
|
|
now = DateTime.now
|
|
|
|
unless attrs[:notification_level]
|
|
category_notification_level =
|
|
CategoryUser
|
|
.where(user_id: user_id)
|
|
.where("category_id IN (SELECT category_id FROM topics WHERE id = :id)", id: topic_id)
|
|
.where(
|
|
"notification_level IN (:levels)",
|
|
levels: [
|
|
CategoryUser.notification_levels[:watching],
|
|
CategoryUser.notification_levels[:tracking],
|
|
],
|
|
)
|
|
.order("notification_level DESC")
|
|
.limit(1)
|
|
.pluck(:notification_level)
|
|
.first
|
|
|
|
tag_notification_level =
|
|
TagUser
|
|
.where(user_id: user_id)
|
|
.where("tag_id IN (SELECT tag_id FROM topic_tags WHERE topic_id = :id)", id: topic_id)
|
|
.where(
|
|
"notification_level IN (:levels)",
|
|
levels: [
|
|
CategoryUser.notification_levels[:watching],
|
|
CategoryUser.notification_levels[:tracking],
|
|
],
|
|
)
|
|
.order("notification_level DESC")
|
|
.limit(1)
|
|
.pluck(:notification_level)
|
|
.first
|
|
|
|
if category_notification_level &&
|
|
!(tag_notification_level && (tag_notification_level > category_notification_level))
|
|
attrs[:notification_level] = category_notification_level
|
|
attrs[:notifications_changed_at] = DateTime.now
|
|
attrs[:notifications_reason_id] = (
|
|
if category_notification_level == CategoryUser.notification_levels[:watching]
|
|
TopicUser.notification_reasons[:auto_watch_category]
|
|
else
|
|
TopicUser.notification_reasons[:auto_track_category]
|
|
end
|
|
)
|
|
elsif tag_notification_level
|
|
attrs[:notification_level] = tag_notification_level
|
|
attrs[:notifications_changed_at] = DateTime.now
|
|
attrs[:notifications_reason_id] = (
|
|
if tag_notification_level == TagUser.notification_levels[:watching]
|
|
TopicUser.notification_reasons[:auto_watch_tag]
|
|
else
|
|
TopicUser.notification_reasons[:auto_track_tag]
|
|
end
|
|
)
|
|
end
|
|
end
|
|
|
|
unless attrs[:notification_level]
|
|
if Topic.private_messages.where(id: topic_id).exists? &&
|
|
Notification.where(
|
|
user_id: user_id,
|
|
topic_id: topic_id,
|
|
notification_type: Notification.types[:invited_to_private_message],
|
|
).exists?
|
|
group_notification_level =
|
|
Group
|
|
.joins(
|
|
"LEFT OUTER JOIN group_users gu ON gu.group_id = groups.id AND gu.user_id = #{user_id}",
|
|
)
|
|
.joins("LEFT OUTER JOIN topic_allowed_groups tag ON tag.topic_id = #{topic_id}")
|
|
.where("gu.id IS NOT NULL AND tag.id IS NOT NULL")
|
|
.pluck(:default_notification_level)
|
|
.first
|
|
|
|
if group_notification_level.present?
|
|
attrs[:notification_level] = group_notification_level
|
|
else
|
|
attrs[:notification_level] = notification_levels[:watching]
|
|
end
|
|
else
|
|
auto_track_after = UserOption.where(user_id: user_id).pick(:auto_track_topics_after_msecs)
|
|
auto_track_after ||= SiteSetting.default_other_auto_track_topics_after_msecs
|
|
|
|
if auto_track_after >= 0 && auto_track_after <= (attrs[:total_msecs_viewed].to_i || 0)
|
|
attrs[:notification_level] ||= notification_levels[:tracking]
|
|
end
|
|
end
|
|
end
|
|
|
|
TopicUser.create!(
|
|
attrs.merge!(
|
|
user_id: user_id,
|
|
topic_id: topic_id,
|
|
first_visited_at: now,
|
|
last_visited_at: now,
|
|
),
|
|
)
|
|
|
|
DiscourseEvent.trigger(:topic_first_visited_by_user, topic_id, user_id)
|
|
end
|
|
|
|
def track_visit!(topic_id, user_id)
|
|
now = DateTime.now
|
|
rows = TopicUser.where(topic_id: topic_id, user_id: user_id).update_all(last_visited_at: now)
|
|
|
|
change(user_id, topic_id, last_visited_at: now, first_visited_at: now) if rows == 0
|
|
end
|
|
|
|
# Update the last read and the last seen post count, but only if it doesn't exist.
|
|
# This would be a lot easier if psql supported some kind of upsert
|
|
UPDATE_TOPIC_USER_SQL = <<~SQL
|
|
UPDATE topic_users
|
|
SET
|
|
last_read_post_number =
|
|
LEAST(
|
|
CASE WHEN :whisperer
|
|
THEN highest_staff_post_number
|
|
ELSE highest_post_number END
|
|
,
|
|
GREATEST(:post_number, tu.last_read_post_number)
|
|
),
|
|
total_msecs_viewed = LEAST(tu.total_msecs_viewed + :msecs,86400000),
|
|
notification_level =
|
|
case when tu.notifications_reason_id is null and (tu.total_msecs_viewed + :msecs) >
|
|
coalesce(uo.auto_track_topics_after_msecs,:threshold) and
|
|
coalesce(uo.auto_track_topics_after_msecs, :threshold) >= 0
|
|
and t.archetype = 'regular' then
|
|
:tracking
|
|
else
|
|
tu.notification_level
|
|
end
|
|
FROM topic_users tu
|
|
join topics t on t.id = tu.topic_id
|
|
join users u on u.id = :user_id
|
|
join user_options uo on uo.user_id = :user_id
|
|
WHERE
|
|
tu.topic_id = topic_users.topic_id AND
|
|
tu.user_id = topic_users.user_id AND
|
|
tu.topic_id = :topic_id AND
|
|
tu.user_id = :user_id
|
|
RETURNING
|
|
topic_users.notification_level,
|
|
tu.notification_level old_level,
|
|
tu.last_read_post_number,
|
|
t.archetype
|
|
SQL
|
|
|
|
INSERT_TOPIC_USER_SQL =
|
|
"INSERT INTO topic_users (user_id, topic_id, last_read_post_number, last_visited_at, first_visited_at, notification_level)
|
|
SELECT :user_id, :topic_id, :post_number, :now, :now, :new_status
|
|
FROM topics AS ft
|
|
JOIN users u on u.id = :user_id
|
|
WHERE ft.id = :topic_id
|
|
AND NOT EXISTS(SELECT 1
|
|
FROM topic_users AS ftu
|
|
WHERE ftu.user_id = :user_id and ftu.topic_id = :topic_id)"
|
|
|
|
def update_last_read(user, topic_id, post_number, new_posts_read, msecs, opts = {})
|
|
return if post_number.blank?
|
|
msecs = 0 if msecs.to_i < 0
|
|
|
|
args = {
|
|
user_id: user.id,
|
|
topic_id: topic_id,
|
|
post_number: post_number,
|
|
now: DateTime.now,
|
|
msecs: msecs,
|
|
tracking: notification_levels[:tracking],
|
|
threshold: SiteSetting.default_other_auto_track_topics_after_msecs,
|
|
whisperer: user.whisperer?,
|
|
}
|
|
|
|
rows = DB.query(UPDATE_TOPIC_USER_SQL, args)
|
|
|
|
if rows.length == 1
|
|
before = rows[0].old_level.to_i
|
|
after = rows[0].notification_level.to_i
|
|
before_last_read = rows[0].last_read_post_number.to_i
|
|
archetype = rows[0].archetype
|
|
|
|
if before_last_read < post_number
|
|
# The user read at least one new post
|
|
publish_read(
|
|
topic_id: topic_id,
|
|
post_number: post_number,
|
|
user: user,
|
|
notification_level: after,
|
|
private_message: archetype == Archetype.private_message,
|
|
)
|
|
end
|
|
|
|
user.update_posts_read!(new_posts_read, mobile: opts[:mobile]) if new_posts_read > 0
|
|
|
|
notification_level_change(user.id, topic_id, after, nil) if before != after
|
|
end
|
|
|
|
if rows.length == 0
|
|
# The user read at least one post in a topic that they haven't viewed before.
|
|
args[:new_status] = notification_levels[:regular]
|
|
if (
|
|
user.user_option.auto_track_topics_after_msecs ||
|
|
SiteSetting.default_other_auto_track_topics_after_msecs
|
|
) == 0
|
|
args[:new_status] = notification_levels[:tracking]
|
|
end
|
|
|
|
publish_read(
|
|
topic_id: topic_id,
|
|
post_number: post_number,
|
|
user: user,
|
|
notification_level: args[:new_status],
|
|
private_message: Topic.exists?(archetype: Archetype.private_message, id: topic_id),
|
|
)
|
|
|
|
user.update_posts_read!(new_posts_read, mobile: opts[:mobile])
|
|
|
|
begin
|
|
DB.exec(INSERT_TOPIC_USER_SQL, args)
|
|
rescue PG::UniqueViolation
|
|
# if record is inserted between two statements this can happen
|
|
# we retry once to avoid failing the req
|
|
if opts[:retry]
|
|
raise
|
|
else
|
|
opts[:retry] = true
|
|
update_last_read(user, topic_id, post_number, new_posts_read, msecs, opts)
|
|
end
|
|
end
|
|
|
|
notification_level_change(user.id, topic_id, args[:new_status], nil)
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def publish_read(topic_id:, post_number:, user:, notification_level: nil, private_message:)
|
|
klass =
|
|
if private_message
|
|
PrivateMessageTopicTrackingState
|
|
else
|
|
TopicTrackingState
|
|
end
|
|
|
|
klass.publish_read(topic_id, post_number, user, notification_level)
|
|
end
|
|
end
|
|
|
|
# Update the cached topic_user.liked column based on data
|
|
# from the post_actions table. This is useful when posts
|
|
# have moved around, or to ensure integrity of the data.
|
|
#
|
|
# By default this will update data for all topics and all users.
|
|
# The parameters can be used to shrink the scope, and make it faster.
|
|
# user_id, post_id and topic_id can optionally be arrays of ids.
|
|
#
|
|
# Providing post_id will automatically scope to the relevant user_id and topic_id.
|
|
# A provided `topic_id` value will always take precedence, which is
|
|
# useful when a post has been moved between topics.
|
|
def self.update_post_action_cache(
|
|
user_id: nil,
|
|
post_id: nil,
|
|
topic_id: nil,
|
|
post_action_type: :like
|
|
)
|
|
raise ArgumentError, "post_action_type must equal :like" if post_action_type != :like
|
|
raise ArgumentError, "post_id and user_id cannot be supplied together" if user_id && post_id
|
|
action_type_name = "liked"
|
|
|
|
builder = DB.build <<~SQL
|
|
UPDATE topic_users tu
|
|
SET #{action_type_name} = x.state
|
|
FROM (
|
|
SELECT CASE WHEN EXISTS (
|
|
SELECT 1
|
|
FROM post_actions pa
|
|
JOIN posts p on p.id = pa.post_id
|
|
JOIN topics t ON t.id = p.topic_id
|
|
WHERE pa.deleted_at IS NULL AND
|
|
p.deleted_at IS NULL AND
|
|
t.deleted_at IS NULL AND
|
|
pa.post_action_type_id = :action_type_id AND
|
|
tu2.topic_id = t.id AND
|
|
tu2.user_id = pa.user_id
|
|
LIMIT 1
|
|
) THEN true ELSE false END state, tu2.topic_id, tu2.user_id
|
|
FROM topic_users tu2
|
|
/*where*/
|
|
) x
|
|
WHERE x.topic_id = tu.topic_id AND x.user_id = tu.user_id AND x.state != tu.#{action_type_name}
|
|
SQL
|
|
|
|
builder.where("tu2.user_id IN (:user_id)", user_id: user_id) if user_id
|
|
|
|
builder.where("tu2.topic_id IN (:topic_id)", topic_id: topic_id) if topic_id
|
|
|
|
if post_id
|
|
if !topic_id
|
|
builder.where(
|
|
"tu2.topic_id IN (SELECT topic_id FROM posts WHERE id IN (:post_id))",
|
|
post_id: post_id,
|
|
)
|
|
end
|
|
builder.where(<<~SQL, post_id: post_id)
|
|
tu2.user_id IN (
|
|
SELECT user_id FROM post_actions
|
|
WHERE post_id IN (:post_id)
|
|
AND post_action_type_id = :action_type_id
|
|
)
|
|
SQL
|
|
end
|
|
|
|
builder.exec(action_type_id: PostActionType.types[post_action_type])
|
|
end
|
|
|
|
# cap number of unread topics at count, bumping up last_read if needed
|
|
def self.cap_unread!(user_id, count)
|
|
sql = <<SQL
|
|
UPDATE topic_users tu
|
|
SET last_read_post_number = max_number
|
|
FROM (
|
|
SELECT MAX(post_number) max_number, p.topic_id FROM posts p
|
|
WHERE deleted_at IS NULL
|
|
GROUP BY p.topic_id
|
|
) m
|
|
WHERE tu.user_id = :user_id AND
|
|
m.topic_id = tu.topic_id AND
|
|
tu.topic_id IN (
|
|
#{TopicTrackingState.report_raw_sql(skip_new: true, select: "topics.id")}
|
|
offset :count
|
|
)
|
|
SQL
|
|
|
|
DB.exec(sql, user_id: user_id, count: count)
|
|
end
|
|
|
|
def self.ensure_consistency!(topic_id = nil)
|
|
update_post_action_cache(topic_id: topic_id)
|
|
|
|
# TODO this needs some reworking, when we mark stuff skipped
|
|
# we up these numbers so they are not in-sync
|
|
# the simple fix is to add a column here, but table is already quite big
|
|
# long term we want to split up topic_users and allow for this better
|
|
builder = DB.build <<~SQL
|
|
UPDATE topic_users t
|
|
SET
|
|
last_read_post_number = LEAST(GREATEST(last_read, last_read_post_number), max_post_number)
|
|
FROM (
|
|
SELECT topic_id, user_id, MAX(post_number) last_read
|
|
FROM post_timings
|
|
GROUP BY topic_id, user_id
|
|
) as X
|
|
JOIN (
|
|
SELECT p.topic_id, MAX(p.post_number) max_post_number from posts p
|
|
GROUP BY p.topic_id
|
|
) as Y on Y.topic_id = X.topic_id
|
|
/*where*/
|
|
SQL
|
|
|
|
builder.where <<~SQL
|
|
X.topic_id = t.topic_id AND
|
|
X.user_id = t.user_id AND
|
|
(
|
|
last_read_post_number <> LEAST(GREATEST(last_read, last_read_post_number), max_post_number)
|
|
)
|
|
SQL
|
|
|
|
builder.where("t.topic_id = :topic_id", topic_id: topic_id) if topic_id
|
|
|
|
builder.exec
|
|
end
|
|
end
|
|
|
|
# == Schema Information
|
|
#
|
|
# Table name: topic_users
|
|
#
|
|
# user_id :integer not null
|
|
# topic_id :integer not null
|
|
# posted :boolean default(FALSE), not null
|
|
# last_read_post_number :integer
|
|
# last_visited_at :datetime
|
|
# first_visited_at :datetime
|
|
# notification_level :integer default(1), not null
|
|
# notifications_changed_at :datetime
|
|
# notifications_reason_id :integer
|
|
# total_msecs_viewed :integer default(0), not null
|
|
# cleared_pinned_at :datetime
|
|
# id :integer not null, primary key
|
|
# last_emailed_post_number :integer
|
|
# liked :boolean default(FALSE)
|
|
# bookmarked :boolean default(FALSE)
|
|
# last_posted_at :datetime
|
|
#
|
|
# Indexes
|
|
#
|
|
# index_topic_users_on_topic_id_and_notification_level (topic_id,notification_level)
|
|
# index_topic_users_on_topic_id_and_user_id (topic_id,user_id) UNIQUE
|
|
# index_topic_users_on_user_id_and_topic_id (user_id,topic_id) UNIQUE
|
|
#
|