Bump version

* Format 'Scheduled At' in task table according to user's TZ

* Changed video preview layout to 1 column on all displays

* Made links in descriptions clickable

* Updated Copy JSON button to properly escape newline characters

README.md

@@ -131,9 +131,6 @@ You _must_ ensure the host directories you've mounted are writable by the user r
 > [!IMPORTANT]
 > It's not recommended to run the container as root. Doing so can create permission issues if other apps need to work with the downloaded media.
 
-> [!TIP]
-> If you need to run any command as root, you can run `su` from the container's shell as there is no password set for the root user.
-
 ### ADVANCED: Storing Pinchflat config directory on a network share
 
 As pointed out in [#137](https://github.com/kieraneglin/pinchflat/issues/137), SQLite doesn't like being run in WAL mode on network shares. If you're running Pinchflat on a network share, you can disable WAL mode by setting the `JOURNAL_MODE` environment variable to `delete`. This will make Pinchflat run in rollback journal mode which is less performant but should work on network shares.
@@ -155,7 +152,7 @@ If you change this setting and it works well for you, please leave a comment on
 | `ENABLE_IPV6`               | No        | `false`                   | Setting to _any_ non-blank value will enable IPv6                                                                               |
 | `JOURNAL_MODE`              | No        | `wal`                     | Set to `delete` if your config directory is stored on a network share (not recommended)                                         |
 | `TZ_DATA_DIR`               | No        | `/etc/elixir_tzdata_data` | The container path where the timezone database is stored                                                                        |
-| `BASE_ROUTE_PATH`           | No        | `/`                       | The base path for route generation. Useful when running behind certain reverse proxies                                          |
+| `BASE_ROUTE_PATH`           | No        | `/`                       | The base path for route generation. Useful when running behind certain reverse proxies, but prefix must be stripped.            |
 | `YT_DLP_WORKER_CONCURRENCY` | No        | `2`                       | The number of concurrent workers that use `yt-dlp` _per queue_. Set to 1 if you're getting IP limited, otherwise don't touch it |
 
 ## EFF donations

docker/selfhosted.Dockerfile

@@ -127,17 +127,6 @@ EXPOSE ${PORT}
 # Only copy the final release from the build stage
 COPY --from=builder /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.
-# The user could just run the whole container as root and bypass this anyway so
-# it's not a huge deal.
-# This removes the root password to allow users to assume root if needed. This is
-# preferrable to running the whole container as root so that the files/directories
-# created by the app aren't owned by root and are therefore easier for other users
-# and processes to interact with. If you want to just run the whole container as
-# root, use --user 0:0 or something.
-RUN passwd -d root
-
 HEALTHCHECK --interval=120s --start-period=10s \
   CMD curl --fail http://localhost:${PORT}/healthcheck || exit 1
 

lib/pinchflat/downloading/media_download_worker.ex

@@ -12,6 +12,7 @@ defmodule Pinchflat.Downloading.MediaDownloadWorker do
   alias Pinchflat.Tasks
   alias Pinchflat.Repo
   alias Pinchflat.Media
+  alias Pinchflat.Media.FileSyncing
   alias Pinchflat.Downloading.MediaDownloader
 
   alias Pinchflat.Lifecycle.UserScripts.CommandRunner, as: UserScriptRunner
@@ -85,6 +86,7 @@ defmodule Pinchflat.Downloading.MediaDownloadWorker do
             media_redownloaded_at: get_redownloaded_at(is_quality_upgrade)
           })
 
+        :ok = FileSyncing.delete_outdated_files(media_item, updated_media_item)
         run_user_script(:media_downloaded, updated_media_item)
 
         :ok

lib/pinchflat/downloading/media_retention_worker.ex

@@ -49,6 +49,8 @@ defmodule Pinchflat.Downloading.MediaRetentionWorker do
     end)
   end
 
+  # NOTE: Since this is a date and not a datetime, we can't add logic to have to-the-minute
+  # comparison like we can with retention periods. We can only compare to the day.
   defp delete_media_items_from_before_cutoff do
     deletable_media =
       MediaQuery.new()

lib/pinchflat/media/file_syncing.ex

