Various refactoring and typespec improvements

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

lib/service/export/common.ex

@@ -6,56 +6,99 @@ defmodule Mobilizon.Service.Export.Common do
   alias Mobilizon.{Actors, Events, Posts, Users}
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Events.{Event, FeedToken}
+  alias Mobilizon.Posts.Post
   alias Mobilizon.Storage.Page
   alias Mobilizon.Users.User
 
-  @spec fetch_actor_event_feed(String.t(), integer()) :: String.t()
+  @spec fetch_actor_event_feed(String.t(), integer()) ::
+          {:ok, Actor.t(), [Event.t()], [Post.t()]}
+          | {:error, :actor_not_public | :actor_not_found}
   def fetch_actor_event_feed(name, limit) do
-    with %Actor{} = actor <- Actors.get_actor_by_name(name),
-         {:visibility, true} <- {:visibility, Actor.is_public_visibility?(actor)},
-         %Page{elements: events} <- Events.list_public_events_for_actor(actor, 1, limit),
-         %Page{elements: posts} <- Posts.get_public_posts_for_group(actor, 1, limit) do
-      {:ok, actor, events, posts}
-    else
-      err ->
-        {:error, err}
+    case Actors.get_actor_by_name(name) do
+      %Actor{} = actor ->
+        if Actor.is_public_visibility?(actor) do
+          %Page{elements: events} = Events.list_public_events_for_actor(actor, 1, limit)
+          %Page{elements: posts} = Posts.get_public_posts_for_group(actor, 1, limit)
+          {:ok, actor, events, posts}
+        else
+          {:error, :actor_not_public}
+        end
+
+      nil ->
+        {:error, :actor_not_found}
     end
   end
 
-  # Only events, not posts
-  @spec fetch_events_from_token(String.t(), integer()) :: String.t()
-  def fetch_events_from_token(token, limit) do
-    with {:ok, uuid} <- ShortUUID.decode(token),
-         {:ok, _uuid} <- Ecto.UUID.cast(uuid),
-         %FeedToken{actor: actor, user: %User{} = user} <- Events.get_feed_token(uuid) do
-      case actor do
-        %Actor{} = actor ->
-          %{
-            type: :actor,
-            actor: actor,
-            events: fetch_actor_private_events(actor, limit),
-            user: user,
-            token: token
-          }
+  @typep token_feed_data :: %{
+           type: :actor | :user,
+           actor: Actor.t() | nil,
+           user: User.t(),
+           events: [Event.t()],
+           token: String.t()
+         }
 
-        nil ->
-          with actors <- Users.get_actors_for_user(user),
-               events <-
-                 actors
-                 |> Enum.map(&fetch_actor_private_events(&1, limit))
-                 |> Enum.concat() do
-            %{type: :user, events: events, user: user, token: token, actor: nil}
-          end
-      end
+  # Only events, not posts
+  @spec fetch_events_from_token(String.t(), integer()) ::
+          token_feed_data | {:error, :bad_token | :token_not_found}
+  def fetch_events_from_token(token, limit) do
+    case uuid_from_token(token) do
+      {:ok, uuid} ->
+        case Events.get_feed_token(uuid) do
+          nil ->
+            {:error, :token_not_found}
+
+          %FeedToken{actor: actor, user: %User{} = user} ->
+            produce_actor_feed(actor, user, token, limit)
+        end
+
+      {:error, :bad_token} ->
+        {:error, :bad_token}
+    end
+  end
+
+  @spec uuid_from_token(String.t()) :: {:ok, String.t()} | {:error, :bad_token}
+  defp uuid_from_token(token) do
+    case ShortUUID.decode(token) do
+      {:ok, uuid} ->
+        case Ecto.UUID.cast(uuid) do
+          {:ok, _uuid} ->
+            {:ok, uuid}
+
+          :error ->
+            {:error, :bad_token}
+        end
+
+      {:error, _err} ->
+        {:error, :bad_token}
+    end
+  end
+
+  @spec produce_actor_feed(Actor.t() | nil, User.t(), String.t(), integer()) :: token_feed_data
+  defp produce_actor_feed(%Actor{} = actor, %User{} = user, token, limit) do
+    %{
+      type: :actor,
+      actor: actor,
+      events: fetch_actor_private_events(actor, limit),
+      user: user,
+      token: token
+    }
+  end
+
+  defp produce_actor_feed(nil, %User{} = user, token, limit) do
+    with actors <- Users.get_actors_for_user(user),
+         events <-
+           actors
+           |> Enum.map(&fetch_actor_private_events(&1, limit))
+           |> Enum.concat() do
+      %{type: :user, events: events, user: user, token: token, actor: nil}
     end
   end
 
   @spec fetch_instance_public_content(integer()) :: {:ok, list(Event.t()), list(Post.t())}
   def fetch_instance_public_content(limit) do
-    with %Page{elements: events} <- Events.list_public_local_events(1, limit),
-         %Page{elements: posts} <- Posts.list_public_local_posts(1, limit) do
-      {:ok, events, posts}
-    end
+    %Page{elements: events} = Events.list_public_local_events(1, limit)
+    %Page{elements: posts} = Posts.list_public_local_posts(1, limit)
+    {:ok, events, posts}
   end
 
   @spec fetch_actor_private_events(Actor.t(), integer()) :: list(Event.t())

lib/service/export/feed.ex

