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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Object do
   6   use Ecto.Schema
   7
   8   import Ecto.Query
   9   import Ecto.Changeset
  10
  11   alias Pleroma.Activity
  12   alias Pleroma.Object
  13   alias Pleroma.Object.Fetcher
  14   alias Pleroma.ObjectTombstone
  15   alias Pleroma.Repo
  16   alias Pleroma.User
  17
  18   require Logger
  19
  20   @type t() :: %__MODULE__{}
  21
  22   @derive {Jason.Encoder, only: [:data]}
  23
  24   schema "objects" do
  25     field(:data, :map)
  26
  27     timestamps()
  28   end
  29
  30   def with_joined_activity(query, activity_type \\ "Create", join_type \\ :inner) do
  31     object_position = Map.get(query.aliases, :object, 0)
  32
  33     join(query, join_type, [{object, object_position}], a in Activity,
  34       on:
  35         fragment(
  36           "COALESCE(?->'object'->>'id', ?->>'object') = (? ->> 'id') AND (?->>'type' = ?) ",
  37           a.data,
  38           a.data,
  39           object.data,
  40           a.data,
  41           ^activity_type
  42         ),
  43       as: :object_activity
  44     )
  45   end
  46
  47   def create(data) do
  48     Object.change(%Object{}, %{data: data})
  49     |> Repo.insert()
  50   end
  51
  52   def change(struct, params \\ %{}) do
  53     struct
  54     |> cast(params, [:data])
  55     |> validate_required([:data])
  56     |> unique_constraint(:ap_id, name: :objects_unique_apid_index)
  57   end
  58
  59   def get_by_id(nil), do: nil
  60   def get_by_id(id), do: Repo.get(Object, id)
  61
  62   def get_by_id_and_maybe_refetch(id, opts \\ []) do
  63     %{updated_at: updated_at} = object = get_by_id(id)
  64
  65     if opts[:interval] &&
  66          NaiveDateTime.diff(NaiveDateTime.utc_now(), updated_at) > opts[:interval] do
  67       case Fetcher.refetch_object(object) do
  68         {:ok, %Object{} = object} ->
  69           object
  70
  71         e ->
  72           Logger.error("Couldn't refresh #{object.data["id"]}:\n#{inspect(e)}")
  73           object
  74       end
  75     else
  76       object
  77     end
  78   end
  79
  80   def get_by_ap_id(nil), do: nil
  81
  82   def get_by_ap_id(ap_id) do
  83     Repo.one(from(object in Object, where: fragment("(?)->>'id' = ?", object.data, ^ap_id)))
  84   end
  85
  86   @doc """
  87   Get a single attachment by it's name and href
  88   """
  89   @spec get_attachment_by_name_and_href(String.t(), String.t()) :: Object.t() | nil
  90   def get_attachment_by_name_and_href(name, href) do
  91     query =
  92       from(o in Object,
  93         where: fragment("(?)->>'name' = ?", o.data, ^name),
  94         where: fragment("(?)->>'href' = ?", o.data, ^href)
  95       )
  96
  97     Repo.one(query)
  98   end
  99
 100   defp warn_on_no_object_preloaded(ap_id) do
 101     "Object.normalize() called without preloaded object (#{inspect(ap_id)}). Consider preloading the object"
 102     |> Logger.debug()
 103
 104     Logger.debug("Backtrace: #{inspect(Process.info(:erlang.self(), :current_stacktrace))}")
 105   end
 106
 107   def normalize(_, fetch_remote \\ true, options \\ [])
 108
 109   # If we pass an Activity to Object.normalize(), we can try to use the preloaded object.
 110   # Use this whenever possible, especially when walking graphs in an O(N) loop!
 111   def normalize(%Object{} = object, _, _), do: object
 112   def normalize(%Activity{object: %Object{} = object}, _, _), do: object
 113
 114   # A hack for fake activities
 115   def normalize(%Activity{data: %{"object" => %{"fake" => true} = data}}, _, _) do
 116     %Object{id: "pleroma:fake_object_id", data: data}
 117   end
 118
 119   # No preloaded object
 120   def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}, fetch_remote, _) do
 121     warn_on_no_object_preloaded(ap_id)
 122     normalize(ap_id, fetch_remote)
 123   end
 124
 125   # No preloaded object
 126   def normalize(%Activity{data: %{"object" => ap_id}}, fetch_remote, _) do
 127     warn_on_no_object_preloaded(ap_id)
 128     normalize(ap_id, fetch_remote)
 129   end
 130
 131   # Old way, try fetching the object through cache.
 132   def normalize(%{"id" => ap_id}, fetch_remote, _), do: normalize(ap_id, fetch_remote)
 133   def normalize(ap_id, false, _) when is_binary(ap_id), do: get_cached_by_ap_id(ap_id)
 134
 135   def normalize(ap_id, true, options) when is_binary(ap_id) do
 136     Fetcher.fetch_object_from_id!(ap_id, options)
 137   end
 138
 139   def normalize(_, _, _), do: nil
 140
 141   # Owned objects can only be accessed by their owner
 142   def authorize_access(%Object{data: %{"actor" => actor}}, %User{ap_id: ap_id}) do
 143     if actor == ap_id do
 144       :ok
 145     else
 146       {:error, :forbidden}
 147     end
 148   end
 149
 150   # Legacy objects can be accessed by anybody
 151   def authorize_access(%Object{}, %User{}), do: :ok
 152
 153   @spec get_cached_by_ap_id(String.t()) :: Object.t() | nil
 154   def get_cached_by_ap_id(ap_id) do
 155     key = "object:#{ap_id}"
 156
 157     with {:ok, nil} <- Cachex.get(:object_cache, key),
 158          object when not is_nil(object) <- get_by_ap_id(ap_id),
 159          {:ok, true} <- Cachex.put(:object_cache, key, object) do
 160       object
 161     else
 162       {:ok, object} -> object
 163       nil -> nil
 164     end
 165   end
 166
 167   def context_mapping(context) do
 168     Object.change(%Object{}, %{data: %{"id" => context}})
 169   end
 170
 171   def make_tombstone(%Object{data: %{"id" => id, "type" => type}}, deleted \\ DateTime.utc_now()) do
 172     %ObjectTombstone{
 173       id: id,
 174       formerType: type,
 175       deleted: deleted
 176     }
 177     |> Map.from_struct()
 178   end
 179
 180   def swap_object_with_tombstone(object) do
 181     tombstone = make_tombstone(object)
 182
 183     object
 184     |> Object.change(%{data: tombstone})
 185     |> Repo.update()
 186   end
 187
 188   def delete(%Object{data: %{"id" => id}} = object) do
 189     with {:ok, _obj} = swap_object_with_tombstone(object),
 190          deleted_activity = Activity.delete_all_by_object_ap_id(id),
 191          {:ok, true} <- Cachex.del(:object_cache, "object:#{id}"),
 192          {:ok, _} <- Cachex.del(:web_resp_cache, URI.parse(id).path) do
 193       with true <- Pleroma.Config.get([:instance, :cleanup_attachments]) do
 194         {:ok, _} =
 195           Pleroma.Workers.AttachmentsCleanupWorker.enqueue("cleanup_attachments", %{
 196             "object" => object
 197           })
 198       end
 199
 200       {:ok, object, deleted_activity}
 201     end
 202   end
 203
 204   def prune(%Object{data: %{"id" => id}} = object) do
 205     with {:ok, object} <- Repo.delete(object),
 206          {:ok, true} <- Cachex.del(:object_cache, "object:#{id}"),
 207          {:ok, _} <- Cachex.del(:web_resp_cache, URI.parse(id).path) do
 208       {:ok, object}
 209     end
 210   end
 211
 212   def set_cache(%Object{data: %{"id" => ap_id}} = object) do
 213     Cachex.put(:object_cache, "object:#{ap_id}", object)
 214     {:ok, object}
 215   end
 216
 217   def update_and_set_cache(changeset) do
 218     with {:ok, object} <- Repo.update(changeset) do
 219       set_cache(object)
 220     end
 221   end
 222
 223   def increase_replies_count(ap_id) do
 224     Object
 225     |> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
 226     |> update([o],
 227       set: [
 228         data:
 229           fragment(
 230             """
 231             safe_jsonb_set(?, '{repliesCount}',
 232               (coalesce((?->>'repliesCount')::int, 0) + 1)::varchar::jsonb, true)
 233             """,
 234             o.data,
 235             o.data
 236           )
 237       ]
 238     )
 239     |> Repo.update_all([])
 240     |> case do
 241       {1, [object]} -> set_cache(object)
 242       _ -> {:error, "Not found"}
 243     end
 244   end
 245
 246   def decrease_replies_count(ap_id) do
 247     Object
 248     |> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
 249     |> update([o],
 250       set: [
 251         data:
 252           fragment(
 253             """
 254             safe_jsonb_set(?, '{repliesCount}',
 255               (greatest(0, (?->>'repliesCount')::int - 1))::varchar::jsonb, true)
 256             """,
 257             o.data,
 258             o.data
 259           )
 260       ]
 261     )
 262     |> Repo.update_all([])
 263     |> case do
 264       {1, [object]} -> set_cache(object)
 265       _ -> {:error, "Not found"}
 266     end
 267   end
 268
 269   def increase_vote_count(ap_id, name, actor) do
 270     with %Object{} = object <- Object.normalize(ap_id),
 271          "Question" <- object.data["type"] do
 272       multiple = Map.has_key?(object.data, "anyOf")
 273
 274       options =
 275         (object.data["anyOf"] || object.data["oneOf"] || [])
 276         |> Enum.map(fn
 277           %{"name" => ^name} = option ->
 278             Kernel.update_in(option["replies"]["totalItems"], &(&1 + 1))
 279
 280           option ->
 281             option
 282         end)
 283
 284       voters = [actor | object.data["voters"] || []] |> Enum.uniq()
 285
 286       data =
 287         if multiple do
 288           Map.put(object.data, "anyOf", options)
 289         else
 290           Map.put(object.data, "oneOf", options)
 291         end
 292         |> Map.put("voters", voters)
 293
 294       object
 295       |> Object.change(%{data: data})
 296       |> update_and_set_cache()
 297     else
 298       _ -> :noop
 299     end
 300   end
 301
 302   @doc "Updates data field of an object"
 303   def update_data(%Object{data: data} = object, attrs \\ %{}) do
 304     object
 305     |> Object.change(%{data: Map.merge(data || %{}, attrs)})
 306     |> Repo.update()
 307   end
 308
 309   def local?(%Object{data: %{"id" => id}}) do
 310     String.starts_with?(id, Pleroma.Web.base_url() <> "/")
 311   end
 312
 313   def replies(object, opts \\ []) do
 314     object = Object.normalize(object)
 315
 316     query =
 317       Object
 318       |> where(
 319         [o],
 320         fragment("(?)->>'inReplyTo' = ?", o.data, ^object.data["id"])
 321       )
 322       |> order_by([o], asc: o.id)
 323
 324     if opts[:self_only] do
 325       actor = object.data["actor"]
 326       where(query, [o], fragment("(?)->>'actor' = ?", o.data, ^actor))
 327     else
 328       query
 329     end
 330   end
 331
 332   def self_replies(object, opts \\ []),
 333     do: replies(object, Keyword.put(opts, :self_only, true))
 334 end