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