Add pagination to events, groups, partipants to an event and categories

lists

lib/mobilizon/actors/actor.ex

@@ -20,11 +20,13 @@ defmodule Mobilizon.Actors.Actor do
   """
   use Ecto.Schema
   import Ecto.Changeset
+
   alias Mobilizon.Actors
   alias Mobilizon.Actors.{Actor, User, Follower, Member}
   alias Mobilizon.Events.Event
 
   import Ecto.Query
+  import Mobilizon.Ecto
   alias Mobilizon.Repo
 
   require Logger
@@ -232,18 +234,15 @@ defmodule Mobilizon.Actors.Actor do
 
   If actor A and C both follow actor B, actor B's followers are A and C
   """
-  def get_followers(%Actor{id: actor_id} = _actor, page \\ 1, limit \\ 10) do
-    start = (page - 1) * limit
-
+  def get_followers(%Actor{id: actor_id} = _actor, page \\ nil, limit \\ nil) do
     Repo.all(
       from(
         a in Actor,
         join: f in Follower,
         on: a.id == f.actor_id,
-        where: f.target_actor_id == ^actor_id,
-        limit: ^limit,
-        offset: ^start
+        where: f.target_actor_id == ^actor_id
       )
+      |> paginate(page, limit)
     )
   end
 
@@ -252,18 +251,15 @@ defmodule Mobilizon.Actors.Actor do
 
   If actor A follows actor B and C, actor A's followings are B and B
   """
-  def get_followings(%Actor{id: actor_id} = _actor, page \\ 1, limit \\ 10) do
-    start = (page - 1) * limit
-
+  def get_followings(%Actor{id: actor_id} = _actor, page \\ nil, limit \\ nil) do
     Repo.all(
       from(
         a in Actor,
         join: f in Follower,
         on: a.id == f.target_actor_id,
-        where: f.actor_id == ^actor_id,
-        limit: ^limit,
-        offset: ^start
+        where: f.actor_id == ^actor_id
       )
+      |> paginate(page, limit)
     )
   end
 

lib/mobilizon/actors/actors.ex

@@ -4,6 +4,8 @@ defmodule Mobilizon.Actors do
   """
 
   import Ecto.Query, warn: false
+  import Mobilizon.Ecto
+
   alias Mobilizon.Repo
 
   alias Mobilizon.Actors.{Actor, Bot, Member, Follower, User}
@@ -150,8 +152,14 @@ defmodule Mobilizon.Actors do
   @doc """
   List the groups
   """
-  def list_groups do
-    Repo.all(from(a in Actor, where: a.type == ^:Group))
+  def list_groups(page \\ nil, limit \\ nil) do
+    Repo.all(
+      from(
+        a in Actor,
+        where: a.type == ^:Group
+      )
+      |> paginate(page, limit)
+    )
   end
 
   def get_group_by_name(name) do
@@ -446,21 +454,18 @@ defmodule Mobilizon.Actors do
   Find actors by their name or displayed name
   """
   @spec find_actors_by_username_or_name(String.t(), integer(), integer()) :: list(Actor.t())
-  def find_actors_by_username_or_name(username, page \\ 1, limit \\ 10)
+  def find_actors_by_username_or_name(username, page \\ nil, limit \\ nil)
   def find_actors_by_username_or_name("", _page, _limit), do: []
 
   def find_actors_by_username_or_name(username, page, limit) do
-    start = (page - 1) * limit
-
     Repo.all(
       from(
         a in Actor,
-        limit: ^limit,
-        offset: ^start,
         where:
           ilike(a.preferred_username, ^like_sanitize(username)) or
             ilike(a.name, ^like_sanitize(username))
       )
+      |> paginate(page, limit)
     )
   end
 

lib/mobilizon/ecto.ex

@@ -0,0 +1,34 @@
+defmodule Mobilizon.Ecto do
+  @moduledoc """
+  Mobilizon Ecto utils
+  """
+
+  import Ecto.Query, warn: false
+
+  @doc """
+  Add limit and offset to the query
+  """
+  def paginate(query, page \\ 1, size \\ 10)
+  def paginate(query, page, _size) when is_nil(page), do: paginate(query)
+  def paginate(query, page, size) when is_nil(size), do: paginate(query, page)
+
+  def paginate(query, page, size) do
+    from(query,
+      limit: ^size,
+      offset: ^((page - 1) * size)
+    )
+  end
+
+  def increment_slug(slug) do
+    case List.pop_at(String.split(slug, "-"), -1) do
+      {nil, _} ->
+        slug
+
+      {suffix, slug_parts} ->
+        case Integer.parse(suffix) do
+          {id, _} -> Enum.join(slug_parts, "-") <> "-" <> Integer.to_string(id + 1)
+          :error -> slug <> "-1"
+        end
+    end
+  end
+end

lib/mobilizon/events/events.ex

@@ -4,6 +4,7 @@ defmodule Mobilizon.Events do
   """
 
   import Ecto.Query, warn: false
