git.squeep.com Git - akkoma/blob - lib/pleroma/web/mastodon_api/mastodon_api_controller.ex

   1 defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
   2   use Pleroma.Web, :controller
   3   alias Pleroma.{Repo, Object, Activity, User, Notification, Stats}
   4   alias Pleroma.Web
   5   alias Pleroma.Web.MastodonAPI.{StatusView, AccountView, MastodonView, ListView, FilterView}
   6   alias Pleroma.Web.ActivityPub.ActivityPub
   7   alias Pleroma.Web.ActivityPub.Utils
   8   alias Pleroma.Web.CommonAPI
   9   alias Pleroma.Web.OAuth.{Authorization, Token, App}
  10   alias Pleroma.Web.MediaProxy
  11   alias Comeonin.Pbkdf2
  12   import Ecto.Query
  13   require Logger
  14
  15   @httpoison Application.get_env(:pleroma, :httpoison)
  16
  17   action_fallback(:errors)
  18
  19   def create_app(conn, params) do
  20     with cs <- App.register_changeset(%App{}, params) |> IO.inspect(),
  21          {:ok, app} <- Repo.insert(cs) |> IO.inspect() do
  22       res = %{
  23         id: app.id |> to_string,
  24         name: app.client_name,
  25         client_id: app.client_id,
  26         client_secret: app.client_secret,
  27         redirect_uri: app.redirect_uris,
  28         website: app.website
  29       }
  30
  31       json(conn, res)
  32     end
  33   end
  34
  35   defp add_if_present(
  36          map,
  37          params,
  38          params_field,
  39          map_field,
  40          value_function \\ fn x -> {:ok, x} end
  41        ) do
  42     if Map.has_key?(params, params_field) do
  43       case value_function.(params[params_field]) do
  44         {:ok, new_value} -> Map.put(map, map_field, new_value)
  45         :error -> map
  46       end
  47     else
  48       map
  49     end
  50   end
  51
  52   def update_credentials(%{assigns: %{user: user}} = conn, params) do
  53     original_user = user
  54
  55     user_params =
  56       %{}
  57       |> add_if_present(params, "display_name", :name)
  58       |> add_if_present(params, "note", :bio)
  59       |> add_if_present(params, "avatar", :avatar, fn value ->
  60         with %Plug.Upload{} <- value,
  61              {:ok, object} <- ActivityPub.upload(value, type: :avatar) do
  62           {:ok, object.data}
  63         else
  64           _ -> :error
  65         end
  66       end)
  67
  68     info_params =
  69       %{}
  70       |> add_if_present(params, "locked", :locked, fn value -> {:ok, value == "true"} end)
  71       |> add_if_present(params, "header", :banner, fn value ->
  72         with %Plug.Upload{} <- value,
  73              {:ok, object} <- ActivityPub.upload(value, type: :banner) do
  74           {:ok, object.data}
  75         else
  76           _ -> :error
  77         end
  78       end)
  79
  80     info_cng = User.Info.mastodon_profile_update(user.info, info_params)
  81
  82     with changeset <- User.update_changeset(user, user_params),
  83          changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
  84          {:ok, user} <- User.update_and_set_cache(changeset) do
  85       if original_user != user do
  86         CommonAPI.update(user)
  87       end
  88
  89       json(conn, AccountView.render("account.json", %{user: user, for: user}))
  90     else
  91       _e ->
  92         conn
  93         |> put_status(403)
  94         |> json(%{error: "Invalid request"})
  95     end
  96   end
  97
  98   def verify_credentials(%{assigns: %{user: user}} = conn, _) do
  99     account = AccountView.render("account.json", %{user: user, for: user})
 100     json(conn, account)
 101   end
 102
 103   def user(%{assigns: %{user: for_user}} = conn, %{"id" => id}) do
 104     with %User{} = user <- Repo.get(User, id) do
 105       account = AccountView.render("account.json", %{user: user, for: for_user})
 106       json(conn, account)
 107     else
 108       _e ->
 109         conn
 110         |> put_status(404)
 111         |> json(%{error: "Can't find user"})
 112     end
 113   end
 114
 115   @mastodon_api_level "2.5.0"
 116
 117   def masto_instance(conn, _params) do
 118     instance = Pleroma.Config.get(:instance)
 119
 120     response = %{
 121       uri: Web.base_url(),
 122       title: Keyword.get(instance, :name),
 123       description: Keyword.get(instance, :description),
 124       version: "#{@mastodon_api_level} (compatible; #{Pleroma.Application.named_version()})",
 125       email: Keyword.get(instance, :email),
 126       urls: %{
 127         streaming_api: String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws")
 128       },
 129       stats: Stats.get_stats(),
 130       thumbnail: Web.base_url() <> "/instance/thumbnail.jpeg",
 131       max_toot_chars: Keyword.get(instance, :limit)
 132     }
 133
 134     json(conn, response)
 135   end
 136
 137   def peers(conn, _params) do
 138     json(conn, Stats.get_peers())
 139   end
 140
 141   defp mastodonized_emoji do
 142     Pleroma.Emoji.get_all()
 143     |> Enum.map(fn {shortcode, relative_url} ->
 144       url = to_string(URI.merge(Web.base_url(), relative_url))
 145
 146       %{
 147         "shortcode" => shortcode,
 148         "static_url" => url,
 149         "visible_in_picker" => true,
 150         "url" => url
 151       }
 152     end)
 153   end
 154
 155   def custom_emojis(conn, _params) do
 156     mastodon_emoji = mastodonized_emoji()
 157     json(conn, mastodon_emoji)
 158   end
 159
 160   defp add_link_headers(conn, method, activities, param \\ nil, params \\ %{}) do
 161     last = List.last(activities)
 162     first = List.first(activities)
 163
 164     if last do
 165       min = last.id
 166       max = first.id
 167
 168       {next_url, prev_url} =
 169         if param do
 170           {
 171             mastodon_api_url(
 172               Pleroma.Web.Endpoint,
 173               method,
 174               param,
 175               Map.merge(params, %{max_id: min})
 176             ),
 177             mastodon_api_url(
 178               Pleroma.Web.Endpoint,
 179               method,
 180               param,
 181               Map.merge(params, %{since_id: max})
 182             )
 183           }
 184         else
 185           {
 186             mastodon_api_url(
 187               Pleroma.Web.Endpoint,
 188               method,
 189               Map.merge(params, %{max_id: min})
 190             ),
 191             mastodon_api_url(
 192               Pleroma.Web.Endpoint,
 193               method,
 194               Map.merge(params, %{since_id: max})
 195             )
 196           }
 197         end
 198
 199       conn
 200       |> put_resp_header("link", "<#{next_url}>; rel=\"next\", <#{prev_url}>; rel=\"prev\"")
 201     else
 202       conn
 203     end
 204   end
 205
 206   def home_timeline(%{assigns: %{user: user}} = conn, params) do
 207     params =
 208       params
 209       |> Map.put("type", ["Create", "Announce"])
 210       |> Map.put("blocking_user", user)
 211       |> Map.put("user", user)
 212
 213     activities =
 214       ActivityPub.fetch_activities([user.ap_id | user.following], params)
 215       |> ActivityPub.contain_timeline(user)
 216       |> Enum.reverse()
 217
 218     conn
 219     |> add_link_headers(:home_timeline, activities)
 220     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 221   end
 222
 223   def public_timeline(%{assigns: %{user: user}} = conn, params) do
 224     local_only = params["local"] in [true, "True", "true", "1"]
 225
 226     params =
 227       params
 228       |> Map.put("type", ["Create", "Announce"])
 229       |> Map.put("local_only", local_only)
 230       |> Map.put("blocking_user", user)
 231
 232     activities =
 233       ActivityPub.fetch_public_activities(params)
 234       |> Enum.reverse()
 235
 236     conn
 237     |> add_link_headers(:public_timeline, activities, false, %{"local" => local_only})
 238     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 239   end
 240
 241   def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
 242     with %User{} = user <- Repo.get(User, params["id"]) do
 243       # Since Pleroma has no "pinned" posts feature, we'll just set an empty list here
 244       activities =
 245         if params["pinned"] == "true" do
 246           []
 247         else
 248           ActivityPub.fetch_user_activities(user, reading_user, params)
 249         end
 250
 251       conn
 252       |> add_link_headers(:user_statuses, activities, params["id"])
 253       |> render(StatusView, "index.json", %{
 254         activities: activities,
 255         for: reading_user,
 256         as: :activity
 257       })
 258     end
 259   end
 260
 261   def dm_timeline(%{assigns: %{user: user}} = conn, params) do
 262     query =
 263       ActivityPub.fetch_activities_query(
 264         [user.ap_id],
 265         Map.merge(params, %{"type" => "Create", visibility: "direct"})
 266       )
 267
 268     activities = Repo.all(query)
 269
 270     conn
 271     |> add_link_headers(:dm_timeline, activities)
 272     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 273   end
 274
 275   def get_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 276     with %Activity{} = activity <- Repo.get(Activity, id),
 277          true <- ActivityPub.visible_for_user?(activity, user) do
 278       try_render(conn, StatusView, "status.json", %{activity: activity, for: user})
 279     end
 280   end
 281
 282   def get_context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 283     with %Activity{} = activity <- Repo.get(Activity, id),
 284          activities <-
 285            ActivityPub.fetch_activities_for_context(activity.data["context"], %{
 286              "blocking_user" => user,
 287              "user" => user
 288            }),
 289          activities <-
 290            activities |> Enum.filter(fn %{id: aid} -> to_string(aid) != to_string(id) end),
 291          activities <-
 292            activities |> Enum.filter(fn %{data: %{"type" => type}} -> type == "Create" end),
 293          grouped_activities <- Enum.group_by(activities, fn %{id: id} -> id < activity.id end) do
 294       result = %{
 295         ancestors:
 296           StatusView.render(
 297             "index.json",
 298             for: user,
 299             activities: grouped_activities[true] || [],
 300             as: :activity
 301           )
 302           |> Enum.reverse(),
 303         descendants:
 304           StatusView.render(
 305             "index.json",
 306             for: user,
 307             activities: grouped_activities[false] || [],
 308             as: :activity
 309           )
 310           |> Enum.reverse()
 311       }
 312
 313       json(conn, result)
 314     end
 315   end
 316
 317   def post_status(conn, %{"status" => "", "media_ids" => media_ids} = params)
 318       when length(media_ids) > 0 do
 319     params =
 320       params
 321       |> Map.put("status", ".")
 322
 323     post_status(conn, params)
 324   end
 325
 326   def post_status(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
 327     params =
 328       params
 329       |> Map.put("in_reply_to_status_id", params["in_reply_to_id"])
 330       |> Map.put("no_attachment_links", true)
 331
 332     idempotency_key =
 333       case get_req_header(conn, "idempotency-key") do
 334         [key] -> key
 335         _ -> Ecto.UUID.generate()
 336       end
 337
 338     {:ok, activity} =
 339       Cachex.fetch!(:idempotency_cache, idempotency_key, fn _ -> CommonAPI.post(user, params) end)
 340
 341     try_render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 342   end
 343
 344   def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 345     with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
 346       json(conn, %{})
 347     else
 348       _e ->
 349         conn
 350         |> put_status(403)
 351         |> json(%{error: "Can't delete this post"})
 352     end
 353   end
 354
 355   def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 356     with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user) do
 357       try_render(conn, StatusView, "status.json", %{activity: announce, for: user, as: :activity})
 358     end
 359   end
 360
 361   def unreblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 362     with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
 363          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
 364       try_render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 365     end
 366   end
 367
 368   def fav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 369     with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
 370          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
 371       try_render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 372     end
 373   end
 374
 375   def unfav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 376     with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
 377          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
 378       try_render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 379     end
 380   end
 381
 382   def notifications(%{assigns: %{user: user}} = conn, params) do
 383     notifications = Notification.for_user(user, params)
 384
 385     result =
 386       Enum.map(notifications, fn x ->
 387         render_notification(user, x)
 388       end)
 389       |> Enum.filter(& &1)
 390
 391     conn
 392     |> add_link_headers(:notifications, notifications)
 393     |> json(result)
 394   end
 395
 396   def get_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
 397     with {:ok, notification} <- Notification.get(user, id) do
 398       json(conn, render_notification(user, notification))
 399     else
 400       {:error, reason} ->
 401         conn
 402         |> put_resp_content_type("application/json")
 403         |> send_resp(403, Jason.encode!(%{"error" => reason}))
 404     end
 405   end
 406
 407   def clear_notifications(%{assigns: %{user: user}} = conn, _params) do
 408     Notification.clear(user)
 409     json(conn, %{})
 410   end
 411
 412   def dismiss_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
 413     with {:ok, _notif} <- Notification.dismiss(user, id) do
 414       json(conn, %{})
 415     else
 416       {:error, reason} ->
 417         conn
 418         |> put_resp_content_type("application/json")
 419         |> send_resp(403, Jason.encode!(%{"error" => reason}))
 420     end
 421   end
 422
 423   def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 424     id = List.wrap(id)
 425     q = from(u in User, where: u.id in ^id)
 426     targets = Repo.all(q)
 427     render(conn, AccountView, "relationships.json", %{user: user, targets: targets})
 428   end
 429
 430   # Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array.
 431   def relationships(%{assigns: %{user: user}} = conn, _) do
 432     conn
 433     |> json([])
 434   end
 435
 436   def update_media(%{assigns: %{user: _}} = conn, data) do
 437     with %Object{} = object <- Repo.get(Object, data["id"]),
 438          true <- is_binary(data["description"]),
 439          description <- data["description"] do
 440       new_data = %{object.data | "name" => description}
 441
 442       change = Object.change(object, %{data: new_data})
 443       {:ok, _} = Repo.update(change)
 444
 445       data =
 446         new_data
 447         |> Map.put("id", object.id)
 448
 449       render(conn, StatusView, "attachment.json", %{attachment: data})
 450     end
 451   end
 452
 453   def upload(%{assigns: %{user: _}} = conn, %{"file" => file} = data) do
 454     with {:ok, object} <- ActivityPub.upload(file, description: Map.get(data, "description")) do
 455       change = Object.change(object, %{data: object.data})
 456       {:ok, object} = Repo.update(change)
 457
 458       objdata =
 459         object.data
 460         |> Map.put("id", object.id)
 461
 462       render(conn, StatusView, "attachment.json", %{attachment: objdata})
 463     end
 464   end
 465
 466   def favourited_by(conn, %{"id" => id}) do
 467     with %Activity{data: %{"object" => %{"likes" => likes}}} <- Repo.get(Activity, id) do
 468       q = from(u in User, where: u.ap_id in ^likes)
 469       users = Repo.all(q)
 470       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 471     else
 472       _ -> json(conn, [])
 473     end
 474   end
 475
 476   def reblogged_by(conn, %{"id" => id}) do
 477     with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Repo.get(Activity, id) do
 478       q = from(u in User, where: u.ap_id in ^announces)
 479       users = Repo.all(q)
 480       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 481     else
 482       _ -> json(conn, [])
 483     end
 484   end
 485
 486   def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
 487     local_only = params["local"] in [true, "True", "true", "1"]
 488
 489     params =
 490       params
 491       |> Map.put("type", "Create")
 492       |> Map.put("local_only", local_only)
 493       |> Map.put("blocking_user", user)
 494       |> Map.put("tag", String.downcase(params["tag"]))
 495
 496     activities =
 497       ActivityPub.fetch_public_activities(params)
 498       |> Enum.reverse()
 499
 500     conn
 501     |> add_link_headers(:hashtag_timeline, activities, params["tag"], %{"local" => local_only})
 502     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 503   end
 504
 505   # TODO: Pagination
 506   def followers(conn, %{"id" => id}) do
 507     with %User{} = user <- Repo.get(User, id),
 508          {:ok, followers} <- User.get_followers(user) do
 509       render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
 510     end
 511   end
 512
 513   def following(conn, %{"id" => id}) do
 514     with %User{} = user <- Repo.get(User, id),
 515          {:ok, followers} <- User.get_friends(user) do
 516       render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
 517     end
 518   end
 519
 520   def follow_requests(%{assigns: %{user: followed}} = conn, _params) do
 521     with {:ok, follow_requests} <- User.get_follow_requests(followed) do
 522       render(conn, AccountView, "accounts.json", %{users: follow_requests, as: :user})
 523     end
 524   end
 525
 526   def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
 527     with %User{} = follower <- Repo.get(User, id),
 528          {:ok, follower} <- User.maybe_follow(follower, followed),
 529          %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
 530          {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
 531          {:ok, _activity} <-
 532            ActivityPub.accept(%{
 533              to: [follower.ap_id],
 534              actor: followed.ap_id,
 535              object: follow_activity.data["id"],
 536              type: "Accept"
 537            }) do
 538       render(conn, AccountView, "relationship.json", %{user: followed, target: follower})
 539     else
 540       {:error, message} ->
 541         conn
 542         |> put_resp_content_type("application/json")
 543         |> send_resp(403, Jason.encode!(%{"error" => message}))
 544     end
 545   end
 546
 547   def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
 548     with %User{} = follower <- Repo.get(User, id),
 549          %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
 550          {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
 551          {:ok, _activity} <-
 552            ActivityPub.reject(%{
 553              to: [follower.ap_id],
 554              actor: followed.ap_id,
 555              object: follow_activity.data["id"],
 556              type: "Reject"
 557            }) do
 558       render(conn, AccountView, "relationship.json", %{user: followed, target: follower})
 559     else
 560       {:error, message} ->
 561         conn
 562         |> put_resp_content_type("application/json")
 563         |> send_resp(403, Jason.encode!(%{"error" => message}))
 564     end
 565   end
 566
 567   def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
 568     with %User{} = followed <- Repo.get(User, id),
 569          {:ok, follower} <- User.maybe_direct_follow(follower, followed),
 570          {:ok, _activity} <- ActivityPub.follow(follower, followed),
 571          {:ok, follower, followed} <-
 572            User.wait_and_refresh(
 573              Pleroma.Config.get([:activitypub, :follow_handshake_timeout]),
 574              follower,
 575              followed
 576            ) do
 577       render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
 578     else
 579       {:error, message} ->
 580         conn
 581         |> put_resp_content_type("application/json")
 582         |> send_resp(403, Jason.encode!(%{"error" => message}))
 583     end
 584   end
 585
 586   def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
 587     with %User{} = followed <- Repo.get_by(User, nickname: uri),
 588          {:ok, follower} <- User.maybe_direct_follow(follower, followed),
 589          {:ok, _activity} <- ActivityPub.follow(follower, followed) do
 590       render(conn, AccountView, "account.json", %{user: followed, for: follower})
 591     else
 592       {:error, message} ->
 593         conn
 594         |> put_resp_content_type("application/json")
 595         |> send_resp(403, Jason.encode!(%{"error" => message}))
 596     end
 597   end
 598
 599   def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
 600     with %User{} = followed <- Repo.get(User, id),
 601          {:ok, _activity} <- ActivityPub.unfollow(follower, followed),
 602          {:ok, follower, _} <- User.unfollow(follower, followed) do
 603       render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
 604     end
 605   end
 606
 607   def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
 608     with %User{} = blocked <- Repo.get(User, id),
 609          {:ok, blocker} <- User.block(blocker, blocked),
 610          {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
 611       render(conn, AccountView, "relationship.json", %{user: blocker, target: blocked})
 612     else
 613       {:error, message} ->
 614         conn
 615         |> put_resp_content_type("application/json")
 616         |> send_resp(403, Jason.encode!(%{"error" => message}))
 617     end
 618   end
 619
 620   def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
 621     with %User{} = blocked <- Repo.get(User, id),
 622          {:ok, blocker} <- User.unblock(blocker, blocked),
 623          {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
 624       render(conn, AccountView, "relationship.json", %{user: blocker, target: blocked})
 625     else
 626       {:error, message} ->
 627         conn
 628         |> put_resp_content_type("application/json")
 629         |> send_resp(403, Jason.encode!(%{"error" => message}))
 630     end
 631   end
 632
 633   # TODO: Use proper query
 634   def blocks(%{assigns: %{user: user}} = conn, _) do
 635     with blocked_users <- user.info.blocks || [],
 636          accounts <- Enum.map(blocked_users, fn ap_id -> User.get_cached_by_ap_id(ap_id) end) do
 637       res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
 638       json(conn, res)
 639     end
 640   end
 641
 642   def domain_blocks(%{assigns: %{user: %{info: info}}} = conn, _) do
 643     json(conn, info.domain_blocks || [])
 644   end
 645
 646   def block_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
 647     User.block_domain(blocker, domain)
 648     json(conn, %{})
 649   end
 650
 651   def unblock_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
 652     User.unblock_domain(blocker, domain)
 653     json(conn, %{})
 654   end
 655
 656   def status_search(query) do
 657     fetched =
 658       if Regex.match?(~r/https?:/, query) do
 659         with {:ok, object} <- ActivityPub.fetch_object_from_id(query) do
 660           [Activity.get_create_activity_by_object_ap_id(object.data["id"])]
 661         else
 662           _e -> []
 663         end
 664       end || []
 665
 666     q =
 667       from(
 668         a in Activity,
 669         where: fragment("?->>'type' = 'Create'", a.data),
 670         where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
 671         where:
 672           fragment(
 673             "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
 674             a.data,
 675             ^query
 676           ),
 677         limit: 20,
 678         order_by: [desc: :id]
 679       )
 680
 681     Repo.all(q) ++ fetched
 682   end
 683
 684   def search2(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 685     accounts = User.search(query, params["resolve"] == "true")
 686
 687     statuses = status_search(query)
 688
 689     tags_path = Web.base_url() <> "/tag/"
 690
 691     tags =
 692       String.split(query)
 693       |> Enum.uniq()
 694       |> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
 695       |> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
 696       |> Enum.map(fn tag -> %{name: tag, url: tags_path <> tag} end)
 697
 698     res = %{
 699       "accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
 700       "statuses" =>
 701         StatusView.render("index.json", activities: statuses, for: user, as: :activity),
 702       "hashtags" => tags
 703     }
 704
 705     json(conn, res)
 706   end
 707
 708   def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 709     accounts = User.search(query, params["resolve"] == "true")
 710
 711     statuses = status_search(query)
 712
 713     tags =
 714       String.split(query)
 715       |> Enum.uniq()
 716       |> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
 717       |> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
 718
 719     res = %{
 720       "accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
 721       "statuses" =>
 722         StatusView.render("index.json", activities: statuses, for: user, as: :activity),
 723       "hashtags" => tags
 724     }
 725
 726     json(conn, res)
 727   end
 728
 729   def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 730     accounts = User.search(query, params["resolve"] == "true")
 731
 732     res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
 733
 734     json(conn, res)
 735   end
 736
 737   def favourites(%{assigns: %{user: user}} = conn, _) do
 738     params =
 739       %{}
 740       |> Map.put("type", "Create")
 741       |> Map.put("favorited_by", user.ap_id)
 742       |> Map.put("blocking_user", user)
 743
 744     activities =
 745       ActivityPub.fetch_public_activities(params)
 746       |> Enum.reverse()
 747
 748     conn
 749     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 750   end
 751
 752   def get_lists(%{assigns: %{user: user}} = conn, opts) do
 753     lists = Pleroma.List.for_user(user, opts)
 754     res = ListView.render("lists.json", lists: lists)
 755     json(conn, res)
 756   end
 757
 758   def get_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 759     with %Pleroma.List{} = list <- Pleroma.List.get(id, user) do
 760       res = ListView.render("list.json", list: list)
 761       json(conn, res)
 762     else
 763       _e -> json(conn, "error")
 764     end
 765   end
 766
 767   def account_lists(%{assigns: %{user: user}} = conn, %{"id" => account_id}) do
 768     lists = Pleroma.List.get_lists_account_belongs(user, account_id)
 769     res = ListView.render("lists.json", lists: lists)
 770     json(conn, res)
 771   end
 772
 773   def delete_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 774     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 775          {:ok, _list} <- Pleroma.List.delete(list) do
 776       json(conn, %{})
 777     else
 778       _e ->
 779         json(conn, "error")
 780     end
 781   end
 782
 783   def create_list(%{assigns: %{user: user}} = conn, %{"title" => title}) do
 784     with {:ok, %Pleroma.List{} = list} <- Pleroma.List.create(title, user) do
 785       res = ListView.render("list.json", list: list)
 786       json(conn, res)
 787     end
 788   end
 789
 790   def add_to_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
 791     accounts
 792     |> Enum.each(fn account_id ->
 793       with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 794            %User{} = followed <- Repo.get(User, account_id) do
 795         Pleroma.List.follow(list, followed)
 796       end
 797     end)
 798
 799     json(conn, %{})
 800   end
 801
 802   def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
 803     accounts
 804     |> Enum.each(fn account_id ->
 805       with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 806            %User{} = followed <- Repo.get(Pleroma.User, account_id) do
 807         Pleroma.List.unfollow(list, followed)
 808       end
 809     end)
 810
 811     json(conn, %{})
 812   end
 813
 814   def list_accounts(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 815     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 816          {:ok, users} = Pleroma.List.get_following(list) do
 817       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 818     end
 819   end
 820
 821   def rename_list(%{assigns: %{user: user}} = conn, %{"id" => id, "title" => title}) do
 822     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 823          {:ok, list} <- Pleroma.List.rename(list, title) do
 824       res = ListView.render("list.json", list: list)
 825       json(conn, res)
 826     else
 827       _e ->
 828         json(conn, "error")
 829     end
 830   end
 831
 832   def list_timeline(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params) do
 833     with %Pleroma.List{title: title, following: following} <- Pleroma.List.get(id, user) do
 834       params =
 835         params
 836         |> Map.put("type", "Create")
 837         |> Map.put("blocking_user", user)
 838
 839       # we must filter the following list for the user to avoid leaking statuses the user
 840       # does not actually have permission to see (for more info, peruse security issue #270).
 841       following_to =
 842         following
 843         |> Enum.filter(fn x -> x in user.following end)
 844
 845       activities =
 846         ActivityPub.fetch_activities_bounded(following_to, following, params)
 847         |> Enum.reverse()
 848
 849       conn
 850       |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 851     else
 852       _e ->
 853         conn
 854         |> put_status(403)
 855         |> json(%{error: "Error."})
 856     end
 857   end
 858
 859   def index(%{assigns: %{user: user}} = conn, _params) do
 860     token =
 861       conn
 862       |> get_session(:oauth_token)
 863
 864     if user && token do
 865       mastodon_emoji = mastodonized_emoji()
 866
 867       limit = Pleroma.Config.get([:instance, :limit])
 868
 869       accounts =
 870         Map.put(%{}, user.id, AccountView.render("account.json", %{user: user, for: user}))
 871
 872       initial_state =
 873         %{
 874           meta: %{
 875             streaming_api_base_url:
 876               String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws"),
 877             access_token: token,
 878             locale: "en",
 879             domain: Pleroma.Web.Endpoint.host(),
 880             admin: "1",
 881             me: "#{user.id}",
 882             unfollow_modal: false,
 883             boost_modal: false,
 884             delete_modal: true,
 885             auto_play_gif: false,
 886             display_sensitive_media: false,
 887             reduce_motion: false,
 888             max_toot_chars: limit
 889           },
 890           rights: %{
 891             delete_others_notice: !!user.info.is_moderator
 892           },
 893           compose: %{
 894             me: "#{user.id}",
 895             default_privacy: user.info.default_scope,
 896             default_sensitive: false
 897           },
 898           media_attachments: %{
 899             accept_content_types: [
 900               ".jpg",
 901               ".jpeg",
 902               ".png",
 903               ".gif",
 904               ".webm",
 905               ".mp4",
 906               ".m4v",
 907               "image\/jpeg",
 908               "image\/png",
 909               "image\/gif",
 910               "video\/webm",
 911               "video\/mp4"
 912             ]
 913           },
 914           settings:
 915             Map.get(user.info, :settings) ||
 916               %{
 917                 onboarded: true,
 918                 home: %{
 919                   shows: %{
 920                     reblog: true,
 921                     reply: true
 922                   }
 923                 },
 924                 notifications: %{
 925                   alerts: %{
 926                     follow: true,
 927                     favourite: true,
 928                     reblog: true,
 929                     mention: true
 930                   },
 931                   shows: %{
 932                     follow: true,
 933                     favourite: true,
 934                     reblog: true,
 935                     mention: true
 936                   },
 937                   sounds: %{
 938                     follow: true,
 939                     favourite: true,
 940                     reblog: true,
 941                     mention: true
 942                   }
 943                 }
 944               },
 945           push_subscription: nil,
 946           accounts: accounts,
 947           custom_emojis: mastodon_emoji,
 948           char_limit: limit
 949         }
 950         |> Jason.encode!()
 951
 952       conn
 953       |> put_layout(false)
 954       |> render(MastodonView, "index.html", %{initial_state: initial_state})
 955     else
 956       conn
 957       |> redirect(to: "/web/login")
 958     end
 959   end
 960
 961   def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
 962     with new_info <- Map.put(user.info, "settings", settings),
 963          change <- User.info_changeset(user, %{info: new_info}),
 964          {:ok, _user} <- User.update_and_set_cache(change) do
 965       conn
 966       |> json(%{})
 967     else
 968       e ->
 969         conn
 970         |> json(%{error: inspect(e)})
 971     end
 972   end
 973
 974   def login(conn, %{"code" => code}) do
 975     with {:ok, app} <- get_or_make_app(),
 976          %Authorization{} = auth <- Repo.get_by(Authorization, token: code, app_id: app.id),
 977          {:ok, token} <- Token.exchange_token(app, auth) do
 978       conn
 979       |> put_session(:oauth_token, token.token)
 980       |> redirect(to: "/web/getting-started")
 981     end
 982   end
 983
 984   def login(conn, _) do
 985     with {:ok, app} <- get_or_make_app() do
 986       path =
 987         o_auth_path(conn, :authorize,
 988           response_type: "code",
 989           client_id: app.client_id,
 990           redirect_uri: ".",
 991           scope: app.scopes
 992         )
 993
 994       conn
 995       |> redirect(to: path)
 996     end
 997   end
 998
 999   defp get_or_make_app() do
1000     with %App{} = app <- Repo.get_by(App, client_name: "Mastodon-Local") do
1001       {:ok, app}
1002     else
1003       _e ->
1004         cs =
1005           App.register_changeset(%App{}, %{
1006             client_name: "Mastodon-Local",
1007             redirect_uris: ".",
1008             scopes: "read,write,follow"
1009           })
1010
1011         Repo.insert(cs)
1012     end
1013   end
1014
1015   def logout(conn, _) do
1016     conn
1017     |> clear_session
1018     |> redirect(to: "/")
1019   end
1020
1021   def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
1022     Logger.debug("Unimplemented, returning unmodified relationship")
1023
1024     with %User{} = target <- Repo.get(User, id) do
1025       render(conn, AccountView, "relationship.json", %{user: user, target: target})
1026     end
1027   end
1028
1029   def empty_array(conn, _) do
1030     Logger.debug("Unimplemented, returning an empty array")
1031     json(conn, [])
1032   end
1033
1034   def empty_object(conn, _) do
1035     Logger.debug("Unimplemented, returning an empty object")
1036     json(conn, %{})
1037   end
1038
1039   def render_notification(user, %{id: id, activity: activity, inserted_at: created_at} = _params) do
1040     actor = User.get_cached_by_ap_id(activity.data["actor"])
1041
1042     created_at =
1043       NaiveDateTime.to_iso8601(created_at)
1044       |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
1045
1046     id = id |> to_string
1047
1048     case activity.data["type"] do
1049       "Create" ->
1050         %{
1051           id: id,
1052           type: "mention",
1053           created_at: created_at,
1054           account: AccountView.render("account.json", %{user: actor, for: user}),
1055           status: StatusView.render("status.json", %{activity: activity, for: user})
1056         }
1057
1058       "Like" ->
1059         liked_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
1060
1061         %{
1062           id: id,
1063           type: "favourite",
1064           created_at: created_at,
1065           account: AccountView.render("account.json", %{user: actor, for: user}),
1066           status: StatusView.render("status.json", %{activity: liked_activity, for: user})
1067         }
1068
1069       "Announce" ->
1070         announced_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
1071
1072         %{
1073           id: id,
1074           type: "reblog",
1075           created_at: created_at,
1076           account: AccountView.render("account.json", %{user: actor, for: user}),
1077           status: StatusView.render("status.json", %{activity: announced_activity, for: user})
1078         }
1079
1080       "Follow" ->
1081         %{
1082           id: id,
1083           type: "follow",
1084           created_at: created_at,
1085           account: AccountView.render("account.json", %{user: actor, for: user})
1086         }
1087
1088       _ ->
1089         nil
1090     end
1091   end
1092
1093   def get_filters(%{assigns: %{user: user}} = conn, _) do
1094     filters = Pleroma.Filter.get_filters(user)
1095     res = FilterView.render("filters.json", filters: filters)
1096     json(conn, res)
1097   end
1098
1099   def create_filter(
1100         %{assigns: %{user: user}} = conn,
1101         %{"phrase" => phrase, "context" => context} = params
1102       ) do
1103     query = %Pleroma.Filter{
1104       user_id: user.id,
1105       phrase: phrase,
1106       context: context,
1107       hide: Map.get(params, "irreversible", nil),
1108       whole_word: Map.get(params, "boolean", true)
1109       # expires_at
1110     }
1111
1112     {:ok, response} = Pleroma.Filter.create(query)
1113     res = FilterView.render("filter.json", filter: response)
1114     json(conn, res)
1115   end
1116
1117   def get_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
1118     filter = Pleroma.Filter.get(filter_id, user)
1119     res = FilterView.render("filter.json", filter: filter)
1120     json(conn, res)
1121   end
1122
1123   def update_filter(
1124         %{assigns: %{user: user}} = conn,
1125         %{"phrase" => phrase, "context" => context, "id" => filter_id} = params
1126       ) do
1127     query = %Pleroma.Filter{
1128       user_id: user.id,
1129       filter_id: filter_id,
1130       phrase: phrase,
1131       context: context,
1132       hide: Map.get(params, "irreversible", nil),
1133       whole_word: Map.get(params, "boolean", true)
1134       # expires_at
1135     }
1136
1137     {:ok, response} = Pleroma.Filter.update(query)
1138     res = FilterView.render("filter.json", filter: response)
1139     json(conn, res)
1140   end
1141
1142   def delete_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
1143     query = %Pleroma.Filter{
1144       user_id: user.id,
1145       filter_id: filter_id
1146     }
1147
1148     {:ok, _} = Pleroma.Filter.delete(query)
1149     json(conn, %{})
1150   end
1151
1152   def errors(conn, _) do
1153     conn
1154     |> put_status(500)
1155     |> json("Something went wrong")
1156   end
1157
1158   def suggestions(%{assigns: %{user: user}} = conn, _) do
1159     suggestions = Pleroma.Config.get(:suggestions)
1160
1161     if Keyword.get(suggestions, :enabled, false) do
1162       api = Keyword.get(suggestions, :third_party_engine, "")
1163       timeout = Keyword.get(suggestions, :timeout, 5000)
1164       limit = Keyword.get(suggestions, :limit, 23)
1165
1166       host = Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host])
1167
1168       user = user.nickname
1169       url = String.replace(api, "{{host}}", host) |> String.replace("{{user}}", user)
1170
1171       with {:ok, %{status_code: 200, body: body}} <-
1172              @httpoison.get(url, [], timeout: timeout, recv_timeout: timeout),
1173            {:ok, data} <- Jason.decode(body) do
1174         data2 =
1175           Enum.slice(data, 0, limit)
1176           |> Enum.map(fn x ->
1177             Map.put(
1178               x,
1179               "id",
1180               case User.get_or_fetch(x["acct"]) do
1181                 %{id: id} -> id
1182                 _ -> 0
1183               end
1184             )
1185           end)
1186           |> Enum.map(fn x ->
1187             Map.put(x, "avatar", MediaProxy.url(x["avatar"]))
1188           end)
1189           |> Enum.map(fn x ->
1190             Map.put(x, "avatar_static", MediaProxy.url(x["avatar_static"]))
1191           end)
1192
1193         conn
1194         |> json(data2)
1195       else
1196         e -> Logger.error("Could not retrieve suggestions at fetch #{url}, #{inspect(e)}")
1197       end
1198     else
1199       json(conn, [])
1200     end
1201   end
1202
1203   def try_render(conn, renderer, target, params)
1204       when is_binary(target) do
1205     res = render(conn, renderer, target, params)
1206
1207     if res == nil do
1208       conn
1209       |> put_status(501)
1210       |> json(%{error: "Can't display this activity"})
1211     else
1212       res
1213     end
1214   end
1215
1216   def try_render(conn, _, _, _) do
1217     conn
1218     |> put_status(501)
1219     |> json(%{error: "Can't display this activity"})
1220   end
1221 end