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}
   4   alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
   5   alias Pleroma.Web.CommonAPI
   6   alias Pleroma.{Repo, Activity, User, Object}
   7   alias Pleroma.Web.ActivityPub.ActivityPub
   8   alias Ecto.Changeset
   9
  10   require Logger
  11
  12   def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
  13     render(conn, UserView, "show.json", %{user: user})
  14   end
  15
  16   def status_update(%{assigns: %{user: user}} = conn, %{"status" => status_text} = status_data) do
  17     with media_ids <- extract_media_ids(status_data),
  18          {:ok, activity} <- TwitterAPI.create_status(user, Map.put(status_data, "media_ids",  media_ids)) do
  19       conn
  20       |> json(ActivityRepresenter.to_map(activity, %{user: user}))
  21     else
  22       _ -> empty_status_reply(conn)
  23     end
  24   end
  25
  26   def status_update(conn, _status_data) do
  27     empty_status_reply(conn)
  28   end
  29
  30   defp empty_status_reply(conn) do
  31     bad_request_reply(conn, "Client must provide a 'status' parameter with a value.")
  32   end
  33
  34   defp extract_media_ids(status_data) do
  35     with media_ids when not is_nil(media_ids) <- status_data["media_ids"],
  36          split_ids <- String.split(media_ids, ","),
  37          clean_ids <- Enum.reject(split_ids, fn (id) -> String.length(id) == 0 end)
  38       do
  39         clean_ids
  40       else _e -> []
  41     end
  42   end
  43
  44   def public_and_external_timeline(%{assigns: %{user: user}} = conn, params) do
  45     statuses = TwitterAPI.fetch_public_and_external_statuses(user, params)
  46     {:ok, json} = Poison.encode(statuses)
  47
  48     conn
  49     |> json_reply(200, json)
  50   end
  51
  52   def public_timeline(%{assigns: %{user: user}} = conn, params) do
  53     statuses = TwitterAPI.fetch_public_statuses(user, params)
  54     {:ok, json} = Poison.encode(statuses)
  55
  56     conn
  57     |> json_reply(200, json)
  58   end
  59
  60   def friends_timeline(%{assigns: %{user: user}} = conn, params) do
  61     statuses = TwitterAPI.fetch_friend_statuses(user, params)
  62     {:ok, json} = Poison.encode(statuses)
  63
  64     conn
  65     |> json_reply(200, json)
  66   end
  67
  68   def show_user(conn, params) do
  69     with {:ok, shown} <- TwitterAPI.get_user(params) do
  70       if user = conn.assigns.user do
  71         render conn, UserView, "show.json", %{user: shown, for: user}
  72       else
  73         render conn, UserView, "show.json", %{user: shown}
  74       end
  75     else
  76       {:error, msg} ->
  77         bad_request_reply(conn, msg)
  78     end
  79   end
  80
  81   def user_timeline(%{assigns: %{user: user}} = conn, params) do
  82     case TwitterAPI.get_user(user, params) do
  83       {:ok, target_user} ->
  84         params = Map.merge(params, %{"actor_id" => target_user.ap_id, "whole_db" => true})
  85         statuses  = TwitterAPI.fetch_user_statuses(user, params)
  86         conn
  87         |> json_reply(200, statuses |> Poison.encode!)
  88       {:error, msg} ->
  89         bad_request_reply(conn, msg)
  90     end
  91   end
  92
  93   def mentions_timeline(%{assigns: %{user: user}} = conn, params) do
  94     statuses = TwitterAPI.fetch_mentions(user, params)
  95     {:ok, json} = Poison.encode(statuses)
  96
  97     conn
  98     |> json_reply(200, json)
  99   end
 100
 101   def follow(%{assigns: %{user: user}} = conn, params) do
 102     case TwitterAPI.follow(user, params) do
 103       {:ok, user, followed, _activity} ->
 104         render(conn, UserView, "show.json", %{user: followed, for: user})
 105       {:error, msg} -> forbidden_json_reply(conn, msg)
 106     end
 107   end
 108
 109   def block(%{assigns: %{user: user}} = conn, params) do
 110     case TwitterAPI.block(user, params) do
 111       {:ok, user, blocked} ->
 112         render conn, UserView, "show.json", %{user: blocked, for: user}
 113       {:error, msg} -> forbidden_json_reply(conn, msg)
 114     end
 115   end
 116
 117   def unblock(%{assigns: %{user: user}} = conn, params) do
 118     case TwitterAPI.unblock(user, params) do
 119       {:ok, user, blocked} ->
 120         render conn, UserView, "show.json", %{user: blocked, for: user}
 121       {:error, msg} -> forbidden_json_reply(conn, msg)
 122     end
 123   end
 124
 125   def delete_post(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 126     with {:ok, delete} <- CommonAPI.delete(id, user) do
 127       json = ActivityRepresenter.to_json(delete, %{user: user, for: user})
 128       conn
 129       |> json_reply(200, json)
 130     end
 131   end
 132
 133   def unfollow(%{assigns: %{user: user}} = conn, params) do
 134     case TwitterAPI.unfollow(user, params) do
 135       {:ok, user, unfollowed} ->
 136         render(conn, UserView, "show.json", %{user: unfollowed, for: user})
 137       {:error, msg} -> forbidden_json_reply(conn, msg)
 138     end
 139   end
 140
 141   def fetch_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 142     response = Poison.encode!(TwitterAPI.fetch_status(user, id))
 143
 144     conn
 145     |> json_reply(200, response)
 146   end
 147
 148   def fetch_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 149     id = String.to_integer(id)
 150     response = Poison.encode!(TwitterAPI.fetch_conversation(user, id))
 151
 152     conn
 153     |> json_reply(200, response)
 154   end
 155
 156   def upload(conn, %{"media" => media}) do
 157     response = TwitterAPI.upload(media)
 158     conn
 159     |> put_resp_content_type("application/atom+xml")
 160     |> send_resp(200, response)
 161   end
 162
 163   def upload_json(conn, %{"media" => media}) do
 164     response = TwitterAPI.upload(media, "json")
 165     conn
 166     |> json_reply(200, response)
 167   end
 168
 169   def get_by_id_or_ap_id(id) do
 170     activity = Repo.get(Activity, id) || Activity.get_create_activity_by_object_ap_id(id)
 171     if activity.data["type"] == "Create" do
 172       activity
 173     else
 174       Activity.get_create_activity_by_object_ap_id(activity.data["object"])
 175     end
 176   end
 177
 178   def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 179     with {:ok, status} <- TwitterAPI.fav(user, id) do
 180       json(conn, status)
 181     end
 182   end
 183
 184   def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 185     with {:ok, status} <- TwitterAPI.unfav(user, id) do
 186       json(conn, status)
 187     end
 188   end
 189
 190   def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 191     with {:ok, status} <- TwitterAPI.repeat(user, id) do
 192       json(conn, status)
 193     end
 194   end
 195
 196   def register(conn, params) do
 197     with {:ok, user} <- TwitterAPI.register_user(params) do
 198       render(conn, UserView, "show.json", %{user: user})
 199     else
 200       {:error, errors} ->
 201       conn
 202       |> json_reply(400, Poison.encode!(errors))
 203     end
 204   end
 205
 206   def update_avatar(%{assigns: %{user: user}} = conn, params) do
 207     {:ok, object} = ActivityPub.upload(params)
 208     change = Changeset.change(user, %{avatar: object.data})
 209     {:ok, user} = Repo.update(change)
 210
 211     render(conn, UserView, "show.json", %{user: user, for: user})
 212   end
 213
 214   def update_banner(%{assigns: %{user: user}} = conn, params) do
 215     with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}),
 216          new_info <- Map.put(user.info, "banner", object.data),
 217          change <- User.info_changeset(user, %{info: new_info}),
 218          {:ok, user} <- Repo.update(change) do
 219       %{"url" => [ %{ "href" => href } | t ]} = object.data
 220       response = %{ url: href } |> Poison.encode!
 221       conn
 222       |> json_reply(200, response)
 223     end
 224   end
 225
 226   def update_background(%{assigns: %{user: user}} = conn, params) do
 227     with {:ok, object} <- ActivityPub.upload(params),
 228          new_info <- Map.put(user.info, "background", object.data),
 229          change <- User.info_changeset(user, %{info: new_info}),
 230          {:ok, user} <- Repo.update(change) do
 231       %{"url" => [ %{ "href" => href } | t ]} = object.data
 232       response = %{ url: href } |> Poison.encode!
 233       conn
 234       |> json_reply(200, response)
 235     end
 236   end
 237
 238   def external_profile(%{assigns: %{user: current_user}} = conn, %{"profileurl" => uri}) do
 239     with {:ok, user_map} <- TwitterAPI.get_external_profile(current_user, uri),
 240          response <- Poison.encode!(user_map) do
 241       conn
 242       |> json_reply(200, response)
 243     else
 244       _e ->
 245         conn
 246         |> put_status(404)
 247         |> json(%{error: "Can't find user"})
 248     end
 249   end
 250
 251   def update_most_recent_notification(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 252     with id when is_number(id) <- String.to_integer(id),
 253          info <- user.info,
 254          mrn <- max(id, user.info["most_recent_notification"] || 0),
 255          updated_info <- Map.put(info, "most_recent_notification", mrn),
 256          changeset <- User.info_changeset(user, %{info: updated_info}),
 257          {:ok, user} <- Repo.update(changeset) do
 258       conn
 259       |> json_reply(200, Poison.encode!(mrn))
 260     else
 261       _e -> bad_request_reply(conn, "Can't update.")
 262     end
 263   end
 264
 265   def followers(%{assigns: %{user: user}} = conn, _params) do
 266     with {:ok, followers} <- User.get_followers(user) do
 267       render(conn, UserView, "index.json", %{users: followers, for: user})
 268     else
 269       _e -> bad_request_reply(conn, "Can't get followers")
 270     end
 271   end
 272
 273   def friends(%{assigns: %{user: user}} = conn, _params) do
 274     with {:ok, friends} <- User.get_friends(user) do
 275       render(conn, UserView, "index.json", %{users: friends, for: user})
 276     else
 277       _e -> bad_request_reply(conn, "Can't get friends")
 278     end
 279   end
 280
 281   def update_profile(%{assigns: %{user: user}} = conn, params) do
 282     params = if bio = params["description"] do
 283       Map.put(params, "bio", bio)
 284     else
 285       params
 286     end
 287
 288     with changeset <- User.update_changeset(user, params),
 289          {:ok, user} <- Repo.update(changeset) do
 290       render(conn, UserView, "user.json", %{user: user, for: user})
 291     else
 292       error ->
 293         Logger.debug("Can't update user: #{inspect(error)}")
 294         bad_request_reply(conn, "Can't update user")
 295     end
 296   end
 297
 298   def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
 299     conn
 300     |> json(TwitterAPI.search(user, params))
 301   end
 302
 303   defp bad_request_reply(conn, error_message) do
 304     json = error_json(conn, error_message)
 305     json_reply(conn, 400, json)
 306   end
 307
 308   defp json_reply(conn, status, json) do
 309     conn
 310     |> put_resp_content_type("application/json")
 311     |> send_resp(status, json)
 312   end
 313
 314   defp forbidden_json_reply(conn, error_message) do
 315     json = error_json(conn, error_message)
 316     json_reply(conn, 403, json)
 317   end
 318
 319   defp error_json(conn, error_message) do
 320     %{"error" => error_message, "request" => conn.request_path} |> Poison.encode!
 321   end
 322 end