No OneTemporary
Actions

Authored By

Unknown

Size

53 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/rich_media_backfill.change b/changelog.d/rich_media_backfill.change
	new file mode 100644
	index 000000000..d746ac8ce
	--- /dev/null
	+++ b/changelog.d/rich_media_backfill.change
	@@ -0,0 +1 @@
	+Rich Media backfilling is now an Oban job
	diff --git a/config/test.exs b/config/test.exs
	index 9afb2763a..1e8168548 100644
	--- a/config/test.exs
	+++ b/config/test.exs
	@@ -1,197 +1,195 @@
	import Config

	# We don't run a server during test. If one is required,
	# you can enable the server option below.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [port: 4001],
	url: [port: 4001],
	server: true

	# Disable captha for tests
	config :pleroma, Pleroma.Captcha,
	# It should not be enabled for automatic tests
	enabled: false,
	# A fake captcha service for tests
	method: Pleroma.Captcha.Mock

	# Print only warnings and errors during test
	config :logger, :console,
	level: :warning,
	format: "\n[$level] $message\n"

	config :pleroma, :auth, oauth_consumer_strategies: []

	config :pleroma, Pleroma.Upload,
	filters: [],
	link_name: false,
	default_description: :filename

	config :pleroma, Pleroma.Uploaders.Local, uploads: "test/uploads"

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Test, enabled: true

	config :pleroma, :instance,
	email: "admin@example.com",
	notify_email: "noreply@example.com",
	skip_thread_containment: false,
	federating: false,
	external_user_synchronization: false,
	static_dir: "test/instance_static/"

	config :pleroma, :activitypub, sign_object_fetches: false, follow_handshake_timeout: 0

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_test",
	hostname: System.get_env("DB_HOST") \|\| "localhost",
	port: System.get_env("DB_PORT") \|\| "5432",
	pool: Ecto.Adapters.SQL.Sandbox,
	pool_size: System.schedulers_online() * 2,
	log: false

	config :pleroma, :dangerzone, override_repo_pool_size: true

	# Reduce hash rounds for testing
	config :pleroma, :password, iterations: 1

	config :tesla, adapter: Tesla.Mock

	config :pleroma, :rich_media,
	enabled: false,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"],
	max_body: 2_000_000

	config :pleroma, :instance,
	multi_factor_authentication: [
	totp: [
	# digits 6 or 8
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 2,
	length: 6
	]
	]

	config :web_push_encryption, :vapid_details,
	subject: "mailto:administrator@example.com",
	public_key:
	"BLH1qVhJItRGCfxgTtONfsOKDc9VRAraXw-3NsmjMngWSh7NxOizN6bkuRA7iLTMPS82PjwJAr3UoK9EC1IFrz4",
	private_key: "_-XZ0iebPrRfZ_o0-IatTdszYa8VCH1yLN-JauK7HHA"

	config :pleroma, Oban, testing: :manual

	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 2,
	total_user_limit: 3,
	enabled: false

	config :pleroma, :rate_limit, %{}

	config :pleroma, :http_security, report_uri: "https://endpoint.com"

	config :pleroma, :http, send_user_agent: false

	rum_enabled = System.get_env("RUM_ENABLED") == "true"
	config :pleroma, :database, rum_enabled: rum_enabled
	IO.puts("RUM enabled: #{rum_enabled}")

	config :joken, default_signer: "yU8uHKq+yyAkZ11Hx//jcdacWc8yQ1bxAAGrplzB0Zwwjkp35v0RK9SO8WTPr6QZ"

	config :pleroma, Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.ClientMock

	config :pleroma, :modules, runtime_dir: "test/fixtures/modules"

	config :pleroma, Pleroma.Gun, Pleroma.GunMock

	config :pleroma, Pleroma.Emails.NewUsersDigestEmail, enabled: true

	config :pleroma, Pleroma.Web.Plugs.RemoteIp, enabled: false

	config :pleroma, Pleroma.Web.ApiSpec.CastAndValidate, strict: true

	config :tzdata, :autoupdate, :disabled

	config :pleroma, :mrf, policies: []

	config :pleroma, :pipeline,
	object_validator: Pleroma.Web.ActivityPub.ObjectValidatorMock,
	mrf: Pleroma.Web.ActivityPub.MRFMock,
	activity_pub: Pleroma.Web.ActivityPub.ActivityPubMock,
	side_effects: Pleroma.Web.ActivityPub.SideEffectsMock,
	federator: Pleroma.Web.FederatorMock,
	config: Pleroma.ConfigMock

	config :pleroma, :cachex, provider: Pleroma.CachexMock

	config :pleroma, Pleroma.Web.WebFinger, update_nickname_on_user_fetch: false

	config :pleroma, :side_effects,
	ap_streamer: Pleroma.Web.ActivityPub.ActivityPubMock,
	logger: Pleroma.LoggerMock

	config :pleroma, Pleroma.Search, module: Pleroma.Search.DatabaseSearch

	config :pleroma, Pleroma.Search.Meilisearch, url: "http://127.0.0.1:7700/", private_key: nil

	# Reduce recompilation time
	# https://dashbit.co/blog/speeding-up-re-compilation-of-elixir-projects
	config :phoenix, :plug_init_mode, :runtime

	config :pleroma, :config_impl, Pleroma.UnstubbedConfigMock

	config :pleroma, Pleroma.PromEx, disabled: true

	# Mox definitions. Only read during compile time.
	config :pleroma, Pleroma.User.Backup, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Uploaders.S3, ex_aws_impl: Pleroma.Uploaders.S3.ExAwsMock
	config :pleroma, Pleroma.Uploaders.S3, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Upload, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.ScheduledActivity, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Web.RichMedia.Helpers, config_impl: Pleroma.StaticStubbedConfigMock
	config :pleroma, Pleroma.Uploaders.IPFS, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Web.Plugs.HTTPSecurityPlug, config_impl: Pleroma.StaticStubbedConfigMock
	config :pleroma, Pleroma.Web.Plugs.HTTPSignaturePlug, config_impl: Pleroma.StaticStubbedConfigMock

	config :pleroma, Pleroma.Web.Plugs.HTTPSignaturePlug,
	http_signatures_impl: Pleroma.StubbedHTTPSignaturesMock

	peer_module =
	if String.to_integer(System.otp_release()) >= 25 do
	:peer
	else
	:slave
	end

	config :pleroma, Pleroma.Cluster, peer_module: peer_module

	config :pleroma, Pleroma.Application,
	background_migrators: false,
	internal_fetch: false,
	load_custom_modules: false,
	max_restarts: 100,
	streamer_registry: false,
	test_http_pools: true

	config :pleroma, Pleroma.Web.Streaming, sync_streaming: true

	-config :pleroma, Pleroma.Web.MastodonAPI.StatusView, sync_fetching: true
	-
	config :pleroma, Pleroma.Uploaders.Uploader, timeout: 1_000

	config :pleroma, Pleroma.Emoji.Loader, test_emoji: true

	config :pleroma, Pleroma.Web.RichMedia.Backfill, provider: Pleroma.Web.RichMedia.Backfill

	if File.exists?("./config/test.secret.exs") do
	import_config "test.secret.exs"
	else
	IO.puts(
	"You may want to create test.secret.exs to declare custom database connection parameters."
	)
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index 963658b1e..d9d7e516a 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,857 +1,850 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusView do
	use Pleroma.Web, :view

	require Pleroma.Constants

	alias Pleroma.Activity
	- alias Pleroma.Config
	alias Pleroma.HTML
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.PollView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.PleromaAPI.EmojiReactionController
	alias Pleroma.Web.RichMedia.Card

	import Pleroma.Web.ActivityPub.Visibility, only: [get_visibility: 1, visible_for_user?: 2]

	# This is a naive way to do this, just spawning a process per activity
	# to fetch the preview. However it should be fine considering
	# pagination is restricted to 40 activities at a time
	defp fetch_rich_media_for_activities(activities) do
	Enum.each(activities, fn activity ->
	- fun = fn -> Card.get_by_activity(activity) end
	-
	- if Config.get([__MODULE__, :sync_fetching], false) do
	- fun.()
	- else
	- spawn(fun)
	- end
	+ Card.get_by_activity(activity)
	end)
	end

	# TODO: Add cached version.
	defp get_replied_to_activities([]), do: %{}

	defp get_replied_to_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["inReplyTo"] != "" && object.data["inReplyTo"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	defp get_quoted_activities([]), do: %{}

	defp get_quoted_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["quoteUrl"] != "" && object.data["quoteUrl"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	# DEPRECATED This field seems to be a left-over from the StatusNet era.
	# If your application uses `pleroma.conversation_id`: this field is deprecated.
	# It is currently stubbed instead by doing a CRC32 of the context, and
	# clearing the MSB to avoid overflow exceptions with signed integers on the
	# different clients using this field (Java/Kotlin code, mostly; see Husky.)
	# This should be removed in a future version of Pleroma. Pleroma-FE currently
	# depends on this field, as well.
	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context) do
	import Bitwise

	:erlang.crc32(context)
	\|> band(bnot(0x8000_0000))
	end

	defp get_context_id(_), do: nil

	# Check if the user reblogged this status
	defp reblogged?(activity, %User{ap_id: ap_id}) do
	with %Object{data: %{"announcements" => announcements}} when is_list(announcements) <-
	Object.normalize(activity, fetch: false) do
	ap_id in announcements
	else
	_ -> false
	end
	end

	# False if the user is logged out
	defp reblogged?(_activity, _user), do: false

	def render("index.json", opts) do
	reading_user = opts[:for]

	# To do: check AdminAPIControllerTest on the reasons behind nil activities in the list
	activities = Enum.filter(opts.activities, & &1)

	# Start prefetching rich media before doing anything else
	fetch_rich_media_for_activities(activities)
	replied_to_activities = get_replied_to_activities(activities)
	quoted_activities = get_quoted_activities(activities)

	parent_activities =
	activities
	\|> Enum.filter(&(&1.data["type"] == "Announce" && &1.data["object"]))
	\|> Enum.map(&Object.normalize(&1, fetch: false).data["id"])
	\|> Activity.create_by_object_ap_id()
	\|> Activity.with_preloaded_object(:left)
	\|> Activity.with_preloaded_bookmark(reading_user)
	\|> Activity.with_set_thread_muted_field(reading_user)
	\|> Repo.all()

	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

	is_nil(reading_user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	# Note: unresolved users are filtered out
	actors =
	(activities ++ parent_activities)
	\|> Enum.map(&CommonAPI.get_user(&1.data["actor"], false))
	\|> Enum.filter(& &1)

	UserRelationship.view_relationships_option(reading_user, actors, subset: :source_mutes)
	end

	opts =
	opts
	\|> Map.put(:replied_to_activities, replied_to_activities)
	\|> Map.put(:quoted_activities, quoted_activities)
	\|> Map.put(:parent_activities, parent_activities)
	\|> Map.put(:relationships, relationships_opt)

	safe_render_many(activities, StatusView, "show.json", opts)
	end

	def render(
	"show.json",
	%{activity: %{data: %{"type" => "Announce", "object" => _object}} = activity} = opts
	) do
	user = CommonAPI.get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])
	object = Object.normalize(activity, fetch: false)

	reblogged_parent_activity =
	if opts[:parent_activities] do
	Activity.Queries.find_by_object_ap_id(
	opts[:parent_activities],
	object.data["id"]
	)
	else
	Activity.create_by_object_ap_id(object.data["id"])
	\|> Activity.with_preloaded_bookmark(opts[:for])
	\|> Activity.with_set_thread_muted_field(opts[:for])
	\|> Repo.one()
	end

	reblog_rendering_opts = Map.put(opts, :activity, reblogged_parent_activity)
	reblogged = render("show.json", reblog_rendering_opts)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmark = Activity.get_bookmark(reblogged_parent_activity, opts[:for])

	bookmark_folder =
	if bookmark != nil do
	bookmark.folder_id
	else
	nil
	end

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: object.data["id"],
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: reblogged,
	content: reblogged[:content] \|\| "",
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: reblogged?(reblogged_parent_activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmark),
	muted: false,
	pinned: pinned?,
	sensitive: false,
	spoiler_text: "",
	visibility: get_visibility(activity),
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: build_application(object.data["generator"]),
	language: nil,
	emojis: [],
	pleroma: %{
	local: activity.local,
	pinned_at: pinned_at,
	bookmark_folder: bookmark_folder
	}
	}
	end

	def render("show.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	user = CommonAPI.get_user(activity.data["actor"])
	user_follower_address = user.follower_address

	like_count = object.data["like_count"] \|\| 0
	announcement_count = object.data["announcement_count"] \|\| 0

	hashtags = Object.hashtags(object)
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	tags = Object.tags(object)

	tag_mentions =
	tags
	\|> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
	\|> Enum.map(fn tag -> tag["href"] end)

	mentions =
	(object.data["to"] ++ tag_mentions)
	\|> Enum.uniq()
	\|> Enum.map(fn
	Pleroma.Constants.as_public() -> nil
	^user_follower_address -> nil
	ap_id -> User.get_cached_by_ap_id(ap_id)
	end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmark = Activity.get_bookmark(activity, opts[:for])

	bookmark_folder =
	if bookmark != nil do
	bookmark.folder_id
	else
	nil
	end

	client_posted_this_activity = opts[:for] && user.id == opts[:for].id

	expires_at =
	with true <- client_posted_this_activity,
	%Oban.Job{scheduled_at: scheduled_at} <-
	Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id) do
	scheduled_at
	else
	_ -> nil
	end

	thread_muted? =
	cond do
	is_nil(opts[:for]) -> false
	is_boolean(activity.thread_muted?) -> activity.thread_muted?
	true -> CommonAPI.thread_muted?(opts[:for], activity)
	end

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["published"])

	edited_at =
	with %{"updated" => updated} <- object.data,
	date <- Utils.to_masto_date(updated),
	true <- date != "" do
	date
	else
	_ ->
	nil
	end

	reply_to = get_reply_to(activity, opts)
	reply_to_user = reply_to && CommonAPI.get_user(reply_to.data["actor"])

	history_len =
	1 +
	(Object.Updater.history_for(object.data)
	\|> Map.get("orderedItems")
	\|> length())

	# See render("history.json", ...) for more details
	# Here the implicit index of the current content is 0
	chrono_order = history_len - 1

	quote_activity = get_quote(activity, opts)

	quote_id =
	case quote_activity do
	%Activity{id: id} -> id
	_ -> nil
	end

	quote_post =
	if visible_for_user?(quote_activity, opts[:for]) and opts[:show_quote] != false do
	quote_rendering_opts = Map.merge(opts, %{activity: quote_activity, show_quote: false})
	render("show.json", quote_rendering_opts)
	else
	nil
	end

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	content_plaintext =
	content
	\|> Activity.HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	summary = object.data["summary"] \|\| ""

	card =
	case Card.get_by_activity(activity) do
	%Card{} = result -> render("card.json", result)
	_ -> nil
	end

	url =
	if user.local do
	Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	else
	object.data["url"] \|\| object.data["external_url"] \|\| object.data["id"]
	end

	direct_conversation_id =
	with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
	{_, true} <- {:include_id, opts[:with_direct_conversation_id]},
	{_, %User{} = for_user} <- {:for_user, opts[:for]} do
	Activity.direct_conversation_id(activity, for_user)
	else
	{:direct_conversation_id, participation_id} when is_integer(participation_id) ->
	participation_id

	_e ->
	nil
	end

	emoji_reactions =
	object
	\|> Object.get_emoji_reactions()
	\|> EmojiReactionController.filter_allowed_users(
	opts[:for],
	Map.get(opts, :with_muted, false)
	)
	\|> Stream.map(fn {emoji, users, url} ->
	build_emoji_map(emoji, users, url, opts[:for])
	end)
	\|> Enum.to_list()

	# Status muted state (would do 1 request per status unless user mutes are preloaded)
	muted =
	thread_muted? \|\|
	UserRelationship.exists?(
	get_in(opts, [:relationships, :user_relationships]),
	:mute,
	opts[:for],
	user,
	fn for_user, user -> User.mutes?(for_user, user) end
	)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: url,
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: reply_to && to_string(reply_to.id),
	in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
	reblog: nil,
	card: card,
	content: content_html,
	text: opts[:with_source] && get_source_text(object.data["source"]),
	created_at: created_at,
	edited_at: edited_at,
	reblogs_count: announcement_count,
	replies_count: object.data["repliesCount"] \|\| 0,
	favourites_count: like_count,
	reblogged: reblogged?(activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmark),
	muted: muted,
	pinned: pinned?,
	sensitive: sensitive,
	spoiler_text: summary,
	visibility: get_visibility(object),
	media_attachments: attachments,
	poll: render(PollView, "show.json", object: object, for: opts[:for]),
	mentions: mentions,
	tags: build_tags(tags),
	application: build_application(object.data["generator"]),
	language: nil,
	emojis: build_emojis(object.data["emoji"]),
	pleroma: %{
	local: activity.local,
	conversation_id: get_context_id(activity),
	context: object.data["context"],
	in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
	quote: quote_post,
	quote_id: quote_id,
	quote_url: object.data["quoteUrl"],
	quote_visible: visible_for_user?(quote_activity, opts[:for]),
	content: %{"text/plain" => content_plaintext},
	spoiler_text: %{"text/plain" => summary},
	expires_at: expires_at,
	direct_conversation_id: direct_conversation_id,
	thread_muted: thread_muted?,
	emoji_reactions: emoji_reactions,
	parent_visible: visible_for_user?(reply_to, opts[:for]),
	pinned_at: pinned_at,
	quotes_count: object.data["quotesCount"] \|\| 0,
	bookmark_folder: bookmark_folder
	}
	}
	end

	def render("show.json", _) do
	nil
	end

	def render("history.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	hashtags = Object.hashtags(object)

	user = CommonAPI.get_user(activity.data["actor"])

	past_history =
	Object.Updater.history_for(object.data)
	\|> Map.get("orderedItems")
	\|> Enum.map(&Map.put(&1, "id", object.data["id"]))
	\|> Enum.map(&%Object{data: &1, id: object.id})

	history =
	[object \| past_history]
	# Mastodon expects the original to be at the first
	\|> Enum.reverse()
	\|> Enum.with_index()
	\|> Enum.map(fn {object, chrono_order} ->
	%{
	# The history is prepended every time there is a new edit.
	# In chrono_order, the oldest item is always at 0, and so on.
	# The chrono_order is an invariant kept between edits.
	chrono_order: chrono_order,
	object: object
	}
	end)

	individual_opts =
	opts
	\|> Map.put(:as, :item)
	\|> Map.put(:user, user)
	\|> Map.put(:hashtags, hashtags)

	render_many(history, StatusView, "history_item.json", individual_opts)
	end

	def render(
	"history_item.json",
	%{
	activity: activity,
	user: user,
	item: %{object: object, chrono_order: chrono_order},
	hashtags: hashtags
	} = opts
	) do
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["updated"] \|\| object.data["published"])

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	summary = object.data["summary"] \|\| ""

	%{
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	content: content_html,
	sensitive: sensitive,
	spoiler_text: summary,
	created_at: created_at,
	media_attachments: attachments,
	emojis: build_emojis(object.data["emoji"]),
	poll: render(PollView, "show.json", object: object, for: opts[:for])
	}
	end

	def render("source.json", %{activity: %{data: %{"object" => _object}} = activity} = _opts) do
	object = Object.normalize(activity, fetch: false)

	%{
	id: activity.id,
	text: get_source_text(Map.get(object.data, "source", "")),
	spoiler_text: Map.get(object.data, "summary", ""),
	content_type: get_source_content_type(object.data["source"])
	}
	end

	def render("card.json", %Card{fields: rich_media}) do
	page_url_data = URI.parse(rich_media["url"])

	page_url = page_url_data \|> to_string

	image_url = proxied_url(rich_media["image"], page_url_data)
	audio_url = proxied_url(rich_media["audio"], page_url_data)
	video_url = proxied_url(rich_media["video"], page_url_data)

	%{
	type: "link",
	provider_name: page_url_data.host,
	provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
	url: page_url,
	image: image_url,
	image_description: rich_media["image:alt"] \|\| "",
	title: rich_media["title"] \|\| "",
	description: rich_media["description"] \|\| "",
	pleroma: %{
	opengraph:
	rich_media
	\|> Maps.put_if_present("image", image_url)
	\|> Maps.put_if_present("audio", audio_url)
	\|> Maps.put_if_present("video", video_url)
	}
	}
	end

	def render("card.json", _), do: nil

	def render("attachment.json", %{attachment: attachment}) do
	[attachment_url \| _] = attachment["url"]
	media_type = attachment_url["mediaType"] \|\| attachment_url["mimeType"] \|\| "image"
	href = attachment_url["href"] \|> MediaProxy.url()
	href_preview = attachment_url["href"] \|> MediaProxy.preview_url()
	meta = render("attachment_meta.json", %{attachment: attachment})

	type =
	cond do
	String.contains?(media_type, "image") -> "image"
	String.contains?(media_type, "video") -> "video"
	String.contains?(media_type, "audio") -> "audio"
	true -> "unknown"
	end

	attachment_id =
	with {_, ap_id} when is_binary(ap_id) <- {:ap_id, attachment["id"]},
	{_, %Object{data: _object_data, id: object_id}} <-
	{:object, Object.get_by_ap_id(ap_id)} do
	to_string(object_id)
	else
	_ ->
	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
	to_string(attachment["id"] \|\| hash_id)
	end

	description =
	if attachment["summary"] do
	HTML.strip_tags(attachment["summary"])
	else
	attachment["name"]
	end

	name = if attachment["summary"], do: attachment["name"]

	pleroma =
	%{mime_type: media_type}
	\|> Maps.put_if_present(:name, name)

	%{
	id: attachment_id,
	url: href,
	remote_url: href,
	preview_url: href_preview,
	text_url: href,
	type: type,
	description: description,
	pleroma: pleroma,
	blurhash: attachment["blurhash"]
	}
	\|> Maps.put_if_present(:meta, meta)
	end

	def render("attachment_meta.json", %{
	attachment: %{"url" => [%{"width" => width, "height" => height} \| _]}
	})
	when is_integer(width) and is_integer(height) do
	%{
	original: %{
	width: width,
	height: height,
	aspect: width / height
	}
	}
	end

	def render("attachment_meta.json", _), do: nil

	def render("context.json", %{activity: activity, activities: activities, user: user}) do
	%{ancestors: ancestors, descendants: descendants} =
	activities
	\|> Enum.reverse()
	\|> Enum.group_by(fn %{id: id} -> if id < activity.id, do: :ancestors, else: :descendants end)
	\|> Map.put_new(:ancestors, [])
	\|> Map.put_new(:descendants, [])

	%{
	ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
	descendants: render("index.json", for: user, activities: descendants, as: :activity)
	}
	end

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- replied_to_activities[object.data["inReplyTo"]] do
	# If user didn't participate in the thread
	Activity.get_in_reply_to_activity(activity)
	end
	end

	def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
	Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
	else
	nil
	end
	end

	def get_quote(activity, %{quoted_activities: quoted_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- quoted_activities[object.data["quoteUrl"]] do
	# For when a quote post is inside an Announce
	Activity.get_create_by_object_ap_id_with_object(object.data["quoteUrl"])
	end
	end

	def get_quote(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["quoteUrl"] && object.data["quoteUrl"] != "" do
	Activity.get_create_by_object_ap_id(object.data["quoteUrl"])
	else
	nil
	end
	end

	def render_content(%{data: %{"name" => name}} = object) when not is_nil(name) and name != "" do
	url = object.data["url"] \|\| object.data["id"]

	"<p><a href=\"#{url}\">#{name}</a></p>#{object.data["content"]}"
	end

	def render_content(object), do: object.data["content"] \|\| ""

	@doc """
	Builds a dictionary tags.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
	[{"name": "fediverse", "url": "/tag/fediverse"},
	{"name": "nextcloud", "url": "/tag/nextcloud"}]

	"""
	@spec build_tags(list(any())) :: list(map())
	def build_tags(object_tags) when is_list(object_tags) do
	object_tags
	\|> Enum.filter(&is_binary/1)
	\|> Enum.map(&%{name: &1, url: "#{Pleroma.Web.Endpoint.url()}/tag/#{URI.encode(&1)}"})
	end

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

	Arguments: `nil` or list tuple of name and url.

	Returns list emojis.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
	[%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]

	"""
	@spec build_emojis(nil \| list(tuple())) :: list(map())
	def build_emojis(nil), do: []

	def build_emojis(emojis) do
	emojis
	\|> Enum.map(fn {name, url} ->
	name = HTML.strip_tags(name)

	url =
	url
	\|> HTML.strip_tags()
	\|> MediaProxy.url()

	%{shortcode: name, url: url, static_url: url, visible_in_picker: false}
	end)
	end

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true

	defp pin_data(%Object{data: %{"id" => object_id}}, %User{pinned_objects: pinned_objects}) do
	if pinned_at = pinned_objects[object_id] do
	{true, Utils.to_masto_date(pinned_at)}
	else
	{false, nil}
	end
	end

	defp build_emoji_map(emoji, users, url, current_user) do
	%{
	name: Pleroma.Web.PleromaAPI.EmojiReactionView.emoji_name(emoji, url),
	count: length(users),
	url: MediaProxy.url(url),
	me: !!(current_user && current_user.ap_id in users),
	account_ids: Enum.map(users, fn user -> User.get_cached_by_ap_id(user).id end)
	}
	end

	@spec build_application(map() \| nil) :: map() \| nil
	defp build_application(%{"type" => _type, "name" => name, "url" => url}),
	do: %{name: name, website: url}

	defp build_application(_), do: nil

	# Workaround for Elixir issue #10771
	# Avoid applying URI.merge unless necessary
	# TODO: revert to always attempting URI.merge(image_url_data, page_url_data)
	# when Elixir 1.12 is the minimum supported version
	@spec build_image_url(struct() \| nil, struct()) :: String.t() \| nil
	defp build_image_url(
	%URI{scheme: image_scheme, host: image_host} = image_url_data,
	%URI{} = _page_url_data
	)
	when not is_nil(image_scheme) and not is_nil(image_host) do
	image_url_data \|> to_string
	end

	defp build_image_url(%URI{} = image_url_data, %URI{} = page_url_data) do
	URI.merge(page_url_data, image_url_data) \|> to_string
	end

	defp get_source_text(%{"content" => content} = _source) do
	content
	end

	defp get_source_text(source) when is_binary(source) do
	source
	end

	defp get_source_text(_) do
	""
	end

	defp get_source_content_type(%{"mediaType" => type} = _source) do
	type
	end

	defp get_source_content_type(_source) do
	Utils.get_content_type(nil)
	end

	defp proxied_url(url, page_url_data) do
	if is_binary(url) do
	build_image_url(URI.parse(url), page_url_data) \|> MediaProxy.url()
	else
	nil
	end
	end
	end
	diff --git a/lib/pleroma/web/rich_media/backfill.ex b/lib/pleroma/web/rich_media/backfill.ex
	index 46b879434..1d8cc87d4 100644
	--- a/lib/pleroma/web/rich_media/backfill.ex
	+++ b/lib/pleroma/web/rich_media/backfill.ex
	@@ -1,101 +1,74 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.Backfill do
	alias Pleroma.Web.RichMedia.Card
	alias Pleroma.Web.RichMedia.Parser
	alias Pleroma.Web.RichMedia.Parser.TTL
	alias Pleroma.Workers.RichMediaWorker

	require Logger

	- @backfiller Pleroma.Config.get([__MODULE__, :provider], Pleroma.Web.RichMedia.Backfill.Task)
	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	- @max_attempts 3
	- @retry 5_000

	- def start(%{url: url} = args) when is_binary(url) do
	+ @spec run(map()) ::
	+ :ok \| {:error, {:invalid_metadata, any()} \| :body_too_large \| {:content, any()} \| any()}
	+ def run(%{"url" => url} = args) do
	url_hash = Card.url_to_hash(url)

	- args =
	- args
	- \|> Map.put(:attempt, 1)
	- \|> Map.put(:url_hash, url_hash)
	-
	- @backfiller.run(args)
	- end
	-
	- def run(%{url: url, url_hash: url_hash, attempt: attempt} = args)
	- when attempt <= @max_attempts do
	case Parser.parse(url) do
	{:ok, fields} ->
	{:ok, card} = Card.create(url, fields)

	maybe_schedule_expiration(url, fields)

	- if Map.has_key?(args, :activity_id) do
	+ with %{"activity_id" => activity_id} <- args,
	+ false <- is_nil(activity_id) do
	stream_update(args)
	end

	warm_cache(url_hash, card)

	{:error, {:invalid_metadata, fields}} ->
	Logger.debug("Rich media incomplete or invalid metadata for #{url}: #{inspect(fields)}")
	negative_cache(url_hash)

	{:error, :body_too_large} ->
	Logger.error("Rich media error for #{url}: :body_too_large")
	negative_cache(url_hash)

	{:error, {:content_type, type}} ->
	Logger.debug("Rich media error for #{url}: :content_type is #{type}")
	negative_cache(url_hash)

	e ->
	Logger.debug("Rich media error for #{url}: #{inspect(e)}")
	-
	- :timer.sleep(@retry * attempt)
	-
	- run(%{args \| attempt: attempt + 1})
	+ {:error, e}
	end
	end

	- def run(%{url: url, url_hash: url_hash}) do
	- Logger.debug("Rich media failure for #{url}")
	-
	- negative_cache(url_hash, :timer.minutes(15))
	- end
	-
	defp maybe_schedule_expiration(url, fields) do
	case TTL.process(fields, url) do
	{:ok, ttl} when is_number(ttl) ->
	timestamp = DateTime.from_unix!(ttl)

	RichMediaWorker.new(%{"op" => "expire", "url" => url}, scheduled_at: timestamp)
	\|> Oban.insert()

	_ ->
	:ok
	end
	end

	- defp stream_update(%{activity_id: activity_id}) do
	+ defp stream_update(%{"activity_id" => activity_id}) do
	Pleroma.Activity.get_by_id(activity_id)
	\|> Pleroma.Activity.normalize()
	\|> Pleroma.Web.ActivityPub.ActivityPub.stream_out()
	end

	defp warm_cache(key, val), do: @cachex.put(:rich_media_cache, key, val)
	- defp negative_cache(key, ttl \\ nil), do: @cachex.put(:rich_media_cache, key, nil, ttl: ttl)
	-end

	-defmodule Pleroma.Web.RichMedia.Backfill.Task do
	- alias Pleroma.Web.RichMedia.Backfill
	-
	- def run(args) do
	- Task.Supervisor.start_child(Pleroma.TaskSupervisor, Backfill, :run, [args],
	- name: {:global, {:rich_media, args.url_hash}}
	- )
	- end
	+ defp negative_cache(key, ttl \\ :timer.minutes(15)),
	+ do: @cachex.put(:rich_media_cache, key, nil, ttl: ttl)
	end
	diff --git a/lib/pleroma/web/rich_media/card.ex b/lib/pleroma/web/rich_media/card.ex
	index 040066f36..72ff5e791 100644
	--- a/lib/pleroma/web/rich_media/card.ex
	+++ b/lib/pleroma/web/rich_media/card.ex
	@@ -1,162 +1,163 @@
	defmodule Pleroma.Web.RichMedia.Card do
	use Ecto.Schema
	import Ecto.Changeset
	import Ecto.Query

	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Repo
	- alias Pleroma.Web.RichMedia.Backfill
	alias Pleroma.Web.RichMedia.Parser
	+ alias Pleroma.Workers.RichMediaWorker

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	@config_impl Application.compile_env(:pleroma, [__MODULE__, :config_impl], Pleroma.Config)

	@type t :: %__MODULE__{}

	schema "rich_media_card" do
	field(:url_hash, :binary)
	field(:fields, :map)

	timestamps()
	end

	@doc false
	def changeset(card, attrs) do
	card
	\|> cast(attrs, [:url_hash, :fields])
	\|> validate_required([:url_hash, :fields])
	\|> unique_constraint(:url_hash)
	end

	@spec create(String.t(), map()) :: {:ok, t()}
	def create(url, fields) do
	url_hash = url_to_hash(url)

	fields = Map.put_new(fields, "url", url)

	%__MODULE__{}
	\|> changeset(%{url_hash: url_hash, fields: fields})
	\|> Repo.insert(on_conflict: {:replace, [:fields]}, conflict_target: :url_hash)
	end

	@spec delete(String.t()) :: {:ok, Ecto.Schema.t()} \| {:error, Ecto.Changeset.t()} \| :ok
	def delete(url) do
	url_hash = url_to_hash(url)
	@cachex.del(:rich_media_cache, url_hash)

	case get_by_url(url) do
	%__MODULE__{} = card -> Repo.delete(card)
	nil -> :ok
	end
	end

	@spec get_by_url(String.t() \| nil) :: t() \| nil \| :error
	def get_by_url(url) when is_binary(url) do
	if @config_impl.get([:rich_media, :enabled]) do
	url_hash = url_to_hash(url)

	@cachex.fetch!(:rich_media_cache, url_hash, fn _ ->
	result =
	__MODULE__
	\|> where(url_hash: ^url_hash)
	\|> Repo.one()

	case result do
	%__MODULE__{} = card -> {:commit, card}
	_ -> {:ignore, nil}
	end
	end)
	else
	:error
	end
	end

	def get_by_url(nil), do: nil

	- @spec get_or_backfill_by_url(String.t(), map()) :: t() \| nil
	- def get_or_backfill_by_url(url, backfill_opts \\ %{}) do
	+ @spec get_or_backfill_by_url(String.t(), keyword()) :: t() \| nil
	+ def get_or_backfill_by_url(url, opts \\ []) do
	if @config_impl.get([:rich_media, :enabled]) do
	case get_by_url(url) do
	%__MODULE__{} = card ->
	card

	nil ->
	- backfill_opts = Map.put(backfill_opts, :url, url)
	+ activity_id = Keyword.get(opts, :activity, nil)

	- Backfill.start(backfill_opts)
	+ RichMediaWorker.new(%{"op" => "backfill", "url" => url, "activity_id" => activity_id})
	+ \|> Oban.insert()

	nil

	:error ->
	nil
	end
	else
	nil
	end
	end

	@spec get_by_object(Object.t()) :: t() \| nil \| :error
	def get_by_object(object) do
	case HTML.extract_first_external_url_from_object(object) do
	nil -> nil
	url -> get_or_backfill_by_url(url)
	end
	end

	@spec get_by_activity(Activity.t()) :: t() \| nil \| :error
	# Fake/Draft activity
	def get_by_activity(%Activity{id: "pleroma:fakeid"} = activity) do
	with {_, true} <- {:config, @config_impl.get([:rich_media, :enabled])},
	%Object{} = object <- Object.normalize(activity, fetch: false),
	url when not is_nil(url) <- HTML.extract_first_external_url_from_object(object) do
	case get_by_url(url) do
	# Cache hit
	%__MODULE__{} = card ->
	card

	# Cache miss, but fetch for rendering the Draft
	_ ->
	with {:ok, fields} <- Parser.parse(url),
	{:ok, card} <- create(url, fields) do
	card
	else
	_ -> nil
	end
	end
	else
	_ ->
	nil
	end
	end

	def get_by_activity(activity) do
	with %Object{} = object <- Object.normalize(activity, fetch: false),
	{_, nil} <- {:cached, get_cached_url(object, activity.id)} do
	nil
	else
	{:cached, url} ->
	- get_or_backfill_by_url(url, %{activity_id: activity.id})
	+ get_or_backfill_by_url(url, activity_id: activity.id)

	_ ->
	:error
	end
	end

	@spec url_to_hash(String.t()) :: String.t()
	def url_to_hash(url) do
	:crypto.hash(:sha256, url) \|> Base.encode16(case: :lower)
	end

	defp get_cached_url(object, activity_id) do
	key = "URL\|#{activity_id}"

	@cachex.fetch!(:scrubber_cache, key, fn _ ->
	url = HTML.extract_first_external_url_from_object(object)
	Activity.HTML.add_cache_key_for(activity_id, key)

	{:commit, url}
	end)
	end
	end
	diff --git a/lib/pleroma/workers/rich_media_worker.ex b/lib/pleroma/workers/rich_media_worker.ex
	index 968395c64..f18ac658a 100644
	--- a/lib/pleroma/workers/rich_media_worker.ex
	+++ b/lib/pleroma/workers/rich_media_worker.ex
	@@ -1,15 +1,19 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.RichMediaWorker do
	+ alias Pleroma.Web.RichMedia.Backfill
	alias Pleroma.Web.RichMedia.Card

	- use Oban.Worker,
	- queue: :background
	+ use Oban.Worker, queue: :background, max_attempts: 3, unique: [period: 300]

	@impl Oban.Worker
	def perform(%Job{args: %{"op" => "expire", "url" => url} = _args}) do
	Card.delete(url)
	end
	+
	+ def perform(%Job{args: %{"op" => "backfill", "url" => _url} = args}) do
	+ Backfill.run(args)
	+ end
	end
	diff --git a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	index f17add774..c78c03aba 100644
	--- a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	+++ b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	@@ -1,87 +1,90 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ChatMessageReferenceViewTest do
	alias Pleroma.NullCache
	use Pleroma.DataCase, async: true

	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Object
	+ alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView

	import Mox
	import Pleroma.Factory

	setup do: clear_config([:rich_media, :enabled], true)

	test "it displays a chat message" do
	user = insert(:user)
	recipient = insert(:user)

	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, upload} = ActivityPub.upload(file, actor: recipient.ap_id)

	{:ok, activity} =
	CommonAPI.post_chat_message(user, recipient, "kippis :firefox:", idempotency_key: "123")

	chat = Chat.get(user.id, recipient.ap_id)

	object = Object.normalize(activity, fetch: false)

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	id = cm_ref.id

	Pleroma.CachexMock
	\|> stub(:get, fn
	:chat_message_id_idempotency_key_cache, ^id -> {:ok, "123"}
	cache, key -> NullCache.get(cache, key)
	end)
	\|> stub(:fetch, fn :rich_media_cache, _, _ -> {:ok, {:ok, %{}}} end)

	chat_message = MessageReferenceView.render("show.json", chat_message_reference: cm_ref)

	assert chat_message[:id] == cm_ref.id
	assert chat_message[:content] == "kippis :firefox:"
	assert chat_message[:account_id] == user.id
	assert chat_message[:chat_id]
	assert chat_message[:created_at]
	assert chat_message[:unread] == false
	assert match?([%{shortcode: "firefox"}], chat_message[:emojis])
	assert chat_message[:idempotency_key] == "123"

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

	{:ok, activity} =
	CommonAPI.post_chat_message(recipient, user, "gkgkgk https://example.com/ogp",
	media_id: upload.id
	)

	+ ObanHelpers.perform_all()
	+
	object = Object.normalize(activity, fetch: false)

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	chat_message_two = MessageReferenceView.render("show.json", chat_message_reference: cm_ref)

	assert chat_message_two[:id] == cm_ref.id
	assert chat_message_two[:content] == object.data["content"]
	assert chat_message_two[:account_id] == recipient.id
	assert chat_message_two[:chat_id] == chat_message[:chat_id]
	assert chat_message_two[:attachment]
	assert chat_message_two[:unread] == true
	assert chat_message_two[:card]
	end
	end
	diff --git a/test/pleroma/web/rich_media/card_test.exs b/test/pleroma/web/rich_media/card_test.exs
	index 516ac9951..c76df99e2 100644
	--- a/test/pleroma/web/rich_media/card_test.exs
	+++ b/test/pleroma/web/rich_media/card_test.exs
	@@ -1,71 +1,76 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2024 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.CardTest do
	use Pleroma.DataCase, async: true

	+ alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.RichMedia.Card

	import Mox
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	:ok
	end

	setup do: clear_config([:rich_media, :enabled], true)

	test "crawls URL in activity" do
	user = insert(:user)

	url = "https://example.com/ogp"
	url_hash = Card.url_to_hash(url)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "[test](#{url})",
	content_type: "text/markdown"
	})

	+ ObanHelpers.perform_all()
	+
	assert %Card{url_hash: ^url_hash, fields: _} = Card.get_by_activity(activity)
	end

	test "recrawls URLs on status edits/updates" do
	original_url = "https://google.com/"
	original_url_hash = Card.url_to_hash(original_url)
	updated_url = "https://yahoo.com/"
	updated_url_hash = Card.url_to_hash(updated_url)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "I like this site #{original_url}"})

	# Force a backfill
	Card.get_by_activity(activity)
	+ ObanHelpers.perform_all()

	assert match?(
	%Card{url_hash: ^original_url_hash, fields: _},
	Card.get_by_activity(activity)
	)

	{:ok, _} = CommonAPI.update(user, activity, %{status: "I like this site #{updated_url}"})

	activity = Pleroma.Activity.get_by_id(activity.id)

	# Force a backfill
	Card.get_by_activity(activity)
	+ ObanHelpers.perform_all()

	assert match?(
	%Card{url_hash: ^updated_url_hash, fields: _},
	Card.get_by_activity(activity)
	)
	end
	end
	diff --git a/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs b/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs
	index 8fd9e6a5f..e02dd437a 100644
	--- a/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs
	+++ b/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs
	@@ -1,108 +1,116 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrlTest do
	use Pleroma.DataCase, async: false
	- use Oban.Testing, repo: Pleroma.Repo
	+ use Oban.Testing, repo: Pleroma.Repo, testing: :inline

	import Mox

	+ alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.RichMedia.Card
	alias Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl

	setup do
	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	clear_config([:rich_media, :enabled], true)

	:ok
	end

	test "s3 signed url is parsed correct for expiration time" do
	url = "https://pleroma.social/amz"

	{:ok, timestamp} =
	Timex.now()
	\|> DateTime.truncate(:second)
	\|> Timex.format("{ISO:Basic:Z}")

	# in seconds
	valid_till = 30

	metadata = construct_metadata(timestamp, valid_till, url)

	expire_time =
	Timex.parse!(timestamp, "{ISO:Basic:Z}") \|> Timex.to_unix() \|> Kernel.+(valid_till)

	assert expire_time == Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl.ttl(metadata, url)
	end

	test "s3 signed url is parsed and correct ttl is set for rich media" do
	url = "https://pleroma.social/amz"

	{:ok, timestamp} =
	Timex.now()
	\|> DateTime.truncate(:second)
	\|> Timex.format("{ISO:Basic:Z}")

	# in seconds
	valid_till = 30

	metadata = construct_metadata(timestamp, valid_till, url)

	body = """
	<meta name="twitter:card" content="Pleroma" />
	<meta name="twitter:site" content="Pleroma" />
	<meta name="twitter:title" content="Pleroma" />
	<meta name="twitter:description" content="Pleroma" />
	<meta name="twitter:image" content="#{Map.get(metadata, "image")}" />
	"""

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^url
	} ->
	%Tesla.Env{status: 200, body: body}

	%{method: :head} ->
	%Tesla.Env{status: 200}
	end)

	Card.get_or_backfill_by_url(url)

	- assert_enqueued(
	- worker: Pleroma.Workers.RichMediaWorker,
	- args: %{"op" => "expire", "url" => url}
	- )
	+ # Find the backfill job
	+ expected_job =
	+ [
	+ worker: "Pleroma.Workers.RichMediaWorker",
	+ args: %{"op" => "backfill", "url" => url}
	+ ]

	- [%Oban.Job{scheduled_at: scheduled_at}] = all_enqueued()
	+ assert_enqueued(expected_job)
	+
	+ # Run it manually
	+ ObanHelpers.perform_all()
	+
	+ [%Oban.Job{scheduled_at: scheduled_at} \| _] = all_enqueued()

	timestamp_dt = Timex.parse!(timestamp, "{ISO:Basic:Z}")

	assert DateTime.diff(scheduled_at, timestamp_dt) == valid_till
	end

	test "AWS URL for an image without expiration works" do
	og_data = %{"image" => "https://amazonaws.com/image.png"}

	assert is_nil(AwsSignedUrl.ttl(og_data, ""))
	end

	defp construct_s3_url(timestamp, valid_till) do
	"https://pleroma.s3.ap-southeast-1.amazonaws.com/sachin%20%281%29%20_a%20-%25%2Aasdasd%20BNN%20bnnn%20.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIBLWWK6RGDQXDLJQ%2F20190716%2Fap-southeast-1%2Fs3%2Faws4_request&X-Amz-Date=#{timestamp}&X-Amz-Expires=#{valid_till}&X-Amz-Signature=04ffd6b98634f4b1bbabc62e0fac4879093cd54a6eed24fe8eb38e8369526bbf&X-Amz-SignedHeaders=host"
	end

	defp construct_metadata(timestamp, valid_till, url) do
	%{
	"image" => construct_s3_url(timestamp, valid_till),
	"site" => "Pleroma",
	"title" => "Pleroma",
	"description" => "Pleroma",
	"url" => url
	}
	end
	end
	diff --git a/test/pleroma/web/rich_media/parser/ttl/opengraph_test.exs b/test/pleroma/web/rich_media/parser/ttl/opengraph_test.exs
	index e275ee523..6805e786d 100644
	--- a/test/pleroma/web/rich_media/parser/ttl/opengraph_test.exs
	+++ b/test/pleroma/web/rich_media/parser/ttl/opengraph_test.exs
	@@ -1,44 +1,57 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2024 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.Parser.TTL.OpengraphTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	import Mox

	+ alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.RichMedia.Card

	setup do
	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	clear_config([:rich_media, :enabled], true)

	:ok
	end

	test "OpenGraph TTL value is honored" do
	url = "https://reddit.com/r/somepost"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^url
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/reddit.html")}

	%{method: :head} ->
	%Tesla.Env{status: 200}
	end)

	Card.get_or_backfill_by_url(url)

	+ # Find the backfill job
	+ expected_job =
	+ [
	+ worker: "Pleroma.Workers.RichMediaWorker",
	+ args: %{"op" => "backfill", "url" => url}
	+ ]
	+
	+ assert_enqueued(expected_job)
	+
	+ # Run it manually
	+ ObanHelpers.perform_all()
	+
	assert_enqueued(
	worker: Pleroma.Workers.RichMediaWorker,
	args: %{"op" => "expire", "url" => url}
	)
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 4:22 AM (1 d, 2 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799429
Default Alt Text: (53 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions