闭社主体 forked from https://github.com/tootsuite/mastodon
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

311 lines
9.9 KiB

8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
  1. # frozen_string_literal: true
  2. # == Schema Information
  3. #
  4. # Table name: statuses
  5. #
  6. # id :integer not null, primary key
  7. # uri :string
  8. # text :text default(""), not null
  9. # created_at :datetime not null
  10. # updated_at :datetime not null
  11. # in_reply_to_id :integer
  12. # reblog_of_id :integer
  13. # url :string
  14. # sensitive :boolean default(FALSE), not null
  15. # visibility :integer default("public"), not null
  16. # spoiler_text :text default(""), not null
  17. # reply :boolean default(FALSE), not null
  18. # favourites_count :integer default(0), not null
  19. # reblogs_count :integer default(0), not null
  20. # language :string
  21. # conversation_id :integer
  22. # local :boolean
  23. # account_id :integer not null
  24. # application_id :integer
  25. # in_reply_to_account_id :integer
  26. #
  27. class Status < ApplicationRecord
  28. include Paginable
  29. include Streamable
  30. include Cacheable
  31. include StatusThreadingConcern
  32. enum visibility: [:public, :unlisted, :private, :direct], _suffix: :visibility
  33. belongs_to :application, class_name: 'Doorkeeper::Application'
  34. belongs_to :account, inverse_of: :statuses, counter_cache: true, required: true
  35. belongs_to :in_reply_to_account, foreign_key: 'in_reply_to_account_id', class_name: 'Account'
  36. belongs_to :conversation
  37. belongs_to :thread, foreign_key: 'in_reply_to_id', class_name: 'Status', inverse_of: :replies
  38. belongs_to :reblog, foreign_key: 'reblog_of_id', class_name: 'Status', inverse_of: :reblogs, counter_cache: :reblogs_count
  39. has_many :favourites, inverse_of: :status, dependent: :destroy
  40. has_many :reblogs, foreign_key: 'reblog_of_id', class_name: 'Status', inverse_of: :reblog, dependent: :destroy
  41. has_many :replies, foreign_key: 'in_reply_to_id', class_name: 'Status', inverse_of: :thread
  42. has_many :mentions, dependent: :destroy
  43. has_many :media_attachments, dependent: :destroy
  44. has_and_belongs_to_many :tags
  45. has_and_belongs_to_many :preview_cards
  46. has_one :notification, as: :activity, dependent: :destroy
  47. has_one :stream_entry, as: :activity, inverse_of: :status
  48. validates :uri, uniqueness: true, presence: true, unless: :local?
  49. validates :text, presence: true, unless: :reblog?
  50. validates_with StatusLengthValidator
  51. validates :reblog, uniqueness: { scope: :account }, if: :reblog?
  52. default_scope { recent }
  53. scope :recent, -> { reorder(id: :desc) }
  54. scope :remote, -> { where(local: false).or(where.not(uri: nil)) }
  55. scope :local, -> { where(local: true).or(where(uri: nil)) }
  56. scope :without_replies, -> { where('statuses.reply = FALSE OR statuses.in_reply_to_account_id = statuses.account_id') }
  57. scope :without_reblogs, -> { where('statuses.reblog_of_id IS NULL') }
  58. scope :with_public_visibility, -> { where(visibility: :public) }
  59. scope :tagged_with, ->(tag) { joins(:statuses_tags).where(statuses_tags: { tag_id: tag }) }
  60. scope :excluding_silenced_accounts, -> { left_outer_joins(:account).where(accounts: { silenced: false }) }
  61. scope :including_silenced_accounts, -> { left_outer_joins(:account).where(accounts: { silenced: true }) }
  62. scope :not_excluded_by_account, ->(account) { where.not(account_id: account.excluded_from_timeline_account_ids) }
  63. scope :not_domain_blocked_by_account, ->(account) { account.excluded_from_timeline_domains.blank? ? left_outer_joins(:account) : left_outer_joins(:account).where('accounts.domain IS NULL OR accounts.domain NOT IN (?)', account.excluded_from_timeline_domains) }
  64. cache_associated :account, :application, :media_attachments, :tags, :stream_entry, mentions: :account, reblog: [:account, :application, :stream_entry, :tags, :media_attachments, mentions: :account], thread: :account
  65. delegate :domain, to: :account, prefix: true
  66. def reply?
  67. !in_reply_to_id.nil? || attributes['reply']
  68. end
  69. def local?
  70. attributes['local'] || uri.nil?
  71. end
  72. def reblog?
  73. !reblog_of_id.nil?
  74. end
  75. def verb
  76. if destroyed?
  77. :delete
  78. else
  79. reblog? ? :share : :post
  80. end
  81. end
  82. def object_type
  83. reply? ? :comment : :note
  84. end
  85. def proper
  86. reblog? ? reblog : self
  87. end
  88. def content
  89. proper.text
  90. end
  91. def target
  92. reblog
  93. end
  94. def title
  95. if destroyed?
  96. "#{account.acct} deleted status"
  97. else
  98. reblog? ? "#{account.acct} shared a status by #{reblog.account.acct}" : "New status by #{account.acct}"
  99. end
  100. end
  101. def hidden?
  102. private_visibility? || direct_visibility?
  103. end
  104. def non_sensitive_with_media?
  105. !sensitive? && media_attachments.any?
  106. end
  107. def emojis
  108. CustomEmoji.from_text([spoiler_text, text].join(' '), account.domain)
  109. end
  110. after_create_commit :store_uri, if: :local?
  111. around_create Mastodon::Snowflake::Callbacks
  112. before_validation :prepare_contents, if: :local?
  113. before_validation :set_reblog
  114. before_validation :set_visibility
  115. before_validation :set_conversation
  116. before_validation :set_sensitivity
  117. before_validation :set_local
  118. class << self
  119. def not_in_filtered_languages(account)
  120. where(language: nil).or where.not(language: account.filtered_languages)
  121. end
  122. def as_home_timeline(account)
  123. where(account: [account] + account.following).where(visibility: [:public, :unlisted, :private])
  124. end
  125. def as_public_timeline(account = nil, local_only = false)
  126. query = timeline_scope(local_only).without_replies
  127. apply_timeline_filters(query, account, local_only)
  128. end
  129. def as_tag_timeline(tag, account = nil, local_only = false)
  130. query = timeline_scope(local_only).tagged_with(tag)
  131. apply_timeline_filters(query, account, local_only)
  132. end
  133. def as_outbox_timeline(account)
  134. where(account: account, visibility: :public)
  135. end
  136. def favourites_map(status_ids, account_id)
  137. Favourite.select('status_id').where(status_id: status_ids).where(account_id: account_id).map { |f| [f.status_id, true] }.to_h
  138. end
  139. def reblogs_map(status_ids, account_id)
  140. select('reblog_of_id').where(reblog_of_id: status_ids).where(account_id: account_id).reorder(nil).map { |s| [s.reblog_of_id, true] }.to_h
  141. end
  142. def mutes_map(conversation_ids, account_id)
  143. ConversationMute.select('conversation_id').where(conversation_id: conversation_ids).where(account_id: account_id).map { |m| [m.conversation_id, true] }.to_h
  144. end
  145. def pins_map(status_ids, account_id)
  146. StatusPin.select('status_id').where(status_id: status_ids).where(account_id: account_id).map { |p| [p.status_id, true] }.to_h
  147. end
  148. def reload_stale_associations!(cached_items)
  149. account_ids = []
  150. cached_items.each do |item|
  151. account_ids << item.account_id
  152. account_ids << item.reblog.account_id if item.reblog?
  153. end
  154. account_ids.uniq!
  155. return if account_ids.empty?
  156. accounts = Account.where(id: account_ids).map { |a| [a.id, a] }.to_h
  157. cached_items.each do |item|
  158. item.account = accounts[item.account_id]
  159. item.reblog.account = accounts[item.reblog.account_id] if item.reblog?
  160. end
  161. end
  162. def permitted_for(target_account, account)
  163. visibility = [:public, :unlisted]
  164. if account.nil?
  165. where(visibility: visibility)
  166. elsif target_account.blocking?(account) # get rid of blocked peeps
  167. none
  168. elsif account.id == target_account.id # author can see own stuff
  169. all
  170. else
  171. # followers can see followers-only stuff, but also things they are mentioned in.
  172. # non-followers can see everything that isn't private/direct, but can see stuff they are mentioned in.
  173. visibility.push(:private) if account.following?(target_account)
  174. where(visibility: visibility).or(where(id: account.mentions.select(:status_id)))
  175. end
  176. end
  177. private
  178. def timeline_scope(local_only = false)
  179. starting_scope = local_only ? Status.local : Status
  180. starting_scope
  181. .with_public_visibility
  182. .without_reblogs
  183. end
  184. def apply_timeline_filters(query, account, local_only)
  185. if account.nil?
  186. filter_timeline_default(query)
  187. else
  188. filter_timeline_for_account(query, account, local_only)
  189. end
  190. end
  191. def filter_timeline_for_account(query, account, local_only)
  192. query = query.not_excluded_by_account(account)
  193. query = query.not_domain_blocked_by_account(account) unless local_only
  194. query = query.not_in_filtered_languages(account) if account.filtered_languages.present?
  195. query.merge(account_silencing_filter(account))
  196. end
  197. def filter_timeline_default(query)
  198. query.excluding_silenced_accounts
  199. end
  200. def account_silencing_filter(account)
  201. if account.silenced?
  202. including_silenced_accounts
  203. else
  204. excluding_silenced_accounts
  205. end
  206. end
  207. end
  208. private
  209. def store_uri
  210. update_attribute(:uri, ActivityPub::TagManager.instance.uri_for(self)) if uri.nil?
  211. end
  212. def prepare_contents
  213. text&.strip!
  214. spoiler_text&.strip!
  215. end
  216. def set_reblog
  217. self.reblog = reblog.reblog if reblog? && reblog.reblog?
  218. end
  219. def set_visibility
  220. self.visibility = (account.locked? ? :private : :public) if visibility.nil?
  221. self.visibility = reblog.visibility if reblog?
  222. self.sensitive = false if sensitive.nil?
  223. end
  224. def set_sensitivity
  225. self.sensitive = sensitive || spoiler_text.present?
  226. end
  227. def set_conversation
  228. self.reply = !(in_reply_to_id.nil? && thread.nil?) unless reply
  229. if reply? && !thread.nil?
  230. self.in_reply_to_account_id = carried_over_reply_to_account_id
  231. self.conversation_id = thread.conversation_id if conversation_id.nil?
  232. elsif conversation_id.nil?
  233. create_conversation
  234. end
  235. end
  236. def carried_over_reply_to_account_id
  237. if thread.account_id == account_id && thread.reply?
  238. thread.in_reply_to_account_id
  239. else
  240. thread.account_id
  241. end
  242. end
  243. def set_local
  244. self.local = account.local?
  245. end
  246. end