git.squeep.com Git - akkoma/blob - lib/pleroma/web/twitter_api/twitter_api_controller.ex

   1 defmodule Pleroma.Web.TwitterAPI.Controller do
   2   use Pleroma.Web, :controller
   3   alias Pleroma.Formatter
   4   alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView, ActivityView, NotificationView}
   5   alias Pleroma.Web.CommonAPI
   6   alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
   7   alias Pleroma.{Repo, Activity, User, Notification}
   8   alias Pleroma.Web.ActivityPub.ActivityPub
   9   alias Pleroma.Web.ActivityPub.Utils
  10   alias Ecto.Changeset
  11
  12   require Logger
  13
  14   plug(:only_if_public_instance when action in [:public_timeline, :public_and_external_timeline])
  15   action_fallback(:errors)
  16
  17   def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
  18     token = Phoenix.Token.sign(conn, "user socket", user.id)
  19     render(conn, UserView, "show.json", %{user: user, token: token})
  20   end
  21
  22   def status_update(%{assigns: %{user: user}} = conn, %{"status" => _} = status_data) do
  23     with media_ids <- extract_media_ids(status_data),
  24          {:ok, activity} <-
  25            TwitterAPI.create_status(user, Map.put(status_data, "media_ids", media_ids)) do
  26       conn
  27       |> json(ActivityView.render("activity.json", activity: activity, for: user))
  28     else
  29       _ -> empty_status_reply(conn)
  30     end
  31   end
  32
  33   def status_update(conn, _status_data) do
  34     empty_status_reply(conn)
  35   end
  36
  37   defp empty_status_reply(conn) do
  38     bad_request_reply(conn, "Client must provide a 'status' parameter with a value.")
  39   end
  40
  41   defp extract_media_ids(status_data) do
  42     with media_ids when not is_nil(media_ids) <- status_data["media_ids"],
  43          split_ids <- String.split(media_ids, ","),
  44          clean_ids <- Enum.reject(split_ids, fn id -> String.length(id) == 0 end) do
  45       clean_ids
  46     else
  47       _e -> []
  48     end
  49   end
  50
  51   def public_and_external_timeline(%{assigns: %{user: user}} = conn, params) do
  52     params =
  53       params
  54       |> Map.put("type", ["Create", "Announce"])
  55       |> Map.put("blocking_user", user)
  56
  57     activities = ActivityPub.fetch_public_activities(params)
  58
  59     conn
  60     |> render(ActivityView, "index.json", %{activities: activities, for: user})
  61   end
  62
  63   def public_timeline(%{assigns: %{user: user}} = conn, params) do
  64     params =
  65       params
  66       |> Map.put("type", ["Create", "Announce"])
  67       |> Map.put("local_only", true)
  68       |> Map.put("blocking_user", user)
  69
  70     activities = ActivityPub.fetch_public_activities(params)
  71
  72     conn
  73     |> render(ActivityView, "index.json", %{activities: activities, for: user})
  74   end
  75
  76   def friends_timeline(%{assigns: %{user: user}} = conn, params) do
  77     params =
  78       params
  79       |> Map.put("type", ["Create", "Announce", "Follow", "Like"])
  80       |> Map.put("blocking_user", user)
  81       |> Map.put("user", user)
  82
  83     activities =
  84       ActivityPub.fetch_activities([user.ap_id | user.following], params)
  85       |> ActivityPub.contain_timeline(user)
  86
  87     conn
  88     |> render(ActivityView, "index.json", %{activities: activities, for: user})
  89   end
  90
  91   def show_user(conn, params) do
  92     with {:ok, shown} <- TwitterAPI.get_user(params) do
  93       if user = conn.assigns.user do
  94         render(conn, UserView, "show.json", %{user: shown, for: user})
  95       else
  96         render(conn, UserView, "show.json", %{user: shown})
  97       end
  98     else
  99       {:error, msg} ->
 100         bad_request_reply(conn, msg)
 101     end
 102   end
 103
 104   def user_timeline(%{assigns: %{user: user}} = conn, params) do
 105     case TwitterAPI.get_user(user, params) do
 106       {:ok, target_user} ->
 107         activities = ActivityPub.fetch_user_activities(target_user, user, params)
 108
 109         conn
 110         |> render(ActivityView, "index.json", %{activities: activities, for: user})
 111
 112       {:error, msg} ->
 113         bad_request_reply(conn, msg)
 114     end
 115   end
 116
 117   def mentions_timeline(%{assigns: %{user: user}} = conn, params) do
 118     params =
 119       params
 120       |> Map.put("type", ["Create", "Announce", "Follow", "Like"])
 121       |> Map.put("blocking_user", user)
 122
 123     activities = ActivityPub.fetch_activities([user.ap_id], params)
 124
 125     conn
 126     |> render(ActivityView, "index.json", %{activities: activities, for: user})
 127   end
 128
 129   def notifications(%{assigns: %{user: user}} = conn, params) do
 130     notifications = Notification.for_user(user, params)
 131
 132     conn
 133     |> render(NotificationView, "notification.json", %{notifications: notifications, for: user})
 134   end
 135
 136   def notifications_read(%{assigns: %{user: user}} = conn, %{"latest_id" => latest_id} = params) do
 137     Notification.set_read_up_to(user, latest_id)
 138
 139     notifications = Notification.for_user(user, params)
 140
 141     conn
 142     |> render(NotificationView, "notification.json", %{notifications: notifications, for: user})
 143   end
 144
 145   def notifications_read(%{assigns: %{user: user}} = conn, _) do
 146     bad_request_reply(conn, "You need to specify latest_id")
 147   end
 148
 149   def follow(%{assigns: %{user: user}} = conn, params) do
 150     case TwitterAPI.follow(user, params) do
 151       {:ok, user, followed, _activity} ->
 152         render(conn, UserView, "show.json", %{user: followed, for: user})
 153
 154       {:error, msg} ->
 155         forbidden_json_reply(conn, msg)
 156     end
 157   end
 158
 159   def block(%{assigns: %{user: user}} = conn, params) do
 160     case TwitterAPI.block(user, params) do
 161       {:ok, user, blocked} ->
 162         render(conn, UserView, "show.json", %{user: blocked, for: user})
 163
 164       {:error, msg} ->
 165         forbidden_json_reply(conn, msg)
 166     end
 167   end
 168
 169   def unblock(%{assigns: %{user: user}} = conn, params) do
 170     case TwitterAPI.unblock(user, params) do
 171       {:ok, user, blocked} ->
 172         render(conn, UserView, "show.json", %{user: blocked, for: user})
 173
 174       {:error, msg} ->
 175         forbidden_json_reply(conn, msg)
 176     end
 177   end
 178
 179   def delete_post(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 180     with {:ok, activity} <- TwitterAPI.delete(user, id) do
 181       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 182     end
 183   end
 184
 185   def unfollow(%{assigns: %{user: user}} = conn, params) do
 186     case TwitterAPI.unfollow(user, params) do
 187       {:ok, user, unfollowed} ->
 188         render(conn, UserView, "show.json", %{user: unfollowed, for: user})
 189
 190       {:error, msg} ->
 191         forbidden_json_reply(conn, msg)
 192     end
 193   end
 194
 195   def fetch_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 196     with %Activity{} = activity <- Repo.get(Activity, id),
 197          true <- ActivityPub.visible_for_user?(activity, user) do
 198       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 199     end
 200   end
 201
 202   def fetch_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 203     id = String.to_integer(id)
 204
 205     with context when is_binary(context) <- TwitterAPI.conversation_id_to_context(id),
 206          activities <-
 207            ActivityPub.fetch_activities_for_context(context, %{
 208              "blocking_user" => user,
 209              "user" => user
 210            }) do
 211       conn
 212       |> render(ActivityView, "index.json", %{activities: activities, for: user})
 213     end
 214   end
 215
 216   def upload(conn, %{"media" => media}) do
 217     response = TwitterAPI.upload(media)
 218
 219     conn
 220     |> put_resp_content_type("application/atom+xml")
 221     |> send_resp(200, response)
 222   end
 223
 224   def upload_json(conn, %{"media" => media}) do
 225     response = TwitterAPI.upload(media, "json")
 226
 227     conn
 228     |> json_reply(200, response)
 229   end
 230
 231   def get_by_id_or_ap_id(id) do
 232     activity = Repo.get(Activity, id) || Activity.get_create_activity_by_object_ap_id(id)
 233
 234     if activity.data["type"] == "Create" do
 235       activity
 236     else
 237       Activity.get_create_activity_by_object_ap_id(activity.data["object"])
 238     end
 239   end
 240
 241   def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 242     with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
 243          {:ok, activity} <- TwitterAPI.fav(user, id) do
 244       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 245     end
 246   end
 247
 248   def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 249     with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
 250          {:ok, activity} <- TwitterAPI.unfav(user, id) do
 251       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 252     end
 253   end
 254
 255   def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 256     with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
 257          {:ok, activity} <- TwitterAPI.repeat(user, id) do
 258       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 259     end
 260   end
 261
 262   def unretweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 263     with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
 264          {:ok, activity} <- TwitterAPI.unrepeat(user, id) do
 265       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 266     end
 267   end
 268
 269   def register(conn, params) do
 270     with {:ok, user} <- TwitterAPI.register_user(params) do
 271       render(conn, UserView, "show.json", %{user: user})
 272     else
 273       {:error, errors} ->
 274         conn
 275         |> json_reply(400, Jason.encode!(errors))
 276     end
 277   end
 278
 279   def update_avatar(%{assigns: %{user: user}} = conn, params) do
 280     upload_limit =
 281       Application.get_env(:pleroma, :instance)
 282       |> Keyword.fetch(:avatar_upload_limit)
 283
 284     {:ok, object} = ActivityPub.upload(params, upload_limit)
 285     change = Changeset.change(user, %{avatar: object.data})
 286     {:ok, user} = User.update_and_set_cache(change)
 287     CommonAPI.update(user)
 288
 289     render(conn, UserView, "show.json", %{user: user, for: user})
 290   end
 291
 292   def update_banner(%{assigns: %{user: user}} = conn, params) do
 293     upload_limit =
 294       Application.get_env(:pleroma, :instance)
 295       |> Keyword.fetch(:banner_upload_limit)
 296
 297     with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}, upload_limit),
 298          new_info <- Map.put(user.info, "banner", object.data),
 299          change <- User.info_changeset(user, %{info: new_info}),
 300          {:ok, user} <- User.update_and_set_cache(change) do
 301       CommonAPI.update(user)
 302       %{"url" => [%{"href" => href} | _]} = object.data
 303       response = %{url: href} |> Jason.encode!()
 304
 305       conn
 306       |> json_reply(200, response)
 307     end
 308   end
 309
 310   def update_background(%{assigns: %{user: user}} = conn, params) do
 311     upload_limit =
 312       Application.get_env(:pleroma, :instance)
 313       |> Keyword.fetch(:background_upload_limit)
 314
 315     with {:ok, object} <- ActivityPub.upload(params, upload_limit),
 316          new_info <- Map.put(user.info, "background", object.data),
 317          change <- User.info_changeset(user, %{info: new_info}),
 318          {:ok, _user} <- User.update_and_set_cache(change) do
 319       %{"url" => [%{"href" => href} | _]} = object.data
 320       response = %{url: href} |> Jason.encode!()
 321
 322       conn
 323       |> json_reply(200, response)
 324     end
 325   end
 326
 327   def external_profile(%{assigns: %{user: current_user}} = conn, %{"profileurl" => uri}) do
 328     with {:ok, user_map} <- TwitterAPI.get_external_profile(current_user, uri),
 329          response <- Jason.encode!(user_map) do
 330       conn
 331       |> json_reply(200, response)
 332     else
 333       _e ->
 334         conn
 335         |> put_status(404)
 336         |> json(%{error: "Can't find user"})
 337     end
 338   end
 339
 340   def update_most_recent_notification(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 341     with id when is_number(id) <- String.to_integer(id),
 342          info <- user.info,
 343          mrn <- max(id, user.info["most_recent_notification"] || 0),
 344          updated_info <- Map.put(info, "most_recent_notification", mrn),
 345          changeset <- User.info_changeset(user, %{info: updated_info}),
 346          {:ok, _user} <- User.update_and_set_cache(changeset) do
 347       conn
 348       |> json_reply(200, Jason.encode!(mrn))
 349     else
 350       _e -> bad_request_reply(conn, "Can't update.")
 351     end
 352   end
 353
 354   def followers(conn, params) do
 355     with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
 356          {:ok, followers} <- User.get_followers(user) do
 357       render(conn, UserView, "index.json", %{users: followers, for: conn.assigns[:user]})
 358     else
 359       _e -> bad_request_reply(conn, "Can't get followers")
 360     end
 361   end
 362
 363   def friends(conn, params) do
 364     with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
 365          {:ok, friends} <- User.get_friends(user) do
 366       render(conn, UserView, "index.json", %{users: friends, for: conn.assigns[:user]})
 367     else
 368       _e -> bad_request_reply(conn, "Can't get friends")
 369     end
 370   end
 371
 372   def friend_requests(conn, params) do
 373     with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
 374          {:ok, friend_requests} <- User.get_follow_requests(user) do
 375       render(conn, UserView, "index.json", %{users: friend_requests, for: conn.assigns[:user]})
 376     else
 377       _e -> bad_request_reply(conn, "Can't get friend requests")
 378     end
 379   end
 380
 381   def approve_friend_request(conn, %{"user_id" => uid} = params) do
 382     with followed <- conn.assigns[:user],
 383          uid when is_number(uid) <- String.to_integer(uid),
 384          %User{} = follower <- Repo.get(User, uid),
 385          {:ok, follower} <- User.maybe_follow(follower, followed),
 386          %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
 387          {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
 388          {:ok, _activity} <-
 389            ActivityPub.accept(%{
 390              to: [follower.ap_id],
 391              actor: followed.ap_id,
 392              object: follow_activity.data["id"],
 393              type: "Accept"
 394            }) do
 395       render(conn, UserView, "show.json", %{user: follower, for: followed})
 396     else
 397       e -> bad_request_reply(conn, "Can't approve user: #{inspect(e)}")
 398     end
 399   end
 400
 401   def deny_friend_request(conn, %{"user_id" => uid} = params) do
 402     with followed <- conn.assigns[:user],
 403          uid when is_number(uid) <- String.to_integer(uid),
 404          %User{} = follower <- Repo.get(User, uid),
 405          %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
 406          {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
 407          {:ok, _activity} <-
 408            ActivityPub.reject(%{
 409              to: [follower.ap_id],
 410              actor: followed.ap_id,
 411              object: follow_activity.data["id"],
 412              type: "Reject"
 413            }) do
 414       render(conn, UserView, "show.json", %{user: follower, for: followed})
 415     else
 416       e -> bad_request_reply(conn, "Can't deny user: #{inspect(e)}")
 417     end
 418   end
 419
 420   def friends_ids(%{assigns: %{user: user}} = conn, _params) do
 421     with {:ok, friends} <- User.get_friends(user) do
 422       ids =
 423         friends
 424         |> Enum.map(fn x -> x.id end)
 425         |> Jason.encode!()
 426
 427       json(conn, ids)
 428     else
 429       _e -> bad_request_reply(conn, "Can't get friends")
 430     end
 431   end
 432
 433   def empty_array(conn, _params) do
 434     json(conn, Jason.encode!([]))
 435   end
 436
 437   def raw_empty_array(conn, _params) do
 438     json(conn, [])
 439   end
 440
 441   def update_profile(%{assigns: %{user: user}} = conn, params) do
 442     params =
 443       if bio = params["description"] do
 444         mentions = Formatter.parse_mentions(bio)
 445         tags = Formatter.parse_tags(bio)
 446
 447         emoji =
 448           (user.info["source_data"]["tag"] || [])
 449           |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
 450           |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
 451             {String.trim(name, ":"), url}
 452           end)
 453
 454         bio_html = CommonUtils.format_input(bio, mentions, tags, "text/plain")
 455         Map.put(params, "bio", bio_html |> Formatter.emojify(emoji))
 456       else
 457         params
 458       end
 459
 460     user =
 461       if locked = params["locked"] do
 462         with locked <- locked == "true",
 463              new_info <- Map.put(user.info, "locked", locked),
 464              change <- User.info_changeset(user, %{info: new_info}),
 465              {:ok, user} <- User.update_and_set_cache(change) do
 466           user
 467         else
 468           _e -> user
 469         end
 470       else
 471         user
 472       end
 473
 474     user =
 475       if no_rich_text = params["no_rich_text"] do
 476         with no_rich_text <- no_rich_text == "true",
 477              new_info <- Map.put(user.info, "no_rich_text", no_rich_text),
 478              change <- User.info_changeset(user, %{info: new_info}),
 479              {:ok, user} <- User.update_and_set_cache(change) do
 480           user
 481         else
 482           _e -> user
 483         end
 484       else
 485         user
 486       end
 487
 488     user =
 489       if default_scope = params["default_scope"] do
 490         with new_info <- Map.put(user.info, "default_scope", default_scope),
 491              change <- User.info_changeset(user, %{info: new_info}),
 492              {:ok, user} <- User.update_and_set_cache(change) do
 493           user
 494         else
 495           _e -> user
 496         end
 497       else
 498         user
 499       end
 500
 501     with changeset <- User.update_changeset(user, params),
 502          {:ok, user} <- User.update_and_set_cache(changeset) do
 503       CommonAPI.update(user)
 504       render(conn, UserView, "user.json", %{user: user, for: user})
 505     else
 506       error ->
 507         Logger.debug("Can't update user: #{inspect(error)}")
 508         bad_request_reply(conn, "Can't update user")
 509     end
 510   end
 511
 512   def search(%{assigns: %{user: user}} = conn, %{"q" => _query} = params) do
 513     activities = TwitterAPI.search(user, params)
 514
 515     conn
 516     |> render(ActivityView, "index.json", %{activities: activities, for: user})
 517   end
 518
 519   defp bad_request_reply(conn, error_message) do
 520     json = error_json(conn, error_message)
 521     json_reply(conn, 400, json)
 522   end
 523
 524   defp json_reply(conn, status, json) do
 525     conn
 526     |> put_resp_content_type("application/json")
 527     |> send_resp(status, json)
 528   end
 529
 530   defp forbidden_json_reply(conn, error_message) do
 531     json = error_json(conn, error_message)
 532     json_reply(conn, 403, json)
 533   end
 534
 535   def only_if_public_instance(conn = %{conn: %{assigns: %{user: _user}}}, _), do: conn
 536
 537   def only_if_public_instance(conn, _) do
 538     if Keyword.get(Application.get_env(:pleroma, :instance), :public) do
 539       conn
 540     else
 541       conn
 542       |> forbidden_json_reply("Invalid credentials.")
 543       |> halt()
 544     end
 545   end
 546
 547   defp error_json(conn, error_message) do
 548     %{"error" => error_message, "request" => conn.request_path} |> Jason.encode!()
 549   end
 550
 551   def errors(conn, {:param_cast, _}) do
 552     conn
 553     |> put_status(400)
 554     |> json("Invalid parameters")
 555   end
 556
 557   def errors(conn, _) do
 558     conn
 559     |> put_status(500)
 560     |> json("Something went wrong")
 561   end
 562 end