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, Activity, User, Notification, Stats}
   4   alias Pleroma.Web
   5   alias Pleroma.Web.MastodonAPI.{StatusView, AccountView, MastodonView, ListView}
   6   alias Pleroma.Web.ActivityPub.ActivityPub
   7   alias Pleroma.Web.{CommonAPI, OStatus}
   8   alias Pleroma.Web.OAuth.{Authorization, Token, App}
   9   alias Comeonin.Pbkdf2
  10   import Ecto.Query
  11   require Logger
  12
  13   action_fallback(:errors)
  14
  15   def create_app(conn, params) do
  16     with cs <- App.register_changeset(%App{}, params) |> IO.inspect(),
  17          {:ok, app} <- Repo.insert(cs) |> IO.inspect() do
  18       res = %{
  19         id: app.id,
  20         client_id: app.client_id,
  21         client_secret: app.client_secret
  22       }
  23
  24       json(conn, res)
  25     end
  26   end
  27
  28   def update_credentials(%{assigns: %{user: user}} = conn, params) do
  29     original_user = user
  30
  31     params =
  32       if bio = params["note"] do
  33         Map.put(params, "bio", bio)
  34       else
  35         params
  36       end
  37
  38     params =
  39       if name = params["display_name"] do
  40         Map.put(params, "name", name)
  41       else
  42         params
  43       end
  44
  45     user =
  46       if avatar = params["avatar"] do
  47         with %Plug.Upload{} <- avatar,
  48              {:ok, object} <- ActivityPub.upload(avatar),
  49              change = Ecto.Changeset.change(user, %{avatar: object.data}),
  50              {:ok, user} = User.update_and_set_cache(change) do
  51           user
  52         else
  53           _e -> user
  54         end
  55       else
  56         user
  57       end
  58
  59     user =
  60       if banner = params["header"] do
  61         with %Plug.Upload{} <- banner,
  62              {:ok, object} <- ActivityPub.upload(banner),
  63              new_info <- Map.put(user.info, "banner", object.data),
  64              change <- User.info_changeset(user, %{info: new_info}),
  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     with changeset <- User.update_changeset(user, params),
  75          {:ok, user} <- User.update_and_set_cache(changeset) do
  76       if original_user != user do
  77         CommonAPI.update(user)
  78       end
  79
  80       json(conn, AccountView.render("account.json", %{user: user}))
  81     else
  82       _e ->
  83         conn
  84         |> put_status(403)
  85         |> json(%{error: "Invalid request"})
  86     end
  87   end
  88
  89   def verify_credentials(%{assigns: %{user: user}} = conn, _) do
  90     account = AccountView.render("account.json", %{user: user})
  91     json(conn, account)
  92   end
  93
  94   def user(conn, %{"id" => id}) do
  95     with %User{} = user <- Repo.get(User, id) do
  96       account = AccountView.render("account.json", %{user: user})
  97       json(conn, account)
  98     else
  99       _e ->
 100         conn
 101         |> put_status(404)
 102         |> json(%{error: "Can't find user"})
 103     end
 104   end
 105
 106   @instance Application.get_env(:pleroma, :instance)
 107   @mastodon_api_level "2.3.3"
 108
 109   def masto_instance(conn, _params) do
 110     response = %{
 111       uri: Web.base_url(),
 112       title: Keyword.get(@instance, :name),
 113       description: "A Pleroma instance, an alternative fediverse server",
 114       version: "#{@mastodon_api_level} (compatible; #{Keyword.get(@instance, :version)})",
 115       email: Keyword.get(@instance, :email),
 116       urls: %{
 117         streaming_api: String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws")
 118       },
 119       stats: Stats.get_stats(),
 120       thumbnail: Web.base_url() <> "/instance/thumbnail.jpeg",
 121       max_toot_chars: Keyword.get(@instance, :limit)
 122     }
 123
 124     json(conn, response)
 125   end
 126
 127   def peers(conn, _params) do
 128     json(conn, Stats.get_peers())
 129   end
 130
 131   defp mastodonized_emoji do
 132     Pleroma.Formatter.get_custom_emoji()
 133     |> Enum.map(fn {shortcode, relative_url} ->
 134       url = to_string(URI.merge(Web.base_url(), relative_url))
 135
 136       %{
 137         "shortcode" => shortcode,
 138         "static_url" => url,
 139         "visible_in_picker" => true,
 140         "url" => url
 141       }
 142     end)
 143   end
 144
 145   def custom_emojis(conn, _params) do
 146     mastodon_emoji = mastodonized_emoji()
 147     json(conn, mastodon_emoji)
 148   end
 149
 150   defp add_link_headers(conn, method, activities, param \\ nil, params \\ %{}) do
 151     last = List.last(activities)
 152     first = List.first(activities)
 153
 154     if last do
 155       min = last.id
 156       max = first.id
 157
 158       {next_url, prev_url} =
 159         if param do
 160           {
 161             mastodon_api_url(
 162               Pleroma.Web.Endpoint,
 163               method,
 164               param,
 165               Map.merge(params, %{max_id: min})
 166             ),
 167             mastodon_api_url(
 168               Pleroma.Web.Endpoint,
 169               method,
 170               param,
 171               Map.merge(params, %{since_id: max})
 172             )
 173           }
 174         else
 175           {
 176             mastodon_api_url(
 177               Pleroma.Web.Endpoint,
 178               method,
 179               Map.merge(params, %{max_id: min})
 180             ),
 181             mastodon_api_url(
 182               Pleroma.Web.Endpoint,
 183               method,
 184               Map.merge(params, %{since_id: max})
 185             )
 186           }
 187         end
 188
 189       conn
 190       |> put_resp_header("link", "<#{next_url}>; rel=\"next\", <#{prev_url}>; rel=\"prev\"")
 191     else
 192       conn
 193     end
 194   end
 195
 196   def home_timeline(%{assigns: %{user: user}} = conn, params) do
 197     params =
 198       params
 199       |> Map.put("type", ["Create", "Announce"])
 200       |> Map.put("blocking_user", user)
 201       |> Map.put("user", user)
 202
 203     activities =
 204       ActivityPub.fetch_activities([user.ap_id | user.following], params)
 205       |> Enum.reverse()
 206
 207     conn
 208     |> add_link_headers(:home_timeline, activities)
 209     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 210   end
 211
 212   def public_timeline(%{assigns: %{user: user}} = conn, params) do
 213     local_only = params["local"] in [true, "True", "true", "1"]
 214
 215     params =
 216       params
 217       |> Map.put("type", ["Create", "Announce"])
 218       |> Map.put("local_only", local_only)
 219       |> Map.put("blocking_user", user)
 220
 221     activities =
 222       ActivityPub.fetch_public_activities(params)
 223       |> Enum.reverse()
 224
 225     conn
 226     |> add_link_headers(:public_timeline, activities, false, %{"local" => local_only})
 227     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 228   end
 229
 230   def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
 231     with %User{} = user <- Repo.get(User, params["id"]) do
 232       # Since Pleroma has no "pinned" posts feature, we'll just set an empty list here
 233       activities =
 234         if params["pinned"] == "true" do
 235           []
 236         else
 237           ActivityPub.fetch_user_activities(user, reading_user, params)
 238         end
 239
 240       conn
 241       |> add_link_headers(:user_statuses, activities, params["id"])
 242       |> render(StatusView, "index.json", %{
 243         activities: activities,
 244         for: reading_user,
 245         as: :activity
 246       })
 247     end
 248   end
 249
 250   def dm_timeline(%{assigns: %{user: user}} = conn, _params) do
 251     query =
 252       ActivityPub.fetch_activities_query([user.ap_id], %{"type" => "Create", visibility: "direct"})
 253
 254     activities = Repo.all(query)
 255
 256     conn
 257     |> add_link_headers(:dm_timeline, activities)
 258     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 259   end
 260
 261   def get_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 262     with %Activity{} = activity <- Repo.get(Activity, id),
 263          true <- ActivityPub.visible_for_user?(activity, user) do
 264       render(conn, StatusView, "status.json", %{activity: activity, for: user})
 265     end
 266   end
 267
 268   def get_context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 269     with %Activity{} = activity <- Repo.get(Activity, id),
 270          activities <-
 271            ActivityPub.fetch_activities_for_context(activity.data["context"], %{
 272              "blocking_user" => user,
 273              "user" => user
 274            }),
 275          activities <-
 276            activities |> Enum.filter(fn %{id: aid} -> to_string(aid) != to_string(id) end),
 277          activities <-
 278            activities |> Enum.filter(fn %{data: %{"type" => type}} -> type == "Create" end),
 279          grouped_activities <- Enum.group_by(activities, fn %{id: id} -> id < activity.id end) do
 280       result = %{
 281         ancestors:
 282           StatusView.render(
 283             "index.json",
 284             for: user,
 285             activities: grouped_activities[true] || [],
 286             as: :activity
 287           )
 288           |> Enum.reverse(),
 289         descendants:
 290           StatusView.render(
 291             "index.json",
 292             for: user,
 293             activities: grouped_activities[false] || [],
 294             as: :activity
 295           )
 296           |> Enum.reverse()
 297       }
 298
 299       json(conn, result)
 300     end
 301   end
 302
 303   def post_status(conn, %{"status" => "", "media_ids" => media_ids} = params)
 304       when length(media_ids) > 0 do
 305     params =
 306       params
 307       |> Map.put("status", ".")
 308
 309     post_status(conn, params)
 310   end
 311
 312   def post_status(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
 313     params =
 314       params
 315       |> Map.put("in_reply_to_status_id", params["in_reply_to_id"])
 316       |> Map.put("no_attachment_links", true)
 317
 318     idempotency_key =
 319       case get_req_header(conn, "idempotency-key") do
 320         [key] -> key
 321         _ -> Ecto.UUID.generate()
 322       end
 323
 324     {:ok, activity} =
 325       Cachex.fetch!(:idempotency_cache, idempotency_key, fn _ -> CommonAPI.post(user, params) end)
 326
 327     render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 328   end
 329
 330   def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 331     with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
 332       json(conn, %{})
 333     else
 334       _e ->
 335         conn
 336         |> put_status(403)
 337         |> json(%{error: "Can't delete this post"})
 338     end
 339   end
 340
 341   def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 342     with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user) do
 343       render(conn, StatusView, "status.json", %{activity: announce, for: user, as: :activity})
 344     end
 345   end
 346
 347   def unreblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 348     with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
 349          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
 350       render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 351     end
 352   end
 353
 354   def fav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 355     with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
 356          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
 357       render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 358     end
 359   end
 360
 361   def unfav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 362     with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
 363          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
 364       render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 365     end
 366   end
 367
 368   def notifications(%{assigns: %{user: user}} = conn, params) do
 369     notifications = Notification.for_user(user, params)
 370
 371     result =
 372       Enum.map(notifications, fn x ->
 373         render_notification(user, x)
 374       end)
 375       |> Enum.filter(& &1)
 376
 377     conn
 378     |> add_link_headers(:notifications, notifications)
 379     |> json(result)
 380   end
 381
 382   def get_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
 383     with {:ok, notification} <- Notification.get(user, id) do
 384       json(conn, render_notification(user, notification))
 385     else
 386       {:error, reason} ->
 387         conn
 388         |> put_resp_content_type("application/json")
 389         |> send_resp(403, Jason.encode!(%{"error" => reason}))
 390     end
 391   end
 392
 393   def clear_notifications(%{assigns: %{user: user}} = conn, _params) do
 394     Notification.clear(user)
 395     json(conn, %{})
 396   end
 397
 398   def dismiss_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
 399     with {:ok, _notif} <- Notification.dismiss(user, id) do
 400       json(conn, %{})
 401     else
 402       {:error, reason} ->
 403         conn
 404         |> put_resp_content_type("application/json")
 405         |> send_resp(403, Jason.encode!(%{"error" => reason}))
 406     end
 407   end
 408
 409   def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 410     id = List.wrap(id)
 411     q = from(u in User, where: u.id in ^id)
 412     targets = Repo.all(q)
 413     render(conn, AccountView, "relationships.json", %{user: user, targets: targets})
 414   end
 415
 416   def upload(%{assigns: %{user: _}} = conn, %{"file" => file}) do
 417     with {:ok, object} <- ActivityPub.upload(file) do
 418       data =
 419         object.data
 420         |> Map.put("id", object.id)
 421
 422       render(conn, StatusView, "attachment.json", %{attachment: data})
 423     end
 424   end
 425
 426   def favourited_by(conn, %{"id" => id}) do
 427     with %Activity{data: %{"object" => %{"likes" => likes}}} <- Repo.get(Activity, id) do
 428       q = from(u in User, where: u.ap_id in ^likes)
 429       users = Repo.all(q)
 430       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 431     else
 432       _ -> json(conn, [])
 433     end
 434   end
 435
 436   def reblogged_by(conn, %{"id" => id}) do
 437     with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Repo.get(Activity, id) do
 438       q = from(u in User, where: u.ap_id in ^announces)
 439       users = Repo.all(q)
 440       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 441     else
 442       _ -> json(conn, [])
 443     end
 444   end
 445
 446   def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
 447     local_only = params["local"] in [true, "True", "true", "1"]
 448
 449     params =
 450       params
 451       |> Map.put("type", "Create")
 452       |> Map.put("local_only", local_only)
 453       |> Map.put("blocking_user", user)
 454
 455     activities =
 456       ActivityPub.fetch_public_activities(params)
 457       |> Enum.reverse()
 458
 459     conn
 460     |> add_link_headers(:hashtag_timeline, activities, params["tag"], %{"local" => local_only})
 461     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 462   end
 463
 464   # TODO: Pagination
 465   def followers(conn, %{"id" => id}) do
 466     with %User{} = user <- Repo.get(User, id),
 467          {:ok, followers} <- User.get_followers(user) do
 468       render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
 469     end
 470   end
 471
 472   def following(conn, %{"id" => id}) do
 473     with %User{} = user <- Repo.get(User, id),
 474          {:ok, followers} <- User.get_friends(user) do
 475       render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
 476     end
 477   end
 478
 479   def follow_requests(%{assigns: %{user: followed}} = conn, _params) do
 480     with {:ok, follow_requests} <- User.get_follow_requests(followed) do
 481       render(conn, AccountView, "accounts.json", %{users: follow_requests, as: :user})
 482     end
 483   end
 484
 485   def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
 486     with %User{} = followed <- Repo.get(User, id),
 487          {:ok, follower} <- User.maybe_direct_follow(follower, followed),
 488          {:ok, _activity} <- ActivityPub.follow(follower, followed) do
 489       render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
 490     else
 491       {:error, message} ->
 492         conn
 493         |> put_resp_content_type("application/json")
 494         |> send_resp(403, Jason.encode!(%{"error" => message}))
 495     end
 496   end
 497
 498   def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
 499     with %User{} = followed <- Repo.get_by(User, nickname: uri),
 500          {:ok, follower} <- User.maybe_direct_follow(follower, followed),
 501          {:ok, _activity} <- ActivityPub.follow(follower, followed) do
 502       render(conn, AccountView, "account.json", %{user: followed})
 503     else
 504       {:error, message} ->
 505         conn
 506         |> put_resp_content_type("application/json")
 507         |> send_resp(403, Jason.encode!(%{"error" => message}))
 508     end
 509   end
 510
 511   def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
 512     with %User{} = followed <- Repo.get(User, id),
 513          {:ok, _activity} <- ActivityPub.unfollow(follower, followed),
 514          {:ok, follower, _} <- User.unfollow(follower, followed) do
 515       render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
 516     end
 517   end
 518
 519   def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
 520     with %User{} = blocked <- Repo.get(User, id),
 521          {:ok, blocker} <- User.block(blocker, blocked),
 522          {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
 523       render(conn, AccountView, "relationship.json", %{user: blocker, target: blocked})
 524     else
 525       {:error, message} ->
 526         conn
 527         |> put_resp_content_type("application/json")
 528         |> send_resp(403, Jason.encode!(%{"error" => message}))
 529     end
 530   end
 531
 532   def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
 533     with %User{} = blocked <- Repo.get(User, id),
 534          {:ok, blocker} <- User.unblock(blocker, blocked),
 535          {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
 536       render(conn, AccountView, "relationship.json", %{user: blocker, target: blocked})
 537     else
 538       {:error, message} ->
 539         conn
 540         |> put_resp_content_type("application/json")
 541         |> send_resp(403, Jason.encode!(%{"error" => message}))
 542     end
 543   end
 544
 545   # TODO: Use proper query
 546   def blocks(%{assigns: %{user: user}} = conn, _) do
 547     with blocked_users <- user.info["blocks"] || [],
 548          accounts <- Enum.map(blocked_users, fn ap_id -> User.get_cached_by_ap_id(ap_id) end) do
 549       res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
 550       json(conn, res)
 551     end
 552   end
 553
 554   def domain_blocks(%{assigns: %{user: %{info: info}}} = conn, _) do
 555     json(conn, info["domain_blocks"] || [])
 556   end
 557
 558   def block_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
 559     User.block_domain(blocker, domain)
 560     json(conn, %{})
 561   end
 562
 563   def unblock_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
 564     User.unblock_domain(blocker, domain)
 565     json(conn, %{})
 566   end
 567
 568   def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 569     accounts = User.search(query, params["resolve"] == "true")
 570
 571     fetched =
 572       if Regex.match?(~r/https?:/, query) do
 573         with {:ok, activities} <- OStatus.fetch_activity_from_url(query) do
 574           activities
 575           |> Enum.filter(fn
 576             %{data: %{"type" => "Create"}} -> true
 577             _ -> false
 578           end)
 579         else
 580           _e -> []
 581         end
 582       end || []
 583
 584     q =
 585       from(
 586         a in Activity,
 587         where: fragment("?->>'type' = 'Create'", a.data),
 588         where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
 589         where:
 590           fragment(
 591             "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
 592             a.data,
 593             ^query
 594           ),
 595         limit: 20,
 596         order_by: [desc: :id]
 597       )
 598
 599     statuses = Repo.all(q) ++ fetched
 600
 601     tags =
 602       String.split(query)
 603       |> Enum.uniq()
 604       |> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
 605       |> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
 606
 607     res = %{
 608       "accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
 609       "statuses" =>
 610         StatusView.render("index.json", activities: statuses, for: user, as: :activity),
 611       "hashtags" => tags
 612     }
 613
 614     json(conn, res)
 615   end
 616
 617   def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 618     accounts = User.search(query, params["resolve"] == "true")
 619
 620     res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
 621
 622     json(conn, res)
 623   end
 624
 625   def favourites(%{assigns: %{user: user}} = conn, _) do
 626     params =
 627       %{}
 628       |> Map.put("type", "Create")
 629       |> Map.put("favorited_by", user.ap_id)
 630       |> Map.put("blocking_user", user)
 631
 632     activities =
 633       ActivityPub.fetch_public_activities(params)
 634       |> Enum.reverse()
 635
 636     conn
 637     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 638   end
 639
 640   def get_lists(%{assigns: %{user: user}} = conn, opts) do
 641     lists = Pleroma.List.for_user(user, opts)
 642     res = ListView.render("lists.json", lists: lists)
 643     json(conn, res)
 644   end
 645
 646   def get_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 647     with %Pleroma.List{} = list <- Pleroma.List.get(id, user) do
 648       res = ListView.render("list.json", list: list)
 649       json(conn, res)
 650     else
 651       _e -> json(conn, "error")
 652     end
 653   end
 654
 655   def delete_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 656     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 657          {:ok, _list} <- Pleroma.List.delete(list) do
 658       json(conn, %{})
 659     else
 660       _e ->
 661         json(conn, "error")
 662     end
 663   end
 664
 665   def create_list(%{assigns: %{user: user}} = conn, %{"title" => title}) do
 666     with {:ok, %Pleroma.List{} = list} <- Pleroma.List.create(title, user) do
 667       res = ListView.render("list.json", list: list)
 668       json(conn, res)
 669     end
 670   end
 671
 672   def add_to_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
 673     accounts
 674     |> Enum.each(fn account_id ->
 675       with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 676            %User{} = followed <- Repo.get(User, account_id) do
 677         Pleroma.List.follow(list, followed)
 678       end
 679     end)
 680
 681     json(conn, %{})
 682   end
 683
 684   def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
 685     accounts
 686     |> Enum.each(fn account_id ->
 687       with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 688            %User{} = followed <- Repo.get(Pleroma.User, account_id) do
 689         Pleroma.List.unfollow(list, followed)
 690       end
 691     end)
 692
 693     json(conn, %{})
 694   end
 695
 696   def list_accounts(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 697     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 698          {:ok, users} = Pleroma.List.get_following(list) do
 699       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 700     end
 701   end
 702
 703   def rename_list(%{assigns: %{user: user}} = conn, %{"id" => id, "title" => title}) do
 704     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 705          {:ok, list} <- Pleroma.List.rename(list, title) do
 706       res = ListView.render("list.json", list: list)
 707       json(conn, res)
 708     else
 709       _e ->
 710         json(conn, "error")
 711     end
 712   end
 713
 714   def list_timeline(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params) do
 715     with %Pleroma.List{title: title, following: following} <- Pleroma.List.get(id, user) do
 716       params =
 717         params
 718         |> Map.put("type", "Create")
 719         |> Map.put("blocking_user", user)
 720
 721       # adding title is a hack to not make empty lists function like a public timeline
 722       activities =
 723         ActivityPub.fetch_activities([title | following], params)
 724         |> Enum.reverse()
 725
 726       conn
 727       |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 728     else
 729       _e ->
 730         conn
 731         |> put_status(403)
 732         |> json(%{error: "Error."})
 733     end
 734   end
 735
 736   def index(%{assigns: %{user: user}} = conn, _params) do
 737     token =
 738       conn
 739       |> get_session(:oauth_token)
 740
 741     if user && token do
 742       mastodon_emoji = mastodonized_emoji()
 743       accounts = Map.put(%{}, user.id, AccountView.render("account.json", %{user: user}))
 744
 745       initial_state =
 746         %{
 747           meta: %{
 748             streaming_api_base_url:
 749               String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws"),
 750             access_token: token,
 751             locale: "en",
 752             domain: Pleroma.Web.Endpoint.host(),
 753             admin: "1",
 754             me: "#{user.id}",
 755             unfollow_modal: false,
 756             boost_modal: false,
 757             delete_modal: true,
 758             auto_play_gif: false,
 759             reduce_motion: false
 760           },
 761           compose: %{
 762             me: "#{user.id}",
 763             default_privacy: "public",
 764             default_sensitive: false
 765           },
 766           media_attachments: %{
 767             accept_content_types: [
 768               ".jpg",
 769               ".jpeg",
 770               ".png",
 771               ".gif",
 772               ".webm",
 773               ".mp4",
 774               ".m4v",
 775               "image\/jpeg",
 776               "image\/png",
 777               "image\/gif",
 778               "video\/webm",
 779               "video\/mp4"
 780             ]
 781           },
 782           settings:
 783             Map.get(user.info, "settings") ||
 784               %{
 785                 onboarded: true,
 786                 home: %{
 787                   shows: %{
 788                     reblog: true,
 789                     reply: true
 790                   }
 791                 },
 792                 notifications: %{
 793                   alerts: %{
 794                     follow: true,
 795                     favourite: true,
 796                     reblog: true,
 797                     mention: true
 798                   },
 799                   shows: %{
 800                     follow: true,
 801                     favourite: true,
 802                     reblog: true,
 803                     mention: true
 804                   },
 805                   sounds: %{
 806                     follow: true,
 807                     favourite: true,
 808                     reblog: true,
 809                     mention: true
 810                   }
 811                 }
 812               },
 813           push_subscription: nil,
 814           accounts: accounts,
 815           custom_emojis: mastodon_emoji,
 816           char_limit: Keyword.get(@instance, :limit)
 817         }
 818         |> Jason.encode!()
 819
 820       conn
 821       |> put_layout(false)
 822       |> render(MastodonView, "index.html", %{initial_state: initial_state})
 823     else
 824       conn
 825       |> redirect(to: "/web/login")
 826     end
 827   end
 828
 829   def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
 830     with new_info <- Map.put(user.info, "settings", settings),
 831          change <- User.info_changeset(user, %{info: new_info}),
 832          {:ok, _user} <- User.update_and_set_cache(change) do
 833       conn
 834       |> json(%{})
 835     else
 836       e ->
 837         conn
 838         |> json(%{error: inspect(e)})
 839     end
 840   end
 841
 842   def login(conn, _) do
 843     conn
 844     |> render(MastodonView, "login.html", %{error: false})
 845   end
 846
 847   defp get_or_make_app() do
 848     with %App{} = app <- Repo.get_by(App, client_name: "Mastodon-Local") do
 849       {:ok, app}
 850     else
 851       _e ->
 852         cs =
 853           App.register_changeset(%App{}, %{
 854             client_name: "Mastodon-Local",
 855             redirect_uris: ".",
 856             scopes: "read,write,follow"
 857           })
 858
 859         Repo.insert(cs)
 860     end
 861   end
 862
 863   def login_post(conn, %{"authorization" => %{"name" => name, "password" => password}}) do
 864     with %User{} = user <- User.get_by_nickname_or_email(name),
 865          true <- Pbkdf2.checkpw(password, user.password_hash),
 866          {:ok, app} <- get_or_make_app(),
 867          {:ok, auth} <- Authorization.create_authorization(app, user),
 868          {:ok, token} <- Token.exchange_token(app, auth) do
 869       conn
 870       |> put_session(:oauth_token, token.token)
 871       |> redirect(to: "/web/getting-started")
 872     else
 873       _e ->
 874         conn
 875         |> render(MastodonView, "login.html", %{error: "Wrong username or password"})
 876     end
 877   end
 878
 879   def logout(conn, _) do
 880     conn
 881     |> clear_session
 882     |> redirect(to: "/")
 883   end
 884
 885   def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 886     Logger.debug("Unimplemented, returning unmodified relationship")
 887
 888     with %User{} = target <- Repo.get(User, id) do
 889       render(conn, AccountView, "relationship.json", %{user: user, target: target})
 890     end
 891   end
 892
 893   def empty_array(conn, _) do
 894     Logger.debug("Unimplemented, returning an empty array")
 895     json(conn, [])
 896   end
 897
 898   def empty_object(conn, _) do
 899     Logger.debug("Unimplemented, returning an empty object")
 900     json(conn, %{})
 901   end
 902
 903   def render_notification(user, %{id: id, activity: activity, inserted_at: created_at} = _params) do
 904     actor = User.get_cached_by_ap_id(activity.data["actor"])
 905
 906     created_at =
 907       NaiveDateTime.to_iso8601(created_at)
 908       |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
 909
 910     case activity.data["type"] do
 911       "Create" ->
 912         %{
 913           id: id,
 914           type: "mention",
 915           created_at: created_at,
 916           account: AccountView.render("account.json", %{user: actor}),
 917           status: StatusView.render("status.json", %{activity: activity, for: user})
 918         }
 919
 920       "Like" ->
 921         liked_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
 922
 923         %{
 924           id: id,
 925           type: "favourite",
 926           created_at: created_at,
 927           account: AccountView.render("account.json", %{user: actor}),
 928           status: StatusView.render("status.json", %{activity: liked_activity, for: user})
 929         }
 930
 931       "Announce" ->
 932         announced_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
 933
 934         %{
 935           id: id,
 936           type: "reblog",
 937           created_at: created_at,
 938           account: AccountView.render("account.json", %{user: actor}),
 939           status: StatusView.render("status.json", %{activity: announced_activity, for: user})
 940         }
 941
 942       "Follow" ->
 943         %{
 944           id: id,
 945           type: "follow",
 946           created_at: created_at,
 947           account: AccountView.render("account.json", %{user: actor})
 948         }
 949
 950       _ ->
 951         nil
 952     end
 953   end
 954
 955   def errors(conn, _) do
 956     conn
 957     |> put_status(500)
 958     |> json("Something went wrong")
 959   end
 960 end