git.squeep.com Git - akkoma/blob - lib/pleroma/web/mastodon_api/mastodon_api_controller.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.MastodonAPI.MastodonAPIController do
   6   use Pleroma.Web, :controller
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.Config
  10   alias Pleroma.Filter
  11   alias Pleroma.Notification
  12   alias Pleroma.Object
  13   alias Pleroma.Repo
  14   alias Pleroma.Stats
  15   alias Pleroma.User
  16   alias Pleroma.Web
  17   alias Pleroma.Web.ActivityPub.ActivityPub
  18   alias Pleroma.Web.ActivityPub.Visibility
  19   alias Pleroma.Web.CommonAPI
  20   alias Pleroma.Web.MastodonAPI.AccountView
  21   alias Pleroma.Web.MastodonAPI.AppView
  22   alias Pleroma.Web.MastodonAPI.FilterView
  23   alias Pleroma.Web.MastodonAPI.ListView
  24   alias Pleroma.Web.MastodonAPI.MastodonAPI
  25   alias Pleroma.Web.MastodonAPI.MastodonView
  26   alias Pleroma.Web.MastodonAPI.NotificationView
  27   alias Pleroma.Web.MastodonAPI.ReportView
  28   alias Pleroma.Web.MastodonAPI.StatusView
  29   alias Pleroma.Web.MediaProxy
  30   alias Pleroma.Web.OAuth.App
  31   alias Pleroma.Web.OAuth.Authorization
  32   alias Pleroma.Web.OAuth.Token
  33
  34   import Pleroma.Web.ControllerHelper, only: [oauth_scopes: 2]
  35   import Ecto.Query
  36
  37   require Logger
  38
  39   @httpoison Application.get_env(:pleroma, :httpoison)
  40   @local_mastodon_name "Mastodon-Local"
  41
  42   action_fallback(:errors)
  43
  44   def create_app(conn, params) do
  45     scopes = oauth_scopes(params, ["read"])
  46
  47     app_attrs =
  48       params
  49       |> Map.drop(["scope", "scopes"])
  50       |> Map.put("scopes", scopes)
  51
  52     with cs <- App.register_changeset(%App{}, app_attrs),
  53          false <- cs.changes[:client_name] == @local_mastodon_name,
  54          {:ok, app} <- Repo.insert(cs) do
  55       conn
  56       |> put_view(AppView)
  57       |> render("show.json", %{app: app})
  58     end
  59   end
  60
  61   defp add_if_present(
  62          map,
  63          params,
  64          params_field,
  65          map_field,
  66          value_function \\ fn x -> {:ok, x} end
  67        ) do
  68     if Map.has_key?(params, params_field) do
  69       case value_function.(params[params_field]) do
  70         {:ok, new_value} -> Map.put(map, map_field, new_value)
  71         :error -> map
  72       end
  73     else
  74       map
  75     end
  76   end
  77
  78   def update_credentials(%{assigns: %{user: user}} = conn, params) do
  79     original_user = user
  80
  81     user_params =
  82       %{}
  83       |> add_if_present(params, "display_name", :name)
  84       |> add_if_present(params, "note", :bio, fn value -> {:ok, User.parse_bio(value)} end)
  85       |> add_if_present(params, "avatar", :avatar, fn value ->
  86         with %Plug.Upload{} <- value,
  87              {:ok, object} <- ActivityPub.upload(value, type: :avatar) do
  88           {:ok, object.data}
  89         else
  90           _ -> :error
  91         end
  92       end)
  93
  94     info_params =
  95       %{}
  96       |> add_if_present(params, "locked", :locked, fn value -> {:ok, value == "true"} end)
  97       |> add_if_present(params, "header", :banner, fn value ->
  98         with %Plug.Upload{} <- value,
  99              {:ok, object} <- ActivityPub.upload(value, type: :banner) do
 100           {:ok, object.data}
 101         else
 102           _ -> :error
 103         end
 104       end)
 105
 106     info_cng = User.Info.mastodon_profile_update(user.info, info_params)
 107
 108     with changeset <- User.update_changeset(user, user_params),
 109          changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
 110          {:ok, user} <- User.update_and_set_cache(changeset) do
 111       if original_user != user do
 112         CommonAPI.update(user)
 113       end
 114
 115       json(conn, AccountView.render("account.json", %{user: user, for: user}))
 116     else
 117       _e ->
 118         conn
 119         |> put_status(403)
 120         |> json(%{error: "Invalid request"})
 121     end
 122   end
 123
 124   def verify_credentials(%{assigns: %{user: user}} = conn, _) do
 125     account = AccountView.render("account.json", %{user: user, for: user})
 126     json(conn, account)
 127   end
 128
 129   def verify_app_credentials(%{assigns: %{user: _user, token: token}} = conn, _) do
 130     with %Token{app: %App{} = app} <- Repo.preload(token, :app) do
 131       conn
 132       |> put_view(AppView)
 133       |> render("short.json", %{app: app})
 134     end
 135   end
 136
 137   def user(%{assigns: %{user: for_user}} = conn, %{"id" => nickname_or_id}) do
 138     with %User{} = user <- User.get_cached_by_nickname_or_id(nickname_or_id),
 139          true <- User.auth_active?(user) || user.id == for_user.id || User.superuser?(for_user) do
 140       account = AccountView.render("account.json", %{user: user, for: for_user})
 141       json(conn, account)
 142     else
 143       _e ->
 144         conn
 145         |> put_status(404)
 146         |> json(%{error: "Can't find user"})
 147     end
 148   end
 149
 150   @mastodon_api_level "2.5.0"
 151
 152   def masto_instance(conn, _params) do
 153     instance = Config.get(:instance)
 154
 155     response = %{
 156       uri: Web.base_url(),
 157       title: Keyword.get(instance, :name),
 158       description: Keyword.get(instance, :description),
 159       version: "#{@mastodon_api_level} (compatible; #{Pleroma.Application.named_version()})",
 160       email: Keyword.get(instance, :email),
 161       urls: %{
 162         streaming_api: Pleroma.Web.Endpoint.websocket_url()
 163       },
 164       stats: Stats.get_stats(),
 165       thumbnail: Web.base_url() <> "/instance/thumbnail.jpeg",
 166       languages: ["en"],
 167       registrations: Pleroma.Config.get([:instance, :registrations_open]),
 168       # Extra (not present in Mastodon):
 169       max_toot_chars: Keyword.get(instance, :limit)
 170     }
 171
 172     json(conn, response)
 173   end
 174
 175   def peers(conn, _params) do
 176     json(conn, Stats.get_peers())
 177   end
 178
 179   defp mastodonized_emoji do
 180     Pleroma.Emoji.get_all()
 181     |> Enum.map(fn {shortcode, relative_url} ->
 182       url = to_string(URI.merge(Web.base_url(), relative_url))
 183
 184       %{
 185         "shortcode" => shortcode,
 186         "static_url" => url,
 187         "visible_in_picker" => true,
 188         "url" => url
 189       }
 190     end)
 191   end
 192
 193   def custom_emojis(conn, _params) do
 194     mastodon_emoji = mastodonized_emoji()
 195     json(conn, mastodon_emoji)
 196   end
 197
 198   defp add_link_headers(conn, method, activities, param \\ nil, params \\ %{}) do
 199     params =
 200       conn.params
 201       |> Map.drop(["since_id", "max_id"])
 202       |> Map.merge(params)
 203
 204     last = List.last(activities)
 205     first = List.first(activities)
 206
 207     if last do
 208       min = last.id
 209       max = first.id
 210
 211       {next_url, prev_url} =
 212         if param do
 213           {
 214             mastodon_api_url(
 215               Pleroma.Web.Endpoint,
 216               method,
 217               param,
 218               Map.merge(params, %{max_id: min})
 219             ),
 220             mastodon_api_url(
 221               Pleroma.Web.Endpoint,
 222               method,
 223               param,
 224               Map.merge(params, %{since_id: max})
 225             )
 226           }
 227         else
 228           {
 229             mastodon_api_url(
 230               Pleroma.Web.Endpoint,
 231               method,
 232               Map.merge(params, %{max_id: min})
 233             ),
 234             mastodon_api_url(
 235               Pleroma.Web.Endpoint,
 236               method,
 237               Map.merge(params, %{since_id: max})
 238             )
 239           }
 240         end
 241
 242       conn
 243       |> put_resp_header("link", "<#{next_url}>; rel=\"next\", <#{prev_url}>; rel=\"prev\"")
 244     else
 245       conn
 246     end
 247   end
 248
 249   def home_timeline(%{assigns: %{user: user}} = conn, params) do
 250     params =
 251       params
 252       |> Map.put("type", ["Create", "Announce"])
 253       |> Map.put("blocking_user", user)
 254       |> Map.put("muting_user", user)
 255       |> Map.put("user", user)
 256
 257     activities =
 258       [user.ap_id | user.following]
 259       |> ActivityPub.fetch_activities(params)
 260       |> ActivityPub.contain_timeline(user)
 261       |> Enum.reverse()
 262
 263     conn
 264     |> add_link_headers(:home_timeline, activities)
 265     |> put_view(StatusView)
 266     |> render("index.json", %{activities: activities, for: user, as: :activity})
 267   end
 268
 269   def public_timeline(%{assigns: %{user: user}} = conn, params) do
 270     local_only = params["local"] in [true, "True", "true", "1"]
 271
 272     activities =
 273       params
 274       |> Map.put("type", ["Create", "Announce"])
 275       |> Map.put("local_only", local_only)
 276       |> Map.put("blocking_user", user)
 277       |> Map.put("muting_user", user)
 278       |> ActivityPub.fetch_public_activities()
 279       |> Enum.reverse()
 280
 281     conn
 282     |> add_link_headers(:public_timeline, activities, false, %{"local" => local_only})
 283     |> put_view(StatusView)
 284     |> render("index.json", %{activities: activities, for: user, as: :activity})
 285   end
 286
 287   def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
 288     with %User{} = user <- User.get_by_id(params["id"]) do
 289       activities = ActivityPub.fetch_user_activities(user, reading_user, params)
 290
 291       conn
 292       |> add_link_headers(:user_statuses, activities, params["id"])
 293       |> put_view(StatusView)
 294       |> render("index.json", %{
 295         activities: activities,
 296         for: reading_user,
 297         as: :activity
 298       })
 299     end
 300   end
 301
 302   def dm_timeline(%{assigns: %{user: user}} = conn, params) do
 303     params =
 304       params
 305       |> Map.put("type", "Create")
 306       |> Map.put("blocking_user", user)
 307       |> Map.put("user", user)
 308       |> Map.put(:visibility, "direct")
 309
 310     activities =
 311       [user.ap_id]
 312       |> ActivityPub.fetch_activities_query(params)
 313       |> Repo.all()
 314
 315     conn
 316     |> add_link_headers(:dm_timeline, activities)
 317     |> put_view(StatusView)
 318     |> render("index.json", %{activities: activities, for: user, as: :activity})
 319   end
 320
 321   def get_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 322     with %Activity{} = activity <- Activity.get_by_id(id),
 323          true <- Visibility.visible_for_user?(activity, user) do
 324       conn
 325       |> put_view(StatusView)
 326       |> try_render("status.json", %{activity: activity, for: user})
 327     end
 328   end
 329
 330   def get_context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 331     with %Activity{} = activity <- Activity.get_by_id(id),
 332          activities <-
 333            ActivityPub.fetch_activities_for_context(activity.data["context"], %{
 334              "blocking_user" => user,
 335              "user" => user
 336            }),
 337          activities <-
 338            activities |> Enum.filter(fn %{id: aid} -> to_string(aid) != to_string(id) end),
 339          activities <-
 340            activities |> Enum.filter(fn %{data: %{"type" => type}} -> type == "Create" end),
 341          grouped_activities <- Enum.group_by(activities, fn %{id: id} -> id < activity.id end) do
 342       result = %{
 343         ancestors:
 344           StatusView.render(
 345             "index.json",
 346             for: user,
 347             activities: grouped_activities[true] || [],
 348             as: :activity
 349           )
 350           |> Enum.reverse(),
 351         # credo:disable-for-previous-line Credo.Check.Refactor.PipeChainStart
 352         descendants:
 353           StatusView.render(
 354             "index.json",
 355             for: user,
 356             activities: grouped_activities[false] || [],
 357             as: :activity
 358           )
 359           |> Enum.reverse()
 360         # credo:disable-for-previous-line Credo.Check.Refactor.PipeChainStart
 361       }
 362
 363       json(conn, result)
 364     end
 365   end
 366
 367   def post_status(conn, %{"status" => "", "media_ids" => media_ids} = params)
 368       when length(media_ids) > 0 do
 369     params =
 370       params
 371       |> Map.put("status", ".")
 372
 373     post_status(conn, params)
 374   end
 375
 376   def post_status(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
 377     params =
 378       params
 379       |> Map.put("in_reply_to_status_id", params["in_reply_to_id"])
 380
 381     idempotency_key =
 382       case get_req_header(conn, "idempotency-key") do
 383         [key] -> key
 384         _ -> Ecto.UUID.generate()
 385       end
 386
 387     {:ok, activity} =
 388       Cachex.fetch!(:idempotency_cache, idempotency_key, fn _ -> CommonAPI.post(user, params) end)
 389
 390     conn
 391     |> put_view(StatusView)
 392     |> try_render("status.json", %{activity: activity, for: user, as: :activity})
 393   end
 394
 395   def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 396     with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
 397       json(conn, %{})
 398     else
 399       _e ->
 400         conn
 401         |> put_status(403)
 402         |> json(%{error: "Can't delete this post"})
 403     end
 404   end
 405
 406   def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 407     with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user) do
 408       conn
 409       |> put_view(StatusView)
 410       |> try_render("status.json", %{activity: announce, for: user, as: :activity})
 411     end
 412   end
 413
 414   def unreblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 415     with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
 416          %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
 417       conn
 418       |> put_view(StatusView)
 419       |> try_render("status.json", %{activity: activity, for: user, as: :activity})
 420     end
 421   end
 422
 423   def fav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 424     with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
 425          %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
 426       conn
 427       |> put_view(StatusView)
 428       |> try_render("status.json", %{activity: activity, for: user, as: :activity})
 429     end
 430   end
 431
 432   def unfav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 433     with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
 434          %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
 435       conn
 436       |> put_view(StatusView)
 437       |> try_render("status.json", %{activity: activity, for: user, as: :activity})
 438     end
 439   end
 440
 441   def pin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 442     with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
 443       conn
 444       |> put_view(StatusView)
 445       |> try_render("status.json", %{activity: activity, for: user, as: :activity})
 446     else
 447       {:error, reason} ->
 448         conn
 449         |> put_resp_content_type("application/json")
 450         |> send_resp(:bad_request, Jason.encode!(%{"error" => reason}))
 451     end
 452   end
 453
 454   def unpin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 455     with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
 456       conn
 457       |> put_view(StatusView)
 458       |> try_render("status.json", %{activity: activity, for: user, as: :activity})
 459     end
 460   end
 461
 462   def bookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 463     with %Activity{} = activity <- Activity.get_by_id(id),
 464          %User{} = user <- User.get_by_nickname(user.nickname),
 465          true <- Visibility.visible_for_user?(activity, user),
 466          {:ok, user} <- User.bookmark(user, activity.data["object"]["id"]) do
 467       conn
 468       |> put_view(StatusView)
 469       |> try_render("status.json", %{activity: activity, for: user, as: :activity})
 470     end
 471   end
 472
 473   def unbookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 474     with %Activity{} = activity <- Activity.get_by_id(id),
 475          %User{} = user <- User.get_by_nickname(user.nickname),
 476          true <- Visibility.visible_for_user?(activity, user),
 477          {:ok, user} <- User.unbookmark(user, activity.data["object"]["id"]) do
 478       conn
 479       |> put_view(StatusView)
 480       |> try_render("status.json", %{activity: activity, for: user, as: :activity})
 481     end
 482   end
 483
 484   def mute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 485     activity = Activity.get_by_id(id)
 486
 487     with {:ok, activity} <- CommonAPI.add_mute(user, activity) do
 488       conn
 489       |> put_view(StatusView)
 490       |> try_render("status.json", %{activity: activity, for: user, as: :activity})
 491     else
 492       {:error, reason} ->
 493         conn
 494         |> put_resp_content_type("application/json")
 495         |> send_resp(:bad_request, Jason.encode!(%{"error" => reason}))
 496     end
 497   end
 498
 499   def unmute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 500     activity = Activity.get_by_id(id)
 501
 502     with {:ok, activity} <- CommonAPI.remove_mute(user, activity) do
 503       conn
 504       |> put_view(StatusView)
 505       |> try_render("status.json", %{activity: activity, for: user, as: :activity})
 506     end
 507   end
 508
 509   def notifications(%{assigns: %{user: user}} = conn, params) do
 510     notifications = MastodonAPI.get_notifications(user, params)
 511
 512     conn
 513     |> add_link_headers(:notifications, notifications)
 514     |> put_view(NotificationView)
 515     |> render("index.json", %{notifications: notifications, for: user})
 516   end
 517
 518   def get_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
 519     with {:ok, notification} <- Notification.get(user, id) do
 520       conn
 521       |> put_view(NotificationView)
 522       |> render("show.json", %{notification: notification, for: user})
 523     else
 524       {:error, reason} ->
 525         conn
 526         |> put_resp_content_type("application/json")
 527         |> send_resp(403, Jason.encode!(%{"error" => reason}))
 528     end
 529   end
 530
 531   def clear_notifications(%{assigns: %{user: user}} = conn, _params) do
 532     Notification.clear(user)
 533     json(conn, %{})
 534   end
 535
 536   def dismiss_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
 537     with {:ok, _notif} <- Notification.dismiss(user, id) do
 538       json(conn, %{})
 539     else
 540       {:error, reason} ->
 541         conn
 542         |> put_resp_content_type("application/json")
 543         |> send_resp(403, Jason.encode!(%{"error" => reason}))
 544     end
 545   end
 546
 547   def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 548     id = List.wrap(id)
 549     q = from(u in User, where: u.id in ^id)
 550     targets = Repo.all(q)
 551
 552     conn
 553     |> put_view(AccountView)
 554     |> render("relationships.json", %{user: user, targets: targets})
 555   end
 556
 557   # Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array.
 558   def relationships(%{assigns: %{user: _user}} = conn, _), do: json(conn, [])
 559
 560   def update_media(%{assigns: %{user: user}} = conn, data) do
 561     with %Object{} = object <- Repo.get(Object, data["id"]),
 562          true <- Object.authorize_mutation(object, user),
 563          true <- is_binary(data["description"]),
 564          description <- data["description"] do
 565       new_data = %{object.data | "name" => description}
 566
 567       {:ok, _} =
 568         object
 569         |> Object.change(%{data: new_data})
 570         |> Repo.update()
 571
 572       attachment_data = Map.put(new_data, "id", object.id)
 573
 574       conn
 575       |> put_view(StatusView)
 576       |> render("attachment.json", %{attachment: attachment_data})
 577     end
 578   end
 579
 580   def upload(%{assigns: %{user: user}} = conn, %{"file" => file} = data) do
 581     with {:ok, object} <-
 582            ActivityPub.upload(
 583              file,
 584              actor: User.ap_id(user),
 585              description: Map.get(data, "description")
 586            ) do
 587       attachment_data = Map.put(object.data, "id", object.id)
 588
 589       conn
 590       |> put_view(StatusView)
 591       |> render("attachment.json", %{attachment: attachment_data})
 592     end
 593   end
 594
 595   def favourited_by(conn, %{"id" => id}) do
 596     with %Activity{data: %{"object" => %{"likes" => likes}}} <- Activity.get_by_id(id) do
 597       q = from(u in User, where: u.ap_id in ^likes)
 598       users = Repo.all(q)
 599
 600       conn
 601       |> put_view(AccountView)
 602       |> render(AccountView, "accounts.json", %{users: users, as: :user})
 603     else
 604       _ -> json(conn, [])
 605     end
 606   end
 607
 608   def reblogged_by(conn, %{"id" => id}) do
 609     with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Activity.get_by_id(id) do
 610       q = from(u in User, where: u.ap_id in ^announces)
 611       users = Repo.all(q)
 612
 613       conn
 614       |> put_view(AccountView)
 615       |> render("accounts.json", %{users: users, as: :user})
 616     else
 617       _ -> json(conn, [])
 618     end
 619   end
 620
 621   def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
 622     local_only = params["local"] in [true, "True", "true", "1"]
 623
 624     tags =
 625       [params["tag"], params["any"]]
 626       |> List.flatten()
 627       |> Enum.uniq()
 628       |> Enum.filter(& &1)
 629       |> Enum.map(&String.downcase(&1))
 630
 631     tag_all =
 632       params["all"] ||
 633         []
 634         |> Enum.map(&String.downcase(&1))
 635
 636     tag_reject =
 637       params["none"] ||
 638         []
 639         |> Enum.map(&String.downcase(&1))
 640
 641     activities =
 642       params
 643       |> Map.put("type", "Create")
 644       |> Map.put("local_only", local_only)
 645       |> Map.put("blocking_user", user)
 646       |> Map.put("muting_user", user)
 647       |> Map.put("tag", tags)
 648       |> Map.put("tag_all", tag_all)
 649       |> Map.put("tag_reject", tag_reject)
 650       |> ActivityPub.fetch_public_activities()
 651       |> Enum.reverse()
 652
 653     conn
 654     |> add_link_headers(:hashtag_timeline, activities, params["tag"], %{"local" => local_only})
 655     |> put_view(StatusView)
 656     |> render("index.json", %{activities: activities, for: user, as: :activity})
 657   end
 658
 659   def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
 660     with %User{} = user <- User.get_by_id(id),
 661          followers <- MastodonAPI.get_followers(user, params) do
 662       followers =
 663         cond do
 664           for_user && user.id == for_user.id -> followers
 665           user.info.hide_followers -> []
 666           true -> followers
 667         end
 668
 669       conn
 670       |> add_link_headers(:followers, followers, user)
 671       |> put_view(AccountView)
 672       |> render("accounts.json", %{users: followers, as: :user})
 673     end
 674   end
 675
 676   def following(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
 677     with %User{} = user <- User.get_by_id(id),
 678          followers <- MastodonAPI.get_friends(user, params) do
 679       followers =
 680         cond do
 681           for_user && user.id == for_user.id -> followers
 682           user.info.hide_follows -> []
 683           true -> followers
 684         end
 685
 686       conn
 687       |> add_link_headers(:following, followers, user)
 688       |> put_view(AccountView)
 689       |> render("accounts.json", %{users: followers, as: :user})
 690     end
 691   end
 692
 693   def follow_requests(%{assigns: %{user: followed}} = conn, _params) do
 694     with {:ok, follow_requests} <- User.get_follow_requests(followed) do
 695       conn
 696       |> put_view(AccountView)
 697       |> render("accounts.json", %{users: follow_requests, as: :user})
 698     end
 699   end
 700
 701   def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
 702     with %User{} = follower <- User.get_by_id(id),
 703          {:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do
 704       conn
 705       |> put_view(AccountView)
 706       |> render("relationship.json", %{user: followed, target: follower})
 707     else
 708       {:error, message} ->
 709         conn
 710         |> put_resp_content_type("application/json")
 711         |> send_resp(403, Jason.encode!(%{"error" => message}))
 712     end
 713   end
 714
 715   def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
 716     with %User{} = follower <- User.get_by_id(id),
 717          {:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
 718       conn
 719       |> put_view(AccountView)
 720       |> render("relationship.json", %{user: followed, target: follower})
 721     else
 722       {:error, message} ->
 723         conn
 724         |> put_resp_content_type("application/json")
 725         |> send_resp(403, Jason.encode!(%{"error" => message}))
 726     end
 727   end
 728
 729   def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
 730     with %User{} = followed <- User.get_by_id(id),
 731          false <- User.following?(follower, followed),
 732          {:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
 733       conn
 734       |> put_view(AccountView)
 735       |> render("relationship.json", %{user: follower, target: followed})
 736     else
 737       true ->
 738         followed = User.get_cached_by_id(id)
 739
 740         {:ok, follower} =
 741           case conn.params["reblogs"] do
 742             true -> CommonAPI.show_reblogs(follower, followed)
 743             false -> CommonAPI.hide_reblogs(follower, followed)
 744           end
 745
 746         conn
 747         |> put_view(AccountView)
 748         |> render("relationship.json", %{user: follower, target: followed})
 749
 750       {:error, message} ->
 751         conn
 752         |> put_resp_content_type("application/json")
 753         |> send_resp(403, Jason.encode!(%{"error" => message}))
 754     end
 755   end
 756
 757   def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
 758     with %User{} = followed <- User.get_by_nickname(uri),
 759          {:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
 760       conn
 761       |> put_view(AccountView)
 762       |> render("account.json", %{user: followed, for: follower})
 763     else
 764       {:error, message} ->
 765         conn
 766         |> put_resp_content_type("application/json")
 767         |> send_resp(403, Jason.encode!(%{"error" => message}))
 768     end
 769   end
 770
 771   def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
 772     with %User{} = followed <- User.get_by_id(id),
 773          {:ok, follower} <- CommonAPI.unfollow(follower, followed) do
 774       conn
 775       |> put_view(AccountView)
 776       |> render("relationship.json", %{user: follower, target: followed})
 777     end
 778   end
 779
 780   def mute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
 781     with %User{} = muted <- User.get_by_id(id),
 782          {:ok, muter} <- User.mute(muter, muted) do
 783       conn
 784       |> put_view(AccountView)
 785       |> render("relationship.json", %{user: muter, target: muted})
 786     else
 787       {:error, message} ->
 788         conn
 789         |> put_resp_content_type("application/json")
 790         |> send_resp(403, Jason.encode!(%{"error" => message}))
 791     end
 792   end
 793
 794   def unmute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
 795     with %User{} = muted <- User.get_by_id(id),
 796          {:ok, muter} <- User.unmute(muter, muted) do
 797       conn
 798       |> put_view(AccountView)
 799       |> render("relationship.json", %{user: muter, target: muted})
 800     else
 801       {:error, message} ->
 802         conn
 803         |> put_resp_content_type("application/json")
 804         |> send_resp(403, Jason.encode!(%{"error" => message}))
 805     end
 806   end
 807
 808   def mutes(%{assigns: %{user: user}} = conn, _) do
 809     with muted_accounts <- User.muted_users(user) do
 810       res = AccountView.render("accounts.json", users: muted_accounts, for: user, as: :user)
 811       json(conn, res)
 812     end
 813   end
 814
 815   def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
 816     with %User{} = blocked <- User.get_by_id(id),
 817          {:ok, blocker} <- User.block(blocker, blocked),
 818          {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
 819       conn
 820       |> put_view(AccountView)
 821       |> render("relationship.json", %{user: blocker, target: blocked})
 822     else
 823       {:error, message} ->
 824         conn
 825         |> put_resp_content_type("application/json")
 826         |> send_resp(403, Jason.encode!(%{"error" => message}))
 827     end
 828   end
 829
 830   def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
 831     with %User{} = blocked <- User.get_by_id(id),
 832          {:ok, blocker} <- User.unblock(blocker, blocked),
 833          {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
 834       conn
 835       |> put_view(AccountView)
 836       |> render("relationship.json", %{user: blocker, target: blocked})
 837     else
 838       {:error, message} ->
 839         conn
 840         |> put_resp_content_type("application/json")
 841         |> send_resp(403, Jason.encode!(%{"error" => message}))
 842     end
 843   end
 844
 845   def blocks(%{assigns: %{user: user}} = conn, _) do
 846     with blocked_accounts <- User.blocked_users(user) do
 847       res = AccountView.render("accounts.json", users: blocked_accounts, for: user, as: :user)
 848       json(conn, res)
 849     end
 850   end
 851
 852   def domain_blocks(%{assigns: %{user: %{info: info}}} = conn, _) do
 853     json(conn, info.domain_blocks || [])
 854   end
 855
 856   def block_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
 857     User.block_domain(blocker, domain)
 858     json(conn, %{})
 859   end
 860
 861   def unblock_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
 862     User.unblock_domain(blocker, domain)
 863     json(conn, %{})
 864   end
 865
 866   def status_search(user, query) do
 867     fetched =
 868       if Regex.match?(~r/https?:/, query) do
 869         with {:ok, object} <- ActivityPub.fetch_object_from_id(query),
 870              %Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
 871              true <- Visibility.visible_for_user?(activity, user) do
 872           [activity]
 873         else
 874           _e -> []
 875         end
 876       end || []
 877
 878     q =
 879       from(
 880         a in Activity,
 881         where: fragment("?->>'type' = 'Create'", a.data),
 882         where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
 883         where:
 884           fragment(
 885             "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
 886             a.data,
 887             ^query
 888           ),
 889         limit: 20,
 890         order_by: [desc: :id]
 891       )
 892
 893     Repo.all(q) ++ fetched
 894   end
 895
 896   def search2(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 897     accounts = User.search(query, resolve: params["resolve"] == "true", for_user: user)
 898
 899     statuses = status_search(user, query)
 900
 901     tags_path = Web.base_url() <> "/tag/"
 902
 903     tags =
 904       query
 905       |> String.split()
 906       |> Enum.uniq()
 907       |> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
 908       |> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
 909       |> Enum.map(fn tag -> %{name: tag, url: tags_path <> tag} end)
 910
 911     res = %{
 912       "accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
 913       "statuses" =>
 914         StatusView.render("index.json", activities: statuses, for: user, as: :activity),
 915       "hashtags" => tags
 916     }
 917
 918     json(conn, res)
 919   end
 920
 921   def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 922     accounts = User.search(query, resolve: params["resolve"] == "true", for_user: user)
 923
 924     statuses = status_search(user, query)
 925
 926     tags =
 927       query
 928       |> String.split()
 929       |> Enum.uniq()
 930       |> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
 931       |> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
 932
 933     res = %{
 934       "accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
 935       "statuses" =>
 936         StatusView.render("index.json", activities: statuses, for: user, as: :activity),
 937       "hashtags" => tags
 938     }
 939
 940     json(conn, res)
 941   end
 942
 943   def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 944     accounts = User.search(query, resolve: params["resolve"] == "true", for_user: user)
 945
 946     res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
 947
 948     json(conn, res)
 949   end
 950
 951   def favourites(%{assigns: %{user: user}} = conn, params) do
 952     params =
 953       params
 954       |> Map.put("type", "Create")
 955       |> Map.put("favorited_by", user.ap_id)
 956       |> Map.put("blocking_user", user)
 957
 958     activities =
 959       ActivityPub.fetch_activities([], params)
 960       |> Enum.reverse()
 961
 962     conn
 963     |> add_link_headers(:favourites, activities)
 964     |> put_view(StatusView)
 965     |> render("index.json", %{activities: activities, for: user, as: :activity})
 966   end
 967
 968   def bookmarks(%{assigns: %{user: user}} = conn, _) do
 969     user = User.get_by_id(user.id)
 970
 971     activities =
 972       user.bookmarks
 973       |> Enum.map(fn id -> Activity.get_create_by_object_ap_id(id) end)
 974       |> Enum.reverse()
 975
 976     conn
 977     |> put_view(StatusView)
 978     |> render("index.json", %{activities: activities, for: user, as: :activity})
 979   end
 980
 981   def get_lists(%{assigns: %{user: user}} = conn, opts) do
 982     lists = Pleroma.List.for_user(user, opts)
 983     res = ListView.render("lists.json", lists: lists)
 984     json(conn, res)
 985   end
 986
 987   def get_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 988     with %Pleroma.List{} = list <- Pleroma.List.get(id, user) do
 989       res = ListView.render("list.json", list: list)
 990       json(conn, res)
 991     else
 992       _e ->
 993         conn
 994         |> put_status(404)
 995         |> json(%{error: "Record not found"})
 996     end
 997   end
 998
 999   def account_lists(%{assigns: %{user: user}} = conn, %{"id" => account_id}) do
1000     lists = Pleroma.List.get_lists_account_belongs(user, account_id)
1001     res = ListView.render("lists.json", lists: lists)
1002     json(conn, res)
1003   end
1004
1005   def delete_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
1006     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
1007          {:ok, _list} <- Pleroma.List.delete(list) do
1008       json(conn, %{})
1009     else
1010       _e ->
1011         json(conn, "error")
1012     end
1013   end
1014
1015   def create_list(%{assigns: %{user: user}} = conn, %{"title" => title}) do
1016     with {:ok, %Pleroma.List{} = list} <- Pleroma.List.create(title, user) do
1017       res = ListView.render("list.json", list: list)
1018       json(conn, res)
1019     end
1020   end
1021
1022   def add_to_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
1023     accounts
1024     |> Enum.each(fn account_id ->
1025       with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
1026            %User{} = followed <- User.get_by_id(account_id) do
1027         Pleroma.List.follow(list, followed)
1028       end
1029     end)
1030
1031     json(conn, %{})
1032   end
1033
1034   def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
1035     accounts
1036     |> Enum.each(fn account_id ->
1037       with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
1038            %User{} = followed <- Pleroma.User.get_by_id(account_id) do
1039         Pleroma.List.unfollow(list, followed)
1040       end
1041     end)
1042
1043     json(conn, %{})
1044   end
1045
1046   def list_accounts(%{assigns: %{user: user}} = conn, %{"id" => id}) do
1047     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
1048          {:ok, users} = Pleroma.List.get_following(list) do
1049       conn
1050       |> put_view(AccountView)
1051       |> render("accounts.json", %{users: users, as: :user})
1052     end
1053   end
1054
1055   def rename_list(%{assigns: %{user: user}} = conn, %{"id" => id, "title" => title}) do
1056     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
1057          {:ok, list} <- Pleroma.List.rename(list, title) do
1058       res = ListView.render("list.json", list: list)
1059       json(conn, res)
1060     else
1061       _e ->
1062         json(conn, "error")
1063     end
1064   end
1065
1066   def list_timeline(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params) do
1067     with %Pleroma.List{title: _title, following: following} <- Pleroma.List.get(id, user) do
1068       params =
1069         params
1070         |> Map.put("type", "Create")
1071         |> Map.put("blocking_user", user)
1072         |> Map.put("muting_user", user)
1073
1074       # we must filter the following list for the user to avoid leaking statuses the user
1075       # does not actually have permission to see (for more info, peruse security issue #270).
1076       activities =
1077         following
1078         |> Enum.filter(fn x -> x in user.following end)
1079         |> ActivityPub.fetch_activities_bounded(following, params)
1080         |> Enum.reverse()
1081
1082       conn
1083       |> put_view(StatusView)
1084       |> render("index.json", %{activities: activities, for: user, as: :activity})
1085     else
1086       _e ->
1087         conn
1088         |> put_status(403)
1089         |> json(%{error: "Error."})
1090     end
1091   end
1092
1093   def index(%{assigns: %{user: user}} = conn, _params) do
1094     token =
1095       conn
1096       |> get_session(:oauth_token)
1097
1098     if user && token do
1099       mastodon_emoji = mastodonized_emoji()
1100
1101       limit = Config.get([:instance, :limit])
1102
1103       accounts =
1104         Map.put(%{}, user.id, AccountView.render("account.json", %{user: user, for: user}))
1105
1106       flavour = get_user_flavour(user)
1107
1108       initial_state =
1109         %{
1110           meta: %{
1111             streaming_api_base_url:
1112               String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws"),
1113             access_token: token,
1114             locale: "en",
1115             domain: Pleroma.Web.Endpoint.host(),
1116             admin: "1",
1117             me: "#{user.id}",
1118             unfollow_modal: false,
1119             boost_modal: false,
1120             delete_modal: true,
1121             auto_play_gif: false,
1122             display_sensitive_media: false,
1123             reduce_motion: false,
1124             max_toot_chars: limit,
1125             mascot: "/images/pleroma-fox-tan-smol.png"
1126           },
1127           rights: %{
1128             delete_others_notice: present?(user.info.is_moderator),
1129             admin: present?(user.info.is_admin)
1130           },
1131           compose: %{
1132             me: "#{user.id}",
1133             default_privacy: user.info.default_scope,
1134             default_sensitive: false,
1135             allow_content_types: Config.get([:instance, :allowed_post_formats])
1136           },
1137           media_attachments: %{
1138             accept_content_types: [
1139               ".jpg",
1140               ".jpeg",
1141               ".png",
1142               ".gif",
1143               ".webm",
1144               ".mp4",
1145               ".m4v",
1146               "image\/jpeg",
1147               "image\/png",
1148               "image\/gif",
1149               "video\/webm",
1150               "video\/mp4"
1151             ]
1152           },
1153           settings:
1154             user.info.settings ||
1155               %{
1156                 onboarded: true,
1157                 home: %{
1158                   shows: %{
1159                     reblog: true,
1160                     reply: true
1161                   }
1162                 },
1163                 notifications: %{
1164                   alerts: %{
1165                     follow: true,
1166                     favourite: true,
1167                     reblog: true,
1168                     mention: true
1169                   },
1170                   shows: %{
1171                     follow: true,
1172                     favourite: true,
1173                     reblog: true,
1174                     mention: true
1175                   },
1176                   sounds: %{
1177                     follow: true,
1178                     favourite: true,
1179                     reblog: true,
1180                     mention: true
1181                   }
1182                 }
1183               },
1184           push_subscription: nil,
1185           accounts: accounts,
1186           custom_emojis: mastodon_emoji,
1187           char_limit: limit
1188         }
1189         |> Jason.encode!()
1190
1191       conn
1192       |> put_layout(false)
1193       |> put_view(MastodonView)
1194       |> render("index.html", %{initial_state: initial_state, flavour: flavour})
1195     else
1196       conn
1197       |> redirect(to: "/web/login")
1198     end
1199   end
1200
1201   def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
1202     info_cng = User.Info.mastodon_settings_update(user.info, settings)
1203
1204     with changeset <- Ecto.Changeset.change(user),
1205          changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
1206          {:ok, _user} <- User.update_and_set_cache(changeset) do
1207       json(conn, %{})
1208     else
1209       e ->
1210         conn
1211         |> put_resp_content_type("application/json")
1212         |> send_resp(500, Jason.encode!(%{"error" => inspect(e)}))
1213     end
1214   end
1215
1216   @supported_flavours ["glitch", "vanilla"]
1217
1218   def set_flavour(%{assigns: %{user: user}} = conn, %{"flavour" => flavour} = _params)
1219       when flavour in @supported_flavours do
1220     flavour_cng = User.Info.mastodon_flavour_update(user.info, flavour)
1221
1222     with changeset <- Ecto.Changeset.change(user),
1223          changeset <- Ecto.Changeset.put_embed(changeset, :info, flavour_cng),
1224          {:ok, user} <- User.update_and_set_cache(changeset),
1225          flavour <- user.info.flavour do
1226       json(conn, flavour)
1227     else
1228       e ->
1229         conn
1230         |> put_resp_content_type("application/json")
1231         |> send_resp(500, Jason.encode!(%{"error" => inspect(e)}))
1232     end
1233   end
1234
1235   def set_flavour(conn, _params) do
1236     conn
1237     |> put_status(400)
1238     |> json(%{error: "Unsupported flavour"})
1239   end
1240
1241   def get_flavour(%{assigns: %{user: user}} = conn, _params) do
1242     json(conn, get_user_flavour(user))
1243   end
1244
1245   defp get_user_flavour(%User{info: %{flavour: flavour}}) when flavour in @supported_flavours do
1246     flavour
1247   end
1248
1249   defp get_user_flavour(_) do
1250     "glitch"
1251   end
1252
1253   def login(%{assigns: %{user: %User{}}} = conn, _params) do
1254     redirect(conn, to: local_mastodon_root_path(conn))
1255   end
1256
1257   @doc "Local Mastodon FE login init action"
1258   def login(conn, %{"code" => auth_token}) do
1259     with {:ok, app} <- get_or_make_app(),
1260          %Authorization{} = auth <- Repo.get_by(Authorization, token: auth_token, app_id: app.id),
1261          {:ok, token} <- Token.exchange_token(app, auth) do
1262       conn
1263       |> put_session(:oauth_token, token.token)
1264       |> redirect(to: local_mastodon_root_path(conn))
1265     end
1266   end
1267
1268   @doc "Local Mastodon FE callback action"
1269   def login(conn, _) do
1270     with {:ok, app} <- get_or_make_app() do
1271       path =
1272         o_auth_path(
1273           conn,
1274           :authorize,
1275           response_type: "code",
1276           client_id: app.client_id,
1277           redirect_uri: ".",
1278           scope: Enum.join(app.scopes, " ")
1279         )
1280
1281       conn
1282       |> redirect(to: path)
1283     end
1284   end
1285
1286   defp local_mastodon_root_path(conn), do: mastodon_api_path(conn, :index, ["getting-started"])
1287
1288   defp get_or_make_app do
1289     find_attrs = %{client_name: @local_mastodon_name, redirect_uris: "."}
1290     scopes = ["read", "write", "follow", "push"]
1291
1292     with %App{} = app <- Repo.get_by(App, find_attrs) do
1293       {:ok, app} =
1294         if app.scopes == scopes do
1295           {:ok, app}
1296         else
1297           app
1298           |> Ecto.Changeset.change(%{scopes: scopes})
1299           |> Repo.update()
1300         end
1301
1302       {:ok, app}
1303     else
1304       _e ->
1305         cs =
1306           App.register_changeset(
1307             %App{},
1308             Map.put(find_attrs, :scopes, scopes)
1309           )
1310
1311         Repo.insert(cs)
1312     end
1313   end
1314
1315   def logout(conn, _) do
1316     conn
1317     |> clear_session
1318     |> redirect(to: "/")
1319   end
1320
1321   def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
1322     Logger.debug("Unimplemented, returning unmodified relationship")
1323
1324     with %User{} = target <- User.get_by_id(id) do
1325       conn
1326       |> put_view(AccountView)
1327       |> render("relationship.json", %{user: user, target: target})
1328     end
1329   end
1330
1331   def empty_array(conn, _) do
1332     Logger.debug("Unimplemented, returning an empty array")
1333     json(conn, [])
1334   end
1335
1336   def empty_object(conn, _) do
1337     Logger.debug("Unimplemented, returning an empty object")
1338     json(conn, %{})
1339   end
1340
1341   def get_filters(%{assigns: %{user: user}} = conn, _) do
1342     filters = Filter.get_filters(user)
1343     res = FilterView.render("filters.json", filters: filters)
1344     json(conn, res)
1345   end
1346
1347   def create_filter(
1348         %{assigns: %{user: user}} = conn,
1349         %{"phrase" => phrase, "context" => context} = params
1350       ) do
1351     query = %Filter{
1352       user_id: user.id,
1353       phrase: phrase,
1354       context: context,
1355       hide: Map.get(params, "irreversible", nil),
1356       whole_word: Map.get(params, "boolean", true)
1357       # expires_at
1358     }
1359
1360     {:ok, response} = Filter.create(query)
1361     res = FilterView.render("filter.json", filter: response)
1362     json(conn, res)
1363   end
1364
1365   def get_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
1366     filter = Filter.get(filter_id, user)
1367     res = FilterView.render("filter.json", filter: filter)
1368     json(conn, res)
1369   end
1370
1371   def update_filter(
1372         %{assigns: %{user: user}} = conn,
1373         %{"phrase" => phrase, "context" => context, "id" => filter_id} = params
1374       ) do
1375     query = %Filter{
1376       user_id: user.id,
1377       filter_id: filter_id,
1378       phrase: phrase,
1379       context: context,
1380       hide: Map.get(params, "irreversible", nil),
1381       whole_word: Map.get(params, "boolean", true)
1382       # expires_at
1383     }
1384
1385     {:ok, response} = Filter.update(query)
1386     res = FilterView.render("filter.json", filter: response)
1387     json(conn, res)
1388   end
1389
1390   def delete_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
1391     query = %Filter{
1392       user_id: user.id,
1393       filter_id: filter_id
1394     }
1395
1396     {:ok, _} = Filter.delete(query)
1397     json(conn, %{})
1398   end
1399
1400   # fallback action
1401   #
1402   def errors(conn, _) do
1403     conn
1404     |> put_status(500)
1405     |> json("Something went wrong")
1406   end
1407
1408   def suggestions(%{assigns: %{user: user}} = conn, _) do
1409     suggestions = Config.get(:suggestions)
1410
1411     if Keyword.get(suggestions, :enabled, false) do
1412       api = Keyword.get(suggestions, :third_party_engine, "")
1413       timeout = Keyword.get(suggestions, :timeout, 5000)
1414       limit = Keyword.get(suggestions, :limit, 23)
1415
1416       host = Config.get([Pleroma.Web.Endpoint, :url, :host])
1417
1418       user = user.nickname
1419
1420       url =
1421         api
1422         |> String.replace("{{host}}", host)
1423         |> String.replace("{{user}}", user)
1424
1425       with {:ok, %{status: 200, body: body}} <-
1426              @httpoison.get(
1427                url,
1428                [],
1429                adapter: [
1430                  recv_timeout: timeout,
1431                  pool: :default
1432                ]
1433              ),
1434            {:ok, data} <- Jason.decode(body) do
1435         data =
1436           data
1437           |> Enum.slice(0, limit)
1438           |> Enum.map(fn x ->
1439             Map.put(
1440               x,
1441               "id",
1442               case User.get_or_fetch(x["acct"]) do
1443                 %{id: id} -> id
1444                 _ -> 0
1445               end
1446             )
1447           end)
1448           |> Enum.map(fn x ->
1449             Map.put(x, "avatar", MediaProxy.url(x["avatar"]))
1450           end)
1451           |> Enum.map(fn x ->
1452             Map.put(x, "avatar_static", MediaProxy.url(x["avatar_static"]))
1453           end)
1454
1455         conn
1456         |> json(data)
1457       else
1458         e -> Logger.error("Could not retrieve suggestions at fetch #{url}, #{inspect(e)}")
1459       end
1460     else
1461       json(conn, [])
1462     end
1463   end
1464
1465   def status_card(%{assigns: %{user: user}} = conn, %{"id" => status_id}) do
1466     with %Activity{} = activity <- Activity.get_by_id(status_id),
1467          true <- Visibility.visible_for_user?(activity, user) do
1468       data =
1469         StatusView.render(
1470           "card.json",
1471           Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
1472         )
1473
1474       json(conn, data)
1475     else
1476       _e ->
1477         %{}
1478     end
1479   end
1480
1481   def reports(%{assigns: %{user: user}} = conn, params) do
1482     case CommonAPI.report(user, params) do
1483       {:ok, activity} ->
1484         conn
1485         |> put_view(ReportView)
1486         |> try_render("report.json", %{activity: activity})
1487
1488       {:error, err} ->
1489         conn
1490         |> put_status(:bad_request)
1491         |> json(%{error: err})
1492     end
1493   end
1494
1495   def try_render(conn, target, params)
1496       when is_binary(target) do
1497     res = render(conn, target, params)
1498
1499     if res == nil do
1500       conn
1501       |> put_status(501)
1502       |> json(%{error: "Can't display this activity"})
1503     else
1504       res
1505     end
1506   end
1507
1508   def try_render(conn, _, _) do
1509     conn
1510     |> put_status(501)
1511     |> json(%{error: "Can't display this activity"})
1512   end
1513
1514   defp present?(nil), do: false
1515   defp present?(false), do: false
1516   defp present?(_), do: true
1517 end