Add cron job to clean old activities

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

lib/graphql/resolvers/activity.ex

@@ -19,7 +19,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Activity do
     with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
          {:member, true} <- {:member, Actors.is_member?(actor_id, group_id) or is_moderator(role)} do
       %Page{total: total, elements: elements} =
-        Activities.list_activities_for_group(group_id, actor_id, [], page, limit)
+        Activities.list_group_activities_for_member(group_id, actor_id, [], page, limit)
 
       elements =
         Enum.map(elements, fn %Activity{} = activity ->

lib/mobilizon/activities/activities.ex

@@ -72,13 +72,14 @@ defmodule Mobilizon.Activities do
     Repo.all(Activity)
   end
 
-  @spec list_activities_for_group(
+  @spec list_group_activities_for_member(
+          integer() | String.t(),
           integer() | String.t(),
           Keyword.t(),
           integer() | nil,
           integer() | nil
         ) :: Page.t()
-  def list_activities_for_group(
+  def list_group_activities_for_member(
         group_id,
         actor_asking_id,
         filters \\ [],
@@ -97,6 +98,26 @@ defmodule Mobilizon.Activities do
     |> Page.build_page(page, limit)
   end
 
+  @spec list_group_activities(
+          integer() | String.t(),
+          Keyword.t(),
+          integer() | nil,
+          integer() | nil
+        ) :: Page.t()
+  def list_group_activities(
+        group_id,
+        filters \\ [],
+        page \\ nil,
+        limit \\ nil
+      ) do
+    Activity
+    |> where([a], a.group_id == ^group_id)
+    |> filter_object_type(Keyword.get(filters, :type))
+    |> order_by(desc: :inserted_at)
+    |> preload([:author, :group])
+    |> Page.build_page(page, limit)
+  end
+
   @doc """
   Gets a single activity.
 

lib/service/clean_old_activity.ex

@@ -0,0 +1,64 @@
+defmodule Mobilizon.Service.CleanOldActivity do
+  @moduledoc """
+  Service to clean old activities
+  """
+
+  alias Mobilizon.Activities.Activity
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Config
+  alias Mobilizon.Storage.Repo
+  import Ecto.Query
+
+  @doc """
+  Clean old activities
+
+  Remove activities that are older than a certain period
+
+  Options:
+   * `grace_period` how old in hours can the media be before it's taken into account for deletion
+   * `dry_run` just return the media that would have been deleted, don't actually delete it
+  """
+  @spec clean(Keyword.t()) :: {:ok, list(Media.t())} | {:error, String.t()}
+  def clean(opts \\ []) do
+    {query, nb_actors} = find_activities(opts)
+
+    if Keyword.get(opts, :dry_run, false) do
+      nb_activities = Repo.aggregate(query, :count)
+      {:ok, actors: nb_actors, activities: nb_activities}
+    else
+      {nb_activities, _} = Repo.delete_all(query)
+      {:ok, actors: nb_actors, activities: nb_activities}
+    end
+  end
+
+  @spec find_activities(Keyword.t()) :: {Ecto.Query.t(), list()}
+  defp find_activities(opts) do
+    grace_period =
+      Keyword.get(opts, :grace_period, Config.get([:instance, :activity_expire_days], 365))
+
+    expiration_date = DateTime.add(DateTime.utc_now(), grace_period * -3600)
+
+    activities_to_keep =
+      Keyword.get(
+        opts,
+        :activity_keep_number,
+        Config.get([:instance, :activity_keep_number], 100)
+      )
+
+    actor_ids =
+      Actor
+      |> where(type: :Group)
+      |> join(:inner, [ac], a in Activity, on: a.group_id == ac.id)
+      |> group_by([ac], ac.id)
+      |> having([_ac, a], count(a.id) > ^activities_to_keep)
+      |> select([ac], ac.id)
+      |> Repo.all()
+
+    query =
+      Activity
+      |> where([a], a.inserted_at < ^expiration_date)
+      |> where([a], a.group_id in ^actor_ids)
+
+    {query, length(actor_ids)}
+  end
+end

lib/service/workers/clean_old_activity_worker.ex

@@ -0,0 +1,13 @@
+defmodule Mobilizon.Service.Workers.CleanOldActivityWorker do
+  @moduledoc """
+  Worker to clean old activity
+  """
+
+  use Oban.Worker, queue: "background"
+  alias Mobilizon.Service.CleanOldActivity
+
+  @impl Oban.Worker
+  def perform(%Job{}) do
+    CleanOldActivity.clean()
+  end
+end