1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.CommonAPI do
8 alias Pleroma.Formatter
10 alias Pleroma.ThreadMute
12 alias Pleroma.Web.ActivityPub.ActivityPub
13 alias Pleroma.Web.ActivityPub.Utils
14 alias Pleroma.Web.ActivityPub.Visibility
16 import Pleroma.Web.CommonAPI.Utils
18 def follow(follower, followed) do
19 with {:ok, follower} <- User.maybe_direct_follow(follower, followed),
20 {:ok, activity} <- ActivityPub.follow(follower, followed),
21 {:ok, follower, followed} <-
22 User.wait_and_refresh(
23 Pleroma.Config.get([:activitypub, :follow_handshake_timeout]),
27 {:ok, follower, followed, activity}
31 def unfollow(follower, unfollowed) do
32 with {:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed),
33 {:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed) do
38 def accept_follow_request(follower, followed) do
39 with {:ok, follower} <- User.follow(follower, followed),
40 %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
41 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
46 object: follow_activity.data["id"],
53 def reject_follow_request(follower, followed) do
54 with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
55 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
60 object: follow_activity.data["id"],
67 def delete(activity_id, user) do
68 with %Activity{data: %{"object" => _}} = activity <-
69 Activity.get_by_id_with_object(activity_id),
70 %Object{} = object <- Object.normalize(activity),
71 true <- User.superuser?(user) || user.ap_id == object.data["actor"],
72 {:ok, _} <- unpin(activity_id, user),
73 {:ok, delete} <- ActivityPub.delete(object) do
77 {:error, "Could not delete"}
81 def repeat(id_or_ap_id, user) do
82 with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
83 object <- Object.normalize(activity),
84 nil <- Utils.get_existing_announce(user.ap_id, object) do
85 ActivityPub.announce(user, object)
88 {:error, "Could not repeat"}
92 def unrepeat(id_or_ap_id, user) do
93 with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
94 object <- Object.normalize(activity) do
95 ActivityPub.unannounce(user, object)
98 {:error, "Could not unrepeat"}
102 def favorite(id_or_ap_id, user) do
103 with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
104 object <- Object.normalize(activity),
105 nil <- Utils.get_existing_like(user.ap_id, object) do
106 ActivityPub.like(user, object)
109 {:error, "Could not favorite"}
113 def unfavorite(id_or_ap_id, user) do
114 with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
115 object <- Object.normalize(activity) do
116 ActivityPub.unlike(user, object)
119 {:error, "Could not unfavorite"}
123 def vote(user, object, choices) do
124 with "Question" <- object.data["type"],
125 {:author, false} <- {:author, object.data["actor"] == user.ap_id},
126 {:existing_votes, []} <- {:existing_votes, Utils.get_existing_votes(user.ap_id, object)},
127 {options, max_count} <- get_options_and_max_count(object),
128 option_count <- Enum.count(options),
129 {:choice_check, {choices, true}} <-
130 {:choice_check, normalize_and_validate_choice_indices(choices, option_count)},
131 {:count_check, true} <- {:count_check, Enum.count(choices) <= max_count} do
133 Enum.map(choices, fn index ->
134 answer_data = make_answer_data(user, object, Enum.at(options, index)["name"])
137 ActivityPub.create(%{
138 to: answer_data["to"],
140 context: object.data["context"],
142 additional: %{"cc" => answer_data["cc"]}
148 object = Object.get_cached_by_ap_id(object.data["id"])
149 {:ok, answer_activities, object}
151 {:author, _} -> {:error, "Poll's author can't vote"}
152 {:existing_votes, _} -> {:error, "Already voted"}
153 {:choice_check, {_, false}} -> {:error, "Invalid indices"}
154 {:count_check, false} -> {:error, "Too many choices"}
158 defp get_options_and_max_count(object) do
159 if Map.has_key?(object.data, "anyOf") do
160 {object.data["anyOf"], Enum.count(object.data["anyOf"])}
162 {object.data["oneOf"], 1}
166 defp normalize_and_validate_choice_indices(choices, count) do
167 Enum.map_reduce(choices, true, fn index, valid ->
168 index = if is_binary(index), do: String.to_integer(index), else: index
169 {index, if(valid, do: index < count, else: valid)}
173 def get_visibility(%{"visibility" => visibility}, in_reply_to)
174 when visibility in ~w{public unlisted private direct},
175 do: {visibility, get_replied_to_visibility(in_reply_to)}
177 def get_visibility(_, in_reply_to) when not is_nil(in_reply_to) do
178 visibility = get_replied_to_visibility(in_reply_to)
179 {visibility, visibility}
182 def get_visibility(_, in_reply_to), do: {"public", get_replied_to_visibility(in_reply_to)}
184 def get_replied_to_visibility(nil), do: nil
186 def get_replied_to_visibility(activity) do
187 with %Object{} = object <- Object.normalize(activity) do
188 Pleroma.Web.ActivityPub.Visibility.get_visibility(object)
192 def post(user, %{"status" => status} = data) do
193 limit = Pleroma.Config.get([:instance, :limit])
195 with status <- String.trim(status),
196 attachments <- attachments_from_ids(data),
197 in_reply_to <- get_replied_to_activity(data["in_reply_to_status_id"]),
198 {visibility, in_reply_to_visibility} <- get_visibility(data, in_reply_to),
200 {:private_to_public, in_reply_to_visibility == "direct" && visibility != "direct"},
201 {content_html, mentions, tags} <-
208 mentioned_users <- for({_, mentioned_user} <- mentions, do: mentioned_user.ap_id),
209 addressed_users <- get_addressed_users(mentioned_users, data["to"]),
210 {poll, poll_emoji} <- make_poll_data(data),
211 {to, cc} <- get_to_and_cc(user, addressed_users, in_reply_to, visibility),
212 context <- make_context(in_reply_to),
213 cw <- data["spoiler_text"] || "",
214 sensitive <- data["sensitive"] || Enum.member?(tags, {"#nsfw", "nsfw"}),
215 full_payload <- String.trim(status <> cw),
216 :ok <- validate_character_limit(full_payload, attachments, limit),
235 Map.merge(Formatter.get_emoji_map(full_payload), poll_emoji)
244 additional: %{"cc" => cc, "directMessage" => visibility == "direct"}
246 Pleroma.Web.ControllerHelper.truthy_param?(data["preview"]) || false
251 {:private_to_public, true} -> {:error, "The message visibility must be direct"}
257 # Updates the emojis for a user based on their profile
260 with emoji <- emoji_from_profile(user),
261 source_data <- (user.info.source_data || %{}) |> Map.put("tag", emoji),
262 info_cng <- User.Info.set_source_data(user.info, source_data),
263 change <- Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_cng),
264 {:ok, user} <- User.update_and_set_cache(change) do
271 ActivityPub.update(%{
273 to: [user.follower_address],
276 object: Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
280 def pin(id_or_ap_id, %{ap_id: user_ap_id} = user) do
291 } = activity <- get_by_id_or_ap_id(id_or_ap_id),
292 true <- Visibility.is_public?(activity),
293 %{valid?: true} = info_changeset <-
294 User.Info.add_pinnned_activity(user.info, activity),
296 Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_changeset),
297 {:ok, _user} <- User.update_and_set_cache(changeset) do
300 %{errors: [pinned_activities: {err, _}]} ->
304 {:error, "Could not pin"}
308 def unpin(id_or_ap_id, user) do
309 with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
310 %{valid?: true} = info_changeset <-
311 User.Info.remove_pinnned_activity(user.info, activity),
313 Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_changeset),
314 {:ok, _user} <- User.update_and_set_cache(changeset) do
317 %{errors: [pinned_activities: {err, _}]} ->
321 {:error, "Could not unpin"}
325 def add_mute(user, activity) do
326 with {:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]) do
329 {:error, _} -> {:error, "conversation is already muted"}
333 def remove_mute(user, activity) do
334 ThreadMute.remove_mute(user.id, activity.data["context"])
338 def thread_muted?(%{id: nil} = _user, _activity), do: false
340 def thread_muted?(user, activity) do
341 with [] <- ThreadMute.check_muted(user.id, activity.data["context"]) do
348 def bookmarked?(user, activity) do
349 with %Bookmark{} <- Bookmark.get(user.id, activity.id) do
357 def report(user, data) do
358 with {:account_id, %{"account_id" => account_id}} <- {:account_id, data},
359 {:account, %User{} = account} <- {:account, User.get_cached_by_id(account_id)},
360 {:ok, {content_html, _, _}} <- make_report_content_html(data["comment"]),
361 {:ok, statuses} <- get_report_statuses(account, data),
364 context: Utils.generate_context_id(),
368 content: content_html,
369 forward: data["forward"] || false
373 {:error, err} -> {:error, err}
374 {:account_id, %{}} -> {:error, "Valid `account_id` required"}
375 {:account, nil} -> {:error, "Account not found"}
379 def update_report_state(activity_id, state) do
380 with %Activity{} = activity <- Activity.get_by_id(activity_id),
381 {:ok, activity} <- Utils.update_report_state(activity, state) do
391 {:error, "Could not update state"}
395 def update_activity_scope(activity_id, opts \\ %{}) do
396 with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
397 {:ok, activity} <- toggle_sensitive(activity, opts),
398 {:ok, activity} <- set_visibility(activity, opts) do
409 defp toggle_sensitive(activity, %{"sensitive" => sensitive}) when sensitive in ~w(true false) do
410 toggle_sensitive(activity, %{"sensitive" => String.to_existing_atom(sensitive)})
413 defp toggle_sensitive(%Activity{object: object} = activity, %{"sensitive" => sensitive})
414 when is_boolean(sensitive) do
415 new_data = Map.put(object.data, "sensitive", sensitive)
419 |> Object.change(%{data: new_data})
420 |> Object.update_and_set_cache()
422 {:ok, Map.put(activity, :object, object)}
425 defp toggle_sensitive(activity, _), do: {:ok, activity}
427 defp set_visibility(activity, %{"visibility" => visibility}) do
428 Utils.update_activity_visibility(activity, visibility)
431 defp set_visibility(activity, _), do: {:ok, activity}
433 def hide_reblogs(user, muted) do
436 if ap_id not in user.info.muted_reblogs do
437 info_changeset = User.Info.add_reblog_mute(user.info, ap_id)
438 changeset = Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_changeset)
439 User.update_and_set_cache(changeset)
443 def show_reblogs(user, muted) do
446 if ap_id in user.info.muted_reblogs do
447 info_changeset = User.Info.remove_reblog_mute(user.info, ap_id)
448 changeset = Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_changeset)
449 User.update_and_set_cache(changeset)