about summary refs log tree commit diff
path: root/app/services/remove_status_service.rb
blob: 238099169135e57860b412930b65310cbff8e910 (plain) (blame)
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
# frozen_string_literal: true

class RemoveStatusService < BaseService
  include StreamEntryRenderer

  def call(status, **options)
    @payload      = Oj.dump(event: :delete, payload: status.id.to_s)
    @status       = status
    @account      = status.account
    @tags         = status.tags.pluck(:name).to_a
    @mentions     = status.mentions.includes(:account).to_a
    @reblogs      = status.reblogs.to_a
    @stream_entry = status.stream_entry
    @options      = options

    remove_from_self if status.account.local?
    remove_from_followers
    remove_from_lists
    remove_from_affected
    remove_reblogs
    remove_from_hashtags
    remove_from_public
    remove_from_media if status.media_attachments.any?
    remove_from_direct if status.direct_visibility?

    @status.destroy!

    # There is no reason to send out Undo activities when the
    # cause is that the original object has been removed, since
    # original object being removed implicitly removes reblogs
    # of it. The Delete activity of the original is forwarded
    # separately.
    return if !@account.local? || @options[:original_removed]

    remove_from_remote_followers
    remove_from_remote_affected
  end

  private

  def remove_from_self
    FeedManager.instance.unpush_from_home(@account, @status)
  end

  def remove_from_followers
    @account.followers_for_local_distribution.find_each do |follower|
      FeedManager.instance.unpush_from_home(follower, @status)
    end
  end

  def remove_from_lists
    @account.lists_for_local_distribution.select(:id, :account_id).find_each do |list|
      FeedManager.instance.unpush_from_list(list, @status)
    end
  end

  def remove_from_affected
    @mentions.map(&:account).select(&:local?).each do |account|
      Redis.current.publish("timeline:#{account.id}", @payload)
    end
  end

  def remove_from_remote_affected
    # People who got mentioned in the status, or who
    # reblogged it from someone else might not follow
    # the author and wouldn't normally receive the
    # delete notification - so here, we explicitly
    # send it to them

    target_accounts = (@mentions.map(&:account).reject(&:local?) + @reblogs.map(&:account).reject(&:local?))
    target_accounts << @status.reblog.account if @status.reblog? && !@status.reblog.account.local?
    target_accounts.uniq!(&:id)

    # Ostatus
    NotificationWorker.push_bulk(target_accounts.select(&:ostatus?).uniq(&:domain)) do |target_account|
      [salmon_xml, @account.id, target_account.id]
    end

    # ActivityPub
    ActivityPub::DeliveryWorker.push_bulk(target_accounts.select(&:activitypub?).uniq(&:inbox_url)) do |target_account|
      [signed_activity_json, @account.id, target_account.inbox_url]
    end
  end

  def remove_from_remote_followers
    # OStatus
    Pubsubhubbub::RawDistributionWorker.perform_async(salmon_xml, @account.id)

    # ActivityPub
    ActivityPub::DeliveryWorker.push_bulk(@account.followers.inboxes) do |inbox_url|
      [signed_activity_json, @account.id, inbox_url]
    end
  end

  def salmon_xml
    @salmon_xml ||= stream_entry_to_xml(@stream_entry)
  end

  def signed_activity_json
    @signed_activity_json ||= Oj.dump(ActivityPub::LinkedDataSignature.new(activity_json).sign!(@account))
  end

  def activity_json
    @activity_json ||= ActiveModelSerializers::SerializableResource.new(
      @status,
      serializer: @status.reblog? ? ActivityPub::UndoAnnounceSerializer : ActivityPub::DeleteSerializer,
      adapter: ActivityPub::Adapter
    ).as_json
  end

  def remove_reblogs
    # We delete reblogs of the status before the original status,
    # because once original status is gone, reblogs will disappear
    # without us being able to do all the fancy stuff

    @reblogs.each do |reblog|
      RemoveStatusService.new.call(reblog, original_removed: true)
    end
  end

  def remove_from_hashtags
    return unless @status.public_visibility?

    @tags.each do |hashtag|
      Redis.current.publish("timeline:hashtag:#{hashtag}", @payload)
      Redis.current.publish("timeline:hashtag:#{hashtag}:local", @payload) if @status.local?
    end
  end

  def remove_from_public
    return unless @status.public_visibility?

    Redis.current.publish('timeline:public', @payload)
    Redis.current.publish('timeline:public:local', @payload) if @status.local?
  end

  def remove_from_media
    return unless @status.public_visibility?

    Redis.current.publish('timeline:public:media', @payload)
    Redis.current.publish('timeline:public:local:media', @payload) if @status.local?
  end

  def remove_from_direct
    @mentions.each do |mention|
      Redis.current.publish("timeline:direct:#{mention.account.id}", @payload) if mention.account.local?
    end
    Redis.current.publish("timeline:direct:#{@account.id}", @payload) if @account.local?
  end

  def redis
    Redis.current
  end
end