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

   1 defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
   2   alias Pleroma.{User, Activity, Repo, Object}
   3   alias Pleroma.Web.ActivityPub.ActivityPub
   4   alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
   5   alias Pleroma.Web.TwitterAPI.UserView
   6   alias Pleroma.Web.{OStatus, CommonAPI}
   7   import Ecto.Query
   8
   9   @httpoison Application.get_env(:pleroma, :httpoison)
  10
  11   def create_status(%User{} = user, %{"status" => _} = data) do
  12     CommonAPI.post(user, data)
  13   end
  14
  15   def fetch_friend_statuses(user, opts \\ %{}) do
  16     opts =
  17       opts
  18       |> Map.put("blocking_user", user)
  19       |> Map.put("user", user)
  20       |> Map.put("type", ["Create", "Announce", "Follow", "Like"])
  21
  22     ActivityPub.fetch_activities([user.ap_id | user.following], opts)
  23     |> activities_to_statuses(%{for: user})
  24   end
  25
  26   def fetch_public_statuses(user, opts \\ %{}) do
  27     opts =
  28       opts
  29       |> Map.put("local_only", true)
  30       |> Map.put("blocking_user", user)
  31       |> Map.put("type", ["Create", "Announce", "Follow"])
  32
  33     ActivityPub.fetch_public_activities(opts)
  34     |> activities_to_statuses(%{for: user})
  35   end
  36
  37   def fetch_public_and_external_statuses(user, opts \\ %{}) do
  38     opts =
  39       opts
  40       |> Map.put("blocking_user", user)
  41       |> Map.put("type", ["Create", "Announce", "Follow"])
  42
  43     ActivityPub.fetch_public_activities(opts)
  44     |> activities_to_statuses(%{for: user})
  45   end
  46
  47   def fetch_user_statuses(user, opts \\ %{}) do
  48     opts =
  49       opts
  50       |> Map.put("type", ["Create"])
  51
  52     ActivityPub.fetch_public_activities(opts)
  53     |> activities_to_statuses(%{for: user})
  54   end
  55
  56   def fetch_mentions(user, opts \\ %{}) do
  57     ActivityPub.fetch_activities([user.ap_id], opts)
  58     |> activities_to_statuses(%{for: user})
  59   end
  60
  61   def fetch_conversation(user, id) do
  62     with context when is_binary(context) <- conversation_id_to_context(id),
  63          activities <-
  64            ActivityPub.fetch_activities_for_context(context, %{
  65              "blocking_user" => user,
  66              "user" => user
  67            }),
  68          statuses <- activities |> activities_to_statuses(%{for: user}) do
  69       statuses
  70     else
  71       _e ->
  72         []
  73     end
  74   end
  75
  76   def fetch_status(user, id) do
  77     with %Activity{} = activity <- Repo.get(Activity, id),
  78          true <- ActivityPub.visible_for_user?(activity, user) do
  79       activity_to_status(activity, %{for: user})
  80     end
  81   end
  82
  83   def follow(%User{} = follower, params) do
  84     with {:ok, %User{} = followed} <- get_user(params),
  85          {:ok, follower} <- User.follow(follower, followed),
  86          {:ok, activity} <- ActivityPub.follow(follower, followed) do
  87       {:ok, follower, followed, activity}
  88     else
  89       err -> err
  90     end
  91   end
  92
  93   def unfollow(%User{} = follower, params) do
  94     with {:ok, %User{} = unfollowed} <- get_user(params),
  95          {:ok, follower, follow_activity} <- User.unfollow(follower, unfollowed),
  96          {:ok, _activity} <-
  97            ActivityPub.insert(%{
  98              "type" => "Undo",
  99              "actor" => follower.ap_id,
 100              # get latest Follow for these users
 101              "object" => follow_activity.data["id"],
 102              "published" => make_date()
 103            }) do
 104       {:ok, follower, unfollowed}
 105     else
 106       err -> err
 107     end
 108   end
 109
 110   def block(%User{} = blocker, params) do
 111     with {:ok, %User{} = blocked} <- get_user(params),
 112          {:ok, blocker} <- User.block(blocker, blocked) do
 113       {:ok, blocker, blocked}
 114     else
 115       err -> err
 116     end
 117   end
 118
 119   def unblock(%User{} = blocker, params) do
 120     with {:ok, %User{} = blocked} <- get_user(params),
 121          {:ok, blocker} <- User.unblock(blocker, blocked) do
 122       {:ok, blocker, blocked}
 123     else
 124       err -> err
 125     end
 126   end
 127
 128   def repeat(%User{} = user, ap_id_or_id) do
 129     with {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(ap_id_or_id, user),
 130          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id),
 131          status <- activity_to_status(activity, %{for: user}) do
 132       {:ok, status}
 133     end
 134   end
 135
 136   def fav(%User{} = user, ap_id_or_id) do
 137     with {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.favorite(ap_id_or_id, user),
 138          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id),
 139          status <- activity_to_status(activity, %{for: user}) do
 140       {:ok, status}
 141     end
 142   end
 143
 144   def unfav(%User{} = user, ap_id_or_id) do
 145     with {:ok, %{data: %{"id" => id}}} = CommonAPI.unfavorite(ap_id_or_id, user),
 146          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id),
 147          status <- activity_to_status(activity, %{for: user}) do
 148       {:ok, status}
 149     end
 150   end
 151
 152   def upload(%Plug.Upload{} = file, format \\ "xml") do
 153     {:ok, object} = ActivityPub.upload(file)
 154
 155     url = List.first(object.data["url"])
 156     href = url["href"]
 157     type = url["mediaType"]
 158
 159     case format do
 160       "xml" ->
 161         # Fake this as good as possible...
 162         """
 163         <?xml version="1.0" encoding="UTF-8"?>
 164         <rsp stat="ok" xmlns:atom="http://www.w3.org/2005/Atom">
 165         <mediaid>#{object.id}</mediaid>
 166         <media_id>#{object.id}</media_id>
 167         <media_id_string>#{object.id}</media_id_string>
 168         <media_url>#{href}</media_url>
 169         <mediaurl>#{href}</mediaurl>
 170         <atom:link rel="enclosure" href="#{href}" type="#{type}"></atom:link>
 171         </rsp>
 172         """
 173
 174       "json" ->
 175         %{
 176           media_id: object.id,
 177           media_id_string: "#{object.id}}",
 178           media_url: href,
 179           size: 0
 180         }
 181         |> Jason.encode!()
 182     end
 183   end
 184
 185   def register_user(params) do
 186     params = %{
 187       nickname: params["nickname"],
 188       name: params["fullname"],
 189       bio: params["bio"],
 190       email: params["email"],
 191       password: params["password"],
 192       password_confirmation: params["confirm"]
 193     }
 194
 195     changeset = User.register_changeset(%User{}, params)
 196
 197     with {:ok, user} <- Repo.insert(changeset) do
 198       {:ok, user}
 199     else
 200       {:error, changeset} ->
 201         errors =
 202           Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
 203           |> Jason.encode!()
 204
 205         {:error, %{error: errors}}
 206     end
 207   end
 208
 209   def get_by_id_or_nickname(id_or_nickname) do
 210     if !is_integer(id_or_nickname) && :error == Integer.parse(id_or_nickname) do
 211       Repo.get_by(User, nickname: id_or_nickname)
 212     else
 213       Repo.get(User, id_or_nickname)
 214     end
 215   end
 216
 217   def get_user(user \\ nil, params) do
 218     case params do
 219       %{"user_id" => user_id} ->
 220         case target = get_by_id_or_nickname(user_id) do
 221           nil ->
 222             {:error, "No user with such user_id"}
 223
 224           _ ->
 225             {:ok, target}
 226         end
 227
 228       %{"screen_name" => nickname} ->
 229         case target = Repo.get_by(User, nickname: nickname) do
 230           nil ->
 231             {:error, "No user with such screen_name"}
 232
 233           _ ->
 234             {:ok, target}
 235         end
 236
 237       _ ->
 238         if user do
 239           {:ok, user}
 240         else
 241           {:error, "You need to specify screen_name or user_id"}
 242         end
 243     end
 244   end
 245
 246   defp parse_int(string, default)
 247
 248   defp parse_int(string, default) when is_binary(string) do
 249     with {n, _} <- Integer.parse(string) do
 250       n
 251     else
 252       _e -> default
 253     end
 254   end
 255
 256   defp parse_int(_, default), do: default
 257
 258   def search(user, %{"q" => query} = params) do
 259     limit = parse_int(params["rpp"], 20)
 260     page = parse_int(params["page"], 1)
 261     offset = (page - 1) * limit
 262
 263     q =
 264       from(
 265         a in Activity,
 266         where: fragment("?->>'type' = 'Create'", a.data),
 267         where:
 268           fragment(
 269             "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
 270             a.data,
 271             ^query
 272           ),
 273         limit: ^limit,
 274         offset: ^offset,
 275         # this one isn't indexed so psql won't take the wrong index.
 276         order_by: [desc: :inserted_at]
 277       )
 278
 279     activities = Repo.all(q)
 280   end
 281
 282   defp activities_to_statuses(activities, opts) do
 283     Enum.map(activities, fn activity ->
 284       activity_to_status(activity, opts)
 285     end)
 286   end
 287
 288   # For likes, fetch the liked activity, too.
 289   defp activity_to_status(%Activity{data: %{"type" => "Like"}} = activity, opts) do
 290     actor = get_in(activity.data, ["actor"])
 291     user = User.get_cached_by_ap_id(actor)
 292     [liked_activity] = Activity.all_by_object_ap_id(activity.data["object"])
 293
 294     ActivityRepresenter.to_map(
 295       activity,
 296       Map.merge(opts, %{user: user, liked_activity: liked_activity})
 297     )
 298   end
 299
 300   # For announces, fetch the announced activity and the user.
 301   defp activity_to_status(%Activity{data: %{"type" => "Announce"}} = activity, opts) do
 302     actor = get_in(activity.data, ["actor"])
 303     user = User.get_cached_by_ap_id(actor)
 304     [announced_activity] = Activity.all_by_object_ap_id(activity.data["object"])
 305     announced_actor = User.get_cached_by_ap_id(announced_activity.data["actor"])
 306
 307     ActivityRepresenter.to_map(
 308       activity,
 309       Map.merge(opts, %{users: [user, announced_actor], announced_activity: announced_activity})
 310     )
 311   end
 312
 313   defp activity_to_status(%Activity{data: %{"type" => "Delete"}} = activity, opts) do
 314     actor = get_in(activity.data, ["actor"])
 315     user = User.get_cached_by_ap_id(actor)
 316     ActivityRepresenter.to_map(activity, Map.merge(opts, %{user: user}))
 317   end
 318
 319   defp activity_to_status(activity, opts) do
 320     actor = get_in(activity.data, ["actor"])
 321     user = User.get_cached_by_ap_id(actor)
 322     # mentioned_users = Repo.all(from user in User, where: user.ap_id in ^activity.data["to"])
 323     mentioned_users =
 324       Enum.map(activity.recipients || [], fn ap_id ->
 325         if ap_id do
 326           User.get_cached_by_ap_id(ap_id)
 327         else
 328           nil
 329         end
 330       end)
 331       |> Enum.filter(& &1)
 332
 333     ActivityRepresenter.to_map(
 334       activity,
 335       Map.merge(opts, %{user: user, mentioned: mentioned_users})
 336     )
 337   end
 338
 339   defp make_date do
 340     DateTime.utc_now() |> DateTime.to_iso8601()
 341   end
 342
 343   def context_to_conversation_id(context) do
 344     with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
 345       id
 346     else
 347       _e ->
 348         changeset = Object.context_mapping(context)
 349
 350         case Repo.insert(changeset) do
 351           {:ok, %{id: id}} ->
 352             id
 353
 354           # This should be solved by an upsert, but it seems ecto
 355           # has problems accessing the constraint inside the jsonb.
 356           {:error, _} ->
 357             Object.get_cached_by_ap_id(context).id
 358         end
 359     end
 360   end
 361
 362   def conversation_id_to_context(id) do
 363     with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
 364       context
 365     else
 366       _e ->
 367         {:error, "No such conversation"}
 368     end
 369   end
 370
 371   def get_external_profile(for_user, uri) do
 372     with %User{} = user <- User.get_or_fetch(uri) do
 373       spawn(fn ->
 374         with url <- user.info["topic"],
 375              {:ok, %{body: body}} <-
 376                @httpoison.get(url, [], follow_redirect: true, timeout: 10000, recv_timeout: 20000) do
 377           OStatus.handle_incoming(body)
 378         end
 379       end)
 380
 381       {:ok, UserView.render("show.json", %{user: user, for: for_user})}
 382     else
 383       _e ->
 384         {:error, "Couldn't find user"}
 385     end
 386   end
 387 end