mastodon_api_controller.ex 13.9 KB
Newer Older
1
2
defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
  use Pleroma.Web, :controller
3
  alias Pleroma.{Repo, Activity, User, Notification}
lain's avatar
lain committed
4
5
  alias Pleroma.Web.OAuth.App
  alias Pleroma.Web
lain's avatar
lain committed
6
7
8
  alias Pleroma.Web.MastodonAPI.{StatusView, AccountView}
  alias Pleroma.Web.ActivityPub.ActivityPub
  alias Pleroma.Web.TwitterAPI.TwitterAPI
lain's avatar
lain committed
9
  alias Pleroma.Web.CommonAPI
Roger Braun's avatar
Roger Braun committed
10
  import Ecto.Query
11
  import Logger
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  def create_app(conn, params) do
    with cs <- App.register_changeset(%App{}, params) |> IO.inspect,
         {:ok, app} <- Repo.insert(cs) |> IO.inspect do
      res = %{
        id: app.id,
        client_id: app.client_id,
        client_secret: app.client_secret
      }

      json(conn, res)
    end
  end

  def verify_credentials(%{assigns: %{user: user}} = conn, params) do
lain's avatar
lain committed
27
28
29
30
    account = AccountView.render("account.json", %{user: user})
    json(conn, account)
  end

Roger Braun's avatar
Roger Braun committed
31
32
33
34
35
36
37
38
39
40
41
  def user(conn, %{"id" => id}) do
    with %User{} = user <- Repo.get(User, id) do
      account = AccountView.render("account.json", %{user: user})
      json(conn, account)
    else
      _e -> conn
      |> put_status(404)
      |> json(%{error: "Can't find user"})
    end
  end

lain's avatar
lain committed
42
43
  @instance Application.get_env(:pleroma, :instance)

lain's avatar
lain committed
44
45
46
  def masto_instance(conn, _params) do
    response = %{
      uri: Web.base_url,
lain's avatar
lain committed
47
      title: Keyword.get(@instance, :name),
lain's avatar
lain committed
48
      description: "A Pleroma instance, an alternative fediverse server",
lain's avatar
lain committed
49
50
51
52
53
54
55
56
57
58
      version: Keyword.get(@instance, :version),
      email: Keyword.get(@instance, :email),
      urls: %{
        streaming_api: String.replace(Web.base_url, ["http","https"], "wss")
      },
      stats: %{
        user_count: 1,
        status_count: 2,
        domain_count: 3
      }
59
60
    }

lain's avatar
lain committed
61
    json(conn, response)
62
  end
lain's avatar
lain committed
63

lain's avatar
lain committed
64
  defp add_link_headers(conn, method, activities) do
65
66
67
68
69
    last = List.last(activities)
    first = List.first(activities)
    if last do
      min = last.id
      max = first.id
lain's avatar
lain committed
70
71
      next_url = mastodon_api_url(Pleroma.Web.Endpoint, method, max_id: min)
      prev_url = mastodon_api_url(Pleroma.Web.Endpoint, method, since_id: max)
72
73
74
75
76
77
78
      conn
      |> put_resp_header("link", "<#{next_url}>; rel=\"next\", <#{prev_url}>; rel=\"prev\"")
    else
      conn
    end
  end

lain's avatar
lain committed
79
  def home_timeline(%{assigns: %{user: user}} = conn, params) do
lain's avatar
lain committed
80
81
    params = params
    |> Map.put("type", ["Create", "Announce"])
lain's avatar
lain committed
82
    |> Map.put("blocking_user", user)
lain's avatar
lain committed
83
84

    activities = ActivityPub.fetch_activities([user.ap_id | user.following], params)
lain's avatar
lain committed
85
    |> Enum.reverse
86
87

    conn
lain's avatar
lain committed
88
    |> add_link_headers(:home_timeline, activities)
lain's avatar
lain committed
89
    |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
lain's avatar
lain committed
90
91
92
93
  end

  def public_timeline(%{assigns: %{user: user}} = conn, params) do
    params = params
