Merge branch 'develop' of https://git.pleroma.social/pleroma/pleroma into develop
[akkoma] / lib / pleroma / web / common_api / utils.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.Web.CommonAPI.Utils do
6 alias Calendar.Strftime
7 alias Comeonin.Pbkdf2
8 alias Pleroma.Activity
9 alias Pleroma.Config
10 alias Pleroma.Formatter
11 alias Pleroma.Object
12 alias Pleroma.Repo
13 alias Pleroma.User
14 alias Pleroma.Web.ActivityPub.Utils
15 alias Pleroma.Web.ActivityPub.Visibility
16 alias Pleroma.Web.Endpoint
17 alias Pleroma.Web.MediaProxy
18
19 require Logger
20
21 # This is a hack for twidere.
22 def get_by_id_or_ap_id(id) do
23 activity =
24 Activity.get_by_id_with_object(id) || Activity.get_create_by_object_ap_id_with_object(id)
25
26 activity &&
27 if activity.data["type"] == "Create" do
28 activity
29 else
30 Activity.get_create_by_object_ap_id_with_object(activity.data["object"])
31 end
32 end
33
34 def get_replied_to_activity(""), do: nil
35
36 def get_replied_to_activity(id) when not is_nil(id) do
37 Activity.get_by_id(id)
38 end
39
40 def get_replied_to_activity(_), do: nil
41
42 def attachments_from_ids(data) do
43 if Map.has_key?(data, "descriptions") do
44 attachments_from_ids_descs(data["media_ids"], data["descriptions"])
45 else
46 attachments_from_ids_no_descs(data["media_ids"])
47 end
48 end
49
50 def attachments_from_ids_no_descs(ids) do
51 Enum.map(ids || [], fn media_id ->
52 Repo.get(Object, media_id).data
53 end)
54 end
55
56 def attachments_from_ids_descs(ids, descs_str) do
57 {_, descs} = Jason.decode(descs_str)
58
59 Enum.map(ids || [], fn media_id ->
60 Map.put(Repo.get(Object, media_id).data, "name", descs[media_id])
61 end)
62 end
63
64 def to_for_user_and_mentions(user, mentions, inReplyTo, "public") do
65 mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)
66
67 to = ["https://www.w3.org/ns/activitystreams#Public" | mentioned_users]
68 cc = [user.follower_address]
69
70 if inReplyTo do
71 {Enum.uniq([inReplyTo.data["actor"] | to]), cc}
72 else
73 {to, cc}
74 end
75 end
76
77 def to_for_user_and_mentions(user, mentions, inReplyTo, "unlisted") do
78 mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)
79
80 to = [user.follower_address | mentioned_users]
81 cc = ["https://www.w3.org/ns/activitystreams#Public"]
82
83 if inReplyTo do
84 {Enum.uniq([inReplyTo.data["actor"] | to]), cc}
85 else
86 {to, cc}
87 end
88 end
89
90 def to_for_user_and_mentions(user, mentions, inReplyTo, "private") do
91 {to, cc} = to_for_user_and_mentions(user, mentions, inReplyTo, "direct")
92 {[user.follower_address | to], cc}
93 end
94
95 def to_for_user_and_mentions(_user, mentions, inReplyTo, "direct") do
96 mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)
97
98 if inReplyTo do
99 {Enum.uniq([inReplyTo.data["actor"] | mentioned_users]), []}
100 else
101 {mentioned_users, []}
102 end
103 end
104
105 def make_content_html(
106 status,
107 attachments,
108 data,
109 visibility
110 ) do
111 no_attachment_links =
112 data
113 |> Map.get("no_attachment_links", Config.get([:instance, :no_attachment_links]))
114 |> Kernel.in([true, "true"])
115
116 content_type = get_content_type(data["content_type"])
117
118 options =
119 if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
120 [safe_mention: true]
121 else
122 []
123 end
124
125 status
126 |> format_input(content_type, options)
127 |> maybe_add_attachments(attachments, no_attachment_links)
128 |> maybe_add_nsfw_tag(data)
129 end
130
131 defp get_content_type(content_type) do
132 if Enum.member?(Config.get([:instance, :allowed_post_formats]), content_type) do
133 content_type
134 else
135 "text/plain"
136 end
137 end
138
139 defp maybe_add_nsfw_tag({text, mentions, tags}, %{"sensitive" => sensitive})
140 when sensitive in [true, "True", "true", "1"] do
141 {text, mentions, [{"#nsfw", "nsfw"} | tags]}
142 end
143
144 defp maybe_add_nsfw_tag(data, _), do: data
145
146 def make_context(%Activity{data: %{"context" => context}}), do: context
147 def make_context(_), do: Utils.generate_context_id()
148
149 def maybe_add_attachments(parsed, _attachments, true = _no_links), do: parsed
150
151 def maybe_add_attachments({text, mentions, tags}, attachments, _no_links) do
152 text = add_attachments(text, attachments)
153 {text, mentions, tags}
154 end
155
156 def add_attachments(text, attachments) do
157 attachment_text =
158 Enum.map(attachments, fn
159 %{"url" => [%{"href" => href} | _]} = attachment ->
160 name = attachment["name"] || URI.decode(Path.basename(href))
161 href = MediaProxy.url(href)
162 "<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"
163
164 _ ->
165 ""
166 end)
167
168 Enum.join([text | attachment_text], "<br>")
169 end
170
171 def format_input(text, format, options \\ [])
172
173 @doc """
174 Formatting text to plain text.
175 """
176 def format_input(text, "text/plain", options) do
177 text
178 |> Formatter.html_escape("text/plain")
179 |> Formatter.linkify(options)
180 |> (fn {text, mentions, tags} ->
181 {String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
182 end).()
183 end
184
185 @doc """
186 Formatting text to html.
187 """
188 def format_input(text, "text/html", options) do
189 text
190 |> Formatter.html_escape("text/html")
191 |> Formatter.linkify(options)
192 end
193
194 @doc """
195 Formatting text to markdown.
196 """
197 def format_input(text, "text/markdown", options) do
198 options = Keyword.put(options, :mentions_escape, true)
199
200 text
201 |> Formatter.linkify(options)
202 |> (fn {text, mentions, tags} -> {Earmark.as_html!(text), mentions, tags} end).()
203 |> Formatter.html_escape("text/html")
204 end
205
206 def make_note_data(
207 actor,
208 to,
209 context,
210 content_html,
211 attachments,
212 inReplyTo,
213 tags,
214 cw \\ nil,
215 cc \\ []
216 ) do
217 object = %{
218 "type" => "Note",
219 "to" => to,
220 "cc" => cc,
221 "content" => content_html,
222 "summary" => cw,
223 "context" => context,
224 "attachment" => attachments,
225 "actor" => actor,
226 "tag" => tags |> Enum.map(fn {_, tag} -> tag end) |> Enum.uniq()
227 }
228
229 if inReplyTo do
230 object
231 |> Map.put("inReplyTo", inReplyTo.data["object"]["id"])
232 |> Map.put("inReplyToStatusId", inReplyTo.id)
233 else
234 object
235 end
236 end
237
238 def format_naive_asctime(date) do
239 date |> DateTime.from_naive!("Etc/UTC") |> format_asctime
240 end
241
242 def format_asctime(date) do
243 Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
244 end
245
246 def date_to_asctime(date) when is_binary(date) do
247 with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
248 format_asctime(date)
249 else
250 _e ->
251 Logger.warn("Date #{date} in wrong format, must be ISO 8601")
252 ""
253 end
254 end
255
256 def date_to_asctime(date) do
257 Logger.warn("Date #{date} in wrong format, must be ISO 8601")
258 ""
259 end
260
261 def to_masto_date(%NaiveDateTime{} = date) do
262 date
263 |> NaiveDateTime.to_iso8601()
264 |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
265 end
266
267 def to_masto_date(date) do
268 try do
269 date
270 |> NaiveDateTime.from_iso8601!()
271 |> NaiveDateTime.to_iso8601()
272 |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
273 rescue
274 _e -> ""
275 end
276 end
277
278 defp shortname(name) do
279 if String.length(name) < 30 do
280 name
281 else
282 String.slice(name, 0..30) <> "…"
283 end
284 end
285
286 def confirm_current_password(user, password) do
287 with %User{local: true} = db_user <- User.get_by_id(user.id),
288 true <- Pbkdf2.checkpw(password, db_user.password_hash) do
289 {:ok, db_user}
290 else
291 _ -> {:error, "Invalid password."}
292 end
293 end
294
295 def emoji_from_profile(%{info: _info} = user) do
296 (Formatter.get_emoji(user.bio) ++ Formatter.get_emoji(user.name))
297 |> Enum.map(fn {shortcode, url, _} ->
298 %{
299 "type" => "Emoji",
300 "icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}#{url}"},
301 "name" => ":#{shortcode}:"
302 }
303 end)
304 end
305
306 def maybe_notify_to_recipients(
307 recipients,
308 %Activity{data: %{"to" => to, "type" => _type}} = _activity
309 ) do
310 recipients ++ to
311 end
312
313 def maybe_notify_mentioned_recipients(
314 recipients,
315 %Activity{data: %{"to" => _to, "type" => type} = data} = activity
316 )
317 when type == "Create" do
318 object = Object.normalize(activity)
319
320 object_data =
321 cond do
322 !is_nil(object) ->
323 object.data
324
325 is_map(data["object"]) ->
326 data["object"]
327
328 true ->
329 %{}
330 end
331
332 tagged_mentions = maybe_extract_mentions(object_data)
333
334 recipients ++ tagged_mentions
335 end
336
337 def maybe_notify_mentioned_recipients(recipients, _), do: recipients
338
339 def maybe_notify_subscribers(
340 recipients,
341 %Activity{data: %{"actor" => actor, "type" => type}} = activity
342 )
343 when type == "Create" do
344 with %User{} = user <- User.get_cached_by_ap_id(actor) do
345 subscriber_ids =
346 user
347 |> User.subscribers()
348 |> Enum.filter(&Visibility.visible_for_user?(activity, &1))
349 |> Enum.map(& &1.ap_id)
350
351 recipients ++ subscriber_ids
352 end
353 end
354
355 def maybe_notify_subscribers(recipients, _), do: recipients
356
357 def maybe_extract_mentions(%{"tag" => tag}) do
358 tag
359 |> Enum.filter(fn x -> is_map(x) end)
360 |> Enum.filter(fn x -> x["type"] == "Mention" end)
361 |> Enum.map(fn x -> x["href"] end)
362 end
363
364 def maybe_extract_mentions(_), do: []
365
366 def make_report_content_html(nil), do: {:ok, {nil, [], []}}
367
368 def make_report_content_html(comment) do
369 max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
370
371 if String.length(comment) <= max_size do
372 {:ok, format_input(comment, "text/plain")}
373 else
374 {:error, "Comment must be up to #{max_size} characters"}
375 end
376 end
377
378 def get_report_statuses(%User{ap_id: actor}, %{"status_ids" => status_ids}) do
379 {:ok, Activity.all_by_actor_and_id(actor, status_ids)}
380 end
381
382 def get_report_statuses(_, _), do: {:ok, nil}
383
384 # DEPRECATED mostly, context objects are now created at insertion time.
385 def context_to_conversation_id(context) do
386 with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
387 id
388 else
389 _e ->
390 changeset = Object.context_mapping(context)
391
392 case Repo.insert(changeset) do
393 {:ok, %{id: id}} ->
394 id
395
396 # This should be solved by an upsert, but it seems ecto
397 # has problems accessing the constraint inside the jsonb.
398 {:error, _} ->
399 Object.get_cached_by_ap_id(context).id
400 end
401 end
402 end
403
404 def conversation_id_to_context(id) do
405 with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
406 context
407 else
408 _e ->
409 {:error, "No such conversation"}
410 end
411 end
412 end