+  import Mobilizon.Ecto
   alias Mobilizon.Repo
 
   alias Mobilizon.Events.{Event, Comment, Participant}
@@ -18,16 +19,12 @@ defmodule Mobilizon.Events do
     queryable
   end
 
-  def get_events_for_actor(%Actor{id: actor_id} = _actor, page \\ 1, limit \\ 10) do
-    start = (page - 1) * limit
-
+  def get_events_for_actor(%Actor{id: actor_id} = _actor, page \\ nil, limit \\ nil) do
     query =
       from(
         e in Event,
         where: e.organizer_actor_id == ^actor_id,
-        limit: ^limit,
         order_by: [desc: :id],
-        offset: ^start,
         preload: [
           :organizer_actor,
           :category,
@@ -38,6 +35,7 @@ defmodule Mobilizon.Events do
           :physical_address
         ]
       )
+      |> paginate(page, limit)
 
     events = Repo.all(query)
 
@@ -186,15 +184,10 @@ defmodule Mobilizon.Events do
       [%Event{}, ...]
 
   """
-  def list_events(page \\ 1, limit \\ 10) do
-    start = (page - 1) * limit
-
+  def list_events(page \\ nil, limit \\ nil) do
     query =
-      from(e in Event,
-        limit: ^limit,
-        offset: ^start,
-        preload: [:organizer_actor]
-      )
+      from(e in Event, preload: [:organizer_actor])
+      |> paginate(page, limit)
 
     Repo.all(query)
   end
@@ -202,20 +195,18 @@ defmodule Mobilizon.Events do
   @doc """
   Find events by name
   """
-  def find_events_by_name(name, page \\ 1, limit \\ 10)
+  def find_events_by_name(name, page \\ nil, limit \\ nil)
   def find_events_by_name("", page, limit), do: list_events(page, limit)
 
   def find_events_by_name(name, page, limit) do
     name = String.trim(name)
-    start = (page - 1) * limit
 
     query =
       from(e in Event,
-        limit: ^limit,
-        offset: ^start,
         where: ilike(e.title, ^like_sanitize(name)),
         preload: [:organizer_actor]
       )
+      |> paginate(page, limit)
 
     Repo.all(query)
   end
@@ -309,8 +300,11 @@ defmodule Mobilizon.Events do
       [%Category{}, ...]
 
   """
-  def list_categories do
-    Repo.all(Category)
+  def list_categories(page \\ nil, limit \\ nil) do
+    Repo.all(
+      Category
+      |> paginate(page, limit)
+    )
   end
 
   @doc """
@@ -519,7 +513,7 @@ defmodule Mobilizon.Events do
       [%Participant{}, ...]
 
   """
-  def list_participants_for_event(uuid) do
+  def list_participants_for_event(uuid, page \\ nil, limit \\ nil) do
     Repo.all(
       from(
         p in Participant,
@@ -528,6 +522,7 @@ defmodule Mobilizon.Events do
         where: e.uuid == ^uuid,
         preload: [:actor]
       )
+      |> paginate(page, limit)
     )
   end
 
@@ -846,16 +841,12 @@ defmodule Mobilizon.Events do
     Repo.all(Comment)
   end
 
-  def get_comments_for_actor(%Actor{id: actor_id}, page \\ 1, limit \\ 10) do
-    start = (page - 1) * limit
-
+  def get_comments_for_actor(%Actor{id: actor_id}, page \\ nil, limit \\ nil) do
     query =
       from(
         c in Comment,
         where: c.actor_id == ^actor_id,
-        limit: ^limit,
         order_by: [desc: :id],
-        offset: ^start,
         preload: [
           :actor,
           :in_reply_to_comment,
@@ -863,6 +854,7 @@ defmodule Mobilizon.Events do
           :event
         ]
       )
+      |> paginate(page, limit)
 
     comments = Repo.all(query)
 

lib/mobilizon/events/tag.ex

@@ -25,7 +25,7 @@ defmodule Mobilizon.Events.Tag.TitleSlug do
 
       _tag ->
         slug
-        |> Mobilizon.Slug.increment_slug()
+        |> Mobilizon.Ecto.increment_slug()
         |> build_unique_slug(changeset)
     end
   end

lib/mobilizon/slug.ex

@@ -1,17 +0,0 @@
-defmodule Mobilizon.Slug do
-  @moduledoc """
-  Common functions for slug generation
-  """
-  def increment_slug(slug) do
-    case List.pop_at(String.split(slug, "-"), -1) do
-      {nil, _} ->
-        slug
-
-      {suffix, slug_parts} ->
-        case Integer.parse(suffix) do
-          {id, _} -> Enum.join(slug_parts, "-") <> "-" <> Integer.to_string(id + 1)
-          :error -> slug <> "-1"
-        end
-    end
-  end
-end