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