Add cached RSS feeds for actors endpoints

lib/mobilizon/actors/actor.ex

@@ -354,6 +354,9 @@ defmodule Mobilizon.Actors.Actor do
     end
   end
 
+  @doc """
+  Return the preferred_username with the eventual @domain suffix if it's a distant actor
+  """
   @spec actor_acct_from_actor(struct()) :: String.t()
   def actor_acct_from_actor(%Actor{preferred_username: preferred_username, domain: domain}) do
     if is_nil(domain) do
@@ -362,4 +365,16 @@ defmodule Mobilizon.Actors.Actor do
       "#{preferred_username}@#{domain}"
     end
   end
+
+  @doc """
+  Returns the display name if available, or the preferred_username (with the eventual @domain suffix if it's a distant actor).
+  """
+  @spec display_name(struct()) :: String.t()
+  def display_name(%Actor{name: name} = actor) do
+    case name do
+      nil -> actor_acct_from_actor(actor)
+      "" -> actor_acct_from_actor(actor)
+      name -> name
+    end
+  end
 end

lib/mobilizon/actors/actors.ex

@@ -612,67 +612,9 @@ defmodule Mobilizon.Actors do
     with {:ok, %User{} = user} <-
            %User{} |> User.registration_changeset(args) |> Mobilizon.Repo.insert() do
       {:ok, user}
-      # else
-      #   {:error, %Ecto.Changeset{} = changeset} ->
-      #     {:error, Ecto.Changeset.traverse_errors(changeset, fn {msg, opts} ->
-      #       Enum.reduce(opts, msg, fn {key, value}, acc ->
-      #         String.replace(acc, "%{#{key}}", to_string(value))
-      #       end)
-      #     end)}
     end
   end
 
-  # @spec register(map()) :: {:ok, Actor.t()} | {:error, String.t()}
-  # def register(%{email: email, password: password, username: username}) do
-  #   with avatar <- gravatar(email),
-  #        user_changeset <-
-  #          User.registration_changeset(%User{}, %{
-  #            email: email,
-  #            password: password,
-  #            default_actor: %{
-  #              preferred_username: username,
-  #              domain: nil,
-  #              keys: create_keys(),
-  #              avatar_url: avatar
-  #            }
-  #          }),
-  #        {:ok, %User{default_actor: %Actor{} = actor, id: user_id} = user} <-
-  #          Mobilizon.Repo.insert(user_changeset),
-  #        {:ok, %Actor{} = _actor} <- update_actor(actor, %{user_id: user_id}) do
-  #     {:ok, Repo.preload(user, [:actors])}
-  #   else
-  #     {:error, %Ecto.Changeset{} = changeset} ->
-  #       handle_actor_user_changeset(changeset)
-  #   end
-  # end
-
-  # @spec handle_actor_user_changeset(Ecto.Changeset.t()) :: {:error, String.t()}
-  # defp handle_actor_user_changeset(changeset) do
-  #   changeset =
-  #     Ecto.Changeset.traverse_errors(changeset, fn
-  #       {msg, _opts} -> msg
-  #       msg -> msg
-  #     end)
-
-  #   email_msg = Map.get(changeset, :email) || [:empty_email]
-  #   {:error, hd(email_msg)}
-  # end
-
-  # @spec gravatar(String.t()) :: String.t() | nil
-  # defp gravatar(nil), do: nil
-
-  # defp gravatar(email) do
-  #   avatar_url = gravatar_url(email, default: "404")
-
-  #   case HTTPoison.get(avatar_url) do
-  #     {:ok, %HTTPoison.Response{status_code: 200}} ->
-  #       avatar_url
-
-  #     _ ->
-  #       nil
-  #   end
-  # end
-
   @doc """
   Create a new person actor
   """

lib/mobilizon/application.ex

@@ -17,6 +17,7 @@ defmodule Mobilizon.Application do
       supervisor(MobilizonWeb.Endpoint, []),
       # Start your own worker by calling: Mobilizon.Worker.start_link(arg1, arg2, arg3)
       # worker(Mobilizon.Worker, [arg1, arg2, arg3]),
+      worker(Cachex, [:mobilizon, []]),
       worker(Guardian.DB.Token.SweeperServer, []),
       worker(Mobilizon.Service.Federator, [])
     ]

lib/mobilizon_web/controllers/activity_pub_controller.ex

@@ -21,6 +21,10 @@ defmodule MobilizonWeb.ActivityPubController do
     "application/activity+json, application/ld+json"
   ]
 
+  def actor(conn, %{"name" => _name, "_format" => "atom"} = params) do
+    MobilizonWeb.FeedController.actor(conn, params)
+  end
+
   def actor(conn, %{"name" => name}) do
     with %Actor{} = actor <- Actors.get_local_actor_by_name(name) do
       if conn |> get_req_header("accept") |> is_ap_header() do

