mirror of
https://github.com/discourse/discourse.git
synced 2024-11-26 19:00:32 -06:00
5bd55acf83
Ensures that `UserStat#post_count` and `UserStat#topic_count` does not go below 0. When it does like it did now, we tend to have bugs in our code since we're usually coding with the assumption that the count isn't negative. In order to support the constraints, our post and topic fabricators in tests will now automatically increment the count for the respective user's `UserStat` as well. We have to do this because our fabricators bypasss `PostCreator` which holds the responsibility of updating `UserStat#post_count` and `UserStat#topic_count`.
421 lines
15 KiB
Ruby
421 lines
15 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
#
|
|
# How a post is deleted is affected by who is performing the action.
|
|
# this class contains the logic to delete it.
|
|
#
|
|
class PostDestroyer
|
|
|
|
def self.destroy_old_hidden_posts
|
|
Post.where(deleted_at: nil, hidden: true)
|
|
.where("hidden_at < ?", 30.days.ago)
|
|
.find_each do |post|
|
|
PostDestroyer.new(Discourse.system_user, post).destroy
|
|
end
|
|
end
|
|
|
|
def self.destroy_stubs
|
|
context = I18n.t('remove_posts_deleted_by_author')
|
|
|
|
# exclude deleted topics and posts that are actively flagged
|
|
Post.where(deleted_at: nil, user_deleted: true)
|
|
.where("NOT EXISTS (
|
|
SELECT 1 FROM topics t
|
|
WHERE t.deleted_at IS NOT NULL AND
|
|
t.id = posts.topic_id
|
|
)")
|
|
.where("updated_at < ?", SiteSetting.delete_removed_posts_after.hours.ago)
|
|
.where("NOT EXISTS (
|
|
SELECT 1
|
|
FROM post_actions pa
|
|
WHERE pa.post_id = posts.id
|
|
AND pa.deleted_at IS NULL
|
|
AND pa.deferred_at IS NULL
|
|
AND pa.post_action_type_id IN (?)
|
|
)", PostActionType.notify_flag_type_ids)
|
|
.find_each do |post|
|
|
|
|
PostDestroyer.new(Discourse.system_user, post, context: context).destroy
|
|
end
|
|
end
|
|
|
|
def self.delete_with_replies(performed_by, post, reviewable = nil, defer_reply_flags: true)
|
|
reply_ids = post.reply_ids(Guardian.new(performed_by), only_replies_to_single_post: false)
|
|
replies = Post.where(id: reply_ids.map { |r| r[:id] })
|
|
PostDestroyer.new(performed_by, post, reviewable: reviewable).destroy
|
|
|
|
options = { defer_flags: defer_reply_flags }
|
|
options.merge!({ reviewable: reviewable, notify_responders: true, parent_post: post }) if SiteSetting.notify_users_after_responses_deleted_on_flagged_post
|
|
replies.each { |reply| PostDestroyer.new(performed_by, reply, options).destroy }
|
|
end
|
|
|
|
def initialize(user, post, opts = {})
|
|
@user = user
|
|
@post = post
|
|
@topic = post.topic if post
|
|
@opts = opts
|
|
end
|
|
|
|
def destroy
|
|
payload = WebHook.generate_payload(:post, @post) if WebHook.active_web_hooks(:post).exists?
|
|
topic = Topic.with_deleted.find_by(id: @post.topic_id)
|
|
is_first_post = @post.is_first_post? && topic
|
|
has_topic_web_hooks = is_first_post && WebHook.active_web_hooks(:topic).exists?
|
|
|
|
if has_topic_web_hooks
|
|
topic_view = TopicView.new(topic.id, Discourse.system_user, skip_staff_action: true)
|
|
topic_payload = WebHook.generate_payload(:topic, topic_view, WebHookTopicViewSerializer)
|
|
end
|
|
|
|
delete_removed_posts_after = @opts[:delete_removed_posts_after] || SiteSetting.delete_removed_posts_after
|
|
|
|
if delete_removed_posts_after < 1 || post_is_reviewable? || Guardian.new(@user).can_moderate_topic?(topic) || permanent?
|
|
perform_delete
|
|
elsif @user.id == @post.user_id
|
|
mark_for_deletion(delete_removed_posts_after)
|
|
end
|
|
|
|
UserActionManager.post_destroyed(@post)
|
|
|
|
DiscourseEvent.trigger(:post_destroyed, @post, @opts, @user)
|
|
WebHook.enqueue_post_hooks(:post_destroyed, @post, payload)
|
|
Jobs.enqueue(:sync_topic_user_bookmarked, topic_id: topic.id) if topic
|
|
|
|
if is_first_post
|
|
UserProfile.remove_featured_topic_from_all_profiles(topic)
|
|
UserActionManager.topic_destroyed(topic)
|
|
DiscourseEvent.trigger(:topic_destroyed, topic, @user)
|
|
WebHook.enqueue_topic_hooks(:topic_destroyed, topic, topic_payload) if has_topic_web_hooks
|
|
end
|
|
end
|
|
|
|
def recover
|
|
if (post_is_reviewable? || Guardian.new(@user).can_moderate_topic?(@post.topic)) && @post.deleted_at
|
|
staff_recovered
|
|
elsif @user.staff? || @user.id == @post.user_id
|
|
user_recovered
|
|
end
|
|
topic = Topic.with_deleted.find @post.topic_id
|
|
topic.update_column(:user_id, Discourse::SYSTEM_USER_ID) if !topic.user_id
|
|
topic.recover!(@user) if @post.is_first_post?
|
|
topic.update_statistics
|
|
|
|
UserActionManager.post_created(@post)
|
|
DiscourseEvent.trigger(:post_recovered, @post, @opts, @user)
|
|
Jobs.enqueue(:sync_topic_user_bookmarked, topic_id: topic.id) if topic
|
|
|
|
if @post.is_first_post?
|
|
UserActionManager.topic_created(topic)
|
|
DiscourseEvent.trigger(:topic_recovered, topic, @user)
|
|
StaffActionLogger.new(@user).log_topic_delete_recover(topic, "recover_topic", @opts.slice(:context)) if @user.id != @post.user_id
|
|
update_imap_sync(@post, false)
|
|
end
|
|
end
|
|
|
|
def staff_recovered
|
|
new_post_attrs = { user_deleted: false }
|
|
new_post_attrs[:user_id] = Discourse::SYSTEM_USER_ID if !@post.user_id
|
|
@post.update_columns(new_post_attrs)
|
|
@post.recover!
|
|
|
|
mark_topic_changed
|
|
|
|
if @post.topic && !@post.topic.private_message?
|
|
if author = @post.user
|
|
if @post.is_first_post?
|
|
author.user_stat.topic_count += 1
|
|
else
|
|
author.user_stat.post_count += 1
|
|
end
|
|
author.user_stat.save!
|
|
end
|
|
|
|
if @post.is_first_post?
|
|
# Update stats of all people who replied
|
|
counts = Post.where(post_type: Post.types[:regular], topic_id: @post.topic_id).where('post_number > 1').group(:user_id).count
|
|
counts.each do |user_id, count|
|
|
if user_stat = UserStat.where(user_id: user_id).first
|
|
user_stat.update(post_count: user_stat.post_count + count)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
@post.publish_change_to_clients! :recovered
|
|
TopicTrackingState.publish_recover(@post.topic) if @post.topic && @post.is_first_post?
|
|
end
|
|
|
|
# When a post is properly deleted. Well, it's still soft deleted, but it will no longer
|
|
# show up in the topic
|
|
# Permanent option allows to hard delete.
|
|
def perform_delete
|
|
Post.transaction do
|
|
permanent? ? @post.destroy! : @post.trash!(@user)
|
|
if @post.topic
|
|
make_previous_post_the_last_one
|
|
mark_topic_changed
|
|
clear_user_posted_flag
|
|
end
|
|
|
|
Topic.reset_highest(@post.topic_id)
|
|
trash_public_post_actions
|
|
trash_revisions
|
|
trash_user_actions
|
|
remove_associated_replies
|
|
remove_associated_notifications
|
|
|
|
if @user.id != @post.user_id && !@opts[:skip_staff_log]
|
|
if @post.topic && @post.is_first_post?
|
|
StaffActionLogger.new(@user).log_topic_delete_recover(@post.topic, "delete_topic", @opts.slice(:context))
|
|
else
|
|
StaffActionLogger.new(@user).log_post_deletion(@post, @opts.slice(:context))
|
|
end
|
|
end
|
|
|
|
if @post.topic && @post.is_first_post?
|
|
permanent? ? @post.topic.destroy! : @post.topic.trash!(@user)
|
|
PublishedPage.unpublish!(@user, @post.topic) if @post.topic.published_page
|
|
end
|
|
TopicLink.where(link_post_id: @post.id).destroy_all
|
|
update_associated_category_latest_topic
|
|
update_user_counts if !permanent?
|
|
TopicUser.update_post_action_cache(post_id: @post.id)
|
|
|
|
DB.after_commit do
|
|
if @opts[:reviewable]
|
|
notify_deletion(@opts[:reviewable], { notify_responders: @opts[:notify_responders], parent_post: @opts[:parent_post] })
|
|
ignore(@post.reviewable_flag) if @post.reviewable_flag && SiteSetting.notify_users_after_responses_deleted_on_flagged_post
|
|
elsif reviewable = @post.reviewable_flag
|
|
@opts[:defer_flags] ? ignore(reviewable) : agree(reviewable)
|
|
end
|
|
end
|
|
end
|
|
|
|
update_imap_sync(@post, true) if @post.topic&.deleted_at
|
|
feature_users_in_the_topic if @post.topic
|
|
@post.publish_change_to_clients!(permanent? ? :destroyed : :deleted) if @post.topic
|
|
TopicTrackingState.send(permanent? ? :publish_destroy : :publish_delete, @post.topic) if @post.topic && @post.post_number == 1
|
|
end
|
|
|
|
def permanent?
|
|
@opts[:force_destroy] || (@opts[:permanent] && @user == @post.user && @post.topic.private_message?)
|
|
end
|
|
|
|
# When a user 'deletes' their own post. We just change the text.
|
|
def mark_for_deletion(delete_removed_posts_after = SiteSetting.delete_removed_posts_after)
|
|
I18n.with_locale(SiteSetting.default_locale) do
|
|
|
|
# don't call revise from within transaction, high risk of deadlock
|
|
key = @post.is_first_post? ? 'js.topic.deleted_by_author_simple' : 'js.post.deleted_by_author_simple'
|
|
@post.revise(@user,
|
|
{ raw: I18n.t(key) },
|
|
force_new_version: true,
|
|
deleting_post: true,
|
|
skip_validations: true
|
|
)
|
|
|
|
Post.transaction do
|
|
@post.update_column(:user_deleted, true)
|
|
@post.topic_links.each(&:destroy)
|
|
@post.topic.update_column(:closed, true) if @post.is_first_post?
|
|
end
|
|
end
|
|
end
|
|
|
|
def user_recovered
|
|
return unless @post.user_deleted?
|
|
|
|
Post.transaction do
|
|
@post.update_column(:user_deleted, false)
|
|
@post.skip_unique_check = true
|
|
@post.topic.update_column(:closed, false) if @post.is_first_post?
|
|
end
|
|
|
|
# has internal transactions, if we nest then there are some very high risk deadlocks
|
|
last_revision = @post.revisions.last
|
|
if last_revision.present? && last_revision.modifications['raw'].present?
|
|
@post.revise(@user, { raw: last_revision.modifications["raw"][0] }, force_new_version: true)
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def post_is_reviewable?
|
|
return true if @user.staff?
|
|
|
|
topic = @post.topic || Topic.with_deleted.find(@post.topic_id)
|
|
Guardian.new(@user).can_review_topic?(topic) && Reviewable.exists?(target: @post)
|
|
end
|
|
|
|
# we need topics to change if ever a post in them is deleted or created
|
|
# this ensures users relying on this information can keep unread tracking
|
|
# working as desired
|
|
def mark_topic_changed
|
|
# make this as fast as possible, can bypass everything
|
|
DB.exec(<<~SQL, updated_at: Time.now, id: @post.topic_id)
|
|
UPDATE topics
|
|
SET updated_at = :updated_at
|
|
WHERE id = :id
|
|
SQL
|
|
end
|
|
|
|
def make_previous_post_the_last_one
|
|
last_post = Post.where("topic_id = ? and id <> ?", @post.topic_id, @post.id)
|
|
.select(:created_at, :user_id, :post_number)
|
|
.where("topic_id = ? and id <> ?", @post.topic_id, @post.id)
|
|
.where.not(user_id: nil)
|
|
.where.not(post_type: Post.types[:whisper])
|
|
.order('created_at desc')
|
|
.limit(1)
|
|
.first
|
|
|
|
if last_post.present?
|
|
topic = @post.topic
|
|
topic.last_posted_at = last_post.created_at
|
|
topic.last_post_user_id = last_post.user_id
|
|
topic.highest_post_number = last_post.post_number
|
|
|
|
# we go via save here cause we need to run hooks
|
|
topic.save!(validate: false)
|
|
end
|
|
end
|
|
|
|
def clear_user_posted_flag
|
|
unless Post.exists?(["topic_id = ? and user_id = ? and id <> ?", @post.topic_id, @post.user_id, @post.id])
|
|
TopicUser.where(topic_id: @post.topic_id, user_id: @post.user_id).update_all 'posted = false'
|
|
end
|
|
end
|
|
|
|
def feature_users_in_the_topic
|
|
Jobs.enqueue(:feature_topic_users, topic_id: @post.topic_id)
|
|
end
|
|
|
|
def trash_public_post_actions
|
|
if public_post_actions = PostAction.publics.where(post_id: @post.id)
|
|
public_post_actions.each { |pa| permanent? ? pa.destroy! : pa.trash!(@user) }
|
|
|
|
return if permanent?
|
|
|
|
@post.custom_fields["deleted_public_actions"] = public_post_actions.ids
|
|
@post.save_custom_fields
|
|
|
|
f = PostActionType.public_types.map { |k, _| ["#{k}_count", 0] }
|
|
Post.with_deleted.where(id: @post.id).update_all(Hash[*f.flatten])
|
|
end
|
|
end
|
|
|
|
def trash_revisions
|
|
return unless permanent?
|
|
@post.revisions.each(&:destroy!)
|
|
end
|
|
|
|
def agree(reviewable)
|
|
notify_deletion(reviewable)
|
|
result = reviewable.perform(@user, :agree_and_keep, post_was_deleted: true)
|
|
reviewable.transition_to(result.transition_to, @user)
|
|
end
|
|
|
|
def ignore(reviewable)
|
|
reviewable.perform_ignore(@user, post_was_deleted: true)
|
|
reviewable.transition_to(:ignored, @user)
|
|
end
|
|
|
|
def notify_deletion(reviewable, options = {})
|
|
return if @post.user.blank?
|
|
|
|
allowed_user = @user.human? && @user.staff?
|
|
return unless allowed_user && rs = reviewable.reviewable_scores.order('created_at DESC').first
|
|
|
|
notify_responders = options[:notify_responders]
|
|
|
|
Jobs.enqueue(
|
|
:send_system_message,
|
|
user_id: @post.user_id,
|
|
message_type: notify_responders ? :flags_agreed_and_post_deleted_for_responders : :flags_agreed_and_post_deleted,
|
|
message_options: {
|
|
flagged_post_raw_content: notify_responders ? options[:parent_post].raw : @post.raw,
|
|
flagged_post_response_raw_content: @post.raw,
|
|
url: notify_responders ? options[:parent_post].url : @post.url,
|
|
flag_reason: I18n.t(
|
|
"flag_reasons#{".responder" if notify_responders}.#{PostActionType.types[rs.reviewable_score_type]}",
|
|
locale: SiteSetting.default_locale,
|
|
base_path: Discourse.base_path
|
|
)
|
|
}
|
|
)
|
|
end
|
|
|
|
def trash_user_actions
|
|
UserAction.where(target_post_id: @post.id).each do |ua|
|
|
row = {
|
|
action_type: ua.action_type,
|
|
user_id: ua.user_id,
|
|
acting_user_id: ua.acting_user_id,
|
|
target_topic_id: ua.target_topic_id,
|
|
target_post_id: ua.target_post_id
|
|
}
|
|
UserAction.remove_action!(row)
|
|
end
|
|
end
|
|
|
|
def remove_associated_replies
|
|
post_ids = PostReply.where(reply_post_id: @post.id).pluck(:post_id)
|
|
|
|
if post_ids.present?
|
|
PostReply.where(reply_post_id: @post.id).delete_all
|
|
Post.where(id: post_ids).each { |p| p.update_column :reply_count, p.replies.count }
|
|
end
|
|
end
|
|
|
|
def remove_associated_notifications
|
|
Notification
|
|
.where(topic_id: @post.topic_id, post_number: @post.post_number)
|
|
.delete_all
|
|
end
|
|
|
|
def update_associated_category_latest_topic
|
|
return unless @post.topic && @post.topic.category
|
|
return unless @post.id == @post.topic.category.latest_post_id || (@post.is_first_post? && @post.topic_id == @post.topic.category.latest_topic_id)
|
|
|
|
@post.topic.category.update_latest
|
|
end
|
|
|
|
def update_user_counts
|
|
author = @post.user
|
|
|
|
return unless author
|
|
|
|
author.create_user_stat if author.user_stat.nil?
|
|
|
|
if @post.created_at == author.user_stat.first_post_created_at
|
|
author.user_stat.update!(first_post_created_at: author.posts.order('created_at ASC').first.try(:created_at))
|
|
end
|
|
|
|
UserStatCountUpdater.decrement!(@post)
|
|
|
|
if @post.created_at == author.last_posted_at
|
|
author.last_posted_at = author.posts.order('created_at DESC').first.try(:created_at)
|
|
author.save!
|
|
end
|
|
|
|
if @post.is_first_post? && @post.topic && !@post.topic.private_message?
|
|
# Update stats of all people who replied
|
|
counts = Post.where(post_type: Post.types[:regular], topic_id: @post.topic_id).where('post_number > 1').group(:user_id).count
|
|
|
|
counts.each do |user_id, count|
|
|
if user_stat = UserStat.where(user_id: user_id).first
|
|
user_stat.update(post_count: user_stat.post_count - count)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def update_imap_sync(post, sync)
|
|
return if !SiteSetting.enable_imap
|
|
incoming = IncomingEmail.find_by(post_id: post.id, topic_id: post.topic_id)
|
|
return if !incoming || !incoming.imap_uid
|
|
incoming.update(imap_sync: sync)
|
|
end
|
|
|
|
end
|