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