Introduce instance ICS & Atom feeds (disabled by default)

And refactor the feed modules

Signed-off-by: Thomas Citharel <tcit@tcit.fr>

lib/service/export/icalendar.ex

@@ -3,83 +3,23 @@ defmodule Mobilizon.Service.Export.ICalendar do
   Export an event to iCalendar format.
   """
 
-  alias Mobilizon.{Actors, Config, Events, Users}
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Addresses.Address
-  alias Mobilizon.Events.{Event, FeedToken}
+  alias Mobilizon.{Config, Events}
+  alias Mobilizon.Events.Event
+  alias Mobilizon.Service.Export.Common
   alias Mobilizon.Service.Formatter.HTML
-  alias Mobilizon.Storage.Page
-  alias Mobilizon.Users.User
 
   @vendor "Mobilizon #{Config.instance_version()}"
 
-  @doc """
-  Export a public event to iCalendar format.
-
-  The event must have a visibility of `:public` or `:unlisted`
-  """
-  @spec export_public_event(Event.t()) :: {:ok, String.t()}
-  def export_public_event(%Event{visibility: visibility} = event)
-      when visibility in [:public, :unlisted] do
-    export_event(event)
-  end
-
-  @spec export_public_event(Event.t()) :: {:error, :event_not_public}
-  def export_public_event(%Event{}), do: {:error, :event_not_public}
-
-  @doc """
-  Export an event to iCalendar format
-  """
-  def export_event(%Event{} = event) do
-    {:ok, %ICalendar{events: [do_export_event(event)]} |> ICalendar.to_ics(vendor: @vendor)}
-  end
-
-  @spec do_export_event(Event.t()) :: ICalendar.Event.t()
-  defp do_export_event(%Event{} = event) do
-    %ICalendar.Event{
-      summary: event.title,
-      dtstart: event.begins_on,
-      dtstamp: event.publish_at || DateTime.utc_now(),
-      dtend: event.ends_on,
-      description: HTML.strip_tags(event.description),
-      uid: event.uuid,
-      url: event.url,
-      geo: Address.coords(event.physical_address),
-      location: Address.representation(event.physical_address),
-      categories: event.tags |> Enum.map(& &1.title)
-    }
-  end
-
-  @doc """
-  Export a public actor's events to iCalendar format.
-
-  The actor must have a visibility of `:public` or `:unlisted`, as well as the events
-  """
-  @spec export_public_actor(Actor.t()) :: String.t()
-  def export_public_actor(%Actor{} = actor) do
-    with {:visibility, true} <- {:visibility, Actor.is_public_visibility?(actor)},
-         %Page{elements: events} <-
-           Events.list_public_events_for_actor(actor) do
-      {:ok, %ICalendar{events: events |> Enum.map(&do_export_event/1)} |> ICalendar.to_ics()}
-    end
-  end
-
-  @spec export_private_actor(Actor.t()) :: String.t()
-  def export_private_actor(%Actor{} = actor) do
-    with events <-
-           actor |> Events.list_event_participations_for_actor() |> participations_to_events() do
-      {:ok, %ICalendar{events: events |> Enum.map(&do_export_event/1)} |> ICalendar.to_ics()}
-    end
-  end
-
   @doc """
   Create cache for an actor, an event or an user token
   """
   def create_cache("actor_" <> name) do
-    with %Actor{} = actor <- Actors.get_local_actor_by_name(name),
-         {:ok, res} <- export_public_actor(actor) do
-      {:commit, res}
-    else
+    case export_public_actor(name) do
+      {:ok, res} ->
+        {:commit, res}
+
       err ->
         {:ignore, err}
     end
@@ -105,33 +45,96 @@ defmodule Mobilizon.Service.Export.ICalendar do
     end
   end
 
-  @spec fetch_events_from_token(String.t()) :: String.t()
-  defp fetch_events_from_token(token) do
-    with %FeedToken{actor: actor, user: %User{} = user} <- Events.get_feed_token(token) do
-      case actor do
-        %Actor{} = actor ->
-          export_private_actor(actor)
+  def create_cache("instance") do
+    case fetch_instance_feed() do
+      {:ok, res} ->
+        {:commit, res}
 
-        nil ->
-          with actors <- Users.get_actors_for_user(user),
-               events <-
-                 actors
-                 |> Enum.map(fn actor ->
-                   actor
-                   |> Events.list_event_participations_for_actor()
-                   |> participations_to_events()
-                 end)
-                 |> Enum.concat() do
-            {:ok,
-             %ICalendar{events: events |> Enum.map(&do_export_event/1)} |> ICalendar.to_ics()}
-          end
-      end
+      err ->
+        {:ignore, err}
     end
   end
 
-  defp participations_to_events(%Page{elements: participations}) do
-    participations
-    |> Enum.map(& &1.event_id)
-    |> Enum.map(&Events.get_event_with_preload!/1)
+  @spec fetch_instance_feed :: {:ok, String.t()}
+  defp fetch_instance_feed do
+    case Common.fetch_instance_public_content() do
+      {:ok, events, _posts} ->
+        {:ok, %ICalendar{events: events |> Enum.map(&do_export_event/1)} |> ICalendar.to_ics()}
+
+      err ->
+        {:error, err}
+    end
+  end
+
+  @doc """
+  Export an event to iCalendar format.
+  """
+  @spec export_event(Event.t()) :: {:ok, String.t()}
+  def export_event(%Event{} = event), do: {:ok, events_to_ics([event])}
+
+  @doc """
+  Export a public event to iCalendar format.
+
+  The event must have a visibility of `:public` or `:unlisted`
+  """
+  @spec export_public_event(Event.t()) :: {:ok, String.t()}
+  def export_public_event(%Event{visibility: visibility} = event)
+      when visibility in [:public, :unlisted] do
+    {:ok, events_to_ics([event])}
+  end
+
+  @spec export_public_event(Event.t()) :: {:error, :event_not_public}
+  def export_public_event(%Event{}), do: {:error, :event_not_public}
+
+  @doc """
+  Export a public actor's events to iCalendar format.
+
+  The actor must have a visibility of `:public` or `:unlisted`, as well as the events
+  """
+  @spec export_public_actor(String.t()) :: String.t()
+  def export_public_actor(name) do
+    case Common.fetch_actor_event_feed(name) do
+      {:ok, _actor, events, _posts} ->
+        {:ok, events_to_ics(events)}
+
+      err ->
+        {:error, err}
+    end
+  end
+
+  @spec export_private_actor(Actor.t()) :: String.t()
+  def export_private_actor(%Actor{} = actor) do
+    with events <- Common.fetch_actor_private_events(actor) do
+      {:ok, events_to_ics(events)}
+    end
+  end
+
+  @spec fetch_events_from_token(String.t()) :: String.t()
+  defp fetch_events_from_token(token) do
+    with %{events: events} <- Common.fetch_events_from_token(token) do
+      {:ok, events_to_ics(events)}
+    end
+  end
+
+  @spec events_to_ics(list(Events.t())) :: String.t()
+  defp events_to_ics(events) do
+    %ICalendar{events: events |> Enum.map(&do_export_event/1)}
+    |> ICalendar.to_ics(vendor: @vendor)
+  end
+
+  @spec do_export_event(Event.t()) :: ICalendar.Event.t()
+  defp do_export_event(%Event{} = event) do
+    %ICalendar.Event{
+      summary: event.title,
+      dtstart: event.begins_on,
+      dtstamp: event.publish_at || DateTime.utc_now(),
+      dtend: event.ends_on,
+      description: HTML.strip_tags(event.description),
+      uid: event.uuid,
+      url: event.url,
+      geo: Address.coords(event.physical_address),
+      location: Address.representation(event.physical_address),
+      categories: event.tags |> Enum.map(& &1.title)
+    }
   end
 end