Draft: Multi-language posting

lib/pleroma/ecto_type/activity_pub/object_validators/content_language_map.ex

@@ -5,13 +5,13 @@
 defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.ContentLanguageMap do
   use Ecto.Type
 
-  import Pleroma.EctoType.ActivityPub.ObjectValidators.LanguageCode,
-    only: [good_locale_code?: 1]
+  alias Pleroma.MultiLanguage
 
   def type, do: :map
 
   def cast(%{} = object) do
-    with {status, %{} = data} when status in [:modified, :ok] <- validate_map(object) do
+    with {status, %{} = data} when status in [:modified, :ok] <-
+           MultiLanguage.validate_map(object) do
       {:ok, data}
     else
       {_, nil} -> {:ok, nil}
@@ -24,26 +24,4 @@ defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.ContentLanguageMap do
   def dump(data), do: {:ok, data}
 
   def load(data), do: {:ok, data}
-
-  defp validate_map(%{} = object) do
-    {status, data} =
-      object
-      |> Enum.reduce({:ok, %{}}, fn
-        {lang, value}, {status, acc} when is_binary(lang) and is_binary(value) ->
-          if good_locale_code?(lang) do
-            {status, Map.put(acc, lang, value)}
-          else
-            {:modified, acc}
-          end
-
-        _, {_status, acc} ->
-          {:modified, acc}
-      end)
-
-    if data == %{} do
-      {status, nil}
-    else
-      {status, data}
-    end
-  end
 end

lib/pleroma/ecto_type/activity_pub/object_validators/language_code.ex

@@ -5,10 +5,12 @@
 defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.LanguageCode do
   use Ecto.Type
 
+  alias Pleroma.MultiLanguage
+
   def type, do: :string
 
   def cast(language) when is_binary(language) do
-    if good_locale_code?(language) do
+    if MultiLanguage.good_locale_code?(language) do
       {:ok, language}
     else
       {:error, :invalid_language}
@@ -20,8 +22,4 @@ defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.LanguageCode do
   def dump(data), do: {:ok, data}
 
   def load(data), do: {:ok, data}
-
-  def good_locale_code?(code) when is_binary(code), do: code =~ ~r<^[a-zA-Z0-9\-]+$>
-
-  def good_locale_code?(_code), do: false
 end

lib/pleroma/emoji/formatter.ex

@@ -48,5 +48,9 @@ defmodule Pleroma.Emoji.Formatter do
     end)
   end
 
+  def get_emoji_map(%{} = map) do
+    Enum.reduce(map, %{}, fn {_, content}, acc -> Map.merge(acc, get_emoji_map(content)) end)
+  end
+
   def get_emoji_map(_), do: %{}
 end

lib/pleroma/multi_language.ex

@@ -0,0 +1,43 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.MultiLanguage do
+  def good_locale_code?(code) when is_binary(code), do: code =~ ~r<^[a-zA-Z0-9\-]+$>
+
+  def good_locale_code?(_code), do: false
+
+  def validate_map(%{} = object) do
+    {status, data} =
+      object
+      |> Enum.reduce({:ok, %{}}, fn
+        {lang, value}, {status, acc} when is_binary(lang) and is_binary(value) ->
+          if good_locale_code?(lang) do
+            {status, Map.put(acc, lang, value)}
+          else
+            {:modified, acc}
+          end
+
+        _, {_status, acc} ->
+          {:modified, acc}
+      end)
+
+    if data == %{} do
+      {status, nil}
+    else
+      {status, data}
+    end
+  end
+
+  def validate_map(_), do: {:error, nil}
+
+  def str_to_map(data, opts \\ []) do
+    with lang when is_binary(lang) <- opts[:lang],
+         true <- good_locale_code?(lang) do
+      %{lang => data}
+    else
+      _ ->
+        %{"und" => data}
+    end
+  end
+end

lib/pleroma/upload.ex

@@ -62,6 +62,7 @@ defmodule Pleroma.Upload do
           height: integer(),
           blurhash: String.t(),
           description: String.t(),
+          description_map: map(),
           path: String.t()
         }
   defstruct [
@@ -73,21 +74,44 @@ defmodule Pleroma.Upload do
     :height,
     :blurhash,
     :description,
+    :description_map,
     :path
   ]
 
   @config_impl Application.compile_env(:pleroma, [__MODULE__, :config_impl], Pleroma.Config)
 
   defp get_description(upload) do
-    case {upload.description, Pleroma.Config.get([Pleroma.Upload, :default_description])} do
-      {description, _} when is_binary(description) -> description
+    case {upload, Pleroma.Config.get([Pleroma.Upload, :default_description])} do
+      {%{description_map: %{} = description_map}, _} -> description_map
+      {%{description: description}, _} when is_binary(description) -> description
       {_, :filename} -> upload.name
       {_, str} when is_binary(str) -> str
       _ -> ""
     end
   end
 
