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, fn value -> {:ok, User.parse_bio(value)} end)
  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" => object}} <- Repo.get(Activity, id),
 468          %Object{data: %{"likes" => likes}} <- Object.normalize(object) do
 469       q = from(u in User, where: u.ap_id in ^likes)
 470       users = Repo.all(q)
 471       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 472     else
 473       _ -> json(conn, [])
 474     end
 475   end
 476
 477   def reblogged_by(conn, %{"id" => id}) do
 478     with %Activity{data: %{"object" => object}} <- Repo.get(Activity, id),
 479          %Object{data: %{"announcements" => announces}} <- Object.normalize(object) do
 480       q = from(u in User, where: u.ap_id in ^announces)
 481       users = Repo.all(q)
 482       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 483     else
 484       _ -> json(conn, [])
 485     end
 486   end
 487
 488   def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
 489     local_only = params["local"] in [true, "True", "true", "1"]
 490
 491     params =
 492       params
 493       |> Map.put("type", "Create")
 494       |> Map.put("local_only", local_only)
 495       |> Map.put("blocking_user", user)
 496       |> Map.put("tag", String.downcase(params["tag"]))
 497
 498     activities =
 499       ActivityPub.fetch_public_activities(params)
 500       |> Enum.reverse()
 501
 502     conn
 503     |> add_link_headers(:hashtag_timeline, activities, params["tag"], %{"local" => local_only})
 504     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 505   end
 506
 507   # TODO: Pagination
 508   def followers(conn, %{"id" => id}) do
 509     with %User{} = user <- Repo.get(User, id),
 510          {:ok, followers} <- User.get_followers(user) do
 511       render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
 512     end
 513   end
 514
 515   def following(conn, %{"id" => id}) do
 516     with %User{} = user <- Repo.get(User, id),
 517          {:ok, followers} <- User.get_friends(user) do
 518       render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
 519     end
 520   end
 521
 522   def follow_requests(%{assigns: %{user: followed}} = conn, _params) do
 523     with {:ok, follow_requests} <- User.get_follow_requests(followed) do
 524       render(conn, AccountView, "accounts.json", %{users: follow_requests, as: :user})
 525     end
 526   end
 527
 528   def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
 529     with %User{} = follower <- Repo.get(User, id),
 530          {:ok, follower} <- User.maybe_follow(follower, followed),
 531          %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
 532          {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
 533          {:ok, _activity} <-
 534            ActivityPub.accept(%{
 535              to: [follower.ap_id],
 536              actor: followed.ap_id,
 537              object: follow_activity.data["id"],
 538              type: "Accept"
 539            }) do
 540       render(conn, AccountView, "relationship.json", %{user: followed, target: follower})
 541     else
 542       {:error, message} ->
 543         conn
 544         |> put_resp_content_type("application/json")
 545         |> send_resp(403, Jason.encode!(%{"error" => message}))
 546     end
 547   end
 548
 549   def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
 550     with %User{} = follower <- Repo.get(User, id),
 551          %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
 552          {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
 553          {:ok, _activity} <-
 554            ActivityPub.reject(%{
 555              to: [follower.ap_id],
 556              actor: followed.ap_id,
 557              object: follow_activity.data["id"],
 558              type: "Reject"
 559            }) do
 560       render(conn, AccountView, "relationship.json", %{user: followed, target: follower})
 561     else
 562       {:error, message} ->
 563         conn
 564         |> put_resp_content_type("application/json")
 565         |> send_resp(403, Jason.encode!(%{"error" => message}))
 566     end
 567   end
 568
 569   def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
 570     with %User{} = followed <- Repo.get(User, id),
 571          {:ok, follower} <- User.maybe_direct_follow(follower, followed),
 572          {:ok, _activity} <- ActivityPub.follow(follower, followed),
 573          {:ok, follower, followed} <-
 574            User.wait_and_refresh(
 575              Pleroma.Config.get([:activitypub, :follow_handshake_timeout]),
 576              follower,
 577              followed
 578            ) do
 579       render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
 580     else
 581       {:error, message} ->
 582         conn
 583         |> put_resp_content_type("application/json")
 584         |> send_resp(403, Jason.encode!(%{"error" => message}))
 585     end
 586   end
 587
 588   def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
 589     with %User{} = followed <- Repo.get_by(User, nickname: uri),
 590          {:ok, follower} <- User.maybe_direct_follow(follower, followed),
 591          {:ok, _activity} <- ActivityPub.follow(follower, followed) do
 592       render(conn, AccountView, "account.json", %{user: followed, for: follower})
 593     else
 594       {:error, message} ->
 595         conn
 596         |> put_resp_content_type("application/json")
 597         |> send_resp(403, Jason.encode!(%{"error" => message}))
 598     end
 599   end
 600
 601   def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
 602     with %User{} = followed <- Repo.get(User, id),
 603          {:ok, _activity} <- ActivityPub.unfollow(follower, followed),
 604          {:ok, follower, _} <- User.unfollow(follower, followed) do
 605       render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
 606     end
 607   end
 608
 609   def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
 610     with %User{} = blocked <- Repo.get(User, id),
 611          {:ok, blocker} <- User.block(blocker, blocked),
 612          {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
 613       render(conn, AccountView, "relationship.json", %{user: blocker, target: blocked})
 614     else
 615       {:error, message} ->
 616         conn
 617         |> put_resp_content_type("application/json")
 618         |> send_resp(403, Jason.encode!(%{"error" => message}))
 619     end
 620   end
 621
 622   def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
 623     with %User{} = blocked <- Repo.get(User, id),
 624          {:ok, blocker} <- User.unblock(blocker, blocked),
 625          {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
 626       render(conn, AccountView, "relationship.json", %{user: blocker, target: blocked})
 627     else
 628       {:error, message} ->
 629         conn
 630         |> put_resp_content_type("application/json")
 631         |> send_resp(403, Jason.encode!(%{"error" => message}))
 632     end
 633   end
 634
 635   # TODO: Use proper query
 636   def blocks(%{assigns: %{user: user}} = conn, _) do
 637     with blocked_users <- user.info.blocks || [],
 638          accounts <- Enum.map(blocked_users, fn ap_id -> User.get_cached_by_ap_id(ap_id) end) do
 639       res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
 640       json(conn, res)
 641     end
 642   end
 643
 644   def domain_blocks(%{assigns: %{user: %{info: info}}} = conn, _) do
 645     json(conn, info.domain_blocks || [])
 646   end
 647
 648   def block_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
 649     User.block_domain(blocker, domain)
 650     json(conn, %{})
 651   end
 652
 653   def unblock_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
 654     User.unblock_domain(blocker, domain)
 655     json(conn, %{})
 656   end
 657
 658   def status_search(query) do
 659     fetched =
 660       if Regex.match?(~r/https?:/, query) do
 661         with {:ok, object} <- ActivityPub.fetch_object_from_id(query) do
 662           [Activity.get_create_activity_by_object_ap_id(object.data["id"])]
 663         else
 664           _e -> []
 665         end
 666       end || []
 667
 668     q =
 669       from(
 670         a in Activity,
 671         where: fragment("?->>'type' = 'Create'", a.data),
 672         where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
 673         where:
 674           fragment(
 675             "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
 676             a.data,
 677             ^query
 678           ),
 679         limit: 20,
 680         order_by: [desc: :id]
 681       )
 682
 683     Repo.all(q) ++ fetched
 684   end
 685
 686   def search2(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 687     accounts = User.search(query, params["resolve"] == "true")
 688
 689     statuses = status_search(query)
 690
 691     tags_path = Web.base_url() <> "/tag/"
 692
 693     tags =
 694       String.split(query)
 695       |> Enum.uniq()
 696       |> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
 697       |> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
 698       |> Enum.map(fn tag -> %{name: tag, url: tags_path <> tag} end)
 699
 700     res = %{
 701       "accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
 702       "statuses" =>
 703         StatusView.render("index.json", activities: statuses, for: user, as: :activity),
 704       "hashtags" => tags
 705     }
 706
 707     json(conn, res)
 708   end
 709
 710   def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 711     accounts = User.search(query, params["resolve"] == "true")
 712
 713     statuses = status_search(query)
 714
 715     tags =
 716       String.split(query)
 717       |> Enum.uniq()
 718       |> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
 719       |> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
 720
 721     res = %{
 722       "accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
 723       "statuses" =>
 724         StatusView.render("index.json", activities: statuses, for: user, as: :activity),
 725       "hashtags" => tags
 726     }
 727
 728     json(conn, res)
 729   end
 730
 731   def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 732     accounts = User.search(query, params["resolve"] == "true")
 733
 734     res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
 735
 736     json(conn, res)
 737   end
 738
 739   def favourites(%{assigns: %{user: user}} = conn, _) do
 740     params =
 741       %{}
 742       |> Map.put("type", "Create")
 743       |> Map.put("favorited_by", user.ap_id)
 744       |> Map.put("blocking_user", user)
 745
 746     activities =
 747       ActivityPub.fetch_public_activities(params)
 748       |> Enum.reverse()
 749
 750     conn
 751     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 752   end
 753
 754   def get_lists(%{assigns: %{user: user}} = conn, opts) do
 755     lists = Pleroma.List.for_user(user, opts)
 756     res = ListView.render("lists.json", lists: lists)
 757     json(conn, res)
 758   end
 759
 760   def get_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 761     with %Pleroma.List{} = list <- Pleroma.List.get(id, user) do
 762       res = ListView.render("list.json", list: list)
 763       json(conn, res)
 764     else
 765       _e -> json(conn, "error")
 766     end
 767   end
 768
 769   def account_lists(%{assigns: %{user: user}} = conn, %{"id" => account_id}) do
 770     lists = Pleroma.List.get_lists_account_belongs(user, account_id)
 771     res = ListView.render("lists.json", lists: lists)
 772     json(conn, res)
 773   end
 774
 775   def delete_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 776     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 777          {:ok, _list} <- Pleroma.List.delete(list) do
 778       json(conn, %{})
 779     else
 780       _e ->
 781         json(conn, "error")
 782     end
 783   end
 784
 785   def create_list(%{assigns: %{user: user}} = conn, %{"title" => title}) do
 786     with {:ok, %Pleroma.List{} = list} <- Pleroma.List.create(title, user) do
 787       res = ListView.render("list.json", list: list)
 788       json(conn, res)
 789     end
 790   end
 791
 792   def add_to_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
 793     accounts
 794     |> Enum.each(fn account_id ->
 795       with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 796            %User{} = followed <- Repo.get(User, account_id) do
 797         Pleroma.List.follow(list, followed)
 798       end
 799     end)
 800
 801     json(conn, %{})
 802   end
 803
 804   def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
 805     accounts
 806     |> Enum.each(fn account_id ->
 807       with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 808            %User{} = followed <- Repo.get(Pleroma.User, account_id) do
 809         Pleroma.List.unfollow(list, followed)
 810       end
 811     end)
 812
 813     json(conn, %{})
 814   end
 815
 816   def list_accounts(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 817     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 818          {:ok, users} = Pleroma.List.get_following(list) do
 819       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 820     end
 821   end
 822
 823   def rename_list(%{assigns: %{user: user}} = conn, %{"id" => id, "title" => title}) do
 824     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 825          {:ok, list} <- Pleroma.List.rename(list, title) do
 826       res = ListView.render("list.json", list: list)
 827       json(conn, res)
 828     else
 829       _e ->
 830         json(conn, "error")
 831     end
 832   end
 833
 834   def list_timeline(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params) do
 835     with %Pleroma.List{title: title, following: following} <- Pleroma.List.get(id, user) do
 836       params =
 837         params
 838         |> Map.put("type", "Create")
 839         |> Map.put("blocking_user", user)
 840
 841       # we must filter the following list for the user to avoid leaking statuses the user
 842       # does not actually have permission to see (for more info, peruse security issue #270).
 843       following_to =
 844         following
 845         |> Enum.filter(fn x -> x in user.following end)
 846
 847       activities =
 848         ActivityPub.fetch_activities_bounded(following_to, following, params)
 849         |> Enum.reverse()
 850
 851       conn
 852       |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 853     else
 854       _e ->
 855         conn
 856         |> put_status(403)
 857         |> json(%{error: "Error."})
 858     end
 859   end
 860
 861   def index(%{assigns: %{user: user}} = conn, _params) do
 862     token =
 863       conn
 864       |> get_session(:oauth_token)
 865
 866     if user && token do
 867       mastodon_emoji = mastodonized_emoji()
 868
 869       limit = Pleroma.Config.get([:instance, :limit])
 870
 871       accounts =
 872         Map.put(%{}, user.id, AccountView.render("account.json", %{user: user, for: user}))
 873
 874       initial_state =
 875         %{
 876           meta: %{
 877             streaming_api_base_url:
 878               String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws"),
 879             access_token: token,
 880             locale: "en",
 881             domain: Pleroma.Web.Endpoint.host(),
 882             admin: "1",
 883             me: "#{user.id}",
 884             unfollow_modal: false,
 885             boost_modal: false,
 886             delete_modal: true,
 887             auto_play_gif: false,
 888             display_sensitive_media: false,
 889             reduce_motion: false,
 890             max_toot_chars: limit
 891           },
 892           rights: %{
 893             delete_others_notice: !!user.info.is_moderator
 894           },
 895           compose: %{
 896             me: "#{user.id}",
 897             default_privacy: user.info.default_scope,
 898             default_sensitive: false
 899           },
 900           media_attachments: %{
 901             accept_content_types: [
 902               ".jpg",
 903               ".jpeg",
 904               ".png",
 905               ".gif",
 906               ".webm",
 907               ".mp4",
 908               ".m4v",
 909               "image\/jpeg",
 910               "image\/png",
 911               "image\/gif",
 912               "video\/webm",
 913               "video\/mp4"
 914             ]
 915           },
 916           settings:
 917             Map.get(user.info, :settings) ||
 918               %{
 919                 onboarded: true,
 920                 home: %{
 921                   shows: %{
 922                     reblog: true,
 923                     reply: true
 924                   }
 925                 },
 926                 notifications: %{
 927                   alerts: %{
 928                     follow: true,
 929                     favourite: true,
 930                     reblog: true,
 931                     mention: true
 932                   },
 933                   shows: %{
 934                     follow: true,
 935                     favourite: true,
 936                     reblog: true,
 937                     mention: true
 938                   },
 939                   sounds: %{
 940                     follow: true,
 941                     favourite: true,
 942                     reblog: true,
 943                     mention: true
 944                   }
 945                 }
 946               },
 947           push_subscription: nil,
 948           accounts: accounts,
 949           custom_emojis: mastodon_emoji,
 950           char_limit: limit
 951         }
 952         |> Jason.encode!()
 953
 954       conn
 955       |> put_layout(false)
 956       |> render(MastodonView, "index.html", %{initial_state: initial_state})
 957     else
 958       conn
 959       |> redirect(to: "/web/login")
 960     end
 961   end
 962
 963   def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
 964     with new_info <- Map.put(user.info, "settings", settings),
 965          change <- User.info_changeset(user, %{info: new_info}),
 966          {:ok, _user} <- User.update_and_set_cache(change) do
 967       conn
 968       |> json(%{})
 969     else
 970       e ->
 971         conn
 972         |> json(%{error: inspect(e)})
 973     end
 974   end
 975
 976   def login(conn, %{"code" => code}) do
 977     with {:ok, app} <- get_or_make_app(),
 978          %Authorization{} = auth <- Repo.get_by(Authorization, token: code, app_id: app.id),
 979          {:ok, token} <- Token.exchange_token(app, auth) do
 980       conn
 981       |> put_session(:oauth_token, token.token)
 982       |> redirect(to: "/web/getting-started")
 983     end
 984   end
 985
 986   def login(conn, _) do
 987     with {:ok, app} <- get_or_make_app() do
 988       path =
 989         o_auth_path(conn, :authorize,
 990           response_type: "code",
 991           client_id: app.client_id,
 992           redirect_uri: ".",
 993           scope: app.scopes
 994         )
 995
 996       conn
 997       |> redirect(to: path)
 998     end
 999   end
1000
1001   defp get_or_make_app() do
1002     with %App{} = app <- Repo.get_by(App, client_name: "Mastodon-Local") do
1003       {:ok, app}
1004     else
1005       _e ->
1006         cs =
1007           App.register_changeset(%App{}, %{
1008             client_name: "Mastodon-Local",
1009             redirect_uris: ".",
1010             scopes: "read,write,follow"
1011           })
1012
1013         Repo.insert(cs)
1014     end
1015   end
1016
1017   def logout(conn, _) do
1018     conn
1019     |> clear_session
1020     |> redirect(to: "/")
1021   end
1022
1023   def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
1024     Logger.debug("Unimplemented, returning unmodified relationship")
1025
1026     with %User{} = target <- Repo.get(User, id) do
1027       render(conn, AccountView, "relationship.json", %{user: user, target: target})
1028     end
1029   end
1030
1031   def empty_array(conn, _) do
1032     Logger.debug("Unimplemented, returning an empty array")
1033     json(conn, [])
1034   end
1035
1036   def empty_object(conn, _) do
1037     Logger.debug("Unimplemented, returning an empty object")
1038     json(conn, %{})
1039   end
1040
1041   def render_notification(user, %{id: id, activity: activity, inserted_at: created_at} = _params) do
1042     actor = User.get_cached_by_ap_id(activity.data["actor"])
1043
1044     created_at =
1045       NaiveDateTime.to_iso8601(created_at)
1046       |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
1047
1048     id = id |> to_string
1049
1050     case activity.data["type"] do
1051       "Create" ->
1052         %{
1053           id: id,
1054           type: "mention",
1055           created_at: created_at,
1056           account: AccountView.render("account.json", %{user: actor, for: user}),
1057           status: StatusView.render("status.json", %{activity: activity, for: user})
1058         }
1059
1060       "Like" ->
1061         liked_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
1062
1063         %{
1064           id: id,
1065           type: "favourite",
1066           created_at: created_at,
1067           account: AccountView.render("account.json", %{user: actor, for: user}),
1068           status: StatusView.render("status.json", %{activity: liked_activity, for: user})
1069         }
1070
1071       "Announce" ->
1072         announced_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
1073
1074         %{
1075           id: id,
1076           type: "reblog",
1077           created_at: created_at,
1078           account: AccountView.render("account.json", %{user: actor, for: user}),
1079           status: StatusView.render("status.json", %{activity: announced_activity, for: user})
1080         }
1081
1082       "Follow" ->
1083         %{
1084           id: id,
1085           type: "follow",
1086           created_at: created_at,
1087           account: AccountView.render("account.json", %{user: actor, for: user})
1088         }
1089
1090       _ ->
1091         nil
1092     end
1093   end
1094
1095   def get_filters(%{assigns: %{user: user}} = conn, _) do
1096     filters = Pleroma.Filter.get_filters(user)
1097     res = FilterView.render("filters.json", filters: filters)
1098     json(conn, res)
1099   end
1100
1101   def create_filter(
1102         %{assigns: %{user: user}} = conn,
1103         %{"phrase" => phrase, "context" => context} = params
1104       ) do
1105     query = %Pleroma.Filter{
1106       user_id: user.id,
1107       phrase: phrase,
1108       context: context,
1109       hide: Map.get(params, "irreversible", nil),
1110       whole_word: Map.get(params, "boolean", true)
1111       # expires_at
1112     }
1113
1114     {:ok, response} = Pleroma.Filter.create(query)
1115     res = FilterView.render("filter.json", filter: response)
1116     json(conn, res)
1117   end
1118
1119   def get_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
1120     filter = Pleroma.Filter.get(filter_id, user)
1121     res = FilterView.render("filter.json", filter: filter)
1122     json(conn, res)
1123   end
1124
1125   def update_filter(
1126         %{assigns: %{user: user}} = conn,
1127         %{"phrase" => phrase, "context" => context, "id" => filter_id} = params
1128       ) do
1129     query = %Pleroma.Filter{
1130       user_id: user.id,
1131       filter_id: filter_id,
1132       phrase: phrase,
1133       context: context,
1134       hide: Map.get(params, "irreversible", nil),
1135       whole_word: Map.get(params, "boolean", true)
1136       # expires_at
1137     }
1138
1139     {:ok, response} = Pleroma.Filter.update(query)
1140     res = FilterView.render("filter.json", filter: response)
1141     json(conn, res)
1142   end
1143
1144   def delete_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
1145     query = %Pleroma.Filter{
1146       user_id: user.id,
1147       filter_id: filter_id
1148     }
1149
1150     {:ok, _} = Pleroma.Filter.delete(query)
1151     json(conn, %{})
1152   end
1153
1154   def errors(conn, _) do
1155     conn
1156     |> put_status(500)
1157     |> json("Something went wrong")
1158   end
1159
1160   def suggestions(%{assigns: %{user: user}} = conn, _) do
1161     suggestions = Pleroma.Config.get(:suggestions)
1162
1163     if Keyword.get(suggestions, :enabled, false) do
1164       api = Keyword.get(suggestions, :third_party_engine, "")
1165       timeout = Keyword.get(suggestions, :timeout, 5000)
1166       limit = Keyword.get(suggestions, :limit, 23)
1167
1168       host = Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host])
1169
1170       user = user.nickname
1171       url = String.replace(api, "{{host}}", host) |> String.replace("{{user}}", user)
1172
1173       with {:ok, %{status_code: 200, body: body}} <-
1174              @httpoison.get(url, [], timeout: timeout, recv_timeout: timeout),
1175            {:ok, data} <- Jason.decode(body) do
1176         data2 =
1177           Enum.slice(data, 0, limit)
1178           |> Enum.map(fn x ->
1179             Map.put(
1180               x,
1181               "id",
1182               case User.get_or_fetch(x["acct"]) do
1183                 %{id: id} -> id
1184                 _ -> 0
1185               end
1186             )
1187           end)
1188           |> Enum.map(fn x ->
1189             Map.put(x, "avatar", MediaProxy.url(x["avatar"]))
1190           end)
1191           |> Enum.map(fn x ->
1192             Map.put(x, "avatar_static", MediaProxy.url(x["avatar_static"]))
1193           end)
1194
1195         conn
1196         |> json(data2)
1197       else
1198         e -> Logger.error("Could not retrieve suggestions at fetch #{url}, #{inspect(e)}")
1199       end
1200     else
1201       json(conn, [])
1202     end
1203   end
1204
1205   def try_render(conn, renderer, target, params)
1206       when is_binary(target) do
1207     res = render(conn, renderer, target, params)
1208
1209     if res == nil do
1210       conn
1211       |> put_status(501)
1212       |> json(%{error: "Can't display this activity"})
1213     else
1214       res
1215     end
1216   end
1217
1218   def try_render(conn, _, _, _) do
1219     conn
1220     |> put_status(501)
1221     |> json(%{error: "Can't display this activity"})
1222   end
1223 end