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