b357d5399d024cc0968acc5b8719206a2306184c
[akkoma] / lib / pleroma / notification.ex
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Notification do
6 use Ecto.Schema
7
8 alias Pleroma.Activity
9 alias Pleroma.Notification
10 alias Pleroma.Object
11 alias Pleroma.Pagination
12 alias Pleroma.Repo
13 alias Pleroma.User
14 alias Pleroma.Web.CommonAPI
15 alias Pleroma.Web.CommonAPI.Utils
16
17 import Ecto.Query
18 import Ecto.Changeset
19
20 schema "notifications" do
21 field(:seen, :boolean, default: false)
22 belongs_to(:user, User, type: Pleroma.FlakeId)
23 belongs_to(:activity, Activity, type: Pleroma.FlakeId)
24
25 timestamps()
26 end
27
28 def changeset(%Notification{} = notification, attrs) do
29 notification
30 |> cast(attrs, [:seen])
31 end
32
33 def for_user_query(user) do
34 Notification
35 |> where(user_id: ^user.id)
36 |> join(:inner, [n], activity in assoc(n, :activity))
37 |> join(:left, [n, a], object in Object,
38 on:
39 fragment(
40 "(?->>'id') = COALESCE((? -> 'object'::text) ->> 'id'::text)",
41 object.data,
42 a.data
43 )
44 )
45 |> preload([n, a, o], activity: {a, object: o})
46 end
47
48 def for_user(user, opts \\ %{}) do
49 user
50 |> for_user_query()
51 |> Pagination.fetch_paginated(opts)
52 end
53
54 def set_read_up_to(%{id: user_id} = _user, id) do
55 query =
56 from(
57 n in Notification,
58 where: n.user_id == ^user_id,
59 where: n.id <= ^id,
60 update: [
61 set: [seen: true]
62 ]
63 )
64
65 Repo.update_all(query, [])
66 end
67
68 def read_one(%User{} = user, notification_id) do
69 with {:ok, %Notification{} = notification} <- get(user, notification_id) do
70 notification
71 |> changeset(%{seen: true})
72 |> Repo.update()
73 end
74 end
75
76 def get(%{id: user_id} = _user, id) do
77 query =
78 from(
79 n in Notification,
80 where: n.id == ^id,
81 join: activity in assoc(n, :activity),
82 preload: [activity: activity]
83 )
84
85 notification = Repo.one(query)
86
87 case notification do
88 %{user_id: ^user_id} ->
89 {:ok, notification}
90
91 _ ->
92 {:error, "Cannot get notification"}
93 end
94 end
95
96 def clear(user) do
97 from(n in Notification, where: n.user_id == ^user.id)
98 |> Repo.delete_all()
99 end
100
101 def destroy_multiple(%{id: user_id} = _user, ids) do
102 from(n in Notification,
103 where: n.id in ^ids,
104 where: n.user_id == ^user_id
105 )
106 |> Repo.delete_all()
107 end
108
109 def dismiss(%{id: user_id} = _user, id) do
110 notification = Repo.get(Notification, id)
111
112 case notification do
113 %{user_id: ^user_id} ->
114 Repo.delete(notification)
115
116 _ ->
117 {:error, "Cannot dismiss notification"}
118 end
119 end
120
121 def create_notifications(%Activity{data: %{"to" => _, "type" => type}} = activity)
122 when type in ["Create", "Like", "Announce", "Follow"] do
123 users = get_notified_from_activity(activity)
124
125 notifications = Enum.map(users, fn user -> create_notification(activity, user) end)
126 {:ok, notifications}
127 end
128
129 def create_notifications(_), do: {:ok, []}
130
131 # TODO move to sql, too.
132 def create_notification(%Activity{} = activity, %User{} = user) do
133 unless skip?(activity, user) do
134 notification = %Notification{user_id: user.id, activity: activity}
135 {:ok, notification} = Repo.insert(notification)
136 Pleroma.Web.Streamer.stream("user", notification)
137 Pleroma.Web.Push.send(notification)
138 notification
139 end
140 end
141
142 def get_notified_from_activity(activity, local_only \\ true)
143
144 def get_notified_from_activity(
145 %Activity{data: %{"to" => _, "type" => type} = _data} = activity,
146 local_only
147 )
148 when type in ["Create", "Like", "Announce", "Follow"] do
149 recipients =
150 []
151 |> Utils.maybe_notify_to_recipients(activity)
152 |> Utils.maybe_notify_mentioned_recipients(activity)
153 |> Utils.maybe_notify_subscribers(activity)
154 |> Enum.uniq()
155
156 User.get_users_from_set(recipients, local_only)
157 end
158
159 def get_notified_from_activity(_, _local_only), do: []
160
161 def skip?(activity, user) do
162 [:self, :blocked, :local, :muted, :followers, :follows, :recently_followed]
163 |> Enum.any?(&skip?(&1, activity, user))
164 end
165
166 def skip?(:self, activity, user) do
167 activity.data["actor"] == user.ap_id
168 end
169
170 def skip?(:blocked, activity, user) do
171 actor = activity.data["actor"]
172 User.blocks?(user, %{ap_id: actor})
173 end
174
175 def skip?(:local, %{local: true}, %{info: %{notification_settings: %{"local" => false}}}),
176 do: true
177
178 def skip?(:local, %{local: false}, %{info: %{notification_settings: %{"remote" => false}}}),
179 do: true
180
181 def skip?(:muted, activity, user) do
182 actor = activity.data["actor"]
183
184 User.mutes?(user, %{ap_id: actor}) or CommonAPI.thread_muted?(user, activity)
185 end
186
187 def skip?(
188 :followers,
189 activity,
190 %{info: %{notification_settings: %{"followers" => false}}} = user
191 ) do
192 actor = activity.data["actor"]
193 follower = User.get_cached_by_ap_id(actor)
194 User.following?(follower, user)
195 end
196
197 def skip?(:follows, activity, %{info: %{notification_settings: %{"follows" => false}}} = user) do
198 actor = activity.data["actor"]
199 followed = User.get_by_ap_id(actor)
200 User.following?(user, followed)
201 end
202
203 def skip?(:recently_followed, %{data: %{"type" => "Follow"}} = activity, user) do
204 actor = activity.data["actor"]
205
206 Notification.for_user(user)
207 |> Enum.any?(fn
208 %{activity: %{data: %{"type" => "Follow", "actor" => ^actor}}} -> true
209 _ -> false
210 end)
211 end
212
213 def skip?(_, _, _), do: false
214 end