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     {:ok, object} = ActivityPub.upload(params)
 267     change = Changeset.change(user, %{avatar: object.data})
 268     {:ok, user} = User.update_and_set_cache(change)
 269     CommonAPI.update(user)
 270
 271     render(conn, UserView, "show.json", %{user: user, for: user})
 272   end
 273
 274   def update_banner(%{assigns: %{user: user}} = conn, params) do
 275     with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}),
 276          new_info <- Map.put(user.info, "banner", object.data),
 277          change <- User.info_changeset(user, %{info: new_info}),
 278          {:ok, user} <- User.update_and_set_cache(change) do
 279       CommonAPI.update(user)
 280       %{"url" => [%{"href" => href} | _]} = object.data
 281       response = %{url: href} |> Jason.encode!()
 282
 283       conn
 284       |> json_reply(200, response)
 285     end
 286   end
 287
 288   def update_background(%{assigns: %{user: user}} = conn, params) do
 289     with {:ok, object} <- ActivityPub.upload(params),
 290          new_info <- Map.put(user.info, "background", object.data),
 291          change <- User.info_changeset(user, %{info: new_info}),
 292          {:ok, _user} <- User.update_and_set_cache(change) do
 293       %{"url" => [%{"href" => href} | _]} = object.data
 294       response = %{url: href} |> Jason.encode!()
 295
 296       conn
 297       |> json_reply(200, response)
 298     end
 299   end
 300
 301   def external_profile(%{assigns: %{user: current_user}} = conn, %{"profileurl" => uri}) do
 302     with {:ok, user_map} <- TwitterAPI.get_external_profile(current_user, uri),
 303          response <- Jason.encode!(user_map) do
 304       conn
 305       |> json_reply(200, response)
 306     else
 307       _e ->
 308         conn
 309         |> put_status(404)
 310         |> json(%{error: "Can't find user"})
 311     end
 312   end
 313
 314   def update_most_recent_notification(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 315     with id when is_number(id) <- String.to_integer(id),
 316          info <- user.info,
 317          mrn <- max(id, user.info["most_recent_notification"] || 0),
 318          updated_info <- Map.put(info, "most_recent_notification", mrn),
 319          changeset <- User.info_changeset(user, %{info: updated_info}),
 320          {:ok, _user} <- User.update_and_set_cache(changeset) do
 321       conn
 322       |> json_reply(200, Jason.encode!(mrn))
 323     else
 324       _e -> bad_request_reply(conn, "Can't update.")
 325     end
 326   end
 327
 328   def followers(conn, params) do
 329     with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
 330          {:ok, followers} <- User.get_followers(user) do
 331       render(conn, UserView, "index.json", %{users: followers, for: conn.assigns[:user]})
 332     else
 333       _e -> bad_request_reply(conn, "Can't get followers")
 334     end
 335   end
 336
 337   def friends(conn, params) do
 338     with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
 339          {:ok, friends} <- User.get_friends(user) do
 340       render(conn, UserView, "index.json", %{users: friends, for: conn.assigns[:user]})
 341     else
 342       _e -> bad_request_reply(conn, "Can't get friends")
 343     end
 344   end
 345
 346   def friend_requests(conn, params) do
 347     with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
 348          {:ok, friend_requests} <- User.get_follow_requests(user) do
 349       render(conn, UserView, "index.json", %{users: friend_requests, for: conn.assigns[:user]})
 350     else
 351       _e -> bad_request_reply(conn, "Can't get friend requests")
 352     end
 353   end
 354
 355   def approve_friend_request(conn, %{"user_id" => uid} = params) do
 356     with followed <- conn.assigns[:user],
 357          uid when is_number(uid) <- String.to_integer(uid),
 358          %User{} = follower <- Repo.get(User, uid),
 359          {:ok, follower} <- User.maybe_follow(follower, followed),
 360          %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
 361          {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
 362          {:ok, _activity} <-
 363            ActivityPub.accept(%{
 364              to: [follower.ap_id],
 365              actor: followed.ap_id,
 366              object: follow_activity.data["id"],
 367              type: "Accept"
 368            }) do
 369       render(conn, UserView, "show.json", %{user: follower, for: followed})
 370     else
 371       e -> bad_request_reply(conn, "Can't approve user: #{inspect(e)}")
 372     end
 373   end
 374
 375   def deny_friend_request(conn, %{"user_id" => uid} = params) do
 376     with followed <- conn.assigns[:user],
 377          uid when is_number(uid) <- String.to_integer(uid),
 378          %User{} = follower <- Repo.get(User, uid),
 379          %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
 380          {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
 381          {:ok, _activity} <-
 382            ActivityPub.reject(%{
 383              to: [follower.ap_id],
 384              actor: followed.ap_id,
 385              object: follow_activity.data["id"],
 386              type: "Reject"
 387            }) do
 388       render(conn, UserView, "show.json", %{user: follower, for: followed})
 389     else
 390       e -> bad_request_reply(conn, "Can't deny user: #{inspect(e)}")
 391     end
 392   end
 393
 394   def friends_ids(%{assigns: %{user: user}} = conn, _params) do
 395     with {:ok, friends} <- User.get_friends(user) do
 396       ids =
 397         friends
 398         |> Enum.map(fn x -> x.id end)
 399         |> Jason.encode!()
 400
 401       json(conn, ids)
 402     else
 403       _e -> bad_request_reply(conn, "Can't get friends")
 404     end
 405   end
 406
 407   def empty_array(conn, _params) do
 408     json(conn, Jason.encode!([]))
 409   end
 410
 411   def raw_empty_array(conn, _params) do
 412     json(conn, [])
 413   end
 414
 415   def update_profile(%{assigns: %{user: user}} = conn, params) do
 416     params =
 417       if bio = params["description"] do
 418         mentions = Formatter.parse_mentions(bio)
 419         tags = Formatter.parse_tags(bio)
 420
 421         emoji =
 422           (user.info["source_data"]["tag"] || [])
 423           |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
 424           |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
 425             {String.trim(name, ":"), url}
 426           end)
 427
 428         bio_html = CommonUtils.format_input(bio, mentions, tags, "text/plain")
 429         Map.put(params, "bio", bio_html |> Formatter.emojify(emoji))
 430       else
 431         params
 432       end
 433
 434     user =
 435       if locked = params["locked"] do
 436         with locked <- locked == "true",
 437              new_info <- Map.put(user.info, "locked", locked),
 438              change <- User.info_changeset(user, %{info: new_info}),
 439              {:ok, user} <- User.update_and_set_cache(change) do
 440           user
 441         else
 442           _e -> user
 443         end
 444       else
 445         user
 446       end
 447
 448     user =
 449       if no_rich_text = params["no_rich_text"] do
 450         with no_rich_text <- no_rich_text == "true",
 451              new_info <- Map.put(user.info, "no_rich_text", no_rich_text),
 452              change <- User.info_changeset(user, %{info: new_info}),
 453              {:ok, user} <- User.update_and_set_cache(change) do
 454           user
 455         else
 456           _e -> user
 457         end
 458       else
 459         user
 460       end
 461
 462     user =
 463       if default_scope = params["default_scope"] do
 464         with new_info <- Map.put(user.info, "default_scope", default_scope),
 465              change <- User.info_changeset(user, %{info: new_info}),
 466              {:ok, user} <- User.update_and_set_cache(change) do
 467           user
 468         else
 469           _e -> user
 470         end
 471       else
 472         user
 473       end
 474
 475     with changeset <- User.update_changeset(user, params),
 476          {:ok, user} <- User.update_and_set_cache(changeset) do
 477       CommonAPI.update(user)
 478       render(conn, UserView, "user.json", %{user: user, for: user})
 479     else
 480       error ->
 481         Logger.debug("Can't update user: #{inspect(error)}")
 482         bad_request_reply(conn, "Can't update user")
 483     end
 484   end
 485
 486   def search(%{assigns: %{user: user}} = conn, %{"q" => _query} = params) do
 487     activities = TwitterAPI.search(user, params)
 488
 489     conn
 490     |> render(ActivityView, "index.json", %{activities: activities, for: user})
 491   end
 492
 493   defp bad_request_reply(conn, error_message) do
 494     json = error_json(conn, error_message)
 495     json_reply(conn, 400, json)
 496   end
 497
 498   defp json_reply(conn, status, json) do
 499     conn
 500     |> put_resp_content_type("application/json")
 501     |> send_resp(status, json)
 502   end
 503
 504   defp forbidden_json_reply(conn, error_message) do
 505     json = error_json(conn, error_message)
 506     json_reply(conn, 403, json)
 507   end
 508
 509   defp error_json(conn, error_message) do
 510     %{"error" => error_message, "request" => conn.request_path} |> Jason.encode!()
 511   end
 512
 513   def errors(conn, {:param_cast, _}) do
 514     conn
 515     |> put_status(400)
 516     |> json("Invalid parameters")
 517   end
 518
 519   def errors(conn, _) do
 520     conn
 521     |> put_status(500)
 522     |> json("Something went wrong")
 523   end
 524 end