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}
   4   alias Pleroma.Web.CommonAPI
   5   alias Pleroma.{Repo, Activity, User}
   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         params =
 100           params
 101           |> Map.put("type", ["Create", "Announce"])
 102           |> Map.put("actor_id", target_user.ap_id)
 103           |> Map.put("whole_db", true)
 104
 105         activities = ActivityPub.fetch_public_activities(params)
 106
 107         conn
 108         |> render(ActivityView, "index.json", %{activities: activities, for: user})
 109
 110       {:error, msg} ->
 111         bad_request_reply(conn, msg)
 112     end
 113   end
 114
 115   def mentions_timeline(%{assigns: %{user: user}} = conn, params) do
 116     activities = ActivityPub.fetch_activities([user.ap_id], params)
 117
 118     conn
 119     |> render(ActivityView, "index.json", %{activities: activities, for: user})
 120   end
 121
 122   def follow(%{assigns: %{user: user}} = conn, params) do
 123     case TwitterAPI.follow(user, params) do
 124       {:ok, user, followed, _activity} ->
 125         render(conn, UserView, "show.json", %{user: followed, for: user})
 126
 127       {:error, msg} ->
 128         forbidden_json_reply(conn, msg)
 129     end
 130   end
 131
 132   def block(%{assigns: %{user: user}} = conn, params) do
 133     case TwitterAPI.block(user, params) do
 134       {:ok, user, blocked} ->
 135         render(conn, UserView, "show.json", %{user: blocked, for: user})
 136
 137       {:error, msg} ->
 138         forbidden_json_reply(conn, msg)
 139     end
 140   end
 141
 142   def unblock(%{assigns: %{user: user}} = conn, params) do
 143     case TwitterAPI.unblock(user, params) do
 144       {:ok, user, blocked} ->
 145         render(conn, UserView, "show.json", %{user: blocked, for: user})
 146
 147       {:error, msg} ->
 148         forbidden_json_reply(conn, msg)
 149     end
 150   end
 151
 152   def delete_post(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 153     with {:ok, activity} <- TwitterAPI.delete(user, id) do
 154       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 155     end
 156   end
 157
 158   def unfollow(%{assigns: %{user: user}} = conn, params) do
 159     case TwitterAPI.unfollow(user, params) do
 160       {:ok, user, unfollowed} ->
 161         render(conn, UserView, "show.json", %{user: unfollowed, for: user})
 162
 163       {:error, msg} ->
 164         forbidden_json_reply(conn, msg)
 165     end
 166   end
 167
 168   def fetch_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 169     with %Activity{} = activity <- Repo.get(Activity, id),
 170          true <- ActivityPub.visible_for_user?(activity, user) do
 171       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 172     end
 173   end
 174
 175   def fetch_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 176     id = String.to_integer(id)
 177
 178     with context when is_binary(context) <- TwitterAPI.conversation_id_to_context(id),
 179          activities <-
 180            ActivityPub.fetch_activities_for_context(context, %{
 181              "blocking_user" => user,
 182              "user" => user
 183            }) do
 184       conn
 185       |> render(ActivityView, "index.json", %{activities: activities, for: user})
 186     end
 187   end
 188
 189   def upload(conn, %{"media" => media}) do
 190     response = TwitterAPI.upload(media)
 191
 192     conn
 193     |> put_resp_content_type("application/atom+xml")
 194     |> send_resp(200, response)
 195   end
 196
 197   def upload_json(conn, %{"media" => media}) do
 198     response = TwitterAPI.upload(media, "json")
 199
 200     conn
 201     |> json_reply(200, response)
 202   end
 203
 204   def get_by_id_or_ap_id(id) do
 205     activity = Repo.get(Activity, id) || Activity.get_create_activity_by_object_ap_id(id)
 206
 207     if activity.data["type"] == "Create" do
 208       activity
 209     else
 210       Activity.get_create_activity_by_object_ap_id(activity.data["object"])
 211     end
 212   end
 213
 214   def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 215     with {:ok, activity} <- TwitterAPI.fav(user, id) do
 216       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 217     end
 218   end
 219
 220   def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 221     with {:ok, activity} <- TwitterAPI.unfav(user, id) do
 222       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 223     end
 224   end
 225
 226   def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 227     with {:ok, activity} <- TwitterAPI.repeat(user, id) do
 228       render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
 229     end
 230   end
 231
 232   def register(conn, params) do
 233     with {:ok, user} <- TwitterAPI.register_user(params) do
 234       render(conn, UserView, "show.json", %{user: user})
 235     else
 236       {:error, errors} ->
 237         conn
 238         |> json_reply(400, Jason.encode!(errors))
 239     end
 240   end
 241
 242   def update_avatar(%{assigns: %{user: user}} = conn, params) do
 243     {:ok, object} = ActivityPub.upload(params)
 244     change = Changeset.change(user, %{avatar: object.data})
 245     {:ok, user} = User.update_and_set_cache(change)
 246     CommonAPI.update(user)
 247
 248     render(conn, UserView, "show.json", %{user: user, for: user})
 249   end
 250
 251   def update_banner(%{assigns: %{user: user}} = conn, params) do
 252     with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}),
 253          new_info <- Map.put(user.info, "banner", object.data),
 254          change <- User.info_changeset(user, %{info: new_info}),
 255          {:ok, user} <- User.update_and_set_cache(change) do
 256       CommonAPI.update(user)
 257       %{"url" => [%{"href" => href} | _]} = object.data
 258       response = %{url: href} |> Jason.encode!()
 259
 260       conn
 261       |> json_reply(200, response)
 262     end
 263   end
 264
 265   def update_background(%{assigns: %{user: user}} = conn, params) do
 266     with {:ok, object} <- ActivityPub.upload(params),
 267          new_info <- Map.put(user.info, "background", object.data),
 268          change <- User.info_changeset(user, %{info: new_info}),
 269          {:ok, _user} <- User.update_and_set_cache(change) do
 270       %{"url" => [%{"href" => href} | _]} = object.data
 271       response = %{url: href} |> Jason.encode!()
 272
 273       conn
 274       |> json_reply(200, response)
 275     end
 276   end
 277
 278   def external_profile(%{assigns: %{user: current_user}} = conn, %{"profileurl" => uri}) do
 279     with {:ok, user_map} <- TwitterAPI.get_external_profile(current_user, uri),
 280          response <- Jason.encode!(user_map) do
 281       conn
 282       |> json_reply(200, response)
 283     else
 284       _e ->
 285         conn
 286         |> put_status(404)
 287         |> json(%{error: "Can't find user"})
 288     end
 289   end
 290
 291   def update_most_recent_notification(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 292     with id when is_number(id) <- String.to_integer(id),
 293          info <- user.info,
 294          mrn <- max(id, user.info["most_recent_notification"] || 0),
 295          updated_info <- Map.put(info, "most_recent_notification", mrn),
 296          changeset <- User.info_changeset(user, %{info: updated_info}),
 297          {:ok, _user} <- User.update_and_set_cache(changeset) do
 298       conn
 299       |> json_reply(200, Jason.encode!(mrn))
 300     else
 301       _e -> bad_request_reply(conn, "Can't update.")
 302     end
 303   end
 304
 305   def followers(conn, params) do
 306     with {:ok, user} <- TwitterAPI.get_user(conn.assigns.user, params),
 307          {:ok, followers} <- User.get_followers(user) do
 308       render(conn, UserView, "index.json", %{users: followers, for: user})
 309     else
 310       _e -> bad_request_reply(conn, "Can't get followers")
 311     end
 312   end
 313
 314   def friends(conn, params) do
 315     with {:ok, user} <- TwitterAPI.get_user(conn.assigns.user, params),
 316          {:ok, friends} <- User.get_friends(user) do
 317       render(conn, UserView, "index.json", %{users: friends, for: user})
 318     else
 319       _e -> bad_request_reply(conn, "Can't get friends")
 320     end
 321   end
 322
 323   def friends_ids(%{assigns: %{user: user}} = conn, _params) do
 324     with {:ok, friends} <- User.get_friends(user) do
 325       ids =
 326         friends
 327         |> Enum.map(fn x -> x.id end)
 328         |> Jason.encode!()
 329
 330       json(conn, ids)
 331     else
 332       _e -> bad_request_reply(conn, "Can't get friends")
 333     end
 334   end
 335
 336   def empty_array(conn, _params) do
 337     json(conn, Jason.encode!([]))
 338   end
 339
 340   def update_profile(%{assigns: %{user: user}} = conn, params) do
 341     params =
 342       if bio = params["description"] do
 343         Map.put(params, "bio", bio)
 344       else
 345         params
 346       end
 347
 348     with changeset <- User.update_changeset(user, params),
 349          {:ok, user} <- User.update_and_set_cache(changeset) do
 350       CommonAPI.update(user)
 351       render(conn, UserView, "user.json", %{user: user, for: user})
 352     else
 353       error ->
 354         Logger.debug("Can't update user: #{inspect(error)}")
 355         bad_request_reply(conn, "Can't update user")
 356     end
 357   end
 358
 359   def search(%{assigns: %{user: user}} = conn, %{"q" => _query} = params) do
 360     activities = TwitterAPI.search(user, params)
 361
 362     conn
 363     |> render(ActivityView, "index.json", %{activities: activities, for: user})
 364   end
 365
 366   defp bad_request_reply(conn, error_message) do
 367     json = error_json(conn, error_message)
 368     json_reply(conn, 400, json)
 369   end
 370
 371   defp json_reply(conn, status, json) do
 372     conn
 373     |> put_resp_content_type("application/json")
 374     |> send_resp(status, json)
 375   end
 376
 377   defp forbidden_json_reply(conn, error_message) do
 378     json = error_json(conn, error_message)
 379     json_reply(conn, 403, json)
 380   end
 381
 382   defp error_json(conn, error_message) do
 383     %{"error" => error_message, "request" => conn.request_path} |> Jason.encode!()
 384   end
 385 end