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