Bumped version

* Added OPML Endpoint for podcast rss feeds

* changed opml route and added controller test for opml endpoint

* add copy opml feed button

* add copy opml feed button - correct url

* fix html indenting

* add indentation to opml

Co-authored-by: Kieran <kieran.eglin@gmail.com>

* use convention for unused controller params

Co-authored-by: Kieran <kieran.eglin@gmail.com>

* add test for opml_sources helper function

* change opml endpoint to be more inline with the other routes

---------

Co-authored-by: robs <git@robs.social>
Co-authored-by: Kieran <kieran.eglin@gmail.com>

assets/js/alpine_helpers.js

@@ -35,3 +35,14 @@ window.markVersionAsSeen = (versionString) => {
 window.isVersionSeen = (versionString) => {
   return localStorage.getItem('seenVersion') === versionString
 }
+
+window.dispatchFor = (elementOrId, eventName, detail = {}) => {
+  const element =
+    typeof elementOrId === 'string' ? document.getElementById(elementOrId) : elementOrId
+
+  // This is needed to ensure the DOM has updated before dispatching the event.
+  // Doing so ensures that the latest DOM state is what's sent to the server
+  setTimeout(() => {
+    element.dispatchEvent(new Event(eventName, { bubbles: true, detail }))
+  }, 0)
+}

assets/js/app.js

@@ -39,7 +39,7 @@ let liveSocket = new LiveSocket(document.body.dataset.socketPath, Socket, {
     }
   },
   hooks: {
-    supressEnterSubmission: {
+    'supress-enter-submission': {
       mounted() {
         this.el.addEventListener('keypress', (event) => {
           if (event.key === 'Enter') {

config/runtime.exs

@@ -55,11 +55,16 @@ config :pinchflat, Oban,
   ]
 
 if config_env() == :prod do
-  config_path = "/config"
+  # Various paths. These ones shouldn't be tweaked if running in Docker
+  media_path = System.get_env("MEDIA_PATH", "/downloads")
+  config_path = System.get_env("CONFIG_PATH", "/config")
   db_path = System.get_env("DATABASE_PATH", Path.join([config_path, "db", "pinchflat.db"]))
   log_path = System.get_env("LOG_PATH", Path.join([config_path, "logs", "pinchflat.log"]))
   metadata_path = System.get_env("METADATA_PATH", Path.join([config_path, "metadata"]))
   extras_path = System.get_env("EXTRAS_PATH", Path.join([config_path, "extras"]))
+  tmpfile_path = System.get_env("TMPFILE_PATH", Path.join([System.tmp_dir!(), "pinchflat", "data"]))
+  # This one can be changed if you want
+  tz_data_path = System.get_env("TZ_DATA_PATH", Path.join([extras_path, "elixir_tz_data"]))
   # For running PF as a podcast host on self-hosted environments
   expose_feed_endpoints = String.length(System.get_env("EXPOSE_FEED_ENDPOINTS", "")) > 0
   # For testing alternate journal modes (see issue #137)
@@ -73,10 +78,10 @@ if config_env() == :prod do
   config :pinchflat,
     yt_dlp_executable: System.find_executable("yt-dlp"),
     apprise_executable: System.find_executable("apprise"),
-    media_directory: "/downloads",
+    media_directory: media_path,
     metadata_directory: metadata_path,
     extras_directory: extras_path,
-    tmpfile_directory: Path.join([System.tmp_dir!(), "pinchflat", "data"]),
+    tmpfile_directory: tmpfile_path,
     dns_cluster_query: System.get_env("DNS_CLUSTER_QUERY"),
     expose_feed_endpoints: expose_feed_endpoints,
     # This is configured in application.ex
@@ -84,7 +89,7 @@ if config_env() == :prod do
     log_path: log_path,
     base_route_path: base_route_path
 
-  config :tzdata, :data_dir, System.get_env("TZ_DATA_DIR", "/config/extras/elixir_tz_data")
+  config :tzdata, :data_dir, tz_data_path
 
   config :pinchflat, Pinchflat.Repo,
     database: db_path,

docker/selfhosted.Dockerfile

@@ -88,6 +88,7 @@ RUN apt-get update -y && \
       ca-certificates \
       python3-mutagen \
       curl \
+      zip \
       openssh-client \
       nano \
       python3 \
@@ -116,7 +117,8 @@ ENV LC_ALL en_US.UTF-8
 WORKDIR "/app"
 
 # Set up data volumes
-RUN mkdir /config /downloads /etc/elixir_tzdata_data && chmod ugo+rw /etc/elixir_tzdata_data
+RUN mkdir -p /config /downloads /etc/elixir_tzdata_data /etc/yt-dlp/plugins && \ 
+  chmod ugo+rw /etc/elixir_tzdata_data /etc/yt-dlp /etc/yt-dlp/plugins
 
 # set runner ENV
 ENV MIX_ENV="prod"

lib/pinchflat/boot/pre_job_startup_tasks.ex

@@ -16,6 +16,8 @@ defmodule Pinchflat.Boot.PreJobStartupTasks do
   alias Pinchflat.Settings
   alias Pinchflat.Utils.FilesystemUtils
 
+  alias Pinchflat.Lifecycle.UserScripts.CommandRunner, as: UserScriptRunner
+
   def start_link(opts \\ []) do
     GenServer.start_link(__MODULE__, %{}, opts)
   end
@@ -36,6 +38,7 @@ defmodule Pinchflat.Boot.PreJobStartupTasks do
     create_blank_yt_dlp_files()
     create_blank_user_script_file()
     apply_default_settings()
+    run_app_init_script()
 
     {:ok, state}
   end
@@ -95,6 +98,12 @@ defmodule Pinchflat.Boot.PreJobStartupTasks do
     Settings.set(apprise_version: apprise_version)
   end
 
+  defp run_app_init_script do
+    runner = Application.get_env(:pinchflat, :user_script_runner, UserScriptRunner)
+
+    runner.run(:app_init, %{})
+  end
+
   defp yt_dlp_runner do
     Application.get_env(:pinchflat, :yt_dlp_runner)
   end

lib/pinchflat/downloading/download_option_builder.ex

@@ -4,10 +4,10 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilder do
   """
 
   alias Pinchflat.Sources
-  alias Pinchflat.Settings
   alias Pinchflat.Sources.Source
   alias Pinchflat.Media.MediaItem
   alias Pinchflat.Downloading.OutputPathBuilder
+  alias Pinchflat.Downloading.QualityOptionBuilder
 
   alias Pinchflat.Utils.FilesystemUtils, as: FSUtils
 
@@ -34,21 +34,38 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilder do
 
   @doc """
   Builds the output path for yt-dlp to download media based on the given source's
-  media profile. Uses the source's override output path template if it exists.
+  or media_item's media profile. Uses the source's override output path template if it exists.
 
   Accepts a %MediaItem{} or %Source{} struct. If a %Source{} struct is passed, it
   will use a default %MediaItem{} struct with the given source.
 
   Returns binary()
   """
+  def build_output_path_for(%Source{} = source_with_preloads) do
+    build_output_path_for(%MediaItem{source: source_with_preloads})
+  end
+
   def build_output_path_for(%MediaItem{} = media_item_with_preloads) do
     output_path_template = Sources.output_path_template(media_item_with_preloads.source)
 
     build_output_path(output_path_template, media_item_with_preloads)
   end
 
-  def build_output_path_for(%Source{} = source_with_preloads) do
-    build_output_path_for(%MediaItem{source: source_with_preloads})
+  @doc """
+  Builds the quality options for yt-dlp to download media based on the given source's
+  or media_item's media profile. Useful for helping predict final filepath of downloaded
+  media.
+
+  returns [Keyword.t()]
+  """
+  def build_quality_options_for(%Source{} = source_with_preloads) do
+    build_quality_options_for(%MediaItem{source: source_with_preloads})
+  end
+
+  def build_quality_options_for(%MediaItem{} = media_item_with_preloads) do
+    media_profile = media_item_with_preloads.source.media_profile
+
+    quality_options(media_profile)
   end
 
   defp default_options(override_opts) do
@@ -125,27 +142,7 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilder do
   end
 
   defp quality_options(media_profile) do
-    vcodec = Settings.get!(:video_codec_preference)
-    acodec = Settings.get!(:audio_codec_preference)
-    container = media_profile.media_container
-
-    case media_profile.preferred_resolution do
-      # Also be aware that :audio disabled all embedding options for subtitles
-      :audio ->
-        [:extract_audio, format_sort: "+acodec:#{acodec}", audio_format: container || "best"]
-
-      resolution_atom ->
-        {resolution_string, _} =
-          resolution_atom
-          |> Atom.to_string()
-          |> Integer.parse()
-
-        [
-          # Since Plex doesn't support reading metadata from MKV
-          remux_video: container || "mp4",
-          format_sort: "res:#{resolution_string},+codec:#{vcodec}:#{acodec}"
-        ]
-    end
+    QualityOptionBuilder.build(media_profile)
   end
 
   defp sponsorblock_options(media_profile) do

lib/pinchflat/downloading/media_download_worker.ex

@@ -94,6 +94,9 @@ defmodule Pinchflat.Downloading.MediaDownloadWorker do
       {:recovered, _} ->
         {:error, :retry}
 
+      {:error, :unsuitable_for_download} ->
+        {:ok, :non_retry}
+
       {:error, message} ->
         action_on_error(message)
     end

lib/pinchflat/downloading/media_downloader.ex

@@ -37,6 +37,13 @@ defmodule Pinchflat.Downloading.MediaDownloader do
       {:ok, parsed_json} ->
         update_media_item_from_parsed_json(media_with_preloads, parsed_json)
 
+      {:error, :unsuitable_for_download} ->
+        Logger.warning(
+          "Media item ##{media_with_preloads.id} isn't suitable for download yet. May be an active or processing live stream"
+        )
+
+        {:error, :unsuitable_for_download}
+
       {:error, message, _exit_code} ->
         Logger.error("yt-dlp download error for media item ##{media_with_preloads.id}: #{inspect(message)}")
 
@@ -106,9 +113,14 @@ defmodule Pinchflat.Downloading.MediaDownloader do
 
   defp download_with_options(url, item_with_preloads, output_filepath, override_opts) do
     {:ok, options} = DownloadOptionBuilder.build(item_with_preloads, override_opts)
-    runner_opts = [output_filepath: output_filepath, use_cookies: item_with_preloads.source.use_cookies]
+    use_cookies = item_with_preloads.source.use_cookies
+    runner_opts = [output_filepath: output_filepath, use_cookies: use_cookies]
 
-    YtDlpMedia.download(url, options, runner_opts)
+    case YtDlpMedia.get_downloadable_status(url, use_cookies: use_cookies) do
+      {:ok, :downloadable} -> YtDlpMedia.download(url, options, runner_opts)
+      {:ok, :ignorable} -> {:error, :unsuitable_for_download}
+      err -> err
+    end
   end
 
   defp recoverable_errors do

lib/pinchflat/downloading/quality_option_builder.ex

@@ -0,0 +1,66 @@
+defmodule Pinchflat.Downloading.QualityOptionBuilder do
+  @moduledoc """
+  A standalone builder module for building quality-related options for yt-dlp to download media.
+
+  Currently exclusively used in DownloadOptionBuilder since this logic is too complex to just
+  place in the main module.
+  """
+
+  alias Pinchflat.Settings
+  alias Pinchflat.Profiles.MediaProfile
+
+  @doc """
+  Builds the quality-related options for yt-dlp to download media based on the given media profile
+
+  Includes things like container, preferred format/codec, and audio track options.
+  """
+  def build(%MediaProfile{preferred_resolution: :audio, media_container: container} = media_profile) do
+    acodec = Settings.get!(:audio_codec_preference)
+
+    [
+      :extract_audio,
+      format_sort: "+acodec:#{acodec}",
+      audio_format: container || "best",
+      format: build_format_string(media_profile)
+    ]
+  end
+
+  def build(%MediaProfile{preferred_resolution: resolution_atom, media_container: container} = media_profile) do
+    vcodec = Settings.get!(:video_codec_preference)
+    acodec = Settings.get!(:audio_codec_preference)
+    {resolution_string, _} = resolution_atom |> Atom.to_string() |> Integer.parse()
+
+    [
+      # Since Plex doesn't support reading metadata from MKV
+      remux_video: container || "mp4",
+      format_sort: "res:#{resolution_string},+codec:#{vcodec}:#{acodec}",
+      format: build_format_string(media_profile)
+    ]
+  end
+
+  defp build_format_string(%MediaProfile{preferred_resolution: :audio, audio_track: audio_track}) do
+    if audio_track do
+      "bestaudio[#{build_format_modifier(audio_track)}]/bestaudio/best"
+    else
+      "bestaudio/best"
+    end
+  end
+
+  defp build_format_string(%MediaProfile{audio_track: audio_track}) do
+    if audio_track do
+      "bestvideo+bestaudio[#{build_format_modifier(audio_track)}]/bestvideo*+bestaudio/best"
+    else
+      "bestvideo*+bestaudio/best"
+    end
+  end
+
+  # Reminder to self: this conflicts with `--extractor-args "youtube:lang=<LANG>"`
+  # since that will translate the format_notes as well, which means they may not match.
+  # At least that's what happens now - worth a re-check if I have to come back to this
+  defp build_format_modifier("original"), do: "format_note*=original"
+  defp build_format_modifier("default"), do: "format_note*='(default)'"
+  # This uses the carat to anchor the language to the beginning of the string
+  # since that's what's needed to match `en` to `en-US` and `en-GB`, etc. The user
+  # can always specify the full language code if they want.
+  defp build_format_modifier(language_code), do: "language^=#{language_code}"
+end

lib/pinchflat/fast_indexing/fast_indexing_helpers.ex

@@ -11,13 +11,27 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpers do
 
   alias Pinchflat.Repo
   alias Pinchflat.Media
+  alias Pinchflat.Tasks
   alias Pinchflat.Sources.Source
   alias Pinchflat.FastIndexing.YoutubeRss
   alias Pinchflat.FastIndexing.YoutubeApi
   alias Pinchflat.Downloading.DownloadingHelpers
+  alias Pinchflat.FastIndexing.FastIndexingWorker
+  alias Pinchflat.Downloading.DownloadOptionBuilder
 
   alias Pinchflat.YtDlp.Media, as: YtDlpMedia
 
+  @doc """
+  Kicks off a new fast indexing task for a source. This will delete any existing fast indexing
+  tasks for the source before starting a new one.
+
+  Returns {:ok, %Task{}}
+  """
+  def kickoff_indexing_task(%Source{} = source) do
+    Tasks.delete_pending_tasks_for(source, "FastIndexingWorker", include_executing: true)
+    FastIndexingWorker.kickoff_with_task(source)
+  end
+
   @doc """
   Fetches new media IDs for a source from YT's API or RSS, indexes them, and kicks off downloading
   tasks for any pending media items. See comments in `FastIndexingWorker` for more info on the
@@ -27,6 +41,10 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpers do
   downloaded_.
   """
   def kickoff_download_tasks_from_youtube_rss_feed(%Source{} = source) do
+    # The media_profile is needed to determine the quality options to _then_ determine a more
+    # accurate predicted filepath
+    source = Repo.preload(source, [:media_profile])
+
     {:ok, media_ids} = get_recent_media_ids(source)
     existing_media_items = list_media_items_by_media_id_for(source, media_ids)
     new_media_ids = media_ids -- Enum.map(existing_media_items, & &1.media_id)
@@ -68,7 +86,11 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpers do
   defp create_media_item_from_media_id(source, media_id) do
     url = "https://www.youtube.com/watch?v=#{media_id}"
 
-    case YtDlpMedia.get_media_attributes(url, use_cookies: source.use_cookies) do
+    command_opts =
+      [output: DownloadOptionBuilder.build_output_path_for(source)] ++
+        DownloadOptionBuilder.build_quality_options_for(source)
+
+    case YtDlpMedia.get_media_attributes(url, command_opts, use_cookies: source.use_cookies) do
       {:ok, media_attrs} ->
         Media.create_media_item_from_backend_attrs(source, media_attrs)
 

lib/pinchflat/lifecycle/user_scripts/command_runner.ex

@@ -12,6 +12,7 @@ defmodule Pinchflat.Lifecycle.UserScripts.CommandRunner do
   @behaviour UserScriptCommandRunner
 
   @event_types [
+    :app_init,
     :media_pre_download,
     :media_downloaded,
     :media_deleted

lib/pinchflat/media/media_item.ex

@@ -31,6 +31,7 @@ defmodule Pinchflat.Media.MediaItem do
     :uploaded_at,
     :upload_date_index,
     :duration_seconds,
+    :predicted_media_filepath,
     # these fields are captured only on download
     :media_downloaded_at,
     :media_filepath,
@@ -76,6 +77,7 @@ defmodule Pinchflat.Media.MediaItem do
     field :duration_seconds, :integer
     field :playlist_index, :integer, default: 0
 
+    field :predicted_media_filepath, :string
     field :media_filepath, :string
     field :media_size_bytes, :integer
     field :thumbnail_filepath, :string

lib/pinchflat/podcasts/opml_feed_builder.ex

@@ -0,0 +1,40 @@
+defmodule Pinchflat.Podcasts.OpmlFeedBuilder do
+  @moduledoc """
+  Methods for building an OPML feed for a list of sources.
+  """
+
+  import Pinchflat.Utils.XmlUtils, only: [safe: 1]
+
+  alias PinchflatWeb.Router.Helpers, as: Routes
+
+  @doc """
+  Builds an OPML feed for a given list of sources.
+
+  Returns an XML document as a string.
+  """
+  def build(url_base, sources) do
+    sources_xml =
+      Enum.map(
+        sources,
+        &"""
+        <outline type="rss" text="#{safe(&1.custom_name)}" xmlUrl="#{safe(source_route(url_base, &1))}" />
+        """
+      )
+
+    """
+    <?xml version="1.0" encoding="UTF-8"?>
+    <opml version="2.0">
+      <head>
+        <title>All Sources</title>
+      </head>
+      <body>
+        #{Enum.join(sources_xml, "\n")}
+      </body>
+    </opml>
+    """
+  end
+
+  defp source_route(url_base, source) do
+    Path.join(url_base, "#{Routes.podcast_path(PinchflatWeb.Endpoint, :rss_feed, source.uuid)}.xml")
+  end
+end

lib/pinchflat/podcasts/podcast_helpers.ex

@@ -5,11 +5,25 @@ defmodule Pinchflat.Podcasts.PodcastHelpers do
   """
 
   use Pinchflat.Media.MediaQuery
+  use Pinchflat.Sources.SourcesQuery
 
   alias Pinchflat.Repo
   alias Pinchflat.Metadata.MediaMetadata
   alias Pinchflat.Metadata.SourceMetadata
 
+  @doc """
+  Returns a list of sources that are not marked for deletion.
+
+  Returns: [%Source{}]
+  """
+  def opml_sources() do
+    SourcesQuery.new()
+    |> select([s], %{custom_name: s.custom_name, uuid: s.uuid})
+    |> where([s], is_nil(s.marked_for_deletion_at))
+    |> order_by(asc: :custom_name)
+    |> Repo.all()
+  end
+
   @doc """
   Returns a list of media items that have been downloaded to disk
   and have been proven to still exist there.

lib/pinchflat/profiles/media_profile.ex

@@ -26,6 +26,7 @@ defmodule Pinchflat.Profiles.MediaProfile do
     sponsorblock_categories
     shorts_behaviour
     livestream_behaviour
+    audio_track
     preferred_resolution
     media_container
     redownload_delay_days
@@ -65,7 +66,8 @@ defmodule Pinchflat.Profiles.MediaProfile do
     # See `build_format_clauses` in the Media context for more.
     field :shorts_behaviour, Ecto.Enum, values: ~w(include exclude only)a, default: :include
     field :livestream_behaviour, Ecto.Enum, values: ~w(include exclude only)a, default: :include
-    field :preferred_resolution, Ecto.Enum, values: ~w(4320p 2160p 1080p 720p 480p 360p audio)a, default: :"1080p"
+    field :audio_track, :string
+    field :preferred_resolution, Ecto.Enum, values: ~w(4320p 2160p 1440p 1080p 720p 480p 360p audio)a, default: :"1080p"
     field :media_container, :string, default: nil
 
     field :marked_for_deletion_at, :utc_datetime

lib/pinchflat/profiles/profiles_query.ex

@@ -0,0 +1,29 @@
+defmodule Pinchflat.Profiles.ProfilesQuery do
+  @moduledoc """
+  Query helpers for the Profiles context.
+
+  These methods are made to be one-ish liners used
+  to compose queries. Each method should strive to do
+  _one_ thing. These don't need to be tested as
+  they are just building blocks for other functionality
+  which, itself, will be tested.
+  """
+  import Ecto.Query, warn: false
+
+  alias Pinchflat.Profiles.MediaProfile
+
+  # This allows the module to be aliased and query methods to be used
+  # all in one go
+  # usage: use Pinchflat.Profiles.ProfilesQuery
+  defmacro __using__(_opts) do
+    quote do
+      import Ecto.Query, warn: false
+
+      alias unquote(__MODULE__)
+    end
+  end
+
+  def new do
+    MediaProfile
+  end
+end

lib/pinchflat/release.ex

@@ -29,6 +29,8 @@ defmodule Pinchflat.Release do
       [
         "/config",
         "/downloads",
+        "/etc/yt-dlp",
+        "/etc/yt-dlp/plugins",
         Application.get_env(:pinchflat, :media_directory),
         Application.get_env(:pinchflat, :tmpfile_directory),
         Application.get_env(:pinchflat, :extras_directory),

lib/pinchflat/slow_indexing/slow_indexing_helpers.ex

@@ -16,6 +16,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
   alias Pinchflat.YtDlp.MediaCollection
   alias Pinchflat.Downloading.DownloadingHelpers
   alias Pinchflat.SlowIndexing.FileFollowerServer
+  alias Pinchflat.Downloading.DownloadOptionBuilder
   alias Pinchflat.SlowIndexing.MediaCollectionIndexingWorker
 
   alias Pinchflat.YtDlp.Media, as: YtDlpMedia
@@ -24,13 +25,28 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
   Starts tasks for indexing a source's media regardless of the source's indexing
   frequency. It's assumed the caller will check for indexing frequency.
 
-  Returns {:ok, %Task{}}.
+  Returns {:ok, %Task{}}
   """
   def kickoff_indexing_task(%Source{} = source, job_args \\ %{}, job_opts \\ []) do
+    job_offset_seconds = calculate_job_offset_seconds(source)
+
     Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
     Tasks.delete_pending_tasks_for(source, "MediaCollectionIndexingWorker", include_executing: true)
 
-    MediaCollectionIndexingWorker.kickoff_with_task(source, job_args, job_opts)
+    MediaCollectionIndexingWorker.kickoff_with_task(source, job_args, job_opts ++ [schedule_in: job_offset_seconds])
+  end
+
+  @doc """
+  A helper method to delete all indexing-related tasks for a source.
+  Optionally, you can include executing tasks in the deletion process.
+
+  Returns :ok
+  """
+  def delete_indexing_tasks(%Source{} = source, opts \\ []) do
+    include_executing = Keyword.get(opts, :include_executing, false)
+
+    Tasks.delete_pending_tasks_for(source, "FastIndexingWorker", include_executing: include_executing)
+    Tasks.delete_pending_tasks_for(source, "MediaCollectionIndexingWorker", include_executing: include_executing)
   end
 
   @doc """
@@ -56,6 +72,9 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
   Returns [%MediaItem{} | %Ecto.Changeset{}]
   """
   def index_and_enqueue_download_for_media_items(%Source{} = source) do
+    # The media_profile is needed to determine the quality options to _then_ determine a more
+    # accurate predicted filepath
+    source = Repo.preload(source, [:media_profile])
     # See the method definition below for more info on how file watchers work
     # (important reading if you're not familiar with it)
     {:ok, media_attributes} = setup_file_watcher_and_kickoff_indexing(source)
@@ -94,8 +113,13 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
     {:ok, pid} = FileFollowerServer.start_link()
 
     handler = fn filepath -> setup_file_follower_watcher(pid, filepath, source) end
+
+    command_opts =
+      [output: DownloadOptionBuilder.build_output_path_for(source)] ++
+        DownloadOptionBuilder.build_quality_options_for(source)
+
     runner_opts = [file_listener_handler: handler, use_cookies: source.use_cookies]
-    result = MediaCollection.get_media_attributes_for_collection(source.original_url, runner_opts)
+    result = MediaCollection.get_media_attributes_for_collection(source.original_url, command_opts, runner_opts)
 
     FileFollowerServer.stop(pid)
 
@@ -132,4 +156,14 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
         changeset
     end
   end
+
+  # Find the difference between the current time and the last time the source was indexed
+  defp calculate_job_offset_seconds(%Source{last_indexed_at: nil}), do: 0
+
+  defp calculate_job_offset_seconds(source) do
+    offset_seconds = DateTime.diff(DateTime.utc_now(), source.last_indexed_at, :second)
+    index_frequency_seconds = source.index_frequency_minutes * 60
+
+    max(0, index_frequency_seconds - offset_seconds)
+  end
 end

lib/pinchflat/sources/source.ex

@@ -15,6 +15,7 @@ defmodule Pinchflat.Sources.Source do
   alias Pinchflat.Metadata.SourceMetadata
 
   @allowed_fields ~w(
+    enabled
     collection_name
     collection_id
     collection_type
@@ -64,6 +65,7 @@ defmodule Pinchflat.Sources.Source do
                                 )a
 
   schema "sources" do
+    field :enabled, :boolean, default: true
     # This is _not_ used as the primary key or internally in the database
     # relations. This is only used to prevent an enumeration attack on the streaming
     # and RSS feed endpoints since those _must_ be public (ie: no basic auth)

lib/pinchflat/sources/sources.ex

@@ -15,8 +15,8 @@ defmodule Pinchflat.Sources do
   alias Pinchflat.Metadata.SourceMetadata
   alias Pinchflat.Utils.FilesystemUtils
   alias Pinchflat.Downloading.DownloadingHelpers
-  alias Pinchflat.FastIndexing.FastIndexingWorker
   alias Pinchflat.SlowIndexing.SlowIndexingHelpers
+  alias Pinchflat.FastIndexing.FastIndexingHelpers
   alias Pinchflat.Metadata.SourceMetadataStorageWorker
 
   @doc """
@@ -255,19 +255,40 @@ defmodule Pinchflat.Sources do
     end
   end
 
-  # If the source is NOT new (ie: updated) and the download_media flag has changed,
+  # If the source is new (ie: not persisted), do nothing
+  defp maybe_handle_media_tasks(%{data: %{__meta__: %{state: state}}}, _source) when state != :loaded do
+    :ok
+  end
+
+  # If the source is NOT new (ie: updated),
   # enqueue or dequeue media download tasks as necessary.
   defp maybe_handle_media_tasks(changeset, source) do
-    case {changeset.data, changeset.changes} do
-      {%{__meta__: %{state: :loaded}}, %{download_media: true}} ->
+    current_changes = changeset.changes
+    applied_changes = Ecto.Changeset.apply_changes(changeset)
+
+    # We need both current_changes and applied_changes to determine
+    # the course of action to take. For example, we only care if a source is supposed
+    # to be `enabled` or not - we don't care if that information comes from the
+    # current changes or if that's how it already was in the database.
+    # Rephrased, we're essentially using it in place of `get_field/2`
+    case {current_changes, applied_changes} do
+      {%{download_media: true}, %{enabled: true}} ->
         DownloadingHelpers.enqueue_pending_download_tasks(source)
 
-      {%{__meta__: %{state: :loaded}}, %{download_media: false}} ->
+      {%{enabled: true}, %{download_media: true}} ->
+        DownloadingHelpers.enqueue_pending_download_tasks(source)
+
+      {%{download_media: false}, _} ->
+        DownloadingHelpers.dequeue_pending_download_tasks(source)
+
+      {%{enabled: false}, _} ->
         DownloadingHelpers.dequeue_pending_download_tasks(source)
 
       _ ->
-        :ok
+        nil
     end
+
+    :ok
   end
 
   defp maybe_run_indexing_task(changeset, source) do
@@ -301,13 +322,22 @@ defmodule Pinchflat.Sources do
   end
 
   defp maybe_update_slow_indexing_task(changeset, source) do
-    case changeset.changes do
-      %{index_frequency_minutes: mins} when mins > 0 ->
+    # See comment in `maybe_handle_media_tasks` as to why we need these
+    current_changes = changeset.changes
+    applied_changes = Ecto.Changeset.apply_changes(changeset)
+
+    case {current_changes, applied_changes} do
+      {%{index_frequency_minutes: mins}, %{enabled: true}} when mins > 0 ->
         SlowIndexingHelpers.kickoff_indexing_task(source)
 
-      %{index_frequency_minutes: _} ->
-        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
-        Tasks.delete_pending_tasks_for(source, "MediaCollectionIndexingWorker")
+      {%{enabled: true}, %{index_frequency_minutes: mins}} when mins > 0 ->
+        SlowIndexingHelpers.kickoff_indexing_task(source)
+
+      {%{index_frequency_minutes: _}, _} ->
+        SlowIndexingHelpers.delete_indexing_tasks(source, include_executing: true)
+
+      {%{enabled: false}, _} ->
+        SlowIndexingHelpers.delete_indexing_tasks(source, include_executing: true)
 
       _ ->
         :ok
@@ -315,13 +345,25 @@ defmodule Pinchflat.Sources do
   end
 
   defp maybe_update_fast_indexing_task(changeset, source) do
-    case changeset.changes do
-      %{fast_index: true} ->
-        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
-        FastIndexingWorker.kickoff_with_task(source)
+    # See comment in `maybe_handle_media_tasks` as to why we need these
+    current_changes = changeset.changes
+    applied_changes = Ecto.Changeset.apply_changes(changeset)
 
-      %{fast_index: false} ->
-        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
+    # This technically could be simplified since `maybe_update_slow_indexing_task`
+    # has some overlap re: deleting pending tasks, but I'm keeping it separate
+    # for clarity and explicitness.
+    case {current_changes, applied_changes} do
+      {%{fast_index: true}, %{enabled: true}} ->
+        FastIndexingHelpers.kickoff_indexing_task(source)
+
+      {%{enabled: true}, %{fast_index: true}} ->
+        FastIndexingHelpers.kickoff_indexing_task(source)
+
+      {%{fast_index: false}, _} ->
+        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker", include_executing: true)
+
+      {%{enabled: false}, _} ->
+        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker", include_executing: true)
 
       _ ->
         :ok

lib/pinchflat/utils/string_utils.ex

@@ -26,19 +26,13 @@ defmodule Pinchflat.Utils.StringUtils do
   end
 
   @doc """
-  Truncates a string to the given length and adds `...` if the string is longer than the given length.
-  Will break on a word boundary. Nothing happens if the string is shorter than the given length.
+  Wraps a string in double braces. Useful as a UI helper now that
+  LiveView 1.0.0 allows `{}` for interpolation so now we can't use braces
+  directly in the view.
 
   Returns binary()
   """
-  def truncate(string, length) do
-    if String.length(string) > length do
-      string
-      |> String.slice(0..(length - 1))
-      |> String.replace(~r/\s+\S*$/, "")
-      |> Kernel.<>("...")
-    else
-      string
-    end
+  def double_brace(string) do
+    "{{ #{string} }}"
   end
 end

lib/pinchflat/yt_dlp/command_runner.ex

@@ -3,6 +3,8 @@ defmodule Pinchflat.YtDlp.CommandRunner do
   Runs yt-dlp commands using the `System.cmd/3` function
   """
 
+  require Logger
+
   alias Pinchflat.Utils.CliUtils
   alias Pinchflat.YtDlp.YtDlpCommandRunner
   alias Pinchflat.Utils.FilesystemUtils, as: FSUtils
@@ -24,7 +26,8 @@ defmodule Pinchflat.YtDlp.CommandRunner do
   Returns {:ok, binary()} | {:error, output, status}.
   """
   @impl YtDlpCommandRunner
-  def run(url, command_opts, output_template, addl_opts \\ []) do
+  def run(url, action_name, command_opts, output_template, addl_opts \\ []) do
+    Logger.debug("Running yt-dlp command for action: #{action_name}")
     # This approach lets us mock the command for testing
     command = backend_executable()
 

lib/pinchflat/yt_dlp/media.ex

@@ -11,7 +11,8 @@ defmodule Pinchflat.YtDlp.Media do
     :livestream,
     :short_form_content,
     :uploaded_at,
-    :duration_seconds
+    :duration_seconds,
+    :predicted_media_filepath
   ]
 
   defstruct [
@@ -23,7 +24,8 @@ defmodule Pinchflat.YtDlp.Media do
     :short_form_content,
     :uploaded_at,
     :duration_seconds,
-    :playlist_index
+    :playlist_index,
+    :predicted_media_filepath
   ]
 
   alias __MODULE__
@@ -39,7 +41,7 @@ defmodule Pinchflat.YtDlp.Media do
   def download(url, command_opts \\ [], addl_opts \\ []) do
     all_command_opts = [:no_simulate] ++ command_opts
 
-    with {:ok, output} <- backend_runner().run(url, all_command_opts, "after_move:%()j", addl_opts),
+    with {:ok, output} <- backend_runner().run(url, :download, all_command_opts, "after_move:%()j", addl_opts),
          {:ok, parsed_json} <- Phoenix.json_library().decode(output) do
       {:ok, parsed_json}
     else
@@ -47,6 +49,27 @@ defmodule Pinchflat.YtDlp.Media do
     end
   end
 
+  @doc """
+  Determines if the media at the given URL is ready to be downloaded.
+  Common examples of non-downloadable media are upcoming or in-progress live streams.
+
+  Returns {:ok, :downloadable | :ignorable} | {:error, any}
+  """
+  def get_downloadable_status(url, addl_opts \\ []) do
+    action = :get_downloadable_status
+    command_opts = [:simulate, :skip_download]
+
+    case backend_runner().run(url, action, command_opts, "%(.{live_status})j", addl_opts) do
+      {:ok, output} ->
+        output
+        |> Phoenix.json_library().decode!()
+        |> parse_downloadable_status()
+
+      err ->
+        err
+    end
+  end
+
   @doc """
   Downloads a thumbnail for a single piece of media. Usually used for
   downloading thumbnails for internal use
@@ -58,20 +81,21 @@ defmodule Pinchflat.YtDlp.Media do
 
     # NOTE: it doesn't seem like this command actually returns anything in `after_move` since
     # we aren't downloading the main media file
-    backend_runner().run(url, all_command_opts, "after_move:%()j", addl_opts)
+    backend_runner().run(url, :download_thumbnail, all_command_opts, "after_move:%()j", addl_opts)
   end
 
   @doc """
   Returns a map representing the media at the given URL.
+  Optionally takes a list of additional command options to pass to yt-dlp
+  or configuration-related options to pass to the runner.
 
   Returns {:ok, %Media{}} | {:error, any, ...}.
   """
-  def get_media_attributes(url, addl_opts \\ []) do
-    runner = Application.get_env(:pinchflat, :yt_dlp_runner)
-    command_opts = [:simulate, :skip_download]
+  def get_media_attributes(url, command_opts \\ [], addl_opts \\ []) do
+    all_command_opts = [:simulate, :skip_download] ++ command_opts
     output_template = indexing_output_template()
 
-    case runner.run(url, command_opts, output_template, addl_opts) do
+    case backend_runner().run(url, :get_media_attributes, all_command_opts, output_template, addl_opts) do
       {:ok, output} ->
         output
         |> Phoenix.json_library().decode!()
@@ -91,7 +115,7 @@ defmodule Pinchflat.YtDlp.Media do
         if something is a short via the URL again
   """
   def indexing_output_template do
-    "%(.{id,title,live_status,original_url,description,aspect_ratio,duration,upload_date,timestamp,playlist_index})j"
+    "%(.{id,title,live_status,original_url,description,aspect_ratio,duration,upload_date,timestamp,playlist_index,filename})j"
   end
 
   @doc """
@@ -110,7 +134,8 @@ defmodule Pinchflat.YtDlp.Media do
       duration_seconds: response["duration"] && round(response["duration"]),
       short_form_content: response["original_url"] && short_form_content?(response),
       uploaded_at: response["upload_date"] && parse_uploaded_at(response),
-      playlist_index: response["playlist_index"] || 0
+      playlist_index: response["playlist_index"] || 0,
+      predicted_media_filepath: response["filename"]
     }
   end
 
@@ -142,6 +167,16 @@ defmodule Pinchflat.YtDlp.Media do
   defp parse_uploaded_at(%{"upload_date" => nil}), do: nil
   defp parse_uploaded_at(response), do: MetadataFileHelpers.parse_upload_date(response["upload_date"])
 
+  defp parse_downloadable_status(response) do
+    case response["live_status"] do
+      status when status in ["is_live", "is_upcoming", "post_live"] -> {:ok, :ignorable}
+      status when status in ["was_live", "not_live"] -> {:ok, :downloadable}
+      # This preserves my tenuous support for non-youtube sources.
+      nil -> {:ok, :downloadable}
+      _ -> {:error, "Unknown live status: #{response["live_status"]}"}
+    end
+  end
+
   defp backend_runner do
     # This approach lets us mock the command for testing
     Application.get_env(:pinchflat, :yt_dlp_runner)

lib/pinchflat/yt_dlp/media_collection.ex

@@ -11,31 +11,35 @@ defmodule Pinchflat.YtDlp.MediaCollection do
 
   @doc """
   Returns a list of maps representing the media in the collection.
+  Optionally takes a list of additional command options to pass to yt-dlp
+  or configuration-related options to pass to the runner.
 
-  Options:
+  Runner Options:
     - :file_listener_handler - a function that will be called with the path to the
       file that will be written to when yt-dlp is done. This is useful for
       setting up a file watcher to know when the file is ready to be read.
+    - :use_cookies - whether or not to use user-provided cookies when fetching the media details
 
   Returns {:ok, [map()]} | {:error, any, ...}.
   """
-  def get_media_attributes_for_collection(url, addl_opts \\ []) do
+  def get_media_attributes_for_collection(url, command_opts \\ [], addl_opts \\ []) do
     runner = Application.get_env(:pinchflat, :yt_dlp_runner)
     # `ignore_no_formats_error` is necessary because yt-dlp will error out if
     # the first video has not released yet (ie: is a premier). We don't care about
     # available formats since we're just getting the media details
-    command_opts = [:simulate, :skip_download, :ignore_no_formats_error, :no_warnings]
+    all_command_opts = [:simulate, :skip_download, :ignore_no_formats_error, :no_warnings] ++ command_opts
     use_cookies = Keyword.get(addl_opts, :use_cookies, false)
     output_template = YtDlpMedia.indexing_output_template()
     output_filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
     file_listener_handler = Keyword.get(addl_opts, :file_listener_handler, false)
     runner_opts = [output_filepath: output_filepath, use_cookies: use_cookies]
+    action = :get_media_attributes_for_collection
 
     if file_listener_handler do
       file_listener_handler.(output_filepath)
     end
 
-    case runner.run(url, command_opts, output_template, runner_opts) do
+    case runner.run(url, action, all_command_opts, output_template, runner_opts) do
       {:ok, output} ->
         parsed_lines =
           output
@@ -79,8 +83,9 @@ defmodule Pinchflat.YtDlp.MediaCollection do
 
     all_command_opts = default_opts ++ command_opts
     output_template = "%(.{channel,channel_id,playlist_id,playlist_title,filename})j"
+    action = :get_source_details
 
-    with {:ok, output} <- backend_runner().run(source_url, all_command_opts, output_template, addl_opts),
+    with {:ok, output} <- backend_runner().run(source_url, action, all_command_opts, output_template, addl_opts),
          {:ok, parsed_json} <- Phoenix.json_library().decode(output) do
       {:ok, format_source_details(parsed_json)}
     else
@@ -118,8 +123,9 @@ defmodule Pinchflat.YtDlp.MediaCollection do
 
     all_command_opts = [:skip_download] ++ command_opts
     output_template = "playlist:%()j"
+    action = :get_source_metadata
 
-    with {:ok, output} <- backend_runner().run(source_url, all_command_opts, output_template, addl_opts),
+    with {:ok, output} <- backend_runner().run(source_url, action, all_command_opts, output_template, addl_opts),
          {:ok, parsed_json} <- Phoenix.json_library().decode(output) do
       {:ok, parsed_json}
     else

lib/pinchflat/yt_dlp/yt_dlp_command_runner.ex

@@ -6,7 +6,7 @@ defmodule Pinchflat.YtDlp.YtDlpCommandRunner do
   yt-dlp command.
   """
 
-  @callback run(binary(), keyword(), binary()) :: {:ok, binary()} | {:error, binary(), integer()}
-  @callback run(binary(), keyword(), binary(), keyword()) :: {:ok, binary()} | {:error, binary(), integer()}
+  @callback run(binary(), atom(), keyword(), binary()) :: {:ok, binary()} | {:error, binary(), integer()}
+  @callback run(binary(), atom(), keyword(), binary(), keyword()) :: {:ok, binary()} | {:error, binary(), integer()}
   @callback version() :: {:ok, binary()} | {:error, binary()}
 end

lib/pinchflat_web.ex

@@ -100,6 +100,7 @@ defmodule PinchflatWeb do
       import PinchflatWeb.CustomComponents.TextComponents
       import PinchflatWeb.CustomComponents.TableComponents
       import PinchflatWeb.CustomComponents.ButtonComponents
+      import Pinchflat.Utils.StringUtils, only: [double_brace: 1]
 
       alias Pinchflat.Settings
       alias Pinchflat.Utils.StringUtils

lib/pinchflat_web/components/core_components.ex

@@ -82,7 +82,7 @@ defmodule PinchflatWeb.CoreComponents do
                 </button>
               </div>
               <div id={"#{@id}-content"}>
-                <%= render_slot(@inner_block) %>
+                {render_slot(@inner_block)}
               </div>
             </div>
           </div>
@@ -126,9 +126,9 @@ defmodule PinchflatWeb.CoreComponents do
       ]}>
         <main>
           <h5 :if={@title} class="mb-2 text-lg font-bold">
-            <%= @title %>
+            {@title}
           </h5>
-          <p class="mt-2 text-md leading-5 opacity-80"><%= msg %></p>
+          <p class="mt-2 text-md leading-5 opacity-80">{msg}</p>
         </main>
         <button
           type="button"
@@ -208,9 +208,9 @@ defmodule PinchflatWeb.CoreComponents do
   def simple_form(assigns) do
     ~H"""
     <.form :let={f} for={@for} as={@as} {@rest}>
-      <%= render_slot(@inner_block, f) %>
+      {render_slot(@inner_block, f)}
       <div :for={action <- @actions} class="mt-2 flex items-center justify-between gap-6">
-        <%= render_slot(action, f) %>
+        {render_slot(action, f)}
       </div>
     </.form>
     """
@@ -297,11 +297,11 @@ defmodule PinchflatWeb.CoreComponents do
           class={["rounded focus:ring-0", @inputclass]}
           {@rest}
         />
-        <%= @label %>
-        <span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
+        {@label}
+        <span :if={@label_suffix} class="text-xs text-bodydark">{@label_suffix}</span>
       </label>
-      <.help :if={@help}><%= if @html_help, do: Phoenix.HTML.raw(@help), else: @help %></.help>
-      <.error :for={msg <- @errors}><%= msg %></.error>
+      <.help :if={@help}>{if @html_help, do: Phoenix.HTML.raw(@help), else: @help}</.help>
+      <.error :for={msg <- @errors}>{msg}</.error>
     </div>
     """
   end
@@ -310,7 +310,7 @@ defmodule PinchflatWeb.CoreComponents do
     ~H"""
     <div phx-feedback-for={@name}>
       <.label for={@id}>
-        <%= @label %><span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
+        {@label}<span :if={@label_suffix} class="text-xs text-bodydark">{@label_suffix}</span>
       </.label>
       <section class="grid grid-cols-1 gap-2 md:grid-cols-2 max-w-prose mb-4 ml-1">
         <div :for={{option_name, option_value} <- @options} class="flex items-center">
@@ -323,12 +323,12 @@ defmodule PinchflatWeb.CoreComponents do
             class={["rounded focus:ring-offset-0 ring-offset-0 focus:ring-0 h-5 w-5 ", @inputclass]}
           />
           <label for={"#{@id}-#{option_value}"} class="ml-2 cursor-pointer select-none">
-            <%= option_name %>
+            {option_name}
           </label>
         </div>
       </section>
-      <.help :if={@help}><%= if @html_help, do: Phoenix.HTML.raw(@help), else: @help %></.help>
-      <.error :for={msg <- @errors}><%= msg %></.error>
+      <.help :if={@help}>{if @html_help, do: Phoenix.HTML.raw(@help), else: @help}</.help>
+      <.error :for={msg <- @errors}>{msg}</.error>
     </div>
     """
   end
@@ -340,14 +340,15 @@ defmodule PinchflatWeb.CoreComponents do
       end)
 
     ~H"""
-    <div x-data={"{ enabled: #{@checked}}"}>
-      <.label for={@id}>
-        <%= @label %>
-        <span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
+    <div x-data={"{ enabled: #{@checked} }"} class="" phx-update="ignore" id={"#{@id}-wrapper"}>
+      <.label :if={@label} for={@id}>
+        {@label}
+        <span :if={@label_suffix} class="text-xs text-bodydark">{@label_suffix}</span>
       </.label>
-      <div class="relative">
+      <div class="relative flex flex-col">
         <input type="hidden" id={@id} name={@name} x-bind:value="enabled" {@rest} />
-        <div class="inline-block cursor-pointer" @click="enabled = !enabled">
+        <%!-- This triggers a `change` event on the hidden input when the toggle is clicked --%>
+        <div class="inline-block cursor-pointer" @click={"enabled = !enabled; dispatchFor('#{@id}', 'change')"}>
           <div x-bind:class="enabled && '!bg-primary'" class="block h-8 w-14 rounded-full bg-black"></div>
           <div
             x-bind:class="enabled && '!right-1 !translate-x-full'"
@@ -358,8 +359,8 @@ defmodule PinchflatWeb.CoreComponents do
           >
           </div>
         </div>
-        <.help :if={@help}><%= if @html_help, do: Phoenix.HTML.raw(@help), else: @help %></.help>
-        <.error :for={msg <- @errors}><%= msg %></.error>
+        <.help :if={@help}>{if @html_help, do: Phoenix.HTML.raw(@help), else: @help}</.help>
+        <.error :for={msg <- @errors}>{msg}</.error>
       </div>
     </div>
     """
@@ -369,7 +370,7 @@ defmodule PinchflatWeb.CoreComponents do
     ~H"""
     <div phx-feedback-for={@name}>
       <.label :if={@label} for={@id}>
-        <%= @label %><span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
+        {@label}<span :if={@label_suffix} class="text-xs text-bodydark">{@label_suffix}</span>
       </.label>
       <div class="flex">
         <select
@@ -384,13 +385,13 @@ defmodule PinchflatWeb.CoreComponents do
           multiple={@multiple}
           {@rest}
         >
-          <option :if={@prompt} value=""><%= @prompt %></option>
-          <%= Phoenix.HTML.Form.options_for_select(@options, @value) %>
+          <option :if={@prompt} value="">{@prompt}</option>
+          {Phoenix.HTML.Form.options_for_select(@options, @value)}
         </select>
-        <%= render_slot(@inner_block) %>
+        {render_slot(@inner_block)}
       </div>
-      <.help :if={@help}><%= if @html_help, do: Phoenix.HTML.raw(@help), else: @help %></.help>
-      <.error :for={msg <- @errors}><%= msg %></.error>
+      <.help :if={@help}>{if @html_help, do: Phoenix.HTML.raw(@help), else: @help}</.help>
+      <.error :for={msg <- @errors}>{msg}</.error>
     </div>
     """
   end
@@ -399,7 +400,7 @@ defmodule PinchflatWeb.CoreComponents do
     ~H"""
     <div phx-feedback-for={@name}>
       <.label for={@id}>
-        <%= @label %><span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
+        {@label}<span :if={@label_suffix} class="text-xs text-bodydark">{@label_suffix}</span>
       </.label>
       <textarea
         id={@id}
@@ -413,8 +414,8 @@ defmodule PinchflatWeb.CoreComponents do
         ]}
         {@rest}
       ><%= Phoenix.HTML.Form.normalize_value("textarea", @value) %></textarea>
-      <.help :if={@help}><%= if @html_help, do: Phoenix.HTML.raw(@help), else: @help %></.help>
-      <.error :for={msg <- @errors}><%= msg %></.error>
+      <.help :if={@help}>{if @html_help, do: Phoenix.HTML.raw(@help), else: @help}</.help>
+      <.error :for={msg <- @errors}>{msg}</.error>
     </div>
     """
   end
@@ -424,7 +425,7 @@ defmodule PinchflatWeb.CoreComponents do
     ~H"""
     <div phx-feedback-for={@name}>
       <.label for={@id}>
-        <%= @label %><span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
+        {@label}<span :if={@label_suffix} class="text-xs text-bodydark">{@label_suffix}</span>
       </.label>
       <div class="flex items-center">
         <input
@@ -441,10 +442,10 @@ defmodule PinchflatWeb.CoreComponents do
           ]}
           {@rest}
         />
-        <%= render_slot(@input_append) %>
+        {render_slot(@input_append)}
       </div>
-      <.help :if={@help}><%= if @html_help, do: Phoenix.HTML.raw(@help), else: @help %></.help>
-      <.error :for={msg <- @errors}><%= msg %></.error>
+      <.help :if={@help}>{if @html_help, do: Phoenix.HTML.raw(@help), else: @help}</.help>
+      <.error :for={msg <- @errors}>{msg}</.error>
     </div>
     """
   end
@@ -457,7 +458,7 @@ defmodule PinchflatWeb.CoreComponents do
   def help(assigns) do
     ~H"""
     <p class="mt-1 text-sm leading-5">
-      <%= render_slot(@inner_block) %>
+      {render_slot(@inner_block)}
     </p>
     """
   end
@@ -471,7 +472,7 @@ defmodule PinchflatWeb.CoreComponents do
   def label(assigns) do
     ~H"""
     <label for={@for} class="mt-5 mb-2 inline-block text-md font-medium text-black dark:text-white">
-      <%= render_slot(@inner_block) %>
+      {render_slot(@inner_block)}
     </label>
     """
   end
@@ -485,7 +486,7 @@ defmodule PinchflatWeb.CoreComponents do
     ~H"""
     <p class="mt-1 mb-5 flex gap-3 text-md leading-6 text-rose-600 phx-no-feedback:hidden">
       <.icon name="hero-exclamation-circle-mini" class="mt-0.5 h-5 w-5 flex-none" />
-      <%= render_slot(@inner_block) %>
+      {render_slot(@inner_block)}
     </p>
     """
   end
@@ -504,13 +505,13 @@ defmodule PinchflatWeb.CoreComponents do
     <header class={[@actions != [] && "flex items-center justify-between gap-6", @class]}>
       <div>
         <h1 class="text-lg font-semibold leading-8 text-zinc-800">
-          <%= render_slot(@inner_block) %>
+          {render_slot(@inner_block)}
         </h1>
         <p :if={@subtitle != []} class="mt-2 text-sm leading-6 text-zinc-600">
-          <%= render_slot(@subtitle) %>
+          {render_slot(@subtitle)}
         </p>
       </div>
-      <div class="flex-none"><%= render_slot(@actions) %></div>
+      <div class="flex-none">{render_slot(@actions)}</div>
     </header>
     """
   end
@@ -550,9 +551,9 @@ defmodule PinchflatWeb.CoreComponents do
     <table class="w-[40rem] mt-11 sm:w-full">
       <thead class="text-sm text-left leading-6 text-zinc-500">
         <tr>
-          <th :for={col <- @col} class="p-0 pb-4 pr-6 font-normal"><%= col[:label] %></th>
+          <th :for={col <- @col} class="p-0 pb-4 pr-6 font-normal">{col[:label]}</th>
           <th :if={@action != []} class="relative p-0 pb-4">
-            <span class="sr-only"><%= gettext("Actions") %></span>
+            <span class="sr-only">{gettext("Actions")}</span>
           </th>
         </tr>
       </thead>
@@ -570,7 +571,7 @@ defmodule PinchflatWeb.CoreComponents do
             <div class="block py-4 pr-6">
               <span class="absolute -inset-y-px right-0 -left-4 group-hover:bg-zinc-50 sm:rounded-l-xl" />
               <span class={["relative", i == 0 && "font-semibold text-zinc-900"]}>
-                <%= render_slot(col, @row_item.(row)) %>
+                {render_slot(col, @row_item.(row))}
               </span>
             </div>
           </td>
@@ -578,7 +579,7 @@ defmodule PinchflatWeb.CoreComponents do
             <div class="relative whitespace-nowrap py-4 text-right text-sm font-medium">
               <span class="absolute -inset-y-px -right-4 left-0 group-hover:bg-zinc-50 sm:rounded-r-xl" />
               <span :for={action <- @action} class="relative ml-4 font-semibold leading-6 text-zinc-900 hover:text-zinc-700">
-                <%= render_slot(action, @row_item.(row)) %>
+                {render_slot(action, @row_item.(row))}
               </span>
             </div>
           </td>
@@ -607,8 +608,8 @@ defmodule PinchflatWeb.CoreComponents do
     <div class="mt-2 mb-14">
       <dl class="-my-4 divide-y dark:divide-strokedark">
         <div :for={item <- @item} class="flex gap-4 py-4 text-sm leading-6 sm:gap-8">
-          <dt class="w-1/4 flex-none dark:text-white"><%= item.title %></dt>
-          <dd class="dark:text-white"><%= render_slot(item) %></dd>
+          <dt class="w-1/4 flex-none dark:text-white">{item.title}</dt>
+          <dd class="dark:text-white">{render_slot(item)}</dd>
         </div>
       </dl>
     </div>
@@ -643,12 +644,12 @@ defmodule PinchflatWeb.CoreComponents do
     ~H"""
     <ul>
       <li :for={{k, v} <- @iterable_attributes} class="mb-2 w-2/3">
-        <strong><%= k %>:</strong>
+        <strong>{k}:</strong>
         <code class="inline-block text-sm font-mono text-gray p-0.5 mx-0.5">
           <%= if is_binary(v) && URI.parse(v).scheme && URI.parse(v).scheme =~ "http" do %>
-            <TextComponents.inline_link href={v}><%= v %></TextComponents.inline_link>
+            <TextComponents.inline_link href={v}>{v}</TextComponents.inline_link>
           <% else %>
-            <%= v %>
+            {v}
           <% end %>
         </code>
       </li>
@@ -671,7 +672,7 @@ defmodule PinchflatWeb.CoreComponents do
     <div class="mt-16">
       <.link href={@href} class="text-sm font-semibold leading-6 text-zinc-900 hover:text-zinc-700">
         <.icon name="hero-arrow-left-solid" class="h-3 w-3" />
-        <%= render_slot(@inner_block) %>
+        {render_slot(@inner_block)}
       </.link>
     </div>
     """

lib/pinchflat_web/components/custom_components/button_components.ex

@@ -26,7 +26,7 @@ defmodule PinchflatWeb.CustomComponents.ButtonComponents do
     ~H"""
     <button
       class={[
-        "text-center font-medium text-white",
+        "text-center font-medium text-white whitespace-nowrap",
         "#{@rounding} inline-flex items-center justify-center px-8 py-4",
         "#{@color}",
         "hover:bg-opacity-90 lg:px-8 xl:px-10",
@@ -37,7 +37,7 @@ defmodule PinchflatWeb.CustomComponents.ButtonComponents do
       disabled={@disabled}
       {@rest}
     >
-      <%= render_slot(@inner_block) %>
+      {render_slot(@inner_block)}
     </button>
     """
   end
@@ -66,7 +66,7 @@ defmodule PinchflatWeb.CustomComponents.ButtonComponents do
           "font-medium text-white hover:bg-opacity-95"
         ]}
       >
-        <%= @text %>
+        {@text}
         <CoreComponents.icon
           name="hero-chevron-down"
           class="fill-current duration-200 ease-linear mt-1"
@@ -81,7 +81,7 @@ defmodule PinchflatWeb.CustomComponents.ButtonComponents do
         <ul class="flex flex-col">
           <li :for={option <- @option}>
             <span class="flex px-5 py-2 font-medium text-bodydark2 hover:text-white cursor-pointer">
-              <%= render_slot(option) %>
+              {render_slot(option)}
             </span>
           </li>
         </ul>
@@ -126,7 +126,7 @@ defmodule PinchflatWeb.CustomComponents.ButtonComponents do
       >
         <span class="border-light absolute -top-1 left-1/2 -z-10 h-2 w-2 -translate-x-1/2 rotate-45 rounded-sm bg-meta-4">
         </span>
-        <span><%= @tooltip %></span>
+        <span>{@tooltip}</span>
       </div>
     </div>
     """

lib/pinchflat_web/components/custom_components/tab_components.ex

@@ -34,16 +34,16 @@ defmodule PinchflatWeb.CustomComponents.TabComponents do
             x-bind:class={"openTab === '#{tab.id}' ? activeClasses : inactiveClasses"}
             class="border-b-2 py-4 w-full sm:w-fit text-sm font-medium hover:text-meta-5 md:text-base"
           >
-            <span class="text-xl"><%= tab.title %></span>
+            <span class="text-xl">{tab.title}</span>
           </a>
         </div>
         <div class="mx-4 my-4 lg:my-0 flex gap-5 sm:gap-10 items-center">
-          <%= render_slot(@tab_append) %>
+          {render_slot(@tab_append)}
         </div>
       </header>
       <div class="mt-4 min-h-60">
         <div :for={tab <- @tab} x-show={"openTab === '#{tab.id}'"} class="font-medium leading-relaxed">
-          <%= render_slot(tab) %>
+          {render_slot(tab)}
         </div>
       </div>
     </div>

lib/pinchflat_web/components/custom_components/table_components.ex

@@ -16,6 +16,8 @@ defmodule PinchflatWeb.CustomComponents.TableComponents do
   """
   attr :rows, :list, required: true
   attr :table_class, :string, default: ""
+  attr :sort_key, :string, default: nil
+  attr :sort_direction, :string, default: nil
 
   attr :row_item, :any,
     default: &Function.identity/1,
@@ -24,6 +26,7 @@ defmodule PinchflatWeb.CustomComponents.TableComponents do
   slot :col, required: true do
     attr :label, :string
     attr :class, :string
+    attr :sort_key, :string
   end
 
   def table(assigns) do
@@ -31,8 +34,20 @@ defmodule PinchflatWeb.CustomComponents.TableComponents do
     <table class={["w-full table-auto bg-boxdark", @table_class]}>
       <thead>
         <tr class="text-left bg-meta-4">
-          <th :for={col <- @col} class="px-4 py-4 font-medium text-white xl:pl-11">
-            <%= col[:label] %>
+          <th
+            :for={col <- @col}
+            class={["px-4 py-4 font-medium text-white", col[:sort_key] && "cursor-pointer"]}
+            phx-click={col[:sort_key] && "sort_update"}
+            phx-value-sort_key={col[:sort_key]}
+          >
+            <div class="relative">
+              {col[:label]}
+              <.icon
+                :if={to_string(@sort_key) == col[:sort_key]}
+                name={if @sort_direction == :asc, do: "hero-chevron-up", else: "hero-chevron-down"}
+                class="w-3 h-3 mt-2 ml-1 absolute"
+              />
+            </div>
           </th>
         </tr>
       </thead>
@@ -41,11 +56,11 @@ defmodule PinchflatWeb.CustomComponents.TableComponents do
           <td
             :for={col <- @col}
             class={[
-              "px-4 py-5 pl-9 xl:pl-11",
+              "px-4 py-5",
               col[:class]
             ]}
           >
-            <%= render_slot(col, @row_item.(row)) %>
+            {render_slot(col, @row_item.(row))}
           </td>
         </tr>
       </tbody>
@@ -70,9 +85,9 @@ defmodule PinchflatWeb.CustomComponents.TableComponents do
         <li>
           <span
             class={[
-              "flex h-8 w-8 items-center justify-center rounded",
+              "pagination-prev h-8 w-8 items-center justify-center rounded",
               @page_number != 1 && "cursor-pointer hover:bg-primary hover:text-white",
-              @page_number == 1 && "cursor-not-allowed"
+              @page_number <= 1 && "cursor-not-allowed"
             ]}
             phx-click={@page_number != 1 && "page_change"}
             phx-value-direction="dec"
@@ -88,9 +103,9 @@ defmodule PinchflatWeb.CustomComponents.TableComponents do
         <li>
           <span
             class={[
-              "flex h-8 w-8 items-center justify-center rounded",
+              "pagination-next flex h-8 w-8 items-center justify-center rounded",
               @page_number != @total_pages && "cursor-pointer hover:bg-primary hover:text-white",
-              @page_number == @total_pages && "cursor-not-allowed"
+              @page_number >= @total_pages && "cursor-not-allowed"
             ]}
             phx-click={@page_number != @total_pages && "page_change"}
             phx-value-direction="inc"

lib/pinchflat_web/components/custom_components/text_components.ex

@@ -2,6 +2,7 @@ defmodule PinchflatWeb.CustomComponents.TextComponents do
   @moduledoc false
   use Phoenix.Component
 
+  alias Pinchflat.Utils.NumberUtils
   alias PinchflatWeb.CoreComponents
 
   @doc """
@@ -12,7 +13,7 @@ defmodule PinchflatWeb.CustomComponents.TextComponents do
   def inline_code(assigns) do
     ~H"""
     <code class="inline-block text-sm font-mono text-gray bg-boxdark rounded-md p-0.5 mx-0.5 text-nowrap">
-      <%= render_slot(@inner_block) %>
+      {render_slot(@inner_block)}
     </code>
     """
   end
@@ -26,7 +27,7 @@ defmodule PinchflatWeb.CustomComponents.TextComponents do
   def inline_link(assigns) do
     ~H"""
     <.link href={@href} target="_blank" class="text-blue-500 hover:text-blue-300">
-      <%= render_slot(@inner_block) %>
+      {render_slot(@inner_block)}
     </.link>
     """
   end
@@ -41,7 +42,7 @@ defmodule PinchflatWeb.CustomComponents.TextComponents do
   def subtle_link(assigns) do
     ~H"""
     <.link href={@href} target={@target} class="underline decoration-bodydark decoration-1 hover:decoration-white">
-      <%= render_slot(@inner_block) %>
+      {render_slot(@inner_block)}
     </.link>
     """
   end
@@ -82,7 +83,7 @@ defmodule PinchflatWeb.CustomComponents.TextComponents do
     assigns = Map.put(assigns, :text, formatted_text)
 
     ~H"""
-    <span><%= @text %></span>
+    <span>{@text}</span>
     """
   end
 
@@ -98,7 +99,7 @@ defmodule PinchflatWeb.CustomComponents.TextComponents do
     assigns = Map.put(assigns, :timezone, timezone)
 
     ~H"""
-    <time><%= Calendar.strftime(Timex.Timezone.convert(@datetime, @timezone), @format) %></time>
+    <time>{Calendar.strftime(Timex.Timezone.convert(@datetime, @timezone), @format)}</time>
     """
   end
 
@@ -109,7 +110,7 @@ defmodule PinchflatWeb.CustomComponents.TextComponents do
 
   def localized_number(assigns) do
     ~H"""
-    <span x-data x-text={"Intl.NumberFormat().format(#{@number})"}><%= @number %></span>
+    <span x-data x-text={"Intl.NumberFormat().format(#{@number})"}>{@number}</span>
     """
   end
 
@@ -122,7 +123,27 @@ defmodule PinchflatWeb.CustomComponents.TextComponents do
 
   def pluralize(assigns) do
     ~H"""
-    <%= @word %><%= if @count == 1, do: "", else: @suffix %>
+    {@word}{if @count == 1, do: "", else: @suffix}
+    """
+  end
+
+  @doc """
+  Renders a human-readable byte size
+  """
+
+  attr :byte_size, :integer, required: true
+
+  def readable_filesize(assigns) do
+    {num, suffix} = NumberUtils.human_byte_size(assigns.byte_size, precision: 2)
+
+    assigns =
+      Map.merge(assigns, %{
+        num: num,
+        suffix: suffix
+      })
+
+    ~H"""
+    <.localized_number number={@num} /> {@suffix}
     """
   end
 end

lib/pinchflat_web/components/layouts.ex

@@ -61,7 +61,7 @@ defmodule PinchflatWeb.Layouts do
         x-on:click="selected = !selected"
       >
         <span class="flex items-center gap-2.5">
-          <.icon name={@icon} /> <%= @text %>
+          <.icon name={@icon} /> {@text}
         </span>
         <span class="text-bodydark2">
           <.icon name="hero-chevron-down" x-bind:class="{ 'rotate-180': selected }" />
@@ -103,7 +103,7 @@ defmodule PinchflatWeb.Layouts do
         @class
       ]}
     >
-      <.icon :if={@icon} name={@icon} /> <%= @text %>
+      <.icon :if={@icon} name={@icon} /> {@text}
     </.link>
     """
   end

lib/pinchflat_web/components/layouts/app.html.heex

@@ -6,7 +6,7 @@
     <main>
       <div class="mx-auto max-w-screen-2xl p-4 md:p-6 2xl:p-10">
         <.flash_group flash={@flash} />
-        <%= @inner_content %>
+        {@inner_content}
       </div>
     </main>
   </div>

lib/pinchflat_web/components/layouts/onboarding.html.heex

@@ -11,7 +11,7 @@
     <main>
       <div class="mx-auto max-w-screen-2xl p-4 md:p-6 2xl:p-10">
         <.flash_group flash={@flash} />
-        <%= @inner_content %>
+        {@inner_content}
       </div>
     </main>
   </div>

lib/pinchflat_web/components/layouts/partials/sidebar.html.heex

@@ -67,7 +67,7 @@
             class="group relative flex items-center gap-2.5 px-4 pt-2 text-sm"
             x-on:click={"markVersionAsSeen('#{Application.spec(:pinchflat)[:vsn]}')"}
           >
-            <span>Pinchflat <%= Application.spec(:pinchflat)[:vsn] %></span>
+            <span>Pinchflat {Application.spec(:pinchflat)[:vsn]}</span>
             <a
               href="https://github.com/kieraneglin/pinchflat/releases"
               target="_blank"
@@ -79,7 +79,7 @@
             </a>
           </span>
           <span class="group relative flex items-center gap-2.5 px-4 pt-2 text-sm">
-            yt-dlp <%= Settings.get!(:yt_dlp_version) %>
+            yt-dlp {Settings.get!(:yt_dlp_version)}
           </span>
         </li>
       </ul>

lib/pinchflat_web/components/layouts/partials/upgrade_button_live.ex

@@ -3,7 +3,7 @@ defmodule Pinchflat.UpgradeButtonLive do
 
   def render(assigns) do
     ~H"""
-    <form id="upgradeForm" phx-change="check_matching_text" phx-hook="supressEnterSubmission">
+    <form id="upgradeForm" phx-change="check_matching_text" phx-hook="supress-enter-submission">
       <.input type="text" name="unlock-pro-textbox" value="" />
     </form>
 

lib/pinchflat_web/components/layouts/partials/upgrade_modal.heex

@@ -25,6 +25,6 @@
       into the text box and press the button.
     </p>
 
-    <%= live_render(@conn, Pinchflat.UpgradeButtonLive) %>
+    {live_render(@conn, Pinchflat.UpgradeButtonLive)}
   </section>
 </.modal>

lib/pinchflat_web/components/layouts/root.html.heex

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta name="csrf-token" content={get_csrf_token()} />
     <.live_title>
-      <%= assigns[:page_title] || "Pinchflat" %>
+      {assigns[:page_title] || "Pinchflat"}
     </.live_title>
     <link phx-track-static rel="stylesheet" href={~p"/assets/app.css"} />
     <link rel="icon" type="image/x-icon" href={~p"/favicon.ico?cachebust=2024-03-20"} />
@@ -21,7 +21,7 @@
     class="dark text-bodydark bg-boxdark-2"
     data-socket-path={Path.join(Application.get_env(:pinchflat, :base_route_path), "/live")}
   >
-    <%= @inner_content %>
+    {@inner_content}
 
     <.donate_modal conn={@conn} />
     <template x-if="!proEnabled && !onboarding">

lib/pinchflat_web/controllers/media_items/media_item_html/edit.html.heex

@@ -1,6 +1,6 @@
 <div class="mb-6 flex gap-3 flex-row items-center">
-  <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4">
-    Editing "<%= StringUtils.truncate(@media_item.title, 35) %>"
+  <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4 truncate">
+    Editing "{@media_item.title}"
   </h2>
 </div>
 

lib/pinchflat_web/controllers/media_items/media_item_html/media_preview.heex

@@ -1,13 +1,13 @@
 <%= if media_type(@media_item) == :video do %>
   <video controls class="max-h-128 w-full">
-    <source src={~p"/media/#{@media_item.uuid}/stream"} type="video/mp4" />
+    <source src={~p"/media/#{@media_item.uuid}/stream?v=#{DateTime.to_unix(@media_item.updated_at)}"} type="video/mp4" />
     Your browser does not support the video element.
   </video>
 <% end %>
 
 <%= if media_type(@media_item) == :audio do %>
   <audio controls class="w-full">
-    <source src={~p"/media/#{@media_item.uuid}/stream"} type="audio/mpeg" />
+    <source src={~p"/media/#{@media_item.uuid}/stream?v=#{DateTime.to_unix(@media_item.updated_at)}"} type="audio/mpeg" />
     Your browser does not support the audio element.
   </audio>
 <% end %>

lib/pinchflat_web/controllers/media_items/media_item_html/show.html.heex

@@ -1,10 +1,10 @@
 <div class="mb-6 flex gap-3 flex-row items-center justify-between">
-  <div class="flex gap-3 items-center">
+  <div class="flex gap-3 items-center min-w-0">
     <.link href={~p"/sources/#{@media_item.source_id}"}>
       <.icon name="hero-arrow-left" class="w-10 h-10 hover:dark:text-white" />
     </.link>
-    <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4">
-      <%= StringUtils.truncate(@media_item.title, 35) %>
+    <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4 truncate">
+      {@media_item.title}
     </h2>
   </div>
 
@@ -31,15 +31,18 @@
                 <.media_preview media_item={@media_item} />
               </div>
               <aside class="mt-4">
-                <h2 class="text-xl mb-2"><%= @media_item.title %></h2>
-                <div>Uploaded: <%= DateTime.to_date(@media_item.uploaded_at) %></div>
+                <h2 class="text-xl mb-2">{@media_item.title}</h2>
+                <div>Uploaded: {DateTime.to_date(@media_item.uploaded_at)}</div>
                 <div>
                   <span :if={URI.parse(@media_item.original_url).scheme =~ "http"}>
                     <.subtle_link href={@media_item.original_url} target="_blank">Open Original</.subtle_link>
                     <span class="mx-2">or</span>
                   </span>
                   <span>
-                    <.subtle_link href={~p"/media/#{@media_item.uuid}/stream"} target="_blank">
+                    <.subtle_link
+                      href={~p"/media/#{@media_item.uuid}/stream?v=#{DateTime.to_unix(@media_item.updated_at)}"}
+                      target="_blank"
+                    >
                       Open Local Stream
                     </.subtle_link>
                   </span>
@@ -55,7 +58,7 @@
           <section>
             <strong>Source:</strong>
             <.subtle_link href={~p"/sources/#{@media_item.source_id}"}>
-              <%= @media_item.source.custom_name %>
+              {@media_item.source.custom_name}
             </.subtle_link>
             <.list_items_from_map map={Map.from_struct(@media_item)} />
           </section>
@@ -65,10 +68,10 @@
         <%= if match?([_|_], @media_item.tasks) do %>
           <.table rows={@media_item.tasks} table_class="text-black dark:text-white">
             <:col :let={task} label="Worker">
-              <%= task.job.worker %>
+              {task.job.worker}
             </:col>
             <:col :let={task} label="State">
-              <%= task.job.state %>
+              {task.job.state}
             </:col>
             <:col :let={task} label="Scheduled At">
               <.datetime_in_zone datetime={task.job.scheduled_at} />

lib/pinchflat_web/controllers/media_profiles/media_profile_controller.ex

@@ -1,26 +1,51 @@
 defmodule PinchflatWeb.MediaProfiles.MediaProfileController do
   use PinchflatWeb, :controller
   use Pinchflat.Sources.SourcesQuery
+  use Pinchflat.Profiles.ProfilesQuery
 
   alias Pinchflat.Repo
   alias Pinchflat.Profiles
+  alias Pinchflat.Sources.Source
   alias Pinchflat.Profiles.MediaProfile
   alias Pinchflat.Profiles.MediaProfileDeletionWorker
 
   def index(conn, _params) do
-    media_profiles =
-      MediaProfile
-      |> where([mp], is_nil(mp.marked_for_deletion_at))
-      |> order_by(asc: :name)
-      |> Repo.all()
+    media_profiles_query =
+      from mp in MediaProfile,
+        as: :media_profile,
+        where: is_nil(mp.marked_for_deletion_at),
+        order_by: [asc: mp.name],
+        select: map(mp, ^MediaProfile.__schema__(:fields)),
+        select_merge: %{
+          source_count:
+            subquery(
+              from s in Source,
+                where: s.media_profile_id == parent_as(:media_profile).id,
+                select: count(s.id)
+            )
+        }
 
-    render(conn, :index, media_profiles: media_profiles)
+    render(conn, :index, media_profiles: Repo.all(media_profiles_query))
   end
 
-  def new(conn, _params) do
-    changeset = Profiles.change_media_profile(%MediaProfile{})
+  def new(conn, params) do
+    # Preload an existing media profile for faster creation
+    cs_struct =
+      case to_string(params["template_id"]) do
+        "" -> %MediaProfile{}
+        template_id -> Repo.get(MediaProfile, template_id) || %MediaProfile{}
+      end
 
-    render(conn, :new, changeset: changeset, layout: get_onboarding_layout())
+    render(conn, :new,
+      layout: get_onboarding_layout(),
+      changeset:
+        Profiles.change_media_profile(%MediaProfile{
+          cs_struct
+          | id: nil,
+            name: nil,
+            marked_for_deletion_at: nil
+        })
+    )
   end
 
   def create(conn, %{"media_profile" => media_profile_params}) do

lib/pinchflat_web/controllers/media_profiles/media_profile_html.ex

@@ -10,6 +10,7 @@ defmodule PinchflatWeb.MediaProfiles.MediaProfileHTML do
   """
   attr :changeset, Ecto.Changeset, required: true
   attr :action, :string, required: true
+  attr :method, :string, required: true
 
   def media_profile_form(assigns)
 
@@ -25,6 +26,7 @@ defmodule PinchflatWeb.MediaProfiles.MediaProfileHTML do
     [
       {"8k", "4320p"},
       {"4k", "2160p"},
+      {"1440p", "1440p"},
       {"1080p", "1080p"},
       {"720p", "720p"},
       {"480p", "480p"},

lib/pinchflat_web/controllers/media_profiles/media_profile_html/actions_dropdown.html.heex

@@ -11,6 +11,11 @@
       <span x-show="copied" x-transition.duration.150ms><.icon name="hero-check" class="ml-2 h-4 w-4" /></span>
     </span>
   </:option>
+  <:option>
+    <.link href={~p"/media_profiles/new?template_id=#{@media_profile}"} method="get">
+      Use as Template
+    </.link>
+  </:option>
   <:option>
     <div class="h-px w-full bg-bodydark2"></div>
   </:option>

lib/pinchflat_web/controllers/media_profiles/media_profile_html/edit.html.heex

@@ -2,15 +2,15 @@
   <.link href={~p"/media_profiles"}>
     <.icon name="hero-arrow-left" class="w-10 h-10 hover:dark:text-white" />
   </.link>
-  <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4">
-    Editing "<%= @media_profile.name %>"
+  <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4 truncate">
+    Editing "{@media_profile.name}"
   </h2>
 </div>
 
 <div class="rounded-sm border border-stroke bg-white px-5 pb-2.5 pt-6 shadow-default dark:border-strokedark dark:bg-boxdark sm:px-7.5 xl:pb-1">
   <div class="max-w-full">
     <div class="flex flex-col gap-10">
-      <.media_profile_form changeset={@changeset} action={~p"/media_profiles/#{@media_profile}"} />
+      <.media_profile_form changeset={@changeset} action={~p"/media_profiles/#{@media_profile}"} method="patch" />
     </div>
   </div>
 </div>

lib/pinchflat_web/controllers/media_profiles/media_profile_html/index.html.heex

@@ -10,18 +10,22 @@
     </.link>
   </nav>
 </div>
-
 <div class="rounded-sm border border-stroke bg-white shadow-default dark:border-strokedark dark:bg-boxdark">
   <div class="max-w-full overflow-x-auto">
     <div class="flex flex-col gap-10 min-w-max">
       <.table rows={@media_profiles} table_class="text-black dark:text-white">
-        <:col :let={media_profile} label="Name">
+        <:col :let={media_profile} label="Name" class="truncate max-w-xs">
           <.subtle_link href={~p"/media_profiles/#{media_profile.id}"}>
-            <%= media_profile.name %>
+            {media_profile.name}
           </.subtle_link>
         </:col>
         <:col :let={media_profile} label="Preferred Resolution">
-          <%= media_profile.preferred_resolution %>
+          {media_profile.preferred_resolution}
+        </:col>
+        <:col :let={media_profile} label="Sources">
+          <.subtle_link href={~p"/media_profiles/#{media_profile.id}/#tab-sources"}>
+            <.localized_number number={media_profile.source_count} />
+          </.subtle_link>
         </:col>
         <:col :let={media_profile} label="" class="flex justify-end">
           <.icon_link href={~p"/media_profiles/#{media_profile.id}/edit"} icon="hero-pencil-square" class="mr-4" />

lib/pinchflat_web/controllers/media_profiles/media_profile_html/media_profile_form.html.heex

@@ -2,6 +2,7 @@
   :let={f}
   for={@changeset}
   action={@action}
+  method={@method}
   x-data="{ advancedMode: !!JSON.parse(localStorage.getItem('advancedMode')) }"
   x-init="$watch('advancedMode', value => localStorage.setItem('advancedMode', JSON.stringify(value)))"
 >
@@ -124,6 +125,16 @@
       />
     </section>
 
+    <section x-show="advancedMode">
+      <.input
+        field={f[:audio_track]}
+        placeholder="de"
+        type="text"
+        label="Audio Track Language"
+        help="Only works if there are multiple audio tracks. Use either a language code, 'original' for the original audio track, or 'default' for YouTube's preference. Or just leave it blank"
+      />
+    </section>
+
     <h3 class="mt-10 text-2xl text-black dark:text-white">
       Thumbnail Options
     </h3>

lib/pinchflat_web/controllers/media_profiles/media_profile_html/new.html.heex

@@ -8,7 +8,7 @@
 <div class="rounded-sm border border-stroke bg-white px-5 pb-2.5 pt-6 shadow-default dark:border-strokedark dark:bg-boxdark sm:px-7.5 xl:pb-1">
   <div class="max-w-full">
     <div class="flex flex-col gap-10">
-      <.media_profile_form changeset={@changeset} action={~p"/media_profiles"} />
+      <.media_profile_form changeset={@changeset} action={~p"/media_profiles"} method="post" />
     </div>
   </div>
 </div>

lib/pinchflat_web/controllers/media_profiles/media_profile_html/output_template_help.html.heex

@@ -6,7 +6,9 @@
     <ul class="list-disc list-inside ml-2 md:ml-5">
       <li>
         Liquid-style:
-        <.inline_code>/{{ channel }}/{{ title }} - {{ id }}.{{ ext }}</.inline_code>
+        <.inline_code>
+          {"/#{double_brace("channel")}/#{double_brace("title")} - #{double_brace("id")}.#{double_brace("ext")}"}
+        </.inline_code>
       </li>
       <li>
         <code class="text-sm">yt-dlp</code>-style
@@ -17,7 +19,7 @@
       </li>
       <li>
         Any bare words:
-        <.inline_code>/videos/1080p/{{ id }}.{{ ext }}</.inline_code>
+        <.inline_code>{"/videos/1080p/#{double_brace("id")}.#{double_brace("ext")}"}</.inline_code>
       </li>
     </ul>
     <p class="my-2">
@@ -25,7 +27,7 @@
       <em>any</em>
       single-word <code class="text-sm">yt-dlp</code>
       option can be used as liquid-style and it's automatically made filepath-safe. For example, the
-      <.inline_code>{{ duration }}</.inline_code>
+      <.inline_code>{double_brace("duration")}</.inline_code>
       option is translated to
       <.inline_code>%(duration)S</.inline_code>
     </p>
@@ -33,12 +35,14 @@
       <strong>Major 🔑:</strong>
       these syntaxes can be mixed and matched freely! I prefer to use liquid-style and bare words
       but I'll include <code class="text-sm">yt-dlp</code>-style when I need more control. For example:
-      <.inline_code>/1080p/{{ channel }}/{{ title }}-(%(subtitles.en.-1.ext)s).{{ ext }}</.inline_code>
+      <.inline_code>
+        {"/1080p/#{double_brace("channel")}/#{double_brace("title")}-(%(subtitles.en.-1.ext)s).#{double_brace("ext")}"}
+      </.inline_code>
     </p>
     <p class="my-2">
       <strong>NOTE:</strong>
       Your template <em>must</em>
-      end with an extension option (<.inline_code>.{{ ext }}</.inline_code>
+      end with an extension option (<.inline_code>.{double_brace("ext")}</.inline_code>
       or
       <.inline_code>.%(ext)S</.inline_code>).
       Downloading won't work as expected without it.
@@ -59,21 +63,21 @@
     <h3 class="text-lg font-bold my-2">Media Center Custom Aliases</h3>
     <ul class="list-disc list-inside mb-4 ml-2 md:ml-5 max-w-prose">
       <li :for={{k, v} <- media_center_custom_output_template_options()} class="mt-1">
-        <.inline_code>{{ <%= k %> }}</.inline_code>
-        <span :if={v}>- <%= html_escape({:safe, v}) %></span>
+        <.inline_code>{double_brace(k)}</.inline_code>
+        <span :if={v}>- {html_escape({:safe, v})}</span>
       </li>
     </ul>
     <h3 class="text-lg font-bold mb-2">Other Custom Aliases</h3>
     <ul class="list-disc list-inside mb-4 ml-2 md:ml-5 max-w-prose">
       <li :for={{k, v} <- other_custom_output_template_options()} class="mt-1">
-        <.inline_code>{{ <%= k %> }}</.inline_code>
-        <span :if={v}>- <%= html_escape({:safe, v}) %></span>
+        <.inline_code>{double_brace(k)}</.inline_code>
+        <span :if={v}>- {html_escape({:safe, v})}</span>
       </li>
     </ul>
     <h3 class="text-lg font-bold mb-2">Common Options</h3>
     <ul class="list-disc list-inside ml-2 md:ml-5">
       <li :for={opt <- common_output_template_options()} class="mt-1">
-        <.inline_code>{{ <%= opt %> }}</.inline_code>
+        <.inline_code>{double_brace(opt)}</.inline_code>
       </li>
     </ul>
   </section>

lib/pinchflat_web/controllers/media_profiles/media_profile_html/show.html.heex

@@ -1,10 +1,10 @@
 <div class="mb-6 flex gap-3 flex-row items-center justify-between">
-  <div class="flex items-center">
+  <div class="flex items-center min-w-0">
     <.link href={~p"/media_profiles"}>
       <.icon name="hero-arrow-left" class="w-10 h-10 hover:dark:text-white" />
     </.link>
-    <h2 class="text-title-md2 font-bold text-black dark:text-white ml-2">
-      <%= @media_profile.name %>
+    <h2 class="text-title-md2 font-bold text-black dark:text-white ml-2 truncate">
+      {@media_profile.name}
     </h2>
   </div>
 
@@ -33,10 +33,10 @@
         <.table rows={@sources} table_class="text-black dark:text-white">
           <:col :let={source} label="Name">
             <.subtle_link href={~p"/sources/#{source.id}"}>
-              <%= source.custom_name || source.collection_name %>
+              {source.custom_name || source.collection_name}
             </.subtle_link>
           </:col>
-          <:col :let={source} label="Type"><%= source.collection_type %></:col>
+          <:col :let={source} label="Type">{source.collection_type}</:col>
           <:col :let={source} label="Should Download?">
             <.icon name={if source.download_media, do: "hero-check", else: "hero-x-mark"} />
           </:col>

lib/pinchflat_web/controllers/pages/page_html.ex

@@ -1,23 +1,5 @@
 defmodule PinchflatWeb.Pages.PageHTML do
   use PinchflatWeb, :html
 
-  alias Pinchflat.Utils.NumberUtils
-
   embed_templates "page_html/*"
-
-  attr :media_filesize, :integer, required: true
-
-  def readable_media_filesize(assigns) do
-    {num, suffix} = NumberUtils.human_byte_size(assigns.media_filesize, precision: 2)
-
-    assigns =
-      Map.merge(assigns, %{
-        num: num,
-        suffix: suffix
-      })
-
-    ~H"""
-    <.localized_number number={@num} /> <%= @suffix %>
-    """
-  end
 end

lib/pinchflat_web/controllers/pages/page_html/history_table_live.ex

@@ -28,23 +28,23 @@ defmodule Pinchflat.Pages.HistoryTableLive do
       </span>
       <div class="max-w-full overflow-x-auto">
         <.table rows={@records} table_class="text-white">
-          <:col :let={media_item} label="Title">
+          <:col :let={media_item} label="Title" class="truncate max-w-xs">
             <.subtle_link href={~p"/sources/#{media_item.source_id}/media/#{media_item}"}>
-              <%= StringUtils.truncate(media_item.title, 35) %>
+              {media_item.title}
             </.subtle_link>
           </:col>
           <:col :let={media_item} label="Upload Date">
-            <%= DateTime.to_date(media_item.uploaded_at) %>
+            {DateTime.to_date(media_item.uploaded_at)}
           </:col>
           <:col :let={media_item} label="Indexed At">
-            <%= format_datetime(media_item.inserted_at) %>
+            {format_datetime(media_item.inserted_at)}
           </:col>
           <:col :let={media_item} label="Downloaded At">
-            <%= format_datetime(media_item.media_downloaded_at) %>
+            {format_datetime(media_item.media_downloaded_at)}
           </:col>
-          <:col :let={media_item} label="Source">
+          <:col :let={media_item} label="Source" class="truncate max-w-xs">
             <.subtle_link href={~p"/sources/#{media_item.source_id}"}>
-              <%= StringUtils.truncate(media_item.source.custom_name, 35) %>
+              {media_item.source.custom_name}
             </.subtle_link>
           </:col>
         </.table>
@@ -56,9 +56,9 @@ defmodule Pinchflat.Pages.HistoryTableLive do
     """
   end
 
-  def mount(_params, _session, socket) do
+  def mount(_params, session, socket) do
     page = 1
-    base_query = generate_base_query()
+    base_query = generate_base_query(session["media_state"])
     pagination_attrs = fetch_pagination_attributes(base_query, page)
 
     {:ok, assign(socket, Map.merge(pagination_attrs, %{base_query: base_query}))}
@@ -97,10 +97,17 @@ defmodule Pinchflat.Pages.HistoryTableLive do
     |> Repo.preload(:source)
   end
 
-  defp generate_base_query do
+  defp generate_base_query("pending") do
     MediaQuery.new()
     |> MediaQuery.require_assoc(:media_profile)
-    |> where(^dynamic(^MediaQuery.downloaded() or ^MediaQuery.pending()))
+    |> where(^dynamic(^MediaQuery.pending()))
+    |> order_by(desc: :id)
+  end
+
+  defp generate_base_query("downloaded") do
+    MediaQuery.new()
+    |> MediaQuery.require_assoc(:media_profile)
+    |> where(^dynamic(^MediaQuery.downloaded()))
     |> order_by(desc: :id)
   end
 

lib/pinchflat_web/controllers/pages/page_html/home.html.heex

@@ -33,7 +33,7 @@
     <span class="flex flex-col items-center py-2">
       <span class="text-md font-medium">Library Size</span>
       <h4 class="text-title-md font-bold text-white">
-        <.readable_media_filesize media_filesize={@media_item_size} />
+        <.readable_filesize byte_size={@media_item_size} />
       </h4>
     </span>
   </div>
@@ -41,14 +41,27 @@
 
 <div class="rounded-sm border shadow-default border-strokedark bg-boxdark mt-4 p-5">
   <span class="text-2xl font-medium mb-4">Media History</span>
-  <section class="mt-6">
-    <%= live_render(@conn, Pinchflat.Pages.HistoryTableLive) %>
-  </section>
+  <.tabbed_layout>
+    <:tab title="Downloaded" id="downloaded">
+      {live_render(
+        @conn,
+        Pinchflat.Pages.HistoryTableLive,
+        session: %{"media_state" => "downloaded"}
+      )}
+    </:tab>
+    <:tab title="Pending" id="pending">
+      {live_render(
+        @conn,
+        Pinchflat.Pages.HistoryTableLive,
+        session: %{"media_state" => "pending"}
+      )}
+    </:tab>
+  </.tabbed_layout>
 </div>
 
 <div class="rounded-sm border shadow-default border-strokedark bg-boxdark mt-4 p-5">
   <span class="text-2xl font-medium mb-4">Active Tasks</span>
   <section class="mt-6 min-h-80">
-    <%= live_render(@conn, Pinchflat.Pages.JobTableLive) %>
+    {live_render(@conn, Pinchflat.Pages.JobTableLive)}
   </section>
 </div>

lib/pinchflat_web/controllers/pages/page_html/job_table_live.ex

@@ -19,18 +19,18 @@ defmodule Pinchflat.Pages.JobTableLive do
     <div class="max-w-full overflow-x-auto">
       <.table rows={@tasks} table_class="text-white">
         <:col :let={task} label="Task">
-          <%= worker_to_task_name(task.job.worker) %>
+          {worker_to_task_name(task.job.worker)}
         </:col>
-        <:col :let={task} label="Subject">
+        <:col :let={task} label="Subject" class="truncate max-w-xs">
           <.subtle_link href={task_to_link(task)}>
-            <%= StringUtils.truncate(task_to_record_name(task), 35) %>
+            {task_to_record_name(task)}
           </.subtle_link>
         </:col>
         <:col :let={task} label="Attempt No.">
-          <%= task.job.attempt %>
+          {task.job.attempt}
         </:col>
         <:col :let={task} label="Started At">
-          <%= format_datetime(task.job.attempted_at) %>
+          {format_datetime(task.job.attempted_at)}
         </:col>
       </.table>
     </div>

lib/pinchflat_web/controllers/podcasts/podcast_controller.ex

@@ -6,8 +6,19 @@ defmodule PinchflatWeb.Podcasts.PodcastController do
   alias Pinchflat.Sources.Source
   alias Pinchflat.Media.MediaItem
   alias Pinchflat.Podcasts.RssFeedBuilder
+  alias Pinchflat.Podcasts.OpmlFeedBuilder
   alias Pinchflat.Podcasts.PodcastHelpers
 
+  def opml_feed(conn, _params) do
+    url_base = url(conn, ~p"/")
+    xml = OpmlFeedBuilder.build(url_base, PodcastHelpers.opml_sources())
+
+    conn
+    |> put_resp_content_type("application/opml+xml")
+    |> put_resp_header("content-disposition", "inline")
+    |> send_resp(200, xml)
+  end
+
   def rss_feed(conn, %{"uuid" => uuid}) do
     source = Repo.get_by!(Source, uuid: uuid)
     url_base = url(conn, ~p"/")

lib/pinchflat_web/controllers/searches/search_html.ex

@@ -14,7 +14,7 @@ defmodule PinchflatWeb.Searches.SearchHTML do
 
     ~H"""
     <%= for fragment <- @split_string do %>
-      <%= render_fragment(fragment) %>
+      {render_fragment(fragment)}
     <% end %>
     """
   end

lib/pinchflat_web/controllers/searches/search_html/show.html.heex

@@ -1,6 +1,6 @@
 <div class="mb-6 flex gap-3 flex-row items-center justify-between">
-  <h2 class="text-title-md2 font-bold text-black dark:text-white">
-    Results for "<%= StringUtils.truncate(@search_term, 50) %>"
+  <h2 class="text-title-md2 font-bold text-black dark:text-white truncate">
+    Results for "{@search_term}"
   </h2>
 </div>
 
@@ -9,9 +9,9 @@
     <div class="flex flex-col gap-10 dark:text-white">
       <%= if match?([_|_], @search_results) do %>
         <.table rows={@search_results} table_class="text-black dark:text-white">
-          <:col :let={result} label="Title">
+          <:col :let={result} label="Title" class="truncate max-w-xs">
             <.subtle_link href={~p"/sources/#{result.source_id}/media/#{result.id}"}>
-              <%= StringUtils.truncate(result.title, 35) %>
+              {result.title}
             </.subtle_link>
           </:col>
           <:col :let={result} label="Excerpt">

lib/pinchflat_web/controllers/settings/setting_html/setting_form.html.heex

@@ -19,11 +19,11 @@
       </span>
     </section>
 
-    <%= live_render(
+    {live_render(
       @conn,
       Pinchflat.Settings.AppriseServerLive,
       session: %{"value" => f[:apprise_server].value}
-    ) %>
+    )}
   </section>
 
   <section class="mt-8">

lib/pinchflat_web/controllers/sources/source_controller.ex

@@ -1,12 +1,11 @@
 defmodule PinchflatWeb.Sources.SourceController do
   use PinchflatWeb, :controller
-  use Pinchflat.Media.MediaQuery
+  use Pinchflat.Sources.SourcesQuery
 
   alias Pinchflat.Repo
   alias Pinchflat.Tasks
   alias Pinchflat.Sources
   alias Pinchflat.Sources.Source
-  alias Pinchflat.Media.MediaItem
   alias Pinchflat.Profiles.MediaProfile
   alias Pinchflat.Media.FileSyncingWorker
   alias Pinchflat.Sources.SourceDeletionWorker
@@ -15,33 +14,7 @@ defmodule PinchflatWeb.Sources.SourceController do
   alias Pinchflat.Metadata.SourceMetadataStorageWorker
 
   def index(conn, _params) do
-    source_query =
-      from s in Source,
-        as: :source,
-        inner_join: mp in assoc(s, :media_profile),
-        where: is_nil(s.marked_for_deletion_at) and is_nil(mp.marked_for_deletion_at),
-        preload: [media_profile: mp],
-        order_by: [asc: s.custom_name],
-        select: map(s, ^Source.__schema__(:fields)),
-        select_merge: %{
-          downloaded_count:
-            subquery(
-              from m in MediaItem,
-                where: m.source_id == parent_as(:source).id,
-                where: ^MediaQuery.downloaded(),
-                select: count(m.id)
-            ),
-          pending_count:
-            subquery(
-              from m in MediaItem,
-                join: s in assoc(m, :source),
-                where: m.source_id == parent_as(:source).id,
-                where: ^MediaQuery.pending(),
-                select: count(m.id)
-            )
-        }
-
-    render(conn, :index, sources: Repo.all(source_query))
+    render(conn, :index)
   end
 
   def new(conn, params) do
@@ -67,7 +40,8 @@ defmodule PinchflatWeb.Sources.SourceController do
             collection_name: nil,
             collection_id: nil,
             collection_type: nil,
-            original_url: nil
+            original_url: nil,
+            marked_for_deletion_at: nil
         })
     )
   end

lib/pinchflat_web/controllers/sources/source_html.ex

@@ -27,10 +27,26 @@ defmodule PinchflatWeb.Sources.SourceHTML do
     ]
   end
 
+  def cutoff_date_presets do
+    [
+      {"7 days", compute_date_offset(7)},
+      {"14 days", compute_date_offset(14)},
+      {"30 days", compute_date_offset(30)},
+      {"60 days", compute_date_offset(60)},
+      {"90 days", compute_date_offset(90)},
+      {"180 days", compute_date_offset(180)},
+      {"365 days", compute_date_offset(365)}
+    ]
+  end
+
   def rss_feed_url(conn, source) do
     url(conn, ~p"/sources/#{source.uuid}/feed") <> ".xml"
   end
 
+  def opml_feed_url(conn) do
+    url(conn, ~p"/sources/opml") <> ".xml"
+  end
+
   def output_path_template_override_placeholders(media_profiles) do
     media_profiles
     |> Enum.map(&{&1.id, &1.output_path_template})
@@ -55,4 +71,13 @@ defmodule PinchflatWeb.Sources.SourceHTML do
     Must end with .{{ ext }}. Same rules as Media Profile output path templates. #{help_button} to load your media profile's output template
     """
   end
+
+  defp compute_date_offset(days) do
+    timezone = Application.get_env(:pinchflat, :timezone)
+
+    timezone
+    |> Timex.now()
+    |> Timex.shift(days: -days)
+    |> Timex.format!("{YYYY}-{0M}-{0D}")
+  end
 end

lib/pinchflat_web/controllers/sources/source_html/edit.html.heex

@@ -2,8 +2,8 @@
   <.link href={~p"/sources"}>
     <.icon name="hero-arrow-left" class="w-10 h-10 hover:dark:text-white" />
   </.link>
-  <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4">
-    Editing "<%= @source.custom_name %>"
+  <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4 truncate">
+    Editing "{@source.custom_name}"
   </h2>
 </div>
 

lib/pinchflat_web/controllers/sources/source_html/index.html.heex

@@ -1,6 +1,16 @@
 <div class="mb-6 flex gap-3 flex-row items-center justify-between">
   <h2 class="text-title-md2 font-bold text-black dark:text-white">Sources</h2>
   <nav>
+    <.button color="bg-transparent" x-data="{ copied: false }" x-on:click={~s"
+          copyWithCallbacks(
+            '#{opml_feed_url(@conn)}',
+            () => copied = true,
+            () => copied = false
+          )
+        "}>
+      Copy OPML Feed
+      <span x-show="copied" x-transition.duration.150ms><.icon name="hero-check" class="ml-2 h-4 w-4" /></span>
+    </.button>
     <.link href={~p"/sources/new"}>
       <.button color="bg-primary" rounding="rounded-lg">
         <span class="font-bold mx-2">+</span> New <span class="hidden sm:inline pl-1">Source</span>
@@ -11,33 +21,12 @@
 
 <div class="rounded-sm border border-stroke bg-white shadow-default dark:border-strokedark dark:bg-boxdark">
   <div class="max-w-full overflow-x-auto">
-    <div class="flex flex-col gap-10 min-w-max">
-      <.table rows={@sources} table_class="text-black dark:text-white">
-        <:col :let={source} label="Name">
-          <.subtle_link href={~p"/sources/#{source.id}"}>
-            <%= StringUtils.truncate(source.custom_name || source.collection_name, 35) %>
-          </.subtle_link>
-        </:col>
-        <:col :let={source} label="Type"><%= source.collection_type %></:col>
-        <:col :let={source} label="Pending"><.localized_number number={source.pending_count} /></:col>
-        <:col :let={source} label="Downloaded"><.localized_number number={source.downloaded_count} /></:col>
-        <:col :let={source} label="Retention">
-          <%= if source.retention_period_days && source.retention_period_days > 0 do %>
-            <.localized_number number={source.retention_period_days} />
-            <.pluralize count={source.retention_period_days} word="day" />
-          <% else %>
-            <span class="text-lg">∞</span>
-          <% end %>
-        </:col>
-        <:col :let={source} label="Media Profile">
-          <.subtle_link href={~p"/media_profiles/#{source.media_profile_id}"}>
-            <%= source.media_profile.name %>
-          </.subtle_link>
-        </:col>
-        <:col :let={source} label="" class="flex place-content-evenly">
-          <.icon_link href={~p"/sources/#{source.id}/edit"} icon="hero-pencil-square" class="mx-1" />
-        </:col>
-      </.table>
-    </div>
+    {live_render(@conn, PinchflatWeb.Sources.SourceLive.IndexTableLive,
+      session: %{
+        "initial_sort_key" => :custom_name,
+        "initial_sort_direction" => :asc,
+        "results_per_page" => 10
+      }
+    )}
   </div>
 </div>

lib/pinchflat_web/controllers/sources/source_html/index_table_live.ex

@@ -0,0 +1,103 @@
+defmodule PinchflatWeb.Sources.IndexTableLive do
+  use PinchflatWeb, :live_view
+  use Pinchflat.Media.MediaQuery
+  use Pinchflat.Sources.SourcesQuery
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Sources
+  alias Pinchflat.Sources.Source
+  alias Pinchflat.Media.MediaItem
+
+  def render(assigns) do
+    ~H"""
+    <.table rows={@sources} table_class="text-white">
+      <:col :let={source} label="Name" class="truncate max-w-xs">
+        <.subtle_link href={~p"/sources/#{source.id}"}>
+          {source.custom_name || source.collection_name}
+        </.subtle_link>
+      </:col>
+      <:col :let={source} label="Pending">
+        <.subtle_link href={~p"/sources/#{source.id}/#tab-pending"}>
+          <.localized_number number={source.pending_count} />
+        </.subtle_link>
+      </:col>
+      <:col :let={source} label="Downloaded">
+        <.subtle_link href={~p"/sources/#{source.id}/#tab-downloaded"}>
+          <.localized_number number={source.downloaded_count} />
+        </.subtle_link>
+      </:col>
+      <:col :let={source} label="Retention">
+        <%= if source.retention_period_days && source.retention_period_days > 0 do %>
+          <.localized_number number={source.retention_period_days} />
+          <.pluralize count={source.retention_period_days} word="day" />
+        <% else %>
+          <span class="text-lg">∞</span>
+        <% end %>
+      </:col>
+      <:col :let={source} label="Media Profile">
+        <.subtle_link href={~p"/media_profiles/#{source.media_profile_id}"}>
+          {source.media_profile.name}
+        </.subtle_link>
+      </:col>
+      <:col :let={source} label="Enabled?">
+        <.input
+          name={"source[#{source.id}][enabled]"}
+          value={source.enabled}
+          id={"source_#{source.id}_enabled"}
+          phx-hook="formless-input"
+          data-subscribe="change"
+          data-event-name="toggle_enabled"
+          data-identifier={source.id}
+          type="toggle"
+        />
+      </:col>
+      <:col :let={source} label="" class="flex place-content-evenly">
+        <.icon_link href={~p"/sources/#{source.id}/edit"} icon="hero-pencil-square" class="mx-1" />
+      </:col>
+    </.table>
+    """
+  end
+
+  def mount(_params, _session, socket) do
+    {:ok, assign(socket, %{sources: get_sources()})}
+  end
+
+  def handle_event("formless-input", %{"event" => "toggle_enabled"} = params, socket) do
+    source = Sources.get_source!(params["id"])
+    should_enable = params["value"] == "true"
+
+    {:ok, _} = Sources.update_source(source, %{enabled: should_enable})
+
+    {:noreply, assign(socket, %{sources: get_sources()})}
+  end
+
+  defp get_sources do
+    query =
+      from s in Source,
+        as: :source,
+        inner_join: mp in assoc(s, :media_profile),
+        where: is_nil(s.marked_for_deletion_at) and is_nil(mp.marked_for_deletion_at),
+        preload: [media_profile: mp],
+        order_by: [asc: s.custom_name],
+        select: map(s, ^Source.__schema__(:fields)),
+        select_merge: %{
+          downloaded_count:
+            subquery(
+              from m in MediaItem,
+                where: m.source_id == parent_as(:source).id,
+                where: ^MediaQuery.downloaded(),
+                select: count(m.id)
+            ),
+          pending_count:
+            subquery(
+              from m in MediaItem,
+                join: s in assoc(m, :source),
+                where: m.source_id == parent_as(:source).id,
+                where: ^MediaQuery.pending(),
+                select: count(m.id)
+            )
+        }
+
+    Repo.all(query)
+  end
+end

lib/pinchflat_web/controllers/sources/source_html/media_item_table_live.ex

@@ -1,4 +1,4 @@
-defmodule Pinchflat.Sources.MediaItemTableLive do
+defmodule PinchflatWeb.Sources.MediaItemTableLive do
   use PinchflatWeb, :live_view
   use Pinchflat.Media.MediaQuery
 
@@ -46,16 +46,16 @@ defmodule Pinchflat.Sources.MediaItemTableLive do
         </div>
       </header>
       <.table rows={@records} table_class="text-white">
-        <:col :let={media_item} label="Title">
+        <:col :let={media_item} label="Title" class="truncate max-w-xs">
           <.subtle_link href={~p"/sources/#{@source.id}/media/#{media_item.id}"}>
-            <%= StringUtils.truncate(media_item.title, 50) %>
+            {media_item.title}
           </.subtle_link>
         </:col>
         <:col :let={media_item} :if={@media_state == "other"} label="Manually Ignored?">
           <.icon name={if media_item.prevent_download, do: "hero-check", else: "hero-x-mark"} />
         </:col>
         <:col :let={media_item} label="Upload Date">
-          <%= DateTime.to_date(media_item.uploaded_at) %>
+          {DateTime.to_date(media_item.uploaded_at)}
         </:col>
         <:col :let={media_item} label="" class="flex justify-end">
           <.icon_link href={~p"/sources/#{@source.id}/media/#{media_item.id}/edit"} icon="hero-pencil-square" class="mr-4" />

lib/pinchflat_web/controllers/sources/source_html/show.html.heex

@@ -1,10 +1,10 @@
 <div class="mb-6 flex gap-3 flex-row items-center justify-between">
-  <div class="flex gap-3 items-center">
+  <div class="flex gap-3 items-center min-w-0">
     <.link href={~p"/sources"}>
       <.icon name="hero-arrow-left" class="w-10 h-10 hover:dark:text-white" />
     </.link>
-    <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4">
-      <%= @source.custom_name %>
+    <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4 truncate">
+      {@source.custom_name}
     </h2>
   </div>
 
@@ -29,7 +29,7 @@
           <section>
             <strong>Media Profile:</strong>
             <.subtle_link href={~p"/media_profiles/#{@source.media_profile_id}"}>
-              <%= @source.media_profile.name %>
+              {@source.media_profile.name}
             </.subtle_link>
           </section>
 
@@ -37,34 +37,34 @@
         </div>
       </:tab>
       <:tab title="Pending" id="pending">
-        <%= live_render(
+        {live_render(
           @conn,
-          Pinchflat.Sources.MediaItemTableLive,
+          PinchflatWeb.Sources.MediaItemTableLive,
           session: %{"source_id" => @source.id, "media_state" => "pending"}
-        ) %>
+        )}
       </:tab>
       <:tab title="Downloaded" id="downloaded">
-        <%= live_render(
+        {live_render(
           @conn,
-          Pinchflat.Sources.MediaItemTableLive,
+          PinchflatWeb.Sources.MediaItemTableLive,
           session: %{"source_id" => @source.id, "media_state" => "downloaded"}
-        ) %>
+        )}
       </:tab>
       <:tab title="Other" id="other">
-        <%= live_render(
+        {live_render(
           @conn,
-          Pinchflat.Sources.MediaItemTableLive,
+          PinchflatWeb.Sources.MediaItemTableLive,
           session: %{"source_id" => @source.id, "media_state" => "other"}
-        ) %>
+        )}
       </:tab>
       <:tab title="Tasks" id="tasks">
         <%= if match?([_|_], @pending_tasks) do %>
           <.table rows={@pending_tasks} table_class="text-black dark:text-white">
             <:col :let={task} label="Worker">
-              <%= task.job.worker %>
+              {task.job.worker}
             </:col>
             <:col :let={task} label="State">
-              <%= task.job.state %>
+              {task.job.state}
             </:col>
             <:col :let={task} label="Scheduled At">
               <.datetime_in_zone datetime={task.job.scheduled_at} />

lib/pinchflat_web/controllers/sources/source_html/source_form.html.heex

@@ -111,6 +111,7 @@
       />
     </section>
 
+    <section x-data={"{ cutoffDate: '#{f[:download_cutoff_date].value}' }"}>
       <.input
         field={f[:download_cutoff_date]}
         type="text"
@@ -120,7 +121,21 @@
         pattern="((?:19|20)[0-9][0-9])-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])"
         title="YYYY-MM-DD"
         help="Only download media uploaded after this date. Leave blank to download all media. Must be in YYYY-MM-DD format. Old media may be deleted or downloaded if you change this date"
+        x-model="cutoffDate"
+      >
+        <:input_append>
+          <.input
+            prompt="Select preset"
+            name="download_cutoff_date_preset"
+            value=""
+            options={cutoff_date_presets()}
+            type="select"
+            inputclass="w-30 lg:w-60 ml-2 md:ml-4"
+            x-on:change={"cutoffDate = $event.target.value || '#{f[:download_cutoff_date].value}'"}
           />
+        </:input_append>
+      </.input>
+    </section>
 
     <.input
       field={f[:retention_period_days]}

lib/pinchflat_web/controllers/sources/source_live/index_table_live.ex

@@ -0,0 +1,108 @@
+defmodule PinchflatWeb.Sources.SourceLive.IndexTableLive do
+  use PinchflatWeb, :live_view
+  use Pinchflat.Media.MediaQuery
+  use Pinchflat.Sources.SourcesQuery
+
+  import PinchflatWeb.Helpers.SortingHelpers
+  import PinchflatWeb.Helpers.PaginationHelpers
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Sources.Source
+  alias Pinchflat.Media.MediaItem
+
+  def mount(_params, session, socket) do
+    limit = session["results_per_page"]
+
+    initial_params =
+      Map.merge(
+        %{
+          sort_key: session["initial_sort_key"],
+          sort_direction: session["initial_sort_direction"]
+        },
+        get_pagination_attributes(sources_query(), 1, limit)
+      )
+
+    socket
+    |> assign(initial_params)
+    |> set_sources()
+    |> then(&{:ok, &1})
+  end
+
+  def handle_event("page_change", %{"direction" => direction}, %{assigns: assigns} = socket) do
+    new_page = update_page_number(assigns.page, direction, assigns.total_pages)
+
+    socket
+    |> assign(get_pagination_attributes(sources_query(), new_page, assigns.limit))
+    |> set_sources()
+    |> then(&{:noreply, &1})
+  end
+
+  def handle_event("sort_update", %{"sort_key" => sort_key}, %{assigns: assigns} = socket) do
+    new_sort_key = String.to_existing_atom(sort_key)
+
+    new_params = %{
+      sort_key: new_sort_key,
+      sort_direction: get_sort_direction(assigns.sort_key, new_sort_key, assigns.sort_direction)
+    }
+
+    socket
+    |> assign(new_params)
+    |> set_sources()
+    |> then(&{:noreply, &1})
+  end
+
+  defp sort_attr(:pending_count), do: dynamic([s, mp, dl, pe], pe.pending_count)
+  defp sort_attr(:downloaded_count), do: dynamic([s, mp, dl], dl.downloaded_count)
+  defp sort_attr(:media_size_bytes), do: dynamic([s, mp, dl], dl.media_size_bytes)
+  defp sort_attr(:media_profile_name), do: dynamic([s, mp], mp.name)
+  defp sort_attr(:custom_name), do: dynamic([s], s.custom_name)
+  defp sort_attr(:enabled), do: dynamic([s], s.enabled)
+
+  defp set_sources(%{assigns: assigns} = socket) do
+    sources =
+      sources_query()
+      |> order_by(^[{assigns.sort_direction, sort_attr(assigns.sort_key)}, asc: :id])
+      |> limit(^assigns.limit)
+      |> offset(^assigns.offset)
+      |> Repo.all()
+
+    assign(socket, %{sources: sources})
+  end
+
+  defp sources_query do
+    downloaded_subquery =
+      from(
+        m in MediaItem,
+        select: %{downloaded_count: count(m.id), source_id: m.source_id, media_size_bytes: sum(m.media_size_bytes)},
+        where: ^MediaQuery.downloaded(),
+        group_by: m.source_id
+      )
+
+    pending_subquery =
+      from(
+        m in MediaItem,
+        inner_join: s in assoc(m, :source),
+        inner_join: mp in assoc(s, :media_profile),
+        select: %{pending_count: count(m.id), source_id: m.source_id},
+        where: ^MediaQuery.pending(),
+        group_by: m.source_id
+      )
+
+    from s in Source,
+      as: :source,
+      inner_join: mp in assoc(s, :media_profile),
+      left_join: d in subquery(downloaded_subquery),
+      on: d.source_id == s.id,
+      left_join: p in subquery(pending_subquery),
+      on: p.source_id == s.id,
+      on: d.source_id == s.id,
+      where: is_nil(s.marked_for_deletion_at) and is_nil(mp.marked_for_deletion_at),
+      preload: [media_profile: mp],
+      select: map(s, ^Source.__schema__(:fields)),
+      select_merge: %{
+        downloaded_count: coalesce(d.downloaded_count, 0),
+        pending_count: coalesce(p.pending_count, 0),
+        media_size_bytes: coalesce(d.media_size_bytes, 0)
+      }
+  end
+end

lib/pinchflat_web/controllers/sources/source_live/index_table_live.html.heex

@@ -0,0 +1,41 @@
+<div class="flex flex-col min-w-max">
+  <.table rows={@sources} table_class="text-white" sort_key={@sort_key} sort_direction={@sort_direction}>
+    <:col :let={source} label="Name" sort_key="custom_name" class="truncate max-w-xs">
+      <.subtle_link href={~p"/sources/#{source.id}"}>
+        {source.custom_name}
+      </.subtle_link>
+    </:col>
+    <:col :let={source} label="Pending" sort_key="pending_count">
+      <.subtle_link href={~p"/sources/#{source.id}/#tab-pending"}>
+        <.localized_number number={source.pending_count} />
+      </.subtle_link>
+    </:col>
+    <:col :let={source} label="Downloaded" sort_key="downloaded_count">
+      <.subtle_link href={~p"/sources/#{source.id}/#tab-downloaded"}>
+        <.localized_number number={source.downloaded_count} />
+      </.subtle_link>
+    </:col>
+    <:col :let={source} label="Size" sort_key="media_size_bytes">
+      <.readable_filesize byte_size={source.media_size_bytes} />
+    </:col>
+    <:col :let={source} label="Media Profile" sort_key="media_profile_name" class="truncate max-w-xs">
+      <.subtle_link href={~p"/media_profiles/#{source.media_profile_id}"}>
+        {source.media_profile.name}
+      </.subtle_link>
+    </:col>
+    <:col :let={source} label="Enabled?" sort_key="enabled">
+      <.live_component
+        module={PinchflatWeb.Sources.SourceLive.SourceEnableToggle}
+        source={source}
+        id={"source_#{source.id}_enabled"}
+      />
+    </:col>
+    <:col :let={source} label="" class="flex place-content-evenly">
+      <.icon_link href={~p"/sources/#{source.id}/edit"} icon="hero-pencil-square" class="mx-1" />
+    </:col>
+  </.table>
+
+  <section class="flex justify-center my-5">
+    <.live_pagination_controls page_number={@page} total_pages={@total_pages} />
+  </section>
+</div>

lib/pinchflat_web/controllers/sources/source_live/source_enable_toggle.ex

@@ -0,0 +1,35 @@
+defmodule PinchflatWeb.Sources.SourceLive.SourceEnableToggle do
+  use PinchflatWeb, :live_component
+
+  alias Pinchflat.Sources
+  alias Pinchflat.Sources.Source
+
+  def render(assigns) do
+    ~H"""
+    <div>
+      <.form :let={f} for={@form} phx-change="update" phx-target={@myself} class="enabled_toggle_form">
+        <.input id={"source_#{@source_id}_enabled_input"} field={f[:enabled]} type="toggle" />
+      </.form>
+    </div>
+    """
+  end
+
+  def update(assigns, socket) do
+    initial_data = %{
+      source_id: assigns.source.id,
+      form: Sources.change_source(%Source{}, assigns.source)
+    }
+
+    socket
+    |> assign(initial_data)
+    |> then(&{:ok, &1})
+  end
+
+  def handle_event("update", %{"source" => source_params}, %{assigns: assigns} = socket) do
+    assigns.source_id
+    |> Sources.get_source!()
+    |> Sources.update_source(source_params)
+
+    {:noreply, socket}
+  end
+end

lib/pinchflat_web/helpers/pagination_helpers.ex

@@ -0,0 +1,45 @@
+defmodule PinchflatWeb.Helpers.PaginationHelpers do
+  @moduledoc """
+  Methods for working with pagination, usually in the context of LiveViews or LiveComponents.
+
+  These methods are fairly simple, but they're commonly repeated across different Live entities
+  """
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Utils.NumberUtils
+
+  @doc """
+  Given a query, a page number, and a number of records per page, returns a map of pagination attributes.
+
+  Returns map()
+  """
+  def get_pagination_attributes(query, page, records_per_page) do
+    total_record_count = Repo.aggregate(query, :count, :id)
+    total_pages = max(ceil(total_record_count / records_per_page), 1)
+    clamped_page = NumberUtils.clamp(page, 1, total_pages)
+
+    %{
+      page: clamped_page,
+      total_pages: total_pages,
+      total_record_count: total_record_count,
+      limit: records_per_page,
+      offset: (clamped_page - 1) * records_per_page
+    }
+  end
+
+  @doc """
+  Given a current page number, a direction to move in, and the total number of pages, returns the updated page number.
+  The updated page number is clamped to the range [1, total_pages].
+
+  Returns integer()
+  """
+  def update_page_number(current_page, direction, total_pages) do
+    updated_page =
+      case to_string(direction) do
+        "inc" -> current_page + 1
+        "dec" -> current_page - 1
+      end
+
+    NumberUtils.clamp(updated_page, 1, total_pages)
+  end
+end

lib/pinchflat_web/helpers/sorting_helpers.ex

@@ -0,0 +1,20 @@
+defmodule PinchflatWeb.Helpers.SortingHelpers do
+  @moduledoc """
+  Methods for working with sorting, usually in the context of LiveViews or LiveComponents.
+
+  These methods are fairly simple, but they're commonly repeated across different Live entities
+  """
+
+  @doc """
+  Given the old sort attribute, the new sort attribute, and the old sort direction, returns the new sort direction.
+
+  Returns :asc | :desc
+  """
+  def get_sort_direction(old_sort_attr, new_sort_attr, old_sort_direction) do
+    case {new_sort_attr, old_sort_direction} do
+      {^old_sort_attr, :desc} -> :asc
+      {^old_sort_attr, _} -> :desc
+      _ -> :asc
+    end
+  end
+end

lib/pinchflat_web/router.ex

@@ -23,6 +23,20 @@ defmodule PinchflatWeb.Router do
     plug :maybe_basic_auth
   end
 
+  # Routes in here _may not be_ protected by basic auth. This is necessary for
+  # media streaming to work for RSS podcast feeds.
+  scope "/", PinchflatWeb do
+    pipe_through :feeds
+    # has to match before /sources/:id
+    get "/sources/opml", Podcasts.PodcastController, :opml_feed
+
+    get "/sources/:uuid/feed", Podcasts.PodcastController, :rss_feed
+    get "/sources/:uuid/feed_image", Podcasts.PodcastController, :feed_image
+    get "/media/:uuid/episode_image", Podcasts.PodcastController, :episode_image
+
+    get "/media/:uuid/stream", MediaItems.MediaItemController, :stream
+  end
+
   scope "/", PinchflatWeb do
     pipe_through :browser
 
@@ -48,18 +62,6 @@ defmodule PinchflatWeb.Router do
     end
   end
 
-  # Routes in here _may not be_ protected by basic auth. This is necessary for
-  # media streaming to work for RSS podcast feeds.
-  scope "/", PinchflatWeb do
-    pipe_through :feeds
-
-    get "/sources/:uuid/feed", Podcasts.PodcastController, :rss_feed
-    get "/sources/:uuid/feed_image", Podcasts.PodcastController, :feed_image
-    get "/media/:uuid/episode_image", Podcasts.PodcastController, :episode_image
-
-    get "/media/:uuid/stream", MediaItems.MediaItemController, :stream
-  end
-
   # No auth or CSRF protection for the health check endpoint
   scope "/", PinchflatWeb do
     pipe_through :api

mix.exs

@@ -4,7 +4,7 @@ defmodule Pinchflat.MixProject do
   def project do
     [
       app: :pinchflat,
-      version: "2024.10.30",
+      version: "2024.12.29",
       elixir: "~> 1.17",
       elixirc_paths: elixirc_paths(Mix.env()),
       start_permanent: Mix.env() == :prod,
@@ -54,8 +54,8 @@ defmodule Pinchflat.MixProject do
       {:ecto_sqlite3_extras, "~> 1.2.0"},
       {:phoenix_html, "~> 3.3"},
       {:phoenix_live_reload, "~> 1.2", only: :dev},
-      {:phoenix_live_view, "~> 0.20.1"},
-      {:floki, ">= 0.30.0", only: :test},
+      {:phoenix_live_view, "~> 1.0.0"},
+      {:floki, ">= 0.36.0", only: :test},
       {:phoenix_live_dashboard, "~> 0.8.2"},
       {:esbuild, "~> 0.8", runtime: Mix.env() == :dev},
       {:tailwind, "~> 0.2.0", runtime: Mix.env() == :dev},

mix.lock

@@ -1,6 +1,6 @@
 %{
   "bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},
-  "castore": {:hex, :castore, "1.0.8", "dedcf20ea746694647f883590b82d9e96014057aff1d44d03ec90f36a5c0dc6e", [:mix], [], "hexpm", "0b2b66d2ee742cb1d9cb8c8be3b43c3a70ee8651f37b75a8b982e036752983f1"},
+  "castore": {:hex, :castore, "1.0.10", "43bbeeac820f16c89f79721af1b3e092399b3a1ecc8df1a472738fd853574911", [:mix], [], "hexpm", "1b0b7ea14d889d9ea21202c43a4fa015eb913021cb535e8ed91946f4b77a8848"},
   "cc_precompiler": {:hex, :cc_precompiler, "0.1.10", "47c9c08d8869cf09b41da36538f62bc1abd3e19e41701c2cea2675b53c704258", [:mix], [{:elixir_make, "~> 0.7", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "f6e046254e53cd6b41c6bacd70ae728011aa82b2742a80d6e2214855c6e06b22"},
   "certifi": {:hex, :certifi, "2.12.0", "2d1cca2ec95f59643862af91f001478c9863c2ac9cb6e2f89780bfd8de987329", [:rebar3], [], "hexpm", "ee68d85df22e554040cdb4be100f33873ac6051387baf6a8f6ce82272340ff1c"},
   "combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},
@@ -10,7 +10,7 @@
   "credo": {:hex, :credo, "1.7.7", "771445037228f763f9b2afd612b6aa2fd8e28432a95dbbc60d8e03ce71ba4446", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "8bc87496c9aaacdc3f90f01b7b0582467b69b4bd2441fe8aae3109d843cc2f2e"},
   "credo_naming": {:hex, :credo_naming, "2.1.0", "d44ad58890d4db552e141ce64756a74ac1573665af766d1ac64931aa90d47744", [:make, :mix], [{:credo, "~> 1.6", [hex: :credo, repo: "hexpm", optional: false]}], "hexpm", "830e23b3fba972e2fccec49c0c089fe78c1e64bc16782a2682d78082351a2909"},
   "db_connection": {:hex, :db_connection, "2.7.0", "b99faa9291bb09892c7da373bb82cba59aefa9b36300f6145c5f201c7adf48ec", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "dcf08f31b2701f857dfc787fbad78223d61a32204f217f15e881dd93e4bdd3ff"},
-  "decimal": {:hex, :decimal, "2.1.1", "5611dca5d4b2c3dd497dec8f68751f1f1a54755e8ed2a966c2633cf885973ad6", [:mix], [], "hexpm", "53cfe5f497ed0e7771ae1a475575603d77425099ba5faef9394932b35020ffcc"},
+  "decimal": {:hex, :decimal, "2.2.0", "df3d06bb9517e302b1bd265c1e7f16cda51547ad9d99892049340841f3e15836", [:mix], [], "hexpm", "af8daf87384b51b7e611fb1a1f2c4d4876b65ef968fa8bd3adf44cff401c7f21"},
   "dns_cluster": {:hex, :dns_cluster, "0.1.2", "3eb5be824c7888dadf9781018e1a5f1d3d1113b333c50bce90fb1b83df1015f2", [:mix], [], "hexpm", "7494272040f847637bbdb01bcdf4b871e82daf09b813e7d3cb3b84f112c6f2f8"},
   "ecto": {:hex, :ecto, "3.12.3", "1a9111560731f6c3606924c81c870a68a34c819f6d4f03822f370ea31a582208", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "9efd91506ae722f95e48dc49e70d0cb632ede3b7a23896252a60a14ac6d59165"},
   "ecto_sql": {:hex, :ecto_sql, "3.12.0", "73cea17edfa54bde76ee8561b30d29ea08f630959685006d9c6e7d1e59113b7d", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.12", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.7", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.19 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "dc9e4d206f274f3947e96142a8fdc5f69a2a6a9abb4649ef5c882323b6d512f0"},
@@ -24,7 +24,7 @@
   "faker": {:hex, :faker, "0.17.0", "671019d0652f63aefd8723b72167ecdb284baf7d47ad3a82a15e9b8a6df5d1fa", [:mix], [], "hexpm", "a7d4ad84a93fd25c5f5303510753789fc2433ff241bf3b4144d3f6f291658a6a"},
   "file_system": {:hex, :file_system, "0.2.10", "fb082005a9cd1711c05b5248710f8826b02d7d1784e7c3451f9c1231d4fc162d", [:mix], [], "hexpm", "41195edbfb562a593726eda3b3e8b103a309b733ad25f3d642ba49696bf715dc"},
   "finch": {:hex, :finch, "0.17.0", "17d06e1d44d891d20dbd437335eebe844e2426a0cd7e3a3e220b461127c73f70", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.3", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2.6 or ~> 1.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "8d014a661bb6a437263d4b5abf0bcbd3cf0deb26b1e8596f2a271d22e48934c7"},
-  "floki": {:hex, :floki, "0.35.2", "87f8c75ed8654b9635b311774308b2760b47e9a579dabf2e4d5f1e1d42c39e0b", [:mix], [], "hexpm", "6b05289a8e9eac475f644f09c2e4ba7e19201fd002b89c28c1293e7bd16773d9"},
+  "floki": {:hex, :floki, "0.36.3", "1102f93b16a55bc5383b85ae3ec470f82dee056eaeff9195e8afdf0ef2a43c30", [:mix], [], "hexpm", "fe0158bff509e407735f6d40b3ee0d7deb47f3f3ee7c6c182ad28599f9f6b27a"},
   "gettext": {:hex, :gettext, "0.24.0", "6f4d90ac5f3111673cbefc4ebee96fe5f37a114861ab8c7b7d5b30a1108ce6d8", [:mix], [{:expo, "~> 0.5.1", [hex: :expo, repo: "hexpm", optional: false]}], "hexpm", "bdf75cdfcbe9e4622dd18e034b227d77dd17f0f133853a1c73b97b3d6c770e8b"},
   "hackney": {:hex, :hackney, "1.20.1", "8d97aec62ddddd757d128bfd1df6c5861093419f8f7a4223823537bad5d064e2", [:rebar3], [{:certifi, "~> 2.12.0", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "~> 6.1.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "~> 1.0.0", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~> 1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:parse_trans, "3.4.1", [hex: :parse_trans, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~> 1.1.0", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}, {:unicode_util_compat, "~> 0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "fe9094e5f1a2a2c0a7d10918fee36bfec0ec2a979994cff8cfe8058cd9af38e3"},
   "hpax": {:hex, :hpax, "0.1.2", "09a75600d9d8bbd064cdd741f21fc06fc1f4cf3d0fcc335e5aa19be1a7235c84", [:mix], [], "hexpm", "2c87843d5a23f5f16748ebe77969880e29809580efdaccd615cd3bed628a8c13"},
@@ -40,12 +40,12 @@
   "nimble_pool": {:hex, :nimble_pool, "1.0.0", "5eb82705d138f4dd4423f69ceb19ac667b3b492ae570c9f5c900bb3d2f50a847", [:mix], [], "hexpm", "80be3b882d2d351882256087078e1b1952a28bf98d0a287be87e4a24a710b67a"},
   "oban": {:hex, :oban, "2.18.3", "1608c04f8856c108555c379f2f56bc0759149d35fa9d3b825cb8a6769f8ae926", [:mix], [{:ecto_sql, "~> 3.10", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:ecto_sqlite3, "~> 0.9", [hex: :ecto_sqlite3, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "36ca6ca84ef6518f9c2c759ea88efd438a3c81d667ba23b02b062a0aa785475e"},
   "parse_trans": {:hex, :parse_trans, "3.4.1", "6e6aa8167cb44cc8f39441d05193be6e6f4e7c2946cb2759f015f8c56b76e5ff", [:rebar3], [], "hexpm", "620a406ce75dada827b82e453c19cf06776be266f5a67cff34e1ef2cbb60e49a"},
-  "phoenix": {:hex, :phoenix, "1.7.14", "a7d0b3f1bc95987044ddada111e77bd7f75646a08518942c72a8440278ae7825", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "c7859bc56cc5dfef19ecfc240775dae358cbaa530231118a9e014df392ace61a"},
+  "phoenix": {:hex, :phoenix, "1.7.17", "2fcdceecc6fb90bec26fab008f96abbd0fd93bc9956ec7985e5892cf545152ca", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "50e8ad537f3f7b0efb1509b2f75b5c918f697be6a45d48e49a30d3b7c0e464c9"},
   "phoenix_ecto": {:hex, :phoenix_ecto, "4.4.3", "86e9878f833829c3f66da03d75254c155d91d72a201eb56ae83482328dc7ca93", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "d36c401206f3011fefd63d04e8ef626ec8791975d9d107f9a0817d426f61ac07"},
   "phoenix_html": {:hex, :phoenix_html, "3.3.4", "42a09fc443bbc1da37e372a5c8e6755d046f22b9b11343bf885067357da21cb3", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "0249d3abec3714aff3415e7ee3d9786cb325be3151e6c4b3021502c585bf53fb"},
   "phoenix_live_dashboard": {:hex, :phoenix_live_dashboard, "0.8.3", "7ff51c9b6609470f681fbea20578dede0e548302b0c8bdf338b5a753a4f045bf", [:mix], [{:ecto, "~> 3.6.2 or ~> 3.7", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_mysql_extras, "~> 0.5", [hex: :ecto_mysql_extras, repo: "hexpm", optional: true]}, {:ecto_psql_extras, "~> 0.7", [hex: :ecto_psql_extras, repo: "hexpm", optional: true]}, {:ecto_sqlite3_extras, "~> 1.1.7 or ~> 1.2.0", [hex: :ecto_sqlite3_extras, repo: "hexpm", optional: true]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.19 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6 or ~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "f9470a0a8bae4f56430a23d42f977b5a6205fdba6559d76f932b876bfaec652d"},
   "phoenix_live_reload": {:hex, :phoenix_live_reload, "1.4.1", "2aff698f5e47369decde4357ba91fc9c37c6487a512b41732818f2204a8ef1d3", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "9bffb834e7ddf08467fe54ae58b5785507aaba6255568ae22b4d46e2bb3615ab"},
-  "phoenix_live_view": {:hex, :phoenix_live_view, "0.20.3", "8b6406bc0a451f295407d7acff7f234a6314be5bbe0b3f90ed82b07f50049878", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.15", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a8e4385e05618b424779f894ed2df97d3c7518b7285fcd11979077ae6226466b"},
+  "phoenix_live_view": {:hex, :phoenix_live_view, "1.0.0", "3a10dfce8f87b2ad4dc65de0732fc2a11e670b2779a19e8d3281f4619a85bce4", [:mix], [{:floki, "~> 0.36", [hex: :floki, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.15", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "254caef0028765965ca6bd104cc7d68dcc7d57cc42912bef92f6b03047251d99"},
   "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.1.3", "3168d78ba41835aecad272d5e8cd51aa87a7ac9eb836eabc42f6e57538e3731d", [:mix], [], "hexpm", "bba06bc1dcfd8cb086759f0edc94a8ba2bc8896d5331a1e2c2902bf8e36ee502"},
   "phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"},
   "plug": {:hex, :plug, "1.16.1", "40c74619c12f82736d2214557dedec2e9762029b2438d6d175c5074c933edc9d", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a13ff6b9006b03d7e33874945b2755253841b238c34071ed85b0e86057f8cddc"},
@@ -64,5 +64,5 @@
   "tzdata": {:hex, :tzdata, "1.1.2", "45e5f1fcf8729525ec27c65e163be5b3d247ab1702581a94674e008413eef50b", [:mix], [{:hackney, "~> 1.17", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "cec7b286e608371602318c414f344941d5eb0375e14cfdab605cca2fe66cba8b"},
   "unicode_util_compat": {:hex, :unicode_util_compat, "0.7.0", "bc84380c9ab48177092f43ac89e4dfa2c6d62b40b8bd132b1059ecc7232f9a78", [:rebar3], [], "hexpm", "25eee6d67df61960cf6a794239566599b09e17e668d3700247bc498638152521"},
   "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
-  "websock_adapter": {:hex, :websock_adapter, "0.5.7", "65fa74042530064ef0570b75b43f5c49bb8b235d6515671b3d250022cb8a1f9e", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "d0f478ee64deddfec64b800673fd6e0c8888b079d9f3444dd96d2a98383bdbd1"},
+  "websock_adapter": {:hex, :websock_adapter, "0.5.8", "3b97dc94e407e2d1fc666b2fb9acf6be81a1798a2602294aac000260a7c4a47d", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "315b9a1865552212b5f35140ad194e67ce31af45bcee443d4ecb96b5fd3f3782"},
 }

priv/repo/migrations/20241107201850_add_predicted_media_filepath_to_media_items.exs

@@ -0,0 +1,9 @@
+defmodule Pinchflat.Repo.Migrations.AddPredictedMediaFilepathToMediaItems do
+  use Ecto.Migration
+
+  def change do
+    alter table(:media_items) do
+      add :predicted_media_filepath, :string
+    end
+  end
+end

priv/repo/migrations/20241120204407_add_enabled_to_sources.exs

@@ -0,0 +1,9 @@
+defmodule Pinchflat.Repo.Migrations.AddEnabledToSources do
+  use Ecto.Migration
+
+  def change do
+    alter table(:sources) do
+      add :enabled, :boolean, default: true, null: false
+    end
+  end
+end

priv/repo/migrations/20241127172054_add_audio_lang_to_media_profiles.exs

@@ -0,0 +1,9 @@
+defmodule Pinchflat.Repo.Migrations.AddAudioLangToMediaProfiles do
+  use Ecto.Migration
+
+  def change do
+    alter table(:media_profiles) do
+      add :audio_track, :string
+    end
+  end
+end

test/pinchflat/boot/pre_job_startup_tasks_test.exs

@@ -9,6 +9,7 @@ defmodule Pinchflat.Boot.PreJobStartupTasksTest do
   setup do
     stub(YtDlpRunnerMock, :version, fn -> {:ok, "1"} end)
     stub(AppriseRunnerMock, :version, fn -> {:ok, "2"} end)
+    stub(UserScriptRunnerMock, :run, fn _event_type, _data -> {:ok, "3", 0} end)
 
     :ok
   end
@@ -112,4 +113,16 @@ defmodule Pinchflat.Boot.PreJobStartupTasksTest do
       assert Settings.get!(:apprise_version)
     end
   end
+
+  describe "run_app_init_script" do
+    test "calls the app_init user script runner" do
+      expect(UserScriptRunnerMock, :run, fn :app_init, data ->
+        assert data == %{}
+
+        {:ok, "", 0}
+      end)
+
+      PreJobStartupTasks.init(%{})
+    end
+  end
 end

test/pinchflat/downloading/download_option_builder_test.exs

@@ -6,7 +6,6 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilderTest do
 
   alias Pinchflat.Sources
   alias Pinchflat.Profiles
-  alias Pinchflat.Settings
   alias Pinchflat.Utils.FilesystemUtils
   alias Pinchflat.Downloading.DownloadOptionBuilder
 
@@ -253,21 +252,14 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilderTest do
   end
 
   describe "build/1 when testing media quality and format options" do
-    test "includes quality options" do
-      resolutions = ["360", "480", "720", "1080", "2160", "4320"]
-
-      Enum.each(resolutions, fn resolution ->
-        resolution_atom = String.to_existing_atom(resolution <> "p")
-
-        media_profile = media_profile_fixture(%{preferred_resolution: resolution_atom})
-        source = source_fixture(%{media_profile_id: media_profile.id})
-        media_item = Repo.preload(media_item_fixture(source_id: source.id), source: :media_profile)
+    # There are more tests inside QualityOptionBuilderTest
+    # This is essenitally just testing that we implement that module correctly
 
+    test "includes video options for video profiles", %{media_item: media_item} do
       assert {:ok, res} = DownloadOptionBuilder.build(media_item)
 
-        assert {:format_sort, "res:#{resolution},+codec:avc:m4a"} in res
+      assert {:format_sort, "res:1080,+codec:avc:m4a"} in res
       assert {:remux_video, "mp4"} in res
-      end)
     end
 
     test "includes quality options for audio only", %{media_item: media_item} do
@@ -280,33 +272,6 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilderTest do
 
       refute {:remux_video, "mp4"} in res
     end
-
-    test "includes custom quality options if specified", %{media_item: media_item} do
-      Settings.set(video_codec_preference: "av01")
-      Settings.set(audio_codec_preference: "aac")
-
-      media_item = update_media_profile_attribute(media_item, %{preferred_resolution: :"1080p"})
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-
-      assert {:format_sort, "res:1080,+codec:av01:aac"} in res
-    end
-
-    test "includes custom remux target for videos if specified", %{media_item: media_item} do
-      media_item = update_media_profile_attribute(media_item, %{media_container: "mkv"})
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-
-      assert {:remux_video, "mkv"} in res
-    end
-
-    test "includes custom format target for audio if specified", %{media_item: media_item} do
-      media_item = update_media_profile_attribute(media_item, %{media_container: "flac", preferred_resolution: :audio})
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-
-      assert {:audio_format, "flac"} in res
-    end
   end
 
   describe "build/1 when testing sponsorblock options" do
@@ -461,6 +426,22 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilderTest do
     end
   end
 
+  describe "build_quality_options_for/1" do
+    test "builds quality options for a media item", %{media_item: media_item} do
+      options = DownloadOptionBuilder.build_quality_options_for(media_item)
+
+      assert {:format_sort, "res:1080,+codec:avc:m4a"} in options
+      assert {:remux_video, "mp4"} in options
+    end
+
+    test "builds quality options for a source", %{media_item: media_item} do
+      options = DownloadOptionBuilder.build_quality_options_for(media_item.source)
+
+      assert {:format_sort, "res:1080,+codec:avc:m4a"} in options
+      assert {:remux_video, "mp4"} in options
+    end
+  end
+
   defp update_media_profile_attribute(media_item_with_preloads, attrs) do
     media_item_with_preloads.source.media_profile
     |> Profiles.change_media_profile(attrs)

test/pinchflat/downloading/media_download_worker_test.exs

@@ -9,7 +9,12 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
   alias Pinchflat.Downloading.MediaDownloadWorker
 
   setup do
-    stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+    stub(YtDlpRunnerMock, :run, fn
+      _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+      _url, :download_thumbnail, _opts, _ot, _addl -> {:ok, ""}
+      _url, :download, _opts, _ot, _addl -> {:ok, render_metadata(:media_metadata)}
+    end)
+
     stub(UserScriptRunnerMock, :run, fn _event_type, _data -> {:ok, "", 0} end)
     stub(HTTPClientMock, :get, fn _url, _headers, _opts -> {:ok, ""} end)
 
@@ -52,13 +57,17 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
   end
 
   describe "perform/1" do
-    test "it saves attributes to the media_item", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl ->
-        {:ok, render_metadata(:media_metadata)}
+    setup do
+      stub(YtDlpRunnerMock, :run, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+        _url, :download, _opts, _ot, _addl -> {:ok, render_metadata(:media_metadata)}
+        _url, :download_thumbnail, _opts, _ot, _addl -> {:ok, ""}
       end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+      :ok
+    end
 
+    test "it saves attributes to the media_item", %{media_item: media_item} do
       assert media_item.media_filepath == nil
       perform_job(MediaDownloadWorker, %{id: media_item.id})
       media_item = Repo.reload(media_item)
@@ -67,12 +76,6 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "it saves the metadata to the media_item", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl ->
-        {:ok, render_metadata(:media_metadata)}
-      end)
-
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
-
       assert media_item.metadata == nil
       perform_job(MediaDownloadWorker, %{id: media_item.id})
       assert Repo.reload(media_item).metadata != nil
@@ -86,7 +89,10 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "it sets the job to retryable if the download fails", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:error, "error"} end)
+      expect(YtDlpRunnerMock, :run, 2, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+        _url, :download, _opts, _ot, _addl -> {:error, "error"}
+      end)
 
       Oban.Testing.with_testing_mode(:inline, fn ->
         {:ok, job} = Oban.insert(MediaDownloadWorker.new(%{id: media_item.id}))
@@ -96,8 +102,9 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "sets the job to retryable if the download failed and was retried", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
-        {:error, "Unable to communicate with SponsorBlock", 1}
+      expect(YtDlpRunnerMock, :run, 2, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+        _url, :download, _opts, _ot, _addl -> {:error, "Unable to communicate with SponsorBlock", 1}
       end)
 
       Oban.Testing.with_testing_mode(:inline, fn ->
@@ -108,8 +115,9 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "does not set the job to retryable if retrying wouldn't fix the issue", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
-        {:error, "Something something Video unavailable something something", 1}
+      expect(YtDlpRunnerMock, :run, 2, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+        _url, :download, _opts, _ot, _addl -> {:error, "Something something Video unavailable something something", 1}
       end)
 
       Oban.Testing.with_testing_mode(:inline, fn ->
@@ -120,13 +128,16 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "it ensures error are returned in a 2-item tuple", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:error, "error", 1} end)
+      expect(YtDlpRunnerMock, :run, 2, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+        _url, :download, _opts, _ot, _addl -> {:error, "error", 1}
+      end)
 
       assert {:error, :download_failed} = perform_job(MediaDownloadWorker, %{id: media_item.id})
     end
 
     test "it does not download if the source is set to not download", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 0, fn _url, _opts, _ot, _addl -> :ok end)
+      expect(YtDlpRunnerMock, :run, 0, fn _url, :download, _opts, _ot, _addl -> :ok end)
 
       Sources.update_source(media_item.source, %{download_media: false})
 
@@ -134,7 +145,7 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "does not download if the media item is set to not download", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 0, fn _url, _opts, _ot, _addl -> :ok end)
+      expect(YtDlpRunnerMock, :run, 0, fn _url, :download, _opts, _ot, _addl -> :ok end)
 
       Media.update_media_item(media_item, %{prevent_download: true})
 
@@ -142,14 +153,19 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "it saves the file's size to the database", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download, _opts, _ot, _addl ->
           metadata = render_parsed_metadata(:media_metadata)
           FilesystemUtils.write_p!(metadata["filepath"], "test")
 
           {:ok, Phoenix.json_library().encode!(metadata)}
-      end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
 
       perform_job(MediaDownloadWorker, %{id: media_item.id})
       media_item = Repo.reload(media_item)
@@ -158,10 +174,6 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "does not set redownloaded_at by default", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 2, fn _url, _opts, _ot, _addl ->
-        {:ok, render_metadata(:media_metadata)}
-      end)
-
       perform_job(MediaDownloadWorker, %{id: media_item.id})
       media_item = Repo.reload(media_item)
 
@@ -173,23 +185,40 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "sets the no_force_overwrites runner option", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download, opts, _ot, _addl ->
           assert :no_force_overwrites in opts
           refute :force_overwrites in opts
 
           {:ok, render_metadata(:media_metadata)}
-      end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
 
       perform_job(MediaDownloadWorker, %{id: media_item.id})
     end
   end
 
+  describe "perform/1 when testing non-downloadable media" do
+    test "does not retry the job if the media is currently not downloadable", %{media_item: media_item} do
+      stub(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, _addl ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "is_live"})}
+      end)
+
+      Oban.Testing.with_testing_mode(:inline, fn ->
+        {:ok, job} = Oban.insert(MediaDownloadWorker.new(%{id: media_item.id}))
+
+        assert job.state == "completed"
+      end)
+    end
+  end
+
   describe "perform/1 when testing forced downloads" do
     test "ignores 'prevent_download' if forced", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> :ok end)
-
       Sources.update_source(media_item.source, %{download_media: false})
       Media.update_media_item(media_item, %{prevent_download: true})
 
@@ -197,14 +226,19 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "sets force_overwrites runner option", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download, opts, _ot, _addl ->
           assert :force_overwrites in opts
           refute :no_force_overwrites in opts
 
           {:ok, render_metadata(:media_metadata)}
-      end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
 
       perform_job(MediaDownloadWorker, %{id: media_item.id, force: true})
     end
@@ -212,12 +246,6 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
 
   describe "perform/1 when testing re-downloads" do
     test "sets redownloaded_at on the media_item", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl ->
-        {:ok, render_metadata(:media_metadata)}
-      end)
-
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
-
       perform_job(MediaDownloadWorker, %{id: media_item.id, quality_upgrade?: true})
       media_item = Repo.reload(media_item)
 
@@ -225,28 +253,38 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
 
     test "sets force_overwrites runner option", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download, opts, _ot, _addl ->
           assert :force_overwrites in opts
           refute :no_force_overwrites in opts
 
           {:ok, render_metadata(:media_metadata)}
-      end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
 
       perform_job(MediaDownloadWorker, %{id: media_item.id, force: true})
     end
 
     test "deletes old files if the media item has been updated" do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download, _opts, _ot, _addl ->
           tmp_media_item = media_item_with_attachments()
           metadata = render_parsed_metadata(:media_metadata)
           metadata = Map.put(metadata, "filepath", tmp_media_item.media_filepath)
 
           {:ok, Phoenix.json_library().encode!(metadata)}
-      end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
 
       old_media_item = media_item_with_attachments()
       perform_job(MediaDownloadWorker, %{id: old_media_item.id, force: true})
@@ -259,14 +297,6 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
   end
 
   describe "perform/1 when testing user script callbacks" do
-    setup do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
-        {:ok, render_metadata(:media_metadata)}
-      end)
-
-      :ok
-    end
-
     test "calls the media_pre_download user script runner", %{media_item: media_item} do
       expect(UserScriptRunnerMock, :run, fn :media_pre_download, data ->
         assert data.id == media_item.id

test/pinchflat/downloading/media_downloader_test.exs

@@ -16,14 +16,20 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
       )
 
     stub(HTTPClientMock, :get, fn _url, _headers, _opts -> {:ok, ""} end)
-    stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_args -> {:ok, ""} end)
 
     {:ok, %{media_item: media_item}}
   end
 
   describe "download_for_media_item/3" do
     test "calls the backend runner", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 1, fn url, _opts, ot, addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+
+        url, :download, _opts, ot, addl ->
           assert url == media_item.original_url
           assert ot == "after_move:%()j"
           assert [{:output_filepath, filepath} | _] = addl
@@ -32,14 +38,14 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
           {:ok, render_metadata(:media_metadata)}
       end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl_args -> {:ok, ""} end)
-
       assert {:ok, _} = MediaDownloader.download_for_media_item(media_item)
     end
 
     test "saves the metadata filepath to the database", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 2, fn _url, _opts, _ot, _addl ->
-        {:ok, render_metadata(:media_metadata)}
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+        _url, :download_thumbnail, _opts, _ot, _addl -> {:ok, ""}
+        _url, :download, _opts, _ot, _addl -> {:ok, render_metadata(:media_metadata)}
       end)
 
       assert is_nil(media_item.metadata)
@@ -49,17 +55,27 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
       assert updated_media_item.metadata.thumbnail_filepath =~ "media_items/#{media_item.id}/thumbnail.jpg"
     end
 
+    test "errors for non-downloadable media are passed through", %{media_item: media_item} do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, _addl ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "is_live"})}
+      end)
+
+      assert {:error, :unsuitable_for_download} = MediaDownloader.download_for_media_item(media_item)
+    end
+
     test "non-recoverable errors are passed through", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
-        {:error, :some_error, 1}
+      expect(YtDlpRunnerMock, :run, 2, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+        _url, :download, _opts, _ot, _addl -> {:error, :some_error, 1}
       end)
 
       assert {:error, :some_error} = MediaDownloader.download_for_media_item(media_item)
     end
 
     test "unknown errors are passed through", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
-        {:error, :some_error}
+      expect(YtDlpRunnerMock, :run, 2, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+        _url, :download, _opts, _ot, _addl -> {:error, :some_error}
       end)
 
       assert {:error, message} = MediaDownloader.download_for_media_item(media_item)
@@ -67,16 +83,55 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
     end
   end
 
+  describe "download_for_media_item/3 when testing non-downloadable media" do
+    test "calls the download runner if the media is currently downloadable", %{media_item: media_item} do
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, Phoenix.json_library().encode!(%{"live_status" => "was_live"})}
+
+        _url, :download, _opts, _ot, _addl ->
+          {:ok, render_metadata(:media_metadata)}
+
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
+
+      assert {:ok, _} = MediaDownloader.download_for_media_item(media_item)
+    end
+
+    test "does not call the download runner if the media is not downloadable", %{media_item: media_item} do
+      expect(YtDlpRunnerMock, :run, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, Phoenix.json_library().encode!(%{"live_status" => "is_live"})}
+      end)
+
+      expect(YtDlpRunnerMock, :run, 0, fn _url, :download, _opts, _ot, _addl -> {:ok, ""} end)
+
+      assert {:error, :unsuitable_for_download} = MediaDownloader.download_for_media_item(media_item)
+    end
+
+    test "returns unexpected errors from the download status determination method", %{media_item: media_item} do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, _addl -> {:error, :what_tha} end)
+
+      assert {:error, "Unknown error: {:error, :what_tha}"} = MediaDownloader.download_for_media_item(media_item)
+    end
+  end
+
   describe "download_for_media_item/3 when testing override options" do
     test "includes override opts if specified", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download, opts, _ot, _addl ->
           refute :force_overwrites in opts
           assert :no_force_overwrites in opts
 
           {:ok, render_metadata(:media_metadata)}
-      end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
 
       override_opts = [overwrite_behaviour: :no_force_overwrites]
 
@@ -86,12 +141,18 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
 
   describe "download_for_media_item/3 when testing cookie usage" do
     test "sets use_cookies if the source uses cookies" do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, addl ->
+          assert {:use_cookies, true} in addl
+          {:ok, "{}"}
+
+        _url, :download, _opts, _ot, addl ->
           assert {:use_cookies, true} in addl
           {:ok, render_metadata(:media_metadata)}
-      end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl_args -> {:ok, ""} end)
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
 
       source = source_fixture(%{use_cookies: true})
       media_item = media_item_fixture(%{source_id: source.id})
@@ -100,12 +161,17 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
     end
 
     test "does not set use_cookies if the source does not use cookies" do
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download, _opts, _ot, addl ->
           assert {:use_cookies, false} in addl
           {:ok, render_metadata(:media_metadata)}
-      end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl_args -> {:ok, ""} end)
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
 
       source = source_fixture(%{use_cookies: false})
       media_item = media_item_fixture(%{source_id: source.id})
@@ -118,7 +184,11 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
     test "returns a recovered tuple on recoverable errors", %{media_item: media_item} do
       message = "Unable to communicate with SponsorBlock"
 
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 2, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download, _opts, _ot, _addl ->
           {:error, message, 1}
       end)
 
@@ -128,14 +198,19 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
     test "attempts to update the media item on recoverable errors", %{media_item: media_item} do
       message = "Unable to communicate with SponsorBlock"
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :download, _opts, _ot, addl ->
           [{:output_filepath, filepath} | _] = addl
           File.write(filepath, render_metadata(:media_metadata))
 
           {:error, message, 1}
-      end)
 
-      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl_args -> {:ok, ""} end)
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
 
       assert {:recovered, ^message} = MediaDownloader.download_for_media_item(media_item)
       media_item = Repo.reload(media_item)
@@ -147,8 +222,10 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
 
   describe "download_for_media_item/3 when testing media_item attributes" do
     setup do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
-        {:ok, render_metadata(:media_metadata)}
+      stub(YtDlpRunnerMock, :run, fn
+        _url, :download, _opts, _ot, _addl -> {:ok, render_metadata(:media_metadata)}
+        _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+        _url, :download_thumbnail, _opts, _ot, _addl -> {:ok, ""}
       end)
 
       :ok
@@ -195,7 +272,11 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
     end
 
     test "extracts the thumbnail_filepath", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 2, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
+
+        _url, :download, _opts, _ot, _addl ->
           metadata = render_parsed_metadata(:media_metadata)
 
           thumbnail_filepath =
@@ -209,6 +290,9 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
           :ok = File.cp(thumbnail_filepath_fixture(), thumbnail_filepath)
 
           {:ok, Phoenix.json_library().encode!(metadata)}
+
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
       end)
 
       assert media_item.thumbnail_filepath == nil
@@ -219,13 +303,19 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
     end
 
     test "extracts the metadata_filepath", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, 2, fn _url, _opts, _ot, _addl ->
-        metadata = render_parsed_metadata(:media_metadata)
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, _addl ->
+          {:ok, "{}"}
 
+        _url, :download, _opts, _ot, _addl ->
+          metadata = render_parsed_metadata(:media_metadata)
           infojson_filepath = metadata["infojson_filename"]
           :ok = File.cp(infojson_filepath_fixture(), infojson_filepath)
 
           {:ok, Phoenix.json_library().encode!(metadata)}
+
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
       end)
 
       assert media_item.metadata_filepath == nil
@@ -238,8 +328,10 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
 
   describe "download_for_media_item/3 when testing NFO generation" do
     setup do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
-        {:ok, render_metadata(:media_metadata)}
+      stub(YtDlpRunnerMock, :run, fn
+        _url, :download, _opts, _ot, _addl -> {:ok, render_metadata(:media_metadata)}
+        _url, :get_downloadable_status, _opts, _ot, _addl -> {:ok, "{}"}
+        _url, :download_thumbnail, _opts, _ot, _addl -> {:ok, ""}
       end)
 
       :ok

test/pinchflat/downloading/quality_option_builder_test.exs

@@ -0,0 +1,109 @@
+defmodule Pinchflat.Downloading.QualityOptionBuilderTest do
+  use Pinchflat.DataCase
+  import Pinchflat.ProfilesFixtures
+
+  alias Pinchflat.Profiles
+  alias Pinchflat.Settings
+  alias Pinchflat.Downloading.QualityOptionBuilder
+
+  describe "build/1" do
+    test "includes format options if audio_track is set to original" do
+      media_profile = media_profile_fixture(%{audio_track: "original"})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format, "bestvideo+bestaudio[format_note*=original]/bestvideo*+bestaudio/best"} in res
+    end
+
+    test "includes format options if audio_track is set to default" do
+      media_profile = media_profile_fixture(%{audio_track: "default"})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format, "bestvideo+bestaudio[format_note*='(default)']/bestvideo*+bestaudio/best"} in res
+    end
+
+    test "includes format options if audio_track is set to a language code" do
+      media_profile = media_profile_fixture(%{audio_track: "en"})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format, "bestvideo+bestaudio[language^=en]/bestvideo*+bestaudio/best"} in res
+    end
+  end
+
+  describe "build/1 when testing audio profiles" do
+    setup do
+      {:ok, media_profile: media_profile_fixture(%{preferred_resolution: :audio})}
+    end
+
+    test "includes quality options for audio only", %{media_profile: media_profile} do
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert :extract_audio in res
+      assert {:format_sort, "+acodec:m4a"} in res
+
+      refute {:remux_video, "mp4"} in res
+    end
+
+    test "includes custom format target for audio if specified", %{media_profile: media_profile} do
+      {:ok, media_profile} =
+        Profiles.update_media_profile(media_profile, %{media_container: "flac", preferred_resolution: :audio})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:audio_format, "flac"} in res
+    end
+
+    test "includes custom format options", %{media_profile: media_profile} do
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format, "bestaudio/best"} in res
+    end
+  end
+
+  describe "build/1 when testing non-audio profiles" do
+    setup do
+      {:ok, media_profile: media_profile_fixture(%{preferred_resolution: :"480p"})}
+    end
+
+    test "includes quality options" do
+      resolutions = ["360", "480", "720", "1080", "1440", "2160", "4320"]
+
+      Enum.each(resolutions, fn resolution ->
+        resolution_atom = String.to_existing_atom(resolution <> "p")
+        media_profile = media_profile_fixture(%{preferred_resolution: resolution_atom})
+
+        assert res = QualityOptionBuilder.build(media_profile)
+
+        assert {:format_sort, "res:#{resolution},+codec:avc:m4a"} in res
+        assert {:remux_video, "mp4"} in res
+      end)
+    end
+
+    test "includes custom quality options if specified", %{media_profile: media_profile} do
+      Settings.set(video_codec_preference: "av01")
+      Settings.set(audio_codec_preference: "aac")
+
+      {:ok, media_profile} = Profiles.update_media_profile(media_profile, %{preferred_resolution: :"1080p"})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format_sort, "res:1080,+codec:av01:aac"} in res
+    end
+
+    test "includes custom remux target for videos if specified", %{media_profile: media_profile} do
+      {:ok, media_profile} = Profiles.update_media_profile(media_profile, %{media_container: "mkv"})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:remux_video, "mkv"} in res
+    end
+
+    test "includes custom format options", %{media_profile: media_profile} do
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format, "bestvideo*+bestaudio/best"} in res
+    end
+  end
+end

test/pinchflat/fast_indexing/fast_indexing_helpers_test.exs

@@ -1,6 +1,7 @@
 defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
   use Pinchflat.DataCase
 
+  import Pinchflat.TasksFixtures
   import Pinchflat.MediaFixtures
   import Pinchflat.SourcesFixtures
   import Pinchflat.ProfilesFixtures
@@ -8,17 +9,35 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
   alias Pinchflat.Tasks
   alias Pinchflat.Settings
   alias Pinchflat.Media.MediaItem
+  alias Pinchflat.FastIndexing.FastIndexingWorker
   alias Pinchflat.Downloading.MediaDownloadWorker
   alias Pinchflat.FastIndexing.FastIndexingHelpers
 
   setup do
-    stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+    stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, _addl ->
       {:ok, media_attributes_return_fixture()}
     end)
 
     {:ok, [source: source_fixture()]}
   end
 
+  describe "kickoff_indexing_task/1" do
+    test "deletes any existing fast indexing tasks", %{source: source} do
+      {:ok, job} = Oban.insert(FastIndexingWorker.new(%{"id" => source.id}))
+      task = task_fixture(source_id: source.id, job_id: job.id)
+
+      assert Repo.reload!(task)
+      assert {:ok, _} = FastIndexingHelpers.kickoff_indexing_task(source)
+      assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
+    end
+
+    test "kicks off a new fast indexing task", %{source: source} do
+      assert {:ok, _} = FastIndexingHelpers.kickoff_indexing_task(source)
+      assert [worker] = all_enqueued(worker: FastIndexingWorker)
+      assert worker.args["id"] == source.id
+    end
+  end
+
   describe "kickoff_download_tasks_from_youtube_rss_feed/1" do
     test "enqueues a new worker for each new media_id in the source's RSS feed", %{source: source} do
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
@@ -61,10 +80,22 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
       assert [_] = Tasks.list_tasks_for(media_item, "MediaDownloadWorker")
     end
 
+    test "passes the source's download options to the yt-dlp runner", %{source: source} do
+      expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
+
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, opts, _ot, _addl_opts ->
+        assert {:output, "/tmp/test/media/%(title)S.%(ext)S"} in opts
+        assert {:remux_video, "mp4"} in opts
+        {:ok, media_attributes_return_fixture()}
+      end)
+
+      FastIndexingHelpers.kickoff_download_tasks_from_youtube_rss_feed(source)
+    end
+
     test "sets use_cookies if the source uses cookies" do
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, addl ->
         assert {:use_cookies, true} in addl
 
         {:ok, media_attributes_return_fixture()}
@@ -78,7 +109,7 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
     test "does not set use_cookies if the source does not use cookies" do
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, addl ->
         assert {:use_cookies, false} in addl
 
         {:ok, media_attributes_return_fixture()}
@@ -95,7 +126,7 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
       profile = media_profile_fixture(%{shorts_behaviour: :exclude})
       source = source_fixture(%{media_profile_id: profile.id})
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, _addl ->
         output =
           Phoenix.json_library().encode!(%{
             id: "video2",
@@ -119,7 +150,7 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
     test "does not blow up if a media item cannot be created", %{source: source} do
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, _addl ->
         {:ok, "{}"}
       end)
 
@@ -129,7 +160,7 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
     test "does not blow up if a media item causes a yt-dlp error", %{source: source} do
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, _addl ->
         {:error, "message", 1}
       end)
 

test/pinchflat/fast_indexing/fast_indexing_worker_test.exs

@@ -84,7 +84,10 @@ defmodule Pinchflat.FastIndexing.FastIndexingWorkerTest do
       source = source_fixture(fast_index: true)
 
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, render_metadata(:media_metadata)} end)
+
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, _addl ->
+        {:ok, render_metadata(:media_metadata)}
+      end)
 
       expect(AppriseRunnerMock, :run, fn servers, opts ->
         assert "server_1" = servers
@@ -110,7 +113,11 @@ defmodule Pinchflat.FastIndexing.FastIndexingWorkerTest do
       source = source_fixture(fast_index: true, download_media: false)
 
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, render_metadata(:media_metadata)} end)
+
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, _addl ->
+        {:ok, render_metadata(:media_metadata)}
+      end)
+
       expect(AppriseRunnerMock, :run, 0, fn _servers, _opts -> {:ok, ""} end)
 
       perform_job(FastIndexingWorker, %{id: source.id})
@@ -120,7 +127,11 @@ defmodule Pinchflat.FastIndexing.FastIndexingWorkerTest do
       source = source_fixture(fast_index: true, title_filter_regex: "foobar")
 
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, render_metadata(:media_metadata)} end)
+
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, _addl ->
+        {:ok, render_metadata(:media_metadata)}
+      end)
+
       expect(AppriseRunnerMock, :run, 0, fn _servers, _opts -> {:ok, ""} end)
 
       perform_job(FastIndexingWorker, %{id: source.id})

test/pinchflat/media_test.exs

@@ -757,7 +757,7 @@ defmodule Pinchflat.MediaTest do
     end
 
     test "does delete the media item's metadata files" do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+      stub(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, _addl -> {:ok, ""} end)
       media_item = Repo.preload(media_item_with_attachments(), [:metadata, :source])
 
       update_attrs = %{
@@ -789,7 +789,7 @@ defmodule Pinchflat.MediaTest do
     end
 
     test "deletes the media item's metadata files" do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+      stub(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, _addl -> {:ok, ""} end)
       media_item = Repo.preload(media_item_with_attachments(), [:metadata, :source])
 
       update_attrs = %{
@@ -875,7 +875,7 @@ defmodule Pinchflat.MediaTest do
     end
 
     test "does not delete the media item's metadata files" do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+      stub(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, _addl -> {:ok, ""} end)
       media_item = Repo.preload(media_item_with_attachments(), [:metadata, :source])
 
       update_attrs = %{

test/pinchflat/metadata/metadata_file_helpers_test.exs

@@ -62,7 +62,7 @@ defmodule Pinchflat.Metadata.MetadataFileHelpersTest do
 
   describe "download_and_store_thumbnail_for/2" do
     test "returns the filepath", %{media_item: media_item} do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+      stub(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, _addl -> {:ok, ""} end)
 
       filepath = Helpers.download_and_store_thumbnail_for(media_item)
 
@@ -70,7 +70,7 @@ defmodule Pinchflat.Metadata.MetadataFileHelpersTest do
     end
 
     test "calls yt-dlp with the expected options", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn url, opts, ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn url, :download_thumbnail, opts, ot, _addl ->
         assert url == media_item.original_url
         assert ot == "after_move:%()j"
 
@@ -89,7 +89,7 @@ defmodule Pinchflat.Metadata.MetadataFileHelpersTest do
     end
 
     test "sets use_cookies if the source uses cookies" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, addl ->
         assert {:use_cookies, true} in addl
         {:ok, ""}
       end)
@@ -101,7 +101,7 @@ defmodule Pinchflat.Metadata.MetadataFileHelpersTest do
     end
 
     test "does not set use_cookies if the source does not use cookies" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, addl ->
         assert {:use_cookies, false} in addl
         {:ok, ""}
       end)
@@ -113,7 +113,7 @@ defmodule Pinchflat.Metadata.MetadataFileHelpersTest do
     end
 
     test "returns nil if yt-dlp fails", %{media_item: media_item} do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:error, "error"} end)
+      stub(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, _addl -> {:error, "error"} end)
 
       filepath = Helpers.download_and_store_thumbnail_for(media_item)
 

test/pinchflat/metadata/source_metadata_storage_worker_test.exs

@@ -8,9 +8,6 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
   alias Pinchflat.Metadata.MetadataFileHelpers
   alias Pinchflat.Metadata.SourceMetadataStorageWorker
 
-  @source_details_ot "%(.{channel,channel_id,playlist_id,playlist_title,filename})j"
-  @metadata_ot "playlist:%()j"
-
   describe "kickoff_with_task/1" do
     test "enqueues a new worker for the source" do
       source = source_fixture()
@@ -32,8 +29,8 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
   describe "perform/1" do
     test "won't call itself in an infinite loop" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot -> {:ok, source_details_return_fixture()}
-        _url, _opts, ot, _addl when ot == @metadata_ot -> {:ok, "{}"}
+        _url, :get_source_details, _opts, _ot, _addl -> {:ok, source_details_return_fixture()}
+        _url, :get_source_metadata, _opts, _ot, _addl -> {:ok, "{}"}
       end)
 
       source = source_fixture()
@@ -51,8 +48,8 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
   describe "perform/1 when testing attribute updates" do
     test "the source description is saved" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot -> {:ok, source_details_return_fixture()}
-        _url, _opts, ot, _addl when ot == @metadata_ot -> {:ok, render_metadata(:channel_source_metadata)}
+        _url, :get_source_details, _opts, _ot, _addl -> {:ok, source_details_return_fixture()}
+        _url, :get_source_metadata, _opts, _ot, _addl -> {:ok, render_metadata(:channel_source_metadata)}
       end)
 
       source = source_fixture(%{description: nil})
@@ -68,8 +65,8 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
   describe "perform/1 when testing metadata storage" do
     test "sets metadata location for source" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot -> {:ok, source_details_return_fixture()}
-        _url, _opts, ot, _addl when ot == @metadata_ot -> {:ok, "{}"}
+        _url, :get_source_details, _opts, _ot, _addl -> {:ok, source_details_return_fixture()}
+        _url, :get_source_metadata, _opts, _ot, _addl -> {:ok, "{}"}
       end)
 
       source = Repo.preload(source_fixture(), :metadata)
@@ -87,8 +84,8 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
       file_contents = Phoenix.json_library().encode!(%{"title" => "test"})
 
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot -> {:ok, source_details_return_fixture()}
-        _url, _opts, ot, _addl when ot == @metadata_ot -> {:ok, file_contents}
+        _url, :get_source_details, _opts, _ot, _addl -> {:ok, source_details_return_fixture()}
+        _url, :get_source_metadata, _opts, _ot, _addl -> {:ok, file_contents}
       end)
 
       perform_job(SourceMetadataStorageWorker, %{id: source.id})
@@ -100,8 +97,8 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "sets metadata image location for source" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot -> {:ok, source_details_return_fixture()}
-        _url, _opts, ot, _addl when ot == @metadata_ot -> {:ok, render_metadata(:channel_source_metadata)}
+        _url, :get_source_details, _opts, _ot, _addl -> {:ok, source_details_return_fixture()}
+        _url, :get_source_metadata, _opts, _ot, _addl -> {:ok, render_metadata(:channel_source_metadata)}
       end)
 
       source = source_fixture()
@@ -118,8 +115,8 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "stores metadata images for source" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot -> {:ok, source_details_return_fixture()}
-        _url, _opts, ot, _addl when ot == @metadata_ot -> {:ok, render_metadata(:channel_source_metadata)}
+        _url, :get_source_details, _opts, _ot, _addl -> {:ok, source_details_return_fixture()}
+        _url, :get_source_metadata, _opts, _ot, _addl -> {:ok, render_metadata(:channel_source_metadata)}
       end)
 
       source = source_fixture()
@@ -138,12 +135,12 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
   describe "perform/1 when testing source image downloading" do
     test "downloads and stores source images" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           filename = Path.join([Application.get_env(:pinchflat, :media_directory), "Season 1", "bar.mp4"])
 
           {:ok, source_details_return_fixture(%{filename: filename})}
 
-        _url, opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, opts, _ot, _addl ->
           assert {:convert_thumbnails, "jpg"} in opts
 
           {:ok, render_metadata(:channel_source_metadata)}
@@ -168,10 +165,10 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "calls one set of yt-dlp metadata opts for channels" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           {:ok, source_details_return_fixture()}
 
-        _url, opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, opts, _ot, _addl ->
           assert {:playlist_items, 0} in opts
           assert :write_all_thumbnails in opts
 
@@ -186,10 +183,10 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "calls another set of yt-dlp metadata opts for playlists" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           {:ok, source_details_return_fixture()}
 
-        _url, opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, opts, _ot, _addl ->
           assert {:playlist_items, 1} in opts
           assert :write_thumbnail in opts
 
@@ -204,12 +201,12 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "does not store source images if the profile is not set to" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           filename = Path.join([Application.get_env(:pinchflat, :media_directory), "Season 1", "bar.mp4"])
 
           {:ok, source_details_return_fixture(%{filename: filename})}
 
-        _url, _opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, _addl ->
           {:ok, render_metadata(:channel_source_metadata)}
       end)
 
@@ -226,12 +223,12 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "does not store source images if the series directory cannot be determined" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           filename = Path.join([Application.get_env(:pinchflat, :media_directory), "foo", "bar.mp4"])
 
           {:ok, source_details_return_fixture(%{filename: filename})}
 
-        _url, _opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, _addl ->
           {:ok, render_metadata(:channel_source_metadata)}
       end)
 
@@ -248,10 +245,10 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "sets use_cookies if the source uses cookies" do
       expect(YtDlpRunnerMock, :run, 2, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           {:ok, source_details_return_fixture()}
 
-        _url, _opts, ot, addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, addl ->
           assert {:use_cookies, true} in addl
           {:ok, render_metadata(:channel_source_metadata)}
       end)
@@ -264,10 +261,10 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "does not set use_cookies if the source does not use cookies" do
       expect(YtDlpRunnerMock, :run, 2, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           {:ok, source_details_return_fixture()}
 
-        _url, _opts, ot, addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, addl ->
           assert {:use_cookies, false} in addl
           {:ok, render_metadata(:channel_source_metadata)}
       end)
@@ -282,12 +279,12 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
   describe "perform/1 when determining the series_directory" do
     test "sets the series directory based on the returned media filepath" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           filename = Path.join([Application.get_env(:pinchflat, :media_directory), "Season 1", "bar.mp4"])
 
           {:ok, source_details_return_fixture(%{filename: filename})}
 
-        _url, _opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, _addl ->
           {:ok, "{}"}
       end)
 
@@ -300,12 +297,12 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "does not set the series directory if it cannot be determined" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           filename = Path.join([Application.get_env(:pinchflat, :media_directory), "foo", "bar.mp4"])
 
           {:ok, source_details_return_fixture(%{filename: filename})}
 
-        _url, _opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, _addl ->
           {:ok, "{}"}
       end)
 
@@ -318,11 +315,11 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "sets use_cookies if the source is set to use cookies" do
       expect(YtDlpRunnerMock, :run, 2, fn
-        _url, _opts, ot, addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, addl ->
           assert {:use_cookies, true} in addl
           {:ok, source_details_return_fixture()}
 
-        _url, _opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, _addl ->
           {:ok, "{}"}
       end)
 
@@ -332,11 +329,11 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "does not set use_cookies if the source is not set to use cookies" do
       expect(YtDlpRunnerMock, :run, 2, fn
-        _url, _opts, ot, addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, addl ->
           assert {:use_cookies, false} in addl
           {:ok, source_details_return_fixture()}
 
-        _url, _opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, _addl ->
           {:ok, "{}"}
       end)
 
@@ -348,12 +345,12 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
   describe "perform/1 when storing the series NFO" do
     test "stores the NFO if specified" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           filename = Path.join([Application.get_env(:pinchflat, :media_directory), "Season 1", "bar.mp4"])
 
           {:ok, source_details_return_fixture(%{filename: filename})}
 
-        _url, _opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, _addl ->
           {:ok, "{}"}
       end)
 
@@ -371,12 +368,12 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "does not store the NFO if not specified" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           filename = Path.join([Application.get_env(:pinchflat, :media_directory), "Season 1", "bar.mp4"])
 
           {:ok, source_details_return_fixture(%{filename: filename})}
 
-        _url, _opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, _addl ->
           {:ok, "{}"}
       end)
 
@@ -390,12 +387,12 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
 
     test "does not store the NFO if the series directory cannot be determined" do
       stub(YtDlpRunnerMock, :run, fn
-        _url, _opts, ot, _addl when ot == @source_details_ot ->
+        _url, :get_source_details, _opts, _ot, _addl ->
           filename = Path.join([Application.get_env(:pinchflat, :media_directory), "foo", "bar.mp4"])
 
           {:ok, source_details_return_fixture(%{filename: filename})}
 
-        _url, _opts, ot, _addl when ot == @metadata_ot ->
+        _url, :get_source_metadata, _opts, _ot, _addl ->
           {:ok, "{}"}
       end)
 

test/pinchflat/podcasts/opml_feed_builder_test.exs

@@ -0,0 +1,34 @@
+defmodule Pinchflat.Podcasts.OpmlFeedBuilderTest do
+  use Pinchflat.DataCase
+
+  import Pinchflat.SourcesFixtures
+
+  alias Pinchflat.Podcasts.OpmlFeedBuilder
+
+  setup do
+    source = source_fixture()
+
+    {:ok, source: source}
+  end
+
+  describe "build/2" do
+    test "returns an XML document", %{source: source} do
+      res = OpmlFeedBuilder.build("http://example.com", [source])
+
+      assert String.contains?(res, ~s(<?xml version="1.0" encoding="UTF-8"?>))
+    end
+
+    test "escapes illegal characters" do
+      source = source_fixture(%{custom_name: "A & B"})
+      res = OpmlFeedBuilder.build("http://example.com", [source])
+
+      assert String.contains?(res, ~s(A &amp; B))
+    end
+
+    test "build podcast link with URL base", %{source: source} do
+      res = OpmlFeedBuilder.build("http://example.com", [source])
+
+      assert String.contains?(res, ~s(http://example.com/sources/#{source.uuid}/feed.xml))
+    end
+  end
+end

test/pinchflat/podcasts/podcast_helpers_test.exs

@@ -6,6 +6,16 @@ defmodule Pinchflat.Podcasts.PodcastHelpersTest do
 
   alias Pinchflat.Podcasts.PodcastHelpers
 
+  describe "opml_sources" do
+    test "returns sources not marked for deletion" do
+      source = source_fixture()
+      source_fixture(%{marked_for_deletion_at: DateTime.utc_now()})
+      assert [found_source] = PodcastHelpers.opml_sources()
+      assert found_source.custom_name == source.custom_name
+      assert found_source.uuid == source.uuid
+    end
+  end
+
   describe "persisted_media_items_for/2" do
     test "returns media items with files that exist on-disk" do
       source = source_fixture()

test/pinchflat/slow_indexing/media_collection_indexing_worker_test.exs

@@ -50,37 +50,35 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
 
   describe "perform/1" do
     setup do
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts -> {:ok, ""} end)
+
       stub(AppriseRunnerMock, :run, fn _, _ -> {:ok, ""} end)
 
       :ok
     end
 
     test "it indexes the source if it should be indexed" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
-
       source = source_fixture(index_frequency_minutes: 10)
 
       perform_job(MediaCollectionIndexingWorker, %{id: source.id})
     end
 
     test "it indexes the source no matter what if the source has never been indexed before" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
-
       source = source_fixture(index_frequency_minutes: 0, last_indexed_at: nil)
 
       perform_job(MediaCollectionIndexingWorker, %{id: source.id})
     end
 
     test "it indexes the source no matter what if the 'force' arg is passed" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
-
       source = source_fixture(index_frequency_minutes: 0, last_indexed_at: DateTime.utc_now())
 
       perform_job(MediaCollectionIndexingWorker, %{id: source.id, force: true})
     end
 
     test "it does not do any indexing if the source has been indexed and shouldn't be rescheduled" do
-      expect(YtDlpRunnerMock, :run, 0, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
+      expect(YtDlpRunnerMock, :run, 0, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
+        {:ok, ""}
+      end)
 
       source = source_fixture(index_frequency_minutes: -1, last_indexed_at: DateTime.utc_now())
 
@@ -88,7 +86,7 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     end
 
     test "it does not reschedule if the source shouldn't be indexed" do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts -> {:ok, ""} end)
 
       source = source_fixture(index_frequency_minutes: -1)
       perform_job(MediaCollectionIndexingWorker, %{id: source.id})
@@ -97,7 +95,7 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     end
 
     test "it kicks off a download job for each pending media item" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
         {:ok, source_attributes_return_fixture()}
       end)
 
@@ -108,7 +106,7 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     end
 
     test "it starts a job for any pending media item even if it's from another run" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
         {:ok, source_attributes_return_fixture()}
       end)
 
@@ -120,7 +118,7 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     end
 
     test "it does not kick off a job for media items that could not be saved" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
         {:ok, source_attributes_return_fixture()}
       end)
 
@@ -133,8 +131,6 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     end
 
     test "it reschedules the job based on the index frequency" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
-
       source = source_fixture(index_frequency_minutes: 10)
       perform_job(MediaCollectionIndexingWorker, %{id: source.id})
 
@@ -146,8 +142,6 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     end
 
     test "it creates a task for the rescheduled job" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
-
       source = source_fixture(index_frequency_minutes: 10)
 
       task_count_fetcher = fn ->
@@ -160,8 +154,6 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     end
 
     test "it creates a future task for fast indexing if appropriate" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
-
       source = source_fixture(index_frequency_minutes: 10, fast_index: true)
       perform_job(MediaCollectionIndexingWorker, %{id: source.id})
 
@@ -173,8 +165,6 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     end
 
     test "it deletes existing fast indexing tasks if a new one is created" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
-
       source = source_fixture(index_frequency_minutes: 10, fast_index: true)
       {:ok, job} = Oban.insert(FastIndexingWorker.new(%{"id" => source.id}))
       task = task_fixture(source_id: source.id, job_id: job.id)
@@ -185,8 +175,6 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     end
 
     test "it does not create a task for fast indexing otherwise" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
-
       source = source_fixture(index_frequency_minutes: 10, fast_index: false)
       perform_job(MediaCollectionIndexingWorker, %{id: source.id})
 
@@ -194,7 +182,9 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     end
 
     test "it creates the basic media_item records" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, source_attributes_return_fixture()} end)
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
+        {:ok, source_attributes_return_fixture()}
+      end)
 
       source = source_fixture(index_frequency_minutes: 10)
 
@@ -225,7 +215,7 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorkerTest do
     test "sends a notification if new media was found" do
       source = source_fixture()
 
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
         {:ok, source_attributes_return_fixture()}
       end)
 

test/pinchflat/slow_indexing/slow_indexing_helpers_test.exs

@@ -23,6 +23,36 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
       assert_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
     end
 
+    test "schedules a job for the future based on when the source was last indexed" do
+      source = source_fixture(index_frequency_minutes: 30, last_indexed_at: now_minus(5, :minutes))
+
+      assert {:ok, _} = SlowIndexingHelpers.kickoff_indexing_task(source)
+
+      [job] = all_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
+
+      assert_in_delta DateTime.diff(job.scheduled_at, DateTime.utc_now(), :minute), 25, 1
+    end
+
+    test "schedules a job immediately if the source was indexed far in the past" do
+      source = source_fixture(index_frequency_minutes: 30, last_indexed_at: now_minus(60, :minutes))
+
+      assert {:ok, _} = SlowIndexingHelpers.kickoff_indexing_task(source)
+
+      [job] = all_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
+
+      assert_in_delta DateTime.diff(job.scheduled_at, DateTime.utc_now(), :second), 0, 1
+    end
+
+    test "schedules a job immediately if the source has never been indexed" do
+      source = source_fixture(index_frequency_minutes: 30, last_indexed_at: nil)
+
+      assert {:ok, _} = SlowIndexingHelpers.kickoff_indexing_task(source)
+
+      [job] = all_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
+
+      assert_in_delta DateTime.diff(job.scheduled_at, DateTime.utc_now(), :second), 0, 1
+    end
+
     test "creates and attaches a task" do
       source = source_fixture(index_frequency_minutes: 1)
 
@@ -92,9 +122,59 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
     end
   end
 
+  describe "delete_indexing_tasks/2" do
+    setup do
+      source = source_fixture()
+
+      {:ok, %{source: source}}
+    end
+
+    test "deletes slow indexing tasks for the source", %{source: source} do
+      {:ok, job} = Oban.insert(MediaCollectionIndexingWorker.new(%{"id" => source.id}))
+      _task = task_fixture(source_id: source.id, job_id: job.id)
+
+      assert_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
+      assert :ok = SlowIndexingHelpers.delete_indexing_tasks(source)
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
+    end
+
+    test "deletes fast indexing tasks for the source", %{source: source} do
+      {:ok, job} = Oban.insert(FastIndexingWorker.new(%{"id" => source.id}))
+      _task = task_fixture(source_id: source.id, job_id: job.id)
+
+      assert_enqueued(worker: FastIndexingWorker, args: %{"id" => source.id})
+      assert :ok = SlowIndexingHelpers.delete_indexing_tasks(source)
+      refute_enqueued(worker: FastIndexingWorker)
+    end
+
+    test "doesn't normally delete currently executing tasks", %{source: source} do
+      {:ok, job} = Oban.insert(MediaCollectionIndexingWorker.new(%{"id" => source.id}))
+      task = task_fixture(source_id: source.id, job_id: job.id)
+
+      from(Oban.Job, where: [id: ^job.id], update: [set: [state: "executing"]])
+      |> Repo.update_all([])
+
+      assert Repo.reload!(task)
+      assert :ok = SlowIndexingHelpers.delete_indexing_tasks(source)
+      assert Repo.reload!(task)
+    end
+
+    test "can optionally delete currently executing tasks", %{source: source} do
+      {:ok, job} = Oban.insert(MediaCollectionIndexingWorker.new(%{"id" => source.id}))
+      task = task_fixture(source_id: source.id, job_id: job.id)
+
+      from(Oban.Job, where: [id: ^job.id], update: [set: [state: "executing"]])
+      |> Repo.update_all([])
+
+      assert Repo.reload!(task)
+      assert :ok = SlowIndexingHelpers.delete_indexing_tasks(source, include_executing: true)
+      assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
+    end
+  end
+
   describe "index_and_enqueue_download_for_media_items/1" do
     setup do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
         {:ok, source_attributes_return_fixture()}
       end)
 
@@ -179,7 +259,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
     end
 
     test "doesn't blow up if a media item cannot be coerced into a struct", %{source: source} do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
         response =
           Phoenix.json_library().encode!(%{
             id: "video3",
@@ -202,8 +282,18 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
       assert %Ecto.Changeset{} = changeset
     end
 
+    test "passes the source's download options to the yt-dlp runner", %{source: source} do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, opts, _ot, _addl_opts ->
+        assert {:output, "/tmp/test/media/%(title)S.%(ext)S"} in opts
+        assert {:remux_video, "mp4"} in opts
+        {:ok, source_attributes_return_fixture()}
+      end)
+
+      SlowIndexingHelpers.index_and_enqueue_download_for_media_items(source)
+    end
+
     test "sets use_cookies if the source uses cookies" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
         assert {:use_cookies, true} in addl_opts
         {:ok, source_attributes_return_fixture()}
       end)
@@ -214,7 +304,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
     end
 
     test "doesn't set use_cookies if the source doesn't use cookies" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
         assert {:use_cookies, false} in addl_opts
         {:ok, source_attributes_return_fixture()}
       end)
@@ -233,7 +323,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
     test "creates a new media item for everything already in the file", %{source: source} do
       watcher_poll_interval = Application.get_env(:pinchflat, :file_watcher_poll_interval)
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
         filepath = Keyword.get(addl_opts, :output_filepath)
         File.write(filepath, source_attributes_return_fixture())
 
@@ -252,7 +342,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
     test "enqueues a download for everything already in the file", %{source: source} do
       watcher_poll_interval = Application.get_env(:pinchflat, :file_watcher_poll_interval)
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
         filepath = Keyword.get(addl_opts, :output_filepath)
         File.write(filepath, source_attributes_return_fixture())
 
@@ -272,7 +362,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
       watcher_poll_interval = Application.get_env(:pinchflat, :file_watcher_poll_interval)
       source = source_fixture(download_media: false)
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
         filepath = Keyword.get(addl_opts, :output_filepath)
         File.write(filepath, source_attributes_return_fixture())
 
@@ -292,7 +382,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
       profile = media_profile_fixture(%{shorts_behaviour: :exclude})
       source = source_fixture(%{media_profile_id: profile.id})
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
         filepath = Keyword.get(addl_opts, :output_filepath)
 
         contents =
@@ -323,7 +413,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
     test "does not enqueue multiple download jobs for the same media items", %{source: source} do
       watcher_poll_interval = Application.get_env(:pinchflat, :file_watcher_poll_interval)
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
         filepath = Keyword.get(addl_opts, :output_filepath)
         File.write(filepath, source_attributes_return_fixture())
 
@@ -342,7 +432,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
     test "does not blow up if the file returns invalid json", %{source: source} do
       watcher_poll_interval = Application.get_env(:pinchflat, :file_watcher_poll_interval)
 
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
         filepath = Keyword.get(addl_opts, :output_filepath)
         File.write(filepath, "INVALID")
 

test/pinchflat/sources_test.exs

@@ -85,7 +85,7 @@ defmodule Pinchflat.SourcesTest do
 
   describe "create_source/2" do
     test "automatically sets the UUID" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -97,7 +97,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "UUID is not writable by the user" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -110,7 +110,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "creates a source and adds name + ID from runner response for channels" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -123,7 +123,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "creates a source and adds name + ID for playlists" do
-      expect(YtDlpRunnerMock, :run, &playlist_mock/4)
+      expect(YtDlpRunnerMock, :run, &playlist_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -136,7 +136,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "adds an error if the runner fails" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:error, "some error", 1} end)
+      expect(YtDlpRunnerMock, :run, fn _url, :get_source_details, _opts, _ot, _addl -> {:error, "some error", 1} end)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -148,7 +148,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "adds an error if the runner succeeds but the result was invalid JSON" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, "Not JSON"} end)
+      expect(YtDlpRunnerMock, :run, fn _url, :get_source_details, _opts, _ot, _addl -> {:ok, "Not JSON"} end)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -160,7 +160,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "you can specify a custom custom_name" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -174,7 +174,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "friendly name is pulled from collection_name if not specified" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -187,7 +187,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "creation enforces uniqueness of collection_id scoped to the media_profile and title regex" do
-      expect(YtDlpRunnerMock, :run, 2, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 2, fn _url, :get_source_details, _opts, _ot, _addl ->
         {:ok,
          Phoenix.json_library().encode!(%{
            channel: "some channel name",
@@ -208,7 +208,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "creation lets you duplicate collection_ids and profiles as long as the regex is different" do
-      expect(YtDlpRunnerMock, :run, 2, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 2, fn _url, :get_source_details, _opts, _ot, _addl ->
         {:ok,
          Phoenix.json_library().encode!(%{
            channel: "some channel name",
@@ -232,7 +232,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "creation lets you duplicate collection_ids as long as the media profile is different" do
-      expect(YtDlpRunnerMock, :run, 2, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, 2, fn _url, :get_source_details, _opts, _ot, _addl ->
         {:ok,
          Phoenix.json_library().encode!(%{
            channel: "some channel name",
@@ -256,8 +256,8 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "collection_type is inferred from source details" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
-      expect(YtDlpRunnerMock, :run, &playlist_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
+      expect(YtDlpRunnerMock, :run, &playlist_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -276,13 +276,13 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "creation with invalid data fails fast and does not call the runner" do
-      expect(YtDlpRunnerMock, :run, 0, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, 0, &channel_mock/5)
 
       assert {:error, %Ecto.Changeset{}} = Sources.create_source(@invalid_source_attrs)
     end
 
     test "creation will schedule the indexing task" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -295,7 +295,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "creation schedules an index test even if the index frequency is 0" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -309,7 +309,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "fast_index forces the index frequency to be a default value" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -324,7 +324,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "disabling fast index will not change the index frequency" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -339,7 +339,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "creating will kickoff a metadata storage worker" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -356,7 +356,7 @@ defmodule Pinchflat.SourcesTest do
 
   describe "create_source/2 when testing options" do
     test "run_post_commit_tasks: false won't enqueue post-commit tasks" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
@@ -380,7 +380,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "updates with invalid data fails fast and does not call the runner" do
-      expect(YtDlpRunnerMock, :run, 0, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, 0, &channel_mock/5)
 
       source = source_fixture()
 
@@ -388,7 +388,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "updating the original_url will re-fetch the source details for channels" do
-      expect(YtDlpRunnerMock, :run, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, &channel_mock/5)
 
       source = source_fixture()
       update_attrs = %{original_url: "https://www.youtube.com/channel/abc123"}
@@ -399,7 +399,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "updating the original_url will re-fetch the source details for playlists" do
-      expect(YtDlpRunnerMock, :run, &playlist_mock/4)
+      expect(YtDlpRunnerMock, :run, &playlist_mock/5)
 
       source = source_fixture()
       update_attrs = %{original_url: "https://www.youtube.com/playlist?list=abc123"}
@@ -410,7 +410,7 @@ defmodule Pinchflat.SourcesTest do
     end
 
     test "not updating the original_url will not re-fetch the source details" do
-      expect(YtDlpRunnerMock, :run, 0, &channel_mock/4)
+      expect(YtDlpRunnerMock, :run, 0, &channel_mock/5)
 
       source = source_fixture()
       update_attrs = %{name: "some updated name"}
@@ -418,6 +418,100 @@ defmodule Pinchflat.SourcesTest do
       assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
     end
 
+    test "updates with invalid data returns error changeset" do
+      source = source_fixture()
+
+      assert {:error, %Ecto.Changeset{}} =
+               Sources.update_source(source, @invalid_source_attrs)
+
+      assert source == Sources.get_source!(source.id)
+    end
+
+    test "updating will kickoff a metadata storage worker if the original_url changes" do
+      expect(YtDlpRunnerMock, :run, &playlist_mock/5)
+      source = source_fixture()
+      update_attrs = %{original_url: "https://www.youtube.com/channel/cba321"}
+
+      assert {:ok, %Source{} = source} = Sources.update_source(source, update_attrs)
+
+      assert_enqueued(worker: SourceMetadataStorageWorker, args: %{"id" => source.id})
+    end
+
+    test "updating will not kickoff a metadata storage worker other attrs change" do
+      source = source_fixture()
+      update_attrs = %{name: "some new name"}
+
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+
+      refute_enqueued(worker: SourceMetadataStorageWorker)
+    end
+  end
+
+  describe "update_source/3 when testing media download tasks" do
+    test "enabling the download_media attribute will schedule a download task" do
+      source = source_fixture(download_media: false)
+      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{download_media: true}
+
+      refute_enqueued(worker: MediaDownloadWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+    end
+
+    test "disabling the download_media attribute will cancel the download task" do
+      source = source_fixture(download_media: true, enabled: true)
+      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{download_media: false}
+      DownloadingHelpers.enqueue_pending_download_tasks(source)
+
+      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: MediaDownloadWorker)
+    end
+
+    test "enabling download_media will not schedule a task if the source is disabled" do
+      source = source_fixture(download_media: false, enabled: false)
+      _media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{download_media: true}
+
+      refute_enqueued(worker: MediaDownloadWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: MediaDownloadWorker)
+    end
+
+    test "disabling a source will cancel any pending download tasks" do
+      source = source_fixture(download_media: true, enabled: true)
+      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{enabled: false}
+      DownloadingHelpers.enqueue_pending_download_tasks(source)
+
+      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: MediaDownloadWorker)
+    end
+
+    test "enabling a source will schedule a download task if download_media is true" do
+      source = source_fixture(download_media: true, enabled: false)
+      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: MediaDownloadWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+    end
+
+    test "enabling a source will not schedule a download task if download_media is false" do
+      source = source_fixture(download_media: false, enabled: false)
+      _media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: MediaDownloadWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: MediaDownloadWorker)
+    end
+  end
+
+  describe "update_source/3 when testing slow indexing" do
     test "updating the index frequency to >0 will re-schedule the indexing task" do
       source = source_fixture()
       update_attrs = %{index_frequency_minutes: 123}
@@ -462,27 +556,47 @@ defmodule Pinchflat.SourcesTest do
       refute_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
     end
 
-    test "enabling the download_media attribute will schedule a download task" do
-      source = source_fixture(download_media: false)
-      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
-      update_attrs = %{download_media: true}
+    test "disabling a source will delete any pending tasks" do
+      source = source_fixture()
+      update_attrs = %{enabled: false}
+
+      {:ok, job} = Oban.insert(MediaCollectionIndexingWorker.new(%{"id" => source.id}))
+      task = task_fixture(source_id: source.id, job_id: job.id)
 
-      refute_enqueued(worker: MediaDownloadWorker)
       assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
-      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+
+      assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
     end
 
-    test "disabling the download_media attribute will cancel the download task" do
-      source = source_fixture(download_media: true)
-      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
-      update_attrs = %{download_media: false}
-      DownloadingHelpers.enqueue_pending_download_tasks(source)
+    test "updating the index frequency will not create a task if the source is disabled" do
+      source = source_fixture(enabled: false)
+      update_attrs = %{index_frequency_minutes: 123}
 
-      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
       assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
-      refute_enqueued(worker: MediaDownloadWorker)
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
     end
 
+    test "enabling a source will create a task if the index frequency is >0" do
+      source = source_fixture(enabled: false, index_frequency_minutes: 123)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      assert_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
+    end
+
+    test "enabling a source will not create a task if the index frequency is 0" do
+      source = source_fixture(enabled: false, index_frequency_minutes: 0)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
+    end
+  end
+
+  describe "update_source/3 when testing fast indexing" do
     test "enabling fast_index will schedule a fast indexing task" do
       source = source_fixture(fast_index: false)
       update_attrs = %{fast_index: true}
@@ -503,15 +617,6 @@ defmodule Pinchflat.SourcesTest do
       refute_enqueued(worker: FastIndexingWorker)
     end
 
-    test "updates with invalid data returns error changeset" do
-      source = source_fixture()
-
-      assert {:error, %Ecto.Changeset{}} =
-               Sources.update_source(source, @invalid_source_attrs)
-
-      assert source == Sources.get_source!(source.id)
-    end
-
     test "fast_index forces the index frequency to be a default value" do
       source = source_fixture(%{fast_index: true})
       update_attrs = %{index_frequency_minutes: 0}
@@ -530,23 +635,43 @@ defmodule Pinchflat.SourcesTest do
       assert source.index_frequency_minutes == 0
     end
 
-    test "updating will kickoff a metadata storage worker if the original_url changes" do
-      expect(YtDlpRunnerMock, :run, &playlist_mock/4)
+    test "disabling a source will delete any pending tasks" do
       source = source_fixture()
-      update_attrs = %{original_url: "https://www.youtube.com/channel/cba321"}
+      update_attrs = %{enabled: false}
 
-      assert {:ok, %Source{} = source} = Sources.update_source(source, update_attrs)
-
-      assert_enqueued(worker: SourceMetadataStorageWorker, args: %{"id" => source.id})
-    end
-
-    test "updating will not kickoff a metadata storage worker other attrs change" do
-      source = source_fixture()
-      update_attrs = %{name: "some new name"}
+      {:ok, job} = Oban.insert(FastIndexingWorker.new(%{"id" => source.id}))
+      task = task_fixture(source_id: source.id, job_id: job.id)
 
       assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
 
-      refute_enqueued(worker: SourceMetadataStorageWorker)
+      assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
+    end
+
+    test "updating fast indexing will not create a task if the source is disabled" do
+      source = source_fixture(enabled: false, fast_index: false)
+      update_attrs = %{fast_index: true}
+
+      refute_enqueued(worker: FastIndexingWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: FastIndexingWorker)
+    end
+
+    test "enabling a source will create a task if fast_index is true" do
+      source = source_fixture(enabled: false, fast_index: true)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: FastIndexingWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      assert_enqueued(worker: FastIndexingWorker, args: %{"id" => source.id})
+    end
+
+    test "enabling a source will not create a task if fast_index is false" do
+      source = source_fixture(enabled: false, fast_index: false)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: FastIndexingWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: FastIndexingWorker)
     end
   end
 
@@ -776,7 +901,7 @@ defmodule Pinchflat.SourcesTest do
     end
   end
 
-  defp playlist_mock(_url, _opts, _ot, _addl) do
+  defp playlist_mock(_url, :get_source_details, _opts, _ot, _addl) do
     {
       :ok,
       Phoenix.json_library().encode!(%{
@@ -788,7 +913,7 @@ defmodule Pinchflat.SourcesTest do
     }
   end
 
-  defp channel_mock(_url, _opts, _ot, _addl) do
+  defp channel_mock(_url, :get_source_details, _opts, _ot, _addl) do
     channel_id = "some_channel_id_#{:rand.uniform(1_000_000)}"
 
     {

test/pinchflat/tasks_test.exs

@@ -247,7 +247,7 @@ defmodule Pinchflat.TasksTest do
       assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
     end
 
-    test "deletion can optionall include executing tasks" do
+    test "deletion can optionally include executing tasks" do
       source = source_fixture()
       task = task_fixture(source_id: source.id)
 

test/pinchflat/utils/string_utils_test.exs

@@ -28,17 +28,9 @@ defmodule Pinchflat.Utils.StringUtilsTest do
     end
   end
 
-  describe "truncate/2" do
-    test "truncates a string to the given length and adds ..." do
-      assert StringUtils.truncate("hello world", 5) == "hello..."
-    end
-
-    test "breaks on a word boundary" do
-      assert StringUtils.truncate("hello world", 7) == "hello..."
-    end
-
-    test "does not truncate a string shorter than the given length" do
-      assert StringUtils.truncate("hello", 10) == "hello"
+  describe "double_brace/1" do
+    test "wraps a string in double braces" do
+      assert StringUtils.double_brace("hello") == "{{ hello }}"
     end
   end
 end

test/pinchflat/yt_dlp/command_runner_test.exs

@@ -13,30 +13,30 @@ defmodule Pinchflat.YtDlp.CommandRunnerTest do
   end
 
   describe "run/4" do
-    test "it returns the output and status when the command succeeds" do
-      assert {:ok, _output} = Runner.run(@media_url, [], "")
+    test "returns the output and status when the command succeeds" do
+      assert {:ok, _output} = Runner.run(@media_url, :foo, [], "")
     end
 
-    test "it includes the media url as the first argument" do
-      assert {:ok, output} = Runner.run(@media_url, [:ignore_errors], "")
+    test "includes the media url as the first argument" do
+      assert {:ok, output} = Runner.run(@media_url, :foo, [:ignore_errors], "")
 
       assert String.contains?(output, "#{@media_url} --ignore-errors")
     end
 
-    test "it automatically includes the --print-to-file flag" do
-      assert {:ok, output} = Runner.run(@media_url, [], "%(id)s")
+    test "automatically includes the --print-to-file flag" do
+      assert {:ok, output} = Runner.run(@media_url, :foo, [], "%(id)s")
 
       assert String.contains?(output, "--print-to-file %(id)s /tmp/")
     end
 
-    test "it returns the output and status when the command fails" do
+    test "returns the output and status when the command fails" do
       wrap_executable("/bin/false", fn ->
-        assert {:error, "", 1} = Runner.run(@media_url, [], "")
+        assert {:error, "", 1} = Runner.run(@media_url, :foo, [], "")
       end)
     end
 
     test "optionally lets you specify an output_filepath" do
-      assert {:ok, output} = Runner.run(@media_url, [], "%(id)s", output_filepath: "/tmp/yt-dlp-output.json")
+      assert {:ok, output} = Runner.run(@media_url, :foo, [], "%(id)s", output_filepath: "/tmp/yt-dlp-output.json")
 
       assert String.contains?(output, "--print-to-file %(id)s /tmp/yt-dlp-output.json")
     end
@@ -54,7 +54,7 @@ defmodule Pinchflat.YtDlp.CommandRunnerTest do
     test "includes cookie options when cookies.txt exists and enabled", %{cookie_file: cookie_file} do
       FilesystemUtils.write_p!(cookie_file, "cookie data")
 
-      assert {:ok, output} = Runner.run(@media_url, [], "", use_cookies: true)
+      assert {:ok, output} = Runner.run(@media_url, :foo, [], "", use_cookies: true)
 
       assert String.contains?(output, "--cookies #{cookie_file}")
     end
@@ -62,7 +62,7 @@ defmodule Pinchflat.YtDlp.CommandRunnerTest do
     test "doesn't include cookie options when cookies.txt exists but disabled", %{cookie_file: cookie_file} do
       FilesystemUtils.write_p!(cookie_file, "cookie data")
 
-      assert {:ok, output} = Runner.run(@media_url, [], "", use_cookies: false)
+      assert {:ok, output} = Runner.run(@media_url, :foo, [], "", use_cookies: false)
 
       refute String.contains?(output, "--cookies #{cookie_file}")
     end
@@ -70,7 +70,7 @@ defmodule Pinchflat.YtDlp.CommandRunnerTest do
     test "doesn't include cookie options when cookies.txt blank", %{cookie_file: cookie_file} do
       FilesystemUtils.write_p!(cookie_file, " \n \n ")
 
-      assert {:ok, output} = Runner.run(@media_url, [], "", use_cookies: true)
+      assert {:ok, output} = Runner.run(@media_url, :foo, [], "", use_cookies: true)
 
       refute String.contains?(output, "--cookies")
       refute String.contains?(output, cookie_file)
@@ -79,7 +79,7 @@ defmodule Pinchflat.YtDlp.CommandRunnerTest do
     test "doesn't include cookie options when cookies.txt doesn't exist", %{cookie_file: cookie_file} do
       File.rm(cookie_file)
 
-      assert {:ok, output} = Runner.run(@media_url, [], "")
+      assert {:ok, output} = Runner.run(@media_url, :foo, [], "")
 
       refute String.contains?(output, "--cookies")
       refute String.contains?(output, cookie_file)
@@ -91,19 +91,19 @@ defmodule Pinchflat.YtDlp.CommandRunnerTest do
 
   describe "run/4 when testing global options" do
     test "creates windows-safe filenames" do
-      assert {:ok, output} = Runner.run(@media_url, [], "")
+      assert {:ok, output} = Runner.run(@media_url, :foo, [], "")
 
       assert String.contains?(output, "--windows-filenames")
     end
 
     test "runs quietly" do
-      assert {:ok, output} = Runner.run(@media_url, [], "")
+      assert {:ok, output} = Runner.run(@media_url, :foo, [], "")
 
       assert String.contains?(output, "--quiet")
     end
 
     test "sets the cache directory" do
-      assert {:ok, output} = Runner.run(@media_url, [], "")
+      assert {:ok, output} = Runner.run(@media_url, :foo, [], "")
 
       assert String.contains?(output, "--cache-dir /tmp/test/tmpfiles/yt-dlp-cache")
     end

test/pinchflat/yt_dlp/media_collection_test.exs

@@ -10,7 +10,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
 
   describe "get_media_attributes_for_collection/2" do
     test "returns a list of video attributes with no blank elements" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
         {:ok, source_attributes_return_fixture() <> "\n\n"}
       end)
 
@@ -19,7 +19,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "passes the expected default args" do
-      expect(YtDlpRunnerMock, :run, fn _url, opts, ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, opts, ot, _addl_opts ->
         assert opts == [:simulate, :skip_download, :ignore_no_formats_error, :no_warnings]
         assert ot == Media.indexing_output_template()
 
@@ -30,13 +30,25 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "returns the error straight through when the command fails" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:error, "Big issue", 1} end)
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
+        {:error, "Big issue", 1}
+      end)
 
       assert {:error, "Big issue", 1} = MediaCollection.get_media_attributes_for_collection(@channel_url)
     end
 
+    test "passes long additional command options" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, opts, _ot, _addl_opts ->
+        assert :foo in opts
+
+        {:ok, ""}
+      end)
+
+      assert {:ok, _} = MediaCollection.get_media_attributes_for_collection(@channel_url, [:foo])
+    end
+
     test "passes additional args to runner" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
         assert [{:output_filepath, filepath} | _] = addl_opts
         assert {:use_cookies, false} in addl_opts
         assert String.ends_with?(filepath, ".json")
@@ -48,7 +60,10 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "supports an optional file_listener_handler that gets passed a filename" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, ""} end)
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
+        {:ok, ""}
+      end)
+
       current_self = self()
 
       handler = fn filename ->
@@ -56,14 +71,14 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
       end
 
       assert {:ok, _} =
-               MediaCollection.get_media_attributes_for_collection(@channel_url, file_listener_handler: handler)
+               MediaCollection.get_media_attributes_for_collection(@channel_url, [], file_listener_handler: handler)
 
       assert_receive {:handler, filename}
       assert String.ends_with?(filename, ".json")
     end
 
     test "gracefully handles partially failed responses" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, _addl_opts ->
         {:ok, "INVALID\n\n" <> source_attributes_return_fixture() <> "\nINVALID\n"}
       end)
 
@@ -74,7 +89,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
 
   describe "get_source_details/1" do
     test "returns a map with data on success" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_source_details, _opts, _ot, _addl_opts ->
         Phoenix.json_library().encode(%{
           channel: "PinchflatTestChannel",
           channel_id: "UCQH2",
@@ -94,7 +109,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "passes the expected args to the runner" do
-      expect(YtDlpRunnerMock, :run, fn @channel_url, opts, ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn @channel_url, :get_source_details, opts, ot, _addl_opts ->
         assert opts == [:simulate, :skip_download, :ignore_no_formats_error, playlist_end: 1]
         assert ot == "%(.{channel,channel_id,playlist_id,playlist_title,filename})j"
 
@@ -105,7 +120,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "passes custom args to the runner" do
-      expect(YtDlpRunnerMock, :run, fn @channel_url, opts, _ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn @channel_url, :get_source_details, opts, _ot, _addl_opts ->
         assert {:foo, :bar} in opts
 
         {:ok, "{}"}
@@ -115,7 +130,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "passes additional args to the runner" do
-      expect(YtDlpRunnerMock, :run, fn @channel_url, _opts, _ot, addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn @channel_url, :get_source_details, _opts, _ot, addl_opts ->
         assert {:use_cookies, true} in addl_opts
 
         {:ok, "{}"}
@@ -125,13 +140,13 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "returns an error if the runner returns an error" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:error, "Big issue", 1} end)
+      expect(YtDlpRunnerMock, :run, fn _url, :get_source_details, _opts, _ot, _addl_opts -> {:error, "Big issue", 1} end)
 
       assert {:error, "Big issue", 1} = MediaCollection.get_source_details(@channel_url)
     end
 
     test "returns an error if the output is not JSON" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, "Not JSON"} end)
+      expect(YtDlpRunnerMock, :run, fn _url, :get_source_details, _opts, _ot, _addl_opts -> {:ok, "Not JSON"} end)
 
       assert {:error, "Error decoding JSON response"} = MediaCollection.get_source_details(@channel_url)
     end
@@ -139,7 +154,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
 
   describe "get_source_metadata/1" do
     test "returns a map with data on success" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_source_metadata, _opts, _ot, _addl_opts ->
         Phoenix.json_library().encode(%{channel: "PinchflatTestChannel"})
       end)
 
@@ -149,7 +164,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "passes the expected args to the backend runner" do
-      expect(YtDlpRunnerMock, :run, fn @channel_url, opts, ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn @channel_url, :get_source_metadata, opts, ot, _addl_opts ->
         assert opts == [:skip_download, playlist_items: 0]
         assert ot == "playlist:%()j"
 
@@ -160,7 +175,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "passes additional args to the runner" do
-      expect(YtDlpRunnerMock, :run, fn @channel_url, _opts, _ot, addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn @channel_url, :get_source_metadata, _opts, _ot, addl_opts ->
         assert {:use_cookies, true} in addl_opts
 
         {:ok, "{}"}
@@ -170,7 +185,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "passes custom args to the runner" do
-      expect(YtDlpRunnerMock, :run, fn _url, opts, _ot, _addl_opts ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_source_metadata, opts, _ot, _addl_opts ->
         assert opts == [:skip_download, playlist_items: 1, real_opt: :yup]
 
         {:ok, "{}"}
@@ -186,13 +201,15 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     end
 
     test "returns an error if the runner returns an error" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:error, "Big issue", 1} end)
+      expect(YtDlpRunnerMock, :run, fn _url, :get_source_metadata, _opts, _ot, _addl_opts ->
+        {:error, "Big issue", 1}
+      end)
 
       assert {:error, "Big issue", 1} = MediaCollection.get_source_metadata(@channel_url, playlist_items: 0)
     end
 
     test "returns an error if the output is not JSON" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, "Not JSON"} end)
+      expect(YtDlpRunnerMock, :run, fn _url, :get_source_metadata, _opts, _ot, _addl_opts -> {:ok, "Not JSON"} end)
 
       assert {:error, %Jason.DecodeError{}} = MediaCollection.get_source_metadata(@channel_url, playlist_items: 0)
     end

test/pinchflat/yt_dlp/media_test.exs

@@ -9,7 +9,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
 
   describe "download/3" do
     test "calls the backend runner with the expected arguments" do
-      expect(YtDlpRunnerMock, :run, fn @media_url, opts, ot, addl ->
+      expect(YtDlpRunnerMock, :run, fn @media_url, :download, opts, ot, addl ->
         assert [:no_simulate] = opts
         assert "after_move:%()j" = ot
         assert addl == []
@@ -21,7 +21,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
     end
 
     test "passes along custom command args" do
-      expect(YtDlpRunnerMock, :run, fn _url, opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :download, opts, _ot, _addl ->
         assert [:no_simulate, :custom_arg] = opts
 
         {:ok, "{}"}
@@ -31,7 +31,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
     end
 
     test "passes along additional options" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :download, _opts, _ot, addl ->
         assert [addl_arg: true] = addl
 
         {:ok, "{}"}
@@ -41,7 +41,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
     end
 
     test "parses and returns the generated file as JSON" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :download, _opts, _ot, _addl ->
         {:ok, render_metadata(:media_metadata)}
       end)
 
@@ -50,7 +50,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
     end
 
     test "returns errors" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opt, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :download, _opt, _ot, _addl ->
         {:error, "something"}
       end)
 
@@ -58,9 +58,77 @@ defmodule Pinchflat.YtDlp.MediaTest do
     end
   end
 
+  describe "get_downloadable_status/1" do
+    test "returns :downloadable if the media was never live" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, _addl ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "not_live"})}
+      end)
+
+      assert {:ok, :downloadable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns :downloadable if the media was live and has been processed" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, _addl ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "was_live"})}
+      end)
+
+      assert {:ok, :downloadable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns :downloadable if the media's live_status is nil" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, _addl ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => nil})}
+      end)
+
+      assert {:ok, :downloadable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns :ignorable if the media is currently live" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, _addl ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "is_live"})}
+      end)
+
+      assert {:ok, :ignorable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns :ignorable if the media is scheduled to be live" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, _addl ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "is_upcoming"})}
+      end)
+
+      assert {:ok, :ignorable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns :ignorable if the media was live but hasn't been processed" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, _addl ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "post_live"})}
+      end)
+
+      assert {:ok, :ignorable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns an error if the downloadable status can't be determined" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, _addl ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "what_tha"})}
+      end)
+
+      assert {:error, "Unknown live status: what_tha"} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "optionally accepts additional args" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_downloadable_status, _opts, _ot, addl ->
+        assert [addl_arg: true] = addl
+
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "not_live"})}
+      end)
+
+      assert {:ok, :downloadable} = Media.get_downloadable_status(@media_url, addl_arg: true)
+    end
+  end
+
   describe "download_thumbnail/2" do
     test "calls the backend runner with the expected arguments" do
-      expect(YtDlpRunnerMock, :run, fn @media_url, opts, ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn @media_url, :download_thumbnail, opts, ot, _addl ->
         assert opts == [:no_simulate, :skip_download, :write_thumbnail, {:convert_thumbnail, "jpg"}]
         assert ot == "after_move:%()j"
 
@@ -71,7 +139,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
     end
 
     test "passes along custom command args" do
-      expect(YtDlpRunnerMock, :run, fn _url, opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, opts, _ot, _addl ->
         assert :custom_arg in opts
 
         {:ok, "{}"}
@@ -81,7 +149,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
     end
 
     test "passes along additional options" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, addl ->
         assert [addl_arg: true] = addl
 
         {:ok, "{}"}
@@ -91,7 +159,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
     end
 
     test "returns errors" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opt, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opt, _ot, _addl ->
         {:error, "something"}
       end)
 
@@ -101,7 +169,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
 
   describe "get_media_attributes/1" do
     test "returns a list of video attributes" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, _addl ->
         {:ok, media_attributes_return_fixture()}
       end)
 
@@ -110,7 +178,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
     end
 
     test "it passes the expected default args" do
-      expect(YtDlpRunnerMock, :run, fn _url, opts, ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, opts, ot, _addl ->
         assert opts == [:simulate, :skip_download]
         assert ot == Media.indexing_output_template()
 
@@ -120,17 +188,26 @@ defmodule Pinchflat.YtDlp.MediaTest do
       assert {:ok, _} = Media.get_media_attributes(@media_url)
     end
 
+    test "passes along additional command options" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, opts, _ot, _addl ->
+        assert [:simulate, :skip_download, :custom_arg] = opts
+        {:ok, media_attributes_return_fixture()}
+      end)
+
+      assert {:ok, _} = Media.get_media_attributes(@media_url, [:custom_arg])
+    end
+
     test "passes along additional options" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, addl ->
         assert [addl_arg: true] = addl
         {:ok, media_attributes_return_fixture()}
       end)
 
-      assert {:ok, _} = Media.get_media_attributes(@media_url, addl_arg: true)
+      assert {:ok, _} = Media.get_media_attributes(@media_url, [], addl_arg: true)
     end
 
     test "returns the error straight through when the command fails" do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:error, "Big issue", 1} end)
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, _addl -> {:error, "Big issue", 1} end)
 
       assert {:error, "Big issue", 1} = Media.get_media_attributes(@media_url)
     end
@@ -139,7 +216,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
   describe "indexing_output_template/0" do
     test "contains all the greatest hits" do
       attrs =
-        ~w(id title live_status original_url description aspect_ratio duration upload_date timestamp playlist_index)a
+        ~w(id title live_status original_url description aspect_ratio duration upload_date timestamp playlist_index filename)a
 
       formatted_attrs = "%(.{#{Enum.join(attrs, ",")}})j"
 
@@ -159,7 +236,8 @@ defmodule Pinchflat.YtDlp.MediaTest do
         "duration" => 60,
         "upload_date" => "20210101",
         "timestamp" => 1_600_000_000,
-        "playlist_index" => 1
+        "playlist_index" => 1,
+        "filename" => "TiZPUDkDYbk.mp4"
       }
 
       assert %Media{
@@ -171,7 +249,8 @@ defmodule Pinchflat.YtDlp.MediaTest do
                short_form_content: false,
                uploaded_at: ~U[2020-09-13 12:26:40Z],
                duration_seconds: 60,
-               playlist_index: 1
+               playlist_index: 1,
+               predicted_media_filepath: "TiZPUDkDYbk.mp4"
              } == Media.response_to_struct(response)
     end
 

test/pinchflat_web/controllers/media_profile_controller_test.exs

@@ -79,6 +79,15 @@ defmodule PinchflatWeb.MediaProfileControllerTest do
 
       refute html_response(conn, 200) =~ "MENU"
     end
+
+    test "preloads some attributes when using a template", %{conn: conn} do
+      profile = media_profile_fixture(name: "My first profile", download_subs: true, sub_langs: "de")
+
+      conn = get(conn, ~p"/media_profiles/new", %{"template_id" => profile.id})
+      assert html_response(conn, 200) =~ "New Media Profile"
+      assert html_response(conn, 200) =~ profile.sub_langs
+      refute html_response(conn, 200) =~ profile.name
+    end
   end
 
   describe "edit media_profile" do

test/pinchflat_web/controllers/pages/job_table_live_test.exs

@@ -6,7 +6,6 @@ defmodule PinchflatWeb.Pages.JobTableLiveTest do
   import Pinchflat.MediaFixtures
   import Pinchflat.SourcesFixtures
 
-  alias Pinchflat.Utils.StringUtils
   alias Pinchflat.Pages.JobTableLive
   alias Pinchflat.Downloading.MediaDownloadWorker
   alias Pinchflat.FastIndexing.FastIndexingWorker
@@ -48,7 +47,7 @@ defmodule PinchflatWeb.Pages.JobTableLiveTest do
       {_source, media_item, _task, _job} = create_media_item_job()
       {:ok, _view, html} = live_isolated(conn, JobTableLive, session: %{})
 
-      assert html =~ StringUtils.truncate(media_item.title, 35)
+      assert html =~ media_item.title
     end
 
     test "shows a media item link", %{conn: conn} do
@@ -62,7 +61,7 @@ defmodule PinchflatWeb.Pages.JobTableLiveTest do
       {source, _task, _job} = create_source_job()
       {:ok, _view, html} = live_isolated(conn, JobTableLive, session: %{})
 
-      assert html =~ StringUtils.truncate(source.custom_name, 35)
+      assert html =~ source.custom_name
     end
 
     test "shows a source link", %{conn: conn} do