discourse/lib/new_post_manager.rb

237 lines
7.0 KiB
Ruby
Raw Normal View History

require_dependency 'post_creator'
require_dependency 'new_post_result'
require_dependency 'word_watcher'
# Determines what actions should be taken with new posts.
#
# The default action is to create the post, but this can be extended
# with `NewPostManager.add_handler` to take other approaches depending
# on the user or input.
class NewPostManager
attr_reader :user, :args
2015-04-28 13:53:05 -04:00
def self.sorted_handlers
@sorted_handlers ||= clear_handlers!
end
def self.handlers
2017-07-27 21:20:09 -04:00
sorted_handlers.map { |h| h[:proc] }
end
2015-04-28 13:53:05 -04:00
def self.clear_handlers!
@sorted_handlers = [{ priority: 0, proc: method(:default_handler) }]
end
2017-07-27 21:20:09 -04:00
def self.add_handler(priority = 0, &block)
2015-04-28 13:53:05 -04:00
sorted_handlers << { priority: priority, proc: block }
2017-07-27 21:20:09 -04:00
@sorted_handlers.sort_by! { |h| -h[:priority] }
end
def self.is_first_post?(manager)
user = manager.user
args = manager.args
!!(
args[:first_post_checks] &&
user.post_count == 0
)
end
def self.is_fast_typer?(manager)
args = manager.args
is_first_post?(manager) &&
args[:typing_duration_msecs].to_i < SiteSetting.min_first_post_typing_time &&
2017-11-10 12:18:08 -05:00
SiteSetting.auto_silence_fast_typers_on_first_post &&
manager.user.trust_level <= SiteSetting.auto_silence_fast_typers_max_trust_level
end
2017-11-10 12:18:08 -05:00
def self.matches_auto_silence_regex?(manager)
args = manager.args
2017-11-10 12:18:08 -05:00
pattern = SiteSetting.auto_silence_first_post_regex
return false unless pattern.present?
return false unless is_first_post?(manager)
begin
regex = Regexp.new(pattern, Regexp::IGNORECASE)
rescue => e
2017-11-10 12:18:08 -05:00
Rails.logger.warn "Invalid regex in auto_silence_first_post_regex #{e}"
return false
end
"#{args[:title]} #{args[:raw]}" =~ regex
end
def self.exempt_user?(user)
user.staff?
end
def self.post_needs_approval?(manager)
user = manager.user
return false if exempt_user?(user)
2015-06-04 11:35:36 -04:00
(user.trust_level <= TrustLevel.levels[:basic] && user.post_count < SiteSetting.approve_post_count) ||
(user.trust_level < SiteSetting.approve_unless_trust_level.to_i) ||
(manager.args[:title].present? && user.trust_level < SiteSetting.approve_new_topics_unless_trust_level.to_i) ||
is_fast_typer?(manager) ||
2017-11-10 12:18:08 -05:00
matches_auto_silence_regex?(manager) ||
WordWatcher.new("#{manager.args[:title]} #{manager.args[:raw]}").requires_approval? ||
(SiteSetting.approve_unless_staged && user.staged) ||
post_needs_approval_in_its_category?(manager)
end
def self.post_needs_approval_in_its_category?(manager)
if manager.args[:topic_id].present?
cat = Category.joins(:topics).find_by(topics: { id: manager.args[:topic_id] })
return false unless cat
cat.require_reply_approval?
elsif manager.args[:category].present?
Category.find(manager.args[:category]).require_topic_approval?
else
false
end
2015-04-28 16:14:36 -04:00
end
2015-04-15 12:12:20 -04:00
def self.default_handler(manager)
if post_needs_approval?(manager)
validator = Validators::PostValidator.new
post = Post.new(raw: manager.args[:raw])
post.user = manager.user
validator.validate(post)
if post.errors[:raw].present?
result = NewPostResult.new(:created_post, false)
result.errors[:base] << post.errors[:raw]
return result
elsif manager.args[:topic_id]
topic = Topic.unscoped.where(id: manager.args[:topic_id]).first
unless manager.user.guardian.can_create_post_on_topic?(topic)
result = NewPostResult.new(:created_post, false)
result.errors[:base] << I18n.t(:topic_not_found)
return result
end
elsif manager.args[:category]
category = Category.find_by(id: manager.args[:category])
unless manager.user.guardian.can_create_topic_on_category?(category)
result = NewPostResult.new(:created_post, false)
result.errors[:base] << I18n.t("js.errors.reasons.forbidden")
return result
end
end
result = manager.enqueue
if is_fast_typer?(manager)
2017-11-10 12:18:08 -05:00
UserSilencer.silence(manager.user, Discourse.system_user, keep_posts: true, reason: I18n.t("user.new_user_typed_too_fast"))
elsif matches_auto_silence_regex?(manager)
UserSilencer.silence(manager.user, Discourse.system_user, keep_posts: true, reason: I18n.t("user.content_matches_auto_silence_regex"))
end
result
end
2015-04-15 12:12:20 -04:00
end
def self.queue_enabled?
SiteSetting.approve_post_count > 0 ||
SiteSetting.approve_unless_trust_level.to_i > 0 ||
SiteSetting.approve_new_topics_unless_trust_level.to_i > 0 ||
SiteSetting.approve_unless_staged ||
WordWatcher.words_for_action_exists?(:require_approval) ||
handlers.size > 1
end
def initialize(user, args)
@user = user
2017-07-27 21:20:09 -04:00
@args = args.delete_if { |_, v| v.nil? }
end
def perform
if !self.class.exempt_user?(@user) && matches = WordWatcher.new("#{@args[:title]} #{@args[:raw]}").should_block?
result = NewPostResult.new(:created_post, false)
result.errors[:base] << I18n.t('contains_blocked_words', word: matches[0])
return result
end
2015-05-04 11:07:46 -04:00
# We never queue private messages
return perform_create_post if @args[:archetype] == Archetype.private_message
if args[:topic_id] && Topic.where(id: args[:topic_id], archetype: Archetype.private_message).exists?
return perform_create_post
end
2015-05-04 11:07:46 -04:00
# Perform handlers until one returns a result
handled = NewPostManager.handlers.any? do |handler|
result = handler.call(self)
return result if result
false
end
perform_create_post unless handled
end
# Enqueue this post
def enqueue(reason = nil)
result = NewPostResult.new(:enqueued)
reviewable = ReviewableQueuedPost.new(
created_by: @user,
payload: { raw: @args[:raw] },
topic_id: @args[:topic_id],
reviewable_by_moderator: true
)
reviewable.payload['title'] = @args[:title] if @args[:title].present?
create_options = reviewable.create_options
creator = @args[:topic_id] ?
PostCreator.new(@user, create_options) :
TopicCreator.new(@user, Guardian.new(@user), create_options)
errors = Set.new
creator.valid?
creator.errors.full_messages.each { |msg| errors << msg }
errors = creator.errors.full_messages.uniq
if errors.blank?
if reviewable.save
reviewable.add_score(
Discourse.system_user,
ReviewableScore.types[:needs_approval],
force_review: true
)
else
reviewable.errors.full_messages.each { |msg| errors << msg }
end
end
2015-04-10 17:00:50 -04:00
result.reviewable = reviewable
result.reason = reason if reason
result.check_errors(errors)
result.pending_count = Reviewable.where(created_by: @user).pending.count
result
end
def perform_create_post
result = NewPostResult.new(:create_post)
creator = PostCreator.new(@user, @args)
post = creator.create
result.check_errors_from(creator)
if result.success?
result.post = post
else
@user.flag_linked_posts_as_spam if creator.spam?
end
result
end
end