Fast indexing (#58)

* Made method to getting singular media details; Renamed other related method

* Takes a fun and flirty digression to remove abstractions around yt-dlp since I'm 100% committed to using it exclusively

* Removed commented test code

* Lays the groundwork for fast indexing

* Added module for working with youtube RSS feed

* Added methods to kick off indexing workers from RSS response

* Improve short detection (#59)

* Made media attribute-related yt-dlp calls return a struct

* Added shorts attribute to media items

* Added ability to discern a short from yt-dlp response

* Updated search to use new shorts attribute

* Fast index UI (#63)

* Added fast_index field and adds it to source form

* Added fast indexing to source changeset operations

* Added fast indexing worker and updated other modules to start using it

* Handled fast index worker on source update

* Add support modals (#65)

* Added fast indexing upgrade modal

* Improved modal on smaller screens

* Updated links to work again

* Added donation modal

* Reverted source fast index to 15 minutes

* Removed unneeded HTML attributes from old alpine approach

lib/pinchflat/metadata/metadata_file_helpers.ex

@@ -0,0 +1,72 @@
+defmodule Pinchflat.Metadata.MetadataFileHelpers do
+  @moduledoc """
+  Provides methods for creating/downloading/storing related metadata
+  out-of-band of the normal yt-dlp backend process.
+
+  The idea is that I don't want to craft a complicated yt-dlp command,
+  instead focusing on downloading the media as the user wants it then
+  I can use the result of that here to grab the additional information
+  needed
+  """
+
+  @doc """
+  Compresses and stores metadata for a media item, returning the filepath.
+
+  Returns binary()
+  """
+  def compress_and_store_metadata_for(database_record, metadata_map) do
+    filepath = generate_filepath_for(database_record, "metadata.json.gz")
+    {:ok, json} = Phoenix.json_library().encode(metadata_map)
+
+    File.mkdir_p!(Path.dirname(filepath))
+    :ok = File.write(filepath, json, [:compressed])
+
+    filepath
+  end
+
+  @doc """
+  Reads and decodes compressed metadata from a filepath.
+
+  Returns {:ok, map()} | {:error, any}
+  """
+  def read_compressed_metadata(filepath) do
+    {:ok, json} = File.open(filepath, [:read, :compressed], &IO.read(&1, :all))
+
+    Phoenix.json_library().decode(json)
+  end
+
+  @doc """
+  Downloads and stores a thumbnail for a media item, returning the filepath.
+
+  Returns binary()
+  """
+  def download_and_store_thumbnail_for(database_record, metadata_map) do
+    thumbnail_url = metadata_map["thumbnail"]
+    filepath = generate_filepath_for(database_record, Path.basename(thumbnail_url))
+    thumbnail_blob = fetch_thumbnail_from_url(thumbnail_url)
+
+    File.mkdir_p!(Path.dirname(filepath))
+    :ok = File.write(filepath, thumbnail_blob)
+
+    filepath
+  end
+
+  defp fetch_thumbnail_from_url(url) do
+    http_client = Application.get_env(:pinchflat, :http_client, Pinchflat.HTTP.HTTPClient)
+    {:ok, body} = http_client.get(url, [], body_format: :binary)
+
+    body
+  end
+
+  defp generate_filepath_for(database_record, filename) do
+    metadata_directory = Application.get_env(:pinchflat, :metadata_directory)
+    record_table_name = database_record.__meta__.source
+
+    Path.join([
+      metadata_directory,
+      record_table_name,
+      to_string(database_record.id),
+      filename
+    ])
+  end
+end