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

   1 defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
   2   alias Pleroma.{UserInviteToken, User, Activity, Repo, Object}
   3   alias Pleroma.Web.ActivityPub.ActivityPub
   4   alias Pleroma.Web.TwitterAPI.UserView
   5   alias Pleroma.Web.{OStatus, CommonAPI}
   6   import Ecto.Query
   7
   8   @instance Application.get_env(:pleroma, :instance)
   9   @httpoison Application.get_env(:pleroma, :httpoison)
  10   @registrations_open Keyword.get(@instance, :registrations_open)
  11
  12   def create_status(%User{} = user, %{"status" => _} = data) do
  13     CommonAPI.post(user, data)
  14   end
  15
  16   def delete(%User{} = user, id) do
  17     with %Activity{data: %{"type" => type}} <- Repo.get(Activity, id),
  18          {:ok, activity} <- CommonAPI.delete(id, user) do
  19       {:ok, activity}
  20     end
  21   end
  22
  23   def follow(%User{} = follower, params) do
  24     with {:ok, %User{} = followed} <- get_user(params),
  25          {:ok, follower} <- User.maybe_direct_follow(follower, followed),
  26          {:ok, activity} <- ActivityPub.follow(follower, followed),
  27          {:ok, follower, followed} <- User.wait_and_refresh(500, follower, followed) do
  28       {:ok, follower, followed, activity}
  29     else
  30       err -> err
  31     end
  32   end
  33
  34   def unfollow(%User{} = follower, params) do
  35     with {:ok, %User{} = unfollowed} <- get_user(params),
  36          {:ok, follower, follow_activity} <- User.unfollow(follower, unfollowed),
  37          {:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed) do
  38       {:ok, follower, unfollowed}
  39     else
  40       err -> err
  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_activity_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_activity_by_object_ap_id(id) do
  74       {:ok, activity}
  75     end
  76   end
  77
  78   def fav(%User{} = user, ap_id_or_id) do
  79     with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
  80          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
  81       {:ok, activity}
  82     end
  83   end
  84
  85   def unfav(%User{} = user, ap_id_or_id) do
  86     with {:ok, _unfav, _fav, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
  87          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
  88       {:ok, activity}
  89     end
  90   end
  91
  92   def upload(%Plug.Upload{} = file, format \\ "xml") do
  93     {:ok, object} = ActivityPub.upload(file)
  94
  95     url = List.first(object.data["url"])
  96     href = url["href"]
  97     type = url["mediaType"]
  98
  99     case format do
 100       "xml" ->
 101         # Fake this as good as possible...
 102         """
 103         <?xml version="1.0" encoding="UTF-8"?>
 104         <rsp stat="ok" xmlns:atom="http://www.w3.org/2005/Atom">
 105         <mediaid>#{object.id}</mediaid>
 106         <media_id>#{object.id}</media_id>
 107         <media_id_string>#{object.id}</media_id_string>
 108         <media_url>#{href}</media_url>
 109         <mediaurl>#{href}</mediaurl>
 110         <atom:link rel="enclosure" href="#{href}" type="#{type}"></atom:link>
 111         </rsp>
 112         """
 113
 114       "json" ->
 115         %{
 116           media_id: object.id,
 117           media_id_string: "#{object.id}}",
 118           media_url: href,
 119           size: 0
 120         }
 121         |> Jason.encode!()
 122     end
 123   end
 124
 125   def register_user(params) do
 126     tokenString = params["token"]
 127
 128     params = %{
 129       nickname: params["nickname"],
 130       name: params["fullname"],
 131       bio: params["bio"],
 132       email: params["email"],
 133       password: params["password"],
 134       password_confirmation: params["confirm"]
 135     }
 136
 137     # no need to query DB if registration is open
 138     token =
 139       unless @registrations_open || is_nil(tokenString) do
 140         Repo.get_by(UserInviteToken, %{token: tokenString})
 141       end
 142
 143     cond do
 144       @registrations_open || (!is_nil(token) && !token.used) ->
 145         changeset = User.register_changeset(%User{}, params)
 146
 147         with {:ok, user} <- Repo.insert(changeset) do
 148           !@registrations_open && UserInviteToken.mark_as_used(token.token)
 149           {:ok, user}
 150         else
 151           {:error, changeset} ->
 152             errors =
 153               Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
 154               |> Jason.encode!()
 155
 156             {:error, %{error: errors}}
 157         end
 158
 159       !@registrations_open && is_nil(token) ->
 160         {:error, "Invalid token"}
 161
 162       !@registrations_open && token.used ->
 163         {:error, "Expired token"}
 164     end
 165   end
 166
 167   def get_by_id_or_nickname(id_or_nickname) do
 168     if !is_integer(id_or_nickname) && :error == Integer.parse(id_or_nickname) do
 169       Repo.get_by(User, nickname: id_or_nickname)
 170     else
 171       Repo.get(User, id_or_nickname)
 172     end
 173   end
 174
 175   def get_user(user \\ nil, params) do
 176     case params do
 177       %{"user_id" => user_id} ->
 178         case target = get_by_id_or_nickname(user_id) do
 179           nil ->
 180             {:error, "No user with such user_id"}
 181
 182           _ ->
 183             {:ok, target}
 184         end
 185
 186       %{"screen_name" => nickname} ->
 187         case target = Repo.get_by(User, nickname: nickname) do
 188           nil ->
 189             {:error, "No user with such screen_name"}
 190
 191           _ ->
 192             {:ok, target}
 193         end
 194
 195       _ ->
 196         if user do
 197           {:ok, user}
 198         else
 199           {:error, "You need to specify screen_name or user_id"}
 200         end
 201     end
 202   end
 203
 204   defp parse_int(string, default)
 205
 206   defp parse_int(string, default) when is_binary(string) do
 207     with {n, _} <- Integer.parse(string) do
 208       n
 209     else
 210       _e -> default
 211     end
 212   end
 213
 214   defp parse_int(_, default), do: default
 215
 216   def search(_user, %{"q" => query} = params) do
 217     limit = parse_int(params["rpp"], 20)
 218     page = parse_int(params["page"], 1)
 219     offset = (page - 1) * limit
 220
 221     q =
 222       from(
 223         a in Activity,
 224         where: fragment("?->>'type' = 'Create'", a.data),
 225         where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
 226         where:
 227           fragment(
 228             "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
 229             a.data,
 230             ^query
 231           ),
 232         limit: ^limit,
 233         offset: ^offset,
 234         # this one isn't indexed so psql won't take the wrong index.
 235         order_by: [desc: :inserted_at]
 236       )
 237
 238     _activities = Repo.all(q)
 239   end
 240
 241   defp make_date do
 242     DateTime.utc_now() |> DateTime.to_iso8601()
 243   end
 244
 245   # DEPRECATED mostly, context objects are now created at insertion time.
 246   def context_to_conversation_id(context) do
 247     with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
 248       id
 249     else
 250       _e ->
 251         changeset = Object.context_mapping(context)
 252
 253         case Repo.insert(changeset) do
 254           {:ok, %{id: id}} ->
 255             id
 256
 257           # This should be solved by an upsert, but it seems ecto
 258           # has problems accessing the constraint inside the jsonb.
 259           {:error, _} ->
 260             Object.get_cached_by_ap_id(context).id
 261         end
 262     end
 263   end
 264
 265   def conversation_id_to_context(id) do
 266     with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
 267       context
 268     else
 269       _e ->
 270         {:error, "No such conversation"}
 271     end
 272   end
 273
 274   def get_external_profile(for_user, uri) do
 275     with %User{} = user <- User.get_or_fetch(uri) do
 276       spawn(fn ->
 277         with url <- user.info["topic"],
 278              {:ok, %{body: body}} <-
 279                @httpoison.get(url, [], follow_redirect: true, timeout: 10000, recv_timeout: 20000) do
 280           OStatus.handle_incoming(body)
 281         end
 282       end)
 283
 284       {:ok, UserView.render("show.json", %{user: user, for: for_user})}
 285     else
 286       _e ->
 287         {:error, "Couldn't find user"}
 288     end
 289   end
 290 end