lain's avatar
lain committed
94
    |> Map.put("type", ["Create", "Announce"])
lain's avatar
lain committed
95
    |> Map.put("local_only", !!params["local"])
lain's avatar
lain committed
96
    |> Map.put("blocking_user", user)
lain's avatar
lain committed
97
98

    activities = ActivityPub.fetch_public_activities(params)
lain's avatar
lain committed
99
    |> Enum.reverse
lain's avatar
lain committed
100

lain's avatar
lain committed
101
102
103
    conn
    |> add_link_headers(:public_timeline, activities)
    |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
lain's avatar
lain committed
104
105
  end

106
  # TODO: Link headers
lain's avatar
lain committed
107
108
109
  def user_statuses(%{assigns: %{user: user}} = conn, params) do
    with %User{ap_id: ap_id} <- Repo.get(User, params["id"]) do
      params = params
lain's avatar
lain committed
110
      |> Map.put("type", ["Create", "Announce"])
lain's avatar
lain committed
111
112
113
114
115
116
117
118
119
      |> Map.put("actor_id", ap_id)

      activities = ActivityPub.fetch_activities([], params)
      |> Enum.reverse

      render conn, StatusView, "index.json", %{activities: activities, for: user, as: :activity}
    end
  end

lain's avatar
lain committed
120
121
122
123
124
125
  def get_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
    with %Activity{} = activity <- Repo.get(Activity, id) do
      render conn, StatusView, "status.json", %{activity: activity, for: user}
    end
  end

lain's avatar
lain committed
126
127
  def get_context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
    with %Activity{} = activity <- Repo.get(Activity, id),
lain's avatar
lain committed
128
         activities <- ActivityPub.fetch_activities_for_context(activity.data["object"]["context"], %{"blocking_user" => user}),
lain's avatar
lain committed
129
130
         activities <- activities |> Enum.filter(fn (%{id: aid}) -> to_string(aid) != to_string(id) end),
         grouped_activities <- Enum.group_by(activities, fn (%{id: id}) -> id < activity.id end) do
lain's avatar
lain committed
131
      result = %{
lain's avatar
lain committed
132
133
        ancestors: StatusView.render("index.json", for: user, activities: grouped_activities[true] || [], as: :activity) |> Enum.reverse,
        descendants: StatusView.render("index.json", for: user, activities: grouped_activities[false] || [], as: :activity) |> Enum.reverse,
lain's avatar
lain committed
134
135
136
137
138
139
      }

      json(conn, result)
    end
  end

lain's avatar
lain committed
140
141
142
143
  def post_status(%{assigns: %{user: user}} = conn, %{"status" => status} = params) do
    params = params
    |> Map.put("in_reply_to_status_id", params["in_reply_to_id"])

144
145
    {:ok, activity} = CommonAPI.post(user, params)
    render conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity}
lain's avatar
lain committed
146
  end
lain's avatar
lain committed
147
148
149
150
151
152
153
154
155
156
157

  def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
    with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
      json(conn, %{})
    else
      _e ->
        conn
        |> put_status(403)
        |> json(%{error: "Can't delete this post"})
    end
  end
lain's avatar
lain committed
158
159
160
161
162
163
164

  def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
    with {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(ap_id_or_id, user),
         %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
      render conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity}
    end
  end
lain's avatar
lain committed
165
166

  def fav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
lain's avatar
lain committed
167
168
169
170
171
172
173
174
    with {:ok, _fav, %{data: %{"id" => id}}} = CommonAPI.favorite(ap_id_or_id, user),
         %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
      render conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity}
    end
  end

  def unfav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
    with {:ok, %{data: %{"id" => id}}} = CommonAPI.unfavorite(ap_id_or_id, user),
lain's avatar
lain committed
175
176
177
178
         %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
      render conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity}
    end
  end
179

