1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
|
# frozen_string_literal: true
# == Schema Information
#
# Table name: statuses
#
# id :bigint(8) not null, primary key
# uri :string
# text :text default(""), not null
# created_at :datetime not null
# updated_at :datetime not null
# in_reply_to_id :bigint(8)
# reblog_of_id :bigint(8)
# url :string
# sensitive :boolean default(FALSE), not null
# visibility :integer default("public"), not null
# spoiler_text :text default(""), not null
# reply :boolean default(FALSE), not null
# language :string
# conversation_id :bigint(8)
# local :boolean
# account_id :bigint(8) not null
# application_id :bigint(8)
# in_reply_to_account_id :bigint(8)
# local_only :boolean
# poll_id :bigint(8)
# curated :boolean default(FALSE), not null
# network :boolean default(FALSE), not null
# content_type :string
# footer :text
# edited :boolean
# boostable :boolean
# reject_replies :boolean
# tsv :tsvector
# hidden :boolean
#
class Status < ApplicationRecord
before_destroy :unlink_from_conversations
include Paginable
include Cacheable
include StatusThreadingConcern
# match both with and without U+FE0F (the emoji variation selector)
LOCAL_ONLY_TOKENS = /(?:#!|\u{1f441}\ufe0f?)\u200b?\z/
REJECT_REPLIES_TOKENS = /^(?:please )?(?:ms_dont_at_me|no (?:replie|mention)s|(?:dont|do not) (?:@|at|reply|mention|interact)(?: (?:me|us))?)\b/i
SIMPLIFIED = /[^\w\s@_\"\'\-]+/
# If `override_timestamps` is set at creation time, Snowflake ID creation
# will be based on current time instead of `created_at`
attr_accessor :override_timestamps
update_index('statuses#status', :proper) if Chewy.enabled?
enum visibility: [:public, :unlisted, :private, :direct, :limited, :local], _suffix: :visibility
belongs_to :application, class_name: 'Doorkeeper::Application', optional: true
belongs_to :account, inverse_of: :statuses
belongs_to :in_reply_to_account, foreign_key: 'in_reply_to_account_id', class_name: 'Account', optional: true
belongs_to :conversation, optional: true
belongs_to :preloadable_poll, class_name: 'Poll', foreign_key: 'poll_id', optional: true
belongs_to :thread, foreign_key: 'in_reply_to_id', class_name: 'Status', inverse_of: :replies, optional: true
belongs_to :reblog, foreign_key: 'reblog_of_id', class_name: 'Status', inverse_of: :reblogs, optional: true
has_many :favourites, inverse_of: :status, dependent: :destroy
has_many :bookmarks, inverse_of: :status, dependent: :destroy
has_many :reblogs, foreign_key: 'reblog_of_id', class_name: 'Status', inverse_of: :reblog, dependent: :destroy
has_many :replies, foreign_key: 'in_reply_to_id', class_name: 'Status', inverse_of: :thread
has_many :mentions, dependent: :destroy, inverse_of: :status
has_many :active_mentions, -> { active }, class_name: 'Mention', inverse_of: :status
has_many :media_attachments, dependent: :nullify
has_many :queued_boosts, dependent: :destroy, inverse_of: :status
has_and_belongs_to_many :tags
has_and_belongs_to_many :preview_cards
has_one :notification, as: :activity, dependent: :destroy
has_one :status_stat, inverse_of: :status
has_one :poll, inverse_of: :status, dependent: :destroy
has_one :destructing_status, inverse_of: :status, dependent: :destroy
has_one :defederating_status, inverse_of: :status, dependent: :destroy
has_one :imported_status, inverse_of: :status, dependent: :destroy
has_one :sharekey, inverse_of: :status, dependent: :destroy
validates :uri, uniqueness: true, presence: true, unless: :local?
validates :text, presence: true, unless: -> { with_media? || reblog? }
validates_with StatusLengthValidator
validates_with DisallowedHashtagsValidator
validates :reblog, uniqueness: { scope: :account }, if: :reblog?
validates :visibility, exclusion: { in: %w(direct limited) }, if: :reblog?
validates :content_type, inclusion: { in: %w(text/plain text/console text/markdown text/x-bbcode text/x-bbcode+markdown text/html) }, allow_nil: true
accepts_nested_attributes_for :poll
default_scope { recent }
scope :recent, -> { reorder(id: :desc) }
scope :remote, -> { where(local: false).or(where.not(uri: nil)) }
scope :local, -> { where(local: true).or(where(uri: nil)) }
scope :network, -> { where(network: true) }
scope :curated, -> { where(curated: true) }
scope :hidden, -> { where(hidden: true) }
scope :without_replies, -> { where('statuses.reply = FALSE OR statuses.in_reply_to_account_id = statuses.account_id') }
scope :without_reblogs, -> { where('statuses.reblog_of_id IS NULL') }
scope :reblogs, -> { where('statuses.reblog_of_id IS NOT NULL') } # all reblogs
scope :with_public_visibility, -> { where(visibility: :public, hidden: false) }
scope :public_local_visibility, -> { where(visibility: [:public, :local], hidden: false) }
scope :public_browsable, -> { where(visibility: [:public, :unlisted, :local], hidden: false) }
scope :tagged_with, ->(tag) { joins(:statuses_tags).where(statuses_tags: { tag_id: tag }) }
scope :excluding_silenced_accounts, -> { left_outer_joins(:account).where(accounts: { silenced_at: nil }) }
scope :including_silenced_accounts, -> { left_outer_joins(:account).where.not(accounts: { silenced_at: nil }) }
scope :not_excluded_by_account, ->(account) { where.not(account_id: account.excluded_from_timeline_account_ids) }
scope :reply_not_excluded_by_account, ->(account) { where('statuses.in_reply_to_account_id IS NULL OR statuses.in_reply_to_account_id NOT IN (?)', account.excluded_from_timeline_account_ids) }
scope :mention_not_excluded_by_account, ->(account) { left_outer_joins(:mentions).where('mentions.account_id IS NULL OR mentions.account_id NOT IN (?)', account.excluded_from_timeline_account_ids) }
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) }
scope :search, ->(needle) { where("tsv @@ websearch_to_tsquery('fedi', ?)", needle) }
scope :search_not, ->(needle) { where.not("tsv @@ websearch_to_tsquery('fedi', ?)", needle) }
scope :search_filtered_by_account, ->(account_id) { where("tsv @@ (SELECT tsquery_union(websearch_to_tsquery('fedi', phrase)) FROM custom_filters WHERE account_id = ? AND is_enabled)", account_id) }
scope :search_not_filtered_by_account, ->(account_id) { where.not("tsv @@ (SELECT tsquery_union(websearch_to_tsquery('fedi', phrase)) FROM custom_filters WHERE account_id = ? AND is_enabled)", account_id) }
scope :with_media, -> { joins(:media_attachments).select('statuses.*').distinct(:status_id) }
scope :not_missing_media_desc, -> { left_outer_joins(:media_attachments).select('statuses.*').where('media_attachments.id IS NULL OR media_attachments.description IS NOT NULL') }
scope :only_followers_of, ->(account) { where(account: [account] + account.following) }
scope :tagged_with_all, ->(tags) {
Array(tags).map(&:id).map(&:to_i).reduce(self) do |result, id|
result.joins("INNER JOIN statuses_tags t#{id} ON t#{id}.status_id = statuses.id AND t#{id}.tag_id = #{id}")
end
}
scope :tagged_with_none, ->(tags) {
Array(tags).map(&:id).map(&:to_i).reduce(self) do |result, id|
result.joins("LEFT OUTER JOIN statuses_tags t#{id} ON t#{id}.status_id = statuses.id AND t#{id}.tag_id = #{id}")
.where("t#{id}.tag_id IS NULL")
end
}
scope :not_local_only, -> { where(local_only: [false, nil]) }
cache_associated :application,
:media_attachments,
:conversation,
:status_stat,
:tags,
:preview_cards,
:preloadable_poll,
account: :account_stat,
active_mentions: { account: :account_stat },
reblog: [
:application,
:tags,
:preview_cards,
:media_attachments,
:conversation,
:status_stat,
:preloadable_poll,
account: :account_stat,
active_mentions: { account: :account_stat },
],
thread: { account: :account_stat }
delegate :domain, to: :account, prefix: true
REAL_TIME_WINDOW = 6.hours
def searchable_by(preloaded = nil)
ids = [account_id]
if preloaded.nil?
ids += mentions.pluck(:account_id)
ids += favourites.pluck(:account_id)
ids += bookmarks.pluck(:account_id)
ids += reblogs.pluck(:account_id)
else
ids += preloaded.mentions[id] || []
ids += preloaded.favourites[id] || []
ids += preloaded.bookmarks[id] || []
ids += preloaded.reblogs[id] || []
end
ids.uniq
end
def reply?
!in_reply_to_id.nil? || attributes['reply']
end
def local?
attributes['local'] || uri.nil?
end
def network?
attributes['network'] || local? || account.network?
end
def relayed?
account.username == 'relay' && account.actor_type.in?(Set[:Application, :Service])
end
def reblog?
!reblog_of_id.nil?
end
def within_realtime_window?
created_at >= REAL_TIME_WINDOW.ago
end
def verb
if destroyed?
:delete
else
reblog? ? :share : :post
end
end
def object_type
reply? ? :comment : :note
end
def proper
reblog? ? reblog : self
end
def content
proper.text
end
def draft?
local? && text.present? && self.tags.where(name: 'self.draft').exists?
end
def target
reblog
end
def preview_card
preview_cards.first
end
def title
if destroyed?
"#{account.acct} deleted status"
else
reblog? ? "#{account.acct} shared a status by #{reblog.account.acct}" : "New status by #{account.acct}"
end
end
def distributable?
public_visibility? || unlisted_visibility? || local_visibility?
end
alias sign? distributable?
def with_media?
media_attachments.any?
end
def non_sensitive_with_media?
!sensitive? && with_media?
end
def emojis
return @emojis if defined?(@emojis)
fields = [spoiler_text, text]
fields += preloadable_poll.options unless preloadable_poll.nil?
fields << footer unless footer.nil?
@emojis = CustomEmoji.from_text(fields.join(' '), account.domain)
end
def delete_after
destructing_status&.delete_after
end
def delete_after=(value)
@no_clobber_expirations = true
if value.to_i == 0
DestructingStatus.where(status_id: id).destroy_all
return
end
if defederate_after && defederate_after < (Time.now.utc + 5.minutes + value)
value = 5.minutes + value
end
delete_after = Time.now.utc + value
if destructing_status.nil?
DestructingStatus.create!(status_id: id, delete_after: delete_after)
else
destructing_status.update(delete_after: delete_after)
end
delete_after
end
def defederate_after
defederating_status&.defederate_after
end
def defederate_after=(value)
@no_clobber_expirations = true
if value.to_i == 0
DefederatingStatus.where(status_id: id).destroy_all
return
end
return unless delete_after.nil? || delete_after >= (Time.now.utc + 5.minutes + value)
defederate_after = Time.now.utc + value
if defederating_status.nil?
DefederatingStatus.create!(status_id: id, defederate_after: defederate_after)
else
defederating_status.update(defederate_after: defederate_after)
end
defederate_after
end
def no_clobber_expirations?
@no_clobber_expirations || false
end
def keep_hidden!
@keep_hidden = true
end
def keep_unhidden!
@keep_hidden = false
end
def keep_hidden?
@keep_hidden || false
end
def mark_for_mass_destruction!
@marked_for_mass_destruction = true
end
def marked_for_mass_destruction?
@marked_for_mass_destruction
end
def replies_count
status_stat&.replies_count || 0
end
def reblogs_count
status_stat&.reblogs_count || 0
end
def favourites_count
status_stat&.favourites_count || 0
end
def increment_count!(key)
update_status_stat!(key => public_send(key) + 1)
end
def decrement_count!(key)
update_status_stat!(key => [public_send(key) - 1, 0].max)
end
def sharekey=(value)
if value.nil? && !(new_record? || self.sharekey.nil?)
self.sharekey.destroy
else
@_sharekey = value
update_sharekey unless new_record? || changed?
end
end
def origin=(value)
if value.nil? && !(new_record? || self.imported_status.nil?)
self.imported_status.destroy
else
@_origin = value
update_origin unless new_record? || changed?
end
end
after_create_commit :increment_counter_caches
after_destroy_commit :decrement_counter_caches
after_create_commit :store_uri, if: :local?
after_create_commit :update_statistics, if: :local?
around_create Mastodon::Snowflake::Callbacks
before_create :set_locality
before_validation :prepare_contents, if: :local?
before_validation :set_reblog
before_validation :set_visibility
before_validation :set_conversation
before_validation :set_local
before_validation :infer_reject_replies
after_create :set_poll_id
before_save :process_bangtags?, if: :local?
after_save :update_sharekey, if: :local?
after_save :update_origin, if: :local?
after_save :process_bangtags, if: :local?
class << self
def search_for(term, account = nil, limit = 33, offset = 0)
return none if account.nil?
if term.start_with?('me:')
term = term.split(nil, 2)[1]
query = account.statuses
else
scope = Status.where(hidden: false)
query = Status.where(account_id: account.id)
.or(scope.where(visibility: [:local, :public]))
.or(scope.where(account_id: account.following, visibility: [:private, :unlisted]))
.or(scope.where(id: account.mentions.select(:status_id)))
end
return none if term.blank?
query = query.without_reblogs
.search(term.unaccent)
.offset(offset).limit(limit)
apply_timeline_filters(query, account, true)
rescue ActiveRecord::StatementInvalid
raise Mastodon::ValidationError, 'Invalid syntax.'
end
def selectable_visibilities
visibilities.keys - %w(direct limited)
end
def in_chosen_languages(account)
where(language: nil).or where(language: account.chosen_languages)
end
def as_home_timeline(account, reblogs_only: false)
query = where(account: [account] + account.following, visibility: [:public, :unlisted, :local, :private], hidden: false)
query = query.without_reblogs if !reblogs_only && account.present? && account&.user&.hide_boosts
query = query.reblogs if reblogs_only
query
end
def as_direct_timeline(account, limit = 20, max_id = nil, since_id = nil, cache_ids = false)
# direct timeline is mix of direct message from_me and to_me.
# 2 queries are executed with pagination.
# constant expression using arel_table is required for partial index
# _from_me part does not require any timeline filters
query_from_me = where(account_id: account.id)
.where(Status.arel_table[:visibility].eq(3))
.limit(limit)
.order('statuses.id DESC')
# _to_me part requires mute and block filter.
# FIXME: may we check mutes.hide_notifications?
query_to_me = Status
.joins(:mentions)
.merge(Mention.where(account_id: account.id))
.where(Status.arel_table[:visibility].eq(3))
.limit(limit)
.order('mentions.status_id DESC')
.not_excluded_by_account(account)
.where(hidden: false)
if max_id.present?
query_from_me = query_from_me.where('statuses.id < ?', max_id)
query_to_me = query_to_me.where('mentions.status_id < ?', max_id)
end
if since_id.present?
query_from_me = query_from_me.where('statuses.id > ?', since_id)
query_to_me = query_to_me.where('mentions.status_id > ?', since_id)
end
if cache_ids
# returns array of cache_ids object that have id and updated_at
(query_from_me.cache_ids.to_a + query_to_me.cache_ids.to_a).uniq(&:id).sort_by(&:id).reverse.take(limit)
else
# returns ActiveRecord.Relation
items = (query_from_me.select(:id).to_a + query_to_me.select(:id).to_a).uniq(&:id).sort_by(&:id).reverse.take(limit)
Status.where(id: items.map(&:id))
end
end
def as_public_timeline(account = nil, local_only = false)
if local_only || account.nil? || account&.user&.setting_rawr_federated
query = timeline_scope(local_only)
else
query = Status.curated
end
query = query.without_replies unless Setting.show_replies_in_public_timelines
if account.present? && account.local?
query = query.without_reblogs if account&.user&.hide_boosts
query = query.only_followers_of(account) if account&.user&.only_known
end
apply_timeline_filters(query, account, local_only)
end
def as_tag_timeline(tag, account = nil, local_only = false, priv = false)
query = tag_timeline_scope(account, local_only, priv).tagged_with(tag)
query = query.only_followers_of(account) if account.present? && account.local? && account&.user&.only_known?
apply_timeline_filters(query, account, local_only, true)
end
def as_outbox_timeline(account)
where(account: account, visibility: :public)
end
def favourites_map(status_ids, account_id)
Favourite.select('status_id').where(status_id: status_ids).where(account_id: account_id).each_with_object({}) { |f, h| h[f.status_id] = true }
end
def bookmarks_map(status_ids, account_id)
Bookmark.select('status_id').where(status_id: status_ids).where(account_id: account_id).map { |f| [f.status_id, true] }.to_h
end
def reblogs_map(status_ids, account_id)
select('reblog_of_id').where(reblog_of_id: status_ids).where(account_id: account_id).reorder(nil).each_with_object({}) { |s, h| h[s.reblog_of_id] = true }
end
def mutes_map(conversation_ids, account_id)
ConversationMute.select('conversation_id').where(conversation_id: conversation_ids).where(account_id: account_id).each_with_object({}) { |m, h| h[m.conversation_id] = true }
end
def pins_map(status_ids, account_id)
StatusPin.select('status_id').where(status_id: status_ids).where(account_id: account_id).each_with_object({}) { |p, h| h[p.status_id] = true }
end
def reload_stale_associations!(cached_items)
account_ids = []
cached_items.each do |item|
account_ids << item.account_id
account_ids << item.reblog.account_id if item.reblog?
end
account_ids.uniq!
return if account_ids.empty?
accounts = Account.where(id: account_ids).includes(:account_stat).each_with_object({}) { |a, h| h[a.id] = a }
cached_items.each do |item|
item.account = accounts[item.account_id]
item.reblog.account = accounts[item.reblog.account_id] if item.reblog?
end
end
def permitted_for(target_account, account)
visibility = [:public, :unlisted, :local]
if account.nil?
query = where(visibility: visibility, hidden: false).not_local_only
target_account.replies ? query : query.without_replies
elsif target_account.blocking?(account) # get rid of blocked peeps
none
elsif account.id == target_account.id # author can see own stuff
all
else
# followers can see followers-only stuff, but also things they are mentioned in.
# non-followers can see everything that isn't private/direct, but can see stuff they are mentioned in.
scope = left_outer_joins(:reblog).where(hidden: false)
query = scope.where(visibility: visibility).or(scope.where(id: account.mentions.select(:status_id)))
if account.following?(target_account) then
query = query.or(scope.where(visibility: :private).without_replies)
end
query.merge(scope.where(reblog_of_id: nil).or(scope.where.not(reblogs_statuses: { account_id: account.excluded_from_timeline_account_ids })))
end
end
private
def timeline_scope(local_only = false)
starting_scope = local_only ? Status.network : Status
starting_scope = local_only ? starting_scope.public_local_visibility : starting_scope.with_public_visibility
if Setting.show_reblogs_in_public_timelines
starting_scope
else
starting_scope.without_reblogs
end
end
def browsable_timeline_scope(local_only = false)
starting_scope = local_only ? Status.network : Status
starting_scope = starting_scope.public_browsable
if Setting.show_reblogs_in_public_timelines
starting_scope
else
starting_scope.without_reblogs
end
end
def tag_timeline_scope(account = nil, local_only = false, priv = false)
if priv
return Status.none if account.nil?
starting_scope = account.statuses
else
starting_scope = local_only ? Status.network : Status
starting_scope = starting_scope.public_browsable
end
if Setting.show_reblogs_in_public_timelines
starting_scope
else
starting_scope.without_reblogs
end
end
def apply_timeline_filters(query, account = nil, local_only = false, tag_timeline = false)
if account.nil?
filter_timeline_default(query)
else
filter_timeline_for_account(query, account, local_only, tag_timeline)
end
end
def filter_timeline_for_account(query, account, local_only, tag_timeline)
query = query.not_excluded_by_account(account)
query = query.not_domain_blocked_by_account(account) unless local_only
query = query.in_chosen_languages(account) if account.chosen_languages.present?
query = query.reply_not_excluded_by_account(account) unless tag_timeline
query = query.mention_not_excluded_by_account(account)
unless !account.user.filters_enabled || account.custom_filters.enabled.blank?
if account.user.invert_filters
query = query.search_filtered_by_account(account.id)
else
query = query.search_not_filtered_by_account(account.id)
end
end
query = query.with_media if account.user.media_only?
query = query.not_missing_media_desc if account.user.filter_undescribed?
query.merge(account_silencing_filter(account))
end
def filter_timeline_default(query)
query.not_local_only.excluding_silenced_accounts
end
def account_silencing_filter(account)
if account.silenced?
including_myself = left_outer_joins(:account).where(account_id: account.id).references(:accounts)
excluding_silenced_accounts.or(including_myself)
else
excluding_silenced_accounts
end
end
end
def marked_local_only?
LOCAL_ONLY_TOKENS.match?(content)
end
def marked_reject_replies?
return true if reject_replies
return true if spoiler_text.present? && REJECT_REPLIES_TOKENS.match?(spoiler_text.gsub(SIMPLIFIED, '').strip)
return true if content.present? && REJECT_REPLIES_TOKENS.match?(content.lines.first.gsub(SIMPLIFIED, '').strip)
content.present? && REJECT_REPLIES_TOKENS.match?(content.lines.last.gsub(SIMPLIFIED, '').strip)
end
private
def update_status_stat!(attrs)
return if marked_for_destruction? || destroyed?
record = status_stat || build_status_stat
record.update(attrs)
end
def store_uri
update_column(:uri, ActivityPub::TagManager.instance.uri_for(self)) if uri.nil?
end
def prepare_contents
text&.strip!
spoiler_text&.strip!
end
def set_reblog
self.reblog = reblog.reblog if reblog? && reblog.reblog?
end
def set_poll_id
update_column(:poll_id, poll.id) unless poll.nil?
end
def set_visibility
self.visibility = reblog.visibility if reblog? && visibility.nil?
self.visibility = (account.locked? ? :private : :public) if visibility.nil?
end
def set_locality
if account.domain.nil? && !attribute_changed?(:local_only)
self.local_only = marked_local_only?
end
end
def infer_reject_replies
self.reject_replies = marked_reject_replies?
end
def process_bangtags?
@_process_bangtags |= text_changed?
end
def process_bangtags
return unless @_process_bangtags
Bangtags.new(self).process
end
def update_sharekey
return if @_sharekey.nil?
if self.sharekey.nil?
self.create_sharekey(key: @_sharekey)
else
self.sharekey.update_attributes(key: @_sharekey)
end
end
def update_origin
return if @_origin.nil?
if self.imported_status.nil?
self.create_imported_status(origin: @_origin)
else
self.imported_status.update_attributes(origin: @_origin)
end
end
def set_conversation
self.thread = thread.reblog if thread&.reblog?
self.reply = !(in_reply_to_id.nil? && thread.nil?) unless reply
if reply? && !thread.nil?
self.in_reply_to_account_id = carried_over_reply_to_account_id
self.conversation_id = thread.conversation_id if conversation_id.nil?
elsif conversation_id.nil?
self.conversation = Conversation.new
end
end
def carried_over_reply_to_account_id
if thread.account_id == account_id && thread.reply?
thread.in_reply_to_account_id
else
thread.account_id
end
end
def set_local
self.local = account.local?
self.network = account.network?
end
def update_statistics
return unless distributable?
ActivityTracker.increment('activity:statuses:local')
end
def increment_counter_caches
return if direct_visibility?
account&.increment_count!(:statuses_count)
reblog&.increment_count!(:reblogs_count) if reblog?
thread&.increment_count!(:replies_count) if in_reply_to_id.present? && distributable?
end
def decrement_counter_caches
return if direct_visibility? || marked_for_mass_destruction?
account&.decrement_count!(:statuses_count)
reblog&.decrement_count!(:reblogs_count) if reblog?
thread&.decrement_count!(:replies_count) if in_reply_to_id.present? && distributable?
end
def unlink_from_conversations
return unless direct_visibility?
mentioned_accounts = mentions.includes(:account).map(&:account)
inbox_owners = mentioned_accounts.select(&:local?) + (account.local? ? [account] : [])
inbox_owners.each do |inbox_owner|
AccountConversation.remove_status(inbox_owner, self)
end
end
end
|