179 lines
4.8 KiB
Ruby
179 lines
4.8 KiB
Ruby
require_dependency 'post_creator'
|
|
require_dependency 'new_post_result'
|
|
require_dependency 'post_enqueuer'
|
|
|
|
# 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
|
|
|
|
def self.sorted_handlers
|
|
@sorted_handlers ||= clear_handlers!
|
|
end
|
|
|
|
def self.handlers
|
|
sorted_handlers.map {|h| h[:proc]}
|
|
end
|
|
|
|
def self.clear_handlers!
|
|
@sorted_handlers = [{ priority: 0, proc: method(:default_handler) }]
|
|
end
|
|
|
|
def self.add_handler(priority=0, &block)
|
|
sorted_handlers << { priority: priority, proc: block }
|
|
@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 &&
|
|
SiteSetting.auto_block_fast_typers_on_first_post &&
|
|
manager.user.trust_level <= SiteSetting.auto_block_fast_typers_max_trust_level
|
|
end
|
|
|
|
def self.matches_auto_block_regex?(manager)
|
|
args = manager.args
|
|
|
|
pattern = SiteSetting.auto_block_first_post_regex
|
|
|
|
return false unless pattern.present?
|
|
return false unless is_first_post?(manager)
|
|
|
|
begin
|
|
regex = Regexp.new(pattern, Regexp::IGNORECASE)
|
|
rescue => e
|
|
Rails.logger.warn "Invalid regex in auto_block_first_post_regex #{e}"
|
|
return false
|
|
end
|
|
|
|
"#{args[:title]} #{args[:raw]}" =~ regex
|
|
|
|
end
|
|
|
|
def self.user_needs_approval?(manager)
|
|
user = manager.user
|
|
|
|
return false if user.staff? || user.staged
|
|
|
|
(user.trust_level <= TrustLevel.levels[:basic] && user.post_count < SiteSetting.approve_post_count) ||
|
|
(user.trust_level < SiteSetting.approve_unless_trust_level.to_i) ||
|
|
is_fast_typer?(manager) ||
|
|
matches_auto_block_regex?(manager)
|
|
end
|
|
|
|
def self.default_handler(manager)
|
|
if user_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
|
|
end
|
|
|
|
# Can the user create the post in the first place?
|
|
if 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
|
|
end
|
|
|
|
result = manager.enqueue('default')
|
|
|
|
if is_fast_typer?(manager) || matches_auto_block_regex?(manager)
|
|
UserBlocker.block(manager.user, Discourse.system_user, keep_posts: true)
|
|
end
|
|
|
|
result
|
|
end
|
|
end
|
|
|
|
def self.queue_enabled?
|
|
SiteSetting.approve_post_count > 0 ||
|
|
SiteSetting.approve_unless_trust_level.to_i > 0 ||
|
|
handlers.size > 1
|
|
end
|
|
|
|
def initialize(user, args)
|
|
@user = user
|
|
@args = args.delete_if {|_, v| v.nil?}
|
|
end
|
|
|
|
def perform
|
|
# 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
|
|
|
|
# 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 in a queue
|
|
def enqueue(queue, reason=nil)
|
|
result = NewPostResult.new(:enqueued)
|
|
enqueuer = PostEnqueuer.new(@user, queue)
|
|
|
|
queued_args = {post_options: @args.dup}
|
|
queued_args[:raw] = queued_args[:post_options].delete(:raw)
|
|
queued_args[:topic_id] = queued_args[:post_options].delete(:topic_id)
|
|
|
|
post = enqueuer.enqueue(queued_args)
|
|
|
|
QueuedPost.broadcast_new! if post && post.errors.empty?
|
|
|
|
result.queued_post = post
|
|
result.reason = reason if reason
|
|
result.check_errors_from(enqueuer)
|
|
result.pending_count = QueuedPost.new_posts.where(user_id: @user.id).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
|