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