1329 lines
39 KiB
Ruby
1329 lines
39 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require "archetype"
|
|
require "digest/sha1"
|
|
|
|
class Post < ActiveRecord::Base
|
|
include RateLimiter::OnCreateRecord
|
|
include Trashable
|
|
include Searchable
|
|
include HasCustomFields
|
|
include LimitedEdit
|
|
|
|
self.ignored_columns = [
|
|
"avg_time", # TODO(2021-01-04): remove
|
|
"image_url", # TODO(2021-06-01): remove
|
|
]
|
|
|
|
cattr_accessor :plugin_permitted_create_params, :plugin_permitted_update_params
|
|
self.plugin_permitted_create_params = {}
|
|
self.plugin_permitted_update_params = {}
|
|
|
|
# increase this number to force a system wide post rebake
|
|
# Recreate `index_for_rebake_old` when the number is increased
|
|
# Version 1, was the initial version
|
|
# Version 2 15-12-2017, introduces CommonMark and a huge number of onebox fixes
|
|
BAKED_VERSION = 2
|
|
|
|
# Time between the delete and permanent delete of a post
|
|
PERMANENT_DELETE_TIMER = 5.minutes
|
|
|
|
rate_limit
|
|
rate_limit :limit_posts_per_day
|
|
|
|
belongs_to :user
|
|
belongs_to :topic
|
|
|
|
belongs_to :reply_to_user, class_name: "User"
|
|
|
|
has_many :post_replies
|
|
has_many :replies, through: :post_replies
|
|
has_many :post_actions, dependent: :destroy
|
|
has_many :topic_links
|
|
has_many :group_mentions, dependent: :destroy
|
|
|
|
has_many :upload_references, as: :target, dependent: :destroy
|
|
has_many :uploads, through: :upload_references
|
|
|
|
has_one :post_stat
|
|
|
|
has_many :bookmarks, as: :bookmarkable
|
|
|
|
has_one :incoming_email
|
|
|
|
has_many :post_details
|
|
|
|
has_many :post_revisions
|
|
has_many :revisions, -> { order(:number) }, foreign_key: :post_id, class_name: "PostRevision"
|
|
|
|
has_many :user_actions, foreign_key: :target_post_id
|
|
|
|
belongs_to :image_upload, class_name: "Upload"
|
|
|
|
has_many :post_hotlinked_media, dependent: :destroy, class_name: "PostHotlinkedMedia"
|
|
has_many :reviewables, as: :target, dependent: :destroy
|
|
|
|
validates_with PostValidator, unless: :skip_validation
|
|
|
|
after_commit :index_search
|
|
|
|
# We can pass several creating options to a post via attributes
|
|
attr_accessor :image_sizes,
|
|
:quoted_post_numbers,
|
|
:no_bump,
|
|
:invalidate_oneboxes,
|
|
:cooking_options,
|
|
:skip_unique_check,
|
|
:skip_validation
|
|
|
|
MISSING_UPLOADS ||= "missing uploads"
|
|
MISSING_UPLOADS_IGNORED ||= "missing uploads ignored"
|
|
NOTICE ||= "notice"
|
|
|
|
SHORT_POST_CHARS ||= 1200
|
|
|
|
register_custom_field_type(MISSING_UPLOADS, :json)
|
|
register_custom_field_type(MISSING_UPLOADS_IGNORED, :boolean)
|
|
|
|
register_custom_field_type(NOTICE, :json)
|
|
|
|
scope :private_posts_for_user,
|
|
->(user) {
|
|
where(
|
|
"topics.id IN (#{Topic::PRIVATE_MESSAGES_SQL_USER})
|
|
OR topics.id IN (#{Topic::PRIVATE_MESSAGES_SQL_GROUP})",
|
|
user_id: user.id,
|
|
)
|
|
}
|
|
|
|
scope :by_newest, -> { order("created_at DESC, id DESC") }
|
|
scope :by_post_number, -> { order("post_number ASC") }
|
|
scope :with_user, -> { includes(:user) }
|
|
scope :created_since, ->(time_ago) { where("posts.created_at > ?", time_ago) }
|
|
scope :public_posts,
|
|
-> { joins(:topic).where("topics.archetype <> ?", Archetype.private_message) }
|
|
scope :private_posts,
|
|
-> { joins(:topic).where("topics.archetype = ?", Archetype.private_message) }
|
|
scope :with_topic_subtype, ->(subtype) { joins(:topic).where("topics.subtype = ?", subtype) }
|
|
scope :visible, -> { joins(:topic).where("topics.visible = true").where(hidden: false) }
|
|
scope :secured,
|
|
->(guardian) { where("posts.post_type IN (?)", Topic.visible_post_types(guardian&.user)) }
|
|
|
|
scope :for_mailing_list,
|
|
->(user, since) {
|
|
q =
|
|
created_since(since).joins(
|
|
"INNER JOIN (#{Topic.for_digest(user, Time.at(0)).select(:id).to_sql}) AS digest_topics ON digest_topics.id = posts.topic_id",
|
|
) # we want all topics with new content, regardless when they were created
|
|
.order("posts.created_at ASC")
|
|
|
|
q = q.where.not(post_type: Post.types[:whisper]) unless user.staff?
|
|
q
|
|
}
|
|
|
|
scope :raw_match,
|
|
->(pattern, type = "string") {
|
|
type = type&.downcase
|
|
|
|
case type
|
|
when "string"
|
|
where("raw ILIKE ?", "%#{pattern}%")
|
|
when "regex"
|
|
where("raw ~* ?", "(?n)#{pattern}")
|
|
end
|
|
}
|
|
|
|
scope :have_uploads,
|
|
-> {
|
|
where(
|
|
"
|
|
(
|
|
posts.cooked LIKE '%<a %' OR
|
|
posts.cooked LIKE '%<img %' OR
|
|
posts.cooked LIKE '%<video %'
|
|
) AND (
|
|
posts.cooked LIKE ? OR
|
|
posts.cooked LIKE '%/original/%' OR
|
|
posts.cooked LIKE '%/optimized/%' OR
|
|
posts.cooked LIKE '%data-orig-src=%' OR
|
|
posts.cooked LIKE '%/uploads/short-url/%'
|
|
)",
|
|
"%/uploads/#{RailsMultisite::ConnectionManagement.current_db}/%",
|
|
)
|
|
}
|
|
|
|
delegate :username, to: :user
|
|
|
|
def self.hidden_reasons
|
|
@hidden_reasons ||=
|
|
Enum.new(
|
|
flag_threshold_reached: 1,
|
|
flag_threshold_reached_again: 2,
|
|
new_user_spam_threshold_reached: 3,
|
|
flagged_by_tl3_user: 4,
|
|
email_spam_header_found: 5,
|
|
flagged_by_tl4_user: 6,
|
|
email_authentication_result_header: 7,
|
|
imported_as_unlisted: 8,
|
|
)
|
|
end
|
|
|
|
def self.types
|
|
@types ||= Enum.new(regular: 1, moderator_action: 2, small_action: 3, whisper: 4)
|
|
end
|
|
|
|
def self.cook_methods
|
|
@cook_methods ||= Enum.new(regular: 1, raw_html: 2, email: 3)
|
|
end
|
|
|
|
def self.notices
|
|
@notices ||= Enum.new(custom: "custom", new_user: "new_user", returning_user: "returning_user")
|
|
end
|
|
|
|
def self.find_by_detail(key, value)
|
|
includes(:post_details).find_by(post_details: { key: key, value: value })
|
|
end
|
|
|
|
def self.find_by_number(topic_id, post_number)
|
|
find_by(topic_id: topic_id, post_number: post_number)
|
|
end
|
|
|
|
def whisper?
|
|
post_type == Post.types[:whisper]
|
|
end
|
|
|
|
def add_detail(key, value, extra = nil)
|
|
post_details.build(key: key, value: value, extra: extra)
|
|
end
|
|
|
|
def limit_posts_per_day
|
|
if user && user.new_user_posting_on_first_day? && post_number && post_number > 1
|
|
RateLimiter.new(
|
|
user,
|
|
"first-day-replies-per-day",
|
|
SiteSetting.max_replies_in_first_day,
|
|
1.day.to_i,
|
|
)
|
|
end
|
|
end
|
|
|
|
def readers_count
|
|
read_count = reads - 1 # Excludes poster
|
|
read_count < 0 ? 0 : read_count
|
|
end
|
|
|
|
def publish_change_to_clients!(type, opts = {})
|
|
# special failsafe for posts missing topics consistency checks should fix,
|
|
# but message is safe to skip
|
|
return unless topic
|
|
|
|
skip_topic_stats = opts.delete(:skip_topic_stats)
|
|
|
|
message = {
|
|
id: id,
|
|
post_number: post_number,
|
|
updated_at: Time.now,
|
|
user_id: user_id,
|
|
last_editor_id: last_editor_id,
|
|
type: type,
|
|
version: version,
|
|
}.merge(opts)
|
|
|
|
publish_message!("/topic/#{topic_id}", message)
|
|
Topic.publish_stats_to_clients!(topic.id, type) unless skip_topic_stats
|
|
end
|
|
|
|
def publish_message!(channel, message, opts = {})
|
|
return unless topic
|
|
|
|
if Topic.visible_post_types.include?(post_type)
|
|
opts.merge!(topic.secure_audience_publish_messages)
|
|
else
|
|
opts[:user_ids] = User.human_users.where("admin OR moderator OR id = ?", user_id).pluck(:id)
|
|
end
|
|
|
|
MessageBus.publish(channel, message, opts) if opts[:user_ids] != [] && opts[:group_ids] != []
|
|
end
|
|
|
|
def trash!(trashed_by = nil)
|
|
self.topic_links.each(&:destroy)
|
|
self.save_custom_fields if self.custom_fields.delete(Post::NOTICE)
|
|
super(trashed_by)
|
|
end
|
|
|
|
def recover!
|
|
super
|
|
recover_public_post_actions
|
|
TopicLink.extract_from(self)
|
|
QuotedPost.extract_from(self)
|
|
topic.category.update_latest if topic && topic.category_id && topic.category
|
|
end
|
|
|
|
# The key we use in redis to ensure unique posts
|
|
def unique_post_key
|
|
"unique#{topic&.private_message? ? "-pm" : ""}-post-#{user_id}:#{raw_hash}"
|
|
end
|
|
|
|
def store_unique_post_key
|
|
if SiteSetting.unique_posts_mins > 0
|
|
Discourse.redis.setex(unique_post_key, SiteSetting.unique_posts_mins.minutes.to_i, id)
|
|
end
|
|
end
|
|
|
|
def matches_recent_post?
|
|
post_id = Discourse.redis.get(unique_post_key)
|
|
post_id != (nil) && post_id.to_i != (id)
|
|
end
|
|
|
|
def raw_hash
|
|
return if raw.blank?
|
|
Digest::SHA1.hexdigest(raw)
|
|
end
|
|
|
|
def self.allowed_image_classes
|
|
@allowed_image_classes ||= %w[avatar favicon thumbnail emoji ytp-thumbnail-image]
|
|
end
|
|
|
|
def post_analyzer
|
|
@post_analyzers ||= {}
|
|
@post_analyzers[raw_hash] ||= PostAnalyzer.new(raw, topic_id)
|
|
end
|
|
|
|
%w[
|
|
raw_mentions
|
|
linked_hosts
|
|
embedded_media_count
|
|
attachment_count
|
|
link_count
|
|
raw_links
|
|
has_oneboxes?
|
|
].each { |attr| define_method(attr) { post_analyzer.public_send(attr) } }
|
|
|
|
def add_nofollow?
|
|
return false if user&.staff?
|
|
user.blank? || SiteSetting.tl3_links_no_follow? || !user.has_trust_level?(TrustLevel[3])
|
|
end
|
|
|
|
def omit_nofollow?
|
|
!add_nofollow?
|
|
end
|
|
|
|
def cook(raw, opts = {})
|
|
# For some posts, for example those imported via RSS, we support raw HTML. In that
|
|
# case we can skip the rendering pipeline.
|
|
return raw if cook_method == Post.cook_methods[:raw_html]
|
|
|
|
options = opts.dup
|
|
options[:cook_method] = cook_method
|
|
|
|
# A rule in our Markdown pipeline may have Guardian checks that require a
|
|
# user to be present. The last editing user of the post will be more
|
|
# generally up to date than the creating user. For example, we use
|
|
# this when cooking #hashtags to determine whether we should render
|
|
# the found hashtag based on whether the user can access the category it
|
|
# is referencing.
|
|
options[:user_id] = self.last_editor_id
|
|
options[:omit_nofollow] = true if omit_nofollow?
|
|
|
|
if self.with_secure_uploads?
|
|
each_upload_url do |url|
|
|
uri = URI.parse(url)
|
|
if FileHelper.is_supported_media?(File.basename(uri.path))
|
|
raw =
|
|
raw.sub(
|
|
url,
|
|
Rails.application.routes.url_for(
|
|
controller: "uploads",
|
|
action: "show_secure",
|
|
path: uri.path[1..-1],
|
|
host: Discourse.current_hostname,
|
|
),
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
cooked = post_analyzer.cook(raw, options)
|
|
|
|
new_cooked = Plugin::Filter.apply(:after_post_cook, self, cooked)
|
|
|
|
if post_type == Post.types[:regular]
|
|
if new_cooked != cooked && new_cooked.blank?
|
|
Rails.logger.debug("Plugin is blanking out post: #{self.url}\nraw: #{raw}")
|
|
elsif new_cooked.blank?
|
|
Rails.logger.debug("Blank post detected post: #{self.url}\nraw: #{raw}")
|
|
end
|
|
end
|
|
|
|
new_cooked
|
|
end
|
|
|
|
# Sometimes the post is being edited by someone else, for example, a mod.
|
|
# If that's the case, they should not be bound by the original poster's
|
|
# restrictions, for example on not posting images.
|
|
def acting_user
|
|
@acting_user || user
|
|
end
|
|
|
|
def acting_user=(pu)
|
|
@acting_user = pu
|
|
end
|
|
|
|
def last_editor
|
|
self.last_editor_id ? (User.find_by_id(self.last_editor_id) || user) : user
|
|
end
|
|
|
|
def allowed_spam_hosts
|
|
hosts =
|
|
SiteSetting
|
|
.allowed_spam_host_domains
|
|
.split("|")
|
|
.map { |h| h.strip }
|
|
.reject { |h| !h.include?(".") }
|
|
|
|
hosts << GlobalSetting.hostname
|
|
hosts << RailsMultisite::ConnectionManagement.current_hostname
|
|
end
|
|
|
|
def total_hosts_usage
|
|
hosts = linked_hosts.clone
|
|
allowlisted = allowed_spam_hosts
|
|
|
|
hosts.reject! { |h| allowlisted.any? { |w| h.end_with?(w) } }
|
|
|
|
return hosts if hosts.length == 0
|
|
|
|
TopicLink
|
|
.where(domain: hosts.keys, user_id: acting_user.id)
|
|
.group(:domain, :post_id)
|
|
.count
|
|
.each_key do |tuple|
|
|
domain = tuple[0]
|
|
hosts[domain] = (hosts[domain] || 0) + 1
|
|
end
|
|
|
|
hosts
|
|
end
|
|
|
|
# Prevent new users from posting the same hosts too many times.
|
|
def has_host_spam?
|
|
if acting_user.present? &&
|
|
(
|
|
acting_user.staged? || acting_user.mature_staged? ||
|
|
acting_user.has_trust_level?(TrustLevel[1])
|
|
)
|
|
return false
|
|
end
|
|
return false if topic&.private_message?
|
|
|
|
total_hosts_usage.values.any? { |count| count >= SiteSetting.newuser_spam_host_threshold }
|
|
end
|
|
|
|
def archetype
|
|
topic&.archetype
|
|
end
|
|
|
|
def self.regular_order
|
|
order(:sort_order, :post_number)
|
|
end
|
|
|
|
def self.reverse_order
|
|
order("sort_order desc, post_number desc")
|
|
end
|
|
|
|
def self.summary(topic_id)
|
|
topic_id = topic_id.to_i
|
|
|
|
# percent rank has tons of ties
|
|
where(topic_id: topic_id).where(
|
|
[
|
|
"posts.id = ANY(
|
|
(
|
|
SELECT posts.id
|
|
FROM posts
|
|
WHERE posts.topic_id = #{topic_id.to_i}
|
|
AND posts.post_number = 1
|
|
) UNION
|
|
(
|
|
SELECT p1.id
|
|
FROM posts p1
|
|
WHERE p1.percent_rank <= ?
|
|
AND p1.topic_id = #{topic_id.to_i}
|
|
ORDER BY p1.percent_rank
|
|
LIMIT ?
|
|
)
|
|
)",
|
|
SiteSetting.summary_percent_filter.to_f / 100.0,
|
|
SiteSetting.summary_max_results,
|
|
],
|
|
)
|
|
end
|
|
|
|
def delete_post_notices
|
|
self.custom_fields.delete(Post::NOTICE)
|
|
self.save_custom_fields
|
|
end
|
|
|
|
def recover_public_post_actions
|
|
PostAction
|
|
.publics
|
|
.with_deleted
|
|
.where(post_id: self.id, id: self.custom_fields["deleted_public_actions"])
|
|
.find_each do |post_action|
|
|
post_action.recover!
|
|
post_action.save!
|
|
end
|
|
|
|
self.custom_fields.delete("deleted_public_actions")
|
|
self.save_custom_fields
|
|
end
|
|
|
|
def filter_quotes(parent_post = nil)
|
|
return cooked if parent_post.blank?
|
|
|
|
# We only filter quotes when there is exactly 1
|
|
return cooked unless (quote_count == 1)
|
|
|
|
parent_raw = parent_post.raw.sub(%r{\[quote.+/quote\]}m, "")
|
|
|
|
if raw[parent_raw] || (parent_raw.size < SHORT_POST_CHARS)
|
|
return cooked.sub(%r{\<aside.+\</aside\>}m, "")
|
|
end
|
|
|
|
cooked
|
|
end
|
|
|
|
def external_id
|
|
"#{topic_id}/#{post_number}"
|
|
end
|
|
|
|
def reply_to_post
|
|
return if reply_to_post_number.blank?
|
|
@reply_to_post ||=
|
|
Post.find_by(
|
|
"topic_id = :topic_id AND post_number = :post_number",
|
|
topic_id: topic_id,
|
|
post_number: reply_to_post_number,
|
|
)
|
|
end
|
|
|
|
def reply_notification_target
|
|
return if reply_to_post_number.blank?
|
|
Post.find_by(
|
|
"topic_id = :topic_id AND post_number = :post_number AND user_id <> :user_id",
|
|
topic_id: topic_id,
|
|
post_number: reply_to_post_number,
|
|
user_id: user_id,
|
|
).try(:user)
|
|
end
|
|
|
|
def self.excerpt(cooked, maxlength = nil, options = {})
|
|
maxlength ||= SiteSetting.post_excerpt_maxlength
|
|
PrettyText.excerpt(cooked, maxlength, options)
|
|
end
|
|
|
|
# Strip out most of the markup
|
|
def excerpt(maxlength = nil, options = {})
|
|
Post.excerpt(cooked, maxlength, options.merge(post: self))
|
|
end
|
|
|
|
def excerpt_for_topic
|
|
Post.excerpt(
|
|
cooked,
|
|
SiteSetting.topic_excerpt_maxlength,
|
|
strip_links: true,
|
|
strip_images: true,
|
|
post: self,
|
|
)
|
|
end
|
|
|
|
def is_first_post?
|
|
post_number.blank? ? topic.try(:highest_post_number) == 0 : post_number == 1
|
|
end
|
|
|
|
def is_category_description?
|
|
topic.present? && topic.is_category_topic? && is_first_post?
|
|
end
|
|
|
|
def is_reply_by_email?
|
|
via_email && post_number.present? && post_number > 1
|
|
end
|
|
|
|
def is_flagged?
|
|
flags.count != 0
|
|
end
|
|
|
|
def flags
|
|
post_actions.where(
|
|
post_action_type_id: PostActionType.flag_types_without_custom.values,
|
|
deleted_at: nil,
|
|
)
|
|
end
|
|
|
|
def reviewable_flag
|
|
ReviewableFlaggedPost.pending.find_by(target: self)
|
|
end
|
|
|
|
def with_secure_uploads?
|
|
return false if !SiteSetting.secure_uploads?
|
|
SiteSetting.login_required? ||
|
|
(topic.present? && (topic.private_message? || topic.category&.read_restricted))
|
|
end
|
|
|
|
def hide!(post_action_type_id, reason = nil, custom_message: nil)
|
|
return if hidden?
|
|
|
|
reason ||=
|
|
(
|
|
if hidden_at
|
|
Post.hidden_reasons[:flag_threshold_reached_again]
|
|
else
|
|
Post.hidden_reasons[:flag_threshold_reached]
|
|
end
|
|
)
|
|
|
|
hiding_again = hidden_at.present?
|
|
|
|
self.hidden = true
|
|
self.hidden_at = Time.zone.now
|
|
self.hidden_reason_id = reason
|
|
self.skip_unique_check = true
|
|
|
|
Post.transaction do
|
|
save!
|
|
|
|
Topic.where(
|
|
"id = :topic_id AND NOT EXISTS(SELECT 1 FROM POSTS WHERE topic_id = :topic_id AND NOT hidden)",
|
|
topic_id: topic_id,
|
|
).update_all(visible: false)
|
|
|
|
UserStatCountUpdater.decrement!(self)
|
|
end
|
|
|
|
# inform user
|
|
if user.present?
|
|
options = {
|
|
url: url,
|
|
edit_delay: SiteSetting.cooldown_minutes_after_hiding_posts,
|
|
flag_reason:
|
|
I18n.t(
|
|
"flag_reasons.#{PostActionType.types[post_action_type_id]}",
|
|
locale: SiteSetting.default_locale,
|
|
base_path: Discourse.base_path,
|
|
),
|
|
}
|
|
|
|
message = custom_message
|
|
message = hiding_again ? :post_hidden_again : :post_hidden if message.nil?
|
|
|
|
Jobs.enqueue_in(
|
|
5.seconds,
|
|
:send_system_message,
|
|
user_id: user.id,
|
|
message_type: message.to_s,
|
|
message_options: options,
|
|
)
|
|
end
|
|
end
|
|
|
|
def unhide!
|
|
Post.transaction do
|
|
self.update!(hidden: false)
|
|
self.topic.update(visible: true) if is_first_post?
|
|
UserStatCountUpdater.increment!(self)
|
|
save(validate: false)
|
|
end
|
|
|
|
publish_change_to_clients!(:acted)
|
|
end
|
|
|
|
def full_url
|
|
"#{Discourse.base_url}#{url}"
|
|
end
|
|
|
|
def url(opts = nil)
|
|
opts ||= {}
|
|
|
|
if topic
|
|
Post.url(topic.slug, topic.id, post_number, opts)
|
|
else
|
|
"/404"
|
|
end
|
|
end
|
|
|
|
def canonical_url
|
|
topic_view = TopicView.new(topic, nil, post_number: post_number)
|
|
|
|
page = ""
|
|
|
|
page = "?page=#{topic_view.page}" if topic_view.page > 1
|
|
|
|
"#{topic.url}#{page}#post_#{post_number}"
|
|
end
|
|
|
|
def unsubscribe_url(user)
|
|
key_value = UnsubscribeKey.create_key_for(user, UnsubscribeKey::TOPIC_TYPE, post: self)
|
|
|
|
"#{Discourse.base_url}/email/unsubscribe/#{key_value}"
|
|
end
|
|
|
|
def self.url(slug, topic_id, post_number, opts = nil)
|
|
opts ||= {}
|
|
|
|
result = +"/t/"
|
|
result << "#{slug}/" if !opts[:without_slug]
|
|
|
|
"#{result}#{topic_id}/#{post_number}"
|
|
end
|
|
|
|
def self.urls(post_ids)
|
|
ids = post_ids.map { |u| u }
|
|
if ids.length > 0
|
|
urls = {}
|
|
Topic
|
|
.joins(:posts)
|
|
.where("posts.id" => ids)
|
|
.select(["posts.id as post_id", "post_number", "topics.slug", "topics.title", "topics.id"])
|
|
.each { |t| urls[t.post_id.to_i] = url(t.slug, t.id, t.post_number) }
|
|
urls
|
|
else
|
|
{}
|
|
end
|
|
end
|
|
|
|
def revise(updated_by, changes = {}, opts = {})
|
|
PostRevisor.new(self).revise!(updated_by, changes, opts)
|
|
end
|
|
|
|
def self.rebake_old(limit, priority: :normal, rate_limiter: true)
|
|
limiter =
|
|
RateLimiter.new(
|
|
nil,
|
|
"global_periodical_rebake_limit",
|
|
GlobalSetting.max_old_rebakes_per_15_minutes,
|
|
900,
|
|
global: true,
|
|
)
|
|
|
|
problems = []
|
|
Post
|
|
.where("baked_version IS NULL OR baked_version < ?", BAKED_VERSION)
|
|
.order("id desc")
|
|
.limit(limit)
|
|
.pluck(:id)
|
|
.each do |id|
|
|
begin
|
|
break if !limiter.can_perform?
|
|
|
|
post = Post.find(id)
|
|
post.rebake!(priority: priority)
|
|
|
|
begin
|
|
limiter.performed! if rate_limiter
|
|
rescue RateLimiter::LimitExceeded
|
|
break
|
|
end
|
|
rescue => e
|
|
problems << { post: post, ex: e }
|
|
|
|
attempts = post.custom_fields["rebake_attempts"].to_i
|
|
|
|
if attempts > 3
|
|
post.update_columns(baked_version: BAKED_VERSION)
|
|
Discourse.warn_exception(
|
|
e,
|
|
message: "Can not rebake post# #{post.id} after 3 attempts, giving up",
|
|
)
|
|
else
|
|
post.custom_fields["rebake_attempts"] = attempts + 1
|
|
post.save_custom_fields
|
|
end
|
|
end
|
|
end
|
|
problems
|
|
end
|
|
|
|
def rebake!(invalidate_broken_images: false, invalidate_oneboxes: false, priority: nil)
|
|
new_cooked = cook(raw, topic_id: topic_id, invalidate_oneboxes: invalidate_oneboxes)
|
|
old_cooked = cooked
|
|
|
|
update_columns(cooked: new_cooked, baked_at: Time.zone.now, baked_version: BAKED_VERSION)
|
|
|
|
topic&.update_excerpt(excerpt_for_topic) if is_first_post?
|
|
|
|
if invalidate_broken_images
|
|
post_hotlinked_media.download_failed.destroy_all
|
|
post_hotlinked_media.upload_create_failed.destroy_all
|
|
end
|
|
|
|
# Extracts urls from the body
|
|
TopicLink.extract_from(self)
|
|
QuotedPost.extract_from(self)
|
|
|
|
# make sure we trigger the post process
|
|
trigger_post_process(bypass_bump: true, priority: priority)
|
|
|
|
publish_change_to_clients!(:rebaked)
|
|
|
|
new_cooked != old_cooked
|
|
end
|
|
|
|
def set_owner(new_user, actor, skip_revision = false)
|
|
return if user_id == new_user.id
|
|
|
|
edit_reason = I18n.t("change_owner.post_revision_text", locale: SiteSetting.default_locale)
|
|
|
|
revise(
|
|
actor,
|
|
{ raw: self.raw, user_id: new_user.id, edit_reason: edit_reason },
|
|
bypass_bump: true,
|
|
skip_revision: skip_revision,
|
|
skip_validations: true,
|
|
)
|
|
|
|
topic.update_columns(last_post_user_id: new_user.id) if post_number == topic.highest_post_number
|
|
end
|
|
|
|
before_create { PostCreator.before_create_tasks(self) }
|
|
|
|
def self.estimate_posts_per_day
|
|
val = Discourse.redis.get("estimated_posts_per_day")
|
|
return val.to_i if val
|
|
|
|
posts_per_day =
|
|
Topic.listable_topics.secured.joins(:posts).merge(Post.created_since(30.days.ago)).count / 30
|
|
Discourse.redis.setex("estimated_posts_per_day", 1.day.to_i, posts_per_day.to_s)
|
|
posts_per_day
|
|
end
|
|
|
|
before_save do
|
|
self.last_editor_id ||= user_id
|
|
|
|
if will_save_change_to_raw?
|
|
self.cooked = cook(raw, topic_id: topic_id) if !new_record?
|
|
self.baked_at = Time.zone.now
|
|
self.baked_version = BAKED_VERSION
|
|
end
|
|
end
|
|
|
|
def advance_draft_sequence
|
|
return if topic.blank? # could be deleted
|
|
DraftSequence.next!(last_editor_id, topic.draft_key) if last_editor_id
|
|
end
|
|
|
|
# TODO: move to post-analyzer?
|
|
# Determine what posts are quoted by this post
|
|
def extract_quoted_post_numbers
|
|
temp_collector = []
|
|
|
|
# Create relationships for the quotes
|
|
raw
|
|
.scan(/\[quote=\"([^"]+)"\]/)
|
|
.each do |quote|
|
|
args = parse_quote_into_arguments(quote)
|
|
# If the topic attribute is present, ensure it's the same topic
|
|
if !(args[:topic].present? && topic_id != args[:topic]) && args[:post] != post_number
|
|
temp_collector << args[:post]
|
|
end
|
|
end
|
|
|
|
temp_collector.uniq!
|
|
self.quoted_post_numbers = temp_collector
|
|
self.quote_count = temp_collector.size
|
|
end
|
|
|
|
def save_reply_relationships
|
|
add_to_quoted_post_numbers(reply_to_post_number)
|
|
return if self.quoted_post_numbers.blank?
|
|
|
|
# Create a reply relationship between quoted posts and this new post
|
|
self.quoted_post_numbers.each do |p|
|
|
post = Post.find_by(topic_id: topic_id, post_number: p)
|
|
create_reply_relationship_with(post)
|
|
end
|
|
end
|
|
|
|
# Enqueue post processing for this post
|
|
def trigger_post_process(
|
|
bypass_bump: false,
|
|
priority: :normal,
|
|
new_post: false,
|
|
skip_pull_hotlinked_images: false
|
|
)
|
|
args = {
|
|
bypass_bump: bypass_bump,
|
|
cooking_options: self.cooking_options,
|
|
new_post: new_post,
|
|
post_id: id,
|
|
skip_pull_hotlinked_images: skip_pull_hotlinked_images,
|
|
}
|
|
|
|
args[:image_sizes] = image_sizes if self.image_sizes.present?
|
|
args[:invalidate_oneboxes] = true if self.invalidate_oneboxes.present?
|
|
args[:queue] = priority.to_s if priority && priority != :normal
|
|
|
|
Jobs.enqueue(:process_post, args)
|
|
DiscourseEvent.trigger(:after_trigger_post_process, self)
|
|
end
|
|
|
|
def self.public_posts_count_per_day(
|
|
start_date,
|
|
end_date,
|
|
category_id = nil,
|
|
include_subcategories = false
|
|
)
|
|
result =
|
|
public_posts.where(
|
|
"posts.created_at >= ? AND posts.created_at <= ?",
|
|
start_date,
|
|
end_date,
|
|
).where(post_type: Post.types[:regular])
|
|
|
|
if category_id
|
|
if include_subcategories
|
|
result = result.where("topics.category_id IN (?)", Category.subcategory_ids(category_id))
|
|
else
|
|
result = result.where("topics.category_id = ?", category_id)
|
|
end
|
|
end
|
|
|
|
result.group("date(posts.created_at)").order("date(posts.created_at)").count
|
|
end
|
|
|
|
def self.private_messages_count_per_day(start_date, end_date, topic_subtype)
|
|
private_posts
|
|
.with_topic_subtype(topic_subtype)
|
|
.where("posts.created_at >= ? AND posts.created_at <= ?", start_date, end_date)
|
|
.group("date(posts.created_at)")
|
|
.order("date(posts.created_at)")
|
|
.count
|
|
end
|
|
|
|
def reply_history(max_replies = 100, guardian = nil)
|
|
post_ids = DB.query_single(<<~SQL, post_id: id, topic_id: topic_id)
|
|
WITH RECURSIVE breadcrumb(id, reply_to_post_number) AS (
|
|
SELECT p.id, p.reply_to_post_number FROM posts AS p
|
|
WHERE p.id = :post_id
|
|
UNION
|
|
SELECT p.id, p.reply_to_post_number FROM posts AS p, breadcrumb
|
|
WHERE breadcrumb.reply_to_post_number = p.post_number
|
|
AND p.topic_id = :topic_id
|
|
)
|
|
SELECT id from breadcrumb
|
|
WHERE id <> :post_id
|
|
ORDER by id
|
|
SQL
|
|
|
|
# [1,2,3][-10,-1] => nil
|
|
post_ids = (post_ids[(0 - max_replies)..-1] || post_ids)
|
|
|
|
Post.secured(guardian).where(id: post_ids).includes(:user, :topic).order(:id).to_a
|
|
end
|
|
|
|
MAX_REPLY_LEVEL ||= 1000
|
|
|
|
def reply_ids(guardian = nil, only_replies_to_single_post: true)
|
|
builder = DB.build(<<~SQL)
|
|
WITH RECURSIVE breadcrumb(id, level) AS (
|
|
SELECT :post_id, 0
|
|
UNION
|
|
SELECT reply_post_id, level + 1
|
|
FROM post_replies AS r
|
|
JOIN posts AS p ON p.id = reply_post_id
|
|
JOIN breadcrumb AS b ON (r.post_id = b.id)
|
|
WHERE r.post_id <> r.reply_post_id
|
|
AND b.level < :max_reply_level
|
|
AND p.topic_id = :topic_id
|
|
), breadcrumb_with_count AS (
|
|
SELECT
|
|
id,
|
|
level,
|
|
COUNT(*) AS count
|
|
FROM post_replies AS r
|
|
JOIN breadcrumb AS b ON (r.reply_post_id = b.id)
|
|
WHERE r.reply_post_id <> r.post_id
|
|
GROUP BY id, level
|
|
)
|
|
SELECT id, MIN(level) AS level
|
|
FROM breadcrumb_with_count
|
|
/*where*/
|
|
GROUP BY id
|
|
ORDER BY id
|
|
SQL
|
|
|
|
builder.where("level > 0")
|
|
|
|
# ignore posts that aren't replies to exactly one post
|
|
# for example it skips a post when it contains 2 quotes (which are replies) from different posts
|
|
builder.where("count = 1") if only_replies_to_single_post
|
|
|
|
replies = builder.query_hash(post_id: id, max_reply_level: MAX_REPLY_LEVEL, topic_id: topic_id)
|
|
replies.each { |r| r.symbolize_keys! }
|
|
|
|
secured_ids = Post.secured(guardian).where(id: replies.map { |r| r[:id] }).pluck(:id).to_set
|
|
|
|
replies.reject { |r| !secured_ids.include?(r[:id]) }
|
|
end
|
|
|
|
def revert_to(number)
|
|
return if number >= version
|
|
post_revision = PostRevision.find_by(post_id: id, number: (number + 1))
|
|
post_revision.modifications.each do |attribute, change|
|
|
attribute = "version" if attribute == "cached_version"
|
|
write_attribute(attribute, change[0])
|
|
end
|
|
end
|
|
|
|
def self.rebake_all_quoted_posts(user_id)
|
|
return if user_id.blank?
|
|
|
|
DB.exec(<<~SQL, user_id)
|
|
WITH user_quoted_posts AS (
|
|
SELECT post_id
|
|
FROM quoted_posts
|
|
WHERE quoted_post_id IN (SELECT id FROM posts WHERE user_id = ?)
|
|
)
|
|
UPDATE posts
|
|
SET baked_version = NULL
|
|
WHERE baked_version IS NOT NULL
|
|
AND id IN (SELECT post_id FROM user_quoted_posts)
|
|
SQL
|
|
end
|
|
|
|
def seen?(user)
|
|
PostTiming.where(topic_id: topic_id, post_number: post_number, user_id: user.id).exists?
|
|
end
|
|
|
|
def index_search
|
|
Scheduler::Defer.later "Index post for search" do
|
|
SearchIndexer.index(self)
|
|
end
|
|
end
|
|
|
|
def locked?
|
|
locked_by_id.present?
|
|
end
|
|
|
|
def link_post_uploads(fragments: nil)
|
|
upload_ids = []
|
|
|
|
each_upload_url(fragments: fragments) do |src, _, sha1|
|
|
upload = nil
|
|
upload = Upload.find_by(sha1: sha1) if sha1.present?
|
|
upload ||= Upload.get_from_url(src)
|
|
|
|
# Link any video thumbnails
|
|
if SiteSetting.video_thumbnails_enabled && upload.present? &&
|
|
FileHelper.supported_video.include?(upload.extension&.downcase)
|
|
# Video thumbnails have the filename of the video file sha1 with a .png or .jpg extension.
|
|
# This is because at time of upload in the composer we don't know the topic/post id yet
|
|
# and there is no thumbnail info added to the markdown to tie the thumbnail to the topic/post after
|
|
# creation.
|
|
thumbnail =
|
|
Upload
|
|
.where("original_filename like ?", "#{upload.sha1}.%")
|
|
.order(id: :desc)
|
|
.first if upload.sha1.present?
|
|
if thumbnail.present? && self.is_first_post? && !self.topic.image_upload_id
|
|
upload_ids << thumbnail.id
|
|
self.topic.update_column(:image_upload_id, thumbnail.id)
|
|
extra_sizes =
|
|
ThemeModifierHelper.new(
|
|
theme_ids: Theme.user_selectable.pluck(:id),
|
|
).topic_thumbnail_sizes
|
|
self.topic.generate_thumbnails!(extra_sizes: extra_sizes)
|
|
end
|
|
end
|
|
upload_ids << upload.id if upload.present?
|
|
end
|
|
|
|
upload_references =
|
|
upload_ids.map do |upload_id|
|
|
{
|
|
target_id: self.id,
|
|
target_type: self.class.name,
|
|
upload_id: upload_id,
|
|
created_at: Time.zone.now,
|
|
updated_at: Time.zone.now,
|
|
}
|
|
end
|
|
|
|
UploadReference.transaction do
|
|
UploadReference.where(target: self).delete_all
|
|
UploadReference.insert_all(upload_references) if upload_references.size > 0
|
|
|
|
if SiteSetting.secure_uploads?
|
|
Upload
|
|
.where(id: upload_ids, access_control_post_id: nil)
|
|
.where("id NOT IN (SELECT upload_id FROM custom_emojis)")
|
|
.update_all(access_control_post_id: self.id)
|
|
end
|
|
end
|
|
end
|
|
|
|
def update_uploads_secure_status(source:)
|
|
if Discourse.store.external? && SiteSetting.secure_uploads?
|
|
Jobs.enqueue(:update_post_uploads_secure_status, post_id: self.id, source: source)
|
|
end
|
|
end
|
|
|
|
def each_upload_url(fragments: nil, include_local_upload: true)
|
|
current_db = RailsMultisite::ConnectionManagement.current_db
|
|
upload_patterns = [
|
|
%r{/uploads/#{current_db}/},
|
|
%r{/original/},
|
|
%r{/optimized/},
|
|
%r{/uploads/short-url/[a-zA-Z0-9]+(\.[a-z0-9]+)?},
|
|
]
|
|
|
|
fragments ||= Nokogiri::HTML5.fragment(self.cooked)
|
|
selectors = fragments.css("a/@href", "img/@src", "source/@src", "track/@src", "video/@poster")
|
|
|
|
links =
|
|
selectors
|
|
.map do |media|
|
|
src = media.value
|
|
next if src.blank?
|
|
|
|
if src.end_with?("/images/transparent.png") &&
|
|
(parent = media.parent)["data-orig-src"].present?
|
|
parent["data-orig-src"]
|
|
else
|
|
src
|
|
end
|
|
end
|
|
.compact
|
|
.uniq
|
|
|
|
links.each do |src|
|
|
src = src.split("?")[0]
|
|
|
|
if src.start_with?("upload://")
|
|
sha1 = Upload.sha1_from_short_url(src)
|
|
yield(src, nil, sha1)
|
|
next
|
|
elsif src.include?("/uploads/short-url/")
|
|
sha1 = Upload.sha1_from_short_path(src)
|
|
yield(src, nil, sha1)
|
|
next
|
|
end
|
|
|
|
next if upload_patterns.none? { |pattern| src =~ pattern }
|
|
next if Rails.configuration.multisite && src.exclude?(current_db)
|
|
|
|
src = "#{SiteSetting.force_https ? "https" : "http"}:#{src}" if src.start_with?("//")
|
|
if !Discourse.store.has_been_uploaded?(src) && !Upload.secure_uploads_url?(src) &&
|
|
!(include_local_upload && src =~ %r{\A/[^/]}i)
|
|
next
|
|
end
|
|
|
|
path =
|
|
begin
|
|
URI(
|
|
UrlHelper.unencode(GlobalSetting.cdn_url ? src.sub(GlobalSetting.cdn_url, "") : src),
|
|
)&.path
|
|
rescue URI::Error
|
|
end
|
|
|
|
next if path.blank?
|
|
|
|
sha1 =
|
|
if path.include? "optimized"
|
|
OptimizedImage.extract_sha1(path)
|
|
else
|
|
Upload.extract_sha1(path) || Upload.sha1_from_short_path(path)
|
|
end
|
|
|
|
yield(src, path, sha1)
|
|
end
|
|
end
|
|
|
|
def self.find_missing_uploads(include_local_upload: true)
|
|
missing_uploads = []
|
|
missing_post_uploads = {}
|
|
count = 0
|
|
|
|
DistributedMutex.synchronize("find_missing_uploads", validity: 30.minutes) do
|
|
PostCustomField.where(name: Post::MISSING_UPLOADS).delete_all
|
|
query =
|
|
Post
|
|
.have_uploads
|
|
.joins(:topic)
|
|
.joins(
|
|
"LEFT JOIN post_custom_fields ON posts.id = post_custom_fields.post_id AND post_custom_fields.name = '#{Post::MISSING_UPLOADS_IGNORED}'",
|
|
)
|
|
.where("post_custom_fields.id IS NULL")
|
|
.select(:id, :cooked)
|
|
|
|
query.find_in_batches do |posts|
|
|
ids = posts.pluck(:id)
|
|
sha1s =
|
|
Upload
|
|
.joins(:upload_references)
|
|
.where(upload_references: { target_type: "Post" })
|
|
.where("upload_references.target_id BETWEEN ? AND ?", ids.min, ids.max)
|
|
.pluck(:sha1)
|
|
|
|
posts.each do |post|
|
|
post.each_upload_url do |src, path, sha1|
|
|
next if sha1.present? && sha1s.include?(sha1)
|
|
|
|
missing_post_uploads[post.id] ||= []
|
|
|
|
if missing_uploads.include?(src)
|
|
missing_post_uploads[post.id] << src
|
|
next
|
|
end
|
|
|
|
upload_id = nil
|
|
upload_id = Upload.where(sha1: sha1).pick(:id) if sha1.present?
|
|
upload_id ||= yield(post, src, path, sha1)
|
|
|
|
if upload_id.blank?
|
|
missing_uploads << src
|
|
missing_post_uploads[post.id] << src
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
missing_post_uploads =
|
|
missing_post_uploads.reject do |post_id, uploads|
|
|
if uploads.present?
|
|
PostCustomField.create!(
|
|
post_id: post_id,
|
|
name: Post::MISSING_UPLOADS,
|
|
value: uploads.to_json,
|
|
)
|
|
count += uploads.count
|
|
end
|
|
|
|
uploads.empty?
|
|
end
|
|
end
|
|
|
|
{ uploads: missing_uploads, post_uploads: missing_post_uploads, count: count }
|
|
end
|
|
|
|
def owned_uploads_via_access_control
|
|
Upload.where(access_control_post_id: self.id)
|
|
end
|
|
|
|
def image_url
|
|
raw_url = image_upload&.url
|
|
UrlHelper.cook_url(raw_url, secure: image_upload&.secure?, local: true) if raw_url
|
|
end
|
|
|
|
def cannot_permanently_delete_reason(user)
|
|
if self.deleted_by_id == user&.id && self.deleted_at >= Post::PERMANENT_DELETE_TIMER.ago
|
|
time_left =
|
|
RateLimiter.time_left(
|
|
Post::PERMANENT_DELETE_TIMER.to_i - Time.zone.now.to_i + self.deleted_at.to_i,
|
|
)
|
|
I18n.t("post.cannot_permanently_delete.wait_or_different_admin", time_left: time_left)
|
|
end
|
|
end
|
|
|
|
def mentions
|
|
PrettyText.extract_mentions(Nokogiri::HTML5.fragment(cooked))
|
|
end
|
|
|
|
private
|
|
|
|
def parse_quote_into_arguments(quote)
|
|
return {} unless quote.present?
|
|
args = HashWithIndifferentAccess.new
|
|
quote.first.scan(/([a-z]+)\:(\d+)/).each { |arg| args[arg[0]] = arg[1].to_i }
|
|
args
|
|
end
|
|
|
|
def add_to_quoted_post_numbers(num)
|
|
return unless num.present?
|
|
self.quoted_post_numbers ||= []
|
|
self.quoted_post_numbers << num
|
|
end
|
|
|
|
def create_reply_relationship_with(post)
|
|
return if post.nil? || self.deleted_at.present?
|
|
post_reply = post.post_replies.new(reply_post_id: id)
|
|
if post_reply.save
|
|
if Topic.visible_post_types.include?(self.post_type)
|
|
Post.where(id: post.id).update_all ["reply_count = reply_count + 1"]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
# == Schema Information
|
|
#
|
|
# Table name: posts
|
|
#
|
|
# id :integer not null, primary key
|
|
# user_id :integer
|
|
# topic_id :integer not null
|
|
# post_number :integer not null
|
|
# raw :text not null
|
|
# cooked :text not null
|
|
# created_at :datetime not null
|
|
# updated_at :datetime not null
|
|
# reply_to_post_number :integer
|
|
# reply_count :integer default(0), not null
|
|
# quote_count :integer default(0), not null
|
|
# deleted_at :datetime
|
|
# off_topic_count :integer default(0), not null
|
|
# like_count :integer default(0), not null
|
|
# incoming_link_count :integer default(0), not null
|
|
# bookmark_count :integer default(0), not null
|
|
# score :float
|
|
# reads :integer default(0), not null
|
|
# post_type :integer default(1), not null
|
|
# sort_order :integer
|
|
# last_editor_id :integer
|
|
# hidden :boolean default(FALSE), not null
|
|
# hidden_reason_id :integer
|
|
# notify_moderators_count :integer default(0), not null
|
|
# spam_count :integer default(0), not null
|
|
# illegal_count :integer default(0), not null
|
|
# inappropriate_count :integer default(0), not null
|
|
# last_version_at :datetime not null
|
|
# user_deleted :boolean default(FALSE), not null
|
|
# reply_to_user_id :integer
|
|
# percent_rank :float default(1.0)
|
|
# notify_user_count :integer default(0), not null
|
|
# like_score :integer default(0), not null
|
|
# deleted_by_id :integer
|
|
# edit_reason :string
|
|
# word_count :integer
|
|
# version :integer default(1), not null
|
|
# cook_method :integer default(1), not null
|
|
# wiki :boolean default(FALSE), not null
|
|
# baked_at :datetime
|
|
# baked_version :integer
|
|
# hidden_at :datetime
|
|
# self_edits :integer default(0), not null
|
|
# reply_quoted :boolean default(FALSE), not null
|
|
# via_email :boolean default(FALSE), not null
|
|
# raw_email :text
|
|
# public_version :integer default(1), not null
|
|
# action_code :string
|
|
# locked_by_id :integer
|
|
# image_upload_id :bigint
|
|
# outbound_message_id :string
|
|
#
|
|
# Indexes
|
|
#
|
|
# idx_posts_created_at_topic_id (created_at,topic_id) WHERE (deleted_at IS NULL)
|
|
# idx_posts_deleted_posts (topic_id,post_number) WHERE (deleted_at IS NOT NULL)
|
|
# idx_posts_user_id_deleted_at (user_id) WHERE (deleted_at IS NULL)
|
|
# index_for_rebake_old (id) WHERE (((baked_version IS NULL) OR (baked_version < 2)) AND (deleted_at IS NULL))
|
|
# index_posts_on_id_and_baked_version (id DESC,baked_version) WHERE (deleted_at IS NULL)
|
|
# index_posts_on_id_topic_id_where_not_deleted_or_empty (id,topic_id) WHERE ((deleted_at IS NULL) AND (raw <> ''::text))
|
|
# index_posts_on_image_upload_id (image_upload_id)
|
|
# index_posts_on_reply_to_post_number (reply_to_post_number)
|
|
# index_posts_on_topic_id_and_percent_rank (topic_id,percent_rank)
|
|
# index_posts_on_topic_id_and_post_number (topic_id,post_number) UNIQUE
|
|
# index_posts_on_topic_id_and_sort_order (topic_id,sort_order)
|
|
# index_posts_on_user_id_and_created_at (user_id,created_at)
|
|
# index_posts_user_and_likes (user_id,like_count DESC,created_at DESC) WHERE (post_number > 1)
|
|
#
|