Merge remote-tracking branch 'origin/develop' into improved-reachability

lib/pleroma/backports.ex

@@ -0,0 +1,72 @@
+# Copyright 2012 Plataformatec
+# Copyright 2021 The Elixir Team
+# SPDX-License-Identifier: Apache-2.0
+
+defmodule Pleroma.Backports do
+  import File, only: [dir?: 1]
+
+  # <https://github.com/elixir-lang/elixir/pull/14242>
+  # To be removed when we require Elixir 1.19
+  @doc """
+  Tries to create the directory `path`.
+
+  Missing parent directories are created. Returns `:ok` if successful, or
+  `{:error, reason}` if an error occurs.
+
+  Typical error reasons are:
+
+    * `:eacces`  - missing search or write permissions for the parent
+      directories of `path`
+    * `:enospc`  - there is no space left on the device
+    * `:enotdir` - a component of `path` is not a directory
+
+  """
+  @spec mkdir_p(Path.t()) :: :ok | {:error, File.posix() | :badarg}
+  def mkdir_p(path) do
+    do_mkdir_p(IO.chardata_to_string(path))
+  end
+
+  defp do_mkdir_p("/") do
+    :ok
+  end
+
+  defp do_mkdir_p(path) do
+    parent = Path.dirname(path)
+
+    if parent == path do
+      :ok
+    else
+      case do_mkdir_p(parent) do
+        :ok ->
+          case :file.make_dir(path) do
+            {:error, :eexist} ->
+              if dir?(path), do: :ok, else: {:error, :enotdir}
+
+            other ->
+              other
+          end
+
+        e ->
+          e
+      end
+    end
+  end
+
+  @doc """
+  Same as `mkdir_p/1`, but raises a `File.Error` exception in case of failure.
+  Otherwise `:ok`.
+  """
+  @spec mkdir_p!(Path.t()) :: :ok
+  def mkdir_p!(path) do
+    case mkdir_p(path) do
+      :ok ->
+        :ok
+
+      {:error, reason} ->
+        raise File.Error,
+          reason: reason,
+          action: "make directory (with -p)",
+          path: IO.chardata_to_string(path)
+    end
+  end
+end

lib/pleroma/constants.ex

@@ -100,6 +100,7 @@ defmodule Pleroma.Constants do
       "Add",
       "Remove",
       "Like",
+      "Dislike",
       "Announce",
       "Undo",
       "Flag",
@@ -115,6 +116,7 @@ defmodule Pleroma.Constants do
       "Flag",
       "Follow",
       "Like",
+      "Dislike",
       "EmojiReact",
       "Announce"
     ]

lib/pleroma/emoji/pack.ex

@@ -488,7 +488,7 @@ defmodule Pleroma.Emoji.Pack do
     with true <- String.contains?(file_path, "/"),
          path <- Path.dirname(file_path),
          false <- File.exists?(path) do
-      File.mkdir_p!(path)
+      Pleroma.Backports.mkdir_p!(path)
     end
   end
 
@@ -536,7 +536,7 @@ defmodule Pleroma.Emoji.Pack do
     emoji_path = emoji_path()
     # Create the directory first if it does not exist. This is probably the first request made
     # with the API so it should be sufficient
-    with {:create_dir, :ok} <- {:create_dir, File.mkdir_p(emoji_path)},
+    with {:create_dir, :ok} <- {:create_dir, Pleroma.Backports.mkdir_p(emoji_path)},
          {:ls, {:ok, results}} <- {:ls, File.ls(emoji_path)} do
       {:ok, Enum.sort(results)}
     else
@@ -561,7 +561,7 @@ defmodule Pleroma.Emoji.Pack do
   end
 
   defp unzip(archive, pack_info, remote_pack, local_pack) do
-    with :ok <- File.mkdir_p!(local_pack.path) do
+    with :ok <- Pleroma.Backports.mkdir_p!(local_pack.path) do
       files = Enum.map(remote_pack["files"], fn {_, path} -> path end)
       # Fallback cannot contain a pack.json file
       files = if pack_info[:fallback], do: files, else: ["pack.json" | files]

lib/pleroma/frontend.ex

@@ -66,7 +66,7 @@ defmodule Pleroma.Frontend do
 
   def unzip(zip, dest) do
     File.rm_rf!(dest)
-    File.mkdir_p!(dest)
+    Pleroma.Backports.mkdir_p!(dest)
 
     case Pleroma.SafeZip.unzip_data(zip, dest) do
       {:ok, _} -> :ok
@@ -90,7 +90,7 @@ defmodule Pleroma.Frontend do
   defp install_frontend(frontend_info, source, dest) do
     from = frontend_info["build_dir"] || "dist"
     File.rm_rf!(dest)
