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.{Repo, Activity}
6 alias Pleroma.Web.ActivityPub.ActivityPub
8 def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
9 response = user |> UserRepresenter.to_json(%{for: user})
12 |> json_reply(200, response)
15 def status_update(%{assigns: %{user: user}} = conn, %{"status" => status_text} = status_data) do
16 if status_text |> String.trim |> String.length != 0 do
17 media_ids = extract_media_ids(status_data)
18 {:ok, activity} = TwitterAPI.create_status(user, Map.put(status_data, "media_ids", media_ids ))
20 |> json_reply(200, ActivityRepresenter.to_json(activity, %{user: user}))
22 empty_status_reply(conn)
26 def status_update(conn, _status_data) do
27 empty_status_reply(conn)
30 defp empty_status_reply(conn) do
31 bad_request_reply(conn, "Client must provide a 'status' parameter with a value.")
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)
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)
49 |> json_reply(200, json)
52 def public_timeline(%{assigns: %{user: user}} = conn, params) do
53 statuses = TwitterAPI.fetch_public_statuses(user, params)
54 {:ok, json} = Poison.encode(statuses)
57 |> json_reply(200, json)
60 def friends_timeline(%{assigns: %{user: user}} = conn, params) do
61 statuses = TwitterAPI.fetch_friend_statuses(user, params)
62 {:ok, json} = Poison.encode(statuses)
65 |> json_reply(200, json)
68 def user_timeline(%{assigns: %{user: user}} = conn, params) do
69 case TwitterAPI.get_user(user, params) do
71 params = Map.merge(params, %{"actor_id" => target_user.ap_id})
72 statuses = TwitterAPI.fetch_user_statuses(user, params)
74 |> json_reply(200, statuses |> Poison.encode!)
76 bad_request_reply(conn, msg)
80 def mentions_timeline(%{assigns: %{user: user}} = conn, params) do
81 statuses = TwitterAPI.fetch_mentions(user, params)
82 {:ok, json} = Poison.encode(statuses)
85 |> json_reply(200, json)
88 def follow(%{assigns: %{user: user}} = conn, params) do
89 case TwitterAPI.follow(user, params) do
90 { :ok, user, followed, _activity } ->
91 response = followed |> UserRepresenter.to_json(%{for: user})
93 |> json_reply(200, response)
94 { :error, msg } -> forbidden_json_reply(conn, msg)
98 def unfollow(%{assigns: %{user: user}} = conn, params) do
99 case TwitterAPI.unfollow(user, params) do
100 { :ok, user, unfollowed, } ->
101 response = unfollowed |> UserRepresenter.to_json(%{for: user})
103 |> json_reply(200, response)
104 { :error, msg } -> forbidden_json_reply(conn, msg)
108 def fetch_status(%{assigns: %{user: user}} = conn, %{ "id" => id }) do
109 response = TwitterAPI.fetch_status(user, id) |> Poison.encode!
112 |> json_reply(200, response)
115 def fetch_conversation(%{assigns: %{user: user}} = conn, %{ "id" => id }) do
116 id = String.to_integer(id)
117 response = TwitterAPI.fetch_conversation(user, id) |> Poison.encode!
120 |> json_reply(200, response)
123 def upload(conn, %{"media" => media}) do
124 response = TwitterAPI.upload(media)
126 |> put_resp_content_type("application/atom+xml")
127 |> send_resp(200, response)
130 def help_test(conn, _params) do
131 conn |> json_reply(200, Poison.encode!("ok"))
134 def upload_json(conn, %{"media" => media}) do
135 response = TwitterAPI.upload(media, "json")
137 |> json_reply(200, response)
140 def config(conn, _params) do
143 name: Pleroma.Web.base_url,
144 server: Pleroma.Web.base_url,
151 |> json_reply(200, response)
154 def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
155 activity = Repo.get(Activity, id)
156 {:ok, status} = TwitterAPI.favorite(user, activity)
157 response = Poison.encode!(status)
160 |> json_reply(200, response)
163 def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
164 activity = Repo.get(Activity, id)
165 {:ok, status} = TwitterAPI.unfavorite(user, activity)
166 response = Poison.encode!(status)
169 |> json_reply(200, response)
172 def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
173 activity = Repo.get(Activity, id)
174 if activity.data["actor"] == user.ap_id do
175 bad_request_reply(conn, "You cannot repeat your own notice.")
177 {:ok, status} = TwitterAPI.retweet(user, activity)
178 response = Poison.encode!(status)
182 |> json_reply(200, response)
186 def register(conn, params) do
187 with {:ok, user} <- TwitterAPI.register_user(params) do
189 |> json_reply(200, Poison.encode!(user))
193 |> json_reply(400, Poison.encode!(errors))
197 def update_avatar(%{assigns: %{user: user}} = conn, params) do
198 {:ok, object} = ActivityPub.upload(params)
199 change = Ecto.Changeset.change(user, %{avatar: object.data})
200 {:ok, user} = Repo.update(change)
202 response = UserRepresenter.to_map(user, %{for: user})
206 |> json_reply(200, response)
209 defp bad_request_reply(conn, error_message) do
210 json = error_json(conn, error_message)
211 json_reply(conn, 400, json)
214 defp json_reply(conn, status, json) do
216 |> put_resp_content_type("application/json")
217 |> send_resp(status, json)
220 defp forbidden_json_reply(conn, error_message) do
221 json = error_json(conn, error_message)
222 json_reply(conn, 403, json)
225 defp error_json(conn, error_message) do
226 %{"error" => error_message, "request" => conn.request_path} |> Poison.encode!