defmodule Mobilizon.Service.Export.Feed do @moduledoc """ Serve Atom Syndication Feeds. """ import Mobilizon.Web.Gettext alias Atomex.{Entry, Feed} alias Mobilizon.Actors.Actor alias Mobilizon.Config alias Mobilizon.Events.Event alias Mobilizon.Posts.Post alias Mobilizon.Service.Export.{Cachable, Common} alias Mobilizon.Users.User alias Mobilizon.Web.Endpoint use Mobilizon.Web, :verified_routes require Logger @behaviour Cachable @item_limit 5000 @spec version :: String.t() defp version, do: Config.instance_version() @impl Cachable @spec create_cache(String.t()) :: {:commit, String.t()} | {:ignore, :actor_not_found | :actor_not_public | :bad_token | :token_not_found} def create_cache("actor_" <> name) do case fetch_actor_event_feed(name) do {:ok, res} -> {:commit, res} {:error, err} -> {:ignore, err} end end @impl Cachable def create_cache("token_" <> token) do case fetch_events_from_token(token) do {:ok, res} -> {:commit, res} {:error, err} -> {:ignore, err} end end @impl Cachable def create_cache("instance") do {:ok, res} = fetch_instance_feed() {:commit, res} end @spec fetch_instance_feed :: {:ok, String.t()} defp fetch_instance_feed do {:ok, events, posts} = Common.fetch_instance_public_content(@item_limit) {:ok, build_instance_feed(events, posts)} end # Build an atom feed from the whole instance and its public events and posts @spec build_instance_feed(list(), list()) :: String.t() defp build_instance_feed(events, posts) do self_url = Endpoint.url() title = gettext("Public feed for %{instance}", instance: Config.instance_name() ) # Title uses default instance language self_url |> Feed.new( DateTime.utc_now(), title ) |> Feed.link(self_url, rel: "self") |> Feed.link(self_url, rel: "alternate") |> Feed.generator(Config.instance_name(), uri: Endpoint.url(), version: version()) |> Feed.entries(Enum.map(events ++ posts, &get_entry/1)) |> Feed.build() |> Atomex.generate_document() end @spec fetch_actor_event_feed(String.t(), integer()) :: {:ok, String.t()} | {:error, :actor_not_found | :actor_not_public} defp fetch_actor_event_feed(name, limit \\ @item_limit) do case Common.fetch_actor_event_feed(name, limit) do {:ok, actor, events, posts} -> {:ok, build_actor_feed(actor, events, posts)} {:error, err} -> {:error, err} end end # Build an atom feed from actor and its public events and posts @spec build_actor_feed(Actor.t(), list(Event.t()), list(Post.t()), boolean()) :: String.t() defp build_actor_feed(%Actor{} = actor, events, posts, public \\ true) do display_name = Actor.display_name(actor) self_url = ~p"/@#{actor.preferred_username}/feed/atom" |> url() |> URI.decode() title = if public, do: gettext("%{actor}'s public events feed on %{instance}", actor: display_name, instance: Config.instance_name() ), else: gettext("%{actor}'s private events feed on %{instance}", actor: display_name, instance: Config.instance_name() ) # Title uses default instance language feed = self_url |> Feed.new( DateTime.utc_now(), title ) |> Feed.author(display_name, uri: actor.url) |> Feed.link(self_url, rel: "self") |> Feed.link(actor.url, rel: "alternate") |> Feed.generator(Config.instance_name(), uri: Endpoint.url(), version: version()) |> Feed.entries(Enum.map(events ++ posts, &get_entry/1)) feed = if actor.avatar do feed |> Feed.icon(actor.avatar.url) else feed end feed = if actor.banner do feed |> Feed.logo(actor.banner.url) else feed end feed |> Feed.build() |> Atomex.generate_document() end # Create an entry for the Atom feed @spec get_entry(Event.t()) :: any() defp get_entry(%Event{} = event) do description = event.description || "" entry = event.url |> Entry.new(event.publish_at || event.inserted_at, event.title) |> Entry.link(event.url, rel: "alternate", type: "text/html") |> Entry.content({:cdata, description}, type: "html") |> Entry.published(event.publish_at || event.inserted_at) # Add tags entry = event.tags |> Enum.uniq() |> Enum.reduce(entry, fn tag, acc -> Entry.category(acc, tag.slug, label: tag.title) end) Entry.build(entry) end @spec get_entry(Post.t()) :: any() defp get_entry(%Post{} = post) do body = post.body || "" entry = post.url |> Entry.new(post.publish_at || post.inserted_at, post.title) |> Entry.link(post.url, rel: "alternate", type: "text/html") |> Entry.content({:cdata, body}, type: "html") |> Entry.published(post.publish_at || post.inserted_at) |> Entry.author(post.author.name || post.author.preferred_username) # Add tags entry = post.tags |> Enum.uniq() |> Enum.reduce(entry, fn tag, acc -> Entry.category(acc, tag.slug, label: tag.title) end) Entry.build(entry) end # Only events, not posts @spec fetch_events_from_token(String.t(), integer()) :: {:ok, String.t()} | {:error, :bad_token | :token_not_found} defp fetch_events_from_token(token, limit \\ @item_limit) do case Common.fetch_events_from_token(token, limit) do %{events: events, token: token, user: user, actor: actor, type: type} -> case type do :user -> {:ok, build_user_feed(events, user, token)} :actor -> {:ok, build_actor_feed(actor, events, [], false)} end {:error, err} -> {:error, err} end end # Build an atom feed from actor and its public events @spec build_user_feed(list(Event.t()), User.t(), String.t()) :: String.t() defp build_user_feed(events, %User{email: email}, token) do self_url = ~p"/events/going/#{token}/format" |> url() |> URI.decode() # Title uses default instance language self_url |> Feed.new( DateTime.utc_now(), gettext("Feed for %{email} on %{instance}", email: email, instance: Config.instance_name() ) ) |> Feed.link(self_url, rel: "self") |> Feed.generator(Config.instance_name(), uri: Endpoint.url(), version: version()) |> Feed.entries(Enum.map(events, &get_entry/1)) |> Feed.build() |> Atomex.generate_document() end @impl Cachable def clear_caches(%Event{attributed_to: %Actor{} = actor} = event) do clear_actor_feed(actor) clear_caches(%{event | attributed_to: nil}) end @impl Cachable def clear_caches(%Event{}) do # TODO: It would be nice to clear feed token cache based on participations as well, # but that's harder, as it would require loading all participations clear_instance() end @impl Cachable def clear_caches(%Post{attributed_to: %Actor{} = actor} = post) do clear_actor_feed(actor) clear_caches(%{post | attributed_to: nil}) end @impl Cachable def clear_caches(%Post{}) do clear_instance() end @impl Cachable def clear_caches(%Actor{} = actor) do clear_actor_feed(actor) clear_instance() end defp clear_instance do Cachex.del(:feed, "instance") end defp clear_actor_feed(%Actor{preferred_username: preferred_username} = actor) do if Actor.public_visibility?(actor) do Cachex.del(:feed, "actor_#{preferred_username}") end end end