discourse/app/models/topic.rb

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

2187 lines
70 KiB
Ruby
Raw Normal View History

# frozen_string_literal: true
2013-02-06 03:16:51 +08:00
class Topic < ActiveRecord::Base
class UserExists < StandardError
end
class NotAllowed < StandardError
end
2013-02-06 03:16:51 +08:00
include RateLimiter::OnCreateRecord
include HasCustomFields
include Trashable
include Searchable
include LimitedEdit
extend Forwardable
EXTERNAL_ID_MAX_LENGTH = 50
self.ignored_columns = [
"avg_time", # TODO(2021-01-04): remove
"image_url", # TODO(2021-06-01): remove
]
def_delegator :featured_users, :user_ids, :featured_user_ids
def_delegator :featured_users, :choose, :feature_topic_users
def_delegator :notifier, :watch!, :notify_watch!
def_delegator :notifier, :track!, :notify_tracking!
def_delegator :notifier, :regular!, :notify_regular!
def_delegator :notifier, :mute!, :notify_muted!
def_delegator :notifier, :toggle_mute, :toggle_mute
2013-02-06 03:16:51 +08:00
attr_accessor :allowed_user_ids, :allowed_group_ids, :tags_changed, :includes_destination_category
def self.max_fancy_title_length
400
end
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
def self.share_thumbnail_size
[1024, 1024]
end
def self.thumbnail_sizes
[self.share_thumbnail_size] + DiscoursePluginRegistry.topic_thumbnail_sizes
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
end
def thumbnail_job_redis_key(sizes)
"generate_topic_thumbnail_enqueue_#{id}_#{sizes.inspect}"
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
end
def filtered_topic_thumbnails(extra_sizes: [])
return nil unless original = image_upload
return nil unless original.read_attribute(:width) && original.read_attribute(:height)
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
thumbnail_sizes = Topic.thumbnail_sizes + extra_sizes
topic_thumbnails.filter do |record|
thumbnail_sizes.include?([record.max_width, record.max_height])
end
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
end
def thumbnail_info(enqueue_if_missing: false, extra_sizes: [])
return nil unless original = image_upload
return nil if original.filesize >= SiteSetting.max_image_size_kb.kilobytes
return nil unless original.read_attribute(:width) && original.read_attribute(:height)
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
infos = []
infos << { # Always add original
max_width: nil,
max_height: nil,
width: original.width,
height: original.height,
url: original.url,
}
records = filtered_topic_thumbnails(extra_sizes: extra_sizes)
records.each do |record|
next unless record.optimized_image # Only serialize successful thumbnails
infos << {
max_width: record.max_width,
max_height: record.max_height,
width: record.optimized_image&.width,
height: record.optimized_image&.height,
url: record.optimized_image&.url,
}
end
thumbnail_sizes = Topic.thumbnail_sizes + extra_sizes
if SiteSetting.create_thumbnails && enqueue_if_missing &&
records.length < thumbnail_sizes.length &&
Discourse.redis.set(thumbnail_job_redis_key(extra_sizes), 1, nx: true, ex: 1.minute)
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
Jobs.enqueue(:generate_topic_thumbnails, { topic_id: id, extra_sizes: extra_sizes })
end
infos.each { |i| i[:url] = UrlHelper.cook_url(i[:url], secure: original.secure?, local: true) }
2020-05-15 20:35:20 +08:00
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
infos.sort_by! { |i| -i[:width] * i[:height] }
end
def generate_thumbnails!(extra_sizes: [])
return nil unless SiteSetting.create_thumbnails
return nil unless original = image_upload
return nil if original.filesize >= SiteSetting.max_image_size_kb.kilobytes
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
return nil unless original.width && original.height
extra_sizes = [] unless extra_sizes.kind_of?(Array)
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
(Topic.thumbnail_sizes + extra_sizes).each do |dim|
TopicThumbnail.find_or_create_for!(original, max_width: dim[0], max_height: dim[1])
end
end
def image_url(enqueue_if_missing: false)
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
thumbnail =
topic_thumbnails.detect do |record|
record.max_width == Topic.share_thumbnail_size[0] &&
record.max_height == Topic.share_thumbnail_size[1]
end
2020-05-15 20:35:20 +08:00
if thumbnail.nil? && image_upload && SiteSetting.create_thumbnails &&
image_upload.filesize < SiteSetting.max_image_size_kb.kilobytes &&
image_upload.read_attribute(:width) && image_upload.read_attribute(:height) &&
enqueue_if_missing &&
Discourse.redis.set(thumbnail_job_redis_key([]), 1, nx: true, ex: 1.minute)
Jobs.enqueue(:generate_topic_thumbnails, { topic_id: id })
end
2020-05-15 20:35:20 +08:00
raw_url = thumbnail&.optimized_image&.url || image_upload&.url
UrlHelper.cook_url(raw_url, secure: image_upload&.secure?, local: true) if raw_url
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
end
def featured_users
@featured_users ||= TopicFeaturedUsers.new(self)
end
2013-02-06 03:16:51 +08:00
2013-07-10 03:20:18 +08:00
def trash!(trashed_by = nil)
trigger_event = false
if deleted_at.nil?
update_category_topic_count_by(-1) if visible?
CategoryTagStat.topic_deleted(self) if self.tags.present?
trigger_event = true
end
2013-07-10 03:20:18 +08:00
super(trashed_by)
DiscourseEvent.trigger(:topic_trashed, self) if trigger_event
2017-04-25 02:29:04 +08:00
self.topic_embed.trash! if has_topic_embed?
end
def recover!(recovered_by = nil)
trigger_event = false
unless deleted_at.nil?
update_category_topic_count_by(1) if visible?
CategoryTagStat.topic_recovered(self) if self.tags.present?
trigger_event = true
end
# Note parens are required because superclass doesn't take `recovered_by`
super()
DiscourseEvent.trigger(:topic_recovered, self) if trigger_event
2017-04-25 02:29:04 +08:00
unless (topic_embed = TopicEmbed.with_deleted.find_by_topic_id(id)).nil?
topic_embed.recover!
end
end
2013-02-06 03:16:51 +08:00
rate_limit :default_rate_limiter
rate_limit :limit_topics_per_day
rate_limit :limit_private_messages_per_day
validates :title,
if: Proc.new { |t| t.new_record? || t.title_changed? },
presence: true,
topic_title_length: true,
censored_words: true,
watched_words: true,
quality_title: {
unless: :private_message?,
},
max_emojis: true,
unique_among: {
unless:
Proc.new { |t| (SiteSetting.allow_duplicate_topic_titles? || t.private_message?) },
message: :has_already_been_used,
allow_blank: true,
case_sensitive: false,
collection:
Proc.new { |t|
if SiteSetting.allow_duplicate_topic_titles_category?
Topic.listable_topics.where("category_id = ?", t.category_id)
else
Topic.listable_topics
end
},
}
2013-02-06 03:16:51 +08:00
validates :category_id,
presence: true,
exclusion: {
in: Proc.new { [SiteSetting.uncategorized_category_id] },
},
if:
Proc.new { |t|
(t.new_record? || t.category_id_changed?) &&
!SiteSetting.allow_uncategorized_topics && (t.archetype.nil? || t.regular?)
}
validates :featured_link, allow_nil: true, url: true
validate if: :featured_link do
if featured_link_changed? && !Guardian.new(user).can_edit_featured_link?(category_id)
errors.add(:featured_link)
end
end
validates :external_id,
allow_nil: true,
uniqueness: {
case_sensitive: false,
},
length: {
maximum: EXTERNAL_ID_MAX_LENGTH,
},
format: {
with: /\A[\w-]+\z/,
}
before_validation do
self.title = TextCleaner.clean_title(TextSentinel.title_sentinel(title).text) if errors[
:title
].empty?
self.featured_link = self.featured_link.strip.presence if self.featured_link
end
2013-02-06 03:16:51 +08:00
belongs_to :category
has_many :category_users, through: :category
2013-02-06 03:16:51 +08:00
has_many :posts
# NOTE: To get all Post _and_ Topic bookmarks for a topic by user,
# use the Bookmark.for_user_in_topic scope.
has_many :bookmarks, as: :bookmarkable
has_many :ordered_posts, -> { order(post_number: :asc) }, class_name: "Post"
2013-02-06 03:16:51 +08:00
has_many :topic_allowed_users
has_many :topic_allowed_groups
has_many :incoming_email
has_many :group_archived_messages, dependent: :destroy
has_many :user_archived_messages, dependent: :destroy
has_many :allowed_groups, through: :topic_allowed_groups, source: :group
has_many :allowed_group_users, through: :allowed_groups, source: :users
2013-02-06 03:16:51 +08:00
has_many :allowed_users, through: :topic_allowed_users, source: :user
has_many :topic_tags
has_many :tags, through: :topic_tags, dependent: :destroy # dependent destroy applies to the topic_tags records
has_many :tag_users, through: :tags
2013-12-24 07:50:36 +08:00
has_one :top_topic
has_one :shared_draft, dependent: :destroy
has_one :published_page
2013-02-06 03:16:51 +08:00
belongs_to :user
belongs_to :last_poster, class_name: "User", foreign_key: :last_post_user_id
belongs_to :featured_user1, class_name: "User", foreign_key: :featured_user1_id
belongs_to :featured_user2, class_name: "User", foreign_key: :featured_user2_id
belongs_to :featured_user3, class_name: "User", foreign_key: :featured_user3_id
belongs_to :featured_user4, class_name: "User", foreign_key: :featured_user4_id
has_many :topic_users
has_many :dismissed_topic_users
2013-02-06 03:16:51 +08:00
has_many :topic_links
has_many :topic_invites
has_many :invites, through: :topic_invites, source: :invite
has_many :topic_timers, dependent: :destroy
has_many :reviewables
has_many :user_profiles
2013-02-06 03:16:51 +08:00
2017-04-15 12:11:02 +08:00
has_one :user_warning
has_one :first_post, -> { where post_number: 1 }, class_name: "Post"
has_one :topic_search_data
2017-04-25 02:29:04 +08:00
has_one :topic_embed, dependent: :destroy
has_one :linked_topic, dependent: :destroy
2017-04-25 02:29:04 +08:00
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
belongs_to :image_upload, class_name: "Upload"
has_many :topic_thumbnails, through: :image_upload
2013-02-06 03:16:51 +08:00
# When we want to temporarily attach some data to a forum topic (usually before serialization)
attr_accessor :user_data
attr_accessor :category_user_data
attr_accessor :dismissed
2015-06-22 16:09:08 +08:00
2013-02-06 03:16:51 +08:00
attr_accessor :posters # TODO: can replace with posters_summary once we remove old list code
attr_accessor :participants
attr_accessor :participant_groups
2013-04-03 04:52:51 +08:00
attr_accessor :topic_list
2014-04-26 00:24:22 +08:00
attr_accessor :meta_data
2013-10-17 14:44:56 +08:00
attr_accessor :include_last_poster
attr_accessor :import_mode # set to true to optimize creation and save for imports
2013-02-06 03:16:51 +08:00
# The regular order
scope :topic_list_order, -> { order("topics.bumped_at desc") }
2013-02-06 03:16:51 +08:00
# Return private message topics
scope :private_messages, -> { where(archetype: Archetype.private_message) }
2013-02-06 03:16:51 +08:00
PRIVATE_MESSAGES_SQL_USER = <<~SQL
SELECT topic_id
FROM topic_allowed_users
WHERE user_id = :user_id
SQL
PRIVATE_MESSAGES_SQL_GROUP = <<~SQL
SELECT tg.topic_id
FROM topic_allowed_groups tg
JOIN group_users gu ON gu.user_id = :user_id AND gu.group_id = tg.group_id
SQL
scope :private_messages_for_user,
->(user) {
private_messages.where(
"topics.id IN (#{PRIVATE_MESSAGES_SQL_USER})
OR topics.id IN (#{PRIVATE_MESSAGES_SQL_GROUP})",
user_id: user.id,
)
}
scope :listable_topics, -> { where("topics.archetype <> ?", Archetype.private_message) }
2013-02-06 03:16:51 +08:00
scope :by_newest, -> { order("topics.created_at desc, topics.id desc") }
scope :visible, -> { where(visible: true) }
scope :created_since, lambda { |time_ago| where("topics.created_at > ?", time_ago) }
scope :exclude_scheduled_bump_topics, -> { where.not(id: TopicTimer.scheduled_bump_topics) }
scope :secured,
lambda { |guardian = nil|
ids = guardian.secure_category_ids if guardian
# Query conditions
condition =
if ids.present?
["NOT read_restricted OR id IN (:cats)", cats: ids]
else
["NOT read_restricted"]
end
where(
"topics.category_id IS NULL OR topics.category_id IN (SELECT id FROM categories WHERE #{condition[0]})",
condition[1],
)
}
scope :in_category_and_subcategories,
lambda { |category_id|
if category_id
where("topics.category_id IN (?)", Category.subcategory_ids(category_id.to_i))
end
}
scope :with_subtype, ->(subtype) { where("topics.subtype = ?", subtype) }
attr_accessor :ignore_category_auto_close
attr_accessor :skip_callbacks
attr_accessor :advance_draft
before_create { initialize_default_values }
2013-02-06 03:16:51 +08:00
after_create do
2013-12-13 14:04:45 +08:00
unless skip_callbacks
changed_to_category(category)
advance_draft_sequence if advance_draft
2013-02-06 03:16:51 +08:00
end
end
before_save do
ensure_topic_has_a_category unless skip_callbacks
write_attribute(:fancy_title, Topic.fancy_title(title)) if title_changed?
if category_id_changed? || new_record?
inherit_auto_close_from_category
inherit_slow_mode_from_category
end
end
after_save do
banner = "banner"
if archetype_before_last_save == banner || archetype == banner
ApplicationController.banner_json_cache.clear
end
if tags_changed || saved_change_to_attribute?(:category_id) ||
saved_change_to_attribute?(:title)
SearchIndexer.queue_post_reindex(self.id)
if tags_changed
TagUser.auto_watch(topic_id: id)
TagUser.auto_track(topic_id: id)
self.tags_changed = false
end
end
SearchIndexer.index(self)
end
after_update do
if saved_changes[:category_id] && self.tags.present?
CategoryTagStat.topic_moved(self, *saved_changes[:category_id])
elsif saved_changes[:category_id] && self.category&.read_restricted?
UserProfile.remove_featured_topic_from_all_profiles(self)
end
end
def initialize_default_values
self.bumped_at ||= Time.now
self.last_post_user_id ||= user_id
end
def advance_draft_sequence
if self.private_message?
DraftSequence.next!(user, Draft::NEW_PRIVATE_MESSAGE)
else
DraftSequence.next!(user, Draft::NEW_TOPIC)
end
end
def ensure_topic_has_a_category
if category_id.nil? && (archetype.nil? || self.regular?)
self.category_id = category&.id || SiteSetting.uncategorized_category_id
end
2013-12-12 10:41:34 +08:00
end
def self.visible_post_types(viewed_by = nil, include_moderator_actions: true)
2015-09-11 04:01:23 +08:00
types = Post.types
result = [types[:regular]]
result += [types[:moderator_action], types[:small_action]] if include_moderator_actions
result << types[:whisper] if viewed_by&.whisperer?
2015-09-11 04:01:23 +08:00
result
end
def self.top_viewed(max = 10)
Topic.listable_topics.visible.secured.order("views desc").limit(max)
end
def self.recent(max = 10)
Topic.listable_topics.visible.secured.order("created_at desc").limit(max)
end
def self.count_exceeds_minimum?
count > SiteSetting.minimum_topics_similar
end
def best_post
posts
.where(post_type: Post.types[:regular], user_deleted: false)
.order("score desc nulls last")
.limit(1)
.first
end
def self.has_flag_scope
ReviewableFlaggedPost.pending_and_default_visible
end
def has_flags?
self.class.has_flag_scope.exists?(topic_id: self.id)
end
def is_official_warning?
subtype == TopicSubtype.moderator_warning
end
# all users (in groups or directly targeted) that are going to get the pm
def all_allowed_users
moderators_sql = " UNION #{User.moderators.to_sql}" if private_message? &&
(has_flags? || is_official_warning?)
2015-10-30 01:39:30 +08:00
User.from(
"(#{allowed_users.to_sql} UNION #{allowed_group_users.to_sql}#{moderators_sql}) as users",
)
end
2013-02-06 03:16:51 +08:00
# Additional rate limits on topics: per day and private messages per day
def limit_topics_per_day
return unless regular?
if user && user.new_user_posting_on_first_day?
limit_first_day_topics_per_day
else
apply_per_day_rate_limit_for("topics", :max_topics_per_day)
end
2013-02-06 03:16:51 +08:00
end
def limit_private_messages_per_day
return unless private_message?
apply_per_day_rate_limit_for("pms", :max_personal_messages_per_day)
2013-02-06 03:16:51 +08:00
end
def self.fancy_title(title)
return unless escaped = ERB::Util.html_escape(title)
fancy_title = Emoji.unicode_unescape(HtmlPrettify.render(escaped))
fancy_title.length > Topic.max_fancy_title_length ? escaped : fancy_title
end
2013-02-26 00:42:20 +08:00
def fancy_title
return ERB::Util.html_escape(title) unless SiteSetting.title_fancy_entities?
unless fancy_title = read_attribute(:fancy_title)
fancy_title = Topic.fancy_title(title)
write_attribute(:fancy_title, fancy_title)
if !new_record? && !Discourse.readonly_mode?
# make sure data is set in table, this also allows us to change algorithm
# by simply nulling this column
DB.exec(
"UPDATE topics SET fancy_title = :fancy_title where id = :id",
id: self.id,
fancy_title: fancy_title,
)
end
end
2013-02-20 05:08:23 +08:00
fancy_title
2013-04-22 11:48:05 +08:00
end
# Returns hot topics since a date for display in email digest.
def self.for_digest(user, since, opts = nil)
opts = opts || {}
period = ListController.best_period_for(since)
topics =
Topic
.visible
.secured(Guardian.new(user))
2014-04-18 03:21:55 +08:00
.joins(
"LEFT OUTER JOIN topic_users ON topic_users.topic_id = topics.id AND topic_users.user_id = #{user.id.to_i}",
)
.joins(
"LEFT OUTER JOIN category_users ON category_users.category_id = topics.category_id AND category_users.user_id = #{user.id.to_i}",
)
.joins("LEFT OUTER JOIN users ON users.id = topics.user_id")
.where(closed: false, archived: false)
2014-04-18 03:21:55 +08:00
.where(
"COALESCE(topic_users.notification_level, 1) <> ?",
TopicUser.notification_levels[:muted],
)
.created_since(since)
.where("topics.created_at < ?", (SiteSetting.editing_grace_period || 0).seconds.ago)
.listable_topics
.includes(:category)
unless opts[:include_tl0] || user.user_option.try(:include_tl0_in_digests)
topics = topics.where("COALESCE(users.trust_level, 0) > 0")
end
if !!opts[:top_order]
topics =
topics.joins("LEFT OUTER JOIN top_topics ON top_topics.topic_id = topics.id").order(<<~SQL)
COALESCE(topic_users.notification_level, 1) DESC,
COALESCE(category_users.notification_level, 1) DESC,
COALESCE(top_topics.#{TopTopic.score_column_for_period(period)}, 0) DESC,
topics.bumped_at DESC
SQL
end
topics = topics.limit(opts[:limit]) if opts[:limit]
# Remove category topics
category_topic_ids = Category.pluck(:topic_id).compact!
topics = topics.where("topics.id NOT IN (?)", category_topic_ids) if category_topic_ids.present?
# Remove muted and shared draft categories
remove_category_ids =
CategoryUser.where(
user_id: user.id,
notification_level: CategoryUser.notification_levels[:muted],
).pluck(:category_id)
if SiteSetting.digest_suppress_categories.present?
topics =
topics.where(
"topics.category_id NOT IN (?)",
SiteSetting.digest_suppress_categories.split("|").map(&:to_i),
)
end
if SiteSetting.digest_suppress_tags.present?
topics =
topics.joins("LEFT JOIN topic_tags tg ON topics.id = tg.topic_id").where(
"tg.tag_id NOT IN (?) OR tg.tag_id IS NULL",
SiteSetting.digest_suppress_tags.split("|").map(&:to_i),
)
end
remove_category_ids << SiteSetting.shared_drafts_category if SiteSetting.shared_drafts_enabled?
if remove_category_ids.present?
remove_category_ids.uniq!
topics =
topics.where(
"topic_users.notification_level != ? OR topics.category_id NOT IN (?)",
TopicUser.notification_levels[:muted],
remove_category_ids,
)
end
# Remove muted tags
muted_tag_ids = TagUser.lookup(user, :muted).pluck(:tag_id)
unless muted_tag_ids.empty?
# If multiple tags per topic, include topics with tags that aren't muted,
# and don't forget untagged topics.
topics =
topics.where(
"EXISTS ( SELECT 1 FROM topic_tags WHERE topic_tags.topic_id = topics.id AND tag_id NOT IN (?) )
OR NOT EXISTS (SELECT 1 FROM topic_tags WHERE topic_tags.topic_id = topics.id)",
muted_tag_ids,
)
end
topics
2013-02-06 03:16:51 +08:00
end
2013-02-07 23:45:24 +08:00
2014-04-26 00:24:22 +08:00
def meta_data=(data)
custom_fields.replace(data)
end
def meta_data
custom_fields
end
2013-02-06 03:16:51 +08:00
def update_meta_data(data)
2014-04-26 00:24:22 +08:00
custom_fields.update(data)
2013-02-06 03:16:51 +08:00
save
end
2013-04-22 11:48:05 +08:00
def reload(options = nil)
@post_numbers = nil
@public_topic_timer = nil
@slow_mode_topic_timer = nil
@is_category_topic = nil
2013-04-22 11:48:05 +08:00
super(options)
end
2013-02-06 03:16:51 +08:00
def post_numbers
@post_numbers ||= posts.order(:post_number).pluck(:post_number)
end
def age_in_minutes
((Time.zone.now - created_at) / 1.minute).round
end
def self.listable_count_per_day(
start_date,
end_date,
category_id = nil,
include_subcategories = false
)
result =
listable_topics.where(
"topics.created_at >= ? AND topics.created_at <= ?",
start_date,
end_date,
)
result = result.group("date(topics.created_at)").order("date(topics.created_at)")
result =
result.where(
category_id: include_subcategories ? Category.subcategory_ids(category_id) : category_id,
) if category_id
result.count
2013-03-08 00:07:59 +08:00
end
2013-02-07 23:45:24 +08:00
def private_message?
self.archetype == Archetype.private_message
2013-02-06 03:16:51 +08:00
end
def regular?
self.archetype == Archetype.default
end
def open?
!self.closed?
end
MAX_SIMILAR_BODY_LENGTH ||= 200
def self.similar_to(title, raw, user = nil)
return [] if title.blank?
raw = raw.presence || ""
search_data = Search.prepare_data(title.strip)
return [] if search_data.blank?
tsquery = Search.set_tsquery_weight_filter(search_data, "A")
if raw.present?
cooked =
SearchIndexer::HtmlScrubber.scrub(PrettyText.cook(raw[0...MAX_SIMILAR_BODY_LENGTH].strip))
prepared_data = cooked.present? && Search.prepare_data(cooked)
if prepared_data.present?
raw_tsquery = Search.set_tsquery_weight_filter(prepared_data, "B")
tsquery = "#{tsquery} & #{raw_tsquery}"
end
end
tsquery = Search.to_tsquery(term: tsquery, joiner: "|")
guardian = Guardian.new(user)
excluded_category_ids_sql =
Category
.secured(guardian)
.where(search_priority: Searchable::PRIORITIES[:ignore])
.select(:id)
.to_sql
excluded_category_ids_sql = <<~SQL if user
#{excluded_category_ids_sql}
UNION
#{CategoryUser.muted_category_ids_query(user, include_direct: true).select("categories.id").to_sql}
SQL
candidates =
Topic
.visible
.listable_topics
.secured(guardian)
.joins("JOIN topic_search_data s ON topics.id = s.topic_id")
.joins("LEFT JOIN categories c ON topics.id = c.topic_id")
.where("search_data @@ #{tsquery}")
.where("c.topic_id IS NULL")
.where("topics.category_id NOT IN (#{excluded_category_ids_sql})")
.order("ts_rank(search_data, #{tsquery}) DESC")
.limit(SiteSetting.max_similar_results * 3)
candidate_ids = candidates.pluck(:id)
return [] if candidate_ids.blank?
similars =
Topic
.joins("JOIN posts AS p ON p.topic_id = topics.id AND p.post_number = 1")
.where("topics.id IN (?)", candidate_ids)
.order("similarity DESC")
.limit(SiteSetting.max_similar_results)
if raw.present?
similars.select(
DB.sql_fragment(
"topics.*, similarity(topics.title, :title) + similarity(p.raw, :raw) AS similarity, p.cooked AS blurb",
title: title,
raw: raw,
),
).where(
"similarity(topics.title, :title) + similarity(p.raw, :raw) > 0.2",
title: title,
raw: raw,
)
else
similars.select(
DB.sql_fragment(
"topics.*, similarity(topics.title, :title) AS similarity, p.cooked AS blurb",
title: title,
),
).where("similarity(topics.title, :title) > 0.2", title: title)
end
end
2015-07-29 22:34:21 +08:00
def update_status(status, enabled, user, opts = {})
TopicStatusUpdater.new(self, user).update!(status, enabled, opts)
DiscourseEvent.trigger(:topic_status_updated, self, status, enabled)
if status == "closed"
StaffActionLogger.new(user).log_topic_closed(self, closed: enabled)
elsif status == "archived"
StaffActionLogger.new(user).log_topic_archived(self, archived: enabled)
end
if enabled && private_message? && status.to_s["closed"]
group_ids = user.groups.pluck(:id)
if group_ids.present?
allowed_group_ids =
self.allowed_groups.where("topic_allowed_groups.group_id IN (?)", group_ids).pluck(:id)
allowed_group_ids.each { |id| GroupArchivedMessage.archive!(id, self) }
end
end
2013-02-06 03:16:51 +08:00
end
# Atomically creates the next post number
def self.next_post_number(topic_id, opts = {})
highest =
DB
.query_single(
"SELECT coalesce(max(post_number),0) AS max FROM posts WHERE topic_id = ?",
topic_id,
)
.first
.to_i
2013-02-06 03:16:51 +08:00
if opts[:whisper]
result = DB.query_single(<<~SQL, highest, topic_id)
UPDATE topics
SET highest_staff_post_number = ? + 1
WHERE id = ?
RETURNING highest_staff_post_number
SQL
result.first.to_i
else
reply_sql = opts[:reply] ? ", reply_count = reply_count + 1" : ""
posts_sql = opts[:post] ? ", posts_count = posts_count + 1" : ""
result = DB.query_single(<<~SQL, highest: highest, topic_id: topic_id)
UPDATE topics
SET highest_staff_post_number = :highest + 1,
highest_post_number = :highest + 1
#{reply_sql}
#{posts_sql}
WHERE id = :topic_id
RETURNING highest_post_number
SQL
result.first.to_i
end
end
def self.reset_all_highest!
DB.exec <<~SQL
WITH
X as (
SELECT topic_id,
COALESCE(MAX(post_number), 0) highest_post_number
FROM posts
WHERE deleted_at IS NULL
GROUP BY topic_id
),
Y as (
SELECT topic_id,
coalesce(MAX(post_number), 0) highest_post_number,
count(*) posts_count,
max(created_at) last_posted_at
FROM posts
WHERE deleted_at IS NULL AND post_type <> 4
GROUP BY topic_id
)
UPDATE topics
SET
highest_staff_post_number = X.highest_post_number,
highest_post_number = Y.highest_post_number,
last_posted_at = Y.last_posted_at,
posts_count = Y.posts_count
FROM X, Y
WHERE
topics.archetype <> 'private_message' AND
X.topic_id = topics.id AND
Y.topic_id = topics.id AND (
topics.highest_staff_post_number <> X.highest_post_number OR
topics.highest_post_number <> Y.highest_post_number OR
topics.last_posted_at <> Y.last_posted_at OR
topics.posts_count <> Y.posts_count
)
SQL
DB.exec <<~SQL
WITH
X as (
SELECT topic_id,
COALESCE(MAX(post_number), 0) highest_post_number
FROM posts
WHERE deleted_at IS NULL
GROUP BY topic_id
),
Y as (
SELECT topic_id,
coalesce(MAX(post_number), 0) highest_post_number,
count(*) posts_count,
max(created_at) last_posted_at
FROM posts
WHERE deleted_at IS NULL AND post_type <> 3 AND post_type <> 4
GROUP BY topic_id
)
UPDATE topics
SET
highest_staff_post_number = X.highest_post_number,
highest_post_number = Y.highest_post_number,
last_posted_at = Y.last_posted_at,
posts_count = Y.posts_count
FROM X, Y
WHERE
topics.archetype = 'private_message' AND
X.topic_id = topics.id AND
Y.topic_id = topics.id AND (
topics.highest_staff_post_number <> X.highest_post_number OR
topics.highest_post_number <> Y.highest_post_number OR
topics.last_posted_at <> Y.last_posted_at OR
topics.posts_count <> Y.posts_count
)
SQL
2013-02-06 03:16:51 +08:00
end
# If a post is deleted we have to update our highest post counters and last post information
2013-02-06 03:16:51 +08:00
def self.reset_highest(topic_id)
archetype = Topic.where(id: topic_id).pick(:archetype)
# ignore small_action replies for private messages
post_type =
archetype == Archetype.private_message ? " AND post_type <> #{Post.types[:small_action]}" : ""
result = DB.query_single(<<~SQL, topic_id: topic_id)
UPDATE topics
SET
highest_staff_post_number = (
SELECT COALESCE(MAX(post_number), 0) FROM posts
WHERE topic_id = :topic_id AND
deleted_at IS NULL
),
highest_post_number = (
SELECT COALESCE(MAX(post_number), 0) FROM posts
WHERE topic_id = :topic_id AND
deleted_at IS NULL AND
post_type <> 4
#{post_type}
),
posts_count = (
SELECT count(*) FROM posts
WHERE deleted_at IS NULL AND
topic_id = :topic_id AND
post_type <> 4
#{post_type}
),
last_posted_at = (
SELECT MAX(created_at) FROM posts
WHERE topic_id = :topic_id AND
deleted_at IS NULL AND
post_type <> 4
#{post_type}
),
last_post_user_id = COALESCE((
SELECT user_id FROM posts
WHERE topic_id = :topic_id AND
deleted_at IS NULL AND
post_type <> 4
#{post_type}
ORDER BY created_at desc
LIMIT 1
), last_post_user_id)
WHERE id = :topic_id
RETURNING highest_post_number
SQL
highest_post_number = result.first.to_i
2013-02-06 03:16:51 +08:00
# Update the forum topic user records
DB.exec(<<~SQL, highest: highest_post_number, topic_id: topic_id)
UPDATE topic_users
SET last_read_post_number = CASE
WHEN last_read_post_number > :highest THEN :highest
ELSE last_read_post_number
END
WHERE topic_id = :topic_id
SQL
2013-02-06 03:16:51 +08:00
end
cattr_accessor :update_featured_topics
def changed_to_category(new_category)
return true if new_category.blank? || Category.exists?(topic_id: id)
if new_category.id == SiteSetting.uncategorized_category_id &&
!SiteSetting.allow_uncategorized_topics
return false
end
2013-02-06 03:16:51 +08:00
Topic.transaction do
old_category = category
if self.category_id != new_category.id
self.update(category_id: new_category.id)
if old_category
Category.where(id: old_category.id).update_all("topic_count = topic_count - 1")
count =
if old_category.read_restricted && !new_category.read_restricted
1
elsif !old_category.read_restricted && new_category.read_restricted
-1
end
Tag.update_counters(self.tags, { public_topic_count: count }) if count
end
# when a topic changes category we may have to start watching it
# if we happen to have read state for it
CategoryUser.auto_watch(category_id: new_category.id, topic_id: self.id)
CategoryUser.auto_track(category_id: new_category.id, topic_id: self.id)
if !SiteSetting.disable_category_edit_notifications && (post = self.ordered_posts.first)
notified_user_ids = [post.user_id, post.last_editor_id].uniq
DB.after_commit do
Jobs.enqueue(
:notify_category_change,
post_id: post.id,
notified_user_ids: notified_user_ids,
)
end
end
# when a topic changes category we may need to make uploads
# linked to posts secure/not secure depending on whether the
# category is private. this is only done if the category
# has actually changed to avoid noise.
DB.after_commit { Jobs.enqueue(:update_topic_upload_security, topic_id: self.id) }
2013-02-06 03:16:51 +08:00
end
Category.where(id: new_category.id).update_all("topic_count = topic_count + 1")
if Topic.update_featured_topics != false
CategoryFeaturedTopic.feature_topics_for(old_category) unless @import_mode
unless @import_mode || old_category.try(:id) == new_category.id
CategoryFeaturedTopic.feature_topics_for(new_category)
end
end
2013-02-07 23:45:24 +08:00
end
true
2013-02-06 03:16:51 +08:00
end
def add_small_action(user, action_code, who = nil, opts = {})
custom_fields = {}
custom_fields["action_code_who"] = who if who.present?
opts =
opts.merge(
post_type: Post.types[:small_action],
action_code: action_code,
custom_fields: custom_fields,
)
add_moderator_post(user, nil, opts)
end
def add_moderator_post(user, text, opts = nil)
opts ||= {}
2013-02-06 03:16:51 +08:00
new_post = nil
creator =
PostCreator.new(
user,
raw: text,
post_type: opts[:post_type] || Post.types[:moderator_action],
action_code: opts[:action_code],
no_bump: opts[:bump].blank?,
topic_id: self.id,
silent: opts[:silent],
skip_validations: true,
custom_fields: opts[:custom_fields],
import_mode: opts[:import_mode],
)
2013-02-06 03:16:51 +08:00
if (new_post = creator.create) && new_post.present?
increment!(:moderator_posts_count) if new_post.persisted?
2013-02-06 03:16:51 +08:00
# If we are moving posts, we want to insert the moderator post where the previous posts were
# in the stream, not at the end.
if opts[:post_number].present?
new_post.update!(post_number: opts[:post_number], sort_order: opts[:post_number])
end
2013-02-06 03:16:51 +08:00
# Grab any links that are present
TopicLink.extract_from(new_post)
QuotedPost.extract_from(new_post)
2013-02-06 03:16:51 +08:00
end
2013-02-07 23:45:24 +08:00
2013-02-06 03:16:51 +08:00
new_post
end
def change_category_to_id(category_id)
return false if private_message?
new_category_id = category_id.to_i
# if the category name is blank, reset the attribute
new_category_id = SiteSetting.uncategorized_category_id if new_category_id == 0
2013-02-06 03:16:51 +08:00
return true if self.category_id == new_category_id
cat = Category.find_by(id: new_category_id)
return false unless cat
reviewables.update_all(category_id: new_category_id)
2013-02-06 03:16:51 +08:00
changed_to_category(cat)
end
def remove_allowed_group(removed_by, name)
if group = Group.find_by(name: name)
group_user = topic_allowed_groups.find_by(group_id: group.id)
if group_user
group_user.destroy
allowed_groups.reload
add_small_action(removed_by, "removed_group", group.name)
return true
end
end
false
end
def remove_allowed_user(removed_by, username)
2017-10-10 16:26:56 +08:00
user = username.is_a?(User) ? username : User.find_by(username: username)
if user
topic_user = topic_allowed_users.find_by(user_id: user.id)
2017-10-10 16:26:56 +08:00
if topic_user
2017-10-10 16:26:56 +08:00
if user.id == removed_by&.id
add_small_action(removed_by, "user_left", user.username)
else
add_small_action(removed_by, "removed_user", user.username)
end
topic_user.destroy
return true
end
end
false
end
def reached_recipients_limit?
return false unless private_message?
topic_allowed_users.count + topic_allowed_groups.count >=
SiteSetting.max_allowed_message_recipients
end
def invite_group(user, group)
TopicAllowedGroup.create!(topic_id: self.id, group_id: group.id)
self.allowed_groups.reload
last_post =
self.posts.order("post_number desc").where("not hidden AND posts.deleted_at IS NULL").first
if last_post
Jobs.enqueue(:post_alert, post_id: last_post.id)
add_small_action(user, "invited_group", group.name)
Jobs.enqueue(:group_pm_alert, user_id: user.id, group_id: group.id, post_id: last_post.id)
end
# If the group invited includes the OP of the topic as one of is members,
# we cannot strip the topic_allowed_user record since it will be more
# complicated to recover the topic_allowed_user record for the OP if the
# group is removed.
allowed_user_where_clause = <<~SQL
users.id IN (
SELECT topic_allowed_users.user_id
FROM topic_allowed_users
INNER JOIN group_users ON group_users.user_id = topic_allowed_users.user_id
INNER JOIN topic_allowed_groups ON topic_allowed_groups.group_id = group_users.group_id
WHERE topic_allowed_groups.group_id = :group_id AND
topic_allowed_users.topic_id = :topic_id AND
topic_allowed_users.user_id != :op_user_id
)
SQL
User
.where(
[
allowed_user_where_clause,
{ group_id: group.id, topic_id: self.id, op_user_id: self.user_id },
],
)
.find_each { |allowed_user| remove_allowed_user(Discourse.system_user, allowed_user) }
true
end
def invite(invited_by, username_or_email, group_ids = nil, custom_message = nil)
guardian = Guardian.new(invited_by)
if target_user = User.find_by_username_or_email(username_or_email)
if topic_allowed_users.exists?(user_id: target_user.id)
raise UserExists.new(I18n.t("topic_invite.user_exists"))
end
comm_screener = UserCommScreener.new(acting_user: invited_by, target_user_ids: target_user.id)
if comm_screener.ignoring_or_muting_actor?(target_user.id)
raise NotAllowed.new(I18n.t("not_accepting_pms", username: target_user.username))
end
if TopicUser.where(
topic: self,
user: target_user,
notification_level: TopicUser.notification_levels[:muted],
).exists?
raise NotAllowed.new(I18n.t("topic_invite.muted_topic"))
end
if comm_screener.disallowing_pms_from_actor?(target_user.id)
raise NotAllowed.new(I18n.t("topic_invite.receiver_does_not_allow_pm"))
end
if UserCommScreener.new(
acting_user: target_user,
target_user_ids: invited_by.id,
).disallowing_pms_from_actor?(invited_by.id)
raise NotAllowed.new(I18n.t("topic_invite.sender_does_not_allow_pm"))
end
if private_message?
!!invite_to_private_message(invited_by, target_user, guardian)
else
!!invite_to_topic(invited_by, target_user, group_ids, guardian)
end
elsif username_or_email =~ /\A.+@.+\z/ && guardian.can_invite_via_email?(self)
!!Invite.generate(
invited_by,
email: username_or_email,
topic: self,
group_ids: group_ids,
custom_message: custom_message,
invite_to_topic: true,
)
end
2013-02-06 03:16:51 +08:00
end
def email_already_exists_for?(invite)
invite.email_already_exists && private_message?
end
def grant_permission_to_user(lower_email)
user = User.find_by_email(lower_email)
unless topic_allowed_users.exists?(user_id: user.id)
topic_allowed_users.create!(user_id: user.id)
end
end
def max_post_number
posts.with_deleted.maximum(:post_number).to_i
end
def move_posts(moved_by, post_ids, opts)
post_mover =
PostMover.new(
self,
moved_by,
post_ids,
move_to_pm: opts[:archetype].present? && opts[:archetype] == "private_message",
)
if opts[:destination_topic_id]
topic =
post_mover.to_topic(
opts[:destination_topic_id],
**opts.slice(:participants, :chronological_order),
)
2018-07-10 09:48:57 +08:00
DiscourseEvent.trigger(:topic_merged, post_mover.original_topic, post_mover.destination_topic)
topic
elsif opts[:title]
post_mover.to_new_topic(opts[:title], opts[:category_id], opts[:tags])
2013-02-06 03:16:51 +08:00
end
end
# Updates the denormalized statistics of a topic including featured posters. They shouldn't
# go out of sync unless you do something drastic live move posts from one topic to another.
# this recalculates everything.
def update_statistics
feature_topic_users
update_action_counts
Topic.reset_highest(id)
end
def update_action_counts
update_column(
:like_count,
Post.where.not(post_type: Post.types[:whisper]).where(topic_id: id).sum(:like_count),
)
end
def posters_summary(options = {}) # avatar lookup in options
2013-05-23 14:21:19 +08:00
@posters_summary ||= TopicPostersSummary.new(self, options).summary
2013-02-06 03:16:51 +08:00
end
def participants_summary(options = {})
@participants_summary ||= TopicParticipantsSummary.new(self, options).summary
end
def participant_groups_summary(options = {})
@participant_groups_summary ||= TopicParticipantGroupsSummary.new(self, options).summary
end
def make_banner!(user, bannered_until = nil)
if bannered_until
bannered_until =
begin
Time.parse(bannered_until)
rescue ArgumentError
raise Discourse::InvalidParameters.new(:bannered_until)
end
end
# only one banner at the same time
previous_banner = Topic.where(archetype: Archetype.banner).first
previous_banner.remove_banner!(user) if previous_banner.present?
UserProfile.where("dismissed_banner_key IS NOT NULL").update_all(dismissed_banner_key: nil)
self.archetype = Archetype.banner
self.bannered_until = bannered_until
self.add_small_action(user, "banner.enabled")
self.save
2014-06-19 02:04:10 +08:00
MessageBus.publish("/site/banner", banner)
Jobs.cancel_scheduled_job(:remove_banner, topic_id: self.id)
Jobs.enqueue_at(bannered_until, :remove_banner, topic_id: self.id) if bannered_until
end
def remove_banner!(user)
self.archetype = Archetype.default
self.bannered_until = nil
self.add_small_action(user, "banner.disabled")
self.save
2014-06-19 02:04:10 +08:00
MessageBus.publish("/site/banner", nil)
Jobs.cancel_scheduled_job(:remove_banner, topic_id: self.id)
2014-06-19 02:04:10 +08:00
end
def banner
2017-02-24 19:56:13 +08:00
post = self.ordered_posts.first
2014-06-19 02:04:10 +08:00
{ html: post.cooked, key: self.id, url: self.url }
end
cattr_accessor :slug_computed_callbacks
self.slug_computed_callbacks = []
def slug_for_topic(title)
return "" unless title.present?
slug = Slug.for(title)
# this is a hook for plugins that need to modify the generated slug
self.class.slug_computed_callbacks.each { |callback| slug = callback.call(self, slug, title) }
slug
end
# Even if the slug column in the database is null, topic.slug will return something:
2013-02-06 03:16:51 +08:00
def slug
2013-04-24 10:46:43 +08:00
unless slug = read_attribute(:slug)
return "" unless title.present?
slug = slug_for_topic(title)
2013-04-24 10:46:43 +08:00
if new_record?
write_attribute(:slug, slug)
else
update_column(:slug, slug)
end
end
slug
end
def self.find_by_slug(slug)
if SiteSetting.slug_generation_method != "encoded"
Topic.find_by(slug: slug.downcase)
else
encoded_slug = CGI.escape(slug)
Topic.find_by(slug: encoded_slug)
end
end
2013-04-24 10:46:43 +08:00
def title=(t)
slug = slug_for_topic(t.to_s)
2013-04-24 10:46:43 +08:00
write_attribute(:slug, slug)
write_attribute(:fancy_title, nil)
2013-04-24 10:46:43 +08:00
write_attribute(:title, t)
2013-02-06 03:16:51 +08:00
end
2013-05-24 14:06:38 +08:00
# NOTE: These are probably better off somewhere else.
# Having a model know about URLs seems a bit strange.
2013-02-06 03:16:51 +08:00
def last_post_url
"#{Discourse.base_path}/t/#{slug}/#{id}/#{posts_count}"
2013-02-06 03:16:51 +08:00
end
def self.url(id, slug, post_number = nil)
url = +"#{Discourse.base_url}/t/#{slug}/#{id}"
url << "/#{post_number}" if post_number.to_i > 1
url
end
def url(post_number = nil)
self.class.url id, slug, post_number
end
def self.relative_url(id, slug, post_number = nil)
url = +"#{Discourse.base_path}/t/"
url << "#{slug}/" if slug.present?
url << id.to_s
url << "/#{post_number}" if post_number.to_i > 1
2013-02-06 03:16:51 +08:00
url
end
def slugless_url(post_number = nil)
Topic.relative_url(id, nil, post_number)
end
def relative_url(post_number = nil)
Topic.relative_url(id, slug, post_number)
end
def clear_pin_for(user)
return unless user.present?
TopicUser.change(user.id, id, cleared_pinned_at: Time.now)
end
def re_pin_for(user)
return unless user.present?
TopicUser.change(user.id, id, cleared_pinned_at: nil)
end
def update_pinned(status, global = false, pinned_until = nil)
if pinned_until
pinned_until =
begin
Time.parse(pinned_until)
rescue ArgumentError
raise Discourse::InvalidParameters.new(:pinned_until)
end
end
2015-07-29 22:34:21 +08:00
update_columns(
pinned_at: status ? Time.zone.now : nil,
2015-07-29 22:34:21 +08:00
pinned_globally: global,
pinned_until: pinned_until,
)
Jobs.cancel_scheduled_job(:unpin_topic, topic_id: self.id)
Jobs.enqueue_at(pinned_until, :unpin_topic, topic_id: self.id) if pinned_until
2013-02-06 03:16:51 +08:00
end
def draft_key
"#{Draft::EXISTING_TOPIC}#{id}"
2013-02-06 03:16:51 +08:00
end
2013-05-24 14:06:38 +08:00
def notifier
@topic_notifier ||= TopicNotifier.new(self)
end
def muted?(user)
notifier.muted?(user.id) if user && user.id
end
2015-07-29 22:34:21 +08:00
def self.ensure_consistency!
# unpin topics that might have been missed
Topic.where("pinned_until < ?", Time.now).update_all(
pinned_at: nil,
pinned_globally: false,
pinned_until: nil,
)
Topic
.where("bannered_until < ?", Time.now)
.find_each { |topic| topic.remove_banner!(Discourse.system_user) }
2015-07-29 22:34:21 +08:00
end
def inherit_slow_mode_from_category
if self.category&.default_slow_mode_seconds
self.slow_mode_seconds = self.category&.default_slow_mode_seconds
end
end
def inherit_auto_close_from_category(timer_type: :close)
auto_close_hours = self.category&.auto_close_hours
if self.open? && !@ignore_category_auto_close && auto_close_hours.present? &&
public_topic_timer&.execute_at.blank?
based_on_last_post = self.category.auto_close_based_on_last_post
duration_minutes = based_on_last_post ? auto_close_hours * 60 : nil
# the timer time can be a timestamp or an integer based
# on the number of hours
auto_close_time = auto_close_hours
if !based_on_last_post
# set auto close to the original time it should have been
# when the topic was first created.
start_time = self.created_at || Time.zone.now
auto_close_time = start_time + auto_close_hours.hours
# if we have already passed the original close time then
# we should not recreate the auto-close timer for the topic
return if auto_close_time < Time.zone.now
# timestamp must be a string for set_or_create_timer
auto_close_time = auto_close_time.to_s
end
self.set_or_create_timer(
TopicTimer.types[timer_type],
auto_close_time,
by_user: Discourse.system_user,
based_on_last_post: based_on_last_post,
duration_minutes: duration_minutes,
)
end
end
def public_topic_timer
@public_topic_timer ||= topic_timers.find_by(public_type: true)
end
def slow_mode_topic_timer
@slow_mode_topic_timer ||= topic_timers.find_by(status_type: TopicTimer.types[:clear_slow_mode])
end
def delete_topic_timer(status_type, by_user: Discourse.system_user)
options = { status_type: status_type }
options.merge!(user: by_user) unless TopicTimer.public_types[status_type]
self.topic_timers.find_by(options)&.trash!(by_user)
@public_topic_timer = nil
2017-08-22 14:52:16 +08:00
nil
end
# Valid arguments for the time:
# * An integer, which is the number of hours from now to update the topic's status.
# * A timestamp, like "2013-11-25 13:00", when the topic's status should update.
# * A timestamp with timezone in JSON format. (e.g., "2013-11-26T21:00:00.000Z")
# * `nil` to delete the topic's status update.
# Options:
# * by_user: User who is setting the topic's status update.
# * based_on_last_post: True if time should be based on timestamp of the last post.
# * category_id: Category that the update will apply to.
# * duration_minutes: The duration of the timer in minutes, which is used if the timer is based
# on the last post or if the timer type is delete_replies.
# * silent: Affects whether the close topic timer status change will be silent or not.
def set_or_create_timer(
status_type,
time,
by_user: nil,
based_on_last_post: false,
category_id: SiteSetting.uncategorized_category_id,
duration_minutes: nil,
silent: nil
)
if time.blank? && duration_minutes.blank?
return delete_topic_timer(status_type, by_user: by_user)
end
duration_minutes = duration_minutes ? duration_minutes.to_i : 0
public_topic_timer = !!TopicTimer.public_types[status_type]
topic_timer_options = { topic: self, public_type: public_topic_timer }
topic_timer_options.merge!(user: by_user) unless public_topic_timer
topic_timer_options.merge!(silent: silent) if silent
topic_timer = TopicTimer.find_or_initialize_by(topic_timer_options)
topic_timer.status_type = status_type
time_now = Time.zone.now
topic_timer.based_on_last_post = !based_on_last_post.blank?
if status_type == TopicTimer.types[:publish_to_category]
topic_timer.category = Category.find_by(id: category_id)
end
if topic_timer.based_on_last_post
if duration_minutes > 0
2017-03-31 20:27:46 +08:00
last_post_created_at =
self.ordered_posts.last.present? ? self.ordered_posts.last.created_at : time_now
topic_timer.duration_minutes = duration_minutes
topic_timer.execute_at = last_post_created_at + duration_minutes.minutes
topic_timer.created_at = last_post_created_at
end
elsif topic_timer.status_type == TopicTimer.types[:delete_replies]
if duration_minutes > 0
first_reply_created_at =
(self.ordered_posts.where("post_number > 1").minimum(:created_at) || time_now)
topic_timer.duration_minutes = duration_minutes
topic_timer.execute_at = first_reply_created_at + duration_minutes.minutes
topic_timer.created_at = first_reply_created_at
end
else
utc = Time.find_zone("UTC")
is_float =
(
begin
Float(time)
rescue StandardError
nil
end
)
if is_float
num_hours = time.to_f
topic_timer.execute_at = num_hours.hours.from_now if num_hours > 0
else
timestamp = utc.parse(time)
raise Discourse::InvalidParameters unless timestamp && timestamp > utc.now
# a timestamp in client's time zone, like "2015-5-27 12:00"
topic_timer.execute_at = timestamp
end
end
if topic_timer.execute_at
if by_user&.staff? || by_user&.trust_level == TrustLevel[4]
topic_timer.user = by_user
else
topic_timer.user ||=
(
if self.user.staff? || self.user.trust_level == TrustLevel[4]
self.user
else
Discourse.system_user
end
)
end
if self.persisted?
# See TopicTimer.after_save for additional context; the topic
# status may be changed by saving.
topic_timer.save!
else
self.topic_timers << topic_timer
end
topic_timer
end
end
def read_restricted_category?
category && category.read_restricted
end
def category_allows_unlimited_owner_edits_on_first_post?
category && category.allow_unlimited_owner_edits_on_first_post?
end
2013-12-12 10:41:34 +08:00
def acting_user
@acting_user || user
end
def acting_user=(u)
@acting_user = u
end
2014-03-24 09:19:08 +08:00
def secure_group_ids
@secure_group_ids ||=
(self.category.secure_group_ids if self.category && self.category.read_restricted?)
end
def has_topic_embed?
TopicEmbed.where(topic_id: id).exists?
end
def expandable_first_post?
SiteSetting.embed_truncate? && has_topic_embed?
end
def message_archived?(user)
return false unless user && user.id
# tricky query but this checks to see if message is archived for ALL groups you belong to
# OR if you have it archived as a user explicitly
sql = <<~SQL
SELECT 1
WHERE
(
SELECT count(*) FROM topic_allowed_groups tg
JOIN group_archived_messages gm
ON gm.topic_id = tg.topic_id AND
gm.group_id = tg.group_id
WHERE tg.group_id IN (SELECT g.group_id FROM group_users g WHERE g.user_id = :user_id)
AND tg.topic_id = :topic_id
) =
(
SELECT case when count(*) = 0 then -1 else count(*) end FROM topic_allowed_groups tg
WHERE tg.group_id IN (SELECT g.group_id FROM group_users g WHERE g.user_id = :user_id)
AND tg.topic_id = :topic_id
)
UNION ALL
SELECT 1 FROM topic_allowed_users tu
JOIN user_archived_messages um ON um.user_id = tu.user_id AND um.topic_id = tu.topic_id
WHERE tu.user_id = :user_id AND tu.topic_id = :topic_id
SQL
DB.exec(sql, user_id: user.id, topic_id: id) > 0
end
TIME_TO_FIRST_RESPONSE_SQL ||= <<-SQL
SELECT AVG(t.hours)::float AS "hours", t.created_at AS "date"
FROM (
SELECT t.id, t.created_at::date AS created_at, EXTRACT(EPOCH FROM MIN(p.created_at) - t.created_at)::float / 3600.0 AS "hours"
FROM topics t
LEFT JOIN posts p ON p.topic_id = t.id
/*where*/
GROUP BY t.id
) t
GROUP BY t.created_at
ORDER BY t.created_at
SQL
TIME_TO_FIRST_RESPONSE_TOTAL_SQL ||= <<-SQL
SELECT AVG(t.hours)::float AS "hours"
FROM (
SELECT t.id, EXTRACT(EPOCH FROM MIN(p.created_at) - t.created_at)::float / 3600.0 AS "hours"
FROM topics t
LEFT JOIN posts p ON p.topic_id = t.id
/*where*/
GROUP BY t.id
) t
SQL
def self.time_to_first_response(sql, opts = nil)
opts ||= {}
builder = DB.build(sql)
builder.where("t.created_at >= :start_date", start_date: opts[:start_date]) if opts[:start_date]
builder.where("t.created_at < :end_date", end_date: opts[:end_date]) if opts[:end_date]
if opts[:category_id]
if opts[:include_subcategories]
builder.where("t.category_id IN (?)", Category.subcategory_ids(opts[:category_id]))
else
builder.where("t.category_id = ?", opts[:category_id])
end
end
builder.where("t.archetype <> '#{Archetype.private_message}'")
builder.where("t.deleted_at IS NULL")
builder.where("p.deleted_at IS NULL")
builder.where("p.post_number > 1")
builder.where("p.user_id != t.user_id")
builder.where("p.user_id in (:user_ids)", user_ids: opts[:user_ids]) if opts[:user_ids]
builder.where("p.post_type = :post_type", post_type: Post.types[:regular])
builder.where("EXTRACT(EPOCH FROM p.created_at - t.created_at) > 0")
builder.query_hash
end
def self.time_to_first_response_per_day(start_date, end_date, opts = {})
time_to_first_response(
TIME_TO_FIRST_RESPONSE_SQL,
opts.merge(start_date: start_date, end_date: end_date),
)
end
def self.time_to_first_response_total(opts = nil)
total = time_to_first_response(TIME_TO_FIRST_RESPONSE_TOTAL_SQL, opts)
total.first["hours"].to_f.round(2)
end
WITH_NO_RESPONSE_SQL ||= <<-SQL
SELECT COUNT(*) as count, tt.created_at AS "date"
FROM (
SELECT t.id, t.created_at::date AS created_at, MIN(p.post_number) first_reply
FROM topics t
LEFT JOIN posts p ON p.topic_id = t.id AND p.user_id != t.user_id AND p.deleted_at IS NULL AND p.post_type = #{Post.types[:regular]}
/*where*/
GROUP BY t.id
) tt
WHERE tt.first_reply IS NULL OR tt.first_reply < 2
GROUP BY tt.created_at
ORDER BY tt.created_at
SQL
def self.with_no_response_per_day(
start_date,
end_date,
category_id = nil,
include_subcategories = nil
)
builder = DB.build(WITH_NO_RESPONSE_SQL)
builder.where("t.created_at >= :start_date", start_date: start_date) if start_date
builder.where("t.created_at < :end_date", end_date: end_date) if end_date
if category_id
if include_subcategories
builder.where("t.category_id IN (?)", Category.subcategory_ids(category_id))
else
builder.where("t.category_id = ?", category_id)
end
end
builder.where("t.archetype <> '#{Archetype.private_message}'")
builder.where("t.deleted_at IS NULL")
builder.query_hash
end
WITH_NO_RESPONSE_TOTAL_SQL ||= <<-SQL
SELECT COUNT(*) as count
FROM (
SELECT t.id, MIN(p.post_number) first_reply
FROM topics t
LEFT JOIN posts p ON p.topic_id = t.id AND p.user_id != t.user_id AND p.deleted_at IS NULL AND p.post_type = #{Post.types[:regular]}
/*where*/
GROUP BY t.id
) tt
WHERE tt.first_reply IS NULL OR tt.first_reply < 2
SQL
def self.with_no_response_total(opts = {})
builder = DB.build(WITH_NO_RESPONSE_TOTAL_SQL)
if opts[:category_id]
if opts[:include_subcategories]
builder.where("t.category_id IN (?)", Category.subcategory_ids(opts[:category_id]))
else
builder.where("t.category_id = ?", opts[:category_id])
end
end
builder.where("t.archetype <> '#{Archetype.private_message}'")
builder.where("t.deleted_at IS NULL")
builder.query_single.first.to_i
end
def convert_to_public_topic(user, category_id: nil)
public_topic = TopicConverter.new(self, user).convert_to_public_topic(category_id)
Tag.update_counters(public_topic.tags, { public_topic_count: 1 }) if !category.read_restricted
add_small_action(user, "public_topic") if public_topic
public_topic
end
def convert_to_private_message(user)
read_restricted = category.read_restricted
private_topic = TopicConverter.new(self, user).convert_to_private_message
Tag.update_counters(private_topic.tags, { public_topic_count: -1 }) if !read_restricted
add_small_action(user, "private_topic") if private_topic
private_topic
end
def update_excerpt(excerpt)
update_column(:excerpt, excerpt)
ApplicationController.banner_json_cache.clear if archetype == "banner"
end
def pm_with_non_human_user?
sql = <<~SQL
SELECT 1 FROM topics
LEFT JOIN topic_allowed_groups ON topics.id = topic_allowed_groups.topic_id
WHERE topic_allowed_groups.topic_id IS NULL
AND topics.archetype = :private_message
AND topics.id = :topic_id
AND (
SELECT COUNT(*) FROM topic_allowed_users
WHERE topic_allowed_users.topic_id = :topic_id
AND topic_allowed_users.user_id > 0
) = 1
SQL
result = DB.exec(sql, private_message: Archetype.private_message, topic_id: self.id)
result != 0
end
def featured_link_root_domain
MiniSuffix.domain(UrlHelper.encode_and_parse(self.featured_link).hostname)
end
def self.private_message_topics_count_per_day(start_date, end_date, topic_subtype)
private_messages
.with_subtype(topic_subtype)
.where("topics.created_at >= ? AND topics.created_at <= ?", start_date, end_date)
.group("date(topics.created_at)")
.order("date(topics.created_at)")
.count
end
def is_category_topic?
@is_category_topic ||= Category.exists?(topic_id: self.id.to_i)
end
def reset_bumped_at
post =
ordered_posts.where(
user_deleted: false,
hidden: false,
post_type: Post.types[:regular],
).last || first_post
self.bumped_at = post.created_at
self.save(validate: false)
end
def auto_close_threshold_reached?
return if user&.staff?
scores =
ReviewableScore
.pending
.joins(:reviewable)
.where("reviewable_scores.score >= ?", Reviewable.min_score_for_priority)
.where("reviewables.topic_id = ?", self.id)
.pluck(
"COUNT(DISTINCT reviewable_scores.user_id), COALESCE(SUM(reviewable_scores.score), 0.0)",
)
.first
scores[0] >= SiteSetting.num_flaggers_to_close_topic &&
scores[1] >= Reviewable.score_to_auto_close_topic
end
def update_category_topic_count_by(num)
if category_id.present?
Category
.where("id = ?", category_id)
.where("topic_id != ? OR topic_id IS NULL", self.id)
.update_all("topic_count = topic_count + #{num.to_i}")
end
end
def access_topic_via_group
Group
.joins(:category_groups)
.where("category_groups.category_id = ?", self.category_id)
.where("groups.public_admission OR groups.allow_membership_requests")
.order(:allow_membership_requests)
.first
end
def incoming_email_addresses(group: nil, received_before: Time.zone.now)
email_addresses = Set.new
self
.incoming_email
.where("created_at <= ?", received_before)
.each do |incoming_email|
to_addresses = incoming_email.to_addresses_split
cc_addresses = incoming_email.cc_addresses_split
combined_addresses = [to_addresses, cc_addresses].flatten
# We only care about the emails addressed to the group or CC'd to the
# group if the group is present. If combined addresses is empty we do
# not need to do this check, and instead can proceed on to adding the
# from address.
#
# Will not include test1@gmail.com if the only IncomingEmail
# is:
#
# from: test1@gmail.com
# to: test+support@discoursemail.com
#
# Because we don't care about the from addresses and also the to address
# is not the email_username, which will be something like test1@gmail.com.
if group.present? && combined_addresses.any?
next if combined_addresses.none? { |address| address =~ group.email_username_regex }
end
email_addresses.add(incoming_email.from_address)
email_addresses.merge(combined_addresses)
end
email_addresses.subtract([nil, ""])
email_addresses.delete(group.email_username) if group.present?
email_addresses.to_a
end
def create_invite_notification!(target_user, notification_type, invited_by, post_number: 1)
if UserCommScreener.new(
acting_user: invited_by,
target_user_ids: target_user.id,
).ignoring_or_muting_actor?(target_user.id)
raise NotAllowed.new(I18n.t("not_accepting_pms", username: target_user.username))
end
target_user.notifications.create!(
notification_type: notification_type,
topic_id: self.id,
post_number: post_number,
data: {
topic_title: self.title,
display_username: invited_by.username,
original_user_id: user.id,
original_username: user.username,
}.to_json,
)
end
def rate_limit_topic_invitation(invited_by)
RateLimiter.new(
invited_by,
"topic-invitations-per-day",
SiteSetting.max_topic_invitations_per_day,
1.day.to_i,
).performed!
RateLimiter.new(
invited_by,
"topic-invitations-per-minute",
SiteSetting.max_topic_invitations_per_minute,
1.day.to_i,
).performed!
end
def cannot_permanently_delete_reason(user)
all_posts_count =
Post
.with_deleted
.where(topic_id: self.id)
.where(
post_type: [Post.types[:regular], Post.types[:moderator_action], Post.types[:whisper]],
)
.count
if posts_count > 0 || all_posts_count > 1
I18n.t("post.cannot_permanently_delete.many_posts")
elsif 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 first_smtp_enabled_group
self.allowed_groups.where(smtp_enabled: true).first
end
def secure_audience_publish_messages
target_audience = {}
if private_message?
target_audience[:user_ids] = User.human_users.where("admin OR moderator").pluck(:id)
target_audience[:user_ids] |= allowed_users.pluck(:id)
target_audience[:user_ids] |= allowed_group_users.pluck(:id)
else
target_audience[:group_ids] = secure_group_ids
end
target_audience
end
def self.publish_stats_to_clients!(topic_id, type, opts = {})
topic = Topic.find_by(id: topic_id)
return unless topic.present?
case type
when :liked, :unliked
stats = { like_count: topic.like_count }
when :created, :destroyed, :deleted, :recovered
stats = {
posts_count: topic.posts_count,
last_posted_at: topic.last_posted_at.as_json,
last_poster: BasicUserSerializer.new(topic.last_poster, root: false).as_json,
}
else
stats = nil
end
if stats
secure_audience = topic.secure_audience_publish_messages
if secure_audience[:user_ids] != [] && secure_audience[:group_ids] != []
message = stats.merge({ id: topic_id, updated_at: Time.now, type: :stats })
MessageBus.publish("/topic/#{topic_id}", message, opts.merge(secure_audience))
end
end
end
def group_pm?
private_message? && all_allowed_users.count > 2
end
def visible_tags(guardian)
tags.reject { |tag| guardian.hidden_tag_names.include?(tag[:name]) }
end
private
def invite_to_private_message(invited_by, target_user, guardian)
if !guardian.can_send_private_message?(target_user)
raise UserExists.new(I18n.t("activerecord.errors.models.topic.attributes.base.cant_send_pm"))
end
rate_limit_topic_invitation(invited_by)
Topic.transaction do
unless topic_allowed_users.exists?(user_id: target_user.id)
topic_allowed_users.create!(user_id: target_user.id)
end
user_in_allowed_group = (user.group_ids & topic_allowed_groups.map(&:group_id)).present?
add_small_action(invited_by, "invited_user", target_user.username) if !user_in_allowed_group
create_invite_notification!(
target_user,
Notification.types[:invited_to_private_message],
invited_by,
)
end
end
def invite_to_topic(invited_by, target_user, group_ids, guardian)
Topic.transaction do
rate_limit_topic_invitation(invited_by)
if group_ids.present?
(
self.category.groups.where(id: group_ids).where(automatic: false) -
target_user.groups.where(automatic: false)
).each do |group|
if guardian.can_edit_group?(group)
group.add(target_user)
GroupActionLogger.new(invited_by, group).log_add_user_to_group(target_user)
end
end
end
if Guardian.new(target_user).can_see_topic?(self)
create_invite_notification!(target_user, Notification.types[:invited_to_topic], invited_by)
end
end
end
def limit_first_day_topics_per_day
apply_per_day_rate_limit_for("first-day-topics", :max_topics_in_first_day)
end
def apply_per_day_rate_limit_for(key, method_name)
RateLimiter.new(user, "#{key}-per-day", SiteSetting.get(method_name), 1.day.to_i)
end
2013-02-06 03:16:51 +08:00
end
# == Schema Information
#
# Table name: topics
#
# id :integer not null, primary key
2019-01-12 03:29:56 +08:00
# title :string not null
# last_posted_at :datetime
# created_at :datetime not null
# updated_at :datetime not null
# views :integer default(0), not null
# posts_count :integer default(0), not null
# user_id :integer
# last_post_user_id :integer not null
# reply_count :integer default(0), not null
# featured_user1_id :integer
# featured_user2_id :integer
# featured_user3_id :integer
# deleted_at :datetime
# highest_post_number :integer default(0), not null
# like_count :integer default(0), not null
# incoming_link_count :integer default(0), not null
# category_id :integer
# visible :boolean default(TRUE), not null
# moderator_posts_count :integer default(0), not null
# closed :boolean default(FALSE), not null
# archived :boolean default(FALSE), not null
# bumped_at :datetime not null
# has_summary :boolean default(FALSE), not null
2019-01-12 03:29:56 +08:00
# archetype :string default("regular"), not null
# featured_user4_id :integer
# notify_moderators_count :integer default(0), not null
# spam_count :integer default(0), not null
# pinned_at :datetime
# score :float
# percent_rank :float default(1.0), not null
2019-01-12 03:29:56 +08:00
# subtype :string
# slug :string
# deleted_by_id :integer
# participant_count :integer default(1)
# word_count :integer
# excerpt :string
# pinned_globally :boolean default(FALSE), not null
# pinned_until :datetime
# fancy_title :string
# highest_staff_post_number :integer default(0), not null
# featured_link :string
# reviewable_score :float default(0.0), not null
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
# image_upload_id :bigint
2020-10-28 02:12:33 +08:00
# slow_mode_seconds :integer default(0), not null
# bannered_until :datetime
# external_id :string
#
# Indexes
#
2015-09-18 08:41:10 +08:00
# idx_topics_front_page (deleted_at,visible,archetype,category_id,id)
2018-07-16 14:18:07 +08:00
# idx_topics_user_id_deleted_at (user_id) WHERE (deleted_at IS NULL)
# idxtopicslug (slug) WHERE ((deleted_at IS NULL) AND (slug IS NOT NULL))
# index_topics_on_bannered_until (bannered_until) WHERE (bannered_until IS NOT NULL)
PERF: Improve database query perf when loading topics for a category. (#14416) * PERF: Improve database query perf when loading topics for a category. Instead of left joining the `topics` table against `categories` by filtering with `categories.id`, we can improve the query plan by filtering against `topics.category_id` first before joining which helps to reduce the number of rows in the topics table that has to be joined against the other tables and also make better use of our existing index. The following is a before and after of the query plan for a category with many subcategories. Before: ``` QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------- Limit (cost=1.28..747.09 rows=30 width=12) (actual time=85.502..2453.727 rows=30 loops=1) -> Nested Loop Left Join (cost=1.28..566518.36 rows=22788 width=12) (actual time=85.501..2453.722 rows=30 loops=1) Join Filter: (category_users.category_id = topics.category_id) Filter: ((topics.category_id = 11) OR (COALESCE(category_users.notification_level, 1) <> 0) OR (tu.notification_level > 1)) -> Nested Loop Left Join (cost=1.00..566001.58 rows=22866 width=20) (actual time=85.494..2453.702 rows=30 loops=1) Filter: ((COALESCE(tu.notification_level, 1) > 0) AND ((topics.category_id <> 11) OR (topics.pinned_at IS NULL) OR ((t opics.pinned_at <= tu.cleared_pinned_at) AND (tu.cleared_pinned_at IS NOT NULL)))) Rows Removed by Filter: 1 -> Nested Loop (cost=0.57..528561.75 rows=68606 width=24) (actual time=85.472..2453.562 rows=31 loops=1) Join Filter: ((topics.category_id = categories.id) AND ((categories.topic_id <> topics.id) OR (categories.id = 1 1))) Rows Removed by Join Filter: 13938306 -> Index Scan using index_topics_on_bumped_at on topics (cost=0.42..100480.05 rows=715549 width=24) (actual ti me=0.010..633.015 rows=464623 loops=1) Filter: ((deleted_at IS NULL) AND ((archetype)::text <> 'private_message'::text)) Rows Removed by Filter: 105321 -> Materialize (cost=0.14..36.04 rows=30 width=8) (actual time=0.000..0.002 rows=30 loops=464623) -> Index Scan using categories_pkey on categories (cost=0.14..35.89 rows=30 width=8) (actual time=0.006. .0.040 rows=30 loops=1) Index Cond: (id = ANY ('{11,53,57,55,54,56,112,94,107,115,116,117,97,95,102,103,101,105,99,114,106,1 13,104,98,100,96,108,109,110,111}'::integer[])) -> Index Scan using index_topic_users_on_topic_id_and_user_id on topic_users tu (cost=0.43..0.53 rows=1 width=16) (a ctual time=0.004..0.004 rows=0 loops=31) Index Cond: ((topic_id = topics.id) AND (user_id = 1103877)) -> Materialize (cost=0.28..2.30 rows=1 width=8) (actual time=0.000..0.000 rows=0 loops=30) -> Index Scan using index_category_users_on_user_id_and_last_seen_at on category_users (cost=0.28..2.29 rows=1 width =8) (actual time=0.004..0.004 rows=0 loops=1) Index Cond: (user_id = 1103877) Planning Time: 1.359 ms Execution Time: 2453.765 ms (23 rows) ``` After: ``` QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Limit (cost=1.28..438.55 rows=30 width=12) (actual time=38.297..657.215 rows=30 loops=1) -> Nested Loop Left Join (cost=1.28..195944.68 rows=13443 width=12) (actual time=38.296..657.211 rows=30 loops=1) Filter: ((categories.topic_id <> topics.id) OR (topics.category_id = 11)) Rows Removed by Filter: 29 -> Nested Loop Left Join (cost=1.13..193462.59 rows=13443 width=16) (actual time=38.289..657.092 rows=59 loops=1) Join Filter: (category_users.category_id = topics.category_id) Filter: ((topics.category_id = 11) OR (COALESCE(category_users.notification_level, 1) <> 0) OR (tu.notification_level > 1)) -> Nested Loop Left Join (cost=0.85..193156.79 rows=13489 width=20) (actual time=38.282..657.059 rows=59 loops=1) Filter: ((COALESCE(tu.notification_level, 1) > 0) AND ((topics.category_id <> 11) OR (topics.pinned_at IS NULL) OR ((topics.pinned_at <= tu.cleared_pinned_at) AND (tu.cleared_pinned_at IS NOT NULL)))) Rows Removed by Filter: 1 -> Index Scan using index_topics_on_bumped_at on topics (cost=0.42..134521.06 rows=40470 width=24) (actual time=38.267..656.850 rows=60 loops=1) Filter: ((deleted_at IS NULL) AND ((archetype)::text <> 'private_message'::text) AND (category_id = ANY ('{11,53,57,55,54,56,112,94,107,115,116,117,97,95,102,103,101,105,99,114,106,113,104,98,100,96,108,109,110,111}'::integer[]))) Rows Removed by Filter: 569895 -> Index Scan using index_topic_users_on_topic_id_and_user_id on topic_users tu (cost=0.43..1.43 rows=1 width=16) (actual time=0.003..0.003 rows=0 loops=60) Index Cond: ((topic_id = topics.id) AND (user_id = 1103877)) -> Materialize (cost=0.28..2.30 rows=1 width=8) (actual time=0.000..0.000 rows=0 loops=59) -> Index Scan using index_category_users_on_user_id_and_last_seen_at on category_users (cost=0.28..2.29 rows=1 width=8) (actual time=0.004..0.004 rows=0 loops=1) Index Cond: (user_id = 1103877) -> Index Scan using categories_pkey on categories (cost=0.14..0.17 rows=1 width=8) (actual time=0.001..0.001 rows=1 loops=59) Index Cond: (id = topics.category_id) Planning Time: 1.633 ms Execution Time: 657.255 ms (22 rows) ``` * PERF: Optimize index on topics bumped_at. Replace `index_topics_on_bumped_at` index with a partial index on `Topic#bumped_at` filtered by archetype since there is already another index that covers private topics.
2021-09-28 10:05:00 +08:00
# index_topics_on_bumped_at_public (bumped_at) WHERE ((deleted_at IS NULL) AND ((archetype)::text <> 'private_message'::text))
2018-07-16 14:18:07 +08:00
# index_topics_on_created_at_and_visible (created_at,visible) WHERE ((deleted_at IS NULL) AND ((archetype)::text <> 'private_message'::text))
# index_topics_on_external_id (external_id) UNIQUE WHERE (external_id IS NOT NULL)
2015-09-18 08:41:10 +08:00
# index_topics_on_id_and_deleted_at (id,deleted_at)
# index_topics_on_id_filtered_banner (id) UNIQUE WHERE (((archetype)::text = 'banner'::text) AND (deleted_at IS NULL))
FEATURE: Include optimized thumbnails for topics (#9215) This introduces new APIs for obtaining optimized thumbnails for topics. There are a few building blocks required for this: - Introduces new `image_upload_id` columns on the `posts` and `topics` table. This replaces the old `image_url` column, which means that thumbnails are now restricted to uploads. Hotlinked thumbnails are no longer possible. In normal use (with pull_hotlinked_images enabled), this has no noticeable impact - A migration attempts to match existing urls to upload records. If a match cannot be found then the posts will be queued for rebake - Optimized thumbnails are generated during post_process_cooked. If thumbnails are missing when serializing a topic list, then a sidekiq job is queued - Topic lists and topics now include a `thumbnails` key, which includes all the available images: ``` "thumbnails": [ { "max_width": null, "max_height": null, "url": "//example.com/original-image.png", "width": 1380, "height": 1840 }, { "max_width": 1024, "max_height": 1024, "url": "//example.com/optimized-image.png", "width": 768, "height": 1024 } ] ``` - Themes can request additional thumbnail sizes by using a modifier in their `about.json` file: ``` "modifiers": { "topic_thumbnail_sizes": [ [200, 200], [800, 800] ], ... ``` Remember that these are generated asynchronously, so your theme should include logic to fallback to other available thumbnails if your requested size has not yet been generated - Two new raw plugin outlets are introduced, to improve the customisability of the topic list. `topic-list-before-columns` and `topic-list-before-link`
2020-05-05 16:07:50 +08:00
# index_topics_on_image_upload_id (image_upload_id)
2017-10-06 11:13:01 +08:00
# index_topics_on_lower_title (lower((title)::text))
2018-07-16 14:18:07 +08:00
# index_topics_on_pinned_at (pinned_at) WHERE (pinned_at IS NOT NULL)
# index_topics_on_pinned_globally (pinned_globally) WHERE pinned_globally
# index_topics_on_pinned_until (pinned_until) WHERE (pinned_until IS NOT NULL)
2020-10-28 02:12:33 +08:00
# index_topics_on_timestamps_private (bumped_at,created_at,updated_at) WHERE ((deleted_at IS NULL) AND ((archetype)::text = 'private_message'::text))
2019-04-05 17:13:12 +08:00
# index_topics_on_updated_at_public (updated_at,visible,highest_staff_post_number,highest_post_number,category_id,created_at,id) WHERE (((archetype)::text <> 'private_message'::text) AND (deleted_at IS NULL))
#