@@ -0,0 +1,93 @@
+defmodule Pinchflat.Media.FileSyncing do
+  @moduledoc """
+  Functions for ensuring file state is accurately reflected in the database.
+  """
+
+  alias Pinchflat.Media
+  alias Pinchflat.Utils.MapUtils
+  alias Pinchflat.Media.MediaItem
+  alias Pinchflat.Utils.FilesystemUtils, as: FSUtils
+
+  @doc """
+  Deletes files that are no longer needed by a media item.
+
+  This means that if a media item has been updated, the old and new versions
+  can be passed and any files that are no longer needed will be deleted.
+
+  An example is a video that gets its quality upgraded and its name changes
+  between original download and re-download. The old file will exist on-disk
+  with the old name but the database entry will point to the new file. This
+  function can be used to delete the old file in this case.
+
+  Returns :ok
+  """
+  def delete_outdated_files(old_media_item, new_media_item) do
+    non_subtitle_keys = MediaItem.filepath_attributes() -- [:subtitle_filepaths]
+
+    old_non_subtitles = Map.take(old_media_item, non_subtitle_keys)
+    old_subtitles = MapUtils.from_nested_list(old_media_item.subtitle_filepaths)
+    new_non_subtitles = Map.take(new_media_item, non_subtitle_keys)
+    new_subtitles = MapUtils.from_nested_list(new_media_item.subtitle_filepaths)
+
+    handle_file_deletion(old_non_subtitles, new_non_subtitles)
+    handle_file_deletion(old_subtitles, new_subtitles)
+
+    :ok
+  end
+
+  @doc """
+  Nillifies any media item filepaths that don't exist on disk for a list of media items
+
+  returns [%MediaItem{}]
+  """
+  def sync_file_presence_on_disk(media_items) do
+    Enum.map(media_items, fn media_item ->
+      new_attributes = sync_media_item_files(media_item)
+      # Doing this one-by-one instead of batching since this process
+      # can take time and a batch could let MediaItem state get out of sync
+      {:ok, updated_media_item} = Media.update_media_item(media_item, new_attributes)
+
+      updated_media_item
+    end)
+  end
+
+  defp handle_file_deletion(old_attributes, new_attributes) do
+    # The logic:
+    #   - A file should only be deleted if it exists and the new file is different
+    #   - The new attributes are the ones we're interested in keeping
+    #   - If the old attributes have a key that doesn't exist in the new attributes, don't touch it.
+    #     This is good for archiving but may be unpopular for other users so this may change.
+
+    Enum.each(new_attributes, fn {key, new_filepath} ->
+      old_filepath = Map.get(old_attributes, key)
+      files_have_changed = old_filepath && new_filepath && old_filepath != new_filepath
+      files_exist_on_disk = files_have_changed && File.exists?(old_filepath) && File.exists?(new_filepath)
+
+      if files_exist_on_disk && !FSUtils.filepaths_reference_same_file?(old_filepath, new_filepath) do
+        FSUtils.delete_file_and_remove_empty_directories(old_filepath)
+      end
+    end)
+  end
+
+  defp sync_media_item_files(media_item) do
+    non_subtitle_keys = MediaItem.filepath_attributes() -- [:subtitle_filepaths]
+    subtitle_keys = MapUtils.from_nested_list(media_item.subtitle_filepaths)
+    non_subtitles = Map.take(media_item, non_subtitle_keys)
+
+    # This one is checking for the negative (ie: only update if the file doesn't exist)
+    new_non_subtitle_attrs =
+      Enum.reduce(non_subtitles, %{}, fn {key, filepath}, acc ->
+        if filepath && File.exists?(filepath), do: acc, else: Map.put(acc, key, nil)
+      end)
+
+    # This one is checking for the positive (ie: only update if the file exists)
+    # This is because subtitles, being an array type in the DB, are most easily updated
+    # by a full replacement rather than finding the actual diff
+    new_subtitle_attrs =
+      Enum.reduce(subtitle_keys, [], fn {key, filepath}, acc ->
+        if filepath && File.exists?(filepath), do: acc ++ [[key, filepath]], else: acc
+      end)
+
+    Map.put(new_non_subtitle_attrs, :subtitle_filepaths, new_subtitle_attrs)
+  end
+end

lib/pinchflat/media/file_syncing_worker.ex

@@ -0,0 +1,38 @@
+defmodule Pinchflat.Media.FileSyncingWorker do
+  @moduledoc false
+
+  use Oban.Worker,
+    queue: :local_data,
+    tags: ["sources", "local_data"]
+
+  alias __MODULE__
+  alias Pinchflat.Repo
+  alias Pinchflat.Tasks
+  alias Pinchflat.Sources
+  alias Pinchflat.Media.FileSyncing
+
+  @doc """
+  Starts the source file syncing worker.
+
+  Returns {:ok, %Task{}} | {:error, %Ecto.Changeset{}}
+  """
+  def kickoff_with_task(source, opts \\ []) do
+    %{id: source.id}
+    |> FileSyncingWorker.new(opts)
+    |> Tasks.create_job_with_task(source)
+  end
+
+  @doc """
+  Deletes a profile and optionally deletes its files
+
+  Returns :ok
+  """
+  @impl Oban.Worker
+  def perform(%Oban.Job{args: %{"id" => source_id}}) do
+    source = Repo.preload(Sources.get_source!(source_id), :media_items)
+
+    FileSyncing.sync_file_presence_on_disk(source.media_items)
+
+    :ok
+  end
+end

lib/pinchflat/media/media_query.ex

@@ -88,7 +88,7 @@ defmodule Pinchflat.Media.MediaQuery do
       [mi, source],
       fragment("""
         IFNULL(retention_period_days, 0) > 0 AND
-        DATETIME('now', '-' || retention_period_days || ' day') > media_downloaded_at
+        DATETIME(media_downloaded_at, '+' || retention_period_days || ' day') < DATETIME('now')
       """)
     )
   end
@@ -100,8 +100,8 @@ defmodule Pinchflat.Media.MediaQuery do
       # 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') > uploaded_at AND
