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