-    File.mkdir_p!(dest)
+    Pleroma.Backports.mkdir_p!(dest)
     File.cp_r!(Path.join([source, from]), dest)
     :ok
   end

lib/pleroma/instances/instance.ex

@@ -9,7 +9,6 @@ defmodule Pleroma.Instances.Instance do
   alias Pleroma.Instances.Instance
   alias Pleroma.Maps
   alias Pleroma.Repo
-  alias Pleroma.User
   alias Pleroma.Workers.DeleteWorker
 
   use Ecto.Schema
@@ -294,16 +293,4 @@ defmodule Pleroma.Instances.Instance do
     DeleteWorker.new(%{"op" => "delete_instance", "host" => host})
     |> Oban.insert()
   end
-
-  def perform(:delete_instance, host) when is_binary(host) do
-    User.Query.build(%{nickname: "@#{host}"})
-    |> Repo.chunk_stream(100, :batches)
-    |> Stream.each(fn users ->
-      users
-      |> Enum.each(fn user ->
-        User.perform(:delete, user)
-      end)
-    end)
-    |> Stream.run()
-  end
 end

lib/pleroma/language/translation/deepl.ex

@@ -24,17 +24,15 @@ defmodule Pleroma.Language.Translation.Deepl do
       |> URI.to_string()
 
     case Pleroma.HTTP.post(
-           endpoint <>
-             "?" <>
-             URI.encode_query(%{
-               text: content,
-               source_lang: source_language |> String.upcase(),
-               target_lang: target_language,
-               tag_handling: "html"
-             }),
-           "",
+           endpoint,
+           Jason.encode!(%{
+             text: [content],
+             source_lang: source_language |> String.upcase(),
+             target_lang: target_language,
+             tag_handling: "html"
+           }),
            [
-             {"Content-Type", "application/x-www-form-urlencoded"},
+             {"Content-Type", "application/json"},
              {"Authorization", "DeepL-Auth-Key #{api_key()}"}
            ]
          ) do

lib/pleroma/uploaders/local.ex

@@ -19,7 +19,7 @@ defmodule Pleroma.Uploaders.Local do
 
         [file | folders] ->
           path = Path.join([upload_path()] ++ Enum.reverse(folders))
-          File.mkdir_p!(path)
+          Pleroma.Backports.mkdir_p!(path)
           {path, file}
       end
 

lib/pleroma/user.ex

@@ -150,7 +150,7 @@ defmodule Pleroma.User do
     field(:allow_following_move, :boolean, default: true)
     field(:skip_thread_containment, :boolean, default: false)
     field(:actor_type, :string, default: "Person")
-    field(:also_known_as, {:array, ObjectValidators.ObjectID}, default: [])
+    field(:also_known_as, {:array, ObjectValidators.BareUri}, default: [])
     field(:inbox, :string)
     field(:shared_inbox, :string)
     field(:accepts_chat_messages, :boolean, default: nil)

lib/pleroma/user/backup.ex

@@ -193,7 +193,7 @@ defmodule Pleroma.User.Backup do
     backup = Repo.preload(backup, :user)
     tempfile = Path.join([backup.tempdir, backup.file_name])
 
-    with {_, :ok} <- {:mkdir, File.mkdir_p(backup.tempdir)},
+    with {_, :ok} <- {:mkdir, Pleroma.Backports.mkdir_p(backup.tempdir)},
          {_, :ok} <- {:actor, actor(backup.tempdir, backup.user)},
          {_, :ok} <- {:statuses, statuses(backup.tempdir, backup.user)},
          {_, :ok} <- {:likes, likes(backup.tempdir, backup.user)},

lib/pleroma/web/activity_pub/mrf/quiet_reply.ex

@@ -0,0 +1,61 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2023 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.ActivityPub.MRF.QuietReply do
+  @moduledoc """
+  QuietReply alters the scope of activities from local users when replying by enforcing them to be "Unlisted" or "Quiet Public". This delivers the activity to all the expected recipients and instances, but it will not be published in the Federated / The Whole Known Network timelines. It will still be published to the Home timelines of the user's followers and visible to anyone who opens the thread.
+  """
+  require Pleroma.Constants
+
+  alias Pleroma.User
+
+  @behaviour Pleroma.Web.ActivityPub.MRF.Policy
+
+  @impl true
+  def history_awareness, do: :auto
+
+  @impl true
+  def filter(
+        %{
+          "type" => "Create",
+          "to" => to,
+          "cc" => cc,
+          "object" => %{
+            "actor" => actor,
+            "type" => "Note",
+            "inReplyTo" => in_reply_to
+          }
+        } = activity
+      ) do
+    with true <- is_binary(in_reply_to),
+         true <- Pleroma.Constants.as_public() in to,
+         %User{follower_address: followers_collection, local: true} <-
+           User.get_by_ap_id(actor) do
+      updated_to =
+        [followers_collection | to]
+        |> Kernel.--([Pleroma.Constants.as_public()])
+
+      updated_cc =
+        [Pleroma.Constants.as_public() | cc]
+        |> Kernel.--([followers_collection])
+
+      updated_activity =
+        activity
+        |> Map.put("to", updated_to)
+        |> Map.put("cc", updated_cc)
+        |> put_in(["object", "to"], updated_to)
+        |> put_in(["object", "cc"], updated_cc)
+
+      {:ok, updated_activity}
+    else
+      _ -> {:ok, activity}
+    end
+  end
+
+  @impl true
+  def filter(activity), do: {:ok, activity}
+
+  @impl true
+  def describe, do: {:ok, %{}}
+end