-        DATETIME(media_downloaded_at, '-' || redownload_delay_days || ' day') < uploaded_at
+        DATE('now', '-' || redownload_delay_days || ' day') > DATE(uploaded_at) AND
+        DATE(media_downloaded_at, '-' || redownload_delay_days || ' day') < DATE(uploaded_at)
       """)
     )
   end

lib/pinchflat/sources/sources.ex

@@ -186,7 +186,13 @@ defmodule Pinchflat.Sources do
       {:ok, source_details} ->
         add_source_details_by_collection_type(source, changeset, source_details)
 
-      {:error, runner_error, _status_code} ->
+      err ->
+        runner_error =
+          case err do
+            {:error, error_msg, _status_code} -> error_msg
+            {:error, error_msg} -> error_msg
+          end
+
         Ecto.Changeset.add_error(
           changeset,
           :original_url,

lib/pinchflat/utils/filesystem_utils.ex

@@ -20,6 +20,24 @@ defmodule Pinchflat.Utils.FilesystemUtils do
     end
   end
 
+  @doc """
+  Checks if two filepaths reference the same file.
+
+  Useful if you have a relative and absolute filepath and want to be sure they're the same file.
+  Also works with symlinks.
+
+  Returns boolean()
+  """
+  def filepaths_reference_same_file?(filepath_1, filepath_2) do
+    {:ok, stat_1} = File.stat(filepath_1)
+    {:ok, stat_2} = File.stat(filepath_2)
+
+    identifier_1 = "#{stat_1.major_device}:#{stat_1.minor_device}:#{stat_1.inode}"
+    identifier_2 = "#{stat_2.major_device}:#{stat_2.minor_device}:#{stat_2.inode}"
+
+    identifier_1 == identifier_2
+  end
+
   @doc """
   Generates a temporary file and returns its path. The file is empty and has the given type.
   Generates all the directories in the path if they don't exist.

lib/pinchflat/utils/map_utils.ex

@@ -0,0 +1,17 @@
+defmodule Pinchflat.Utils.MapUtils do
+  @moduledoc """
+  Utility methods for working with maps
+  """
+
+  @doc """
+  Converts a nested list of 2-element tuples or lists into a map.
+
+  Returns map()
+  """
+  def from_nested_list(list) do
+    Enum.reduce(list, %{}, fn
+      [key, value], acc -> Map.put(acc, key, value)
+      {key, value}, acc -> Map.put(acc, key, value)
+    end)
+  end
+end

lib/pinchflat/yt_dlp/media_collection.ex

@@ -84,6 +84,7 @@ defmodule Pinchflat.YtDlp.MediaCollection do
          {:ok, parsed_json} <- Phoenix.json_library().decode(output) do
       {:ok, format_source_details(parsed_json)}
     else
+      {:error, %Jason.DecodeError{}} -> {:error, "Error decoding JSON response"}
       err -> err
     end
   end

lib/pinchflat_web/components/custom_components/text_components.ex

@@ -62,17 +62,24 @@ defmodule PinchflatWeb.CustomComponents.TextComponents do
   end
 
   @doc """
-  Renders a block of text with each line broken into a separate span.
+  Renders a block of text with each line broken into a separate span and links highlighted.
   """
   attr :text, :string, required: true
 