@@ -96,13 +96,13 @@ defmodule Mobilizon.Service.Export.Feed do
       {:ok, actor, events, posts} ->
         {:ok, build_actor_feed(actor, events, posts)}
 
-      err ->
+      {: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(), list(), boolean()) :: String.t()
+  @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)
 
@@ -199,19 +199,22 @@ defmodule Mobilizon.Service.Export.Feed do
   end
 
   # Only events, not posts
-  @spec fetch_events_from_token(String.t()) :: String.t()
+  @spec fetch_events_from_token(String.t(), integer()) :: {:ok, String.t()} | {:error, atom()}
   defp fetch_events_from_token(token, limit \\ @item_limit) do
-    with %{events: events, token: token, user: user, actor: actor, type: type} <-
-           Common.fetch_events_from_token(token, limit) do
-      case type do
-        :user -> {:ok, build_user_feed(events, user, token)}
-        :actor -> {:ok, build_actor_feed(actor, events, [], false)}
-      end
+    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(), User.t(), String.t()) :: String.t()
+  @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 = Endpoint |> Routes.feed_url(:going, token, "atom") |> URI.decode()
 

lib/service/export/icalendar.ex

@@ -15,12 +15,13 @@ defmodule Mobilizon.Service.Export.ICalendar do
   @doc """
   Create cache for an actor, an event or an user token
   """
+  @spec create_cache(String.t()) :: {:commit, String.t()} | {:ignore, atom()}
   def create_cache("actor_" <> name) do
     case export_public_actor(name) do
       {:ok, res} ->
         {:commit, res}
 
-      err ->
+      {:error, err} ->
         {:ignore, err}
     end
   end
@@ -30,8 +31,11 @@ defmodule Mobilizon.Service.Export.ICalendar do
          {:ok, res} <- export_public_event(event) do
       {:commit, res}
     else
-      err ->
+      {:error, err} ->
         {:ignore, err}
+
+      nil ->
+        {:ignore, :event_not_found}
     end
   end
 
@@ -40,30 +44,20 @@ defmodule Mobilizon.Service.Export.ICalendar do
       {:ok, res} ->
         {:commit, res}
 
-      err ->
+      {:error, err} ->
         {:ignore, err}
     end
   end
 
   def create_cache("instance") do
-    case fetch_instance_feed() do
-      {:ok, res} ->
-        {:commit, res}
-
-      err ->
-        {:ignore, err}
-    end
+    {:ok, res} = fetch_instance_feed()
+    {:commit, res}
   end
 
   @spec fetch_instance_feed :: {:ok, String.t()}
   defp fetch_instance_feed do
-    case Common.fetch_instance_public_content(@item_limit) do
-      {:ok, events, _posts} ->
-        {:ok, %ICalendar{events: events |> Enum.map(&do_export_event/1)} |> ICalendar.to_ics()}
-
-      err ->
-        {:error, err}
-    end
+    {:ok, events, _posts} = Common.fetch_instance_public_content(@item_limit)
+    {:ok, %ICalendar{events: events |> Enum.map(&do_export_event/1)} |> ICalendar.to_ics()}
   end
 
   @doc """
@@ -77,13 +71,12 @@ defmodule Mobilizon.Service.Export.ICalendar do
 
   The event must have a visibility of `:public` or `:unlisted`
   """
-  @spec export_public_event(Event.t()) :: {:ok, String.t()}
+  @spec export_public_event(Event.t()) :: {:ok, String.t()} | {:error, :event_not_public}
   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 """
@@ -91,28 +84,33 @@ defmodule Mobilizon.Service.Export.ICalendar do
 
   The actor must have a visibility of `:public` or `:unlisted`, as well as the events
   """
-  @spec export_public_actor(String.t()) :: String.t()
+  @spec export_public_actor(String.t()) ::
+          {:ok, String.t()} | {:error, :actor_not_public | :actor_not_found}
   def export_public_actor(name, limit \\ @item_limit) do
     case Common.fetch_actor_event_feed(name, limit) do
       {:ok, _actor, events, _posts} ->
         {:ok, events_to_ics(events)}
 
-      err ->
+      {:error, err} ->
         {:error, err}
     end
   end
 
-  @spec export_private_actor(Actor.t()) :: String.t()
+  @spec export_private_actor(Actor.t(), integer()) :: {:ok, String.t()}
   def export_private_actor(%Actor{} = actor, limit \\ @item_limit) do
-    with events <- Common.fetch_actor_private_events(actor, limit) do
-      {:ok, events_to_ics(events)}
-    end
+    events = Common.fetch_actor_private_events(actor, limit)
+    {:ok, events_to_ics(events)}
   end
 
-  @spec fetch_events_from_token(String.t()) :: String.t()
+  @spec fetch_events_from_token(String.t(), integer()) ::
+          {:ok, String.t()} | {:error, :actor_not_public | :actor_not_found}
   defp fetch_events_from_token(token, limit \\ @item_limit) do
-    with %{events: events} <- Common.fetch_events_from_token(token, limit) do
-      {:ok, events_to_ics(events)}
+    case Common.fetch_events_from_token(token, limit) do
+      %{events: events} ->
+        {:ok, events_to_ics(events)}
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
@@ -138,6 +136,7 @@ defmodule Mobilizon.Service.Export.ICalendar do
     }
   end
 
+  @spec vendor :: String.t()
   defp vendor do
     "Mobilizon #{Config.instance_version()}"
   end