lib/mobilizon_web/controllers/feed_controller.ex

@@ -0,0 +1,105 @@
+defmodule MobilizonWeb.FeedController do
+  @moduledoc """
+  Controller to serve RSS, ATOM and iCal Feeds
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Events
+  alias Mobilizon.Events.Event
+  alias Atomex.{Feed, Entry}
+  import MobilizonWeb.Gettext
+
+  @version Mix.Project.config()[:version]
+  def version(), do: @version
+
+  def actor(conn, %{"name" => name, "_format" => format}) when format in ["atom"] do
+    name = String.replace_suffix(name, ".atom", "")
+
+    with {status, data} when status in [:ok, :commit] <-
+           Cachex.fetch(:mobilizon, "actor_" <> format <> "_" <> name, &create_cache/1) do
+      conn
+      |> put_resp_content_type("application/atom+xml")
+      |> send_resp(200, data)
+    else
+      _err ->
+        send_resp(conn, 404, "Not found")
+    end
+  end
+
+  @spec create_cache(String.t()) :: {:commit, String.t()} | {:ignore, any()}
+  defp create_cache(key) do
+    with ["actor", type, name] <- String.split(key, "_", parts: 3),
+         {:ok, res} <- fetch_actor_event_feed(type, name) do
+      {:commit, res}
+    else
+      err ->
+        {:ignore, err}
+    end
+  end
+
+  @spec fetch_actor_event_feed(String.t(), String.t()) :: String.t()
+  defp fetch_actor_event_feed(type, name) do
+    with %Actor{} = actor <- Actors.get_local_actor_by_name(name),
+         {:ok, events, _count} <- Events.get_public_events_for_actor(actor) do
+      {:ok, build_actor_feed(actor, events, type)}
+    else
+      err ->
+        {:error, err}
+    end
+  end
+
+  @spec build_actor_feed(Actor.t(), list(), String.t()) :: String.t()
+  defp build_actor_feed(%Actor{} = actor, events, type) do
+    display_name = Actor.display_name(actor)
+
+    # Title uses default instance language
+    feed =
+      Feed.new(
+        actor.url <> ".rss",
+        DateTime.utc_now(),
+        gettext("%{actor}'s public events feed", actor: display_name)
+      )
+      |> Feed.author(display_name, uri: actor.url)
+      |> Feed.link(actor.url <> "." <> type, rel: "self")
+      |> Feed.link(actor.url, rel: "alternate")
+      |> Feed.generator("Mobilizon", uri: "https://joinmobilizon.org", version: version())
+      |> Feed.entries(Enum.map(events, &get_entry/1))
+
+    feed = if actor.avatar_url, do: Feed.icon(feed, actor.avatar_url), else: feed
+
+    feed =
+      if actor.banner_url,
+        do: Feed.logo(feed, actor.banner_url),
+        else: feed
+
+    feed
+    |> Feed.build()
+    |> Atomex.generate_document()
+  end
+
+  defp get_entry(%Event{} = event) do
+    with {:ok, html, []} <- Earmark.as_html(event.description) do
+      entry =
+        Entry.new(event.url, event.inserted_at, event.title)
+        |> Entry.link(event.url, rel: "alternate", type: "text/html")
+        |> Entry.content({:cdata, html}, type: "html")
+
+      entry = if event.publish_at, do: Entry.published(entry, event.publish_at), else: entry
+
+      # Add tags
+      entry =
+        event.tags
+        |> Enum.map(& &1.title)
+        |> Enum.uniq()
+        |> Enum.reduce(entry, fn tag, acc -> Entry.category(acc, tag) end)
+
+      Entry.build(entry)
+    else
+      {:error, _html, error_messages} ->
+        require Logger
+        Logger.error("Unable to produce HTML for Markdown", details: inspect(error_messages))
+    end
+  end
+end

lib/mobilizon_web/router.ex

@@ -22,6 +22,11 @@ defmodule MobilizonWeb.Router do
     plug(:accepts, ["activity-json", "html"])
   end
 
+  pipeline :activity_pub_rss do
+    plug(TrailingFormatPlug)
+    plug(:accepts, ["activity-json", "html", "atom"])
+  end
+
   pipeline :browser do
     plug(:accepts, ["html"])
     plug(:fetch_session)
@@ -52,9 +57,14 @@ defmodule MobilizonWeb.Router do
   end
 
   scope "/", MobilizonWeb do
-    pipe_through(:activity_pub)
+    pipe_through(:activity_pub_rss)
 
     get("/@:name", ActivityPubController, :actor)
+  end
+
+  scope "/", MobilizonWeb do
+    pipe_through(:activity_pub)
+
     get("/@:name/outbox", ActivityPubController, :outbox)
     get("/@:name/following", ActivityPubController, :following)
     get("/@:name/followers", ActivityPubController, :followers)