180
181
182
183
  def notifications(%{assigns: %{user: user}} = conn, params) do
    notifications = Notification.for_user(user, params)
    result = Enum.map(notifications, fn (%{id: id, activity: activity, inserted_at: created_at}) ->
      actor = User.get_cached_by_ap_id(activity.data["actor"])
Roger Braun's avatar
Roger Braun committed
184
      created_at = NaiveDateTime.to_iso8601(created_at)
Roger Braun's avatar
Roger Braun committed
185
      |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
186
      case activity.data["type"] do
lain's avatar
lain committed
187
188
189
190
191
        "Create" ->
          %{id: id, type: "mention", created_at: created_at, account: AccountView.render("account.json", %{user: actor}), status: StatusView.render("status.json", %{activity: activity})}
        "Like" ->
          liked_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
          %{id: id, type: "favourite", created_at: created_at, account: AccountView.render("account.json", %{user: actor}), status: StatusView.render("status.json", %{activity: liked_activity})}
lain's avatar
lain committed
192
193
194
        "Announce" ->
          announced_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
          %{id: id, type: "reblog", created_at: created_at, account: AccountView.render("account.json", %{user: actor}), status: StatusView.render("status.json", %{activity: announced_activity})}
lain's avatar
lain committed
195
196
        "Follow" ->
          %{id: id, type: "follow", created_at: created_at, account: AccountView.render("account.json", %{user: actor})}
197
198
199
200
201
        _ -> nil
      end
    end)
    |> Enum.filter(&(&1))

lain's avatar
lain committed
202
203
204
    conn
    |> add_link_headers(:notifications, notifications)
    |> json(result)
205
206
  end

Roger Braun's avatar
Roger Braun committed
207
208
209
210
211
212
213
214
  def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
    id = List.wrap(id)
    q = from u in User,
      where: u.id in ^id
    targets = Repo.all(q)
    render conn, AccountView, "relationships.json", %{user: user, targets: targets}
  end

lain's avatar
lain committed
215
216
217
218
219
220
221
222
223
  def upload(%{assigns: %{user: user}} = conn, %{"file" => file}) do
    with {:ok, object} <- ActivityPub.upload(file) do
      data = object.data
      |> Map.put("id", object.id)

      render conn, StatusView, "attachment.json", %{attachment: data}
    end
  end

224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
  def favourited_by(conn, %{"id" => id}) do
    with %Activity{data: %{"object" => %{"likes" => likes} = data}} <- Repo.get(Activity, id) do
      q = from u in User,
        where: u.ap_id in ^likes
      users = Repo.all(q)
      render conn, AccountView, "accounts.json", %{users: users, as: :user}
    else
      _ -> json(conn, [])
    end
  end

  def reblogged_by(conn, %{"id" => id}) do
    with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Repo.get(Activity, id) do
      q = from u in User,
        where: u.ap_id in ^announces
      users = Repo.all(q)
      render conn, AccountView, "accounts.json", %{users: users, as: :user}
    else
      _ -> json(conn, [])
    end
  end

246
  # TODO: Link headers
Roger Braun's avatar
Roger Braun committed
247
248
249
250
  def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
    params = params
    |> Map.put("type", "Create")
    |> Map.put("local_only", !!params["local"])
lain's avatar
lain committed
251
    |> Map.put("blocking_user", user)
Roger Braun's avatar
Roger Braun committed
252
253
254
255
256
257
258
259

    activities = ActivityPub.fetch_public_activities(params)
    |> Enum.reverse

    conn
    |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
  end

260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
  # TODO: Pagination
  def followers(conn, %{"id" => id}) do
    with %User{} = user <- Repo.get(User, id),
         {:ok, followers} <- User.get_followers(user) do
      render conn, AccountView, "accounts.json", %{users: followers, as: :user}
    end
  end

  def following(conn, %{"id" => id}) do
    with %User{} = user <- Repo.get(User, id),
         {:ok, followers} <- User.get_friends(user) do
      render conn, AccountView, "accounts.json", %{users: followers, as: :user}
    end
  end

eal's avatar
eal committed
275
276
  def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
    with %User{} = followed <- Repo.get(User, id),
eal's avatar
eal committed
277
278
         {:ok, follower} <- User.follow(follower, followed),
         {:ok, activity} <- ActivityPub.follow(follower, followed) do
