From 88b078ebce4e771c648f76320b5da7d1f4afd435 Mon Sep 17 00:00:00 2001
From: Thomas Citharel <tcit@tcit.fr>
Date: Fri, 29 Oct 2021 10:38:03 +0200
Subject: [PATCH] Increase the number of related events to 4 and refactor
 function

Signed-off-by: Thomas Citharel <tcit@tcit.fr>
---
 lib/graphql/resolvers/event.ex | 70 ++++++++++++++++++++--------------
 1 file changed, 42 insertions(+), 28 deletions(-)

diff --git a/lib/graphql/resolvers/event.ex b/lib/graphql/resolvers/event.ex
index 1138b0bd8..4f25dcd4b 100644
--- a/lib/graphql/resolvers/event.ex
+++ b/lib/graphql/resolvers/event.ex
@@ -21,7 +21,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
 
   # We limit the max number of events that can be retrieved
   @event_max_limit 100
-  @number_of_related_events 3
+  @number_of_related_events 4
 
   @spec organizer_for_event(Event.t(), map(), Absinthe.Resolution.t()) ::
           {:ok, Actor.t() | nil} | {:error, String.t()}
@@ -213,38 +213,19 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
   """
   @spec list_related_events(Event.t(), map(), Absinthe.Resolution.t()) :: {:ok, list(Event.t())}
   def list_related_events(
-        %Event{tags: tags, organizer_actor: organizer_actor, uuid: uuid},
+        %Event{uuid: uuid} = event,
         _args,
         _resolution
       ) do
     # We get the organizer's next public event
     events =
-      [Events.get_upcoming_public_event_for_actor(organizer_actor, uuid)]
-      |> Enum.filter(&is_map/1)
-
-    # We find similar events with the same tags
-    # uniq_by : It's possible event_from_same_actor is inside events_from_tags
-    events =
-      events
-      |> Enum.concat(Events.list_events_by_tags(tags, @number_of_related_events))
-      |> uniq_events()
-
-    # TODO: We should use tag_relations to find more appropriate events
-
-    # We've considered all recommended events, so we fetch the latest events
-    events =
-      if @number_of_related_events - length(events) > 0 do
-        events
-        |> Enum.concat(
-          Events.list_events(1, @number_of_related_events, :begins_on, :asc, true).elements
-        )
-        |> uniq_events()
-      else
-        events
-      end
-
-    events =
-      events
+      event
+      |> organizer_next_public_event()
+      # We find similar events with the same tags
+      |> similar_events_common_tags(event)
+      # TODO: We should use tag_relations to find more appropriate events
+      # We've considered all recommended events, so we fetch the latest events
+      |> add_latest_events()
       # We remove the same event from the results
       |> Enum.filter(fn event -> event.uuid != uuid end)
       # We return only @number_of_related_events right now
@@ -253,6 +234,39 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
     {:ok, events}
   end
 
+  @spec organizer_next_public_event(Event.t()) :: list(Event.t())
+  defp organizer_next_public_event(%Event{attributed_to: %Actor{} = group, uuid: uuid}) do
+    [Events.get_upcoming_public_event_for_actor(group, uuid)]
+    |> Enum.filter(&is_map/1)
+  end
+
+  defp organizer_next_public_event(%Event{organizer_actor: %Actor{} = profile, uuid: uuid}) do
+    [Events.get_upcoming_public_event_for_actor(profile, uuid)]
+    |> Enum.filter(&is_map/1)
+  end
+
+  @spec similar_events_common_tags(list(Event.t()), Event.t()) :: list(Event.t())
+  defp similar_events_common_tags(events, %Event{tags: tags, uuid: uuid}) do
+    events
+    |> Enum.concat(Events.list_events_by_tags(tags, @number_of_related_events))
+    |> Enum.filter(fn event -> event.uuid != uuid end)
+    # uniq_by : It's possible event_from_same_actor is inside events_from_tags
+    |> uniq_events()
+  end
+
+  @spec add_latest_events(list(Event.t())) :: list(Event.t())
+  defp add_latest_events(events) do
+    if @number_of_related_events - length(events) > 0 do
+      events
+      |> Enum.concat(
+        Events.list_events(1, @number_of_related_events + 1, :begins_on, :asc, true).elements
+      )
+      |> uniq_events()
+    else
+      events
+    end
+  end
+
   @spec uniq_events(list(Event.t())) :: list(Event.t())
   defp uniq_events(events), do: Enum.uniq_by(events, fn event -> event.uuid end)