-  @spec store(source, options :: [option()]) :: {:ok, map()} | {:error, any()}
+  defp validate_description_limit(%{} = description) do
+    Enum.all?(description, fn {_, content} ->
+      String.length(content) <= Pleroma.Config.get([:instance, :description_limit])
+    end)
+  end
+
+  defp validate_description_limit(description) when is_binary(description) do
+    String.length(description) <= Pleroma.Config.get([:instance, :description_limit])
+  end
+
+  defp description_fields(%{} = description, language) do
+    %{
+      "name" => Map.get(description, language),
+      "nameMap" => description
+    }
+  end
+
+  defp description_fields(description, _) when is_binary(description) do
+    %{"name" => description}
+  end
+
+  @spec store(source, options :: [option()]) :: {:ok, Map.t()} | {:error, any()}
   @doc "Store a file. If using a `Plug.Upload{}` as the source, be sure to use `Majic.Plug` to ensure its content_type and filename is correct."
   def store(upload, opts \\ []) do
     opts = get_opts(opts)
@@ -96,9 +120,10 @@ defmodule Pleroma.Upload do
          upload = %__MODULE__{upload | path: upload.path || "#{upload.id}/#{upload.name}"},
          {:ok, upload} <- Pleroma.Upload.Filter.filter(opts.filters, upload),
          description = get_description(upload),
+         {_, true} <- {:description_limit, validate_description_limit(description)},
          {_, true} <-
-           {:description_limit,
-            String.length(description) <= Pleroma.Config.get([:instance, :description_limit])},
+           {:valid_locale,
+            opts[:language] == nil or Pleroma.MultiLanguage.good_locale_code?(opts[:language])},
          {:ok, url_spec} <- Pleroma.Uploaders.Uploader.put_file(opts.uploader, upload) do
       {:ok,
        %{
@@ -113,10 +138,11 @@ defmodule Pleroma.Upload do
            }
            |> Maps.put_if_present("width", upload.width)
            |> Maps.put_if_present("height", upload.height)
-         ],
-         "name" => description
+         ]
        }
-       |> Maps.put_if_present("blurhash", upload.blurhash)}
+       |> Map.merge(description_fields(description, opts[:language]))
+       |> Maps.put_if_present("blurhash", upload.blurhash)
+       |> Maps.put_if_present("language", opts[:language])}
     else
       {:description_limit, _} ->
         {:error, :description_too_long}
@@ -156,6 +182,7 @@ defmodule Pleroma.Upload do
       uploader: Keyword.get(opts, :uploader, Pleroma.Config.get([__MODULE__, :uploader])),
       filters: Keyword.get(opts, :filters, Pleroma.Config.get([__MODULE__, :filters])),
       description: Keyword.get(opts, :description),
+      description_map: Keyword.get(opts, :description_map),
       base_url: base_url()
     }
   end
@@ -168,7 +195,8 @@ defmodule Pleroma.Upload do
          name: file.filename,
          tempfile: file.path,
          content_type: file.content_type,
-         description: opts.description
+         description: opts.description,
+         description_map: opts.description_map
        }}
     end
   end

lib/pleroma/web/activity_pub/activity_pub.ex

@@ -33,6 +33,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
   import Ecto.Query
   import Pleroma.Web.ActivityPub.Utils
   import Pleroma.Web.ActivityPub.Visibility
+  import Pleroma.Web.Gettext
   import Pleroma.Webhook.Notify, only: [trigger_webhooks: 2]
 
   require Logger
@@ -1592,12 +1593,37 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
     |> Enum.reverse()
   end
 
+  defp validate_media_description_map(%{} = map, language) do
+    with {:ok, %{}} <- Pleroma.MultiLanguage.validate_map(map),
+         true <- Pleroma.MultiLanguage.good_locale_code?(language) do
+      :ok
+    else
+      false -> :invalid_language
+      _ -> :error
+    end
+  end
+
+  defp validate_media_description_map(nil, _), do: :ok
+  defp validate_media_description_map(_, _), do: :error
+
   @spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} | {:error, any()}
   def upload(file, opts \\ []) do
-    with {:ok, data} <- Upload.store(sanitize_upload_file(file), opts) do
+    with {_, :ok} <-
+           {:description_map,
+            validate_media_description_map(opts[:description_map], opts[:language])},
+         {:ok, data} <- Upload.store(sanitize_upload_file(file), opts) do
       obj_data = Maps.put_if_present(data, "actor", opts[:actor])
 
       Repo.insert(%Object{data: obj_data})
