mirror of
https://github.com/discourse/discourse.git
synced 2024-11-24 13:56:50 +08:00
5dc45b5dcf
* FIX: Secure upload post processing race condition This commit fixes a couple of issues. A little background -- when uploads are created in the composer for posts, regardless of whether the upload will eventually be marked secure or not, if secure_uploads is enabled we always mark the upload secure at first. This is so the upload is by default protected, regardless of post type (regular or PM) or category. This was causing issues in some rare occasions though because of the order of operations of our post creation and processing pipeline. When creating a post, we enqueue a sidekiq job to post-process the post which does various things including converting images to lightboxes. We were also enqueuing a job to update the secure status for all uploads in that post. Sometimes the secure status job would run before the post process job, marking uploads as _not secure_ in the background and changing their ACL before the post processor ran, which meant the users would see a broken image in their posts. This commit fixes that issue by always running the upload security changes inline _within_ the cooked_post_processor job. The other issue was that the lightbox wrapper link for images in the post would end up with a URL like this: ``` href="/secure-uploads/original/2X/4/4e1f00a40b6c952198bbdacae383ba77932fc542.jpeg" ``` Since we weren't actually using the `upload.url` to pass to `UrlHelper.cook_url` here, we weren't converting this href to the CDN URL if the post was not in a secure context (the UrlHelper does not know how to convert a secure-uploads URL to a CDN one). Now we always end up with the correct lightbox href. This was less of an issue than the other one, since the secure-uploads URL works even when the upload has become non-secure, but it was a good inconsistency to fix anyway.
668 lines
20 KiB
Ruby
668 lines
20 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
# Responsible for creating posts and topics
|
|
#
|
|
|
|
class PostCreator
|
|
include HasErrors
|
|
|
|
attr_reader :opts, :post
|
|
|
|
# Acceptable options:
|
|
#
|
|
# raw - raw text of post
|
|
# image_sizes - We can pass a list of the sizes of images in the post as a shortcut.
|
|
# invalidate_oneboxes - Whether to force invalidation of oneboxes in this post
|
|
# acting_user - The user performing the action might be different than the user
|
|
# who is the post "author." For example when copying posts to a new
|
|
# topic.
|
|
# created_at - Post creation time (optional)
|
|
# auto_track - Automatically track this topic if needed (default true)
|
|
# custom_fields - Custom fields to be added to the post, Hash (default nil)
|
|
# post_type - Whether this is a regular post or moderator post.
|
|
# no_bump - Do not cause this post to bump the topic.
|
|
# cooking_options - Options for rendering the text
|
|
# cook_method - Method of cooking the post.
|
|
# :regular - Pass through Markdown parser and strip bad HTML
|
|
# :raw_html - Perform no processing
|
|
# :raw_email - Imported from an email
|
|
# via_email - Mark this post as arriving via email
|
|
# raw_email - Full text of arriving email (to store)
|
|
# action_code - Describes a small_action post (optional)
|
|
# skip_jobs - Don't enqueue jobs when creation succeeds. This is needed if you
|
|
# wrap `PostCreator` in a transaction, as the sidekiq jobs could
|
|
# dequeue before the commit finishes. If you do this, be sure to
|
|
# call `enqueue_jobs` after the transaction is committed.
|
|
# hidden_reason_id - Reason for hiding the post (optional)
|
|
# skip_validations - Do not validate any of the content in the post
|
|
# draft_key - the key of the draft we are creating (will be deleted on success)
|
|
# advance_draft - Destroy draft after creating post or topic
|
|
# silent - Do not update topic stats and fields like last_post_user_id
|
|
#
|
|
# When replying to a topic:
|
|
# topic_id - topic we're replying to
|
|
# reply_to_post_number - post number we're replying to
|
|
#
|
|
# When creating a topic:
|
|
# title - New topic title
|
|
# archetype - Topic archetype
|
|
# is_warning - Is the topic a warning?
|
|
# category - Category to assign to topic
|
|
# target_usernames - comma delimited list of usernames for membership (private message)
|
|
# target_group_names - comma delimited list of groups for membership (private message)
|
|
# created_at - Topic creation time (optional)
|
|
# pinned_at - Topic pinned time (optional)
|
|
# pinned_globally - Is the topic pinned globally (optional)
|
|
# shared_draft - Is the topic meant to be a shared draft
|
|
# topic_opts - Options to be overwritten for topic
|
|
#
|
|
def initialize(user, opts)
|
|
# TODO: we should reload user in case it is tainted, should take in a user_id as opposed to user
|
|
# If we don't do this we introduce a rather risky dependency
|
|
@user = user
|
|
@spam = false
|
|
@opts = opts || {}
|
|
|
|
opts[:title] = pg_clean_up(opts[:title]) if opts[:title]&.include?("\u0000")
|
|
opts[:raw] = pg_clean_up(opts[:raw]) if opts[:raw]&.include?("\u0000")
|
|
opts[:visible] = false if opts[:visible].nil? && opts[:hidden_reason_id].present?
|
|
|
|
opts.delete(:reply_to_post_number) unless opts[:topic_id]
|
|
end
|
|
|
|
def pg_clean_up(str)
|
|
str.gsub("\u0000", "")
|
|
end
|
|
|
|
def spam?
|
|
@spam
|
|
end
|
|
|
|
def skip_validations?
|
|
@opts[:skip_validations]
|
|
end
|
|
|
|
def guardian
|
|
@guardian ||= @opts[:guardian] || Guardian.new(@user)
|
|
end
|
|
|
|
def valid?
|
|
@topic = nil
|
|
@post = nil
|
|
|
|
if @user.suspended? && !skip_validations?
|
|
errors.add(:base, I18n.t(:user_is_suspended))
|
|
return false
|
|
end
|
|
|
|
if @opts[:target_usernames].present? && !skip_validations? && !@user.staff?
|
|
names = @opts[:target_usernames].split(",").flatten.map(&:downcase)
|
|
|
|
# Make sure max_allowed_message_recipients setting is respected
|
|
max_allowed_message_recipients = SiteSetting.max_allowed_message_recipients
|
|
|
|
if names.length > max_allowed_message_recipients
|
|
errors.add(
|
|
:base,
|
|
I18n.t(:max_pm_recipients, recipients_limit: max_allowed_message_recipients),
|
|
)
|
|
|
|
return false
|
|
end
|
|
|
|
# Make sure none of the users have muted or ignored the creator or prevented
|
|
# PMs from being sent to them
|
|
target_users = User.where(username_lower: names.map(&:downcase)).pluck(:id, :username).to_h
|
|
UserCommScreener
|
|
.new(acting_user: @user, target_user_ids: target_users.keys)
|
|
.preventing_actor_communication
|
|
.each do |user_id|
|
|
errors.add(:base, I18n.t(:not_accepting_pms, username: target_users[user_id]))
|
|
end
|
|
|
|
return false if errors[:base].present?
|
|
end
|
|
|
|
if new_topic?
|
|
topic_creator = TopicCreator.new(@user, guardian, @opts)
|
|
return false unless skip_validations? || validate_child(topic_creator)
|
|
else
|
|
@topic = Topic.find_by(id: @opts[:topic_id])
|
|
|
|
if @topic.present? && @opts[:archetype] == Archetype.private_message
|
|
errors.add(:base, I18n.t(:create_pm_on_existing_topic))
|
|
return false
|
|
end
|
|
|
|
if guardian.affected_by_slow_mode?(@topic)
|
|
tu = TopicUser.find_by(user: @user, topic: @topic)
|
|
|
|
if tu&.last_posted_at
|
|
threshold = tu.last_posted_at + @topic.slow_mode_seconds.seconds
|
|
|
|
if DateTime.now < threshold
|
|
errors.add(:base, I18n.t(:slow_mode_enabled))
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
|
|
if @topic.blank? || !(@opts[:skip_guardian] || guardian.can_create?(Post, @topic))
|
|
errors.add(:base, I18n.t(:topic_not_found))
|
|
return false
|
|
end
|
|
end
|
|
|
|
setup_post
|
|
|
|
return true if skip_validations?
|
|
|
|
if @post.has_host_spam?
|
|
@spam = true
|
|
errors.add(:base, I18n.t(:spamming_host))
|
|
return false
|
|
end
|
|
|
|
DiscourseEvent.trigger :before_create_post, @post, @opts
|
|
DiscourseEvent.trigger :validate_post, @post
|
|
|
|
post_validator =
|
|
PostValidator.new(
|
|
skip_topic: true,
|
|
private_message: @opts[:archetype] == Archetype.private_message,
|
|
)
|
|
post_validator.validate(@post)
|
|
|
|
valid = @post.errors.blank?
|
|
add_errors_from(@post) unless valid
|
|
valid
|
|
end
|
|
|
|
def create
|
|
if valid?
|
|
transaction do
|
|
build_post_stats
|
|
create_topic
|
|
create_post_notice
|
|
save_post
|
|
UserActionManager.post_created(@post)
|
|
extract_links
|
|
track_topic
|
|
update_topic_stats
|
|
update_topic_auto_close
|
|
update_user_counts
|
|
create_embedded_topic
|
|
@post.link_post_uploads
|
|
delete_owned_bookmarks
|
|
ensure_in_allowed_users if guardian.is_staff?
|
|
unarchive_message if !@opts[:import_mode]
|
|
DraftSequence.next!(@user, draft_key) if !@opts[:import_mode] && @opts[:advance_draft]
|
|
@post.save_reply_relationships
|
|
end
|
|
end
|
|
|
|
if @post && errors.blank? && !@opts[:import_mode]
|
|
store_unique_post_key
|
|
# update counters etc.
|
|
@post.topic.reload
|
|
|
|
publish
|
|
|
|
track_latest_on_category
|
|
enqueue_jobs unless @opts[:skip_jobs]
|
|
BadgeGranter.queue_badge_grant(Badge::Trigger::PostRevision, post: @post)
|
|
|
|
trigger_after_events unless opts[:skip_events]
|
|
|
|
auto_close
|
|
end
|
|
|
|
if !opts[:import_mode]
|
|
handle_spam if (@spam || @post)
|
|
|
|
ReviewablePost.queue_for_review_if_possible(@post, @user) if !@spam && @post && errors.blank?
|
|
end
|
|
|
|
@post
|
|
end
|
|
|
|
def create!
|
|
create
|
|
|
|
if !self.errors.full_messages.empty?
|
|
raise ActiveRecord::RecordNotSaved.new(self.errors.full_messages.to_sentence)
|
|
end
|
|
|
|
@post
|
|
end
|
|
|
|
def enqueue_jobs
|
|
return unless @post && !@post.errors.present?
|
|
|
|
PostJobsEnqueuer.new(
|
|
@post,
|
|
@topic,
|
|
new_topic?,
|
|
import_mode: @opts[:import_mode],
|
|
post_alert_options: @opts[:post_alert_options],
|
|
).enqueue_jobs
|
|
end
|
|
|
|
def trigger_after_events
|
|
DiscourseEvent.trigger(:topic_created, @post.topic, @opts, @user) unless @opts[:topic_id]
|
|
DiscourseEvent.trigger(:post_created, @post, @opts, @user)
|
|
end
|
|
|
|
def self.track_post_stats
|
|
Rails.env != "test" || @track_post_stats
|
|
end
|
|
|
|
def self.track_post_stats=(val)
|
|
@track_post_stats = val
|
|
end
|
|
|
|
def self.create(user, opts)
|
|
PostCreator.new(user, opts).create
|
|
end
|
|
|
|
def self.create!(user, opts)
|
|
PostCreator.new(user, opts).create!
|
|
end
|
|
|
|
def self.before_create_tasks(post)
|
|
set_reply_info(post)
|
|
|
|
post.word_count = post.raw.scan(/[[:word:]]+/).size
|
|
|
|
whisper = post.post_type == Post.types[:whisper]
|
|
increase_posts_count =
|
|
!post.topic&.private_message? || post.post_type != Post.types[:small_action]
|
|
post.post_number ||=
|
|
Topic.next_post_number(
|
|
post.topic_id,
|
|
reply: post.reply_to_post_number.present?,
|
|
whisper: whisper,
|
|
post: increase_posts_count,
|
|
)
|
|
|
|
cooking_options = post.cooking_options || {}
|
|
cooking_options[:topic_id] = post.topic_id
|
|
|
|
post.cooked ||= post.cook(post.raw, cooking_options.symbolize_keys)
|
|
post.sort_order = post.post_number
|
|
post.last_version_at ||= Time.now
|
|
end
|
|
|
|
def self.set_reply_info(post)
|
|
return unless post.reply_to_post_number.present?
|
|
|
|
# Before the locking here was added, replying to a post and liking a post
|
|
# at roughly the same time could cause a deadlock.
|
|
#
|
|
# Liking a post grabs an update lock on the post and then on the topic (to
|
|
# update like counts).
|
|
#
|
|
# Here, we lock the replied to post before getting the topic lock so that
|
|
# we can update the replied to post later without causing a deadlock.
|
|
|
|
reply_info =
|
|
Post
|
|
.where(topic_id: post.topic_id, post_number: post.reply_to_post_number)
|
|
.select(:user_id, :post_type)
|
|
.lock
|
|
.first
|
|
|
|
if reply_info.present?
|
|
post.reply_to_user_id ||= reply_info.user_id
|
|
whisper_type = Post.types[:whisper]
|
|
post.post_type = whisper_type if reply_info.post_type == whisper_type
|
|
end
|
|
end
|
|
|
|
protected
|
|
|
|
def draft_key
|
|
@draft_key ||= @opts[:draft_key]
|
|
@draft_key ||= @topic ? @topic.draft_key : Draft::NEW_TOPIC
|
|
end
|
|
|
|
def build_post_stats
|
|
if PostCreator.track_post_stats
|
|
sequence = DraftSequence.current(@user, draft_key)
|
|
revisions =
|
|
Draft.where(sequence: sequence, user_id: @user.id, draft_key: draft_key).pick(:revisions) ||
|
|
0
|
|
|
|
@post.build_post_stat(
|
|
drafts_saved: revisions,
|
|
typing_duration_msecs: @opts[:typing_duration_msecs] || 0,
|
|
composer_open_duration_msecs: @opts[:composer_open_duration_msecs] || 0,
|
|
)
|
|
end
|
|
end
|
|
|
|
def auto_close
|
|
topic = @post.topic
|
|
is_private_message = topic.private_message?
|
|
topic_posts_count = @post.topic.posts_count
|
|
|
|
if is_private_message && !topic.closed && SiteSetting.auto_close_messages_post_count > 0 &&
|
|
SiteSetting.auto_close_messages_post_count <= topic_posts_count
|
|
@post.topic.update_status(
|
|
:closed,
|
|
true,
|
|
Discourse.system_user,
|
|
message:
|
|
I18n.t(
|
|
"topic_statuses.autoclosed_message_max_posts",
|
|
count: SiteSetting.auto_close_messages_post_count,
|
|
locale: SiteSetting.default_locale,
|
|
),
|
|
)
|
|
elsif !is_private_message && !topic.closed && SiteSetting.auto_close_topics_post_count > 0 &&
|
|
SiteSetting.auto_close_topics_post_count <= topic_posts_count
|
|
topic.update_status(
|
|
:closed,
|
|
true,
|
|
Discourse.system_user,
|
|
message:
|
|
I18n.t(
|
|
"topic_statuses.autoclosed_topic_max_posts",
|
|
count: SiteSetting.auto_close_topics_post_count,
|
|
locale: SiteSetting.default_locale,
|
|
),
|
|
)
|
|
|
|
if SiteSetting.auto_close_topics_create_linked_topic?
|
|
# enqueue a job to create a linked topic
|
|
Jobs.enqueue_in(5.seconds, :create_linked_topic, post_id: @post.id)
|
|
end
|
|
end
|
|
end
|
|
|
|
def transaction(&blk)
|
|
if new_topic?
|
|
Post.transaction { blk.call }
|
|
else
|
|
# we need to ensure post_number is monotonically increasing with no gaps
|
|
# so we serialize creation to avoid needing rollbacks
|
|
DistributedMutex.synchronize("topic_id_#{@opts[:topic_id]}") { Post.transaction { blk.call } }
|
|
end
|
|
end
|
|
|
|
# You can supply an `embed_url` for a post to set up the embedded relationship.
|
|
# This is used by the wp-discourse plugin to associate a remote post with a
|
|
# discourse post.
|
|
def create_embedded_topic
|
|
return unless @opts[:embed_url].present?
|
|
|
|
original_uri = URI.parse(@opts[:embed_url])
|
|
raise Discourse::InvalidParameters.new(:embed_url) unless original_uri.is_a?(URI::HTTP)
|
|
|
|
embed =
|
|
TopicEmbed.new(topic_id: @post.topic_id, post_id: @post.id, embed_url: @opts[:embed_url])
|
|
rollback_from_errors!(embed) unless embed.save
|
|
end
|
|
|
|
def delete_owned_bookmarks
|
|
return if !@post.topic_id
|
|
BookmarkManager.new(@user).destroy_for_topic(
|
|
Topic.with_deleted.find(@post.topic_id),
|
|
{ auto_delete_preference: Bookmark.auto_delete_preferences[:on_owner_reply] },
|
|
@opts,
|
|
)
|
|
end
|
|
|
|
def handle_spam
|
|
if @spam
|
|
GroupMessage.create(
|
|
Group[:moderators].name,
|
|
:spam_post_blocked,
|
|
user: @user,
|
|
limit_once_per: 24.hours,
|
|
message_params: {
|
|
domains: @post.linked_hosts.keys.join(", "),
|
|
},
|
|
)
|
|
elsif @post && errors.blank? && !skip_validations?
|
|
SpamRule::FlagSockpuppets.new(@post).perform
|
|
end
|
|
end
|
|
|
|
def track_latest_on_category
|
|
return unless @post && @post.errors.count == 0 && @topic && @topic.category_id
|
|
|
|
if @post.is_first_post?
|
|
Category.where(id: @topic.category_id).update_all(
|
|
latest_topic_id: @topic.id,
|
|
latest_post_id: @post.id,
|
|
)
|
|
else
|
|
Category.where(id: @topic.category_id).update_all(latest_post_id: @post.id)
|
|
end
|
|
end
|
|
|
|
def ensure_in_allowed_users
|
|
return unless @topic.private_message? && @topic.id
|
|
return if @post.whisper? || @post.post_type == Post.types[:small_action]
|
|
return if @topic.topic_allowed_users.exists?(user_id: @user.id)
|
|
|
|
if @topic
|
|
.topic_allowed_groups
|
|
.where("group_id IN (SELECT group_id FROM group_users where user_id = ?)", @user.id)
|
|
.exists?
|
|
return
|
|
end
|
|
|
|
@topic.topic_allowed_users.create!(user_id: @user.id)
|
|
end
|
|
|
|
def unarchive_message
|
|
return unless @topic.private_message? && @topic.id
|
|
|
|
UserArchivedMessage
|
|
.where(topic_id: @topic.id)
|
|
.pluck(:user_id)
|
|
.each { |user_id| UserArchivedMessage.move_to_inbox!(user_id, @topic) }
|
|
|
|
GroupArchivedMessage
|
|
.where(topic_id: @topic.id)
|
|
.pluck(:group_id)
|
|
.each do |group_id|
|
|
GroupArchivedMessage.move_to_inbox!(group_id, @topic, acting_user_id: @user.id)
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def create_topic
|
|
return if @topic
|
|
begin
|
|
opts = @opts[:topic_opts] ? @opts.merge(@opts[:topic_opts]) : @opts
|
|
topic_creator = TopicCreator.new(@user, guardian, opts)
|
|
@topic = topic_creator.create
|
|
rescue ActiveRecord::Rollback
|
|
rollback_from_errors!(topic_creator)
|
|
end
|
|
@post.topic_id = @topic.id
|
|
@post.topic = @topic
|
|
@post.wiki = true if @topic && @topic.category && @topic.category.all_topics_wiki
|
|
end
|
|
|
|
def update_topic_stats
|
|
attrs = { updated_at: Time.now }
|
|
|
|
if @post.post_type != Post.types[:whisper] && !@opts[:silent]
|
|
attrs[:last_posted_at] = @post.created_at
|
|
attrs[:last_post_user_id] = @post.user_id
|
|
attrs[:word_count] = (@topic.word_count || 0) + @post.word_count
|
|
attrs[:excerpt] = @post.excerpt_for_topic if new_topic?
|
|
attrs[:bumped_at] = @post.created_at unless @post.no_bump
|
|
end
|
|
|
|
@topic.update_columns(attrs)
|
|
end
|
|
|
|
def update_topic_auto_close
|
|
return if @opts[:import_mode]
|
|
|
|
if @topic.closed?
|
|
@topic.delete_topic_timer(TopicTimer.types[:close])
|
|
else
|
|
topic_timer = @topic.public_topic_timer
|
|
|
|
if topic_timer && topic_timer.based_on_last_post && topic_timer.duration_minutes.to_i > 0
|
|
@topic.set_or_create_timer(
|
|
TopicTimer.types[:close],
|
|
nil,
|
|
based_on_last_post: topic_timer.based_on_last_post,
|
|
duration_minutes: topic_timer.duration_minutes,
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
def setup_post
|
|
@opts[:raw] = TextCleaner.normalize_whitespaces(@opts[:raw] || "").rstrip
|
|
|
|
post =
|
|
Post.new(
|
|
raw: @opts[:raw],
|
|
topic_id: @topic.try(:id),
|
|
user: @user,
|
|
reply_to_post_number: @opts[:reply_to_post_number],
|
|
)
|
|
|
|
# Attributes we pass through to the post instance if present
|
|
%i[
|
|
post_type
|
|
no_bump
|
|
cooking_options
|
|
image_sizes
|
|
acting_user
|
|
invalidate_oneboxes
|
|
cook_method
|
|
via_email
|
|
raw_email
|
|
action_code
|
|
].each { |a| post.public_send("#{a}=", @opts[a]) if @opts[a].present? }
|
|
|
|
post.extract_quoted_post_numbers
|
|
|
|
post.created_at =
|
|
if @opts[:created_at].is_a?(Time)
|
|
@opts[:created_at]
|
|
elsif @opts[:created_at].present?
|
|
Time.zone.parse(@opts[:created_at].to_s)
|
|
end
|
|
|
|
if fields = @opts[:custom_fields]
|
|
post.custom_fields = fields
|
|
end
|
|
|
|
if @opts[:hidden_reason_id].present?
|
|
post.hidden = true
|
|
post.hidden_at = Time.zone.now
|
|
post.hidden_reason_id = @opts[:hidden_reason_id]
|
|
end
|
|
|
|
@post = post
|
|
end
|
|
|
|
def save_post
|
|
@post.disable_rate_limits! if skip_validations?
|
|
@post.skip_validation = skip_validations?
|
|
saved = @post.save
|
|
rollback_from_errors!(@post) unless saved
|
|
end
|
|
|
|
def store_unique_post_key
|
|
@post.store_unique_post_key
|
|
end
|
|
|
|
def update_user_counts
|
|
return if @opts[:import_mode]
|
|
|
|
@user.create_user_stat if @user.user_stat.nil?
|
|
|
|
if @user.user_stat.first_post_created_at.nil?
|
|
@user.user_stat.update!(first_post_created_at: @post.created_at)
|
|
end
|
|
|
|
UserStatCountUpdater.increment!(@post) if !@post.hidden || @post.topic.visible
|
|
|
|
if !@topic.private_message? && @post.post_type != Post.types[:whisper]
|
|
@user.update(last_posted_at: @post.created_at)
|
|
end
|
|
end
|
|
|
|
def create_post_notice
|
|
return if @opts[:import_mode] || @user.anonymous? || @user.bot? || @user.staged
|
|
|
|
last_post_time =
|
|
Post.where(user_id: @user.id).order(created_at: :desc).limit(1).pluck(:created_at).first
|
|
|
|
if !last_post_time
|
|
@post.custom_fields[Post::NOTICE] = { type: Post.notices[:new_user] }
|
|
elsif SiteSetting.returning_users_days > 0 &&
|
|
last_post_time < SiteSetting.returning_users_days.days.ago
|
|
@post.custom_fields[Post::NOTICE] = {
|
|
type: Post.notices[:returning_user],
|
|
last_posted_at: last_post_time.iso8601,
|
|
}
|
|
end
|
|
end
|
|
|
|
def publish
|
|
return if @opts[:import_mode] || @post.post_number == 1
|
|
@post.publish_change_to_clients! :created, { skip_topic_stats: @post.post_number == 1 }
|
|
end
|
|
|
|
def extract_links
|
|
TopicLink.extract_from(@post)
|
|
QuotedPost.extract_from(@post)
|
|
end
|
|
|
|
def track_topic
|
|
return if @opts[:import_mode] || @opts[:auto_track] == false
|
|
|
|
TopicUser.change(
|
|
@post.user_id,
|
|
@topic.id,
|
|
posted: true,
|
|
last_read_post_number: @post.post_number,
|
|
last_posted_at: Time.zone.now,
|
|
)
|
|
|
|
# assume it took us 5 seconds of reading time to make a post
|
|
PostTiming.record_timing(
|
|
topic_id: @post.topic_id,
|
|
user_id: @post.user_id,
|
|
post_number: @post.post_number,
|
|
msecs: 5000,
|
|
)
|
|
|
|
if @user.staged
|
|
TopicUser.auto_notification_for_staging(
|
|
@user.id,
|
|
@topic.id,
|
|
TopicUser.notification_reasons[:auto_watch],
|
|
)
|
|
elsif !@topic.private_message?
|
|
notification_level =
|
|
@user.user_option.notification_level_when_replying ||
|
|
NotificationLevels.topic_levels[:tracking]
|
|
TopicUser.auto_notification(
|
|
@user.id,
|
|
@topic.id,
|
|
TopicUser.notification_reasons[:created_post],
|
|
notification_level,
|
|
)
|
|
end
|
|
end
|
|
|
|
def new_topic?
|
|
@opts[:topic_id].blank?
|
|
end
|
|
end
|