-  def break_on_newline(assigns) do
-    broken_text =
-      assigns.text
-      |> String.split("\n", trim: false)
-      |> Enum.intersperse(Phoenix.HTML.Tag.tag(:span, class: "inline-block mt-2"))
+  def render_description(assigns) do
+    formatted_text =
+      Regex.split(~r{https?://\S+}, assigns.text, include_captures: true)
+      |> Enum.map(fn
+        "http" <> _ = url ->
+          Phoenix.HTML.Tag.content_tag(:a, url, class: "text-blue-500 hover:text-blue-300", href: url, target: "_blank")
 
-    assigns = Map.put(assigns, :text, broken_text)
+        text ->
+          text
+          |> String.split("\n", trim: false)
+          |> Enum.intersperse(Phoenix.HTML.Tag.tag(:span, class: "inline-block mt-2"))
+      end)
+
+    assigns = Map.put(assigns, :text, formatted_text)
 
     ~H"""
     <span><%= @text %></span>

lib/pinchflat_web/components/layouts.ex

@@ -64,7 +64,7 @@ defmodule PinchflatWeb.Layouts do
           <.icon name={@icon} /> <%= @text %>
         </span>
         <span class="text-bodydark2">
-          <.icon name="hero-chevron-up" x-bind:class="{ 'rotate-180': selected }" />
+          <.icon name="hero-chevron-down" x-bind:class="{ 'rotate-180': selected }" />
         </span>
       </span>
 

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

@@ -2,7 +2,7 @@
   <:option>
     <span x-data="{ copied: false }" x-on:click={~s"
         copyWithCallbacks(
-          `#{Jason.Formatter.pretty_print(Phoenix.json_library().encode!(@media_item))}`, 
+          String.raw`#{Jason.Formatter.pretty_print(Phoenix.json_library().encode!(@media_item))}`,
           () => copied = true, 
           () => copied = false
         )

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

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

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

@@ -26,11 +26,12 @@
       <:tab title="Media" id="media">
         <div class="flex flex-col gap-10 dark:text-white">
           <%= if media_file_exists?(@media_item) do %>
-            <section class="grid grid-cols-1 xl:grid-cols-2 xl:gap-6 mt-6">
+            <section class="grid grid-cols-1 xl:gap-6 mt-6">
               <div>
                 <.media_preview media_item={@media_item} />
               </div>
-              <aside class="mt-4 xl:mt-0">
+              <aside class="mt-4">
+                <h2 class="text-xl mb-2"><%= @media_item.title %></h2>
                 <div>Uploaded: <%= DateTime.to_date(@media_item.uploaded_at) %></div>
                 <div>
                   <span :if={URI.parse(@media_item.original_url).scheme =~ "http"}>
@@ -44,7 +45,7 @@
                   </span>
                 </div>
                 <div :if={@media_item.description} class="mt-4 text-bodydark">
-                  <.break_on_newline text={@media_item.description} />
+                  <.render_description text={@media_item.description} />
                 </div>
               </aside>
             </section>
@@ -70,7 +71,7 @@
               <%= task.job.state %>
             </:col>
             <:col :let={task} label="Scheduled At">
-              <%= Calendar.strftime(task.job.scheduled_at, "%y-%m-%d %I:%M:%S %p %Z") %>
+              <.datetime_in_zone datetime={task.job.scheduled_at} />
             </:col>
           </.table>
         <% else %>

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

@@ -2,7 +2,7 @@
   <:option>
     <span x-data="{ copied: false }" x-on:click={~s"
         copyWithCallbacks(
-          `#{Jason.Formatter.pretty_print(Phoenix.json_library().encode!(@media_profile))}`, 
+          String.raw`#{Jason.Formatter.pretty_print(Phoenix.json_library().encode!(@media_profile))}`,
           () => copied = true, 
           () => copied = false
         )

lib/pinchflat_web/controllers/sources/source_controller.ex

@@ -8,6 +8,7 @@ defmodule PinchflatWeb.Sources.SourceController do
   alias Pinchflat.Sources.Source
   alias Pinchflat.Media.MediaItem
   alias Pinchflat.Profiles.MediaProfile
+  alias Pinchflat.Media.FileSyncingWorker
   alias Pinchflat.Sources.SourceDeletionWorker
   alias Pinchflat.Downloading.DownloadingHelpers
   alias Pinchflat.SlowIndexing.SlowIndexingHelpers
@@ -175,6 +176,15 @@ defmodule PinchflatWeb.Sources.SourceController do
     )
   end
 
+  def sync_files_on_disk(conn, %{"source_id" => id}) do
+    wrap_forced_action(
+      conn,
+      id,
+      "File sync enqueued.",
+      &FileSyncingWorker.kickoff_with_task/1
+    )
+  end
+
   defp wrap_forced_action(conn, source_id, message, fun) do
     source = Sources.get_source!(source_id)
     fun.(source)

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

@@ -17,7 +17,7 @@
   <:option>
     <span x-data="{ copied: false }" x-on:click={~s"
         copyWithCallbacks(
-          `#{Jason.Formatter.pretty_print(Phoenix.json_library().encode!(@source))}`, 
+          String.raw`#{Jason.Formatter.pretty_print(Phoenix.json_library().encode!(@source))}`,
           () => copied = true, 
           () => copied = false
         )
@@ -38,7 +38,7 @@
     <.link
       href={~p"/sources/#{@source}/force_download_pending"}
       method="post"
-      data-confirm="Are you sure you want to force a download of all *pending* media items? This isn't normally needed."
+      data-confirm="Are you sure you want to force a download of all pending media items? This isn't normally needed."
     >
       Download Pending
     </.link>
@@ -47,7 +47,7 @@
     <.link
       href={~p"/sources/#{@source}/force_redownload"}
       method="post"
-      data-confirm="Are you sure you want to re-download all currently downloaded media items? This isn't normally needed and won't change anything if the files already exist."
+      data-confirm="Are you sure you want to re-download all currently downloaded media items? This doesn't upgrade your media, but will download any missing files if your settings have changed. This isn't normally needed."
     >
       Redownload Existing
     </.link>
@@ -70,6 +70,15 @@
       Refresh Metadata
     </.link>
   </:option>
+  <:option>
+    <.link
+      href={~p"/sources/#{@source}/sync_files_on_disk"}
+      method="post"
+      data-confirm="Are you sure you want to sync files? This will update media items if their files have been deleted. File addition or moves are not detected. This isn't normally needed."
+    >
+      Sync Files on Disk
+    </.link>
+  </:option>
   <:option>
     <div class="h-px w-full bg-bodydark2"></div>
   </:option>

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

@@ -67,7 +67,7 @@
               <%= task.job.state %>
             </:col>
             <:col :let={task} label="Scheduled At">
-              <%= Calendar.strftime(task.job.scheduled_at, "%y-%m-%d %I:%M:%S %p %Z") %>
+              <.datetime_in_zone datetime={task.job.scheduled_at} />
             </:col>
           </.table>
         <% else %>

lib/pinchflat_web/router.ex

@@ -40,6 +40,7 @@ defmodule PinchflatWeb.Router do
       post "/force_redownload", Sources.SourceController, :force_redownload
       post "/force_index", Sources.SourceController, :force_index
       post "/force_metadata_refresh", Sources.SourceController, :force_metadata_refresh
+      post "/sync_files_on_disk", Sources.SourceController, :sync_files_on_disk
 
       resources "/media", MediaItems.MediaItemController, only: [:show, :edit, :update, :delete] do
         post "/force_download", MediaItems.MediaItemController, :force_download

mix.exs

@@ -4,7 +4,7 @@ defmodule Pinchflat.MixProject do
   def project do
     [
       app: :pinchflat,
-      version: "2024.9.12",
+      version: "2024.10.25",
       elixir: "~> 1.17",
       elixirc_paths: elixirc_paths(Mix.env()),
       start_permanent: Mix.env() == :prod,

mix.lock

@@ -61,7 +61,7 @@
   "telemetry_metrics": {:hex, :telemetry_metrics, "0.6.2", "2caabe9344ec17eafe5403304771c3539f3b6e2f7fb6a6f602558c825d0d0bfb", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "9b43db0dc33863930b9ef9d27137e78974756f5f198cae18409970ed6fa5b561"},
   "telemetry_poller": {:hex, :telemetry_poller, "1.0.0", "db91bb424e07f2bb6e73926fcafbfcbcb295f0193e0a00e825e589a0a47e8453", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b3a24eafd66c3f42da30fc3ca7dda1e9d546c12250a2d60d7b81d264fbec4f6e"},
   "timex": {:hex, :timex, "3.7.11", "bb95cb4eb1d06e27346325de506bcc6c30f9c6dea40d1ebe390b262fad1862d1", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.20", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 1.1", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "8b9024f7efbabaf9bd7aa04f65cf8dcd7c9818ca5737677c7b76acbc6a94d1aa"},
-  "tzdata": {:hex, :tzdata, "1.1.1", "20c8043476dfda8504952d00adac41c6eda23912278add38edc140ae0c5bcc46", [:mix], [{:hackney, "~> 1.17", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "a69cec8352eafcd2e198dea28a34113b60fdc6cb57eb5ad65c10292a6ba89787"},
+  "tzdata": {:hex, :tzdata, "1.1.2", "45e5f1fcf8729525ec27c65e163be5b3d247ab1702581a94674e008413eef50b", [:mix], [{:hackney, "~> 1.17", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "cec7b286e608371602318c414f344941d5eb0375e14cfdab605cca2fe66cba8b"},
   "unicode_util_compat": {:hex, :unicode_util_compat, "0.7.0", "bc84380c9ab48177092f43ac89e4dfa2c6d62b40b8bd132b1059ecc7232f9a78", [:rebar3], [], "hexpm", "25eee6d67df61960cf6a794239566599b09e17e668d3700247bc498638152521"},
   "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
   "websock_adapter": {:hex, :websock_adapter, "0.5.7", "65fa74042530064ef0570b75b43f5c49bb8b235d6515671b3d250022cb8a1f9e", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "d0f478ee64deddfec64b800673fd6e0c8888b079d9f3444dd96d2a98383bdbd1"},

test/pinchflat/downloading/media_download_worker_test.exs

@@ -236,6 +236,26 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
 
       perform_job(MediaDownloadWorker, %{id: media_item.id, force: true})
     end
+
+    test "deletes old files if the media item has been updated" do
+      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl ->
+        tmp_media_item = media_item_with_attachments()
+        metadata = render_parsed_metadata(:media_metadata)
+        metadata = Map.put(metadata, "filepath", tmp_media_item.media_filepath)
+
+        {:ok, Phoenix.json_library().encode!(metadata)}
+      end)
+
+      expect(YtDlpRunnerMock, :run, 1, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+
+      old_media_item = media_item_with_attachments()
+      perform_job(MediaDownloadWorker, %{id: old_media_item.id, force: true})
+      updated_media_item = Repo.reload(old_media_item)
+
+      assert updated_media_item.media_filepath != old_media_item.media_filepath
+      refute File.exists?(old_media_item.media_filepath)
+      assert File.exists?(updated_media_item.media_filepath)
+    end
   end
 
   describe "perform/1 when testing user script callbacks" do

test/pinchflat/downloading/media_retention_worker_test.exs

@@ -46,6 +46,23 @@ defmodule Pinchflat.Downloading.MediaRetentionWorkerTest do
       refute Repo.reload!(old_media_item).media_filepath
     end
 
+    test "deletes media files that are on their retention date per the 24-h clock" do
+      {_source, old_media_item, new_media_item} = prepare_records_for_retention_date(2)
+
+      just_over_two_days_ago = now_minus(2, :days) |> DateTime.add(-1, :minute)
+      just_under_two_days_ago = now_minus(2, :days) |> DateTime.add(1, :minute)
+
+      Media.update_media_item(old_media_item, %{media_downloaded_at: just_over_two_days_ago})
+      Media.update_media_item(new_media_item, %{media_downloaded_at: just_under_two_days_ago})
+
+      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 culled_at and prevent_download" do
       {_source, old_media_item, new_media_item} = prepare_records_for_retention_date()
 
@@ -106,6 +123,25 @@ defmodule Pinchflat.Downloading.MediaRetentionWorkerTest do
       refute Repo.reload!(old_media_item).media_filepath
     end
 
+    # NOTE: Since this is a date and not a datetime, we can't add logic to have to-the-minute
+    # comparison like we can with retention periods. We can only compare to the day.
+    test "doesn't cull media from on or after the cutoff date" do
+      {_source, old_media_item, new_media_item} = prepare_records_for_source_cutoff_date(2)
+
+      Media.update_media_item(old_media_item, %{uploaded_at: now_minus(2, :days)})
+      Media.update_media_item(new_media_item, %{uploaded_at: now_minus(1, :day)})
+
+      perform_job(MediaRetentionWorker, %{})
+
+      assert File.exists?(new_media_item.media_filepath)
+      assert File.exists?(old_media_item.media_filepath)
+      assert Repo.reload!(new_media_item).media_filepath
+      assert Repo.reload!(old_media_item).media_filepath
+
+      refute Repo.reload!(new_media_item).culled_at
+      refute Repo.reload!(old_media_item).culled_at
+    end
+
     test "sets culled_at but not prevent_download" do
       {_source, old_media_item, new_media_item} = prepare_records_for_source_cutoff_date()
 
@@ -131,23 +167,6 @@ defmodule Pinchflat.Downloading.MediaRetentionWorkerTest do
       refute Repo.reload!(old_media_item).culled_at
     end
 
-    test "doesn't cull media from on or after the cutoff date" do
-      {_source, old_media_item, new_media_item} = prepare_records_for_source_cutoff_date(2)
-
-      Media.update_media_item(old_media_item, %{uploaded_at: now_minus(2, :days)})
-      Media.update_media_item(new_media_item, %{uploaded_at: now_minus(1, :day)})
-
-      perform_job(MediaRetentionWorker, %{})
-
-      assert File.exists?(new_media_item.media_filepath)
-      assert File.exists?(old_media_item.media_filepath)
-      assert Repo.reload!(new_media_item).media_filepath
-      assert Repo.reload!(old_media_item).media_filepath
-
-      refute Repo.reload!(new_media_item).culled_at
-      refute Repo.reload!(old_media_item).culled_at
-    end
-
     test "doesn't cull media items that have prevent_culling set" do
       {_source, old_media_item, _new_media_item} = prepare_records_for_source_cutoff_date()
 

test/pinchflat/media/file_syncing_test.exs

@@ -0,0 +1,122 @@
+defmodule Pinchflat.Media.FileSyncingTest do
+  use Pinchflat.DataCase
+
+  import Pinchflat.MediaFixtures
+
+  alias Pinchflat.Media.FileSyncing
+
+  describe "delete_outdated_files/2" do
+    test "deletes outdated non-subtitle files" do
+      new_media_item = media_item_with_attachments()
+      old_media_item = media_item_with_attachments()
+
+      assert :ok = FileSyncing.delete_outdated_files(old_media_item, new_media_item)
+
+      assert File.exists?(new_media_item.media_filepath)
+      refute File.exists?(old_media_item.media_filepath)
+    end
+
+    test "doesn't delete non-subtitle files if the new file is the same" do
+      new_media_item = media_item_with_attachments()
+      old_media_item = media_item_fixture(%{media_filepath: new_media_item.media_filepath})
+
+      assert :ok = FileSyncing.delete_outdated_files(old_media_item, new_media_item)
+
+      assert File.exists?(new_media_item.media_filepath)
+      assert File.exists?(old_media_item.media_filepath)
+    end
+
+    test "doesn't delete the old file if the new file is missing that key" do
+      new_media_item = media_item_fixture(%{media_filepath: nil})
+      old_media_item = media_item_with_attachments()
+
+      assert :ok = FileSyncing.delete_outdated_files(old_media_item, new_media_item)
+
+      assert File.exists?(old_media_item.media_filepath)
+    end
+
+    test "deletes outdated subtitle files" do
+      new_media_item = media_item_with_attachments()
+      old_media_item = media_item_with_attachments()
+
+      assert :ok = FileSyncing.delete_outdated_files(old_media_item, new_media_item)
+
+      assert File.exists?(get_subtitle_filepath(new_media_item, "en"))
+      refute File.exists?(get_subtitle_filepath(old_media_item, "en"))
+    end
+
+    test "keeps old subtitle files if the new file is the same" do
+      new_media_item = media_item_with_attachments()
+      old_media_item = media_item_fixture(%{subtitle_filepaths: new_media_item.subtitle_filepaths})
+
+      assert :ok = FileSyncing.delete_outdated_files(old_media_item, new_media_item)
+
+      assert File.exists?(get_subtitle_filepath(new_media_item, "en"))
+      assert File.exists?(get_subtitle_filepath(old_media_item, "en"))
+    end
+
+    test "doesn't delete old subtitle files if the new file is missing that key" do
+      new_media_item = media_item_fixture(%{subtitle_filepaths: []})
+      old_media_item = media_item_with_attachments()
+
+      assert :ok = FileSyncing.delete_outdated_files(old_media_item, new_media_item)
+
+      assert File.exists?(get_subtitle_filepath(old_media_item, "en"))
+    end
+  end
+
+  describe "sync_file_presence_on_disk/1" do
+    test "removes attributes whose files are missing" do
+      media_item = media_item_fixture(%{media_filepath: "/tmp/missing_file.mp4"})
+
+      assert media_item.media_filepath
+      assert [updated_media_item] = FileSyncing.sync_file_presence_on_disk([media_item])
+      refute updated_media_item.media_filepath
+    end
+
+    test "doesn't remove attributes where the files still exist" do
+      media_item = media_item_with_attachments()
+
+      assert media_item.media_filepath
+      assert [updated_media_item] = FileSyncing.sync_file_presence_on_disk([media_item])
+      assert updated_media_item.media_filepath
+    end
+
+    test "doesn't touch other attributes if some are missing and some aren't" do
+      media_item = media_item_with_attachments()
+      File.rm(media_item.media_filepath)
+
+      assert media_item.thumbnail_filepath
+      assert media_item.media_filepath
+      assert [updated_media_item] = FileSyncing.sync_file_presence_on_disk([media_item])
+      assert updated_media_item.thumbnail_filepath
+      refute updated_media_item.media_filepath
+    end
+
+    test "removes subtitle files that are missing" do
+      media_item = media_item_fixture(%{subtitle_filepaths: [["en", "/tmp/missing_file.srt"]]})
+
+      assert get_subtitle_filepath(media_item, "en")
+      assert [updated_media_item] = FileSyncing.sync_file_presence_on_disk([media_item])
+      refute get_subtitle_filepath(updated_media_item, "en")
+    end
+
+    test "doesn't remove subtitle files that still exist" do
+      media_item = media_item_with_attachments()
+
+      assert get_subtitle_filepath(media_item, "en")
+      assert [updated_media_item] = FileSyncing.sync_file_presence_on_disk([media_item])
+      assert get_subtitle_filepath(updated_media_item, "en")
+    end
+  end
+
+  defp get_subtitle_filepath(media_item, language) do
+    Enum.reduce_while(media_item.subtitle_filepaths, nil, fn [lang, filepath], acc ->
+      if lang == language do
+        {:halt, filepath}
+      else
+        {:cont, acc}
+      end
+    end)
+  end
+end

test/pinchflat/media/file_syncing_worker_test.exs

@@ -0,0 +1,37 @@
+defmodule Pinchflat.Media.FileSyncingWorkerTest do
+  use Pinchflat.DataCase
+
+  import Pinchflat.MediaFixtures
+  import Pinchflat.SourcesFixtures
+
+  alias Pinchflat.Media.FileSyncingWorker
+
+  describe "kickoff_with_task/3" do
+    test "starts the worker" do
+      source = source_fixture()
+
+      assert [] = all_enqueued(worker: FileSyncingWorker)
+      assert {:ok, _} = FileSyncingWorker.kickoff_with_task(source)
+      assert [_] = all_enqueued(worker: FileSyncingWorker)
+    end
+
+    test "attaches a task" do
+      source = source_fixture()
+
+      assert {:ok, task} = FileSyncingWorker.kickoff_with_task(source)
+      assert task.source_id == source.id
+    end
+  end
+
+  describe "perform/1" do
+    test "syncs file presence on disk" do
+      source = source_fixture()
+      media_item = media_item_fixture(%{media_filepath: "/tmp/missing.mp4", source_id: source.id})
+
+      perform_job(FileSyncingWorker, %{"id" => source.id})
+      updated_media_item = Repo.reload!(media_item)
+
+      refute updated_media_item.media_filepath
+    end
+  end
+end

test/pinchflat/media_test.exs

@@ -441,6 +441,13 @@ defmodule Pinchflat.MediaTest do
       assert Media.pending_download?(media_item)
     end
 
+    test "returns true if the cutoff date is equal to the upload date" do
+      source = source_fixture(%{download_cutoff_date: now_minus(2, :days)})
+      media_item = media_item_fixture(%{source_id: source.id, media_filepath: nil, uploaded_at: now_minus(2, :days)})
+
+      assert Media.pending_download?(media_item)
+    end
+
     test "returns false if there is a cutoff date after the media's upload date" do
       source = source_fixture(%{download_cutoff_date: now_minus(1, :day)})
       media_item = media_item_fixture(%{source_id: source.id, media_filepath: nil, uploaded_at: now_minus(2, :days)})

test/pinchflat/sources_test.exs

@@ -147,6 +147,18 @@ defmodule Pinchflat.SourcesTest do
       assert "could not fetch source details from URL" in errors_on(changeset).original_url
     end
 
+    test "adds an error if the runner succeeds but the result was invalid JSON" do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, "Not JSON"} end)
+
+      valid_attrs = %{
+        media_profile_id: media_profile_fixture().id,
+        original_url: "https://www.youtube.com/channel/abc123"
+      }
+
+      assert {:error, %Ecto.Changeset{} = changeset} = Sources.create_source(valid_attrs)
+      assert "could not fetch source details from URL" in errors_on(changeset).original_url
+    end
+
     test "you can specify a custom custom_name" do
       expect(YtDlpRunnerMock, :run, &channel_mock/4)
 

test/pinchflat/utils/filesystem_utils_test.exs

@@ -37,6 +37,46 @@ defmodule Pinchflat.Utils.FilesystemUtilsTest do
     end
   end
 
+  describe "filepaths_reference_same_file?/2" do
+    setup do
+      filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
+
+      on_exit(fn -> File.rm!(filepath) end)
+
+      {:ok, %{filepath: filepath}}
+    end
+
+    test "returns true if the files are the same", %{filepath: filepath} do
+      assert FilesystemUtils.filepaths_reference_same_file?(filepath, filepath)
+    end
+
+    test "returns true if different filepaths point to the same file", %{filepath: filepath} do
+      short_path = Path.expand(filepath)
+      long_path = Path.join(["/tmp", "..", filepath])
+
+      assert short_path != long_path
+      assert FilesystemUtils.filepaths_reference_same_file?(short_path, long_path)
+    end
+
+    test "returns true if the files are symlinked", %{filepath: filepath} do
+      tmpfile_directory = Application.get_env(:pinchflat, :tmpfile_directory)
+      other_filepath = Path.join([tmpfile_directory, "symlink.json"])
+      :ok = File.ln_s!(filepath, other_filepath)
+
+      assert FilesystemUtils.filepaths_reference_same_file?(filepath, other_filepath)
+
+      File.rm!(other_filepath)
+    end
+
+    test "returns false if the files are different", %{filepath: filepath} do
+      other_filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
+
+      refute FilesystemUtils.filepaths_reference_same_file?(filepath, other_filepath)
+
+      File.rm!(other_filepath)
+    end
+  end
+
   describe "generate_metadata_tmpfile/1" do
     test "creates a tmpfile and returns its path" do
       res = FilesystemUtils.generate_metadata_tmpfile(:json)

test/pinchflat/utils/map_utils_test.exs

@@ -0,0 +1,31 @@
+defmodule Pinchflat.Utils.MapUtilsTest do
+  use Pinchflat.DataCase
+
+  alias Pinchflat.Utils.MapUtils
+
+  describe "from_nested_list/1" do
+    test "creates a map from a nested 2-element tuple list" do
+      list = [
+        {"key1", "value1"},
+        {"key2", "value2"}
+      ]
+
+      assert MapUtils.from_nested_list(list) == %{
+               "key1" => "value1",
+               "key2" => "value2"
+             }
+    end
+
+    test "creates a map from a nested 2-element list of lists" do
+      list = [
+        ["key1", "value1"],
+        ["key2", "value2"]
+      ]
+
+      assert MapUtils.from_nested_list(list) == %{
+               "key1" => "value1",
+               "key2" => "value2"
+             }
+    end
+  end
+end

test/pinchflat/yt_dlp/media_collection_test.exs

@@ -133,7 +133,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
     test "returns an error if the output is not JSON" do
       expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts -> {:ok, "Not JSON"} end)
 
-      assert {:error, %Jason.DecodeError{}} = MediaCollection.get_source_details(@channel_url)
+      assert {:error, "Error decoding JSON response"} = MediaCollection.get_source_details(@channel_url)
     end
   end
 

test/pinchflat_web/controllers/source_controller_test.exs

@@ -7,6 +7,7 @@ defmodule PinchflatWeb.SourceControllerTest do
 
   alias Pinchflat.Repo
   alias Pinchflat.Settings
+  alias Pinchflat.Media.FileSyncingWorker
   alias Pinchflat.Sources.SourceDeletionWorker
   alias Pinchflat.Downloading.MediaDownloadWorker
   alias Pinchflat.Metadata.SourceMetadataStorageWorker
@@ -268,6 +269,23 @@ defmodule PinchflatWeb.SourceControllerTest do
     end
   end
 
+  describe "sync_files_on_disk" do
+    test "forces a file sync", %{conn: conn} do
+      source = source_fixture()
+
+      assert [] = all_enqueued(worker: FileSyncingWorker)
+      post(conn, ~p"/sources/#{source.id}/sync_files_on_disk")
+      assert [_] = all_enqueued(worker: FileSyncingWorker)
+    end
+
+    test "redirects to the source page", %{conn: conn} do
+      source = source_fixture()
+
+      conn = post(conn, ~p"/sources/#{source.id}/sync_files_on_disk")
+      assert redirected_to(conn) == ~p"/sources/#{source.id}"
+    end
+  end
+
   defp create_source(_) do
     source = source_fixture()
     media_item = media_item_with_attachments(%{source_id: source.id})

test/support/files/subtitle.srt

@@ -0,0 +1,36 @@
+1
+00:00:00,000 --> 00:00:02,500
+Welcome to the Example Subtitle File!
+
+2
+00:00:03,000 --> 00:00:06,000
+This is a demonstration of SRT subtitles.
+
+3
+00:00:07,000 --> 00:00:10,500
+You can use SRT files to add subtitles to your videos.
+
+4
+00:00:12,000 --> 00:00:15,000
+Each subtitle entry consists of a number, a timecode,
+and the subtitle text.
+
+5
+00:00:16,000 --> 00:00:20,000
+The timecode format is hours:minutes:seconds,milliseconds.
+
+6
+00:00:21,000 --> 00:00:25,000
+You can adjust the timing to match your video.
+
+7
+00:00:26,000 --> 00:00:30,000
+Make sure the subtitle text is clear and readable.
+
+8
+00:00:31,000 --> 00:00:35,000
+And that's how you create an SRT subtitle file!
+
+9
+00:00:36,000 --> 00:00:40,000
+Enjoy adding subtitles to your videos!

test/support/fixtures/media_fixtures.ex

@@ -73,16 +73,19 @@ defmodule Pinchflat.MediaFixtures do
         "#{:rand.uniform(1_000_000)}"
       ])
 
-    stored_media_filepath = Path.join(base_dir, "#media.mp4")
+    stored_media_filepath = Path.join(base_dir, "media.mp4")
     thumbnail_filepath = Path.join(base_dir, "thumbnail.jpg")
+    subtitle_filepath = Path.join(base_dir, "subtitle.en.srt")
 
     FilesystemUtils.cp_p!(media_filepath_fixture(), stored_media_filepath)
     FilesystemUtils.cp_p!(thumbnail_filepath_fixture(), thumbnail_filepath)
+    FilesystemUtils.cp_p!(subtitle_filepath_fixture(), subtitle_filepath)
 
     merged_attrs =
       Map.merge(attrs, %{
         media_filepath: stored_media_filepath,
-        thumbnail_filepath: thumbnail_filepath
+        thumbnail_filepath: thumbnail_filepath,
+        subtitle_filepaths: [["en", subtitle_filepath]]
       })
 
     media_item_fixture(merged_attrs)
@@ -124,6 +127,16 @@ defmodule Pinchflat.MediaFixtures do
     ])
   end
 
+  def subtitle_filepath_fixture do
+    Path.join([
+      File.cwd!(),
+      "test",
+      "support",
+      "files",
+      "subtitle.srt"
+    ])
+  end
+
   def infojson_filepath_fixture do
     Path.join([
       File.cwd!(),