+    else
+      {:description_map, :invalid_language} ->
+        {:error, dgettext("errors", "valid language must be provided with description_map")}
+
+      {:description_map, _} ->
+        {:error, dgettext("errors", "description_map invalid")}
+
+      e ->
+        e
     end
   end
 

lib/pleroma/web/activity_pub/builder.ex

@@ -216,19 +216,51 @@ defmodule Pleroma.Web.ActivityPub.Builder do
 
   @spec note(ActivityDraft.t()) :: {:ok, map(), keyword()}
   def note(%ActivityDraft{} = draft) do
+    content_fields =
+      if draft.content_html_map do
+        case Map.keys(draft.content_html_map) do
+          ["und"] ->
+            %{"content" => Map.get(draft.content_html_map, "und")}
+
+          _ ->
+            %{
+              "contentMap" => draft.content_html_map,
+              "content" => Map.get(draft.content_html_map, draft.language)
+            }
+        end
+      else
+        %{"content" => draft.content_html}
+      end
+
+    summary_fields =
+      if draft.summary_map do
+        case Map.keys(draft.summary_map) do
+          ["und"] ->
+            %{"summary" => Map.get(draft.summary_map, "und")}
+
+          _ ->
+            %{
+              "summaryMap" => draft.summary_map,
+              "summary" => Map.get(draft.summary_map, draft.language)
+            }
+        end
+      else
+        %{"summary" => draft.summary}
+      end
+
     data =
       %{
         "type" => "Note",
         "to" => draft.to,
         "cc" => draft.cc,
-        "content" => draft.content_html,
-        "summary" => draft.summary,
         "sensitive" => draft.sensitive,
         "context" => draft.context,
         "attachment" => draft.attachments,
         "actor" => draft.user.ap_id,
         "tag" => Keyword.values(draft.tags) |> Enum.uniq()
       }
+      |> Map.merge(content_fields)
+      |> Map.merge(summary_fields)
       |> add_in_reply_to(draft.in_reply_to)
       |> add_quote(draft.quote_post)
       |> Map.merge(draft.extra)

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

@@ -12,18 +12,41 @@ defmodule Pleroma.Web.ActivityPub.MRF.EnsureRePrepended do
 
   def history_awareness, do: :auto
 
+  def filter_by_summary(
+        %{data: %{"summaryMap" => %{} = parent_summary_map} = parent},
+        %{"summaryMap" => %{} = child_summary_map} = child
+      ) do
+    fixed_summary_map =
+      Enum.reduce(child_summary_map, %{}, fn {lang, cur}, acc ->
+        with {:ok, fixed_cur} <- fix_one(cur, parent_summary_map[lang]) do
+          Map.put(acc, lang, fixed_cur)
+        else
+          _ -> Map.put(acc, lang, cur)
+        end
+      end)
+
+    fixed_summary =
+      with {:ok, fixed} <- fix_one(child["summary"], parent["summary"]) do
+        fixed
+      else
+        _ -> child["summary"]
+      end
+
+    child
+    |> Map.put("summaryMap", fixed_summary_map)
+    |> Map.put("summary", fixed_summary)
+  end
+
   def filter_by_summary(
         %{data: %{"summary" => parent_summary}} = _in_reply_to,
         %{"summary" => child_summary} = child
       )
       when not is_nil(child_summary) and byte_size(child_summary) > 0 and
              not is_nil(parent_summary) and byte_size(parent_summary) > 0 do
-    if (child_summary == parent_summary and not Regex.match?(@reply_prefix, child_summary)) or
-         (Regex.match?(@reply_prefix, parent_summary) &&
-            Regex.replace(@reply_prefix, parent_summary, "") == child_summary) do
-      Map.put(child, "summary", "re: " <> child_summary)
+    with {:ok, fixed_child_summary} <- fix_one(child_summary, parent_summary) do
+      Map.put(child, "summary", fixed_child_summary)
     else
-      child
+      _ -> child
     end
   end
 
@@ -44,4 +67,20 @@ defmodule Pleroma.Web.ActivityPub.MRF.EnsureRePrepended do
   def filter(object), do: {:ok, object}
 
   def describe, do: {:ok, %{}}
+
+  defp fix_one(child_summary, parent_summary)
+       when is_binary(child_summary) and child_summary != "" and is_binary(parent_summary) and
+              parent_summary != "" do
+    if (child_summary == parent_summary and not Regex.match?(@reply_prefix, child_summary)) or
+         (Regex.match?(@reply_prefix, parent_summary) &&
+            Regex.replace(@reply_prefix, parent_summary, "") == child_summary) do
+      {:ok, "re: " <> child_summary}
+    else
+      {:nochange, nil}
+    end
+  end
+
+  defp fix_one(_, _) do
+    {:nochange, nil}
+  end
 end