git.squeep.com Git - akkoma/blob - lib/pleroma/web/twitter_api/twitter_api.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
   6   alias Pleroma.Activity
   7   alias Pleroma.Emails.Mailer
   8   alias Pleroma.Emails.UserEmail
   9   alias Pleroma.Repo
  10   alias Pleroma.User
  11   alias Pleroma.UserInviteToken
  12   alias Pleroma.Web.ActivityPub.ActivityPub
  13   alias Pleroma.Web.CommonAPI
  14   alias Pleroma.Web.TwitterAPI.UserView
  15
  16   import Ecto.Query
  17
  18   require Pleroma.Constants
  19
  20   def create_status(%User{} = user, %{"status" => _} = data) do
  21     CommonAPI.post(user, data)
  22   end
  23
  24   def delete(%User{} = user, id) do
  25     with %Activity{data: %{"type" => _type}} <- Activity.get_by_id(id),
  26          {:ok, activity} <- CommonAPI.delete(id, user) do
  27       {:ok, activity}
  28     end
  29   end
  30
  31   def follow(%User{} = follower, params) do
  32     with {:ok, %User{} = followed} <- get_user(params) do
  33       CommonAPI.follow(follower, followed)
  34     end
  35   end
  36
  37   def unfollow(%User{} = follower, params) do
  38     with {:ok, %User{} = unfollowed} <- get_user(params),
  39          {:ok, follower} <- CommonAPI.unfollow(follower, unfollowed) do
  40       {:ok, follower, unfollowed}
  41     end
  42   end
  43
  44   def block(%User{} = blocker, params) do
  45     with {:ok, %User{} = blocked} <- get_user(params),
  46          {:ok, blocker} <- User.block(blocker, blocked),
  47          {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
  48       {:ok, blocker, blocked}
  49     else
  50       err -> err
  51     end
  52   end
  53
  54   def unblock(%User{} = blocker, params) do
  55     with {:ok, %User{} = blocked} <- get_user(params),
  56          {:ok, blocker} <- User.unblock(blocker, blocked),
  57          {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
  58       {:ok, blocker, blocked}
  59     else
  60       err -> err
  61     end
  62   end
  63
  64   def repeat(%User{} = user, ap_id_or_id) do
  65     with {:ok, _announce, %{data: %{"id" => id}}} <- CommonAPI.repeat(ap_id_or_id, user),
  66          %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
  67       {:ok, activity}
  68     end
  69   end
  70
  71   def unrepeat(%User{} = user, ap_id_or_id) do
  72     with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
  73          %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
  74       {:ok, activity}
  75     end
  76   end
  77
  78   def pin(%User{} = user, ap_id_or_id) do
  79     CommonAPI.pin(ap_id_or_id, user)
  80   end
  81
  82   def unpin(%User{} = user, ap_id_or_id) do
  83     CommonAPI.unpin(ap_id_or_id, user)
  84   end
  85
  86   def fav(%User{} = user, ap_id_or_id) do
  87     with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
  88          %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
  89       {:ok, activity}
  90     end
  91   end
  92
  93   def unfav(%User{} = user, ap_id_or_id) do
  94     with {:ok, _unfav, _fav, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
  95          %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
  96       {:ok, activity}
  97     end
  98   end
  99
 100   def upload(%Plug.Upload{} = file, %User{} = user, format \\ "xml") do
 101     {:ok, object} = ActivityPub.upload(file, actor: User.ap_id(user))
 102
 103     url = List.first(object.data["url"])
 104     href = url["href"]
 105     type = url["mediaType"]
 106
 107     case format do
 108       "xml" ->
 109         # Fake this as good as possible...
 110         """
 111         <?xml version="1.0" encoding="UTF-8"?>
 112         <rsp stat="ok" xmlns:atom="http://www.w3.org/2005/Atom">
 113         <mediaid>#{object.id}</mediaid>
 114         <media_id>#{object.id}</media_id>
 115         <media_id_string>#{object.id}</media_id_string>
 116         <media_url>#{href}</media_url>
 117         <mediaurl>#{href}</mediaurl>
 118         <atom:link rel="enclosure" href="#{href}" type="#{type}"></atom:link>
 119         </rsp>
 120         """
 121
 122       "json" ->
 123         %{
 124           media_id: object.id,
 125           media_id_string: "#{object.id}}",
 126           media_url: href,
 127           size: 0
 128         }
 129         |> Jason.encode!()
 130     end
 131   end
 132
 133   def register_user(params, opts \\ []) do
 134     token = params["token"]
 135
 136     params = %{
 137       nickname: params["nickname"],
 138       name: params["fullname"],
 139       bio: User.parse_bio(params["bio"]),
 140       email: params["email"],
 141       password: params["password"],
 142       password_confirmation: params["confirm"],
 143       captcha_solution: params["captcha_solution"],
 144       captcha_token: params["captcha_token"],
 145       captcha_answer_data: params["captcha_answer_data"]
 146     }
 147
 148     captcha_enabled = Pleroma.Config.get([Pleroma.Captcha, :enabled])
 149     # true if captcha is disabled or enabled and valid, false otherwise
 150     captcha_ok =
 151       if !captcha_enabled do
 152         :ok
 153       else
 154         Pleroma.Captcha.validate(
 155           params[:captcha_token],
 156           params[:captcha_solution],
 157           params[:captcha_answer_data]
 158         )
 159       end
 160
 161     # Captcha invalid
 162     if captcha_ok != :ok do
 163       {:error, error} = captcha_ok
 164       # I have no idea how this error handling works
 165       {:error, %{error: Jason.encode!(%{captcha: [error]})}}
 166     else
 167       registration_process(
 168         params,
 169         %{
 170           registrations_open: Pleroma.Config.get([:instance, :registrations_open]),
 171           token: token
 172         },
 173         opts
 174       )
 175     end
 176   end
 177
 178   defp registration_process(params, %{registrations_open: true}, opts) do
 179     create_user(params, opts)
 180   end
 181
 182   defp registration_process(params, %{token: token}, opts) do
 183     invite =
 184       unless is_nil(token) do
 185         Repo.get_by(UserInviteToken, %{token: token})
 186       end
 187
 188     valid_invite? = invite && UserInviteToken.valid_invite?(invite)
 189
 190     case invite do
 191       nil ->
 192         {:error, "Invalid token"}
 193
 194       invite when valid_invite? ->
 195         UserInviteToken.update_usage!(invite)
 196         create_user(params, opts)
 197
 198       _ ->
 199         {:error, "Expired token"}
 200     end
 201   end
 202
 203   defp create_user(params, opts) do
 204     changeset = User.register_changeset(%User{}, params, opts)
 205
 206     case User.register(changeset) do
 207       {:ok, user} ->
 208         {:ok, user}
 209
 210       {:error, changeset} ->
 211         errors =
 212           Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
 213           |> Jason.encode!()
 214
 215         {:error, %{error: errors}}
 216     end
 217   end
 218
 219   def password_reset(nickname_or_email) do
 220     with true <- is_binary(nickname_or_email),
 221          %User{local: true} = user <- User.get_by_nickname_or_email(nickname_or_email),
 222          {:ok, token_record} <- Pleroma.PasswordResetToken.create_token(user) do
 223       user
 224       |> UserEmail.password_reset_email(token_record.token)
 225       |> Mailer.deliver_async()
 226
 227       {:ok, :enqueued}
 228     else
 229       false ->
 230         {:error, "bad user identifier"}
 231
 232       %User{local: false} ->
 233         {:error, "remote user"}
 234
 235       nil ->
 236         {:error, "unknown user"}
 237     end
 238   end
 239
 240   def get_user(user \\ nil, params) do
 241     case params do
 242       %{"user_id" => user_id} ->
 243         case User.get_cached_by_nickname_or_id(user_id) do
 244           nil ->
 245             {:error, "No user with such user_id"}
 246
 247           %User{info: %{deactivated: true}} ->
 248             {:error, "User has been disabled"}
 249
 250           user ->
 251             {:ok, user}
 252         end
 253
 254       %{"screen_name" => nickname} ->
 255         case User.get_cached_by_nickname(nickname) do
 256           nil -> {:error, "No user with such screen_name"}
 257           target -> {:ok, target}
 258         end
 259
 260       _ ->
 261         if user do
 262           {:ok, user}
 263         else
 264           {:error, "You need to specify screen_name or user_id"}
 265         end
 266     end
 267   end
 268
 269   defp parse_int(string, default)
 270
 271   defp parse_int(string, default) when is_binary(string) do
 272     with {n, _} <- Integer.parse(string) do
 273       n
 274     else
 275       _e -> default
 276     end
 277   end
 278
 279   defp parse_int(_, default), do: default
 280
 281   # TODO: unify the search query with MastoAPI one and do only pagination here
 282   def search(_user, %{"q" => query} = params) do
 283     limit = parse_int(params["rpp"], 20)
 284     page = parse_int(params["page"], 1)
 285     offset = (page - 1) * limit
 286
 287     q =
 288       from(
 289         [a, o] in Activity.with_preloaded_object(Activity),
 290         where: fragment("?->>'type' = 'Create'", a.data),
 291         where: ^Pleroma.Constants.as_public() in a.recipients,
 292         where:
 293           fragment(
 294             "to_tsvector('english', ?->>'content') @@ plainto_tsquery('english', ?)",
 295             o.data,
 296             ^query
 297           ),
 298         limit: ^limit,
 299         offset: ^offset,
 300         # this one isn't indexed so psql won't take the wrong index.
 301         order_by: [desc: :inserted_at]
 302       )
 303
 304     _activities = Repo.all(q)
 305   end
 306
 307   def get_external_profile(for_user, uri) do
 308     with {:ok, %User{} = user} <- User.get_or_fetch(uri) do
 309       {:ok, UserView.render("show.json", %{user: user, for: for_user})}
 310     else
 311       _e ->
 312         {:error, "Couldn't find user"}
 313     end
 314   end
 315 end