Track usage of media files and add a job to clean them

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

lib/federation/activity_pub/utils.ex

@@ -10,7 +10,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
 
   alias Mobilizon.Actors
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.Media.Picture
+  alias Mobilizon.Medias.Media
 
   alias Mobilizon.Federation.ActivityPub
   alias Mobilizon.Federation.ActivityPub.{Activity, Federator, Relay}
@@ -333,50 +333,50 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
   Return AS Link data from
 
   * a `Plug.Upload` struct, stored an returned
-  * a `Picture`, directly returned
-  * a map containing picture information, stored, saved and returned
+  * a `Media`, directly returned
+  * a map containing media information, stored, saved and returned
 
-  Save picture data from %Plug.Upload{} and return AS Link data.
+  Save media data from %Plug.Upload{} and return AS Link data.
   """
-  def make_picture_data(%Plug.Upload{} = picture, opts) do
-    case Mobilizon.Web.Upload.store(picture, opts) do
-      {:ok, picture} ->
-        picture
+  def make_media_data(%Plug.Upload{} = media, opts) do
+    case Mobilizon.Web.Upload.store(media, opts) do
+      {:ok, media} ->
+        media
 
       _ ->
         nil
     end
   end
 
-  def make_picture_data(%Picture{} = picture) do
-    Converter.Picture.model_to_as(picture)
+  def make_media_data(%Media{} = media) do
+    Converter.Media.model_to_as(media)
   end
 
-  def make_picture_data(picture) when is_map(picture) do
+  def make_media_data(media) when is_map(media) do
     with {:ok, %{"url" => [%{"href" => url, "mediaType" => content_type}], "size" => size}} <-
-           Mobilizon.Web.Upload.store(picture.file),
-         {:picture_exists, nil} <- {:picture_exists, Mobilizon.Media.get_picture_by_url(url)},
-         {:ok, %Picture{file: _file} = picture} <-
-           Mobilizon.Media.create_picture(%{
+           Mobilizon.Web.Upload.store(media.file),
+         {:media_exists, nil} <- {:media_exists, Mobilizon.Medias.get_media_by_url(url)},
+         {:ok, %Media{file: _file} = media} <-
+           Mobilizon.Medias.create_media(%{
              "file" => %{
                "url" => url,
-               "name" => picture.name,
+               "name" => media.name,
                "content_type" => content_type,
                "size" => size
              },
-             "actor_id" => picture.actor_id
+             "actor_id" => media.actor_id
            }) do
-      Converter.Picture.model_to_as(picture)
+      Converter.Media.model_to_as(media)
     else
-      {:picture_exists, %Picture{file: _file} = picture} ->
-        Converter.Picture.model_to_as(picture)
+      {:media_exists, %Media{file: _file} = media} ->
+        Converter.Media.model_to_as(media)
 
       err ->
         err
     end
   end
 
-  def make_picture_data(nil), do: nil
+  def make_media_data(nil), do: nil
 
   @doc """
   Make announce activity data for the given actor and object

lib/federation/activity_stream/converter/event.ex

@@ -10,11 +10,11 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Event do
   alias Mobilizon.Addresses
   alias Mobilizon.Addresses.Address
   alias Mobilizon.Events.Event, as: EventModel
-  alias Mobilizon.Media.Picture
+  alias Mobilizon.Medias.Media
 
   alias Mobilizon.Federation.ActivityStream.{Converter, Convertible}
   alias Mobilizon.Federation.ActivityStream.Converter.Address, as: AddressConverter
-  alias Mobilizon.Federation.ActivityStream.Converter.Picture, as: PictureConverter
+  alias Mobilizon.Federation.ActivityStream.Converter.Media, as: MediaConverter
 
   import Mobilizon.Federation.ActivityStream.Converter.Utils,
     only: [
@@ -55,10 +55,10 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Event do
 
       picture_id =
         with true <- length(attachments) > 0,
-             {:ok, %Picture{id: picture_id}} <-
+             {:ok, %Media{id: picture_id}} <-
                attachments
                |> hd()
-               |> PictureConverter.find_or_create_picture(actor_id) do
+               |> MediaConverter.find_or_create_media(actor_id) do
           picture_id
         else
           _err ->
@@ -239,7 +239,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Event do
           res,
           "attachment",
           [],
-          &(&1 ++ [PictureConverter.model_to_as(event.picture)])
+          &(&1 ++ [MediaConverter.model_to_as(event.picture)])
         )
   end
 