lib/pleroma/web/activity_pub/mrf/steal_emoji_policy.ex

@@ -87,7 +87,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.StealEmojiPolicy do
           Path.join(Config.get([:instance, :static_dir]), "emoji/stolen")
         )
 
-      File.mkdir_p(emoji_dir_path)
+      Pleroma.Backports.mkdir_p(emoji_dir_path)
 
       new_emojis =
         foreign_emojis

lib/pleroma/web/activity_pub/publisher.ex

@@ -93,7 +93,20 @@ defmodule Pleroma.Web.ActivityPub.Publisher do
 
     {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
 
-    cc = Map.get(params, :cc, [])
+    param_cc = Map.get(params, :cc, [])
+
+    original_cc = Map.get(data, "cc", [])
+
+    public_address = Pleroma.Constants.as_public()
+
+    # Ensure unlisted posts don't lose the public address in the cc
+    # if the param_cc was set
+    cc =
+      if public_address in original_cc and public_address not in param_cc do
+        [public_address | param_cc]
+      else
+        param_cc
+      end
 
     json =
       data

lib/pleroma/web/activity_pub/transmogrifier.ex

@@ -664,6 +664,24 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do
     end
   end
 
+  # Rewrite dislikes into the thumbs down emoji
+  defp handle_incoming_normalized(%{"type" => "Dislike"} = data, options) do
+    data
+    |> Map.put("type", "EmojiReact")
+    |> Map.put("content", "👎")
+    |> handle_incoming_normalized(options)
+  end
+
+  defp handle_incoming_normalized(
+         %{"type" => "Undo", "object" => %{"type" => "Dislike"}} = data,
+         options
+       ) do
+    data
+    |> put_in(["object", "type"], "EmojiReact")
+    |> put_in(["object", "content"], "👎")
+    |> handle_incoming_normalized(options)
+  end
+
   defp handle_incoming_normalized(_, _), do: :error
 
   @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil

lib/pleroma/web/api_spec/operations/pleroma_scrobble_operation.ex

@@ -59,11 +59,15 @@ defmodule Pleroma.Web.ApiSpec.PleromaScrobbleOperation do
         album: %Schema{type: :string, description: "The album of the media playing"},
         artist: %Schema{type: :string, description: "The artist of the media playing"},
         length: %Schema{type: :integer, description: "The length of the media playing"},
-        externalLink: %Schema{type: :string, description: "A URL referencing the media playing"},
+        external_link: %Schema{type: :string, description: "A URL referencing the media playing"},
         visibility: %Schema{
           allOf: [VisibilityScope],
           default: "public",
           description: "Scrobble visibility"
+        },
+        externalLink: %Schema{
+          type: :string,
+          description: "Deprecated, use `external_link` instead"
         }
       },
       example: %{
@@ -71,7 +75,7 @@ defmodule Pleroma.Web.ApiSpec.PleromaScrobbleOperation do
         "artist" => "Some Artist",
         "album" => "Some Album",
         "length" => 180_000,
-        "externalLink" => "https://www.last.fm/music/Some+Artist/_/Some+Title"
+        "external_link" => "https://www.last.fm/music/Some+Artist/_/Some+Title"
       }
     }
   end
@@ -85,7 +89,7 @@ defmodule Pleroma.Web.ApiSpec.PleromaScrobbleOperation do
         title: %Schema{type: :string, description: "The title of the media playing"},
         album: %Schema{type: :string, description: "The album of the media playing"},
         artist: %Schema{type: :string, description: "The artist of the media playing"},
-        externalLink: %Schema{type: :string, description: "A URL referencing the media playing"},
+        external_link: %Schema{type: :string, description: "A URL referencing the media playing"},
         length: %Schema{
           type: :integer,
           description: "The length of the media playing",
@@ -100,7 +104,7 @@ defmodule Pleroma.Web.ApiSpec.PleromaScrobbleOperation do
         "artist" => "Some Artist",
         "album" => "Some Album",
         "length" => 180_000,
-        "externalLink" => "https://www.last.fm/music/Some+Artist/_/Some+Title",
+        "external_link" => "https://www.last.fm/music/Some+Artist/_/Some+Title",
         "created_at" => "2019-09-28T12:40:45.000Z"
       }
     }