279
      render conn, AccountView, "relationship.json", %{user: follower, target: followed}
eal's avatar
eal committed
280
    else
eal's avatar
eal committed
281
282
283
284
      {:error, message} = err ->
        conn
        |> put_resp_content_type("application/json")
        |> send_resp(403, Poison.encode!(%{"error" => message}))
285
286
287
    end
  end

eal's avatar
eal committed
288
  def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
eal's avatar
eal committed
289
    with %User{} = followed <- Repo.get_by(User, nickname: uri),
eal's avatar
eal committed
290
291
         {:ok, follower} <- User.follow(follower, followed),
         {:ok, activity} <- ActivityPub.follow(follower, followed) do
eal's avatar
eal committed
292
293
294
295
296
297
298
299
300
      render conn, AccountView, "account.json", %{user: followed}
    else
      {:error, message} = err ->
        conn
        |> put_resp_content_type("application/json")
        |> send_resp(403, Poison.encode!(%{"error" => message}))
    end
  end

301
302
303
304
305
306
307
308
309
310
311
312
313
  # TODO: Clean up and unify
  def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
    with %User{} = followed <- Repo.get(User, id),
         { :ok, follower, follow_activity } <- User.unfollow(follower, followed),
         { :ok, _activity } <- ActivityPub.insert(%{
           "type" => "Undo",
           "actor" => follower.ap_id,
           "object" => follow_activity.data["id"] # get latest Follow for these users
         }) do
      render conn, AccountView, "relationship.json", %{user: follower, target: followed}
    end
  end

lain's avatar
lain committed
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
  def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
    with %User{} = blocked <- Repo.get(User, id),
         {:ok, blocker} <- User.block(blocker, blocked) do
      render conn, AccountView, "relationship.json", %{user: blocker, target: blocked}
    else
      {:error, message} = err ->
        conn
        |> put_resp_content_type("application/json")
        |> send_resp(403, Poison.encode!(%{"error" => message}))
    end
  end

  def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
    with %User{} = blocked <- Repo.get(User, id),
         {:ok, blocker} <- User.unblock(blocker, blocked) do
      render conn, AccountView, "relationship.json", %{user: blocker, target: blocked}
    else
      {:error, message} = err ->
        conn
        |> put_resp_content_type("application/json")
        |> send_resp(403, Poison.encode!(%{"error" => message}))
    end
  end

338
  def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
lain's avatar
lain committed
339
    accounts = User.search(query, params["resolve"] == "true")
lain's avatar
lain committed
340
341
342

    q = from a in Activity,
      where: fragment("?->>'type' = 'Create'", a.data),
lain's avatar
lain committed
343
      where: fragment("to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)", a.data, ^query),
lain's avatar
lain committed
344
345
346
347
348
349
350
351
352
353
354
355
      limit: 20
    statuses = Repo.all(q)

    res = %{
      "accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
      "statuses" => StatusView.render("index.json", activities: statuses, for: user, as: :activity),
      "hashtags" => []
    }

    json(conn, res)
  end

lain's avatar
lain committed
356
357
  def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
    accounts = User.search(query, params["resolve"] == "true")
358
359
360
361
362
363

    res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)

    json(conn, res)
  end

364
365
366
367
  def favourites(%{assigns: %{user: user}} = conn, params) do
    params = conn
    |> Map.put("type", "Create")
    |> Map.put("favorited_by", user.ap_id)
lain's avatar
lain committed
368
    |> Map.put("blocking_user", user)
369
370
371
372
373
374
375
376

    activities = ActivityPub.fetch_activities([], params)
    |> Enum.reverse

    conn
    |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
  end

377
378
379
380
381
382
383
  def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
    Logger.debug("Unimplemented, returning unmodified relationship")
    with %User{} = target <- Repo.get(User, id) do
      render conn, AccountView, "relationship.json", %{user: user, target: target}
    end
  end

384
385
386
387
  def empty_array(conn, _) do
    Logger.debug("Unimplemented, returning an empty array")
    json(conn, [])
  end
388
end