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