lib/pleroma/web/common_api/activity_draft.ex

@@ -91,7 +91,8 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
   defp listen_object(draft) do
     object =
       draft.params
-      |> Map.take([:album, :artist, :title, :length, :externalLink])
+      |> Map.take([:album, :artist, :title, :length])
+      |> Map.put(:externalLink, Map.get(draft.params, :external_link))
       |> Map.new(fn {key, value} -> {to_string(key), value} end)
       |> Map.put("type", "Audio")
       |> Map.put("to", draft.to)

lib/pleroma/web/instance_document.ex

@@ -46,7 +46,7 @@ defmodule Pleroma.Web.InstanceDocument do
 
   defp put_file(origin_path, destination_path) do
     with destination <- instance_static_dir(destination_path),
-         {_, :ok} <- {:mkdir_p, File.mkdir_p(Path.dirname(destination))},
+         {_, :ok} <- {:mkdir_p, Pleroma.Backports.mkdir_p(Path.dirname(destination))},
          {_, {:ok, _}} <- {:copy, File.copy(origin_path, destination)} do
       :ok
     else

lib/pleroma/web/mastodon_api/controllers/search_controller.ex

@@ -190,7 +190,7 @@ defmodule Pleroma.Web.MastodonAPI.SearchController do
       f.()
     rescue
       error ->
-        Logger.error("#{__MODULE__} search error: #{inspect(error)}")
+        Logger.error(Exception.format(:error, error, __STACKTRACE__))
         fallback
     end
   end

lib/pleroma/web/mastodon_api/views/instance_view.ex

@@ -287,7 +287,8 @@ defmodule Pleroma.Web.MastodonAPI.InstanceView do
         birthday_required: Config.get([:instance, :birthday_required]),
         birthday_min_age: Config.get([:instance, :birthday_min_age]),
         translation: supported_languages(),
-        base_urls: base_urls
+        base_urls: base_urls,
+        markup: markup()
       },
       stats: %{mau: Pleroma.User.active_user_count()},
       vapid_public_key: Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
@@ -338,4 +339,12 @@ defmodule Pleroma.Web.MastodonAPI.InstanceView do
       target_languages: target_languages
     }
   end
+
+  defp markup do
+    %{
+      allow_inline_images: Config.get([:markup, :allow_inline_images]),
+      allow_headings: Config.get([:markup, :allow_headings]),
+      allow_tables: Config.get([:markup, :allow_tables])
+    }
+  end
 end

lib/pleroma/web/pleroma_api/controllers/scrobble_controller.ex

@@ -24,6 +24,10 @@ defmodule Pleroma.Web.PleromaAPI.ScrobbleController do
   defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.PleromaScrobbleOperation
 
   def create(%{assigns: %{user: user}, body_params: params} = conn, _) do
+    params =
+      params
+      |> Map.put_new(:external_link, Map.get(params, :externalLink))
+
     with {:ok, activity} <- CommonAPI.listen(user, params) do
       render(conn, "show.json", activity: activity, for: user)
     else

lib/pleroma/web/pleroma_api/views/scrobble_view.ex

@@ -27,8 +27,10 @@ defmodule Pleroma.Web.PleromaAPI.ScrobbleView do
       title: object.data["title"] |> HTML.strip_tags(),
       artist: object.data["artist"] |> HTML.strip_tags(),
       album: object.data["album"] |> HTML.strip_tags(),
-      externalLink: object.data["externalLink"],
-      length: object.data["length"]
+      external_link: object.data["externalLink"],
+      length: object.data["length"],
+      # DEPRECATED
+      externalLink: object.data["externalLink"]
     }
   end
 

lib/pleroma/workers/delete_worker.ex

@@ -3,7 +3,6 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Workers.DeleteWorker do
-  alias Pleroma.Instances.Instance
   alias Pleroma.User
 
   use Oban.Worker, queue: :slow
@@ -15,7 +14,15 @@ defmodule Pleroma.Workers.DeleteWorker do
   end
 
   def perform(%Job{args: %{"op" => "delete_instance", "host" => host}}) do
-    Instance.perform(:delete_instance, host)
+    Pleroma.Repo.transaction(fn ->
+      User.Query.build(%{nickname: "@#{host}"})
+      |> Pleroma.Repo.all()
+      |> Enum.each(fn user ->
+        %{"op" => "delete_user", "user_id" => user.id}
+        |> __MODULE__.new()
+        |> Oban.insert()
+      end)
+    end)
   end
 
   @impl true