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
   4   alias Pleroma.Web.TwitterAPI.Representers.{UserRepresenter, ActivityRepresenter}
   5   alias Pleroma.{Web, Repo, Activity}
   6   alias Pleroma.Web.ActivityPub.ActivityPub
   7   alias Ecto.Changeset
   8
   9   def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
  10     response = user |> UserRepresenter.to_json(%{for: user})
  11
  12     conn
  13     |> json_reply(200, response)
  14   end
  15
  16   def status_update(%{assigns: %{user: user}} = conn, %{"status" => status_text} = status_data) do
  17     if status_text |> String.trim |> String.length != 0 do
  18       media_ids = extract_media_ids(status_data)
  19       {:ok, activity} = TwitterAPI.create_status(user, Map.put(status_data, "media_ids",  media_ids))
  20       conn
  21       |> json_reply(200, ActivityRepresenter.to_json(activity, %{user: 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)
  39       do
  40         clean_ids
  41       else _e -> []
  42     end
  43   end
  44
  45   def public_timeline(%{assigns: %{user: user}} = conn, params) do
  46     statuses = TwitterAPI.fetch_public_statuses(user, params)
  47     {:ok, json} = Poison.encode(statuses)
  48
  49     conn
  50     |> json_reply(200, json)
  51   end
  52
  53   def friends_timeline(%{assigns: %{user: user}} = conn, params) do
  54     statuses = TwitterAPI.fetch_friend_statuses(user, params)
  55     {:ok, json} = Poison.encode(statuses)
  56
  57     conn
  58     |> json_reply(200, json)
  59   end
  60
  61   def user_timeline(%{assigns: %{user: user}} = conn, params) do
  62     case TwitterAPI.get_user(user, params) do
  63       {:ok, target_user} ->
  64         params = Map.merge(params, %{"actor_id" => target_user.ap_id})
  65         statuses  = TwitterAPI.fetch_user_statuses(user, params)
  66         conn
  67         |> json_reply(200, statuses |> Poison.encode!)
  68       {:error, msg} ->
  69         bad_request_reply(conn, msg)
  70     end
  71   end
  72
  73   def mentions_timeline(%{assigns: %{user: user}} = conn, params) do
  74     statuses = TwitterAPI.fetch_mentions(user, params)
  75     {:ok, json} = Poison.encode(statuses)
  76
  77     conn
  78     |> json_reply(200, json)
  79   end
  80
  81   def follow(%{assigns: %{user: user}} = conn, params) do
  82     case TwitterAPI.follow(user, params) do
  83       {:ok, user, followed, _activity} ->
  84         response = followed |> UserRepresenter.to_json(%{for: user})
  85         conn
  86         |> json_reply(200, response)
  87       {:error, msg} -> forbidden_json_reply(conn, msg)
  88     end
  89   end
  90
  91   def unfollow(%{assigns: %{user: user}} = conn, params) do
  92     case TwitterAPI.unfollow(user, params) do
  93       {:ok, user, unfollowed} ->
  94         response = unfollowed |> UserRepresenter.to_json(%{for: user})
  95         conn
  96         |> json_reply(200, response)
  97       {:error, msg} -> forbidden_json_reply(conn, msg)
  98     end
  99   end
 100
 101   def fetch_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 102     response = Poison.encode!(TwitterAPI.fetch_status(user, id))
 103
 104     conn
 105     |> json_reply(200, response)
 106   end
 107
 108   def fetch_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 109     id = String.to_integer(id)
 110     response = Poison.encode!(TwitterAPI.fetch_conversation(user, id))
 111
 112     conn
 113     |> json_reply(200, response)
 114   end
 115
 116   def upload(conn, %{"media" => media}) do
 117     response = TwitterAPI.upload(media)
 118     conn
 119     |> put_resp_content_type("application/atom+xml")
 120     |> send_resp(200, response)
 121   end
 122
 123   def help_test(conn, _params) do
 124     conn |> json_reply(200, Poison.encode!("ok"))
 125   end
 126
 127   def upload_json(conn, %{"media" => media}) do
 128     response = TwitterAPI.upload(media, "json")
 129     conn
 130     |> json_reply(200, response)
 131   end
 132
 133   def config(conn, _params) do
 134     response = %{
 135       site: %{
 136         name: Web.base_url,
 137         server: Web.base_url,
 138         textlimit: -1
 139       }
 140     }
 141     |> Poison.encode!
 142
 143     conn
 144     |> json_reply(200, response)
 145   end
 146
 147   def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 148     activity = Repo.get(Activity, id)
 149     {:ok, status} = TwitterAPI.favorite(user, activity)
 150     response = Poison.encode!(status)
 151
 152     conn
 153     |> json_reply(200, response)
 154   end
 155
 156   def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 157     activity = Repo.get(Activity, id)
 158     {:ok, status} = TwitterAPI.unfavorite(user, activity)
 159     response = Poison.encode!(status)
 160
 161     conn
 162     |> json_reply(200, response)
 163   end
 164
 165   def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 166     activity = Repo.get(Activity, id)
 167     if activity.data["actor"] == user.ap_id do
 168       bad_request_reply(conn, "You cannot repeat your own notice.")
 169     else
 170       {:ok, status} = TwitterAPI.retweet(user, activity)
 171       response = Poison.encode!(status)
 172
 173       conn
 174
 175       |> json_reply(200, response)
 176     end
 177   end
 178
 179   def register(conn, params) do
 180     with {:ok, user} <- TwitterAPI.register_user(params) do
 181       conn
 182       |> json_reply(200, Poison.encode!(user))
 183     else
 184       {:error, errors} ->
 185       conn
 186       |> json_reply(400, Poison.encode!(errors))
 187     end
 188   end
 189
 190   def update_avatar(%{assigns: %{user: user}} = conn, params) do
 191     {:ok, object} = ActivityPub.upload(params)
 192     change = Changeset.change(user, %{avatar: object.data})
 193     {:ok, user} = Repo.update(change)
 194
 195     response = Poison.encode!(UserRepresenter.to_map(user, %{for: user}))
 196
 197     conn
 198     |> json_reply(200, response)
 199   end
 200
 201   defp bad_request_reply(conn, error_message) do
 202     json = error_json(conn, error_message)
 203     json_reply(conn, 400, json)
 204   end
 205
 206   defp json_reply(conn, status, json) do
 207     conn
 208     |> put_resp_content_type("application/json")
 209     |> send_resp(status, json)
 210   end
 211
 212   defp forbidden_json_reply(conn, error_message) do
 213     json = error_json(conn, error_message)
 214     json_reply(conn, 403, json)
 215   end
 216
 217   defp error_json(conn, error_message) do
 218     %{"error" => error_message, "request" => conn.request_path} |> Poison.encode!
 219   end
 220 end