Bumped version

* [Housekeeping] Add release workflow (#141)

* add release workflow

This will create tags when a new release is published

* fix(workflows): refactor release workflow

Signed-off-by: Devin Buhl <devin@buhl.casa>

* Update release.yml

---------

Signed-off-by: Devin Buhl <devin@buhl.casa>

* Linting

* Testing changes

---------

Signed-off-by: Devin Buhl <devin@buhl.casa>
Co-authored-by: Devin Buhl <onedr0p@users.noreply.github.com>

.github/workflows/docker_release.yml

@@ -77,5 +77,3 @@ jobs:
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max

README.md

@@ -48,15 +48,9 @@ If it doesn't work for your use case, please make a feature request! You can als
   - Uses a novel approach to download new content more quickly than other apps
 - Supports downloading audio content
 - Custom rules for handling YouTube Shorts and livestreams
-- Apprise support for notifications
-- Allows automatically redownloading new media after a set period
-  - This can help improve the download quality of new content or improve SponsorBlock tags
-- Optionally automatically delete old content ([docs](https://github.com/kieraneglin/pinchflat/wiki/Automatically-Delete-Media))
 - Advanced options like setting cutoff dates and filtering by title
 - Reliable hands-off operation
 - Can pass cookies to YouTube to download your private playlists ([docs](https://github.com/kieraneglin/pinchflat/wiki/YouTube-Cookies))
-- Sponsorblock integration
-- \[Advanced\] allows custom `yt-dlp` options ([docs](https://github.com/kieraneglin/pinchflat/wiki/%5BAdvanced%5D-Custom-yt%E2%80%90dlp-options))
 
 ## Screenshots
 

assets/js/app.js

@@ -22,7 +22,6 @@ import { Socket } from 'phoenix'
 import { LiveSocket } from 'phoenix_live_view'
 import topbar from '../vendor/topbar'
 import Alpine from 'alpinejs'
-import './tabs'
 
 window.Alpine = Alpine
 Alpine.start()

assets/js/tabs.js

@@ -1,20 +0,0 @@
-window.setTabIndex = (index) => {
-  window.location.hash = `tab-${index}`
-
-  return index
-}
-
-// The conditionals and currIndex stuff ensures that
-// the tab index is always set to 0 if the hash is empty
-// AND other hash values are ignored
-window.getTabIndex = (currIndex) => {
-  if (window.location.hash === '' || window.location.hash === '#') {
-    return 0
-  }
-
-  if (window.location.hash.startsWith('#tab-')) {
-    return parseInt(window.location.hash.replace('#tab-', ''))
-  }
-
-  return currIndex
-}

config/config.exs

@@ -12,9 +12,7 @@ config :pinchflat,
   generators: [timestamp_type: :utc_datetime],
   # Specifying backend data here makes mocking and local testing SUPER easy
   yt_dlp_executable: System.find_executable("yt-dlp"),
-  apprise_executable: System.find_executable("apprise"),
   yt_dlp_runner: Pinchflat.YtDlp.CommandRunner,
-  apprise_runner: Pinchflat.Notifications.CommandRunner,
   media_directory: "/downloads",
   # The user may or may not store metadata for their needs, but the app will always store its copy
   metadata_directory: "/config/metadata",
@@ -48,14 +46,7 @@ config :pinchflat, Oban,
   engine: Oban.Engines.Lite,
   repo: Pinchflat.Repo,
   # Keep old jobs for 30 days for display in the UI
-  plugins: [
+  plugins: [{Oban.Plugins.Pruner, max_age: 30 * 24 * 60 * 60}],
-    {Oban.Plugins.Pruner, max_age: 30 * 24 * 60 * 60},
-    {Oban.Plugins.Cron,
-     crontab: [
-       {"0 1 * * *", Pinchflat.Downloading.MediaRetentionWorker},
-       {"0 2 * * *", Pinchflat.Downloading.MediaRedownloadWorker}
-     ]}
-  ],
   # TODO: consider making this an env var or something?
   queues: [
     default: 10,
@@ -88,7 +79,7 @@ config :esbuild,
 
 # Configure tailwind (the version is required)
 config :tailwind,
-  version: "3.4.3",
+  version: "3.3.2",
   default: [
     args: ~w(
       --config=tailwind.config.js

config/runtime.exs

@@ -57,7 +57,6 @@ if config_env() == :prod do
 
   config :pinchflat,
     yt_dlp_executable: System.find_executable("yt-dlp"),
-    apprise_executable: System.find_executable("apprise"),
     media_directory: "/downloads",
     metadata_directory: metadata_path,
     extras_directory: extras_path,

config/test.exs

@@ -3,7 +3,6 @@ import Config
 config :pinchflat,
   # Specifying backend data here makes mocking and local testing SUPER easy
   yt_dlp_executable: Path.join([File.cwd!(), "/test/support/scripts/yt-dlp-mocks/repeater.sh"]),
-  apprise_executable: Path.join([File.cwd!(), "/test/support/scripts/yt-dlp-mocks/repeater.sh"]),
   media_directory: Path.join([System.tmp_dir!(), "test", "media"]),
   metadata_directory: Path.join([System.tmp_dir!(), "test", "metadata"]),
   tmpfile_directory: Path.join([System.tmp_dir!(), "test", "tmpfiles"]),
@@ -33,7 +32,8 @@ config :pinchflat, Pinchflat.Mailer, adapter: Swoosh.Adapters.Test
 # Disable swoosh api client as it is only required for production adapters.
 config :swoosh, :api_client, false
 
-config :logger, level: :critical
+# Print only warnings and errors during test
+config :logger, level: :warning
 
 # Initialize plugs at runtime for faster test compilation
 config :phoenix, :plug_init_mode, :runtime

dev.Dockerfile

@@ -5,10 +5,15 @@ ARG DEV_IMAGE="hexpm/elixir:${ELIXIR_VERSION}-erlang-${OTP_VERSION}-debian-${DEB
 
 FROM ${DEV_IMAGE}
 
+# Set the locale deets
+ENV LANG en_US.UTF-8
+ENV LANGUAGE en_US:en
+ENV LC_ALL en_US.UTF-8
+
 # Install debian packages
 RUN apt-get update -qq
 RUN apt-get install -y inotify-tools ffmpeg curl git openssh-client \
-  python3 python3-pip python3-setuptools python3-wheel python3-dev locales
+  python3 python3-pip python3-setuptools python3-wheel python3-dev
 
 # Install nodejs
 RUN curl -sL https://deb.nodesource.com/setup_20.x -o nodesource_setup.sh
@@ -20,20 +25,9 @@ RUN npm install -g yarn
 RUN mix local.hex --force
 RUN mix local.rebar --force
 
-# Download and update YT-DLP
+# Download YT-DLP
 # NOTE: If you're seeing weird issues, consider using the FFMPEG released by yt-dlp
-RUN curl -L https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -o /usr/local/bin/yt-dlp
+RUN python3 -m pip install -U --pre yt-dlp --break-system-packages
-RUN chmod a+rx /usr/local/bin/yt-dlp
-RUN yt-dlp -U
-
-# Download Apprise
-RUN python3 -m pip install -U apprise --break-system-packages
-
-# Set the locale
-RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && locale-gen
-ENV LANG en_US.UTF-8
-ENV LANGUAGE en_US:en
-ENV LC_ALL en_US.UTF-8
 
 # Create app directory and copy the Elixir projects into it.
 WORKDIR /app

lib/pinchflat/boot/data_backfill_worker.ex

@@ -0,0 +1,62 @@
+defmodule Pinchflat.Boot.DataBackfillWorker do
+  @moduledoc false
+
+  use Oban.Worker,
+    queue: :local_metadata,
+    unique: [period: :infinity, states: [:available, :scheduled, :retryable]],
+    tags: ["media_item", "media_metadata", "local_metadata", "data_backfill"]
+
+  # This one is going to be a little more self-contained
+  # instead of relying on outside modules for the methods.
+  # That's because, for now, these methods are not intended
+  # to be used elsewhere.
+  #
+  # I'm just trying out that pattern and seeing if I like it better
+  # so this may change.
+  import Ecto.Query, warn: false
+  require Logger
+
+  alias __MODULE__
+  alias Pinchflat.Repo
+
+  @doc """
+  Cancels all pending backfill jobs. Useful for ensuring worker runs immediately
+  on app boot.
+
+  Returns {:ok, integer()}
+  """
+  def cancel_pending_backfill_jobs do
+    Oban.Job
+    |> where(worker: "Pinchflat.Boot.DataBackfillWorker")
+    |> Oban.cancel_all_jobs()
+  end
+
+  @impl Oban.Worker
+  @doc """
+  Performs one-off tasks to get data in the right shape.
+  This can be needed when we add new features or change the way
+  we store data. Must be idempotent. All new data should already
+  conform to the expected schema so this should only be needed
+  for existing data. Still runs periodically to be safe.
+
+  Returns :ok
+  """
+  def perform(%Oban.Job{}) do
+    Logger.info("Running data backfill worker")
+    # Nothing to do for now - just reschedule
+    # Keeping in-place because we _will_ need it in the future
+
+    reschedule_backfill()
+
+    :ok
+  end
+
+  defp reschedule_backfill do
+    # Run hourly
+    next_run_in = 60 * 60
+
+    %{}
+    |> DataBackfillWorker.new(schedule_in: next_run_in)
+    |> Repo.insert_unique_job()
+  end
+end

lib/pinchflat/boot/nfo_backfill_worker.ex

@@ -1,70 +0,0 @@
-defmodule Pinchflat.Boot.NfoBackfillWorker do
-  @moduledoc false
-
-  use Oban.Worker,
-    queue: :local_metadata,
-    # This should have it running once _ever_ (until the job is pruned, anyway)
-    # NOTE: remove within the next month
-    unique: [period: :infinity, states: Oban.Job.states()],
-    tags: ["media_item", "media_metadata", "local_metadata", "data_backfill"]
-
-  import Ecto.Query, warn: false
-  require Logger
-
-  alias Pinchflat.Repo
-  alias Pinchflat.Media
-  alias Pinchflat.Media.MediaItem
-  alias Pinchflat.Metadata.NfoBuilder
-  alias Pinchflat.Metadata.MetadataFileHelpers
-
-  @doc """
-  Runs a one-off backfill job to regenerate NFO files for media items that have
-  both an NFO file and a metadata file. This is needed because NFO files weren't
-  escaping characters properly so we need to regenerate them.
-
-  This job will only run once as long as I remove it before the jobs are pruned in a month.
-
-  Returns :ok
-  """
-  @impl Oban.Worker
-  def perform(%Oban.Job{}) do
-    Logger.info("Running NFO backfill worker")
-
-    media_items = get_media_items_to_backfill()
-
-    Enum.each(media_items, fn media_item ->
-      nfo_exists = File.exists?(media_item.nfo_filepath)
-      metadata_exists = File.exists?(media_item.metadata.metadata_filepath)
-
-      if nfo_exists && metadata_exists do
-        Logger.info("NFO and metadata exist for media item #{media_item.id} - proceeding")
-
-        regenerate_nfo_for_media_item(media_item)
-      end
-    end)
-
-    :ok
-  end
-
-  defp get_media_items_to_backfill do
-    from(m in MediaItem, where: not is_nil(m.nfo_filepath))
-    |> Repo.all()
-    |> Repo.preload([:metadata, source: :media_profile])
-  end
-
-  defp regenerate_nfo_for_media_item(media_item) do
-    try do
-      case MetadataFileHelpers.read_compressed_metadata(media_item.metadata.metadata_filepath) do
-        {:ok, metadata} ->
-          Media.update_media_item(media_item, %{
-            nfo_filepath: NfoBuilder.build_and_store_for_media_item(media_item.nfo_filepath, metadata)
-          })
-
-        _err ->
-          Logger.error("Failed to read metadata for media item #{media_item.id}")
-      end
-    rescue
-      e -> Logger.error("Unknown error regenerating NFO file for MI ##{media_item.id}: #{inspect(e)}")
-    end
-  end
-end

lib/pinchflat/boot/post_job_startup_tasks.ex

@@ -7,13 +7,13 @@ defmodule Pinchflat.Boot.PostJobStartupTasks do
   Phoenix supervision tree.
   """
 
-  alias Pinchflat.Repo
-  alias Pinchflat.Boot.NfoBackfillWorker
-
   # restart: :temporary means that this process will never be restarted (ie: will run once and then die)
   use GenServer, restart: :temporary
   import Ecto.Query, warn: false
 
+  alias Pinchflat.Repo
+  alias Pinchflat.Boot.DataBackfillWorker
+
   def start_link(opts \\ []) do
     GenServer.start_link(__MODULE__, %{}, opts)
   end
@@ -29,8 +29,16 @@ defmodule Pinchflat.Boot.PostJobStartupTasks do
   """
   @impl true
   def init(state) do
-    Repo.insert_unique_job(NfoBackfillWorker.new(%{}))
+    enqueue_backfill_worker()
 
     {:ok, state}
   end
+
+  defp enqueue_backfill_worker do
+    DataBackfillWorker.cancel_pending_backfill_jobs()
+
+    %{}
+    |> DataBackfillWorker.new()
+    |> Repo.insert_unique_job()
+  end
 end

lib/pinchflat/boot/pre_job_startup_tasks.ex

@@ -14,7 +14,7 @@ defmodule Pinchflat.Boot.PreJobStartupTasks do
 
   alias Pinchflat.Repo
   alias Pinchflat.Settings
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
 
   def start_link(opts \\ []) do
     GenServer.start_link(__MODULE__, %{}, opts)
@@ -32,7 +32,7 @@ defmodule Pinchflat.Boot.PreJobStartupTasks do
   @impl true
   def init(state) do
     reset_executing_jobs()
-    create_blank_yt_dlp_files()
+    create_blank_cookie_file()
     apply_default_settings()
 
     {:ok, state}
@@ -50,34 +50,19 @@ defmodule Pinchflat.Boot.PreJobStartupTasks do
     Logger.info("Reset #{count} executing jobs")
   end
 
-  defp create_blank_yt_dlp_files do
+  defp create_blank_cookie_file do
-    files = ["cookies.txt", "yt-dlp-configs/base-config.txt"]
     base_dir = Application.get_env(:pinchflat, :extras_directory)
+    filepath = Path.join(base_dir, "cookies.txt")
 
-    Enum.each(files, fn file ->
+    if !File.exists?(filepath) do
-      filepath = Path.join(base_dir, file)
+      Logger.info("Cookies does not exist - creating it")
 
-      if !File.exists?(filepath) do
+      FilesystemHelpers.write_p!(filepath, "")
-        Logger.info("Creating blank file: #{filepath}")
+    end
-
-        FilesystemUtils.write_p!(filepath, "")
-      end
-    end)
   end
 
   defp apply_default_settings do
-    {:ok, yt_dlp_version} = yt_dlp_runner().version()
+    Settings.fetch!(:onboarding, true)
-    {:ok, apprise_version} = apprise_runner().version()
+    Settings.fetch!(:pro_enabled, false)
-
-    Settings.set(yt_dlp_version: yt_dlp_version)
-    Settings.set(apprise_version: apprise_version)
-  end
-
-  defp yt_dlp_runner do
-    Application.get_env(:pinchflat, :yt_dlp_runner)
-  end
-
-  defp apprise_runner do
-    Application.get_env(:pinchflat, :apprise_runner)
   end
 end

lib/pinchflat/downloading/download_option_builder.ex

@@ -10,7 +10,8 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilder do
   @doc """
   Builds the options for yt-dlp to download media based on the given media's profile.
 
-  Returns {:ok, [Keyword.t()]}
+  IDEA: consider adding the ability to pass in a second argument to override
+        these options
   """
   def build(%MediaItem{} = media_item_with_preloads) do
     media_profile = media_item_with_preloads.source.media_profile
@@ -22,8 +23,7 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilder do
         metadata_options(media_profile) ++
         quality_options(media_profile) ++
         sponsorblock_options(media_profile) ++
-        output_options(media_item_with_preloads) ++
+        output_options(media_item_with_preloads)
-        config_file_options(media_item_with_preloads)
 
     {:ok, built_options}
   end
@@ -128,35 +128,6 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilder do
     end
   end
 
-  # This is put here instead of the CommandRunner module because it should only
-  # be applied to downloading - if it were in CommandRunner it would apply to
-  # all yt-dlp commands (like indexing)
-  defp config_file_options(media_item) do
-    base_dir = Path.join(Application.get_env(:pinchflat, :extras_directory), "yt-dlp-configs")
-    # Ordered by priority - the first file has the highest priority
-    filenames = [
-      "media-item-#{media_item.id}-config.txt",
-      "source-#{media_item.source_id}-config.txt",
-      "media-profile-#{media_item.source.media_profile_id}-config.txt",
-      "base-config.txt"
-    ]
-
-    config_filepaths =
-      Enum.reduce(filenames, [], fn filename, acc ->
-        filepath = Path.join(base_dir, filename)
-
-        case File.read(filepath) do
-          {:ok, file_data} ->
-            if String.trim(file_data) != "", do: [filepath | acc], else: acc
-
-          {:error, _} ->
-            acc
-        end
-      end)
-
-    Enum.map(config_filepaths, fn filepath -> {:config_locations, filepath} end)
-  end
-
   defp output_options(media_item_with_preloads) do
     [
       output: build_output_path_for(media_item_with_preloads.source)
@@ -173,8 +144,6 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilder do
   defp output_options_map(source) do
     %{
       "source_custom_name" => source.custom_name,
-      "source_collection_id" => source.collection_id,
-      "source_collection_name" => source.collection_name,
       "source_collection_type" => source.collection_type
     }
   end

lib/pinchflat/downloading/media_download_worker.ex

@@ -19,33 +19,28 @@ defmodule Pinchflat.Downloading.MediaDownloadWorker do
 
   Returns {:ok, %Task{}} | {:error, :duplicate_job} | {:error, %Ecto.Changeset{}}
   """
-  def kickoff_with_task(media_item, job_args \\ %{}, job_opts \\ []) do
+  def kickoff_with_task(media_item, opts \\ []) do
     %{id: media_item.id}
-    |> Map.merge(job_args)
+    |> MediaDownloadWorker.new(opts)
-    |> MediaDownloadWorker.new(job_opts)
     |> Tasks.create_job_with_task(media_item)
   end
 
   @doc """
   For a given media item, download the media alongside any options.
-  Does not download media if its source is set to not download media
+  Does not download media if its source is set to not download media.
-  (unless forced).
 
   Returns :ok | {:ok, %MediaItem{}} | {:error, any, ...any}
   """
   @impl Oban.Worker
-  def perform(%Oban.Job{args: %{"id" => media_item_id} = args}) do
+  def perform(%Oban.Job{args: %{"id" => media_item_id}}) do
-    should_force = Map.get(args, "force", false)
-    is_redownload = Map.get(args, "redownload?", false)
-
     media_item =
       media_item_id
       |> Media.get_media_item!()
       |> Repo.preload(:source)
 
-    # If the source or media item is set to not download media, perform a no-op unless forced
+    # If the source is set to not download media, perform a no-op
-    if (media_item.source.download_media && !media_item.prevent_download) || should_force do
+    if media_item.source.download_media do
-      download_media_and_schedule_jobs(media_item, is_redownload)
+      download_media_and_schedule_jobs(media_item)
     else
       :ok
     end
@@ -54,39 +49,25 @@ defmodule Pinchflat.Downloading.MediaDownloadWorker do
     Ecto.StaleEntryError -> Logger.info("#{__MODULE__} discarded: media item #{media_item_id} stale")
   end
 
-  defp download_media_and_schedule_jobs(media_item, is_redownload) do
+  defp download_media_and_schedule_jobs(media_item) do
     case MediaDownloader.download_for_media_item(media_item) do
       {:ok, updated_media_item} ->
-        Media.update_media_item(updated_media_item, %{
+        compute_and_save_media_filesize(updated_media_item)
-          media_size_bytes: compute_media_filesize(updated_media_item),
-          media_redownloaded_at: get_redownloaded_at(is_redownload)
-        })
 
         {:ok, updated_media_item}
 
-      {:recovered, _} ->
+      err ->
-        {:error, :retry}
+        err
-
-      {:error, _message} ->
-        {:error, :download_failed}
     end
   end
 
-  defp compute_media_filesize(media_item) do
+  defp compute_and_save_media_filesize(media_item) do
     case File.stat(media_item.media_filepath) do
       {:ok, %{size: size}} ->
-        size
+        Media.update_media_item(media_item, %{media_size_bytes: size})
 
       _ ->
-        nil
+        :ok
-    end
-  end
-
-  defp get_redownloaded_at(is_redownload) do
-    if is_redownload do
-      DateTime.utc_now()
-    else
-      nil
     end
   end
 end

lib/pinchflat/downloading/media_downloader.ex

@@ -5,15 +5,12 @@ defmodule Pinchflat.Downloading.MediaDownloader do
   to download the media with the desired options.
   """
 
-  require Logger
-
   alias Pinchflat.Repo
   alias Pinchflat.Media
   alias Pinchflat.Media.MediaItem
   alias Pinchflat.Metadata.NfoBuilder
   alias Pinchflat.Metadata.MetadataParser
   alias Pinchflat.Metadata.MetadataFileHelpers
-  alias Pinchflat.Utils.FilesystemUtils
   alias Pinchflat.Downloading.DownloadOptionBuilder
 
   alias Pinchflat.YtDlp.Media, as: YtDlpMedia
@@ -30,69 +27,33 @@ defmodule Pinchflat.Downloading.MediaDownloader do
   Returns {:ok, %MediaItem{}} | {:error, any, ...any}
   """
   def download_for_media_item(%MediaItem{} = media_item) do
-    output_filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
+    item_with_preloads = Repo.preload(media_item, [:metadata, source: :media_profile])
-    media_with_preloads = Repo.preload(media_item, [:metadata, source: :media_profile])
 
-    case download_with_options(media_item.original_url, media_with_preloads, output_filepath) do
+    case download_with_options(media_item.original_url, item_with_preloads) do
       {:ok, parsed_json} ->
-        update_media_item_from_parsed_json(media_with_preloads, parsed_json)
+        parsed_attrs =
+          parsed_json
+          |> MetadataParser.parse_for_media_item()
+          |> Map.merge(%{
+            media_downloaded_at: DateTime.utc_now(),
+            nfo_filepath: determine_nfo_filepath(item_with_preloads, parsed_json),
+            metadata: %{
+              # IDEA: might be worth kicking off a job for this since thumbnail fetching
+              # could fail and I want to handle that in isolation
+              metadata_filepath: MetadataFileHelpers.compress_and_store_metadata_for(media_item, parsed_json),
+              thumbnail_filepath: MetadataFileHelpers.download_and_store_thumbnail_for(media_item, parsed_json)
+            }
+          })
 
-      {:error, message, _exit_code} ->
+        # Don't forgor to use preloaded associations or updates to
-        Logger.error("yt-dlp download error for media item ##{media_with_preloads.id}: #{inspect(message)}")
+        # associations won't work!
-
+        Media.update_media_item(item_with_preloads, parsed_attrs)
-        if String.contains?(to_string(message), recoverable_errors()) do
-          attempt_update_media_item(media_with_preloads, output_filepath)
-
-          {:recovered, message}
-        else
-          {:error, message}
-        end
 
       err ->
-        Logger.error("Unknown error downloading media item ##{media_with_preloads.id}: #{inspect(err)}")
+        err
-
-        {:error, "Unknown error: #{inspect(err)}"}
     end
   end
 
-  defp attempt_update_media_item(media_with_preloads, output_filepath) do
-    with {:ok, contents} <- File.read(output_filepath),
-         {:ok, parsed_json} <- Phoenix.json_library().decode(contents) do
-      Logger.info("""
-      Recovery from yt-dlp error seems possible. Updating media item ##{media_with_preloads.id}
-      with parsed JSON from partial download attempt. Full download will be re-attemted in future
-      anyway
-      """)
-
-      update_media_item_from_parsed_json(media_with_preloads, parsed_json)
-    else
-      err ->
-        Logger.error("Unable to recover error for media item ##{media_with_preloads.id}: #{inspect(err)}")
-
-        {:error, :retry_failed}
-    end
-  end
-
-  defp update_media_item_from_parsed_json(media_with_preloads, parsed_json) do
-    parsed_attrs =
-      parsed_json
-      |> MetadataParser.parse_for_media_item()
-      |> Map.merge(%{
-        media_downloaded_at: DateTime.utc_now(),
-        nfo_filepath: determine_nfo_filepath(media_with_preloads, parsed_json),
-        metadata: %{
-          # IDEA: might be worth kicking off a job for this since thumbnail fetching
-          # could fail and I want to handle that in isolation
-          metadata_filepath: MetadataFileHelpers.compress_and_store_metadata_for(media_with_preloads, parsed_json),
-          thumbnail_filepath: MetadataFileHelpers.download_and_store_thumbnail_for(media_with_preloads, parsed_json)
-        }
-      })
-
-    # Don't forgor to use preloaded associations or updates to
-    # associations won't work!
-    Media.update_media_item(media_with_preloads, parsed_attrs)
-  end
-
   defp determine_nfo_filepath(media_item, parsed_json) do
     if media_item.source.media_profile.download_nfo do
       filepath = Path.rootname(parsed_json["filepath"]) <> ".nfo"
@@ -103,15 +64,9 @@ defmodule Pinchflat.Downloading.MediaDownloader do
     end
   end
 
-  defp download_with_options(url, item_with_preloads, output_filepath) do
+  defp download_with_options(url, item_with_preloads) do
     {:ok, options} = DownloadOptionBuilder.build(item_with_preloads)
 
-    YtDlpMedia.download(url, options, output_filepath: output_filepath)
+    YtDlpMedia.download(url, options)
-  end
-
-  defp recoverable_errors do
-    [
-      "Unable to communicate with SponsorBlock"
-    ]
   end
 end

lib/pinchflat/downloading/media_redownload_worker.ex

@@ -1,31 +0,0 @@
-defmodule Pinchflat.Downloading.MediaRedownloadWorker do
-  @moduledoc false
-
-  use Oban.Worker,
-    queue: :media_fetching,
-    unique: [period: :infinity, states: [:available, :scheduled, :retryable, :executing]],
-    tags: ["media_item", "media_fetching"]
-
-  require Logger
-
-  alias Pinchflat.Media
-  alias Pinchflat.Downloading.MediaDownloadWorker
-
-  @doc """
-  Redownloads media items that are eligible for redownload.
-
-  This worker is scheduled to run daily via the Oban Cron plugin
-  and it should run _after_ the retention worker.
-
-  Returns :ok
-  """
-  @impl Oban.Worker
-  def perform(%Oban.Job{}) do
-    redownloadable_media = Media.list_redownloadable_media_items()
-    Logger.info("Redownloading #{length(redownloadable_media)} media items")
-
-    Enum.each(redownloadable_media, fn media_item ->
-      MediaDownloadWorker.kickoff_with_task(media_item, %{redownload?: true})
-    end)
-  end
-end

lib/pinchflat/downloading/media_retention_worker.ex

@@ -1,33 +0,0 @@
-defmodule Pinchflat.Downloading.MediaRetentionWorker do
-  @moduledoc false
-
-  use Oban.Worker,
-    queue: :local_metadata,
-    unique: [period: :infinity, states: [:available, :scheduled, :retryable, :executing]],
-    tags: ["media_item", "local_metadata"]
-
-  require Logger
-
-  alias Pinchflat.Media
-
-  @doc """
-  Deletes media items that are past their retention date and prevents
-  them from being re-downloaded.
-
-  This worker is scheduled to run daily via the Oban Cron plugin.
-
-  Returns :ok
-  """
-  @impl Oban.Worker
-  def perform(%Oban.Job{}) do
-    cullable_media = Media.list_cullable_media_items()
-    Logger.info("Culling #{length(cullable_media)} media items past their retention date")
-
-    Enum.each(cullable_media, fn media_item ->
-      Media.delete_media_files(media_item, %{
-        prevent_download: true,
-        culled_at: DateTime.utc_now()
-      })
-    end)
-  end
-end

lib/pinchflat/fast_indexing/fast_indexing_helpers.ex

@@ -25,7 +25,7 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpers do
   function starts individual indexing tasks for each new media item. I think it does
   make sense grammatically, but I could see how that's confusing.
 
-  Returns [binary()] where each binary is the media ID of a new media item.
+  Returns :ok
   """
   def kickoff_indexing_tasks_from_youtube_rss_feed(%Source{} = source) do
     {:ok, media_ids} = YoutubeRss.get_recent_media_ids_from_rss(source)
@@ -37,8 +37,6 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpers do
 
       MediaIndexingWorker.kickoff_with_task(source, url)
     end)
-
-    new_media_ids
   end
 
   @doc """

lib/pinchflat/fast_indexing/fast_indexing_worker.ex

@@ -11,10 +11,8 @@ defmodule Pinchflat.FastIndexing.FastIndexingWorker do
   alias __MODULE__
   alias Pinchflat.Tasks
   alias Pinchflat.Sources
-  alias Pinchflat.Settings
   alias Pinchflat.Sources.Source
   alias Pinchflat.FastIndexing.FastIndexingHelpers
-  alias Pinchflat.Notifications.SourceNotifications
 
   @doc """
   Starts the source fast indexing worker and creates a task for the source.
@@ -39,7 +37,8 @@ defmodule Pinchflat.FastIndexing.FastIndexingWorker do
     source = Sources.get_source!(source_id)
 
     if source.fast_index do
-      perform_indexing_and_notification(source)
+      FastIndexingHelpers.kickoff_indexing_tasks_from_youtube_rss_feed(source)
+
       reschedule_indexing(source)
     else
       :ok
@@ -49,13 +48,6 @@ defmodule Pinchflat.FastIndexing.FastIndexingWorker do
     Ecto.StaleEntryError -> Logger.info("#{__MODULE__} discarded: source #{source_id} stale")
   end
 
-  defp perform_indexing_and_notification(source) do
-    apprise_server = Settings.get!(:apprise_server)
-    new_media_items = FastIndexingHelpers.kickoff_indexing_tasks_from_youtube_rss_feed(source)
-
-    SourceNotifications.send_new_media_notification(apprise_server, source, length(new_media_items))
-  end
-
   defp reschedule_indexing(source) do
     next_run_in = Source.fast_index_frequency() * 60
 

lib/pinchflat/filesystem/filesystem_helpers.ex

@@ -1,4 +1,4 @@
-defmodule Pinchflat.Utils.FilesystemUtils do
+defmodule Pinchflat.Filesystem.FilesystemHelpers do
   @moduledoc """
   Utility methods for working with the filesystem
   """

lib/pinchflat/media/media.ex

@@ -11,7 +11,7 @@ defmodule Pinchflat.Media do
   alias Pinchflat.Media.MediaItem
   alias Pinchflat.Media.MediaQuery
   alias Pinchflat.Metadata.MediaMetadata
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
 
   @doc """
   Returns the list of media_items.
@@ -22,57 +22,39 @@ defmodule Pinchflat.Media do
     Repo.all(MediaItem)
   end
 
-  @doc """
-  Returns a list of media_items that are cullable based on the retention period
-  of the source they belong to.
-
-  Returns [%MediaItem{}, ...]
-  """
-  def list_cullable_media_items do
-    MediaQuery.new()
-    |> MediaQuery.with_media_filepath()
-    |> MediaQuery.where_past_retention_period()
-    |> MediaQuery.where_culling_not_prevented()
-    |> Repo.all()
-  end
-
-  @doc """
-  Returns a list of media_items that are redownloadable based on the redownload delay
-  of the media_profile their source belongs to.
-
-  The logic is that a media_item is past_redownload_delay if the media_item's
-  upload_date is at least redownload_delay_days ago AND
-  `media_downloaded_at` - `redownload_delay_days` is before the media_item's `upload_date`.
-  This logic grabs media that we've recently downloaded AND is recently uploaded, but
-  doesn't grab media that we've recently downloaded and was uploaded a long time ago.
-  This also makes things work as expected when downloading media from a source for the
-  first time.
-
-  Returns [%MediaItem{}, ...]
-  """
-  def list_redownloadable_media_items do
-    MediaQuery.new()
-    |> MediaQuery.with_media_downloaded_at()
-    |> MediaQuery.where_download_not_prevented()
-    |> MediaQuery.where_not_culled()
-    |> MediaQuery.where_media_not_redownloaded()
-    |> MediaQuery.where_past_redownload_delay()
-    |> Repo.all()
-  end
-
   @doc """
   Returns a list of pending media_items for a given source, where
   pending means the `media_filepath` is `nil` AND the media_item
-  matches satisfies `MediaQuery.where_pending_download`. You
+  matches the format selection rules of the parent media_profile.
-  should really check out that function if you need to know more
+
-  because it has a lot going on.
+  See `build_format_clauses` but tl;dr is it _may_ filter based
+  on shorts or livestreams depending on the media_profile settings.
 
   Returns [%MediaItem{}, ...].
   """
-  def list_pending_media_items_for(%Source{} = source) do
+  def list_pending_media_items_for(%Source{} = source, opts \\ []) do
+    limit = Keyword.get(opts, :limit, nil)
+    source = Repo.preload(source, :media_profile)
+
     MediaQuery.new()
     |> MediaQuery.for_source(source)
-    |> MediaQuery.where_pending_download()
+    |> matching_download_criteria_for(source)
+    |> Repo.maybe_limit(limit)
+    |> Repo.all()
+  end
+
+  @doc """
+  Returns a list of downloaded media_items for a given source.
+
+  Returns [%MediaItem{}, ...].
+  """
+  def list_downloaded_media_items_for(%Source{} = source, opts \\ []) do
+    limit = Keyword.get(opts, :limit, nil)
+
+    MediaQuery.new()
+    |> MediaQuery.for_source(source)
+    |> MediaQuery.with_media_filepath()
+    |> Repo.maybe_limit(limit)
     |> Repo.all()
   end
 
@@ -90,7 +72,7 @@ defmodule Pinchflat.Media do
 
     MediaQuery.new()
     |> MediaQuery.with_id(media_item.id)
-    |> MediaQuery.where_pending_download()
+    |> matching_download_criteria_for(media_item.source)
     |> Repo.exists?()
   end
 
@@ -179,7 +161,7 @@ defmodule Pinchflat.Media do
     Tasks.delete_tasks_for(media_item)
 
     if delete_files do
-      {:ok, _} = do_delete_media_files(media_item)
+      {:ok, _} = delete_media_files(media_item)
     end
 
     # Should delete these no matter what
@@ -187,25 +169,6 @@ defmodule Pinchflat.Media do
     Repo.delete(media_item)
   end
 
-  @doc """
-  Deletes the tasks and media files associated with a media_item but leaves the
-  media_item in the database. Does not delete anything to do with associated metadata.
-
-  Optionally accepts a second argument `addl_attrs` which will be merged into the
-  media_item before it is updated. Useful for setting things like `prevent_download`
-  and `culled_at`, if wanted
-
-  Returns {:ok, %MediaItem{}} | {:error, %Ecto.Changeset{}}
-  """
-  def delete_media_files(%MediaItem{} = media_item, addl_attrs \\ %{}) do
-    filepath_attrs = MediaItem.filepath_attribute_defaults()
-
-    Tasks.delete_tasks_for(media_item)
-    {:ok, _} = do_delete_media_files(media_item)
-
-    update_media_item(media_item, Map.merge(filepath_attrs, addl_attrs))
-  end
-
   @doc """
   Returns an `%Ecto.Changeset{}` for tracking media_item changes.
   """
@@ -213,7 +176,7 @@ defmodule Pinchflat.Media do
     MediaItem.changeset(media_item, attrs)
   end
 
-  defp do_delete_media_files(media_item) do
+  defp delete_media_files(media_item) do
     mapped_struct = Map.from_struct(media_item)
 
     MediaItem.filepath_attributes()
@@ -223,7 +186,7 @@ defmodule Pinchflat.Media do
     end)
     |> List.flatten()
     |> Enum.filter(&is_binary/1)
-    |> Enum.each(&FilesystemUtils.delete_file_and_remove_empty_directories/1)
+    |> Enum.each(&FilesystemHelpers.delete_file_and_remove_empty_directories/1)
 
     {:ok, media_item}
   end
@@ -235,6 +198,14 @@ defmodule Pinchflat.Media do
     MediaMetadata.filepath_attributes()
     |> Enum.map(fn field -> mapped_struct[field] end)
     |> Enum.filter(&is_binary/1)
-    |> Enum.each(&FilesystemUtils.delete_file_and_remove_empty_directories/1)
+    |> Enum.each(&FilesystemHelpers.delete_file_and_remove_empty_directories/1)
+  end
+
+  defp matching_download_criteria_for(query, source_with_preloads) do
+    query
+    |> MediaQuery.with_no_media_filepath()
+    |> MediaQuery.with_upload_date_after(source_with_preloads.download_cutoff_date)
+    |> MediaQuery.with_format_preference(source_with_preloads.media_profile)
+    |> MediaQuery.matching_title_regex(source_with_preloads.title_filter_regex)
   end
 end

lib/pinchflat/media/media_item.ex

@@ -30,12 +30,7 @@ defmodule Pinchflat.Media.MediaItem do
     :subtitle_filepaths,
     :thumbnail_filepath,
     :metadata_filepath,
-    :nfo_filepath,
+    :nfo_filepath
-    # These are user or system controlled fields
-    :prevent_download,
-    :prevent_culling,
-    :culled_at,
-    :media_redownloaded_at
   ]
   # Pretty much all the fields captured at index are required.
   @required_fields ~w(
@@ -47,7 +42,7 @@ defmodule Pinchflat.Media.MediaItem do
     source_id
     upload_date
     short_form_content
-  )a
+    )a
 
   schema "media_items" do
     # This is _not_ used as the primary key or internally in the database
@@ -62,7 +57,6 @@ defmodule Pinchflat.Media.MediaItem do
     field :livestream, :boolean, default: false
     field :short_form_content, :boolean, default: false
     field :media_downloaded_at, :utc_datetime
-    field :media_redownloaded_at, :utc_datetime
     field :upload_date, :date
     field :duration_seconds, :integer
 
@@ -76,10 +70,6 @@ defmodule Pinchflat.Media.MediaItem do
     # Will very likely revisit because I can't leave well-enough alone.
     field :subtitle_filepaths, {:array, {:array, :string}}, default: []
 
-    field :prevent_download, :boolean, default: false
-    field :prevent_culling, :boolean, default: false
-    field :culled_at, :utc_datetime
-
     field :matching_search_term, :string, virtual: true
 
     belongs_to :source, Source
@@ -106,14 +96,4 @@ defmodule Pinchflat.Media.MediaItem do
   def filepath_attributes do
     ~w(media_filepath thumbnail_filepath metadata_filepath subtitle_filepaths nfo_filepath)a
   end
-
-  @doc false
-  def filepath_attribute_defaults do
-    filepath_attributes()
-    |> Enum.map(fn
-      :subtitle_filepaths -> {:subtitle_filepaths, []}
-      field -> {field, nil}
-    end)
-    |> Enum.into(%{})
-  end
 end

lib/pinchflat/media/media_query.ex

@@ -3,10 +3,13 @@ defmodule Pinchflat.Media.MediaQuery do
   Query helpers for the Media context.
 
   These methods are made to be one-ish liners used
-  to compose queries. Each method should strive to do
+  to compose queries for media items. Each method should
-  _one_ thing. These don't need to be tested as
+  strive to do _one_ thing. These don't need to be tested
-  they are just building blocks for other functionality
+  as they are just building blocks for other functionality
   which, itself, will be tested.
+
+  ALSO, this is me trying something new. If I like it,
+  I'll refactor other contexts to use this pattern.
   """
   import Ecto.Query, warn: false
 
@@ -14,8 +17,7 @@ defmodule Pinchflat.Media.MediaQuery do
 
   # Prefixes:
   # - for_* - belonging to a certain record
-  # - join_* - for joining on a certain record
+  # - with_* - for filtering based on full, concrete attributes
-  # - with_*, where_* - for filtering based on full, concrete attributes
   # - matching_* - for filtering based on partial attributes (e.g. LIKE, regex, full-text search)
   #
   # Suffixes:
@@ -29,50 +31,6 @@ defmodule Pinchflat.Media.MediaQuery do
     where(query, [mi], mi.source_id == ^source.id)
   end
 
-  def join_sources(query) do
-    from(mi in query, join: s in assoc(mi, :source), as: :sources)
-  end
-
-  def where_past_retention_period(query) do
-    query
-    |> require_assoc(:source)
-    |> where(
-      [mi, source],
-      fragment("""
-      IFNULL(retention_period_days, 0) > 0 AND
-      DATETIME('now', '-' || retention_period_days || ' day') > media_downloaded_at
-      """)
-    )
-  end
-
-  def where_past_redownload_delay(query) do
-    query
-    |> require_assoc(:source)
-    |> require_assoc(:media_profile)
-    |> where(
-      [_mi, _source, _media_profile],
-      # Returns media items where the upload_date is at least redownload_delay_days ago AND
-      # downloaded_at minus the redownload_delay_days is before the upload date
-      fragment("""
-        IFNULL(redownload_delay_days, 0) > 0 AND
-        DATETIME('now', '-' || redownload_delay_days || ' day') > upload_date AND
-        DATETIME(media_downloaded_at, '-' || redownload_delay_days || ' day') < upload_date
-      """)
-    )
-  end
-
-  def where_culling_not_prevented(query) do
-    where(query, [mi], mi.prevent_culling == false)
-  end
-
-  def where_not_culled(query) do
-    where(query, [mi], is_nil(mi.culled_at))
-  end
-
-  def where_media_not_redownloaded(query) do
-    where(query, [mi], is_nil(mi.media_redownloaded_at))
-  end
-
   def with_id(query, id) do
     where(query, [mi], mi.id == ^id)
   end
@@ -81,10 +39,6 @@ defmodule Pinchflat.Media.MediaQuery do
     where(query, [mi], mi.media_id in ^media_ids)
   end
 
-  def with_media_downloaded_at(query) do
-    where(query, [mi], not is_nil(mi.media_downloaded_at))
-  end
-
   def with_media_filepath(query) do
     where(query, [mi], not is_nil(mi.media_filepath))
   end
@@ -93,23 +47,16 @@ defmodule Pinchflat.Media.MediaQuery do
     where(query, [mi], is_nil(mi.media_filepath))
   end
 
-  def with_upload_date_after_source_cutoff(query) do
+  def with_upload_date_after(query, nil), do: query
-    query
+
-    |> require_assoc(:source)
+  def with_upload_date_after(query, date) do
-    |> where([mi, source], is_nil(source.download_cutoff_date) or mi.upload_date >= source.download_cutoff_date)
+    where(query, [mi], mi.upload_date >= ^date)
   end
 
-  def where_download_not_prevented(query) do
+  def matching_title_regex(query, nil), do: query
-    where(query, [mi], mi.prevent_download == false)
-  end
 
-  def matching_source_title_regex(query) do
+  def matching_title_regex(query, regex) do
-    query
+    where(query, [mi], fragment("regexp_like(?, ?)", mi.title, ^regex))
-    |> require_assoc(:source)
-    |> where(
-      [mi, source],
-      is_nil(source.title_filter_regex) or fragment("regexp_like(?, ?)", mi.title, source.title_filter_regex)
-    )
   end
 
   def matching_search_term(query, nil), do: query
@@ -130,55 +77,44 @@ defmodule Pinchflat.Media.MediaQuery do
     )
   end
 
-  def with_format_matching_profile_preference(query) do
+  # NOTE: this method breaks the contract set by other methods in that it
-    query
+  # takes a media_profile struct instead of taking just the attributes it
-    |> require_assoc(:media_profile)
+  # cares about. Consider refactoring but low priority.
-    |> where(
+  def with_format_preference(query, media_profile) do
-      fragment("""
+    mapped_struct = Map.from_struct(media_profile)
-        CASE
-          WHEN shorts_behaviour = 'only' AND livestream_behaviour = 'only' THEN
-            livestream = true OR short_form_content = true
-          WHEN shorts_behaviour = 'only' THEN
-            short_form_content = true
-          WHEN livestream_behaviour = 'only' THEN
-            livestream = true
-          WHEN shorts_behaviour = 'exclude' AND livestream_behaviour = 'exclude' THEN
-            short_form_content = false AND livestream = false
-          WHEN shorts_behaviour = 'exclude' THEN
-            short_form_content = false
-          WHEN livestream_behaviour = 'exclude' THEN
-            livestream = false
-          ELSE
-            true
-        END
-      """)
-    )
-  end
 
-  def where_pending_download(query) do
+    finders =
-    query
+      Enum.reduce(mapped_struct, dynamic(true), fn attr, dynamic ->
-    |> where_download_not_prevented()
+        case {attr, media_profile} do
-    |> with_no_media_filepath()
+          {{:shorts_behaviour, :only}, %{livestream_behaviour: :only}} ->
-    |> with_upload_date_after_source_cutoff()
+            dynamic(
-    |> with_format_matching_profile_preference()
+              [mi],
-    |> matching_source_title_regex()
+              ^dynamic and (mi.livestream == true or mi.short_form_content == true)
-  end
+            )
 
-  defp require_assoc(query, identifier) do
+          # Technically redundant, but makes the other clauses easier to parse
-    if has_named_binding?(query, identifier) do
+          # (redundant because this condition is the same as the condition above, just flipped)
-      query
+          {{:livestream_behaviour, :only}, %{shorts_behaviour: :only}} ->
-    else
+            dynamic
-      do_require_assoc(query, identifier)
-    end
-  end
 
-  defp do_require_assoc(query, :source) do
+          {{:shorts_behaviour, :only}, _} ->
-    from(mi in query, join: s in assoc(mi, :source), as: :source)
+            dynamic([mi], ^dynamic and mi.short_form_content == true)
-  end
 
-  defp do_require_assoc(query, :media_profile) do
+          {{:livestream_behaviour, :only}, _} ->
-    query
+            dynamic([mi], ^dynamic and mi.livestream == true)
-    |> require_assoc(:source)
+
-    |> join(:inner, [mi, source], mp in assoc(source, :media_profile), as: :media_profile)
+          {{:shorts_behaviour, :exclude}, %{livestream_behaviour: lb}} when lb != :only ->
+            dynamic([mi], ^dynamic and mi.short_form_content == false)
+
+          {{:livestream_behaviour, :exclude}, %{shorts_behaviour: sb}} when sb != :only ->
+            # return records with livestream: false
+            dynamic([mi], ^dynamic and mi.livestream == false)
+
+          _ ->
+            dynamic
+        end
+      end)
+
+    where(query, ^finders)
   end
 end

lib/pinchflat/metadata/metadata_file_helpers.ex

@@ -9,7 +9,7 @@ defmodule Pinchflat.Metadata.MetadataFileHelpers do
   needed
   """
 
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
 
   @doc """
   Returns the directory where metadata for a database record should be stored.
@@ -36,7 +36,7 @@ defmodule Pinchflat.Metadata.MetadataFileHelpers do
     filepath = generate_filepath_for(database_record, "metadata.json.gz")
     {:ok, json} = Phoenix.json_library().encode(metadata_map)
 
-    :ok = FilesystemUtils.write_p!(filepath, json, [:compressed])
+    :ok = FilesystemHelpers.write_p!(filepath, json, [:compressed])
 
     filepath
   end
@@ -62,7 +62,7 @@ defmodule Pinchflat.Metadata.MetadataFileHelpers do
     filepath = generate_filepath_for(database_record, Path.basename(thumbnail_url))
     thumbnail_blob = fetch_thumbnail_from_url(thumbnail_url)
 
-    :ok = FilesystemUtils.write_p!(filepath, thumbnail_blob)
+    :ok = FilesystemHelpers.write_p!(filepath, thumbnail_blob)
 
     filepath
   end

lib/pinchflat/metadata/nfo_builder.ex

@@ -4,10 +4,8 @@ defmodule Pinchflat.Metadata.NfoBuilder do
   use by Kodi/Jellyfin and other media center software.
   """
 
-  import Pinchflat.Utils.XmlUtils, only: [safe: 1]
-
   alias Pinchflat.Metadata.MetadataFileHelpers
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
 
   @doc """
   Builds an NFO file for a media item (read: single "episode") and
@@ -18,7 +16,7 @@ defmodule Pinchflat.Metadata.NfoBuilder do
   def build_and_store_for_media_item(filepath, metadata) do
     nfo = build_for_media_item(metadata)
 
-    FilesystemUtils.write_p!(filepath, nfo)
+    FilesystemHelpers.write_p!(filepath, nfo)
 
     filepath
   end
@@ -32,7 +30,7 @@ defmodule Pinchflat.Metadata.NfoBuilder do
   def build_and_store_for_source(filepath, metadata) do
     nfo = build_for_source(metadata)
 
-    FilesystemUtils.write_p!(filepath, nfo)
+    FilesystemHelpers.write_p!(filepath, nfo)
 
     filepath
   end
@@ -44,12 +42,12 @@ defmodule Pinchflat.Metadata.NfoBuilder do
     """
     <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
     <episodedetails>
-      <title>#{safe(metadata["title"])}</title>
+      <title>#{metadata["title"]}</title>
-      <showtitle>#{safe(metadata["uploader"])}</showtitle>
+      <showtitle>#{metadata["uploader"]}</showtitle>
-      <uniqueid type="youtube" default="true">#{safe(metadata["id"])}</uniqueid>
+      <uniqueid type="youtube" default="true">#{metadata["id"]}</uniqueid>
-      <plot>#{safe(metadata["description"])}</plot>
+      <plot>#{metadata["description"]}</plot>
-      <aired>#{safe(upload_date)}</aired>
+      <aired>#{upload_date}</aired>
-      <season>#{safe(upload_date.year)}</season>
+      <season>#{upload_date.year}</season>
       <episode>#{Calendar.strftime(upload_date, "%m%d")}</episode>
       <genre>YouTube</genre>
     </episodedetails>
@@ -60,9 +58,9 @@ defmodule Pinchflat.Metadata.NfoBuilder do
     """
     <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
     <tvshow>
-      <title>#{safe(metadata["title"])}</title>
+      <title>#{metadata["title"]}</title>
-      <plot>#{safe(metadata["description"])}</plot>
+      <plot>#{metadata["description"]}</plot>
-      <uniqueid type="youtube" default="true">#{safe(metadata["id"])}</uniqueid>
+      <uniqueid type="youtube" default="true">#{metadata["id"]}</uniqueid>
       <genre>YouTube</genre>
     </tvshow>
     """

lib/pinchflat/metadata/source_image_parser.ex

@@ -2,7 +2,7 @@ defmodule Pinchflat.Metadata.SourceImageParser do
   @moduledoc """
   Functions for parsing and storing source images.
   """
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
 
   @doc """
   Given a base directory and source metadata, look for the appropriate images
@@ -62,7 +62,7 @@ defmodule Pinchflat.Metadata.SourceImageParser do
     extension = Path.extname(tmp_filepath)
     final_filepath = Path.join([base_directory, "#{filename}#{extension}"])
 
-    FilesystemUtils.cp_p!(tmp_filepath, final_filepath)
+    FilesystemHelpers.cp_p!(tmp_filepath, final_filepath)
 
     {source_attr_name, final_filepath}
   end

lib/pinchflat/notifications/apprise_command_runner.ex

@@ -1,12 +0,0 @@
-defmodule Pinchflat.Notifications.AppriseCommandRunner do
-  @moduledoc """
-  A behaviour for running CLI commands against a notification backend (apprise).
-
-  Used so we can implement Mox for testing without actually running the
-  apprise command.
-  """
-
-  @callback run(binary(), keyword()) :: :ok | {:error, binary()}
-  @callback run(List.t(), keyword()) :: :ok | {:error, binary()}
-  @callback version() :: {:ok, binary()} | {:error, binary()}
-end

lib/pinchflat/notifications/command_runner.ex

@@ -1,65 +0,0 @@
-defmodule Pinchflat.Notifications.CommandRunner do
-  @moduledoc """
-  Runs apprise commands using the `System.cmd/3` function
-  """
-
-  require Logger
-
-  alias Pinchflat.Utils.CliUtils
-  alias Pinchflat.Utils.FunctionUtils
-  alias Pinchflat.Notifications.AppriseCommandRunner
-
-  @behaviour AppriseCommandRunner
-
-  @doc """
-  Runs an apprise command and returns the string output.
-  Can take a single server string or a list of servers as well as additional
-  arguments to pass to the command.
-
-  Returns {:ok, binary()} | {:error, :no_servers} | {:error, binary()}
-  """
-  @impl AppriseCommandRunner
-  def run(nil, _), do: {:error, :no_servers}
-  def run("", _), do: {:error, :no_servers}
-  def run([], _), do: {:error, :no_servers}
-
-  def run(endpoints, command_opts) do
-    endpoints = List.wrap(endpoints)
-    default_opts = [:verbose]
-    parsed_opts = CliUtils.parse_options(default_opts ++ command_opts)
-
-    Logger.info("[apprise] called with: #{Enum.join(parsed_opts ++ endpoints, " ")}")
-    {output, return_code} = System.cmd(backend_executable(), parsed_opts ++ endpoints)
-    Logger.info("[apprise] response: #{output}")
-
-    case return_code do
-      0 -> {:ok, String.trim(output)}
-      _ -> {:error, String.trim(output)}
-    end
-  end
-
-  @doc """
-  Returns the version of apprise as a string.
-
-  Returns {:ok, binary()} | {:error, binary()}
-  """
-  @impl AppriseCommandRunner
-  def version do
-    case System.cmd(backend_executable(), ["--version"]) do
-      {output, 0} ->
-        output
-        |> String.split(~r{\r?\n})
-        |> List.first()
-        |> String.replace("Apprise", "")
-        |> String.trim()
-        |> FunctionUtils.wrap_ok()
-
-      {output, _} ->
-        {:error, output}
-    end
-  end
-
-  defp backend_executable do
-    Application.get_env(:pinchflat, :apprise_executable)
-  end
-end

lib/pinchflat/notifications/source_notifications.ex

@@ -1,77 +0,0 @@
-defmodule Pinchflat.Notifications.SourceNotifications do
-  @moduledoc """
-  Contains utilities for sending notifications about sources
-  """
-
-  require Logger
-
-  alias Pinchflat.Repo
-  alias Pinchflat.Media.MediaQuery
-
-  @doc """
-  Wraps a function that may change the number of pending  or downloaded
-  media items for a source, sending an apprise notification if
-  the count changes.
-
-  Returns the return value of the provided function
-  """
-  def wrap_new_media_notification(servers, source, func) do
-    before_count = relevant_media_item_count(source)
-    retval = func.()
-    after_count = relevant_media_item_count(source)
-
-    send_new_media_notification(servers, source, after_count - before_count)
-
-    retval
-  end
-
-  @doc """
-  Sends a notification if the count of new media items has changed
-
-  Returns :ok
-  """
-  def send_new_media_notification(_, _, count) when count <= 0, do: :ok
-
-  def send_new_media_notification(servers, source, changed_count) do
-    opts = [
-      title: "[Pinchflat] New media found",
-      body: "Found #{changed_count} new media item(s) for #{source.custom_name}. Downloading them now"
-    ]
-
-    case backend_runner().run(servers, opts) do
-      {:ok, _} ->
-        Logger.info("Sent new media notification for source #{source.id}")
-
-      {:error, :no_servers} ->
-        Logger.info("No notification servers provided for source #{source.id}")
-
-      {:error, err} ->
-        Logger.error("Failed to send new media notification for source #{source.id}: #{err}")
-    end
-
-    :ok
-  end
-
-  defp relevant_media_item_count(source) do
-    pending_media_item_count(source) + downloaded_media_item_count(source)
-  end
-
-  defp pending_media_item_count(source) do
-    MediaQuery.new()
-    |> MediaQuery.for_source(source)
-    |> MediaQuery.where_pending_download()
-    |> Repo.aggregate(:count)
-  end
-
-  defp downloaded_media_item_count(source) do
-    MediaQuery.new()
-    |> MediaQuery.for_source(source)
-    |> MediaQuery.with_media_filepath()
-    |> Repo.aggregate(:count)
-  end
-
-  defp backend_runner do
-    # This approach lets us mock the command for testing
-    Application.get_env(:pinchflat, :apprise_runner)
-  end
-end

lib/pinchflat/podcasts/podcast_helpers.ex

@@ -5,7 +5,7 @@ defmodule Pinchflat.Podcasts.PodcastHelpers do
   """
 
   alias Pinchflat.Repo
-  alias Pinchflat.Media.MediaQuery
+  alias Pinchflat.Media
   alias Pinchflat.Metadata.MediaMetadata
   alias Pinchflat.Metadata.SourceMetadata
 
@@ -25,11 +25,8 @@ defmodule Pinchflat.Podcasts.PodcastHelpers do
   def persisted_media_items_for(source, opts \\ []) do
     limit = Keyword.get(opts, :limit, 500)
 
-    MediaQuery.new()
+    source
-    |> MediaQuery.for_source(source)
+    |> Media.list_downloaded_media_items_for(limit: limit)
-    |> MediaQuery.with_media_filepath()
-    |> Repo.maybe_limit(limit)
-    |> Repo.all()
     |> Enum.filter(fn media_item -> File.exists?(media_item.media_filepath) end)
   end
 

lib/pinchflat/podcasts/rss_feed_builder.ex

@@ -5,8 +5,6 @@ defmodule Pinchflat.Podcasts.RssFeedBuilder do
 
   @datetime_format "%a, %d %b %Y %H:%M:%S %z"
 
-  import Pinchflat.Utils.XmlUtils, only: [safe: 1]
-
   alias Pinchflat.Utils.DatetimeUtils
   alias Pinchflat.Podcasts.PodcastHelpers
   alias PinchflatWeb.Router.Helpers, as: Routes
@@ -45,25 +43,25 @@ defmodule Pinchflat.Podcasts.RssFeedBuilder do
       xmlns:atom="http://www.w3.org/2005/Atom">
       <channel>
         <title>#{safe(source.custom_name)}</title>
-        <link>#{safe(source.original_url)}</link>
+        <link>#{source.original_url}</link>
         <description>#{safe(source.description)}</description>
         <category>TV &amp; Film</category>
         <generator>Generated by Pinchflat</generator>
         <language>en-us</language>
         <lastBuildDate>#{Calendar.strftime(source.updated_at, @datetime_format)}</lastBuildDate>
         <pubDate>#{Calendar.strftime(source.inserted_at, @datetime_format)}</pubDate>
-        <atom:link href="#{safe(generate_self_link(url_base, source))}" rel="self" type="application/rss+xml" />
+        <atom:link href="#{generate_self_link(url_base, source)}" rel="self" type="application/rss+xml" />
         <podcast:locked>yes</podcast:locked>
         <podcast:guid>#{source.uuid}</podcast:guid>
         <image>
-          <url>#{safe(feed_image_path)}</url>
+          <url>#{feed_image_path}</url>
           <title>#{safe(source.custom_name)}</title>
-          <link>#{safe(source.original_url)}</link>
+          <link>#{source.original_url}</link>
         </image>
         <itunes:author>#{safe(source.custom_name)}</itunes:author>
         <itunes:subtitle>#{safe(source.custom_name)}</itunes:subtitle>
         <itunes:block>yes</itunes:block>
-        <itunes:image href="#{safe(feed_image_path)}"></itunes:image>
+        <itunes:image href="#{feed_image_path}"></itunes:image>
         <itunes:explicit>false</itunes:explicit>
         <itunes:category text="TV &amp; Film"></itunes:category>
 
@@ -79,7 +77,7 @@ defmodule Pinchflat.Podcasts.RssFeedBuilder do
     <item>
       <guid isPermaLink="false">#{media_item.uuid}</guid>
       <title>#{safe(media_item.title)}</title>
-      <link>#{safe(media_item.original_url)}</link>
+      <link>#{media_item.original_url}</link>
       <description>#{safe(media_item.description)}</description>
       <pubDate>#{generate_upload_date(media_item)}</pubDate>
       <itunes:duration>#{media_item.duration_seconds}</itunes:duration>
@@ -96,6 +94,14 @@ defmodule Pinchflat.Podcasts.RssFeedBuilder do
     """
   end
 
+  defp safe(nil), do: ""
+
+  defp safe(value) do
+    value
+    |> Phoenix.HTML.html_escape()
+    |> Phoenix.HTML.safe_to_string()
+  end
+
   defp generate_self_link(url_base, source) do
     Path.join(url_base, "#{podcast_route(:rss_feed, source.uuid)}.xml")
   end

lib/pinchflat/profiles/media_profile.ex

@@ -26,14 +26,12 @@ defmodule Pinchflat.Profiles.MediaProfile do
     shorts_behaviour
     livestream_behaviour
     preferred_resolution
-    redownload_delay_days
   )a
 
   @required_fields ~w(name output_path_template)a
 
   schema "media_profiles" do
     field :name, :string
-    field :redownload_delay_days, :integer
 
     field :output_path_template, :string,
       default: "/{{ source_custom_name }}/{{ upload_yyyy_mm_dd }} {{ title }}/{{ title }} [{{ id }}].{{ ext }}"
@@ -62,6 +60,7 @@ 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(2160p 1080p 720p 480p 360p audio)a, default: :"1080p"
 
     has_many :sources, Source
@@ -76,7 +75,6 @@ defmodule Pinchflat.Profiles.MediaProfile do
     |> validate_required(@required_fields)
     # Ensures it ends with `.{{ ext }}` or `.%(ext)s` or similar (with a little wiggle room)
     |> validate_format(:output_path_template, ext_regex(), message: "must end with .{{ ext }}")
-    |> validate_number(:redownload_delay_days, greater_than_or_equal_to: 0)
     |> unique_constraint(:name)
   end
 

lib/pinchflat/release.ex

@@ -7,7 +7,7 @@ defmodule Pinchflat.Release do
 
   require Logger
 
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
 
   def migrate do
     load_app()
@@ -39,7 +39,7 @@ defmodule Pinchflat.Release do
       Logger.info("Checking permissions for #{dir}")
       filepath = Path.join([dir, ".keep"])
 
-      case FilesystemUtils.write_p(filepath, "") do
+      case FilesystemHelpers.write_p(filepath, "") do
         :ok ->
           Logger.info("Permissions OK")
 

lib/pinchflat/settings/setting.ex

@@ -1,36 +1,24 @@
 defmodule Pinchflat.Settings.Setting do
   @moduledoc """
-  The Setting schema.
+  A Setting is a key-value pair with a datatype used to track user-level settings.
   """
 
   use Ecto.Schema
   import Ecto.Changeset
 
-  @allowed_fields [
-    :onboarding,
-    :pro_enabled,
-    :yt_dlp_version,
-    :apprise_version,
-    :apprise_server
-  ]
-
-  @required_fields ~w(
-    onboarding
-    pro_enabled
-  )a
-
   schema "settings" do
-    field :onboarding, :boolean, default: true
+    field :name, :string
-    field :pro_enabled, :boolean, default: false
+    field :value, :string
-    field :yt_dlp_version, :string
+    field :datatype, Ecto.Enum, values: ~w(boolean string integer float)a
-    field :apprise_version, :string
+
-    field :apprise_server, :string
+    timestamps(type: :utc_datetime)
   end
 
   @doc false
   def changeset(setting, attrs) do
     setting
-    |> cast(attrs, @allowed_fields)
+    |> cast(attrs, [:name, :value, :datatype])
-    |> validate_required(@required_fields)
+    |> validate_required([:name, :value, :datatype])
+    |> unique_constraint([:name])
   end
 end

lib/pinchflat/settings/settings.ex

@@ -2,80 +2,94 @@ defmodule Pinchflat.Settings do
   @moduledoc """
   The Settings context.
   """
-  import Ecto.Query, warn: false
 
+  import Ecto.Query, warn: false
   alias Pinchflat.Repo
+
   alias Pinchflat.Settings.Setting
 
   @doc """
-  Returns the only setting record. It _should_ be impossible
+  Returns the list of settings.
-  to create or delete this record, so it's assertive about
-  assuming it's the only one.
 
-  Returns %Setting{}
+  Returns [%Setting{}, ...]
   """
-  def record do
+  def list_settings do
-    Setting
+    Repo.all(Setting)
-    |> limit(1)
-    |> Repo.one()
   end
 
   @doc """
-  Updates the setting record.
+  Creates or updates a setting, returning the parsed value.
+  Raises if an unsupported datatype is used. Optionally allows
+  specifying the datatype.
 
-  Returns {:ok, %Setting{}} | {:error, %Ecto.Changeset{}}
+  Returns value in type of `Ecto.Enum.mappings(Setting, :datatype)`
   """
-  def update_setting(%Setting{} = setting, attrs) do
+  def set!(name, value) do
-    setting
+    set!(name, value, infer_datatype(value))
-    |> Setting.changeset(attrs)
-    |> Repo.update()
   end
 
-  @doc """
+  def set!(name, value, datatype) do
-  Updates a setting, returning the new value.
+    # Only create if doesn't exist
-  Is setup to take a keyword list argument so you
+    case Repo.get_by(Setting, name: to_string(name)) do
-  can call it like `Settings.set(onboarding: true)`
+      nil -> create_setting!(name, value, datatype)
-
+      setting -> update_setting!(setting, value, datatype)
-  Returns {:ok, value} | {:error, :invalid_key} | {:error, %Ecto.Changeset{}}
-  """
-  def set([{attr, value}]) do
-    record()
-    |> update_setting(%{attr => value})
-    |> case do
-      {:ok, %{^attr => _}} -> {:ok, value}
-      {:ok, _} -> {:error, :invalid_key}
-      {:error, changeset} -> {:error, changeset}
     end
   end
 
   @doc """
-  Gets the value of a setting.
+  Gets the parsed value of a setting. Raises if the setting does not exist.
 
-  Returns {:ok, value} | {:error, :invalid_key}
+  Returns value in type of `Ecto.Enum.mappings(Setting, :datatype)`
-  """
-  def get(name) do
-    case Map.fetch(record(), name) do
-      {:ok, value} -> {:ok, value}
-      :error -> {:error, :invalid_key}
-    end
-  end
-
-  @doc """
-  Gets the value of a setting, raising if it doesn't exist.
-
-  Returns value
   """
   def get!(name) do
-    case get(name) do
+    Setting
-      {:ok, value} -> value
+    |> Repo.get_by!(name: to_string(name))
-      {:error, _} -> raise "Setting `#{name}` not found"
+    |> read_setting()
-    end
   end
 
   @doc """
-  Returns `%Ecto.Changeset{}`
+  Attempts to find a setting by name or creates a setting with value
+  if one doesn't exist, returning the parsed value. Optionally allows
+  specifying the datatype.
+
+  Returns value in type of `Ecto.Enum.mappings(Setting, :datatype)`
   """
-  def change_setting(%Setting{} = setting, attrs \\ %{}) do
+  def fetch!(name, value) do
+    fetch!(name, value, infer_datatype(value))
+  end
+
+  def fetch!(name, value, datatype) do
+    case Repo.get_by(Setting, name: to_string(name)) do
+      nil -> create_setting!(name, value, datatype)
+      setting -> read_setting(setting)
+    end
+  end
+
+  defp change_setting(setting, attrs) do
     Setting.changeset(setting, attrs)
   end
+
+  defp create_setting!(name, value, datatype) do
+    %Setting{}
+    |> change_setting(%{name: to_string(name), value: to_string(value), datatype: datatype})
+    |> Repo.insert!()
+    |> read_setting()
+  end
+
+  defp update_setting!(setting, value, datatype) do
+    setting
+    |> change_setting(%{value: to_string(value), datatype: datatype})
+    |> Repo.update!()
+    |> read_setting()
+  end
+
+  defp read_setting(%{value: value, datatype: :string}), do: value
+  defp read_setting(%{value: value, datatype: :boolean}), do: value in ["true", "t", "1"]
+  defp read_setting(%{value: value, datatype: :integer}), do: String.to_integer(value)
+  defp read_setting(%{value: value, datatype: :float}), do: String.to_float(value)
+
+  defp infer_datatype(value) when is_boolean(value), do: :boolean
+  defp infer_datatype(value) when is_integer(value), do: :integer
+  defp infer_datatype(value) when is_float(value), do: :float
+  defp infer_datatype(value) when is_binary(value), do: :string
 end

lib/pinchflat/slow_indexing/media_collection_indexing_worker.ex

@@ -11,21 +11,18 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorker do
   alias __MODULE__
   alias Pinchflat.Tasks
   alias Pinchflat.Sources
-  alias Pinchflat.Settings
   alias Pinchflat.Sources.Source
   alias Pinchflat.FastIndexing.FastIndexingWorker
   alias Pinchflat.SlowIndexing.SlowIndexingHelpers
-  alias Pinchflat.Notifications.SourceNotifications
 
   @doc """
   Starts the source slow indexing worker and creates a task for the source.
 
   Returns {:ok, %Task{}} | {:error, :duplicate_job} | {:error, %Ecto.Changeset{}}
   """
-  def kickoff_with_task(source, job_args \\ %{}, job_opts \\ []) do
+  def kickoff_with_task(source, opts \\ []) do
     %{id: source.id}
-    |> Map.merge(job_args)
+    |> MediaCollectionIndexingWorker.new(opts)
-    |> MediaCollectionIndexingWorker.new(job_opts)
     |> Tasks.create_job_with_task(source)
   end
 
@@ -33,8 +30,8 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorker do
   The ID is that of a source _record_, not a YouTube channel/playlist ID. Indexes
   the provided source, kicks off downloads for each new MediaItem, and
   reschedules the job to run again in the future. It will ALWAYS index a source
-  if it's never been indexed before or if `force` is set to `true`, but rescheduling
+  if it's never been indexed before, but rescheduling is determined by the
-  is determined by the `index_frequency_minutes` field.
+  `index_frequency_minutes` field.
 
   README: Re-scheduling here works a little different than you may expect.
   The reschedule time is relative to the time the job has actually _completed_.
@@ -74,29 +71,25 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorker do
   Returns :ok | {:ok, %Task{}}
   """
   @impl Oban.Worker
-  def perform(%Oban.Job{args: %{"id" => source_id} = args}) do
+  def perform(%Oban.Job{args: %{"id" => source_id}}) do
     source = Sources.get_source!(source_id)
 
     case {source.index_frequency_minutes, source.last_indexed_at} do
       {index_freq, _} when index_freq > 0 ->
         # If the indexing is on a schedule simply run indexing and reschedule
-        perform_indexing_and_notification(source)
+        SlowIndexingHelpers.index_and_enqueue_download_for_media_items(source)
         maybe_enqueue_fast_indexing_task(source)
         reschedule_indexing(source)
 
       {_, nil} ->
         # If the source has never been indexed, index it once
         # even if it's not meant to reschedule
-        perform_indexing_and_notification(source)
+        SlowIndexingHelpers.index_and_enqueue_download_for_media_items(source)
         :ok
 
       _ ->
         # If the source HAS been indexed and is not meant to reschedule,
-        # perform a no-op (unless forced)
+        # perform a no-op
-        if args["force"] do
-          perform_indexing_and_notification(source)
-        end
-
         :ok
     end
   rescue
@@ -104,14 +97,6 @@ defmodule Pinchflat.SlowIndexing.MediaCollectionIndexingWorker do
     Ecto.StaleEntryError -> Logger.info("#{__MODULE__} discarded: source #{source_id} stale")
   end
 
-  defp perform_indexing_and_notification(source) do
-    apprise_server = Settings.get!(:apprise_server)
-
-    SourceNotifications.wrap_new_media_notification(apprise_server, source, fn ->
-      SlowIndexingHelpers.index_and_enqueue_download_for_media_items(source)
-    end)
-  end
-
   defp reschedule_indexing(source) do
     next_run_in = source.index_frequency_minutes * 60
 

lib/pinchflat/slow_indexing/slow_indexing_helpers.ex

@@ -27,12 +27,12 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
 
   Returns {:ok, %Task{}}.
   """
-  def kickoff_indexing_task(%Source{} = source, job_args \\ %{}, job_opts \\ []) do
+  def kickoff_indexing_task(%Source{} = source) do
     Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
     Tasks.delete_pending_tasks_for(source, "MediaIndexingWorker")
     Tasks.delete_pending_tasks_for(source, "MediaCollectionIndexingWorker")
 
-    MediaCollectionIndexingWorker.kickoff_with_task(source, job_args, job_opts)
+    MediaCollectionIndexingWorker.kickoff_with_task(source)
   end
 
   @doc """
@@ -60,7 +60,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
   def index_and_enqueue_download_for_media_items(%Source{} = source) do
     # 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)
+    {:ok, media_attributes} = get_media_attributes_for_collection_and_setup_file_watcher(source)
     # Reload because the source may have been updated during the (long-running) indexing process
     # and important settings like `download_media` may have changed.
     source = Repo.reload!(source)
@@ -84,15 +84,15 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
   # lines (ie: you should gracefully fail if you can't parse a line).
   #
   # This works in-tandem with the normal (blocking) media indexing behaviour. When
-  # the `setup_file_watcher_and_kickoff_indexing` method completes it'll return the
+  # the `get_media_attributes_for_collection` method completes it'll return the FULL result to
-  # FULL result to the caller for parsing. Ideally, every item in the list will have already
+  # the caller for parsing. Ideally, every item in the list will have already
   # been processed by the file follower, but if not, the caller handles creation
   # of any media items that were missed/initially failed.
   #
   # It attempts a graceful shutdown of the file follower after the indexing is done,
   # but the FileFollowerServer will also stop itself if it doesn't see any activity
   # for a sufficiently long time.
-  defp setup_file_watcher_and_kickoff_indexing(source) do
+  defp get_media_attributes_for_collection_and_setup_file_watcher(source) do
     {:ok, pid} = FileFollowerServer.start_link()
 
     handler = fn filepath -> setup_file_follower_watcher(pid, filepath, source) end

lib/pinchflat/sources/source.ex

@@ -29,7 +29,6 @@ defmodule Pinchflat.Sources.Source do
     last_indexed_at
     original_url
     download_cutoff_date
-    retention_period_days
     title_filter_regex
     media_profile_id
   )a
@@ -73,7 +72,6 @@ defmodule Pinchflat.Sources.Source do
     field :last_indexed_at, :utc_datetime
     # Only download media items that were published after this date
     field :download_cutoff_date, :date
-    field :retention_period_days, :integer
     field :original_url, :string
     field :title_filter_regex, :string
 
@@ -108,9 +106,7 @@ defmodule Pinchflat.Sources.Source do
     |> dynamic_default(:custom_name, fn cs -> get_field(cs, :collection_name) end)
     |> dynamic_default(:uuid, fn _ -> Ecto.UUID.generate() end)
     |> validate_required(required_fields)
-    |> validate_number(:retention_period_days, greater_than_or_equal_to: 0)
     |> cast_assoc(:metadata, with: &SourceMetadata.changeset/2, required: false)
-    |> unique_constraint([:collection_id, :media_profile_id, :title_filter_regex], error_key: :original_url)
   end
 
   @doc false

lib/pinchflat/sources/sources.ex

@@ -13,7 +13,7 @@ defmodule Pinchflat.Sources do
   alias Pinchflat.Profiles.MediaProfile
   alias Pinchflat.YtDlp.MediaCollection
   alias Pinchflat.Metadata.SourceMetadata
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
   alias Pinchflat.Downloading.DownloadingHelpers
   alias Pinchflat.FastIndexing.FastIndexingWorker
   alias Pinchflat.SlowIndexing.SlowIndexingHelpers
@@ -153,7 +153,7 @@ defmodule Pinchflat.Sources do
     Source.filepath_attributes()
     |> Enum.map(fn field -> mapped_struct[field] end)
     |> Enum.filter(&is_binary/1)
-    |> Enum.each(&FilesystemUtils.delete_file_and_remove_empty_directories/1)
+    |> Enum.each(&FilesystemHelpers.delete_file_and_remove_empty_directories/1)
   end
 
   defp delete_internal_metadata_files(source) do
@@ -163,7 +163,7 @@ defmodule Pinchflat.Sources do
     SourceMetadata.filepath_attributes()
     |> Enum.map(fn field -> mapped_struct[field] end)
     |> Enum.filter(&is_binary/1)
-    |> Enum.each(&FilesystemUtils.delete_file_and_remove_empty_directories/1)
+    |> Enum.each(&FilesystemHelpers.delete_file_and_remove_empty_directories/1)
   end
 
   defp add_source_details_to_changeset(source, changeset) do

lib/pinchflat/sources/sources_query.ex

@@ -1,31 +0,0 @@
-defmodule Pinchflat.Sources.SourcesQuery do
-  @moduledoc """
-  Query helpers for the Sources 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.Sources.Source
-
-  # Prefixes:
-  # - for_* - belonging to a certain record
-  # - join_* - for joining on a certain record
-  # - with_* - for filtering based on full, concrete attributes
-  # - matching_* - for filtering based on partial attributes (e.g. LIKE, regex, full-text search)
-  #
-  # Suffixes:
-  # - _for - the arg passed is an association record
-
-  def new do
-    Source
-  end
-
-  def for_media_profile(query, media_profile) do
-    where(query, [s], s.media_profile_id == ^media_profile.id)
-  end
-end

lib/pinchflat/utils/cli_utils.ex

@@ -1,48 +0,0 @@
-defmodule Pinchflat.Utils.CliUtils do
-  @moduledoc """
-  Utility methods for working with CLI executables
-  """
-
-  alias Pinchflat.Utils.StringUtils
-
-  @doc """
-  Parses a list of command options into a list of strings suitable for passing to
-  `System.cmd/3`.
-
-  We want to satisfy the following behaviours:
-    1. If the key is an atom, convert it to a string and convert it to kebab case (for convenience)
-    2. If the key is a string, assume we want it as-is and don't convert it
-    3. If the key is accompanied by a value, append the value to the list
-    4. If the key is not accompanied by a value, assume it's a flag and PREpend it to the list
-
-  Returns [binary()]
-  """
-  def parse_options(command_opts) do
-    command_opts
-    |> List.wrap()
-    |> Enum.reduce([], &parse_option/2)
-  end
-
-  defp parse_option({k, v}, acc) when is_atom(k) do
-    stringified_key = StringUtils.to_kebab_case(Atom.to_string(k))
-
-    parse_option({"--#{stringified_key}", v}, acc)
-  end
-
-  defp parse_option({k, v}, acc) when is_binary(k) do
-    acc ++ [k, to_string(v)]
-  end
-
-  defp parse_option(arg, acc) when is_atom(arg) do
-    stringified_arg =
-      arg
-      |> Atom.to_string()
-      |> StringUtils.to_kebab_case()
-
-    parse_option("--#{stringified_arg}", acc)
-  end
-
-  defp parse_option(arg, acc) when is_binary(arg) do
-    acc ++ [arg]
-  end
-end

lib/pinchflat/utils/xml_utils.ex

@@ -1,17 +0,0 @@
-defmodule Pinchflat.Utils.XmlUtils do
-  @moduledoc """
-  Utility methods for working with XML documents
-  """
-
-  @doc """
-  Escapes invalid XML characters in a string
-
-  Returns binary()
-  """
-  def safe(value) do
-    value
-    |> to_string()
-    |> Phoenix.HTML.html_escape()
-    |> Phoenix.HTML.safe_to_string()
-  end
-end

lib/pinchflat/yt_dlp/backend_command_runner.ex

@@ -1,4 +1,4 @@
-defmodule Pinchflat.YtDlp.YtDlpCommandRunner do
+defmodule Pinchflat.YtDlp.BackendCommandRunner do
   @moduledoc """
   A behaviour for running CLI commands against a downloader backend (yt-dlp).
 
@@ -8,5 +8,4 @@ defmodule Pinchflat.YtDlp.YtDlpCommandRunner do
 
   @callback run(binary(), keyword(), binary()) :: {:ok, binary()} | {:error, binary(), integer()}
   @callback run(binary(), keyword(), binary(), keyword()) :: {:ok, binary()} | {:error, binary(), integer()}
-  @callback version() :: {:ok, binary()} | {:error, binary()}
 end

lib/pinchflat/yt_dlp/command_runner.ex

@@ -5,11 +5,11 @@ defmodule Pinchflat.YtDlp.CommandRunner do
 
   require Logger
 
-  alias Pinchflat.Utils.CliUtils
+  alias Pinchflat.Utils.StringUtils
-  alias Pinchflat.YtDlp.YtDlpCommandRunner
+  alias Pinchflat.Filesystem.FilesystemHelpers, as: FSUtils
-  alias Pinchflat.Utils.FilesystemUtils, as: FSUtils
+  alias Pinchflat.YtDlp.BackendCommandRunner
 
-  @behaviour YtDlpCommandRunner
+  @behaviour BackendCommandRunner
 
   @doc """
   Runs a yt-dlp command and returns the string output. Saves the output to
@@ -23,18 +23,17 @@ defmodule Pinchflat.YtDlp.CommandRunner do
 
   Returns {:ok, binary()} | {:error, output, status}.
   """
-  @impl YtDlpCommandRunner
+  @impl BackendCommandRunner
   def run(url, command_opts, output_template, addl_opts \\ []) do
     # This approach lets us mock the command for testing
     command = backend_executable()
-
-    output_filepath = generate_output_filepath(addl_opts)
-    print_to_file_opts = [{:print_to_file, output_template}, output_filepath]
-    external_file_opts = build_external_file_options()
     # These must stay in exactly this order, hence why I'm giving it its own variable.
-    all_opts = command_opts ++ print_to_file_opts ++ external_file_opts
+    # Also, can't use RAM file since yt-dlp needs a concrete filepath.
+    output_filepath = Keyword.get(addl_opts, :output_filepath, FSUtils.generate_metadata_tmpfile(:json))
+    print_to_file_opts = [{:print_to_file, output_template}, output_filepath]
+    cookie_opts = build_cookie_options()
+    formatted_command_opts = [url] ++ parse_options(command_opts ++ print_to_file_opts ++ cookie_opts)
 
-    formatted_command_opts = [url] ++ CliUtils.parse_options(all_opts)
     Logger.info("[yt-dlp] called with: #{Enum.join(formatted_command_opts, " ")}")
 
     case System.cmd(command, formatted_command_opts, stderr_to_stdout: true) do
@@ -49,50 +48,47 @@ defmodule Pinchflat.YtDlp.CommandRunner do
     end
   end
 
-  @doc """
+  defp build_cookie_options do
-  Returns the version of yt-dlp as a string
-
-  Returns {:ok, binary()} | {:error, binary()}
-  """
-  @impl YtDlpCommandRunner
-  def version do
-    command = backend_executable()
-
-    case System.cmd(command, ["--version"]) do
-      {output, 0} ->
-        {:ok, String.trim(output)}
-
-      {output, _} ->
-        {:error, output}
-    end
-  end
-
-  defp generate_output_filepath(addl_opts) do
-    case Keyword.get(addl_opts, :output_filepath) do
-      nil -> FSUtils.generate_metadata_tmpfile(:json)
-      path -> path
-    end
-  end
-
-  defp build_external_file_options do
     base_dir = Application.get_env(:pinchflat, :extras_directory)
-    filename_options_map = %{cookies: "cookies.txt"}
+    cookie_file = Path.join(base_dir, "cookies.txt")
 
-    Enum.reduce(filename_options_map, [], fn {opt_name, filename}, acc ->
+    case File.read(cookie_file) do
-      filepath = Path.join(base_dir, filename)
+      {:ok, cookie_data} ->
+        if String.trim(cookie_data) != "", do: [cookies: cookie_file], else: []
 
-      case File.read(filepath) do
+      {:error, _} ->
-        {:ok, file_data} ->
+        []
-          if String.trim(file_data) != "" do
+    end
-            [{opt_name, filepath} | acc]
+  end
-          else
-            acc
-          end
 
-        {:error, _} ->
+  # We want to satisfy the following behaviours:
-          acc
+  #
-      end
+  # 1. If the key is an atom, convert it to a string and convert it to kebab case (for convenience)
-    end)
+  # 2. If the key is a string, assume we want it as-is and don't convert it
+  # 3. If the key is accompanied by a value, append the value to the list
+  # 4. If the key is not accompanied by a value, assume it's a flag and PREpend it to the list
+  defp parse_options(command_opts) do
+    Enum.reduce(command_opts, [], &parse_option/2)
+  end
+
+  defp parse_option({k, v}, acc) when is_atom(k) do
+    stringified_key = StringUtils.to_kebab_case(Atom.to_string(k))
+
+    parse_option({"--#{stringified_key}", v}, acc)
+  end
+
+  defp parse_option({k, v}, acc) when is_binary(k) do
+    acc ++ [k, to_string(v)]
+  end
+
+  defp parse_option(arg, acc) when is_atom(arg) do
+    stringified_arg = StringUtils.to_kebab_case(Atom.to_string(arg))
+
+    parse_option("--#{stringified_arg}", acc)
+  end
+
+  defp parse_option(arg, acc) when is_binary(arg) do
+    acc ++ [arg]
   end
 
   defp backend_executable do

lib/pinchflat/yt_dlp/media.ex

@@ -35,10 +35,10 @@ defmodule Pinchflat.YtDlp.Media do
 
   Returns {:ok, map()} | {:error, any, ...}.
   """
-  def download(url, command_opts \\ [], addl_opts \\ []) do
+  def download(url, command_opts \\ []) do
     opts = [:no_simulate] ++ command_opts
 
-    with {:ok, output} <- backend_runner().run(url, opts, "after_move:%()j", addl_opts),
+    with {:ok, output} <- backend_runner().run(url, opts, "after_move:%()j"),
          {:ok, parsed_json} <- Phoenix.json_library().decode(output) do
       {:ok, parsed_json}
     else

lib/pinchflat/yt_dlp/media_collection.ex

@@ -6,7 +6,7 @@ defmodule Pinchflat.YtDlp.MediaCollection do
 
   require Logger
 
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
   alias Pinchflat.YtDlp.Media, as: YtDlpMedia
 
   @doc """
@@ -26,7 +26,7 @@ defmodule Pinchflat.YtDlp.MediaCollection do
     # available formats since we're just getting the media details
     command_opts = [:simulate, :skip_download, :ignore_no_formats_error]
     output_template = YtDlpMedia.indexing_output_template()
-    output_filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
+    output_filepath = FilesystemHelpers.generate_metadata_tmpfile(:json)
     file_listener_handler = Keyword.get(addl_opts, :file_listener_handler, false)
 
     if file_listener_handler do

lib/pinchflat_web/components/core_components.ex

@@ -247,7 +247,6 @@ defmodule PinchflatWeb.CoreComponents do
   attr :label_suffix, :string, default: nil
   attr :value, :any
   attr :help, :string, default: nil
-  attr :html_help, :boolean, default: false
 
   attr :type, :string,
     default: "text",
@@ -299,7 +298,7 @@ defmodule PinchflatWeb.CoreComponents do
         <%= @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>
+      <.help :if={@help}><%= @help %></.help>
       <.error :for={msg <- @errors}><%= msg %></.error>
     </div>
     """
@@ -326,7 +325,7 @@ defmodule PinchflatWeb.CoreComponents do
           </label>
         </div>
       </section>
-      <.help :if={@help}><%= if @html_help, do: Phoenix.HTML.raw(@help), else: @help %></.help>
+      <.help :if={@help}><%= @help %></.help>
       <.error :for={msg <- @errors}><%= msg %></.error>
     </div>
     """
@@ -357,7 +356,7 @@ defmodule PinchflatWeb.CoreComponents do
           >
           </div>
         </div>
-        <.help :if={@help}><%= if @html_help, do: Phoenix.HTML.raw(@help), else: @help %></.help>
+        <.help :if={@help}><%= @help %></.help>
         <.error :for={msg <- @errors}><%= msg %></.error>
       </div>
     </div>
@@ -388,7 +387,7 @@ defmodule PinchflatWeb.CoreComponents do
         </select>
         <%= render_slot(@inner_block) %>
       </div>
-      <.help :if={@help}><%= if @html_help, do: Phoenix.HTML.raw(@help), else: @help %></.help>
+      <.help :if={@help}><%= @help %></.help>
       <.error :for={msg <- @errors}><%= msg %></.error>
     </div>
     """
@@ -412,7 +411,7 @@ 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>
+      <.help :if={@help}><%= @help %></.help>
       <.error :for={msg <- @errors}><%= msg %></.error>
     </div>
     """
@@ -439,7 +438,7 @@ defmodule PinchflatWeb.CoreComponents do
         ]}
         {@rest}
       />
-      <.help :if={@help}><%= if @html_help, do: Phoenix.HTML.raw(@help), else: @help %></.help>
+      <.help :if={@help}><%= @help %></.help>
       <.error :for={msg <- @errors}><%= msg %></.error>
     </div>
     """

lib/pinchflat_web/components/custom_components/tab_components.ex

@@ -14,8 +14,7 @@ defmodule PinchflatWeb.CustomComponents.TabComponents do
   def tabbed_layout(assigns) do
     ~H"""
     <div
-      x-data="{ openTab: getTabIndex(0), activeClasses: 'text-meta-5 border-meta-5', inactiveClasses: 'border-transparent' }"
+      x-data="{ openTab: 0, activeClasses: 'text-meta-5 border-meta-5', inactiveClasses: 'border-transparent' }"
-      @hashchange.window="openTab = getTabIndex(openTab)"
       class="w-full"
     >
       <header class="flex flex-col md:flex-row md:justify-between border-b border-strokedark">
@@ -23,7 +22,7 @@ defmodule PinchflatWeb.CustomComponents.TabComponents do
           <a
             :for={{tab, idx} <- Enum.with_index(@tab)}
             href="#"
-            @click.prevent={"openTab = setTabIndex(#{idx})"}
+            @click.prevent={"openTab = #{idx}"}
             x-bind:class={"openTab === #{idx} ? activeClasses : inactiveClasses"}
             class="border-b-2 py-4 w-full sm:w-fit text-sm font-medium hover:text-meta-5 md:text-base"
           >
@@ -34,7 +33,7 @@ defmodule PinchflatWeb.CustomComponents.TabComponents do
           <%= render_slot(@tab_append) %>
         </div>
       </header>
-      <div class="mt-4 min-h-60">
+      <div class="mt-4">
         <div :for={{tab, idx} <- Enum.with_index(@tab)} x-show={"openTab === #{idx}"} class="font-medium leading-relaxed">
           <%= render_slot(tab) %>
         </div>

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

@@ -24,7 +24,6 @@
             <.sidebar_item icon="hero-home" text="Home" href={~p"/"} />
             <.sidebar_item icon="hero-tv" text="Sources" href={~p"/sources"} />
             <.sidebar_item icon="hero-adjustments-vertical" text="Media Profiles" href={~p"/media_profiles"} />
-            <.sidebar_item icon="hero-cog-6-tooth" text="Settings" href={~p"/settings"} />
           </ul>
         </div>
       </nav>
@@ -39,7 +38,12 @@
           target="_blank"
           href="https://github.com/kieraneglin/pinchflat/wiki"
         />
-        <.sidebar_item icon="hero-cog" text="Github" target="_blank" href="https://github.com/kieraneglin/pinchflat" />
+        <.sidebar_item
+          icon="hero-code-bracket"
+          text="Github"
+          target="_blank"
+          href="https://github.com/kieraneglin/pinchflat"
+        />
         <li>
           <span
             class={[
@@ -54,11 +58,8 @@
           </span>
         </li>
         <li>
-          <span class="group relative flex items-center gap-2.5 px-4 pt-2 text-sm">
+          <span class="group relative flex items-center gap-2.5 px-4 py-2 text-sm">
-            Pinchflat v<%= Application.spec(:pinchflat)[:vsn] %>
+            v<%= Application.spec(:pinchflat)[:vsn] %>
-          </span>
-          <span class="group relative flex items-center gap-2.5 px-4 text-sm">
-            yt-dlp <%= Settings.get!(:yt_dlp_version) %>
           </span>
         </li>
       </ul>

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

@@ -30,7 +30,7 @@ defmodule Pinchflat.UpgradeButtonLive do
       |> String.downcase()
 
     if normalized_text == "got it!" do
-      Settings.set(pro_enabled: true)
+      Settings.set!(:pro_enabled, true)
 
       {:noreply, update(socket, :button_disabled, fn _ -> false end)}
     else

lib/pinchflat_web/controllers/health_controller.ex

@@ -1,9 +0,0 @@
-defmodule PinchflatWeb.HealthController do
-  use PinchflatWeb, :controller
-
-  def check(conn, _params) do
-    conn
-    |> put_status(:ok)
-    |> json(%{status: "ok"})
-  end
-end

lib/pinchflat_web/controllers/media_items/media_item_controller.ex

@@ -6,7 +6,6 @@ defmodule PinchflatWeb.MediaItems.MediaItemController do
   alias Pinchflat.Repo
   alias Pinchflat.Media
   alias Pinchflat.Media.MediaItem
-  alias Pinchflat.Downloading.MediaDownloadWorker
 
   def show(conn, %{"id" => id}) do
     media_item =
@@ -17,46 +16,23 @@ defmodule PinchflatWeb.MediaItems.MediaItemController do
     render(conn, :show, media_item: media_item)
   end
 
-  def edit(conn, %{"id" => id}) do
-    media_item = Media.get_media_item!(id)
-    changeset = Media.change_media_item(media_item)
-
-    render(conn, :edit, media_item: media_item, changeset: changeset)
-  end
-
-  def update(conn, %{"id" => id, "media_item" => params}) do
-    media_item = Media.get_media_item!(id)
-
-    case Media.update_media_item(media_item, params) do
-      {:ok, media_item} ->
-        conn
-        |> put_flash(:info, "Media Item updated successfully.")
-        |> redirect(to: ~p"/sources/#{media_item.source_id}/media/#{media_item}")
-
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, :edit, media_item: media_item, changeset: changeset)
-    end
-  end
-
   def delete(conn, %{"id" => id} = params) do
-    prevent_download = Map.get(params, "prevent_download", false)
+    delete_files = Map.get(params, "delete_files", false)
     media_item = Media.get_media_item!(id)
-    {:ok, _} = Media.delete_media_files(media_item, %{prevent_download: prevent_download})
+    {:ok, _} = Media.delete_media_item(media_item, delete_files: delete_files)
+
+    flash_message =
+      if delete_files do
+        "Record and files deleted successfully."
+      else
+        "Record deleted successfully. Files were not deleted."
+      end
 
     conn
-    |> put_flash(:info, "Files deleted successfully.")
+    |> put_flash(:info, flash_message)
     |> redirect(to: ~p"/sources/#{media_item.source_id}")
   end
 
-  def force_download(conn, %{"media_item_id" => id}) do
-    media_item = Media.get_media_item!(id)
-    {:ok, _} = MediaDownloadWorker.kickoff_with_task(media_item, %{force: true})
-
-    conn
-    |> put_flash(:info, "Download task enqueued.")
-    |> redirect(to: ~p"/sources/#{media_item.source_id}/media/#{media_item}")
-  end
-
   # See here for details on streaming files and range requests:
   # https://www.zeng.dev/post/2023-http-range-and-play-mp4-in-browser/
   #

lib/pinchflat_web/controllers/media_items/media_item_html.ex

@@ -3,14 +3,6 @@ defmodule PinchflatWeb.MediaItems.MediaItemHTML do
 
   embed_templates "media_item_html/*"
 
-  @doc """
-  Renders a media item form.
-  """
-  attr :changeset, Ecto.Changeset, required: true
-  attr :action, :string, required: true
-
-  def media_item_form(assigns)
-
   def media_file_exists?(media_item) do
     !!media_item.media_filepath and File.exists?(media_item.media_filepath)
   end

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

@@ -1,32 +0,0 @@
-<.button_dropdown text="Actions" class="justify-center w-full sm:w-50">
-  <:option>
-    <.link
-      href={~p"/sources/#{@media_item.source_id}/media/#{@media_item}/force_download"}
-      method="post"
-      data-confirm="Are you sure you force a download of this media?"
-    >
-      Force Download
-    </.link>
-  </:option>
-  <:option>
-    <div class="h-px w-full bg-bodydark2"></div>
-  </:option>
-  <:option>
-    <.link
-      href={~p"/sources/#{@media_item.source_id}/media/#{@media_item}"}
-      method="delete"
-      data-confirm="Are you sure you want to delete all files for this media item? This cannot be undone."
-    >
-      Delete Files
-    </.link>
-  </:option>
-  <:option>
-    <.link
-      href={~p"/sources/#{@media_item.source_id}/media/#{@media_item}?prevent_download=true"}
-      method="delete"
-      data-confirm="Are you sure you want to delete all files for this media item and prevent it from re-downloading in the future? This cannot be undone."
-    >
-      Delete and Ignore
-    </.link>
-  </:option>
-</.button_dropdown>

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

@@ -1,13 +0,0 @@
-<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>
-</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 overflow-x-auto">
-    <div class="flex flex-col gap-10">
-      <.media_item_form changeset={@changeset} action={~p"/sources/#{@media_item.source_id}/media/#{@media_item}"} />
-    </div>
-  </div>
-</div>

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

@@ -1,31 +0,0 @@
-<.simple_form
-  :let={f}
-  for={@changeset}
-  action={@action}
-  x-data="{ advancedMode: !!JSON.parse(localStorage.getItem('advancedMode')) }"
-  x-init="$watch('advancedMode', value => localStorage.setItem('advancedMode', JSON.stringify(value)))"
->
-  <.error :if={@changeset.action}>
-    Oops, something went wrong! Please check the errors below.
-  </.error>
-
-  <h3 class=" text-2xl text-black dark:text-white">
-    General Options
-  </h3>
-
-  <.input
-    field={f[:prevent_download]}
-    type="toggle"
-    label="Prevent Download"
-    help="Checking excludes this media item from automatic download. Download can still be manually forced"
-  />
-
-  <.input
-    field={f[:prevent_culling]}
-    type="toggle"
-    label="Prevent Automatic Deletion"
-    help="Checking excludes media from being automatically deleted based on media retention rules"
-  />
-
-  <.button class="my-10 sm:mb-7.5 w-full sm:w-auto" rounding="rounded-lg">Save Media Item</.button>
-</.simple_form>

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

@@ -4,23 +4,25 @@
       <.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) %>
+      Media Item #<%= @media_item.id %>
     </h2>
   </div>
-
-  <nav>
-    <.link href={~p"/sources/#{@media_item.source_id}/media/#{@media_item}/edit"}>
-      <.button color="bg-primary" rounding="rounded-lg">
-        <.icon name="hero-pencil-square" class="mr-2" /> Edit
-      </.button>
-    </.link>
-  </nav>
 </div>
 <div class="rounded-sm border border-stroke bg-white py-5 pt-6 shadow-default dark:border-strokedark dark:bg-boxdark px-7.5">
   <div class="max-w-full overflow-x-auto">
     <.tabbed_layout>
       <:tab_append>
-        <.actions_dropdown media_item={@media_item} />
+        <.button_dropdown text="Actions" class="justify-center w-full sm:w-50">
+          <:option>
+            <.link
+              href={~p"/sources/#{@media_item.source_id}/media/#{@media_item}?delete_files=true"}
+              method="delete"
+              data-confirm="Are you sure you want to delete this record and all associated files on disk? This cannot be undone."
+            >
+              Delete Files
+            </.link>
+          </:option>
+        </.button_dropdown>
       </:tab_append>
 
       <:tab title="Attributes">
@@ -30,13 +32,12 @@
             <.media_preview media_item={@media_item} />
           <% end %>
 
-          <h2 class="font-bold text-2xl"><%= @media_item.title %></h2>
           <h3 class="font-bold text-xl">Attributes</h3>
           <section>
             <strong>Source:</strong>
-            <.subtle_link href={~p"/sources/#{@media_item.source_id}"}>
+            <.inline_link href={~p"/sources/#{@media_item.source_id}"}>
               <%= @media_item.source.custom_name %>
-            </.subtle_link>
+            </.inline_link>
           </section>
 
           <.list_items_from_map map={Map.from_struct(@media_item)} />

lib/pinchflat_web/controllers/media_profiles/media_profile_controller.ex

@@ -1,19 +1,12 @@
 defmodule PinchflatWeb.MediaProfiles.MediaProfileController do
   use PinchflatWeb, :controller
 
-  import Ecto.Query, warn: false
-
   alias Pinchflat.Repo
   alias Pinchflat.Profiles
-  alias Pinchflat.Sources.SourcesQuery
   alias Pinchflat.Profiles.MediaProfile
 
   def index(conn, _params) do
-    media_profiles =
+    media_profiles = Profiles.list_media_profiles()
-      MediaProfile
-      |> order_by(asc: :name)
-      |> Repo.all()
-
     render(conn, :index, media_profiles: media_profiles)
   end
 
@@ -39,15 +32,12 @@ defmodule PinchflatWeb.MediaProfiles.MediaProfileController do
   end
 
   def show(conn, %{"id" => id}) do
-    media_profile = Profiles.get_media_profile!(id)
+    media_profile =
+      id
+      |> Profiles.get_media_profile!()
+      |> Repo.preload(:sources)
 
-    sources =
+    render(conn, :show, media_profile: media_profile)
-      SourcesQuery.new()
-      |> SourcesQuery.for_media_profile(media_profile)
-      |> order_by(asc: :custom_name)
-      |> Repo.all()
-
-    render(conn, :show, media_profile: media_profile, sources: sources)
   end
 
   def edit(conn, %{"id" => id}) do

lib/pinchflat_web/controllers/media_profiles/media_profile_html.ex

@@ -59,9 +59,6 @@ defmodule PinchflatWeb.MediaProfiles.MediaProfileHTML do
       upload_year: nil,
       upload_yyyy_mm_dd: "the upload date in the format YYYY-MM-DD",
       source_custom_name: "the name of the sources that use this profile",
-      source_collection_id: "the YouTube ID of the sources that use this profile",
-      source_collection_name:
-        "the YouTube name of the sources that use this profile (often the same as source_custom_name)",
       source_collection_type: "the collection type of the sources using this profile. Either 'channel' or 'playlist'",
       artist_name: "the name of the artist with fallbacks to other uploader fields"
     }

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

@@ -203,17 +203,6 @@
       />
     </section>
 
-    <section x-data="{ presets: { default: null, media_center: 1, audio: null, archiving: 1 } }">
-      <.input
-        field={f[:redownload_delay_days]}
-        type="number"
-        label="Redownload Delay (days)"
-        min="0"
-        help="Delay in days until new media is redownloaded. Redownloading new media can improve its quality or SponsorBlock tags. Leave blank to not redownload"
-        x-init="$watch('selectedPreset', p => p && ($el.value = presets[p]))"
-      />
-    </section>
-
     <h3 class="mt-8 text-2xl text-black dark:text-white">
       Media Center Options
     </h3>

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

@@ -50,11 +50,9 @@
         </div>
       </:tab>
       <:tab title="Sources">
-        <.table rows={@sources} table_class="text-black dark:text-white">
+        <.table rows={@media_profile.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="Should Download?">

lib/pinchflat_web/controllers/pages/page_controller.ex

@@ -11,7 +11,7 @@ defmodule PinchflatWeb.Pages.PageController do
     done_onboarding = params["onboarding"] == "0"
     force_onboarding = params["onboarding"] == "1"
 
-    if done_onboarding, do: Settings.set(onboarding: false)
+    if done_onboarding, do: Settings.set!(:onboarding, false)
 
     if force_onboarding || Settings.get!(:onboarding) do
       render_onboarding_page(conn)
@@ -30,7 +30,7 @@ defmodule PinchflatWeb.Pages.PageController do
   end
 
   defp render_onboarding_page(conn) do
-    Settings.set(onboarding: true)
+    Settings.set!(:onboarding, true)
 
     conn
     |> render(:onboarding_checklist,

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

@@ -1,27 +1,27 @@
 <div class="grid grid-cols-1 gap-4 md:grid-cols-3">
   <div class="rounded-sm border px-7.5 py-6 shadow-default border-strokedark bg-boxdark">
-    <a href={~p"/media_profiles"} class="mt-4 flex flex-col items-center justify-center">
+    <div class="mt-4 flex flex-col items-center justify-center">
       <span class="text-md font-medium">Media Profile(s)</span>
       <h4 class="text-title-md font-bold text-white">
         <%= @media_profile_count %>
       </h4>
-    </a>
+    </div>
   </div>
   <div class="rounded-sm border px-7.5 py-6 shadow-default border-strokedark bg-boxdark">
-    <a href={~p"/sources"} class="mt-4 flex flex-col items-center justify-center">
+    <div class="mt-4 flex flex-col items-center justify-center">
       <span class="text-md font-medium">Source(s)</span>
       <h4 class="text-title-md font-bold text-white">
         <%= @source_count %>
       </h4>
-    </a>
+    </div>
   </div>
   <div class="rounded-sm border px-7.5 py-6 shadow-default border-strokedark bg-boxdark">
-    <a href="#" class="mt-4 flex flex-col items-center justify-center">
+    <div class="mt-4 flex flex-col items-center justify-center">
       <span class="text-md font-medium">Media Item(s)</span>
       <h4 class="text-title-md font-bold text-white">
         <%= @media_item_count %>
       </h4>
-    </a>
+    </div>
   </div>
   <span class="text-strokedark">I know this page isn't super useful yet, but give it time :&rpar;</span>
 </div>

lib/pinchflat_web/controllers/podcasts/podcast_controller.ex

@@ -2,7 +2,7 @@ defmodule PinchflatWeb.Podcasts.PodcastController do
   use PinchflatWeb, :controller
 
   alias Pinchflat.Repo
-  alias Pinchflat.Media.MediaQuery
+  alias Pinchflat.Media
   alias Pinchflat.Sources.Source
   alias Pinchflat.Podcasts.RssFeedBuilder
   alias Pinchflat.Podcasts.PodcastHelpers
@@ -20,15 +20,10 @@ defmodule PinchflatWeb.Podcasts.PodcastController do
 
   def feed_image(conn, %{"uuid" => uuid}) do
     source = Repo.get_by!(Source, uuid: uuid)
-
+    # This provides a fallback image if the source has none.
-    # This is used to fetch a fallback cover image
+    # We only need one since we're using the internal metadata image which
-    # if the source doesn't have any usable images
+    # we know exists.
-    media_items =
+    media_items = Media.list_downloaded_media_items_for(source, limit: 1)
-      MediaQuery.new()
-      |> MediaQuery.for_source(source)
-      |> MediaQuery.with_media_filepath()
-      |> Repo.maybe_limit(1)
-      |> Repo.all()
 
     case PodcastHelpers.select_cover_image(source, media_items) do
       {:error, _} ->

lib/pinchflat_web/controllers/settings/setting_controller.ex

@@ -1,26 +0,0 @@
-defmodule PinchflatWeb.Settings.SettingController do
-  use PinchflatWeb, :controller
-
-  alias Pinchflat.Settings
-
-  def show(conn, _params) do
-    setting = Settings.record()
-    changeset = Settings.change_setting(setting)
-
-    render(conn, "show.html", changeset: changeset)
-  end
-
-  def update(conn, %{"setting" => setting_params}) do
-    setting = Settings.record()
-
-    case Settings.update_setting(setting, setting_params) do
-      {:ok, _} ->
-        conn
-        |> put_flash(:info, "Settings updated successfully.")
-        |> redirect(to: ~p"/settings")
-
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "show.html", changeset: changeset)
-    end
-  end
-end

lib/pinchflat_web/controllers/settings/setting_html.ex

@@ -1,20 +0,0 @@
-defmodule PinchflatWeb.Settings.SettingHTML do
-  use PinchflatWeb, :html
-
-  embed_templates "setting_html/*"
-
-  @doc """
-  Renders a setting form.
-  """
-  attr :changeset, Ecto.Changeset, required: true
-  attr :action, :string, required: true
-
-  def setting_form(assigns)
-
-  def apprise_server_help do
-    url = "https://github.com/caronc/apprise/wiki/URLBasics"
-    classes = "underline decoration-bodydark decoration-1 hover:decoration-white"
-
-    ~s(Server endpoint for Apprise notifications when new media is found. See <a href="#{url}" class="#{classes}" target="_blank">Apprise docs</a> for more information)
-  end
-end

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

@@ -1,21 +0,0 @@
-<.simple_form :let={f} for={@changeset} action={@action}>
-  <.error :if={@changeset.action}>
-    Oops, something went wrong! Please check the errors below.
-  </.error>
-
-  <h3 class="mt-8 text-2xl text-black dark:text-white">
-    Notification Settings
-  </h3>
-
-  <.input
-    field={f[:apprise_server]}
-    type="text"
-    label="Apprise Server"
-    help={apprise_server_help()}
-    html_help={true}
-    inputclass="font-mono text-sm"
-    placeholder="https://discordapp.com/api/webhooks/{WebhookID}/{WebhookToken}"
-  />
-
-  <.button class="my-10 sm:mb-7.5 w-full sm:w-auto" rounding="rounded-lg">Save Settings</.button>
-</.simple_form>

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

@@ -1,12 +0,0 @@
-<div class="mb-6 flex gap-3 flex-row items-center justify-between">
-  <div class="flex gap-3 items-center">
-    <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4">
-      Settings
-    </h2>
-  </div>
-</div>
-<div class="rounded-sm border border-stroke bg-white px-5 py-5 shadow-default dark:border-strokedark dark:bg-boxdark sm:px-7.5">
-  <div class="max-w-full overflow-x-auto">
-    <.setting_form changeset={@changeset} action={~p"/settings"} />
-  </div>
-</div>

lib/pinchflat_web/controllers/sources/source_controller.ex

@@ -4,21 +4,15 @@ defmodule PinchflatWeb.Sources.SourceController do
   import Ecto.Query, warn: false
 
   alias Pinchflat.Repo
+  alias Pinchflat.Media
   alias Pinchflat.Tasks
   alias Pinchflat.Sources
-  alias Pinchflat.MediaQuery
+  alias Pinchflat.Profiles
   alias Pinchflat.Sources.Source
   alias Pinchflat.Media.MediaQuery
-  alias Pinchflat.Profiles.MediaProfile
-  alias Pinchflat.Downloading.DownloadingHelpers
-  alias Pinchflat.SlowIndexing.SlowIndexingHelpers
 
   def index(conn, _params) do
-    sources =
+    sources = Repo.preload(Sources.list_sources(), :media_profile)
-      Source
-      |> order_by(asc: :custom_name)
-      |> Repo.all()
-      |> Repo.preload(:media_profile)
 
     render(conn, :index, sources: sources)
   end
@@ -55,26 +49,9 @@ defmodule PinchflatWeb.Sources.SourceController do
   def show(conn, %{"id" => id}) do
     source = Repo.preload(Sources.get_source!(id), :media_profile)
 
-    pending_tasks =
+    pending_tasks = Repo.preload(Tasks.list_pending_tasks_for(source), :job)
-      source
+    pending_media = Media.list_pending_media_items_for(source, limit: 100)
-      |> Tasks.list_tasks_for(nil, [:executing, :available, :scheduled, :retryable])
+    downloaded_media = Media.list_downloaded_media_items_for(source, limit: 100)
-      |> Repo.preload(:job)
-
-    pending_media =
-      MediaQuery.new()
-      |> MediaQuery.for_source(source)
-      |> MediaQuery.where_pending_download()
-      |> order_by(desc: :id)
-      |> limit(100)
-      |> Repo.all()
-
-    downloaded_media =
-      MediaQuery.new()
-      |> MediaQuery.for_source(source)
-      |> MediaQuery.with_media_filepath()
-      |> order_by(desc: :id)
-      |> limit(100)
-      |> Repo.all()
 
     render(conn, :show,
       source: source,
@@ -127,30 +104,12 @@ defmodule PinchflatWeb.Sources.SourceController do
     |> redirect(to: ~p"/sources")
   end
 
-  def force_download(conn, %{"source_id" => id}) do
-    source = Sources.get_source!(id)
-    DownloadingHelpers.enqueue_pending_download_tasks(source)
-
-    conn
-    |> put_flash(:info, "Forced download of pending media items.")
-    |> redirect(to: ~p"/sources/#{source}")
-  end
-
-  def force_index(conn, %{"source_id" => id}) do
-    source = Sources.get_source!(id)
-    SlowIndexingHelpers.kickoff_indexing_task(source, %{force: true})
-
-    conn
-    |> put_flash(:info, "Index enqueued.")
-    |> redirect(to: ~p"/sources/#{source}")
-  end
-
   defp media_profiles do
-    MediaProfile
+    Profiles.list_media_profiles()
-    |> order_by(asc: :name)
-    |> Repo.all()
   end
 
+  # NOTE: should move this out of the controller
+  # once I finally add some query fragment layer
   defp total_downloaded_for(source) do
     MediaQuery.new()
     |> MediaQuery.for_source(source)

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

@@ -1,55 +0,0 @@
-<.button_dropdown text="Actions" class="justify-center w-full sm:w-50">
-  <:option>
-    <span
-      x-data="{ copied: false }"
-      x-on:click={"
-                window.copyTextToClipboard('#{rss_feed_url(@conn, @source)}')
-                copied = true
-                setTimeout(() => copied = false, 4000)
-              "}
-    >
-      Copy RSS Feed
-      <span x-show="copied" x-transition.duration.150ms><.icon name="hero-check" class="ml-2 h-4 w-4" /></span>
-    </span>
-  </:option>
-  <:option :if={@source.download_media}>
-    <.link
-      href={~p"/sources/#{@source}/force_download"}
-      method="post"
-      data-confirm="Are you sure you want to force a download of all *pending* media items? This isn't normally needed."
-    >
-      Force Download
-    </.link>
-  </:option>
-  <:option>
-    <.link
-      href={~p"/sources/#{@source}/force_index"}
-      method="post"
-      data-confirm="Are you sure you want to force an index of this source? This isn't normally needed."
-    >
-      Force Index
-    </.link>
-  </:option>
-  <:option>
-    <div class="h-px w-full bg-bodydark2"></div>
-  </:option>
-  <:option>
-    <.link
-      href={~p"/sources/#{@source}"}
-      method="delete"
-      data-confirm="Are you sure you want to delete this source (leaving files in place)? This cannot be undone."
-    >
-      Delete Source
-    </.link>
-  </:option>
-  <:option>
-    <.link
-      href={~p"/sources/#{@source}?delete_files=true"}
-      method="delete"
-      data-confirm="Are you sure you want to delete this source and it's files on disk? This cannot be undone."
-      class="mt-5 md:mt-0"
-    >
-      Delete Source + Files
-    </.link>
-  </:option>
-</.button_dropdown>

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

@@ -22,13 +22,6 @@
         <:col :let={source} label="Should Download?">
           <.icon name={if source.download_media, do: "hero-check", else: "hero-x-mark"} />
         </:col>
-        <:col :let={source} label="Retention">
-          <%= if source.retention_period_days && source.retention_period_days > 0 do %>
-            <%= source.retention_period_days %> day(s)
-          <% 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 %>

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

@@ -20,7 +20,43 @@
   <div class="max-w-full overflow-x-auto">
     <.tabbed_layout>
       <:tab_append>
-        <.actions_dropdown source={@source} conn={@conn} />
+        <.button_dropdown text="Actions" class="justify-center w-full sm:w-50">
+          <:option>
+            <span
+              x-data="{ copied: false }"
+              x-on:click={"
+                window.copyTextToClipboard('#{rss_feed_url(@conn, @source)}')
+                copied = true
+                setTimeout(() => copied = false, 4000)
+              "}
+            >
+              Copy RSS Feed
+              <span x-show="copied" x-transition.duration.150ms><.icon name="hero-check" class="ml-2 h-4 w-4" /></span>
+            </span>
+          </:option>
+          <:option>
+            <div class="h-px w-full bg-bodydark2"></div>
+          </:option>
+          <:option>
+            <.link
+              href={~p"/sources/#{@source}"}
+              method="delete"
+              data-confirm="Are you sure you want to delete this source (leaving files in place)? This cannot be undone."
+            >
+              Delete Source
+            </.link>
+          </:option>
+          <:option>
+            <.link
+              href={~p"/sources/#{@source}?delete_files=true"}
+              method="delete"
+              data-confirm="Are you sure you want to delete this source and it's files on disk? This cannot be undone."
+              class="mt-5 md:mt-0"
+            >
+              Delete Source + Files
+            </.link>
+          </:option>
+        </.button_dropdown>
       </:tab_append>
 
       <:tab title="Attributes">
@@ -28,9 +64,9 @@
           <h3 class="font-bold text-lg">Attributes</h3>
           <section>
             <strong>Media Profile:</strong>
-            <.subtle_link href={~p"/media_profiles/#{@source.media_profile_id}"}>
+            <.inline_link href={~p"/media_profiles/#{@source.media_profile_id}"}>
               <%= @source.media_profile.name %>
-            </.subtle_link>
+            </.inline_link>
           </section>
 
           <.list_items_from_map map={Map.from_struct(@source)} />
@@ -41,17 +77,10 @@
           <h4 class="text-white text-lg mb-6">Shows a maximum of 100 media items</h4>
           <.table rows={@pending_media} table_class="text-black dark:text-white">
             <:col :let={media_item} label="Title">
-              <.subtle_link href={~p"/sources/#{@source.id}/media/#{media_item.id}"}>
+              <%= StringUtils.truncate(media_item.title, 50) %>
-                <%= StringUtils.truncate(media_item.title, 50) %>
-              </.subtle_link>
             </:col>
             <:col :let={media_item} label="" class="flex place-content-evenly">
-              <.icon_link href={~p"/sources/#{@source.id}/media/#{media_item.id}"} icon="hero-eye" class="mx-1" />
+              <.icon_link href={~p"/sources/#{@source.id}/media/#{media_item.id}"} icon="hero-eye" />
-              <.icon_link
-                href={~p"/sources/#{@source.id}/media/#{media_item.id}/edit"}
-                icon="hero-pencil-square"
-                class="mx-1"
-              />
             </:col>
           </.table>
         <% else %>
@@ -63,17 +92,10 @@
           <h4 class="text-white text-lg mb-6">Shows a maximum of 100 media items (<%= @total_downloaded %> total)</h4>
           <.table rows={@downloaded_media} table_class="text-black dark:text-white">
             <:col :let={media_item} label="Title">
-              <.subtle_link href={~p"/sources/#{@source.id}/media/#{media_item.id}"}>
+              <%= StringUtils.truncate(media_item.title, 50) %>
-                <%= StringUtils.truncate(media_item.title, 50) %>
-              </.subtle_link>
             </:col>
             <:col :let={media_item} label="" class="flex place-content-evenly">
-              <.icon_link href={~p"/sources/#{@source.id}/media/#{media_item.id}"} icon="hero-eye" class="mx-1" />
+              <.icon_link href={~p"/sources/#{@source.id}/media/#{media_item.id}"} icon="hero-eye" />
-              <.icon_link
-                href={~p"/sources/#{@source.id}/media/#{media_item.id}/edit"}
-                icon="hero-pencil-square"
-                class="mx-1"
-              />
             </:col>
           </.table>
         <% else %>

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

@@ -56,7 +56,7 @@
         type="toggle"
         label="Use Fast Indexing"
         label_suffix="(pro)"
-        help="Experimental. Overrides 'Index Frequency'. Recommended for large channels that upload frequently. Does not work with private playlists. See below for more info"
+        help="Experimental. Overrides 'Index Frequency'. Recommended for large channels that upload frequently. See below for more info"
         x-init="
           // `enabled` is the data attribute that the toggle uses internally
           fastIndexingEnabled = enabled
@@ -88,14 +88,6 @@
     help="Only download media uploaded after this date. Leave blank to download all media. Must be in YYYY-MM-DD format"
   />
 
-  <.input
-    field={f[:retention_period_days]}
-    type="number"
-    label="Retention Period (days)"
-    min="0"
-    help="Days between when media is *downloaded* and when it's deleted. Leave blank to keep media indefinitely"
-  />
-
   <section x-show="advancedMode">
     <h3 class="mt-8 text-2xl text-black dark:text-white">
       Advanced Options

lib/pinchflat_web/endpoint.ex

@@ -20,7 +20,7 @@ defmodule PinchflatWeb.Endpoint do
   plug Plug.Static,
     at: "/",
     from: :pinchflat,
-    gzip: Mix.env() == :prod,
+    gzip: false,
     only: PinchflatWeb.static_paths()
 
   # Code reloading can be explicitly enabled under the

lib/pinchflat_web/router.ex

@@ -1,6 +1,5 @@
 defmodule PinchflatWeb.Router do
   use PinchflatWeb, :router
-  import Phoenix.LiveDashboard.Router
 
   # IMPORTANT: `strip_trailing_extension` in endpoint.ex removes
   # the extension from the path
@@ -12,7 +11,6 @@ defmodule PinchflatWeb.Router do
     plug :put_root_layout, html: {PinchflatWeb.Layouts, :root}
     plug :protect_from_forgery
     plug :put_secure_browser_headers
-    plug :allow_iframe_embed
   end
 
   pipeline :api do
@@ -30,15 +28,9 @@ defmodule PinchflatWeb.Router do
 
     resources "/media_profiles", MediaProfiles.MediaProfileController
     resources "/search", Searches.SearchController, only: [:show], singleton: true
-    resources "/settings", Settings.SettingController, only: [:show, :update], singleton: true
 
     resources "/sources", Sources.SourceController do
-      post "/force_download", Sources.SourceController, :force_download
+      resources "/media", MediaItems.MediaItemController, only: [:show, :delete]
-      post "/force_index", Sources.SourceController, :force_index
-
-      resources "/media", MediaItems.MediaItemController, only: [:show, :edit, :update, :delete] do
-        post "/force_download", MediaItems.MediaItemController, :force_download
-      end
     end
   end
 
@@ -53,19 +45,21 @@ defmodule PinchflatWeb.Router do
     get "/media/:uuid/stream", MediaItems.MediaItemController, :stream
   end
 
-  # No auth or CSRF protection for the health check endpoint
+  # Enable LiveDashboard and Swoosh mailbox preview in development
-  scope "/", PinchflatWeb do
+  if Application.compile_env(:pinchflat, :dev_routes) do
-    pipe_through :api
+    # If you want to use the LiveDashboard in production, you should put
+    # it behind authentication and allow only admins to access it.
+    # If your application does not have an admins-only section yet,
+    # you can use Plug.BasicAuth to set up some basic authentication
+    # as long as you are also using SSL (which you should anyway).
+    import Phoenix.LiveDashboard.Router
 
-    get "/healthcheck", HealthController, :check
+    scope "/dev" do
-  end
+      pipe_through :browser
 
-  scope "/dev" do
+      live_dashboard "/dashboard", metrics: PinchflatWeb.Telemetry
-    pipe_through :browser
+      forward "/mailbox", Plug.Swoosh.MailboxPreview
-
+    end
-    live_dashboard "/dashboard",
-      metrics: PinchflatWeb.Telemetry,
-      ecto_repos: [Pinchflat.Repo]
   end
 
   defp maybe_basic_auth(conn, opts) do
@@ -90,8 +84,4 @@ defmodule PinchflatWeb.Router do
   defp credential_set?(credential) do
     credential && credential != ""
   end
-
-  defp allow_iframe_embed(conn, _opts) do
-    delete_resp_header(conn, "x-frame-options")
-  end
 end

mix.exs

@@ -4,7 +4,7 @@ defmodule Pinchflat.MixProject do
   def project do
     [
       app: :pinchflat,
-      version: "0.1.11",
+      version: "0.1.5",
       elixir: "~> 1.16",
       elixirc_paths: elixirc_paths(Mix.env()),
       start_permanent: Mix.env() == :prod,
@@ -33,7 +33,7 @@ defmodule Pinchflat.MixProject do
   def application do
     [
       mod: {Pinchflat.Application, []},
-      extra_applications: [:logger, :runtime_tools, :inets, :os_mon]
+      extra_applications: [:logger, :runtime_tools, :inets]
     ]
   end
 
@@ -50,7 +50,6 @@ defmodule Pinchflat.MixProject do
       {:phoenix_ecto, "~> 4.4"},
       {:ecto_sql, "~> 3.10"},
       {:ecto_sqlite3, ">= 0.0.0"},
-      {:ecto_sqlite3_extras, "~> 1.2.0"},
       {:phoenix_html, "~> 3.3"},
       {:phoenix_live_reload, "~> 1.2", only: :dev},
       {:phoenix_live_view, "~> 0.20.1"},

mix.lock

@@ -13,7 +13,6 @@
   "ecto": {:hex, :ecto, "3.11.1", "4b4972b717e7ca83d30121b12998f5fcdc62ba0ed4f20fd390f16f3270d85c3e", [: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", "ebd3d3772cd0dfcd8d772659e41ed527c28b2a8bde4b00fe03e0463da0f1983b"},
   "ecto_sql": {:hex, :ecto_sql, "3.11.1", "e9abf28ae27ef3916b43545f9578b4750956ccea444853606472089e7d169470", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.11.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16.0 or ~> 0.17.0 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", "ce14063ab3514424276e7e360108ad6c2308f6d88164a076aac8a387e1fea634"},
   "ecto_sqlite3": {:hex, :ecto_sqlite3, "0.15.1", "40f2fbd9e246455f8c42e7e0a77009ef806caa1b3ce6f717b2a0a80e8432fcfd", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ecto, "~> 3.11", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "~> 3.11", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:exqlite, "~> 0.19", [hex: :exqlite, repo: "hexpm", optional: false]}], "hexpm", "28b16e177123c688948357176662bf9ff9084daddf950ef5b6baf3ee93707064"},
-  "ecto_sqlite3_extras": {:hex, :ecto_sqlite3_extras, "1.2.2", "36e60b561a11441d15f26c791817999269fb578b985162207ebb08b04ca71e40", [:mix], [{:exqlite, ">= 0.13.2", [hex: :exqlite, repo: "hexpm", optional: false]}, {:table_rex, "~> 4.0", [hex: :table_rex, repo: "hexpm", optional: false]}], "hexpm", "2b66ba7246bb4f7e39e2578acd4a0e4e4be54f60ff52d450a01be95eeb78ff1e"},
   "elixir_make": {:hex, :elixir_make, "0.7.8", "505026f266552ee5aabca0b9f9c229cbb496c689537c9f922f3eb5431157efc7", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:certifi, "~> 2.0", [hex: :certifi, repo: "hexpm", optional: true]}], "hexpm", "7a71945b913d37ea89b06966e1342c85cfe549b15e6d6d081e8081c493062c07"},
   "esbuild": {:hex, :esbuild, "0.8.1", "0cbf919f0eccb136d2eeef0df49c4acf55336de864e63594adcea3814f3edf41", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "25fc876a67c13cb0a776e7b5d7974851556baeda2085296c14ab48555ea7560f"},
   "ex_check": {:hex, :ex_check, "0.14.0", "d6fbe0bcc51cf38fea276f5bc2af0c9ae0a2bb059f602f8de88709421dae4f0e", [:mix], [], "hexpm", "8a602e98c66e6a4be3a639321f1f545292042f290f91fa942a285888c6868af0"},
@@ -47,7 +46,6 @@
   "ranch": {:hex, :ranch, "1.8.0", "8c7a100a139fd57f17327b6413e4167ac559fbc04ca7448e9be9057311597a1d", [:make, :rebar3], [], "hexpm", "49fbcfd3682fab1f5d109351b61257676da1a2fdbe295904176d5e521a2ddfe5"},
   "sobelow": {:hex, :sobelow, "0.13.0", "218afe9075904793f5c64b8837cc356e493d88fddde126a463839351870b8d1e", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "cd6e9026b85fc35d7529da14f95e85a078d9dd1907a9097b3ba6ac7ebbe34a0d"},
   "swoosh": {:hex, :swoosh, "1.14.4", "94e9dba91f7695a10f49b0172c4a4cb658ef24abef7e8140394521b7f3bbb2d4", [:mix], [{:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:ex_aws, "~> 2.1", [hex: :ex_aws, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:req, "~> 0.4 or ~> 1.0", [hex: :req, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "081c5a590e4ba85cc89baddf7b2beecf6c13f7f84a958f1cd969290815f0f026"},
-  "table_rex": {:hex, :table_rex, "4.0.0", "3c613a68ebdc6d4d1e731bc973c233500974ec3993c99fcdabb210407b90959b", [:mix], [], "hexpm", "c35c4d5612ca49ebb0344ea10387da4d2afe278387d4019e4d8111e815df8f55"},
   "tailwind": {:hex, :tailwind, "0.2.2", "9e27288b568ede1d88517e8c61259bc214a12d7eed271e102db4c93fcca9b2cd", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}], "hexpm", "ccfb5025179ea307f7f899d1bb3905cd0ac9f687ed77feebc8f67bdca78565c4"},
   "telemetry": {:hex, :telemetry, "1.2.1", "68fdfe8d8f05a8428483a97d7aab2f268aaff24b49e0f599faa091f1d4e7f61c", [:rebar3], [], "hexpm", "dad9ce9d8effc621708f99eac538ef1cbe05d6a874dd741de2e689c47feafed5"},
   "telemetry_metrics": {:hex, :telemetry_metrics, "0.6.2", "2caabe9344ec17eafe5403304771c3539f3b6e2f7fb6a6f602558c825d0d0bfb", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "9b43db0dc33863930b9ef9d27137e78974756f5f198cae18409970ed6fa5b561"},

priv/repo/migrations/20240401170440_re_re_add_source_uniqueness_index.exs

@@ -1,19 +0,0 @@
-defmodule Pinchflat.Repo.Migrations.ReReAddSourceUniquenessIndex do
-  use Ecto.Migration
-
-  def up do
-    execute """
-      CREATE UNIQUE INDEX sources_collection_id_media_profile_id_title_filter_regex_index ON sources (
-        collection_id,
-        media_profile_id,
-        IFNULL(title_filter_regex, '')
-      );
-    """
-  end
-
-  def down do
-    execute """
-      DROP INDEX sources_collection_id_media_profile_id_title_filter_regex_index;
-    """
-  end
-end

priv/repo/migrations/20240402192417_add_prevent_download_to_media_items.exs

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

priv/repo/migrations/20240402221638_add_retention_period_to_sources.exs

@@ -1,9 +0,0 @@
-defmodule Pinchflat.Repo.Migrations.AddRetentionPeriodToSources do
-  use Ecto.Migration
-
-  def change do
-    alter table(:sources) do
-      add :retention_period_days, :integer
-    end
-  end
-end

priv/repo/migrations/20240403164943_add_culled_at_to_media_items.exs

@@ -1,10 +0,0 @@
-defmodule Pinchflat.Repo.Migrations.AddCulledAtToMediaItems do
-  use Ecto.Migration
-
-  def change do
-    alter table(:media_items) do
-      add :culled_at, :utc_datetime
-      add :prevent_culling, :boolean, default: false
-    end
-  end
-end

priv/repo/migrations/20240404172256_rename_settings_table.exs

@@ -1,7 +0,0 @@
-defmodule Pinchflat.Repo.Migrations.RenameSettingsTable do
-  use Ecto.Migration
-
-  def change do
-    rename table(:settings), to: table(:settings_backup)
-  end
-end

priv/repo/migrations/20240404174144_create_new_settings.exs

@@ -1,29 +0,0 @@
-defmodule Pinchflat.Repo.Migrations.CreateNewSettings do
-  use Ecto.Migration
-
-  def up do
-    create table(:settings) do
-      add :onboarding, :boolean, default: true, null: false
-      add :pro_enabled, :boolean, default: false, null: false
-      add :yt_dlp_version, :string
-    end
-
-    # Make an initial record because this will be the only one ever inserted
-    execute "INSERT INTO settings (onboarding, pro_enabled, yt_dlp_version) VALUES (true, false, NULL)"
-
-    # Set the value of onboarding to the previous version set in `settings_backup`
-    execute """
-      UPDATE settings
-      SET onboarding = COALESCE((SELECT value = 'true' FROM settings_backup WHERE name = 'onboarding'), true)
-    """
-
-    execute """
-      UPDATE settings
-      SET pro_enabled = COALESCE((SELECT value = 'true' FROM settings_backup WHERE name = 'pro_enabled'), false)
-    """
-  end
-
-  def down do
-    drop table(:settings)
-  end
-end

priv/repo/migrations/20240404221551_add_apprise_servers_to_settings.exs

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

priv/repo/migrations/20240408181121_add_apprise_version_to_settings.exs

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

priv/repo/migrations/20240409224152_add_redownloaded_fields.exs

@@ -1,13 +0,0 @@
-defmodule Pinchflat.Repo.Migrations.AddRedownloadedFields do
-  use Ecto.Migration
-
-  def change do
-    alter table(:media_profiles) do
-      add :redownload_delay_days, :integer
-    end
-
-    alter table(:media_items) do
-      add :media_redownloaded_at, :utc_datetime
-    end
-  end
-end

selfhosted.Dockerfile

@@ -79,7 +79,7 @@ ARG PORT=8945
 
 RUN apt-get update -y
 RUN apt-get install -y libstdc++6 openssl libncurses5 locales ca-certificates \
-  ffmpeg curl git openssh-client nano python3 python3-pip
+  ffmpeg curl git openssh-client nano
 RUN apt-get clean && rm -f /var/lib/apt/lists/*_*
 
 # Download and update YT-DLP
@@ -87,19 +87,19 @@ RUN curl -L https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -o
 RUN chmod a+rx /usr/local/bin/yt-dlp
 RUN yt-dlp -U
 
-# Download Apprise
-RUN python3 -m pip install -U apprise --break-system-packages
-
 # Set the locale
 RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && locale-gen
+
 ENV LANG en_US.UTF-8
 ENV LANGUAGE en_US:en
 ENV LC_ALL en_US.UTF-8
 
 WORKDIR "/app"
+RUN chown nobody /app
 
 # Set up data volumes
 RUN mkdir /config /downloads
+RUN chown nobody /config /downloads
 
 # set runner ENV
 ENV MIX_ENV="prod"
@@ -108,7 +108,7 @@ ENV RUN_CONTEXT="selfhosted"
 EXPOSE ${PORT}
 
 # Only copy the final release from the build stage
-COPY --from=builder /app/_build/${MIX_ENV}/rel/pinchflat ./
+COPY --from=builder --chown=nobody:root /app/_build/${MIX_ENV}/rel/pinchflat ./
 
 # NEVER do this if you're running in an environment where you don't trust the user
 # (ie: most environments). This is only acceptable in a self-hosted environment.
@@ -121,13 +121,12 @@ COPY --from=builder /app/_build/${MIX_ENV}/rel/pinchflat ./
 # root, use --user 0:0 or something.
 RUN passwd -d root
 
+USER nobody
+
 # If using an environment that doesn't automatically reap zombie processes, it is
 # advised to add an init process such as tini via `apt-get install`
 # above and adding an entrypoint. See https://github.com/krallin/tini for details
 # ENTRYPOINT ["/tini", "--"]
 
-HEALTHCHECK --interval=120s --start-period=10s \
-  CMD curl --fail http://localhost:${PORT}/healthcheck || exit 1
-
 # Start the app
 CMD ["/app/bin/docker_start"]

test/pinchflat/boot/data_backfill_worker_test.exs

@@ -0,0 +1,46 @@
+defmodule Pinchflat.Boot.DataBackfillWorkerTest do
+  use Pinchflat.DataCase
+
+  alias Pinchflat.Boot.DataBackfillWorker
+  alias Pinchflat.JobFixtures.TestJobWorker
+
+  describe "cancel_pending_backfill_jobs/0" do
+    test "cancels all pending backfill jobs" do
+      %{}
+      |> DataBackfillWorker.new()
+      |> Repo.insert_unique_job()
+
+      assert_enqueued(worker: DataBackfillWorker)
+
+      DataBackfillWorker.cancel_pending_backfill_jobs()
+
+      refute_enqueued(worker: DataBackfillWorker)
+    end
+
+    test "does not cancel jobs for other workers" do
+      %{id: 0}
+      |> TestJobWorker.new()
+      |> Repo.insert_unique_job()
+
+      assert_enqueued(worker: TestJobWorker)
+
+      DataBackfillWorker.cancel_pending_backfill_jobs()
+
+      assert_enqueued(worker: TestJobWorker)
+    end
+  end
+
+  describe "perform/1" do
+    setup do
+      DataBackfillWorker.cancel_pending_backfill_jobs()
+
+      :ok
+    end
+
+    test "reschedules itself once complete" do
+      perform_job(DataBackfillWorker, %{})
+
+      assert_enqueued(worker: DataBackfillWorker, scheduled_at: now_plus(60, :minutes))
+    end
+  end
+end

test/pinchflat/boot/pre_job_startup_tasks_test.exs

@@ -1,77 +1,25 @@
 defmodule Pinchflat.Boot.PreJobStartupTasksTest do
   use Pinchflat.DataCase
 
-  import Mox
-  import Pinchflat.JobFixtures
-
   alias Pinchflat.Settings
+  alias Pinchflat.Settings.Setting
   alias Pinchflat.Boot.PreJobStartupTasks
 
-  setup do
-    stub(YtDlpRunnerMock, :version, fn -> {:ok, "1"} end)
-    stub(AppriseRunnerMock, :version, fn -> {:ok, "2"} end)
-
-    :ok
-  end
-
-  describe "reset_executing_jobs" do
-    test "resets executing jobs" do
-      job = job_fixture()
-      Repo.update_all(Oban.Job, set: [state: "executing"])
-
-      assert Repo.reload!(job).state == "executing"
-
-      PreJobStartupTasks.init(%{})
-
-      assert Repo.reload!(job).state == "retryable"
-    end
-  end
-
-  describe "create_blank_yt_dlp_files" do
-    test "creates a blank cookie file" do
-      base_dir = Application.get_env(:pinchflat, :extras_directory)
-      filepath = Path.join(base_dir, "cookies.txt")
-      File.rm(filepath)
-
-      refute File.exists?(filepath)
-
-      PreJobStartupTasks.init(%{})
-
-      assert File.exists?(filepath)
-    end
-
-    test "creates a blank yt-dlp config file" do
-      base_dir = Application.get_env(:pinchflat, :extras_directory)
-      filepath = Path.join([base_dir, "yt-dlp-configs", "base-config.txt"])
-      File.rm(filepath)
-
-      refute File.exists?(filepath)
-
-      PreJobStartupTasks.init(%{})
-
-      assert File.exists?(filepath)
-    end
-  end
-
   describe "apply_default_settings" do
-    test "sets yt_dlp version" do
+    setup do
-      Settings.set(yt_dlp_version: nil)
+      Repo.delete_all(Setting)
 
-      refute Settings.get!(:yt_dlp_version)
+      :ok
-
-      PreJobStartupTasks.init(%{})
-
-      assert Settings.get!(:yt_dlp_version)
     end
 
-    test "sets apprise version" do
+    test "sets default settings" do
-      Settings.set(apprise_version: nil)
+      assert_raise Ecto.NoResultsError, fn -> Settings.get!(:onboarding) end
+      assert_raise Ecto.NoResultsError, fn -> Settings.get!(:pro_enabled) end
 
-      refute Settings.get!(:apprise_version)
+      PreJobStartupTasks.start_link()
 
-      PreJobStartupTasks.init(%{})
+      assert Settings.get!(:onboarding)
-
+      refute Settings.get!(:pro_enabled)
-      assert Settings.get!(:apprise_version)
     end
   end
 end

test/pinchflat/downloading/download_option_builder_test.exs

@@ -5,7 +5,6 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilderTest do
   import Pinchflat.ProfilesFixtures
 
   alias Pinchflat.Profiles
-  alias Pinchflat.Utils.FilesystemUtils
   alias Pinchflat.Downloading.DownloadOptionBuilder
 
   setup do
@@ -262,96 +261,6 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilderTest do
     end
   end
 
-  describe "build/1 when testing config file options" do
-    setup do
-      base_dir = Path.join(Application.get_env(:pinchflat, :extras_directory), "yt-dlp-configs")
-
-      {:ok, %{base_dir: base_dir}}
-    end
-
-    test "includes base config file if it's present", %{media_item: media_item, base_dir: base_dir} do
-      filepath = Path.join(base_dir, "base-config.txt")
-
-      FilesystemUtils.write_p!(filepath, "base config")
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-      assert {:config_locations, filepath} in res
-    end
-
-    test "includes media profile config file if it's present", %{media_item: media_item, base_dir: base_dir} do
-      media_profile = media_item.source.media_profile
-      filepath = Path.join(base_dir, "media-profile-#{media_profile.id}-config.txt")
-
-      FilesystemUtils.write_p!(filepath, "profile config")
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-      assert {:config_locations, filepath} in res
-    end
-
-    test "includes source config file if it's present", %{media_item: media_item, base_dir: base_dir} do
-      source = media_item.source
-      filepath = Path.join(base_dir, "source-#{source.id}-config.txt")
-
-      FilesystemUtils.write_p!(filepath, "profile config")
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-      assert {:config_locations, filepath} in res
-    end
-
-    test "includes media item config file if it's present", %{media_item: media_item, base_dir: base_dir} do
-      filepath = Path.join(base_dir, "media-item-#{media_item.id}-config.txt")
-
-      FilesystemUtils.write_p!(filepath, "media item config")
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-      assert {:config_locations, filepath} in res
-    end
-
-    test "does not include config file options if they are not present", %{media_item: media_item} do
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-
-      refute :config_locations in res
-    end
-
-    test "does not return a config file if it's blank", %{media_item: media_item, base_dir: base_dir} do
-      filepath = Path.join(base_dir, "base-config.txt")
-
-      FilesystemUtils.write_p!(filepath, " \n \n ")
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-      refute :config_locations in res
-    end
-
-    test "returns config files in order of precedence", %{media_item: media_item, base_dir: base_dir} do
-      source = media_item.source
-      media_profile = source.media_profile
-
-      base_filepath = Path.join(base_dir, "base-config.txt")
-      source_filepath = Path.join(base_dir, "source-#{source.id}-config.txt")
-      media_item_filepath = Path.join(base_dir, "media-item-#{media_item.id}-config.txt")
-      media_profile_filepath = Path.join(base_dir, "media-profile-#{media_profile.id}-config.txt")
-
-      FilesystemUtils.write_p!(base_filepath, "config")
-      FilesystemUtils.write_p!(source_filepath, "config")
-      FilesystemUtils.write_p!(media_item_filepath, "config")
-      FilesystemUtils.write_p!(media_profile_filepath, "config")
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-
-      expected_order = [
-        {:config_locations, base_filepath},
-        {:config_locations, media_profile_filepath},
-        {:config_locations, source_filepath},
-        {:config_locations, media_item_filepath}
-      ]
-
-      assert Enum.filter(res, fn
-               {:config_locations, _} -> true
-               _ -> false
-             end) == expected_order
-    end
-  end
-
   describe "build_output_path_for/1" do
     test "builds an output path for a source", %{media_item: media_item} do
       path = DownloadOptionBuilder.build_output_path_for(media_item.source)

test/pinchflat/downloading/media_download_worker_test.exs

@@ -4,9 +4,8 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
   import Mox
   import Pinchflat.MediaFixtures
 
-  alias Pinchflat.Media
   alias Pinchflat.Sources
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
   alias Pinchflat.Downloading.MediaDownloadWorker
 
   setup :verify_on_exit!
@@ -35,40 +34,21 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
       assert {:ok, task} = MediaDownloadWorker.kickoff_with_task(media_item)
       assert task.media_item_id == media_item.id
     end
-
-    test "can be called with additional job arguments", %{media_item: media_item} do
-      job_args = %{"force" => true}
-
-      assert {:ok, _} = MediaDownloadWorker.kickoff_with_task(media_item, job_args)
-
-      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id, "force" => true})
-    end
-
-    test "can be called with additional job options", %{media_item: media_item} do
-      job_opts = [max_attempts: 5]
-
-      assert {:ok, _} = MediaDownloadWorker.kickoff_with_task(media_item, %{}, job_opts)
-
-      [job] = all_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
-      assert job.max_attempts == 5
-    end
   end
 
   describe "perform/1" do
     test "it saves attributes to the media_item", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
         {:ok, render_metadata(:media_metadata)}
       end)
 
       assert media_item.media_filepath == nil
       perform_job(MediaDownloadWorker, %{id: media_item.id})
-      media_item = Repo.reload(media_item)
+      assert Repo.reload(media_item).media_filepath != nil
-
-      assert media_item.media_filepath != nil
     end
 
     test "it saves the metadata to the media_item", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
         {:ok, render_metadata(:media_metadata)}
       end)
 
@@ -85,7 +65,7 @@ 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, fn _url, _opts, _ot -> {:error, "error"} end)
 
       Oban.Testing.with_testing_mode(:inline, fn ->
         {:ok, job} = Oban.insert(MediaDownloadWorker.new(%{id: media_item.id}))
@@ -94,53 +74,18 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
       end)
     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}
-      end)
-
-      Oban.Testing.with_testing_mode(:inline, fn ->
-        {:ok, job} = Oban.insert(MediaDownloadWorker.new(%{id: media_item.id}))
-
-        assert job.state == "retryable"
-      end)
-    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)
-
-      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, _opts, _ot -> :ok end)
 
       Sources.update_source(media_item.source, %{download_media: false})
 
       perform_job(MediaDownloadWorker, %{id: media_item.id})
     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)
-
-      Media.update_media_item(media_item, %{prevent_download: true})
-
-      perform_job(MediaDownloadWorker, %{id: media_item.id})
-    end
-
-    test "downloads anyway 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})
-
-      perform_job(MediaDownloadWorker, %{id: media_item.id, force: true})
-    end
-
     test "it saves the file's size to the database", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
         metadata = render_parsed_metadata(:media_metadata)
-        FilesystemUtils.write_p!(metadata["filepath"], "test")
+        FilesystemHelpers.write_p!(metadata["filepath"], "test")
 
         {:ok, Phoenix.json_library().encode!(metadata)}
       end)
@@ -151,28 +96,6 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
       assert media_item.media_size_bytes > 0
     end
 
-    test "saves redownloaded_at if this is for a redownload", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
-        {:ok, render_metadata(:media_metadata)}
-      end)
-
-      perform_job(MediaDownloadWorker, %{id: media_item.id, redownload?: true})
-      media_item = Repo.reload(media_item)
-
-      assert media_item.media_redownloaded_at != nil
-    end
-
-    test "doesn't save redownloaded_at if this is not for a redownload", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
-        {:ok, render_metadata(:media_metadata)}
-      end)
-
-      perform_job(MediaDownloadWorker, %{id: media_item.id})
-      media_item = Repo.reload(media_item)
-
-      assert media_item.media_redownloaded_at == nil
-    end
-
     test "does not blow up if the record doesn't exist" do
       assert :ok = perform_job(MediaDownloadWorker, %{id: 0})
     end

test/pinchflat/downloading/media_downloader_test.exs

@@ -25,11 +25,9 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
 
   describe "download_for_media_item/3" do
     test "it calls the backend runner", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn url, _opts, ot, addl ->
+      expect(YtDlpRunnerMock, :run, fn url, _opts, ot ->
         assert url == media_item.original_url
         assert ot == "after_move:%()j"
-        assert [{:output_filepath, filepath}] = addl
-        assert is_binary(filepath)
 
         {:ok, render_metadata(:media_metadata)}
       end)
@@ -38,7 +36,7 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
     end
 
     test "it saves the metadata filepath to the database", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
         {:ok, render_metadata(:media_metadata)}
       end)
 
@@ -49,56 +47,18 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
       assert updated_media_item.metadata.thumbnail_filepath =~ "media_items/#{media_item.id}/maxresdefault.jpg"
     end
 
-    test "non-recoverable errors are passed through", %{media_item: media_item} do
+    test "errors are passed through", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
-        {: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}
       end)
 
-      assert {:error, message} = MediaDownloader.download_for_media_item(media_item)
+      assert {:error, :some_error} = MediaDownloader.download_for_media_item(media_item)
-      assert message == "Unknown error: {:error, :some_error}"
-    end
-  end
-
-  describe "download_for_media_item/3 when testing retries" 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 ->
-        {:error, message, 1}
-      end)
-
-      assert {:recovered, ^message} = MediaDownloader.download_for_media_item(media_item)
-    end
-
-    test "attempts to update the media item on recoverable errors", %{media_item: media_item} do
-      message = "Unable to communicate with SponsorBlock"
-
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl ->
-        [{:output_filepath, filepath}] = addl
-        File.write(filepath, render_metadata(:media_metadata))
-
-        {:error, message, 1}
-      end)
-
-      assert {:recovered, ^message} = MediaDownloader.download_for_media_item(media_item)
-      media_item = Repo.reload(media_item)
-
-      assert DateTime.diff(DateTime.utc_now(), media_item.media_downloaded_at) < 2
-      assert String.ends_with?(media_item.media_filepath, ".mkv")
     end
   end
 
   describe "download_for_media_item/3 when testing media_item attributes" do
     setup do
-      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
         {:ok, render_metadata(:media_metadata)}
       end)
 
@@ -140,7 +100,7 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
     end
 
     test "it extracts the thumbnail_filepath", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
         metadata = render_parsed_metadata(:media_metadata)
 
         thumbnail_filepath =
@@ -164,7 +124,7 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
     end
 
     test "it extracts the metadata_filepath", %{media_item: media_item} do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
         metadata = render_parsed_metadata(:media_metadata)
 
         infojson_filepath = metadata["infojson_filename"]
@@ -183,7 +143,7 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
 
   describe "download_for_media_item/3 when testing NFO generation" do
     setup do
-      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
         {:ok, render_metadata(:media_metadata)}
       end)
 

test/pinchflat/downloading/media_redownload_worker_test.exs

@@ -1,44 +0,0 @@
-defmodule Pinchflat.Downloading.MediaRedownloadWorkerTest do
-  use Pinchflat.DataCase
-
-  import Pinchflat.MediaFixtures
-  import Pinchflat.SourcesFixtures
-  import Pinchflat.ProfilesFixtures
-
-  alias Pinchflat.Downloading.MediaDownloadWorker
-  alias Pinchflat.Downloading.MediaRedownloadWorker
-
-  describe "perform/1" do
-    test "kicks off a task for redownloadable media items" do
-      media_profile = media_profile_fixture(%{redownload_delay_days: 4})
-      source = source_fixture(%{media_profile_id: media_profile.id, inserted_at: now_minus(10, :days)})
-
-      media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          upload_date: now_minus(6, :days),
-          media_downloaded_at: now_minus(5, :days)
-        })
-
-      perform_job(MediaRedownloadWorker, %{})
-
-      assert [_] = all_enqueued(worker: MediaDownloadWorker, args: %{id: media_item.id, redownload?: true})
-    end
-
-    test "does not kickoff a task for non-redownloadable media items" do
-      media_profile = media_profile_fixture(%{redownload_delay_days: 4})
-      source = source_fixture(%{media_profile_id: media_profile.id, inserted_at: now_minus(10, :days)})
-
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          upload_date: now_minus(6, :days),
-          media_downloaded_at: now_minus(1, :day)
-        })
-
-      perform_job(MediaRedownloadWorker, %{})
-
-      assert [] = all_enqueued(worker: MediaDownloadWorker)
-    end
-  end
-end

test/pinchflat/downloading/media_retention_worker_test.exs

@@ -1,70 +0,0 @@
-defmodule Pinchflat.Downloading.MediaRetentionWorkerTest do
-  use Pinchflat.DataCase
-
-  import Pinchflat.MediaFixtures
-  import Pinchflat.SourcesFixtures
-
-  alias Pinchflat.Media
-  alias Pinchflat.Downloading.MediaRetentionWorker
-
-  describe "perform/1" do
-    test "deletes media files that are past their retention date" do
-      {_source, old_media_item, new_media_item} = prepare_records()
-
-      perform_job(MediaRetentionWorker, %{})
-
-      assert File.exists?(new_media_item.media_filepath)
-      refute File.exists?(old_media_item.media_filepath)
-      assert Repo.reload!(new_media_item).media_filepath
-      refute Repo.reload!(old_media_item).media_filepath
-    end
-
-    test "sets deleted media to not re-download" do
-      {_source, old_media_item, new_media_item} = prepare_records()
-
-      perform_job(MediaRetentionWorker, %{})
-
-      refute Repo.reload!(new_media_item).prevent_download
-      assert Repo.reload!(old_media_item).prevent_download
-    end
-
-    test "sets culled_at timestamp on deleted media" do
-      {_source, old_media_item, new_media_item} = prepare_records()
-
-      perform_job(MediaRetentionWorker, %{})
-
-      refute Repo.reload!(new_media_item).culled_at
-      assert Repo.reload!(old_media_item).culled_at
-      assert DateTime.diff(now(), Repo.reload!(old_media_item).culled_at) < 1
-    end
-
-    test "doesn't cull media items that have prevent_culling set" do
-      {_source, old_media_item, _new_media_item} = prepare_records()
-
-      Media.update_media_item(old_media_item, %{prevent_culling: true})
-
-      perform_job(MediaRetentionWorker, %{})
-
-      assert File.exists?(old_media_item.media_filepath)
-      assert Repo.reload!(old_media_item).media_filepath
-    end
-  end
-
-  defp prepare_records do
-    source = source_fixture(%{retention_period_days: 2})
-
-    old_media_item =
-      media_item_with_attachments(%{
-        source_id: source.id,
-        media_downloaded_at: now_minus(3, :days)
-      })
-
-    new_media_item =
-      media_item_with_attachments(%{
-        source_id: source.id,
-        media_downloaded_at: now_minus(1, :day)
-      })
-
-    {source, old_media_item, new_media_item}
-  end
-end

test/pinchflat/fast_indexing/fast_indexing_helpers_test.exs

@@ -24,7 +24,7 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest 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)
 
-      assert [_] = FastIndexingHelpers.kickoff_indexing_tasks_from_youtube_rss_feed(source)
+      assert :ok = FastIndexingHelpers.kickoff_indexing_tasks_from_youtube_rss_feed(source)
 
       assert [worker] = all_enqueued(worker: MediaIndexingWorker)
       assert worker.args["id"] == source.id
@@ -35,16 +35,10 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
       media_item_fixture(source_id: source.id, media_id: "test_1")
 
-      assert [] = FastIndexingHelpers.kickoff_indexing_tasks_from_youtube_rss_feed(source)
+      assert :ok = FastIndexingHelpers.kickoff_indexing_tasks_from_youtube_rss_feed(source)
 
       refute_enqueued(worker: MediaIndexingWorker)
     end
-
-    test "returns the IDs of the found media items", %{source: source} do
-      expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
-
-      assert ["test_1"] = FastIndexingHelpers.kickoff_indexing_tasks_from_youtube_rss_feed(source)
-    end
   end
 
   describe "index_and_enqueue_download_for_media_item/2" do

test/pinchflat/fast_indexing/fast_indexing_worker_test.exs

@@ -4,7 +4,6 @@ defmodule Pinchflat.FastIndexing.FastIndexingWorkerTest do
   import Mox
   import Pinchflat.SourcesFixtures
 
-  alias Pinchflat.Settings
   alias Pinchflat.Sources.Source
   alias Pinchflat.FastIndexing.FastIndexingWorker
 
@@ -75,28 +74,4 @@ defmodule Pinchflat.FastIndexing.FastIndexingWorkerTest do
       assert :ok = perform_job(FastIndexingWorker, %{id: 0})
     end
   end
-
-  describe "perform/1 when testing notifications" do
-    setup do
-      Settings.set(apprise_server: "server_1")
-
-      :ok
-    end
-
-    test "sends a notification if new media was found" do
-      source = source_fixture(fast_index: true)
-
-      expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
-
-      expect(AppriseRunnerMock, :run, fn servers, opts ->
-        assert "server_1" = servers
-        assert is_binary(Keyword.get(opts, :title))
-        assert is_binary(Keyword.get(opts, :body))
-
-        {:ok, ""}
-      end)
-
-      perform_job(FastIndexingWorker, %{id: source.id})
-    end
-  end
 end

test/pinchflat/filesystem/filesystem_helpers_test.exs

@@ -1,13 +1,13 @@
-defmodule Pinchflat.Utils.FilesystemUtilsTest do
+defmodule Pinchflat.Filesystem.FilesystemHelpersTest do
   use Pinchflat.DataCase
 
   import Pinchflat.MediaFixtures
 
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
 
   describe "generate_metadata_tmpfile/1" do
     test "creates a tmpfile and returns its path" do
-      res = FilesystemUtils.generate_metadata_tmpfile(:json)
+      res = FilesystemHelpers.generate_metadata_tmpfile(:json)
 
       assert String.ends_with?(res, ".json")
       assert File.exists?(res)
@@ -22,7 +22,7 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
 
       refute media_item.media_size_bytes
 
-      assert {:ok, media_item} = FilesystemUtils.compute_and_save_media_filesize(media_item)
+      assert {:ok, media_item} = FilesystemHelpers.compute_and_save_media_filesize(media_item)
 
       assert Repo.reload!(media_item).media_size_bytes
     end
@@ -30,16 +30,16 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
     test "returns the error if operation fails" do
       media_item = media_item_fixture(%{media_filepath: "/nonexistent/file.mkv"})
 
-      assert {:error, _} = FilesystemUtils.compute_and_save_media_filesize(media_item)
+      assert {:error, _} = FilesystemHelpers.compute_and_save_media_filesize(media_item)
     end
   end
 
   describe "write_p/3" do
     test "writes content to a file" do
-      filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
+      filepath = FilesystemHelpers.generate_metadata_tmpfile(:json)
       content = "{}"
 
-      assert :ok = FilesystemUtils.write_p(filepath, content)
+      assert :ok = FilesystemHelpers.write_p(filepath, content)
       assert File.read!(filepath) == content
 
       File.rm!(filepath)
@@ -50,7 +50,7 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
       filepath = Path.join([tmpfile_directory, "foo", "bar", "file.json"])
       content = "{}"
 
-      assert :ok = FilesystemUtils.write_p(filepath, content)
+      assert :ok = FilesystemHelpers.write_p(filepath, content)
       assert File.read!(filepath) == content
 
       File.rm!(filepath)
@@ -59,10 +59,10 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
 
   describe "write_p!/3" do
     test "writes content to a file" do
-      filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
+      filepath = FilesystemHelpers.generate_metadata_tmpfile(:json)
       content = "{}"
 
-      assert :ok = FilesystemUtils.write_p!(filepath, content)
+      assert :ok = FilesystemHelpers.write_p!(filepath, content)
       assert File.read!(filepath) == content
 
       File.rm!(filepath)
@@ -73,7 +73,7 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
       filepath = Path.join([tmpfile_directory, "foo", "bar", "file.json"])
       content = "{}"
 
-      assert :ok = FilesystemUtils.write_p!(filepath, content)
+      assert :ok = FilesystemHelpers.write_p!(filepath, content)
       assert File.read!(filepath) == content
 
       File.rm!(filepath)
@@ -82,11 +82,11 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
 
   describe "delete_file_and_remove_empty_directories/1" do
     test "deletes file at the provided filepath" do
-      filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
+      filepath = FilesystemHelpers.generate_metadata_tmpfile(:json)
 
       assert File.exists?(filepath)
 
-      assert :ok = FilesystemUtils.delete_file_and_remove_empty_directories(filepath)
+      assert :ok = FilesystemHelpers.delete_file_and_remove_empty_directories(filepath)
 
       refute File.exists?(filepath)
     end
@@ -94,9 +94,9 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
     test "deletes empty directories" do
       tmpfile_directory = Application.get_env(:pinchflat, :tmpfile_directory)
       filepath = Path.join([tmpfile_directory, "foo", "bar", "baz", "qux.json"])
-      FilesystemUtils.write_p!(filepath, "")
+      FilesystemHelpers.write_p!(filepath, "")
 
-      assert :ok = FilesystemUtils.delete_file_and_remove_empty_directories(filepath)
+      assert :ok = FilesystemHelpers.delete_file_and_remove_empty_directories(filepath)
 
       refute File.exists?(filepath)
       refute File.exists?(Path.join([tmpfile_directory, "foo", "bar", "baz"]))
@@ -108,10 +108,10 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
       tmpfile_directory = Application.get_env(:pinchflat, :tmpfile_directory)
       filepath_1 = Path.join([tmpfile_directory, "foo", "bar", "baz", "qux.json"])
       filepath_2 = Path.join([tmpfile_directory, "foo", "baz.json"])
-      FilesystemUtils.write_p!(filepath_1, "")
+      FilesystemHelpers.write_p!(filepath_1, "")
-      FilesystemUtils.write_p!(filepath_2, "")
+      FilesystemHelpers.write_p!(filepath_2, "")
 
-      assert :ok = FilesystemUtils.delete_file_and_remove_empty_directories(filepath_1)
+      assert :ok = FilesystemHelpers.delete_file_and_remove_empty_directories(filepath_1)
 
       refute File.exists?(filepath_1)
       refute File.exists?(Path.join([tmpfile_directory, "foo", "bar", "baz"]))
@@ -121,24 +121,24 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
       assert File.exists?(Path.join([tmpfile_directory, "foo"]))
 
       # cleanup
-      FilesystemUtils.delete_file_and_remove_empty_directories(filepath_2)
+      FilesystemHelpers.delete_file_and_remove_empty_directories(filepath_2)
     end
 
     test "returns an error if file could not be deleted" do
       filepath = "/nonexistent/file.json"
 
-      assert {:error, _} = FilesystemUtils.delete_file_and_remove_empty_directories(filepath)
+      assert {:error, _} = FilesystemHelpers.delete_file_and_remove_empty_directories(filepath)
     end
   end
 
   describe "cp_p!/2" do
     test "copies a file from source to destination" do
       source = "#{tmpfile_directory()}/source.json"
-      FilesystemUtils.write_p!(source, "TEST")
+      FilesystemHelpers.write_p!(source, "TEST")
       destination = "#{tmpfile_directory()}/destination.json"
 
       refute File.exists?(destination)
-      FilesystemUtils.cp_p!(source, destination)
+      FilesystemHelpers.cp_p!(source, destination)
       assert File.exists?(destination)
       assert File.read!(destination) == "TEST"
 
@@ -148,11 +148,11 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
 
     test "creates directories as needed" do
       source = "#{tmpfile_directory()}/source.json"
-      FilesystemUtils.write_p!(source, "TEST")
+      FilesystemHelpers.write_p!(source, "TEST")
       destination = "#{tmpfile_directory()}/foo/bar/destination.json"
 
       refute File.exists?(destination)
-      FilesystemUtils.cp_p!(source, destination)
+      FilesystemHelpers.cp_p!(source, destination)
       assert File.exists?(destination)
 
       File.rm!(source)

test/pinchflat/media_test.exs

@@ -38,223 +38,6 @@ defmodule Pinchflat.MediaTest do
     end
   end
 
-  describe "list_cullable_media_items/0" do
-    test "returns media items where the source has a retention period" do
-      source_one = source_fixture(%{retention_period_days: 2})
-      source_two = source_fixture(%{retention_period_days: 0})
-      source_three = source_fixture(%{retention_period_days: nil})
-
-      _media_item =
-        media_item_fixture(%{
-          source_id: source_two.id,
-          media_filepath: "/video/#{Faker.File.file_name(:video)}",
-          media_downloaded_at: now_minus(3, :days)
-        })
-
-      _media_item =
-        media_item_fixture(%{
-          source_id: source_three.id,
-          media_filepath: "/video/#{Faker.File.file_name(:video)}",
-          media_downloaded_at: now_minus(3, :days)
-        })
-
-      expected_media_item =
-        media_item_fixture(%{
-          source_id: source_one.id,
-          media_filepath: "/video/#{Faker.File.file_name(:video)}",
-          media_downloaded_at: now_minus(3, :days)
-        })
-
-      assert Media.list_cullable_media_items() == [expected_media_item]
-    end
-
-    test "returns media_items with a media_filepath" do
-      source = source_fixture(%{retention_period_days: 2})
-
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          media_filepath: nil,
-          media_downloaded_at: now_minus(3, :days)
-        })
-
-      expected_media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          media_filepath: "/video/#{Faker.File.file_name(:video)}",
-          media_downloaded_at: now_minus(3, :days)
-        })
-
-      assert Media.list_cullable_media_items() == [expected_media_item]
-    end
-
-    test "returns items that have passed their retention period" do
-      source = source_fixture(%{retention_period_days: 2})
-
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          media_filepath: "/video/#{Faker.File.file_name(:video)}",
-          media_downloaded_at: now_minus(2, :days)
-        })
-
-      expected_media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          media_filepath: "/video/#{Faker.File.file_name(:video)}",
-          media_downloaded_at: now_minus(3, :days)
-        })
-
-      assert Media.list_cullable_media_items() == [expected_media_item]
-    end
-
-    test "doesn't return items that are set to prevent culling" do
-      source = source_fixture(%{retention_period_days: 2})
-
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          media_filepath: "/video/#{Faker.File.file_name(:video)}",
-          media_downloaded_at: now_minus(3, :days),
-          prevent_culling: true
-        })
-
-      expected_media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          media_filepath: "/video/#{Faker.File.file_name(:video)}",
-          media_downloaded_at: now_minus(3, :days)
-        })
-
-      assert Media.list_cullable_media_items() == [expected_media_item]
-    end
-  end
-
-  describe "list_redownloadable_media_items/0" do
-    setup do
-      media_profile = media_profile_fixture(%{redownload_delay_days: 4})
-      source = source_fixture(%{media_profile_id: media_profile.id, inserted_at: now_minus(10, :days)})
-
-      {:ok, %{media_profile: media_profile, source: source}}
-    end
-
-    test "returns media eligible for redownload", %{source: source} do
-      media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          upload_date: now_minus(6, :days),
-          media_downloaded_at: now_minus(5, :days)
-        })
-
-      assert Media.list_redownloadable_media_items() == [media_item]
-    end
-
-    test "returns media items that were downloaded in past but still meet redownload delay", %{source: source} do
-      media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          upload_date: now_minus(20, :days),
-          media_downloaded_at: now_minus(19, :days)
-        })
-
-      assert Media.list_redownloadable_media_items() == [media_item]
-    end
-
-    test "does not return media items without a media_downloaded_at", %{source: source} do
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          upload_date: now_minus(5, :days),
-          media_downloaded_at: nil
-        })
-
-      assert Media.list_redownloadable_media_items() == []
-    end
-
-    test "does not return media items that are set to prevent download", %{source: source} do
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          upload_date: now_minus(5, :days),
-          media_downloaded_at: now(),
-          prevent_download: true
-        })
-
-      assert Media.list_redownloadable_media_items() == []
-    end
-
-    test "does not return media items that have been culled", %{source: source} do
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          upload_date: now_minus(5, :days),
-          media_downloaded_at: now(),
-          culled_at: now()
-        })
-
-      assert Media.list_redownloadable_media_items() == []
-    end
-
-    test "does not return media items before the download delay", %{source: source} do
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          upload_date: now_minus(3, :days),
-          media_downloaded_at: now_minus(3, :days)
-        })
-
-      assert Media.list_redownloadable_media_items() == []
-    end
-
-    test "does not return media items that have already been redownloaded", %{source: source} do
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          upload_date: now_minus(5, :days),
-          media_downloaded_at: now(),
-          media_redownloaded_at: now()
-        })
-
-      assert Media.list_redownloadable_media_items() == []
-    end
-
-    test "does not return media items that were first downloaded well after the upload_date", %{source: source} do
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          media_downloaded_at: now(),
-          upload_date: now_minus(20, :days)
-        })
-
-      assert Media.list_redownloadable_media_items() == []
-    end
-
-    test "does not return media items that were recently uploaded", %{source: source} do
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          media_downloaded_at: now(),
-          upload_date: now_minus(2, :days)
-        })
-
-      assert Media.list_redownloadable_media_items() == []
-    end
-
-    test "does not return media items without a redownload delay" do
-      media_profile = media_profile_fixture(%{redownload_delay_days: nil})
-      source = source_fixture(%{media_profile_id: media_profile.id})
-
-      _media_item =
-        media_item_fixture(%{
-          source_id: source.id,
-          upload_date: now_minus(6, :days),
-          media_downloaded_at: now_minus(5, :days)
-        })
-
-      assert Media.list_redownloadable_media_items() == []
-    end
-  end
-
   describe "list_pending_media_items_for/1" do
     test "it returns pending without a filepath for a given source" do
       source = source_fixture()
@@ -274,6 +57,14 @@ defmodule Pinchflat.MediaTest do
 
       assert Media.list_pending_media_items_for(source) == []
     end
+
+    test "optionally accepts a limit" do
+      source = source_fixture()
+      media_item = media_item_fixture(%{source_id: source.id, media_filepath: nil})
+
+      assert Media.list_pending_media_items_for(source, limit: 1) == [media_item]
+      assert Media.list_pending_media_items_for(source, limit: 0) == []
+    end
   end
 
   describe "list_pending_media_items_for/1 when testing shorts" do
@@ -442,13 +233,22 @@ defmodule Pinchflat.MediaTest do
     end
   end
 
-  describe "list_pending_media_items_for/1 when testing download prevention" do
+  describe "list_downloaded_media_items_for/1" do
-    test "returns only media items that are not prevented from downloading" do
+    test "returns only media items with a media_filepath" do
       source = source_fixture()
-      _prevented_media_item = media_item_fixture(%{source_id: source.id, media_filepath: nil, prevent_download: true})
+      _media_item = media_item_fixture(%{source_id: source.id, media_filepath: nil})
-      media_item = media_item_fixture(%{source_id: source.id, media_filepath: nil, prevent_download: false})
+      media_item = media_item_fixture(%{source_id: source.id, media_filepath: "/video/#{Faker.File.file_name(:video)}"})
 
-      assert Media.list_pending_media_items_for(source) == [media_item]
+      assert Media.list_downloaded_media_items_for(source) == [media_item]
+    end
+
+    test "optionally accepts a limit" do
+      source = source_fixture()
+      _media_item = media_item_fixture(%{source_id: source.id, media_filepath: nil})
+      media_item = media_item_fixture(%{source_id: source.id, media_filepath: "/video/#{Faker.File.file_name(:video)}"})
+
+      assert Media.list_downloaded_media_items_for(source, limit: 1) == [media_item]
+      assert Media.list_downloaded_media_items_for(source, limit: 0) == []
     end
   end
 
@@ -520,18 +320,6 @@ defmodule Pinchflat.MediaTest do
 
       assert Media.pending_download?(media_item)
     end
-
-    test "returns true if the media item is not prevented from downloading" do
-      media_item = media_item_fixture(%{media_filepath: nil, prevent_download: false})
-
-      assert Media.pending_download?(media_item)
-    end
-
-    test "returns false if the media item is prevented from downloading" do
-      media_item = media_item_fixture(%{media_filepath: nil, prevent_download: true})
-
-      refute Media.pending_download?(media_item)
-    end
   end
 
   describe "search/1" do
@@ -799,63 +587,6 @@ defmodule Pinchflat.MediaTest do
     end
   end
 
-  describe "delete_media_files/2" do
-    test "does not delete the media_item" do
-      media_item = media_item_fixture()
-
-      assert {:ok, %MediaItem{}} = Media.delete_media_files(media_item)
-      assert Repo.reload!(media_item)
-    end
-
-    test "deletes attached tasks" do
-      media_item = media_item_fixture()
-      task = task_fixture(%{media_item_id: media_item.id})
-
-      assert {:ok, %MediaItem{}} = Media.delete_media_files(media_item)
-      assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
-    end
-
-    test "deletes the media_item's files" do
-      media_item = media_item_with_attachments()
-
-      assert File.exists?(media_item.media_filepath)
-      assert {:ok, _} = Media.delete_media_files(media_item)
-      refute File.exists?(media_item.media_filepath)
-    end
-
-    test "does not delete the media item's metadata files" do
-      stub(HTTPClientMock, :get, fn _url, _headers, _opts -> {:ok, ""} end)
-      media_item = Repo.preload(media_item_with_attachments(), :metadata)
-
-      update_attrs = %{
-        metadata: %{
-          metadata_filepath: MetadataFileHelpers.compress_and_store_metadata_for(media_item, %{}),
-          thumbnail_filepath:
-            MetadataFileHelpers.download_and_store_thumbnail_for(media_item, %{
-              "thumbnail" => "https://example.com/thumbnail.jpg"
-            })
-        }
-      }
-
-      {:ok, updated_media_item} = Media.update_media_item(media_item, update_attrs)
-      metadata = Repo.preload(updated_media_item, :metadata).metadata
-
-      assert {:ok, _} = Media.delete_media_files(updated_media_item)
-      assert Repo.reload(metadata)
-      assert File.exists?(updated_media_item.metadata.metadata_filepath)
-
-      # cleanup
-      Media.delete_media_item(updated_media_item, delete_files: true)
-    end
-
-    test "can take additional attributes update media item" do
-      media_item = media_item_with_attachments()
-
-      assert {:ok, updated_media_item} = Media.delete_media_files(media_item, %{prevent_download: true})
-      assert updated_media_item.prevent_download
-    end
-  end
-
   describe "change_media_item/1" do
     test "change_media_item/1 returns a media_item changeset" do
       media_item = media_item_fixture()

test/pinchflat/metadata/nfo_builder_test.exs

@@ -2,10 +2,10 @@ defmodule Pinchflat.Metadata.NfoBuilderTest do
   use Pinchflat.DataCase
 
   alias Pinchflat.Metadata.NfoBuilder
-  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.Filesystem.FilesystemHelpers
 
   setup do
-    filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
+    filepath = FilesystemHelpers.generate_metadata_tmpfile(:json)
 
     on_exit(fn -> File.rm!(filepath) end)
 
@@ -30,21 +30,6 @@ defmodule Pinchflat.Metadata.NfoBuilderTest do
       assert String.contains?(nfo, ~S(<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>))
       assert String.contains?(nfo, "<title>#{metadata["title"]}</title>")
     end
-
-    test "escapes invalid characters", %{filepath: filepath} do
-      metadata = %{
-        "title" => "hello' & <world>",
-        "uploader" => "uploader",
-        "id" => "id",
-        "description" => "description",
-        "upload_date" => "20210101"
-      }
-
-      result = NfoBuilder.build_and_store_for_media_item(filepath, metadata)
-      nfo = File.read!(result)
-
-      assert String.contains?(nfo, "hello&#39; &amp; &lt;world&gt;")
-    end
   end
 
   describe "build_and_store_for_source/2" do
@@ -61,18 +46,5 @@ defmodule Pinchflat.Metadata.NfoBuilderTest do
       assert String.contains?(nfo, ~S(<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>))
       assert String.contains?(nfo, "<title>#{metadata["title"]}</title>")
     end
-
-    test "escapes invalid characters", %{filepath: filepath} do
-      metadata = %{
-        "title" => "hello' & <world>",
-        "description" => "description",
-        "id" => "id"
-      }
-
-      result = NfoBuilder.build_and_store_for_source(filepath, metadata)
-      nfo = File.read!(result)
-
-      assert String.contains?(nfo, "hello&#39; &amp; &lt;world&gt;")
-    end
   end
 end

test/pinchflat/notifications/command_runner_test.exs

@@ -1,65 +0,0 @@
-defmodule Pinchflat.Notifications.CommandRunnerTest do
-  use ExUnit.Case, async: true
-
-  alias Pinchflat.Notifications.CommandRunner, as: Runner
-
-  @original_executable Application.compile_env(:pinchflat, :apprise_executable)
-
-  setup do
-    on_exit(&reset_executable/0)
-  end
-
-  describe "run/2" do
-    test "returns :ok when the command succeeds" do
-      assert {:ok, _} = Runner.run("server_1", [])
-    end
-
-    test "includes the servers as the first argument" do
-      assert {:ok, output} = Runner.run(["server_1", "server_2"], [])
-
-      assert String.contains?(output, "server_1 server_2")
-    end
-
-    test "lets you pass a single server as a string" do
-      assert {:ok, output} = Runner.run("server_1", [])
-
-      assert String.contains?(output, "server_1")
-    end
-
-    test "passes all arguments to the command" do
-      assert {:ok, output} = Runner.run("server_1", ["--dry-run"])
-
-      assert String.contains?(output, "--dry-run")
-    end
-
-    test "returns the output when the command fails" do
-      wrap_executable("/bin/false", fn ->
-        assert {:error, ""} = Runner.run("server_1", [])
-      end)
-    end
-
-    test "returns a relevant error if no servers are provided" do
-      assert {:error, :no_servers} = Runner.run(nil, [])
-      assert {:error, :no_servers} = Runner.run("", [])
-      assert {:error, :no_servers} = Runner.run([], [])
-    end
-  end
-
-  describe "version/0" do
-    test "adds the version arg" do
-      assert {:ok, output} = Runner.version()
-
-      assert String.contains?(output, "--version")
-    end
-  end
-
-  defp wrap_executable(new_executable, fun) do
-    Application.put_env(:pinchflat, :apprise_executable, new_executable)
-    fun.()
-    reset_executable()
-  end
-
-  def reset_executable do
-    Application.put_env(:pinchflat, :apprise_executable, @original_executable)
-  end
-end