mirror of
https://github.com/discourse/discourse.git
synced 2024-11-30 08:13:43 +08:00
267e8ebaa6
* FIX: min_personal_message_post_length not applying to first post Due to the way PostCreator is wired, we were not applying min_personal_message_post_length to the first post. This meant that admins could not configure it so PMs have different limits. The code was already pretending that this works, but had no reliable way of figuring out if we were dealing with a private message
670 lines
20 KiB
Ruby
670 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)
|
|
# meta_data - Topic meta data hash
|
|
# 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
|
|
@post.update_uploads_secure_status(source: "post creator")
|
|
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
|