No OneTemporary
Actions

Authored By

Unknown

Size

36 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/formatter.ex b/lib/pleroma/formatter.ex
	index 575bf9b2d..fc841a550 100644
	--- a/lib/pleroma/formatter.ex
	+++ b/lib/pleroma/formatter.ex
	@@ -1,167 +1,167 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Formatter do
	alias Pleroma.HTML
	alias Pleroma.User

	@safe_mention_regex ~r/^(\s(?<mentions>(@.+?\s+){1,})+)(?<rest>.)/s
	@link_regex ~r"((?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~%:/?#[\]@!\$&'\\+,;=.]+)\|[0-9a-z+\-\.]+:[0-9a-z$-_.+!'(),]+"ui
	@markdown_characters_regex ~r/(`\|\*\|_\|{\|}\|[\|]\|$\|$\|#\|\+\|-\|\.\|!)/

	defp linkify_opts do
	Pleroma.Config.get(Pleroma.Formatter) ++
	[
	hashtag: true,
	hashtag_handler: &Pleroma.Formatter.hashtag_handler/4,
	mention: true,
	mention_handler: &Pleroma.Formatter.mention_handler/4
	]
	end

	def escape_mention_handler("@" <> nickname = mention, buffer, _, _) do
	case User.get_cached_by_nickname(nickname) do
	%User{} ->
	# escape markdown characters with `\\`
	# (we don't want something like @user__name to be parsed by markdown)
	String.replace(mention, @markdown_characters_regex, "\\\\\\1")

	_ ->
	buffer
	end
	end

	def mention_tag(%User{id: id} = user, nickname, opts \\ []) do
	user_url = user.uri \|\| user.ap_id
	nickname_text = get_nickname_text(nickname, opts)

	:span
	\|> Phoenix.HTML.Tag.content_tag(
	Phoenix.HTML.Tag.content_tag(
	:a,
	["@", Phoenix.HTML.Tag.content_tag(:span, nickname_text)],
	"data-user": id,
	class: "u-url mention",
	href: user_url,
	rel: "ugc"
	),
	class: "h-card"
	)
	\|> Phoenix.HTML.safe_to_string()
	end

	def mention_handler("@" <> nickname, buffer, opts, acc) do
	case User.get_cached_by_nickname(nickname) do
	%User{id: _id} = user ->
	link = mention_tag(user, nickname, opts)

	{link, %{acc \| mentions: MapSet.put(acc.mentions, {"@" <> nickname, user})}}

	_ ->
	{buffer, acc}
	end
	end

	def hashtag_handler("#" <> tag = tag_text, _buffer, _opts, acc) do
	tag = String.downcase(tag)
	url = "#{Pleroma.Web.Endpoint.url()}/tag/#{tag}"

	link =
	Phoenix.HTML.Tag.content_tag(:a, tag_text,
	class: "hashtag",
	"data-tag": tag,
	href: url,
	rel: "tag ugc"
	)
	\|> Phoenix.HTML.safe_to_string()

	{link, %{acc \| tags: MapSet.put(acc.tags, {tag_text, tag})}}
	end

	@doc """
	Parses a text and replace plain text links with HTML. Returns a tuple with a result text, mentions, and hashtags.

	If the 'safe_mention' option is given, only consecutive mentions at the start the post are actually mentioned.
	"""
	@spec linkify(String.t(), keyword()) ::
	{String.t(), [{String.t(), User.t()}], [{String.t(), String.t()}]}
	def linkify(text, options \\ []) do
	options = linkify_opts() ++ options

	if options[:safe_mention] && Regex.named_captures(@safe_mention_regex, text) do
	%{"mentions" => mentions, "rest" => rest} = Regex.named_captures(@safe_mention_regex, text)
	acc = %{mentions: MapSet.new(), tags: MapSet.new()}

	{text_mentions, %{mentions: mentions}} = Linkify.link_map(mentions, acc, options)
	{text_rest, %{tags: tags}} = Linkify.link_map(rest, acc, options)

	{text_mentions <> text_rest, MapSet.to_list(mentions), MapSet.to_list(tags)}
	else
	acc = %{mentions: MapSet.new(), tags: MapSet.new()}
	{text, %{mentions: mentions, tags: tags}} = Linkify.link_map(text, acc, options)

	{text, MapSet.to_list(mentions), MapSet.to_list(tags)}
	end
	end

	@doc """
	Escapes a special characters in mention names.
	"""
	def mentions_escape(text, options \\ []) do
	options =
	Keyword.merge(options,
	mention: true,
	url: false,
	mention_handler: &Pleroma.Formatter.escape_mention_handler/4
	)

	if options[:safe_mention] && Regex.named_captures(@safe_mention_regex, text) do
	%{"mentions" => mentions, "rest" => rest} = Regex.named_captures(@safe_mention_regex, text)
	Linkify.link(mentions, options) <> Linkify.link(rest, options)
	else
	Linkify.link(text, options)
	end
	end

	- def markdown_to_html(text) do
	- Earmark.as_html!(text, %Earmark.Options{compact_output: true})
	+ def markdown_to_html(text, opts \\ %{}) do
	+ Earmark.as_html!(text, %Earmark.Options{compact_output: true} \|> Map.merge(opts))
	end

	def html_escape({text, mentions, hashtags}, type) do
	{html_escape(text, type), mentions, hashtags}
	end

	def html_escape(text, "text/html") do
	HTML.filter_tags(text)
	end

	def html_escape(text, "text/x.misskeymarkdown") do
	text
	\|> HTML.filter_tags()
	end

	def html_escape(text, "text/plain") do
	Regex.split(@link_regex, text, include_captures: true)
	\|> Enum.map_every(2, fn chunk ->
	{:safe, part} = Phoenix.HTML.html_escape(chunk)
	part
	end)
	\|> Enum.join("")
	end

	def truncate(text, max_length \\ 200, omission \\ "...") do
	# Remove trailing whitespace
	text = Regex.replace(~r/([^ \t\r\n])([ \t]+$)/u, text, "\\g{1}")

	if String.length(text) < max_length do
	text
	else
	length_with_omission = max_length - String.length(omission)
	String.slice(text, 0, length_with_omission) <> omission
	end
	end

	defp get_nickname_text(nickname, %{mentions_format: :full}), do: User.full_nickname(nickname)
	defp get_nickname_text(nickname, _), do: User.local_nickname(nickname)
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex b/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex
	index 09b68c977..d4beed78d 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex
	@@ -1,198 +1,200 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.ArticleNotePageValidator do
	use Ecto.Schema
	alias Pleroma.User
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	require Logger

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	quote do
	unquote do
	import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	message_fields()
	object_fields()
	status_object_fields()
	end
	end

	field(:replies, {:array, ObjectValidators.ObjectID}, default: [])
	field(:source, :map)
	field(:contentMap, :map)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp fix_url(%{"url" => url} = data) when is_bitstring(url), do: data
	defp fix_url(%{"url" => url} = data) when is_map(url), do: Map.put(data, "url", url["href"])
	defp fix_url(data), do: data

	defp fix_tag(%{"tag" => tag} = data) when is_list(tag) do
	Map.put(data, "tag", Enum.filter(tag, &is_map/1))
	end

	defp fix_tag(%{"tag" => tag} = data) when is_map(tag), do: Map.put(data, "tag", [tag])
	defp fix_tag(data), do: Map.drop(data, ["tag"])

	defp fix_replies(%{"replies" => replies} = data) when is_list(replies), do: data

	defp fix_replies(%{"replies" => %{"first" => first}} = data) do
	with {:ok, replies} <- Akkoma.Collections.Fetcher.fetch_collection(first) do
	Map.put(data, "replies", replies)
	else
	{:error, _} ->
	Logger.error("Could not fetch replies for #{first}")
	Map.put(data, "replies", [])
	end
	end

	defp fix_replies(%{"replies" => %{"items" => replies}} = data) when is_list(replies),
	do: Map.put(data, "replies", replies)

	defp fix_replies(data), do: Map.delete(data, "replies")

	defp remote_mention_resolver(
	%{"id" => ap_id, "tag" => tags},
	"@" <> nickname = mention,
	buffer,
	opts,
	acc
	) do
	initial_host =
	ap_id
	\|> URI.parse()
	\|> Map.get(:host)

	with mention_tag <-
	Enum.find(tags, fn t ->
	t["type"] == "Mention" &&
	(t["name"] == mention \|\| mention == "#{t["name"]}@#{initial_host}")
	end),
	false <- is_nil(mention_tag),
	{:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(mention_tag["href"]) do
	link = Pleroma.Formatter.mention_tag(user, nickname, opts)
	{link, %{acc \| mentions: MapSet.put(acc.mentions, {"@" <> nickname, user})}}
	else
	_ -> {buffer, acc}
	end
	end

	- # https://github.com/misskey-dev/misskey/pull/8787
	- # Misskey has an awful tendency to drop all custom formatting when it sends remotely
	- # So this basically reprocesses their MFM source
	+ # See https://akkoma.dev/FoundKeyGang/FoundKey/issues/343
	+ # Misskey/Foundkey drops some of the custom formatting when it sends remotely
	+ # So this basically reprocesses the MFM source
	defp fix_misskey_content(
	%{"source" => %{"mediaType" => "text/x.misskeymarkdown", "content" => content}} = object
	)
	when is_binary(content) do
	mention_handler = fn nick, buffer, opts, acc ->
	remote_mention_resolver(object, nick, buffer, opts, acc)
	end

	{linked, _, _} =
	Utils.format_input(content, "text/x.misskeymarkdown", mention_handler: mention_handler)

	Map.put(object, "content", linked)
	end

	+ # See https://github.com/misskey-dev/misskey/pull/8787
	+ # This is for compatibility with older Misskey instances
	defp fix_misskey_content(%{"_misskey_content" => content} = object) when is_binary(content) do
	mention_handler = fn nick, buffer, opts, acc ->
	remote_mention_resolver(object, nick, buffer, opts, acc)
	end

	{linked, _, _} =
	Utils.format_input(content, "text/x.misskeymarkdown", mention_handler: mention_handler)

	object
	\|> Map.put("source", %{
	"content" => content,
	"mediaType" => "text/x.misskeymarkdown"
	})
	\|> Map.put("content", linked)
	\|> Map.delete("_misskey_content")
	end

	defp fix_misskey_content(data), do: data

	defp fix_source(%{"source" => source} = object) when is_binary(source) do
	object
	\|> Map.put("source", %{"content" => source})
	end

	defp fix_source(object), do: object

	defp fix_content_map_languages(%{"contentMap" => content_map} = object)
	when is_map(content_map) do
	# Only allow valid languages
	content_map =
	content_map
	\|> Enum.reject(fn {lang, _content} ->
	!Pleroma.ISO639.valid_alpha2?(lang)
	end)
	\|> Enum.into(%{})

	Map.put(object, "contentMap", content_map)
	end

	defp fix_content_map_languages(object), do: object

	defp fix(data) do
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_object_defaults()
	\|> fix_url()
	\|> fix_tag()
	\|> fix_replies()
	\|> fix_source()
	\|> fix_misskey_content()
	\|> Transmogrifier.fix_attachments()
	\|> Transmogrifier.fix_emoji()
	\|> Transmogrifier.fix_content_map()
	\|> fix_content_map_languages()
	end

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, __schema__(:fields) -- [:attachment, :tag])
	\|> cast_embed(:attachment)
	\|> cast_embed(:tag)
	end

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Article", "Note", "Page"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index 345c5d10d..54918d13c 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,486 +1,486 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.Utils do
	import Pleroma.Web.Gettext

	alias Calendar.Strftime
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI.ActivityDraft
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.Utils.Params

	require Logger
	require Pleroma.Constants

	def attachments_from_ids(%{media_ids: ids, descriptions: desc}) do
	attachments_from_ids_descs(ids, desc)
	end

	def attachments_from_ids(%{media_ids: ids}) do
	attachments_from_ids_no_descs(ids)
	end

	def attachments_from_ids(_), do: []

	def attachments_from_ids_no_descs([]), do: []

	def attachments_from_ids_no_descs(ids) do
	Enum.map(ids, fn media_id ->
	case get_attachment(media_id) do
	%Object{data: data} -> data
	_ -> nil
	end
	end)
	\|> Enum.reject(&is_nil/1)
	end

	def attachments_from_ids_descs([], _), do: []

	def attachments_from_ids_descs(ids, descs_str) do
	{_, descs} = Jason.decode(descs_str)

	Enum.map(ids, fn media_id ->
	with %Object{data: data} <- get_attachment(media_id) do
	Map.put(data, "name", descs[media_id])
	end
	end)
	\|> Enum.reject(&is_nil/1)
	end

	defp get_attachment(media_id) do
	Repo.get(Object, media_id)
	end

	@spec get_to_and_cc(ActivityDraft.t()) :: {list(String.t()), list(String.t())}

	def get_to_and_cc(%{in_reply_to_conversation: %Participation{} = participation}) do
	participation = Repo.preload(participation, :recipients)
	{Enum.map(participation.recipients, & &1.ap_id), []}
	end

	def get_to_and_cc(%{visibility: visibility} = draft) when visibility in ["public", "local"] do
	to =
	case visibility do
	"public" -> [Pleroma.Constants.as_public() \| draft.mentions]
	"local" -> [Utils.as_local_public() \| draft.mentions]
	end

	cc = [draft.user.follower_address]

	if draft.in_reply_to do
	{Enum.uniq([draft.in_reply_to.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def get_to_and_cc(%{visibility: "unlisted"} = draft) do
	to = [draft.user.follower_address \| draft.mentions]
	cc = [Pleroma.Constants.as_public()]

	if draft.in_reply_to do
	{Enum.uniq([draft.in_reply_to.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def get_to_and_cc(%{visibility: "private"} = draft) do
	{to, cc} = get_to_and_cc(struct(draft, visibility: "direct"))
	{[draft.user.follower_address \| to], cc}
	end

	def get_to_and_cc(%{visibility: "direct"} = draft) do
	# If the OP is a DM already, add the implicit actor.
	if draft.in_reply_to && Visibility.is_direct?(draft.in_reply_to) do
	{Enum.uniq([draft.in_reply_to.data["actor"] \| draft.mentions]), []}
	else
	{draft.mentions, []}
	end
	end

	def get_to_and_cc(%{visibility: {:list, _}, mentions: mentions}), do: {mentions, []}

	def get_addressed_users(_, to) when is_list(to) do
	User.get_ap_ids_by_nicknames(to)
	end

	def get_addressed_users(mentioned_users, _), do: mentioned_users

	def maybe_add_list_data(activity_params, user, {:list, list_id}) do
	case Pleroma.List.get(list_id, user) do
	%Pleroma.List{} = list ->
	activity_params
	\|> put_in([:additional, "bcc"], [list.ap_id])
	\|> put_in([:additional, "listMessage"], list.ap_id)
	\|> put_in([:object, "listMessage"], list.ap_id)

	_ ->
	activity_params
	end
	end

	def maybe_add_list_data(activity_params, _, _), do: activity_params

	def make_poll_data(%{"poll" => %{"expires_in" => expires_in}} = data)
	when is_binary(expires_in) do
	# In some cases mastofe sends out strings instead of integers
	data
	\|> put_in(["poll", "expires_in"], String.to_integer(expires_in))
	\|> make_poll_data()
	end

	def make_poll_data(%{poll: %{options: options, expires_in: expires_in}} = data)
	when is_list(options) do
	limits = Config.get([:instance, :poll_limits])

	with :ok <- validate_poll_expiration(expires_in, limits),
	:ok <- validate_poll_options_amount(options, limits),
	:ok <- validate_poll_options_length(options, limits) do
	{option_notes, emoji} =
	Enum.map_reduce(options, %{}, fn option, emoji ->
	note = %{
	"name" => option,
	"type" => "Note",
	"replies" => %{"type" => "Collection", "totalItems" => 0}
	}

	{note, Map.merge(emoji, Pleroma.Emoji.Formatter.get_emoji_map(option))}
	end)

	end_time =
	DateTime.utc_now()
	\|> DateTime.add(expires_in)
	\|> DateTime.to_iso8601()

	key = if Params.truthy_param?(data.poll[:multiple]), do: "anyOf", else: "oneOf"
	poll = %{"type" => "Question", key => option_notes, "closed" => end_time}

	{:ok, {poll, emoji}}
	end
	end

	def make_poll_data(%{"poll" => poll}) when is_map(poll) do
	{:error, "Invalid poll"}
	end

	def make_poll_data(_data) do
	{:ok, {%{}, %{}}}
	end

	defp validate_poll_options_amount(options, %{max_options: max_options}) do
	if Enum.count(options) > max_options do
	{:error, "Poll can't contain more than #{max_options} options"}
	else
	:ok
	end
	end

	defp validate_poll_options_length(options, %{max_option_chars: max_option_chars}) do
	if Enum.any?(options, &(String.length(&1) > max_option_chars)) do
	{:error, "Poll options cannot be longer than #{max_option_chars} characters each"}
	else
	:ok
	end
	end

	defp validate_poll_expiration(expires_in, %{min_expiration: min, max_expiration: max}) do
	cond do
	expires_in > max -> {:error, "Expiration date is too far in the future"}
	expires_in < min -> {:error, "Expiration date is too soon"}
	true -> :ok
	end
	end

	def make_content_html(%ActivityDraft{} = draft) do
	attachment_links =
	draft.params
	\|> Map.get("attachment_links", Config.get([:instance, :attachment_links]))
	\|> Params.truthy_param?()

	content_type = get_content_type(draft.params[:content_type])

	options =
	if draft.visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
	[safe_mention: true]
	else
	[]
	end

	draft.status
	\|> format_input(content_type, options)
	\|> maybe_add_attachments(draft.attachments, attachment_links)
	end

	def get_content_type(content_type) do
	if Enum.member?(Config.get([:instance, :allowed_post_formats]), content_type) do
	content_type
	else
	"text/plain"
	end
	end

	def make_context(%{in_reply_to_conversation: %Participation{} = participation}) do
	Repo.preload(participation, :conversation).conversation.ap_id
	end

	def make_context(%{in_reply_to: %Activity{data: %{"context" => context}}}), do: context
	def make_context(%{quote: %Activity{data: %{"context" => context}}}), do: context
	def make_context(_), do: Utils.generate_context_id()

	def maybe_add_attachments(parsed, _attachments, false = _no_links), do: parsed

	def maybe_add_attachments({text, mentions, tags}, attachments, _no_links) do
	text = add_attachments(text, attachments)
	{text, mentions, tags}
	end

	def add_attachments(text, attachments) do
	attachment_text = Enum.map(attachments, &build_attachment_link/1)
	Enum.join([text \| attachment_text], "<br>")
	end

	defp build_attachment_link(%{"url" => [%{"href" => href} \| _]} = attachment) do
	name = attachment["name"] \|\| URI.decode(Path.basename(href))
	href = MediaProxy.url(href)
	"<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"
	end

	defp build_attachment_link(_), do: ""

	def format_input(text, format, options \\ [])

	@doc """
	Formatting text to plain text, BBCode, HTML, or Markdown
	"""
	def format_input(text, "text/plain", options) do
	text
	\|> Formatter.html_escape("text/plain")
	\|> Formatter.linkify(options)
	\|> (fn {text, mentions, tags} ->
	{String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
	end).()
	end

	def format_input(text, "text/bbcode", options) do
	text
	\|> String.replace(~r/\r/, "")
	\|> Formatter.html_escape("text/plain")
	\|> BBCode.to_html()
	\|> (fn {:ok, html} -> html end).()
	\|> Formatter.linkify(options)
	end

	def format_input(text, "text/html", options) do
	text
	\|> Formatter.html_escape("text/html")
	\|> Formatter.linkify(options)
	end

	def format_input(text, "text/x.misskeymarkdown", options) do
	text
	- \|> Formatter.markdown_to_html()
	+ \|> Formatter.markdown_to_html(%{breaks: true})
	\|> MfmParser.Parser.parse()
	\|> MfmParser.Encoder.to_html()
	\|> Formatter.linkify(options)
	\|> Formatter.html_escape("text/html")
	end

	def format_input(text, "text/markdown", options) do
	text
	\|> Formatter.mentions_escape(options)
	\|> Formatter.markdown_to_html()
	\|> Formatter.linkify(options)
	\|> Formatter.html_escape("text/html")
	end

	def format_naive_asctime(date) do
	date \|> DateTime.from_naive!("Etc/UTC") \|> format_asctime
	end

	def format_asctime(date) do
	Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
	end

	def date_to_asctime(date) when is_binary(date) do
	with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
	format_asctime(date)
	else
	_e ->
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end
	end

	def date_to_asctime(date) do
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end

	def to_masto_date(%NaiveDateTime{} = date) do
	# NOTE: Elixir’s ISO 8601 format is a superset of the real standard
	# It supports negative years for example.
	# ISO8601 only supports years before 1583 with mutual agreement
	if date.year < 1583 do
	"1970-01-01T00:00:00Z"
	else
	date
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	end
	end

	def to_masto_date(date) when is_binary(date) do
	with {:ok, date} <- NaiveDateTime.from_iso8601(date) do
	to_masto_date(date)
	else
	_ -> "1970-01-01T00:00:00Z"
	end
	end

	def to_masto_date(_), do: "1970-01-01T00:00:00Z"

	defp shortname(name) do
	with max_length when max_length > 0 <-
	Config.get([Pleroma.Upload, :filename_display_max_length], 30),
	true <- String.length(name) > max_length do
	String.slice(name, 0..max_length) <> "…"
	else
	_ -> name
	end
	end

	@spec confirm_current_password(User.t(), String.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def confirm_current_password(user, password) do
	with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
	true <- Pleroma.Password.checkpw(password, db_user.password_hash) do
	{:ok, db_user}
	else
	_ -> {:error, dgettext("errors", "Invalid password.")}
	end
	end

	def maybe_notify_to_recipients(
	recipients,
	%Activity{data: %{"to" => to, "type" => _type}} = _activity
	) do
	recipients ++ to
	end

	def maybe_notify_to_recipients(recipients, _), do: recipients

	def maybe_notify_mentioned_recipients(
	recipients,
	%Activity{data: %{"to" => _to, "type" => type} = data} = activity
	)
	when type == "Create" do
	object = Object.normalize(activity, fetch: false)

	object_data =
	cond do
	not is_nil(object) ->
	object.data

	is_map(data["object"]) ->
	data["object"]

	true ->
	%{}
	end

	tagged_mentions = maybe_extract_mentions(object_data)

	recipients ++ tagged_mentions
	end

	def maybe_notify_mentioned_recipients(recipients, _), do: recipients

	def maybe_notify_subscribers(
	recipients,
	%Activity{data: %{"actor" => actor, "type" => "Create"}} = activity
	) do
	# Do not notify subscribers if author is making a reply
	with %Object{data: object} <- Object.normalize(activity, fetch: false),
	nil <- object["inReplyTo"],
	%User{} = user <- User.get_cached_by_ap_id(actor) do
	subscriber_ids =
	user
	\|> User.subscriber_users()
	\|> Enum.filter(&Visibility.visible_for_user?(activity, &1))
	\|> Enum.map(& &1.ap_id)

	recipients ++ subscriber_ids
	else
	_e -> recipients
	end
	end

	def maybe_notify_subscribers(recipients, _), do: recipients

	def maybe_notify_followers(recipients, %Activity{data: %{"type" => "Move"}} = activity) do
	with %User{} = user <- User.get_cached_by_ap_id(activity.actor) do
	user
	\|> User.get_followers()
	\|> Enum.map(& &1.ap_id)
	\|> Enum.concat(recipients)
	else
	_e -> recipients
	end
	end

	def maybe_notify_followers(recipients, _), do: recipients

	def maybe_extract_mentions(%{"tag" => tag}) do
	tag
	\|> Enum.filter(fn x -> is_map(x) && x["type"] == "Mention" end)
	\|> Enum.map(fn x -> x["href"] end)
	\|> Enum.uniq()
	end

	def maybe_extract_mentions(_), do: []

	def make_report_content_html(nil), do: {:ok, {nil, [], []}}

	def make_report_content_html(comment) do
	max_size = Config.get([:instance, :max_report_comment_size], 1000)

	if String.length(comment) <= max_size do
	{:ok, format_input(comment, "text/plain")}
	else
	{:error,
	dgettext("errors", "Comment must be up to %{max_size} characters", max_size: max_size)}
	end
	end

	def get_report_statuses(%User{ap_id: actor}, %{status_ids: status_ids})
	when is_list(status_ids) do
	{:ok, Activity.all_by_actor_and_id(actor, status_ids)}
	end

	def get_report_statuses(_, _), do: {:ok, nil}

	def validate_character_limit("" = _full_payload, [] = _attachments) do
	{:error, dgettext("errors", "Cannot post an empty status without attachments")}
	end

	def validate_character_limit(full_payload, _attachments) do
	limit = Config.get([:instance, :limit])
	length = String.length(full_payload)

	if length <= limit do
	:ok
	else
	{:error, dgettext("errors", "The status is over the character limit")}
	end
	end
	end
	diff --git a/test/fixtures/misskey/mfm_x_format.json b/test/fixtures/misskey/mfm_x_format.json
	index 590e399fe..ecbbddadd 100644
	--- a/test/fixtures/misskey/mfm_x_format.json
	+++ b/test/fixtures/misskey/mfm_x_format.json
	@@ -1,44 +1,44 @@
	{
	"id": "https://misskey.local.live/notes/92j1n3owja",
	"type": "Note",
	"attributedTo": "https://misskey.local.live/users/92hzkskwgy",
	"summary": null,
	"content": "this does not get replaced",
	"source": {
	- "content": "@akkoma_user @remote_user @full_tag_remote_user@misskey.local.live @oops_not_a_mention linkifylink #dancedance $[jelly mfm goes here] \n\n## aaa",
	+ "content": "@akkoma_user @remote_user @full_tag_remote_user@misskey.local.live @oops_not_a_mention linkifylink #dancedance $[jelly mfm goes here] \n\n## aaa\n\nsome text\nnewline",
	"mediaType": "text/x.misskeymarkdown"
	},
	"published": "2022-07-10T15:37:36.368Z",
	"to": [
	"https://www.w3.org/ns/activitystreams#Public"
	],
	"cc": [
	"https://misskey.local.live/users/92hzkskwgy/followers",
	"http://localhost:4001/users/akkoma_user"
	],
	"inReplyTo": null,
	"attachment": [],
	"sensitive": false,
	"tag": [
	{
	"type": "Hashtag",
	"href": "https://misskey.local.live/tags/dancedance",
	"name": "#dancedance"
	},
	{
	"type": "Mention",
	"href": "http://localhost:4001/users/akkoma_user",
	"name": "@akkoma_user"
	},
	{
	"type": "Mention",
	"href": "http://misskey.local.live/users/remote_user",
	"name": "@remote_user"
	},
	{
	"type": "Mention",
	"href": "http://misskey.local.live/users/full_tag_remote_user",
	"name": "@full_tag_remote_user"
	}
	]
	}
	diff --git a/test/pleroma/web/activity_pub/object_validators/article_note_page_validator_test.exs b/test/pleroma/web/activity_pub/object_validators/article_note_page_validator_test.exs
	index 62ac5e051..523a17c17 100644
	--- a/test/pleroma/web/activity_pub/object_validators/article_note_page_validator_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/article_note_page_validator_test.exs
	@@ -1,225 +1,227 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.ArticleNotePageValidatorTest do
	use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ArticleNotePageValidator
	alias Pleroma.Web.ActivityPub.Utils

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	:ok
	end

	describe "Notes" do
	setup do
	user = insert(:user)

	note = %{
	"id" => Utils.generate_activity_id(),
	"type" => "Note",
	"actor" => user.ap_id,
	"to" => [user.follower_address],
	"cc" => [],
	"content" => "Hellow this is content.",
	"context" => "xxx",
	"summary" => "a post"
	}

	%{user: user, note: note}
	end

	test "a basic note validates", %{note: note} do
	%{valid?: true} = ArticleNotePageValidator.cast_and_validate(note)
	end

	test "a note with a language validates" do
	insert(:user, %{ap_id: "https://mastodon.social/users/akkoma_ap_integration_tester"})
	note = File.read!("test/fixtures/mastodon/note_with_language.json") \|> Jason.decode!()

	%{
	valid?: true,
	changes: %{
	contentMap: %{
	"ja" => "<p>tag</p>"
	}
	}
	} = ArticleNotePageValidator.cast_and_validate(note)
	end

	test "a note from factory validates" do
	note = insert(:note)
	%{valid?: true} = ArticleNotePageValidator.cast_and_validate(note.data)
	end

	test "a note with a remote replies collection should validate", _ do
	insert(:user, %{ap_id: "https://bookwyrm.com/user/TestUser"})
	collection = File.read!("test/fixtures/bookwyrm-replies-collection.json")

	Tesla.Mock.mock(fn %{
	method: :get,
	url: "https://bookwyrm.com/user/TestUser/review/17/replies?page=1"
	} ->
	%Tesla.Env{
	status: 200,
	body: collection,
	headers: HttpRequestMock.activitypub_object_headers()
	}
	end)

	note = Jason.decode!(File.read!("test/fixtures/bookwyrm-article.json"))

	%{valid?: true, changes: %{replies: ["https://bookwyrm.com/user/TestUser/status/18"]}} =
	ArticleNotePageValidator.cast_and_validate(note)
	end

	test "a note with an attachment should work", _ do
	insert(:user, %{ap_id: "https://owncast.localhost.localdomain/federation/user/streamer"})

	note =
	"test/fixtures/owncast-note-with-attachment.json"
	\|> File.read!()
	\|> Jason.decode!()

	%{valid?: true} = ArticleNotePageValidator.cast_and_validate(note)
	end

	test "a misskey MFM status with a content field should work and be linked", _ do
	local_user =
	insert(:user, %{nickname: "akkoma_user", ap_id: "http://localhost:4001/users/akkoma_user"})

	remote_user =
	insert(:user, %{
	nickname: "remote_user",
	ap_id: "http://misskey.local.live/users/remote_user"
	})

	full_tag_remote_user =
	insert(:user, %{
	nickname: "full_tag_remote_user",
	ap_id: "http://misskey.local.live/users/full_tag_remote_user"
	})

	insert(:user, %{ap_id: "https://misskey.local.live/users/92hzkskwgy"})

	note =
	"test/fixtures/misskey/mfm_x_format.json"
	\|> File.read!()
	\|> Jason.decode!()

	%{
	valid?: true,
	changes: %{
	content: content,
	source: %{
	"mediaType" => "text/x.misskeymarkdown"
	}
	}
	} = ArticleNotePageValidator.cast_and_validate(note)

	assert content =~
	"<span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{local_user.id}\" href=\"#{local_user.ap_id}\" rel=\"ugc\">@<span>akkoma_user</span></a></span>"

	assert content =~
	"<span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{remote_user.id}\" href=\"#{remote_user.ap_id}\" rel=\"ugc\">@<span>remote_user</span></a></span>"

	assert content =~
	"<span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{full_tag_remote_user.id}\" href=\"#{full_tag_remote_user.ap_id}\" rel=\"ugc\">@<span>full_tag_remote_user</span></a></span>"

	assert content =~ "@oops_not_a_mention"

	assert content =~
	"<span class=\"mfm _mfm_jelly_\" style=\"display: inline-block; animation: 1s linear 0s infinite normal both running mfm-rubberBand;\">mfm goes here</span> </p>aaa"
	+
	+ assert content =~ "some text<br/>newline"
	end

	test "a misskey MFM status with a _misskey_content field should work and be linked", _ do
	local_user =
	insert(:user, %{nickname: "akkoma_user", ap_id: "http://localhost:4001/users/akkoma_user"})

	insert(:user, %{ap_id: "https://misskey.local.live/users/92hzkskwgy"})

	note =
	"test/fixtures/misskey/mfm_underscore_format.json"
	\|> File.read!()
	\|> Jason.decode!()

	changes = ArticleNotePageValidator.cast_and_validate(note)

	%{
	valid?: true,
	changes: %{
	content: content,
	source: %{
	"mediaType" => "text/x.misskeymarkdown",
	"content" => "@akkoma_user linkifylink #dancedance $[jelly mfm goes here] \n\n## aaa"
	}
	}
	} = changes

	assert content =~
	"<span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{local_user.id}\" href=\"#{local_user.ap_id}\" rel=\"ugc\">@<span>akkoma_user</span></a></span>"
	end
	end

	test "a Note without replies/first/items validates" do
	insert(:user, ap_id: "https://mastodon.social/users/emelie")

	note =
	"test/fixtures/tesla_mock/status.emelie.json"
	\|> File.read!()
	\|> Jason.decode!()
	\|> pop_in(["replies", "first", "items"])
	\|> elem(1)

	%{valid?: true} = ArticleNotePageValidator.cast_and_validate(note)
	end

	describe "Note with history" do
	setup do
	user = insert(:user)
	{:ok, activity} = Pleroma.Web.CommonAPI.post(user, %{status: "mew mew :dinosaur:"})
	{:ok, edit} = Pleroma.Web.CommonAPI.update(user, activity, %{status: "edited :blank:"})

	{:ok, %{"object" => external_rep}} =
	Pleroma.Web.ActivityPub.Transmogrifier.prepare_outgoing(edit.data)

	%{external_rep: external_rep}
	end

	test "edited note", %{external_rep: external_rep} do
	assert %{"formerRepresentations" => %{"orderedItems" => [%{"tag" => [_]}]}} = external_rep

	{:ok, validate_res, []} = ObjectValidator.validate(external_rep, [])

	assert %{"formerRepresentations" => %{"orderedItems" => [%{"emoji" => %{"dinosaur" => _}}]}} =
	validate_res
	end

	test "edited note, badly-formed formerRepresentations", %{external_rep: external_rep} do
	external_rep = Map.put(external_rep, "formerRepresentations", %{})

	assert {:error, _} = ObjectValidator.validate(external_rep, [])
	end

	test "edited note, badly-formed history item", %{external_rep: external_rep} do
	history_item =
	Enum.at(external_rep["formerRepresentations"]["orderedItems"], 0)
	\|> Map.put("type", "Foo")

	external_rep =
	put_in(
	external_rep,
	["formerRepresentations", "orderedItems"],
	[history_item]
	)

	assert {:error, _} = ObjectValidator.validate(external_rep, [])
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 10:25 AM (20 h, 38 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1797961
Default Alt Text: (36 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions