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(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
 304     params =
 305       params
 306       |> Map.put("in_reply_to_status_id", params["in_reply_to_id"])
 307       |> Map.put("no_attachment_links", true)
 308
 309     idempotency_key =
 310       case get_req_header(conn, "idempotency-key") do
 311         [key] -> key
 312         _ -> Ecto.UUID.generate()
 313       end
 314
 315     {:ok, activity} =
 316       Cachex.fetch!(:idempotency_cache, idempotency_key, fn _ -> CommonAPI.post(user, params) end)
 317
 318     render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 319   end
 320
 321   def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 322     with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
 323       json(conn, %{})
 324     else
 325       _e ->
 326         conn
 327         |> put_status(403)
 328         |> json(%{error: "Can't delete this post"})
 329     end
 330   end
 331
 332   def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 333     with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user) do
 334       render(conn, StatusView, "status.json", %{activity: announce, for: user, as: :activity})
 335     end
 336   end
 337
 338   def unreblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 339     with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
 340          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
 341       render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 342     end
 343   end
 344
 345   def fav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 346     with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
 347          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
 348       render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 349     end
 350   end
 351
 352   def unfav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
 353     with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
 354          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
 355       render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
 356     end
 357   end
 358
 359   def notifications(%{assigns: %{user: user}} = conn, params) do
 360     notifications = Notification.for_user(user, params)
 361
 362     result =
 363       Enum.map(notifications, fn x ->
 364         render_notification(user, x)
 365       end)
 366       |> Enum.filter(& &1)
 367
 368     conn
 369     |> add_link_headers(:notifications, notifications)
 370     |> json(result)
 371   end
 372
 373   def get_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
 374     with {:ok, notification} <- Notification.get(user, id) do
 375       json(conn, render_notification(user, notification))
 376     else
 377       {:error, reason} ->
 378         conn
 379         |> put_resp_content_type("application/json")
 380         |> send_resp(403, Jason.encode!(%{"error" => reason}))
 381     end
 382   end
 383
 384   def clear_notifications(%{assigns: %{user: user}} = conn, _params) do
 385     Notification.clear(user)
 386     json(conn, %{})
 387   end
 388
 389   def dismiss_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
 390     with {:ok, _notif} <- Notification.dismiss(user, id) do
 391       json(conn, %{})
 392     else
 393       {:error, reason} ->
 394         conn
 395         |> put_resp_content_type("application/json")
 396         |> send_resp(403, Jason.encode!(%{"error" => reason}))
 397     end
 398   end
 399
 400   def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 401     id = List.wrap(id)
 402     q = from(u in User, where: u.id in ^id)
 403     targets = Repo.all(q)
 404     render(conn, AccountView, "relationships.json", %{user: user, targets: targets})
 405   end
 406
 407   def upload(%{assigns: %{user: _}} = conn, %{"file" => file}) do
 408     with {:ok, object} <- ActivityPub.upload(file) do
 409       data =
 410         object.data
 411         |> Map.put("id", object.id)
 412
 413       render(conn, StatusView, "attachment.json", %{attachment: data})
 414     end
 415   end
 416
 417   def favourited_by(conn, %{"id" => id}) do
 418     with %Activity{data: %{"object" => %{"likes" => likes}}} <- Repo.get(Activity, id) do
 419       q = from(u in User, where: u.ap_id in ^likes)
 420       users = Repo.all(q)
 421       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 422     else
 423       _ -> json(conn, [])
 424     end
 425   end
 426
 427   def reblogged_by(conn, %{"id" => id}) do
 428     with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Repo.get(Activity, id) do
 429       q = from(u in User, where: u.ap_id in ^announces)
 430       users = Repo.all(q)
 431       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 432     else
 433       _ -> json(conn, [])
 434     end
 435   end
 436
 437   def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
 438     local_only = params["local"] in [true, "True", "true", "1"]
 439
 440     params =
 441       params
 442       |> Map.put("type", "Create")
 443       |> Map.put("local_only", local_only)
 444       |> Map.put("blocking_user", user)
 445
 446     activities =
 447       ActivityPub.fetch_public_activities(params)
 448       |> Enum.reverse()
 449
 450     conn
 451     |> add_link_headers(:hashtag_timeline, activities, params["tag"], %{"local" => local_only})
 452     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 453   end
 454
 455   # TODO: Pagination
 456   def followers(conn, %{"id" => id}) do
 457     with %User{} = user <- Repo.get(User, id),
 458          {:ok, followers} <- User.get_followers(user) do
 459       render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
 460     end
 461   end
 462
 463   def following(conn, %{"id" => id}) do
 464     with %User{} = user <- Repo.get(User, id),
 465          {:ok, followers} <- User.get_friends(user) do
 466       render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
 467     end
 468   end
 469
 470   def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
 471     with %User{} = followed <- Repo.get(User, id),
 472          {:ok, follower} <- User.maybe_direct_follow(follower, followed),
 473          {:ok, _activity} <- ActivityPub.follow(follower, followed) do
 474       render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
 475     else
 476       {:error, message} ->
 477         conn
 478         |> put_resp_content_type("application/json")
 479         |> send_resp(403, Jason.encode!(%{"error" => message}))
 480     end
 481   end
 482
 483   def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
 484     with %User{} = followed <- Repo.get_by(User, nickname: uri),
 485          {:ok, follower} <- User.maybe_direct_follow(follower, followed),
 486          {:ok, _activity} <- ActivityPub.follow(follower, followed) do
 487       render(conn, AccountView, "account.json", %{user: followed})
 488     else
 489       {:error, message} ->
 490         conn
 491         |> put_resp_content_type("application/json")
 492         |> send_resp(403, Jason.encode!(%{"error" => message}))
 493     end
 494   end
 495
 496   def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
 497     with %User{} = followed <- Repo.get(User, id),
 498          {:ok, _activity} <- ActivityPub.unfollow(follower, followed),
 499          {:ok, follower, _} <- User.unfollow(follower, followed) do
 500       render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
 501     end
 502   end
 503
 504   def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
 505     with %User{} = blocked <- Repo.get(User, id),
 506          {:ok, blocker} <- User.block(blocker, blocked),
 507          {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
 508       render(conn, AccountView, "relationship.json", %{user: blocker, target: blocked})
 509     else
 510       {:error, message} ->
 511         conn
 512         |> put_resp_content_type("application/json")
 513         |> send_resp(403, Jason.encode!(%{"error" => message}))
 514     end
 515   end
 516
 517   def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
 518     with %User{} = blocked <- Repo.get(User, id),
 519          {:ok, blocker} <- User.unblock(blocker, blocked),
 520          {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
 521       render(conn, AccountView, "relationship.json", %{user: blocker, target: blocked})
 522     else
 523       {:error, message} ->
 524         conn
 525         |> put_resp_content_type("application/json")
 526         |> send_resp(403, Jason.encode!(%{"error" => message}))
 527     end
 528   end
 529
 530   # TODO: Use proper query
 531   def blocks(%{assigns: %{user: user}} = conn, _) do
 532     with blocked_users <- user.info["blocks"] || [],
 533          accounts <- Enum.map(blocked_users, fn ap_id -> User.get_cached_by_ap_id(ap_id) end) do
 534       res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
 535       json(conn, res)
 536     end
 537   end
 538
 539   def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 540     accounts = User.search(query, params["resolve"] == "true")
 541
 542     fetched =
 543       if Regex.match?(~r/https?:/, query) do
 544         with {:ok, activities} <- OStatus.fetch_activity_from_url(query) do
 545           activities
 546           |> Enum.filter(fn
 547             %{data: %{"type" => "Create"}} -> true
 548             _ -> false
 549           end)
 550         else
 551           _e -> []
 552         end
 553       end || []
 554
 555     q =
 556       from(
 557         a in Activity,
 558         where: fragment("?->>'type' = 'Create'", a.data),
 559         where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
 560         where:
 561           fragment(
 562             "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
 563             a.data,
 564             ^query
 565           ),
 566         limit: 20,
 567         order_by: [desc: :id]
 568       )
 569
 570     statuses = Repo.all(q) ++ fetched
 571
 572     tags =
 573       String.split(query)
 574       |> Enum.uniq()
 575       |> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
 576       |> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
 577
 578     res = %{
 579       "accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
 580       "statuses" =>
 581         StatusView.render("index.json", activities: statuses, for: user, as: :activity),
 582       "hashtags" => tags
 583     }
 584
 585     json(conn, res)
 586   end
 587
 588   def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 589     accounts = User.search(query, params["resolve"] == "true")
 590
 591     res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
 592
 593     json(conn, res)
 594   end
 595
 596   def favourites(%{assigns: %{user: user}} = conn, _) do
 597     params =
 598       %{}
 599       |> Map.put("type", "Create")
 600       |> Map.put("favorited_by", user.ap_id)
 601       |> Map.put("blocking_user", user)
 602
 603     activities =
 604       ActivityPub.fetch_public_activities(params)
 605       |> Enum.reverse()
 606
 607     conn
 608     |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 609   end
 610
 611   def get_lists(%{assigns: %{user: user}} = conn, opts) do
 612     lists = Pleroma.List.for_user(user, opts)
 613     res = ListView.render("lists.json", lists: lists)
 614     json(conn, res)
 615   end
 616
 617   def get_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 618     with %Pleroma.List{} = list <- Pleroma.List.get(id, user) do
 619       res = ListView.render("list.json", list: list)
 620       json(conn, res)
 621     else
 622       _e -> json(conn, "error")
 623     end
 624   end
 625
 626   def delete_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 627     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 628          {:ok, _list} <- Pleroma.List.delete(list) do
 629       json(conn, %{})
 630     else
 631       _e ->
 632         json(conn, "error")
 633     end
 634   end
 635
 636   def create_list(%{assigns: %{user: user}} = conn, %{"title" => title}) do
 637     with {:ok, %Pleroma.List{} = list} <- Pleroma.List.create(title, user) do
 638       res = ListView.render("list.json", list: list)
 639       json(conn, res)
 640     end
 641   end
 642
 643   def add_to_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
 644     accounts
 645     |> Enum.each(fn account_id ->
 646       with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 647            %User{} = followed <- Repo.get(User, account_id) do
 648         Pleroma.List.follow(list, followed)
 649       end
 650     end)
 651
 652     json(conn, %{})
 653   end
 654
 655   def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
 656     accounts
 657     |> Enum.each(fn account_id ->
 658       with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 659            %User{} = followed <- Repo.get(Pleroma.User, account_id) do
 660         Pleroma.List.unfollow(list, followed)
 661       end
 662     end)
 663
 664     json(conn, %{})
 665   end
 666
 667   def list_accounts(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 668     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 669          {:ok, users} = Pleroma.List.get_following(list) do
 670       render(conn, AccountView, "accounts.json", %{users: users, as: :user})
 671     end
 672   end
 673
 674   def rename_list(%{assigns: %{user: user}} = conn, %{"id" => id, "title" => title}) do
 675     with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
 676          {:ok, list} <- Pleroma.List.rename(list, title) do
 677       res = ListView.render("list.json", list: list)
 678       json(conn, res)
 679     else
 680       _e ->
 681         json(conn, "error")
 682     end
 683   end
 684
 685   def list_timeline(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params) do
 686     with %Pleroma.List{title: title, following: following} <- Pleroma.List.get(id, user) do
 687       params =
 688         params
 689         |> Map.put("type", "Create")
 690         |> Map.put("blocking_user", user)
 691
 692       # adding title is a hack to not make empty lists function like a public timeline
 693       activities =
 694         ActivityPub.fetch_activities([title | following], params)
 695         |> Enum.reverse()
 696
 697       conn
 698       |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
 699     else
 700       _e ->
 701         conn
 702         |> put_status(403)
 703         |> json(%{error: "Error."})
 704     end
 705   end
 706
 707   def index(%{assigns: %{user: user}} = conn, _params) do
 708     token =
 709       conn
 710       |> get_session(:oauth_token)
 711
 712     if user && token do
 713       mastodon_emoji = mastodonized_emoji()
 714       accounts = Map.put(%{}, user.id, AccountView.render("account.json", %{user: user}))
 715
 716       initial_state =
 717         %{
 718           meta: %{
 719             streaming_api_base_url:
 720               String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws"),
 721             access_token: token,
 722             locale: "en",
 723             domain: Pleroma.Web.Endpoint.host(),
 724             admin: "1",
 725             me: "#{user.id}",
 726             unfollow_modal: false,
 727             boost_modal: false,
 728             delete_modal: true,
 729             auto_play_gif: false,
 730             reduce_motion: false
 731           },
 732           compose: %{
 733             me: "#{user.id}",
 734             default_privacy: "public",
 735             default_sensitive: false
 736           },
 737           media_attachments: %{
 738             accept_content_types: [
 739               ".jpg",
 740               ".jpeg",
 741               ".png",
 742               ".gif",
 743               ".webm",
 744               ".mp4",
 745               ".m4v",
 746               "image\/jpeg",
 747               "image\/png",
 748               "image\/gif",
 749               "video\/webm",
 750               "video\/mp4"
 751             ]
 752           },
 753           settings:
 754             Map.get(user.info, "settings") ||
 755               %{
 756                 onboarded: true,
 757                 home: %{
 758                   shows: %{
 759                     reblog: true,
 760                     reply: true
 761                   }
 762                 },
 763                 notifications: %{
 764                   alerts: %{
 765                     follow: true,
 766                     favourite: true,
 767                     reblog: true,
 768                     mention: true
 769                   },
 770                   shows: %{
 771                     follow: true,
 772                     favourite: true,
 773                     reblog: true,
 774                     mention: true
 775                   },
 776                   sounds: %{
 777                     follow: true,
 778                     favourite: true,
 779                     reblog: true,
 780                     mention: true
 781                   }
 782                 }
 783               },
 784           push_subscription: nil,
 785           accounts: accounts,
 786           custom_emojis: mastodon_emoji,
 787           char_limit: Keyword.get(@instance, :limit)
 788         }
 789         |> Jason.encode!()
 790
 791       conn
 792       |> put_layout(false)
 793       |> render(MastodonView, "index.html", %{initial_state: initial_state})
 794     else
 795       conn
 796       |> redirect(to: "/web/login")
 797     end
 798   end
 799
 800   def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
 801     with new_info <- Map.put(user.info, "settings", settings),
 802          change <- User.info_changeset(user, %{info: new_info}),
 803          {:ok, _user} <- User.update_and_set_cache(change) do
 804       conn
 805       |> json(%{})
 806     else
 807       e ->
 808         conn
 809         |> json(%{error: inspect(e)})
 810     end
 811   end
 812
 813   def login(conn, _) do
 814     conn
 815     |> render(MastodonView, "login.html", %{error: false})
 816   end
 817
 818   defp get_or_make_app() do
 819     with %App{} = app <- Repo.get_by(App, client_name: "Mastodon-Local") do
 820       {:ok, app}
 821     else
 822       _e ->
 823         cs =
 824           App.register_changeset(%App{}, %{
 825             client_name: "Mastodon-Local",
 826             redirect_uris: ".",
 827             scopes: "read,write,follow"
 828           })
 829
 830         Repo.insert(cs)
 831     end
 832   end
 833
 834   def login_post(conn, %{"authorization" => %{"name" => name, "password" => password}}) do
 835     with %User{} = user <- User.get_by_nickname_or_email(name),
 836          true <- Pbkdf2.checkpw(password, user.password_hash),
 837          {:ok, app} <- get_or_make_app(),
 838          {:ok, auth} <- Authorization.create_authorization(app, user),
 839          {:ok, token} <- Token.exchange_token(app, auth) do
 840       conn
 841       |> put_session(:oauth_token, token.token)
 842       |> redirect(to: "/web/getting-started")
 843     else
 844       _e ->
 845         conn
 846         |> render(MastodonView, "login.html", %{error: "Wrong username or password"})
 847     end
 848   end
 849
 850   def logout(conn, _) do
 851     conn
 852     |> clear_session
 853     |> redirect(to: "/")
 854   end
 855
 856   def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 857     Logger.debug("Unimplemented, returning unmodified relationship")
 858
 859     with %User{} = target <- Repo.get(User, id) do
 860       render(conn, AccountView, "relationship.json", %{user: user, target: target})
 861     end
 862   end
 863
 864   def empty_array(conn, _) do
 865     Logger.debug("Unimplemented, returning an empty array")
 866     json(conn, [])
 867   end
 868
 869   def empty_object(conn, _) do
 870     Logger.debug("Unimplemented, returning an empty object")
 871     json(conn, %{})
 872   end
 873
 874   def render_notification(user, %{id: id, activity: activity, inserted_at: created_at} = _params) do
 875     actor = User.get_cached_by_ap_id(activity.data["actor"])
 876
 877     created_at =
 878       NaiveDateTime.to_iso8601(created_at)
 879       |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
 880
 881     case activity.data["type"] do
 882       "Create" ->
 883         %{
 884           id: id,
 885           type: "mention",
 886           created_at: created_at,
 887           account: AccountView.render("account.json", %{user: actor}),
 888           status: StatusView.render("status.json", %{activity: activity, for: user})
 889         }
 890
 891       "Like" ->
 892         liked_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
 893
 894         %{
 895           id: id,
 896           type: "favourite",
 897           created_at: created_at,
 898           account: AccountView.render("account.json", %{user: actor}),
 899           status: StatusView.render("status.json", %{activity: liked_activity, for: user})
 900         }
 901
 902       "Announce" ->
 903         announced_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
 904
 905         %{
 906           id: id,
 907           type: "reblog",
 908           created_at: created_at,
 909           account: AccountView.render("account.json", %{user: actor}),
 910           status: StatusView.render("status.json", %{activity: announced_activity, for: user})
 911         }
 912
 913       "Follow" ->
 914         %{
 915           id: id,
 916           type: "follow",
 917           created_at: created_at,
 918           account: AccountView.render("account.json", %{user: actor})
 919         }
 920
 921       _ ->
 922         nil
 923     end
 924   end
 925
 926   def errors(conn, _) do
 927     conn
 928     |> put_status(500)
 929     |> json("Something went wrong")
 930   end
 931 end