lib/federation/activity_stream/converter/media.ex

@@ -0,0 +1,63 @@
+defmodule Mobilizon.Federation.ActivityStream.Converter.Media do
+  @moduledoc """
+  Media converter.
+
+  This module allows to convert events from ActivityStream format to our own
+  internal one, and back.
+  """
+
+  alias Mobilizon.Medias
+  alias Mobilizon.Medias.Media, as: MediaModel
+
+  alias Mobilizon.Web.Upload
+
+  @http_options [
+    ssl: [{:versions, [:"tlsv1.2"]}]
+  ]
+
+  @doc """
+  Convert a media struct to an ActivityStream representation.
+  """
+  @spec model_to_as(MediaModel.t()) :: map
+  def model_to_as(%MediaModel{file: file}) do
+    %{
+      "type" => "Document",
+      "mediaType" => file.content_type,
+      "url" => file.url,
+      "name" => file.name
+    }
+  end
+
+  @doc """
+  Save media data from raw data and return AS Link data.
+  """
+  def find_or_create_media(%{"type" => "Link", "href" => url}, actor_id),
+    do: find_or_create_media(url, actor_id)
+
+  def find_or_create_media(
+        %{"type" => "Document", "url" => media_url, "name" => name},
+        actor_id
+      )
+      when is_bitstring(media_url) do
+    with {:ok, %{body: body}} <- Tesla.get(media_url, opts: @http_options),
+         {:ok, %{name: name, url: url, content_type: content_type, size: size}} <-
+           Upload.store(%{body: body, name: name}),
+         {:media_exists, nil} <- {:media_exists, Medias.get_media_by_url(url)} do
+      Medias.create_media(%{
+        "file" => %{
+          "url" => url,
+          "name" => name,
+          "content_type" => content_type,
+          "size" => size
+        },
+        "actor_id" => actor_id
+      })
+    else
+      {:media_exists, %MediaModel{file: _file} = media} ->
+        {:ok, media}
+
+      err ->
+        err
+    end
+  end
+end

lib/federation/activity_stream/converter/picture.ex

@@ -1,63 +0,0 @@
-defmodule Mobilizon.Federation.ActivityStream.Converter.Picture do
-  @moduledoc """
-  Picture converter.
-
-  This module allows to convert events from ActivityStream format to our own
-  internal one, and back.
-  """
-
-  alias Mobilizon.Media
-  alias Mobilizon.Media.Picture, as: PictureModel
-
-  alias Mobilizon.Web.Upload
-
-  @http_options [
-    ssl: [{:versions, [:"tlsv1.2"]}]
-  ]
-
-  @doc """
-  Convert a picture struct to an ActivityStream representation.
-  """
-  @spec model_to_as(PictureModel.t()) :: map
-  def model_to_as(%PictureModel{file: file}) do
-    %{
-      "type" => "Document",
-      "mediaType" => file.content_type,
-      "url" => file.url,
-      "name" => file.name
-    }
-  end
-
-  @doc """
-  Save picture data from raw data and return AS Link data.
-  """
-  def find_or_create_picture(%{"type" => "Link", "href" => url}, actor_id),
-    do: find_or_create_picture(url, actor_id)
-
-  def find_or_create_picture(
-        %{"type" => "Document", "url" => picture_url, "name" => name},
-        actor_id
-      )
-      when is_bitstring(picture_url) do
-    with {:ok, %{body: body}} <- Tesla.get(picture_url, opts: @http_options),
-         {:ok, %{name: name, url: url, content_type: content_type, size: size}} <-
-           Upload.store(%{body: body, name: name}),
-         {:picture_exists, nil} <- {:picture_exists, Media.get_picture_by_url(url)} do
-      Media.create_picture(%{
-        "file" => %{
-          "url" => url,
-          "name" => name,
-          "content_type" => content_type,
-          "size" => size
-        },
-        "actor_id" => actor_id
-      })
-    else
-      {:picture_exists, %PictureModel{file: _file} = picture} ->
-        {:ok, picture}
-
-      err ->
-        err
-    end
-  end
-end