Introduce group basic federation, event new page and notifications

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

lib/mobilizon/resources/resources.ex

@@ -0,0 +1,227 @@
+defmodule Mobilizon.Resources do
+  @moduledoc """
+  The Resources context.
+  """
+  alias Ecto.Adapters.SQL
+  alias Ecto.Multi
+  alias Ecto.UUID
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Resources.Resource
+  alias Mobilizon.Storage.{Page, Repo}
+
+  import Ecto.Query
+  require Logger
+
+  @resource_preloads [:actor, :creator, :children, :parent]
+
+  @doc """
+  Returns the list of recent resources for a group
+  """
+  @spec get_resources_for_group(Actor.t(), integer | nil, integer | nil) :: Page.t()
+  def get_resources_for_group(%Actor{id: group_id}, page \\ nil, limit \\ nil) do
+    Resource
+    |> where(actor_id: ^group_id)
+    |> order_by(desc: :updated_at)
+    |> Page.build_page(page, limit)
+  end
+
+  @doc """
+  Returns the list of top-level resources for a group
+  """
+  def get_top_level_resources_for_group(%Actor{id: group_id}, page \\ nil, limit \\ nil) do
+    get_resources_for_folder(%Resource{id: "root_something", actor_id: group_id}, page, limit)
+  end
+
+  @doc """
+  Returns the list of resources for a resource folder.
+  """
+  @spec get_resources_for_folder(Resource.t(), integer | nil, integer | nil) :: Page.t()
+  def get_resources_for_folder(resource, page \\ nil, limit \\ nil)
+
+  def get_resources_for_folder(
+        %Resource{id: "root_" <> _group_id, actor_id: group_id},
+        page,
+        limit
+      ) do
+    Resource
+    |> where([r], r.actor_id == ^group_id and is_nil(r.parent_id))
+    |> order_by(asc: :type)
+    |> preload([r], [:actor, :creator])
+    |> Page.build_page(page, limit)
+  end
+
+  def get_resources_for_folder(%Resource{id: resource_id}, page, limit) do
+    Resource
+    |> where([r], r.parent_id == ^resource_id)
+    |> order_by(asc: :type)
+    |> Page.build_page(page, limit)
+  end
+
+  @doc """
+  Get a resource by it's ID
+  """
+  @spec get_resource(integer | String.t()) :: Resource.t() | nil
+  def get_resource(nil), do: nil
+  def get_resource(id), do: Repo.get(Resource, id)
+
+  @spec get_resource_with_preloads(integer | String.t()) :: Resource.t() | nil
+  def get_resource_with_preloads(id) do
+    Resource
+    |> Repo.get(id)
+    |> Repo.preload(@resource_preloads)
+  end
+
+  @spec get_resource_by_group_and_path_with_preloads(String.t() | integer, String.t()) ::
+          Resource.t() | nil
+  def get_resource_by_group_and_path_with_preloads(group_id, "/") do
+    with {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id) do
+      %Resource{
+        actor_id: group_id,
+        id: "root_#{group_id}",
+        actor: group,
+        path: "/",
+        title: "Root"
+      }
+    end
+  end
+
+  def get_resource_by_group_and_path_with_preloads(group_id, path) do
+    Resource
+    |> Repo.get_by(actor_id: group_id, path: path)
+    |> Repo.preload(@resource_preloads)
+  end
+
+  @doc """
+  Get a resource by it's URL
+  """
+  @spec get_resource_by_url(String.t()) :: Resource.t() | nil
+  def get_resource_by_url(url), do: Repo.get_by(Resource, url: url)
+
+  @spec get_resource_by_url_with_preloads(String.t()) :: Resource.t() | nil
+  def get_resource_by_url_with_preloads(url) do
+    Resource
+    |> Repo.get_by(url: url)
+    |> Repo.preload(@resource_preloads)
+  end
+
+  @doc """
+  Creates a resource.
+  """
+  @spec create_resource(map) :: {:ok, Resource.t()} | {:error, Ecto.Changeset.t()}
+  def create_resource(attrs \\ %{}) do
+    Multi.new()
+    |> do_find_parent_path(Map.get(attrs, :parent_id))
+    |> Multi.insert(:insert, fn %{find_parent_path: path} ->
+      Resource.changeset(%Resource{}, Map.put(attrs, :path, "#{path}/#{attrs.title}"))
+    end)
+    |> Repo.transaction()
+    |> case do
+      {:ok, %{insert: %Resource{} = resource}} ->
+        {:ok, resource}
+
+      {:error, operation, reason, _changes} ->
+        {:error, "Error while inserting resource when #{operation} because of #{inspect(reason)}"}
+    end
+  end
+
+  @doc """
+  Updates a resource.
+
+  Since a resource can be a folder and hold children, we do the following in a transaction:
+    * Get the parent path so that we can reconstruct the path for current resource (if moved or simply renamed)
+    * Update all children with the new parent path
+    * Update the resource path itself
+  """
+  @spec update_resource(Resource.t(), map) :: {:ok, Resource.t()} | {:error, Ecto.Changeset.t()}
+  def update_resource(%Resource{title: old_title} = resource, attrs) do
+    Multi.new()
+    |> find_parent_path(resource, attrs)
+    |> update_children(resource, attrs)
+    |> Multi.update(:update, fn %{find_parent_path: path} ->
+      title = Map.get(attrs, :title, old_title)
+      Resource.changeset(resource, Map.put(attrs, :path, "#{path}/#{title}"))
+    end)
+    |> Repo.transaction()
+    |> case do
+      {:ok,
+       %{
+         find_parent_path: _parent_path,
+         update: %Resource{} = resource,
+         update_children: children
+       }} ->
+        resource = Map.put(resource, :children, children)
+        {:ok, resource}
+
+      # collect errors into record changesets
+      {:error, operation, reason, _changes} ->
+        {:error, "Error while updating resource when #{operation} because of #{inspect(reason)}"}
+    end
+  end
+
+  @spec find_parent_path(Multi.t(), Resource.t(), map()) :: Multi.t()
+  defp find_parent_path(
+         %Multi{} = multi,
+         %Resource{parent_id: old_parent_id} = _resource,
+         attrs
+       ) do
+    updated_parent_id = Map.get(attrs, :parent_id, old_parent_id)
+    Logger.debug("Finding parent path for updated_parent_id #{inspect(updated_parent_id)}")
+    do_find_parent_path(multi, updated_parent_id)
+  end
+
+  @spec do_find_parent_path(Multi.t(), String.t() | nil) :: Multi.t()
+  defp do_find_parent_path(%Multi{} = multi, nil),
+    do: Multi.run(multi, :find_parent_path, fn _, _ -> {:ok, ""} end)
+
+  defp do_find_parent_path(%Multi{} = multi, parent_id) do
+    Multi.run(multi, :find_parent_path, fn _repo, _changes ->
+      case get_resource(parent_id) do
+        %Resource{path: path} = _resource -> {:ok, path}
+        _ -> {:error, :not_found}
+      end
+    end)
+  end
+
+  @spec update_children(Multi.t(), Resource.t(), map()) :: Multi.t()
+  defp update_children(
+         %Multi{} = multi,
+         %Resource{
+           id: id,
+           type: :folder,
+           title: old_title,
+           actor_id: actor_id
+         },
+         attrs
+       ) do
+    title = Map.get(attrs, :title, old_title)
+
+    Multi.run(multi, :update_children, fn repo, %{find_parent_path: path} ->
+      {:ok, uuid} = UUID.dump(id)
+
+      {query, params} =
+        {"UPDATE resource SET path = CONCAT($1::text, title) WHERE actor_id = $2 AND parent_id = $3::uuid",
+         ["#{path}/#{title}/", actor_id, uuid]}
+
+      {:ok, _} =
+        SQL.query(
+          repo,
+          query,
+          params
+        )
+
+      children = repo.all(from(r in Resource, where: r.parent_id == ^id))
+
+      {:ok, children}
+    end)
+  end
+
+  defp update_children(multi, _, _),
+    do: Multi.run(multi, :update_children, fn _, _ -> {:ok, ""} end)
+
+  @doc """
+  Deletes a resource
+  """
+  @spec delete_resource(Resource.t()) :: {:ok, Resource.t()} | {:error, Ecto.Changeset.t()}
+  def delete_resource(%Resource{} = resource), do: Repo.delete(resource)
+end