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