[Enhancement] Add media count to sources page (#251)

* [WIP] Got query kinda working, now to refactor other queries

* Refactored all query methods to use dynamic snippets

* Refactored tab layout to grab tabs by name

* Removed standalone show buttons from in-app tables

* Removed unneeded comment

lib/pinchflat/downloading/downloading_helpers.ex

@@ -85,10 +85,16 @@ defmodule Pinchflat.Downloading.DownloadingHelpers do
   """
   def kickoff_redownload_for_existing_media(%Source{} = source) do
     MediaQuery.new()
-    |> MediaQuery.for_source(source)
-    |> MediaQuery.with_media_downloaded_at()
-    |> MediaQuery.where_download_not_prevented()
-    |> MediaQuery.where_not_culled()
+    |> MediaQuery.require_assoc(:media_profile)
+    |> where(
+      ^dynamic(
+        [m, s, mp],
+        ^MediaQuery.for_source(source) and
+          ^MediaQuery.downloaded() and
+          not (^MediaQuery.download_prevented()) and
+          not (^MediaQuery.culled())
+      )
+    )
     |> Repo.all()
     |> Enum.map(&MediaDownloadWorker.kickoff_with_task/1)
   end

lib/pinchflat/fast_indexing/fast_indexing_helpers.ex

@@ -49,8 +49,7 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpers do
 
   defp list_media_items_by_media_id_for(source, media_ids) do
     MediaQuery.new()
-    |> MediaQuery.for_source(source)
-    |> MediaQuery.with_media_ids(media_ids)
+    |> where(^dynamic([mi], ^MediaQuery.for_source(source) and mi.media_id in ^media_ids))
     |> Repo.all()
   end
 

lib/pinchflat/lifecycle/notifications/source_notifications.ex

@@ -63,15 +63,14 @@ defmodule Pinchflat.Lifecycle.Notifications.SourceNotifications do
 
   defp pending_media_item_count(source) do
     MediaQuery.new()
-    |> MediaQuery.for_source(source)
-    |> MediaQuery.where_pending_download()
+    |> MediaQuery.require_assoc(:media_profile)
+    |> where(^dynamic(^MediaQuery.for_source(source) and ^MediaQuery.pending()))
     |> Repo.aggregate(:count)
   end
 
   defp downloaded_media_item_count(source) do
     MediaQuery.new()
-    |> MediaQuery.for_source(source)
-    |> MediaQuery.with_media_filepath()
+    |> where(^dynamic(^MediaQuery.for_source(source) and ^MediaQuery.downloaded()))
     |> Repo.aggregate(:count)
   end
 

lib/pinchflat/media/media.ex

@@ -32,9 +32,8 @@ defmodule Pinchflat.Media do
   """
   def list_cullable_media_items do
     MediaQuery.new()
-    |> MediaQuery.with_media_filepath()
-    |> MediaQuery.where_past_retention_period()
-    |> MediaQuery.where_culling_not_prevented()
+    |> MediaQuery.require_assoc(:source)
+    |> where(^MediaQuery.cullable())
     |> Repo.all()
   end
 
@@ -54,18 +53,14 @@ defmodule Pinchflat.Media do
   """
   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()
+    |> MediaQuery.require_assoc(:media_profile)
+    |> where(^MediaQuery.redownloadable())
     |> 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
+  pending means the media_item satisfies `MediaQuery.pending`. You
   should really check out that function if you need to know more
   because it has a lot going on.
 
@@ -73,15 +68,14 @@ defmodule Pinchflat.Media do
   """
   def list_pending_media_items_for(%Source{} = source) do
     MediaQuery.new()
-    |> MediaQuery.for_source(source)
-    |> MediaQuery.where_pending_download()
+    |> MediaQuery.require_assoc(:media_profile)
+    |> where(^dynamic(^MediaQuery.for_source(source) and ^MediaQuery.pending()))
     |> Repo.all()
   end
 
   @doc """
   For a given media_item, tells you if it is pending download. This is defined as
-  the media_item having a `media_filepath` of `nil` and matching the format selection
-  rules of the parent media_profile.
+  the media_item satisfying `MediaQuery.pending` which you should really check out.
 
   Intentionally does not take the `download_media` setting of the source into account.
 
@@ -91,8 +85,8 @@ defmodule Pinchflat.Media do
     media_item = Repo.preload(media_item, source: :media_profile)
 
     MediaQuery.new()
-    |> MediaQuery.with_id(media_item.id)
-    |> MediaQuery.where_pending_download()
+    |> MediaQuery.require_assoc(:media_profile)
+    |> where(^dynamic([m, s, mp], m.id == ^media_item.id and ^MediaQuery.pending()))
     |> Repo.exists?()
   end
 

lib/pinchflat/media/media_item.ex

@@ -142,8 +142,7 @@ defmodule Pinchflat.Media.MediaItem do
 
     current_max =
       MediaQuery.new()
-      |> MediaQuery.for_source(source_id)
-      |> MediaQuery.where_uploaded_on_date(changes.upload_date)
+      |> where(^dynamic([mi], mi.upload_date == ^changes.upload_date and ^MediaQuery.for_source(source)))
       |> Repo.aggregate(aggregator, :upload_date_index)
 
     case current_max do

lib/pinchflat/media/media_query.ex

@@ -23,138 +23,26 @@ defmodule Pinchflat.Media.MediaQuery do
     end
   end
 
-  # Prefixes:
-  # - for_* - belonging to a certain record
-  # - join_* - for joining on a certain record
-  # - with_*, where_* - 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
-
-  # NOTE: that dyanmic query approach kinda rocked - should refactor in future
-
   def new do
     MediaItem
   end
 
-  def for_source(query, source_id) when is_integer(source_id) do
-    where(query, [mi], mi.source_id == ^source_id)
+  def for_source(source_id) when is_integer(source_id), do: dynamic([mi], mi.source_id == ^source_id)
+  def for_source(source), do: dynamic([mi], mi.source_id == ^source.id)
+
+  def downloaded, do: dynamic([mi], not is_nil(mi.media_filepath))
+  def download_prevented, do: dynamic([mi], mi.prevent_download == true)
+  def culling_prevented, do: dynamic([mi], mi.prevent_culling == true)
+  def culled, do: dynamic([mi], not is_nil(mi.culled_at))
+  def redownloaded, do: dynamic([mi], not is_nil(mi.media_redownloaded_at))
+
+  def upload_date_after_source_cutoff do
+    dynamic([mi, source], is_nil(source.download_cutoff_date) or mi.upload_date >= source.download_cutoff_date)
   end
 
-  def for_source(query, source) 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
-
-  def with_media_ids(query, media_ids) 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
-
-  def with_no_media_filepath(query) do
-    where(query, [mi], is_nil(mi.media_filepath))
-  end
-
-  def with_upload_date_after_source_cutoff(query) do
-    query
-    |> require_assoc(:source)
-    |> where([mi, source], is_nil(source.download_cutoff_date) or mi.upload_date >= source.download_cutoff_date)
-  end
-
-  def where_uploaded_on_date(query, date) do
-    where(query, [mi], mi.upload_date == ^date)
-  end
-
-  def where_download_not_prevented(query) do
-    where(query, [mi], mi.prevent_download == false)
-  end
-
-  def matching_source_title_regex(query) do
-    query
-    |> 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
-
-  def matching_search_term(query, term) do
-    from(mi in query,
-      join: mi_search_index in assoc(mi, :media_items_search_index),
-      where: fragment("media_items_search_index MATCH ?", ^term),
-      select_merge: %{
-        matching_search_term:
-          fragment("""
-            coalesce(snippet(media_items_search_index, 0, '[PF_HIGHLIGHT]', '[/PF_HIGHLIGHT]', '...', 20), '') ||
-            ' ' ||
-            coalesce(snippet(media_items_search_index, 1, '[PF_HIGHLIGHT]', '[/PF_HIGHLIGHT]', '...', 20), '')
-          """)
-      },
-      order_by: [desc: fragment("rank")]
-    )
-  end
-
-  def with_format_matching_profile_preference(query) do
-    query
-    |> require_assoc(:media_profile)
-    |> where(
+  def format_matching_profile_preference do
+    dynamic(
+      [mi, source, media_profile],
       fragment("""
         CASE
           WHEN shorts_behaviour = 'only' AND livestream_behaviour = 'only' THEN
@@ -176,22 +64,68 @@ defmodule Pinchflat.Media.MediaQuery do
     )
   end
 
-  def where_pending_download(query) do
-    query
-    |> where_download_not_prevented()
-    |> with_no_media_filepath()
-    |> with_upload_date_after_source_cutoff()
-    |> with_format_matching_profile_preference()
-    |> matching_source_title_regex()
+  def matches_source_title_regex do
+    dynamic(
+      [mi, source],
+      is_nil(source.title_filter_regex) or fragment("regexp_like(?, ?)", mi.title, source.title_filter_regex)
+    )
   end
 
-  def where_pending_or_downloaded(query) do
-    query
-    |> where_pending_download()
-    |> or_where([mi], not is_nil(mi.media_downloaded_at))
+  def past_retention_period do
+    dynamic(
+      [mi, source],
+      fragment("""
+        IFNULL(retention_period_days, 0) > 0 AND
+        DATETIME('now', '-' || retention_period_days || ' day') > media_downloaded_at
+      """)
+    )
   end
 
-  defp require_assoc(query, identifier) do
+  def past_redownload_delay do
+    dynamic(
+      [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 cullable do
+    dynamic(
+      [mi, source],
+      ^downloaded() and
+        ^past_retention_period() and
+        not (^culling_prevented())
+    )
+  end
+
+  def pending do
+    dynamic(
+      [mi],
+      not (^downloaded()) and
+        not (^download_prevented()) and
+        ^upload_date_after_source_cutoff() and
+        ^format_matching_profile_preference() and
+        ^matches_source_title_regex()
+    )
+  end
+
+  def redownloadable do
+    dynamic(
+      [mi, source],
+      ^downloaded() and
+        not (^download_prevented()) and
+        not (^culled()) and
+        not (^redownloaded()) and
+        ^past_redownload_delay()
+    )
+  end
+
+  def require_assoc(query, identifier) do
     if has_named_binding?(query, identifier) do
       query
     else
@@ -208,4 +142,24 @@ defmodule Pinchflat.Media.MediaQuery do
     |> require_assoc(:source)
     |> join(:inner, [mi, source], mp in assoc(source, :media_profile), as: :media_profile)
   end
+
+  # This needs to be a non-dynamic query because it alone should control things like
+  # ordering and `snippets` for full-text search
+  def matching_search_term(query, nil), do: query
+
+  def matching_search_term(query, term) do
+    from(mi in query,
+      join: mi_search_index in assoc(mi, :media_items_search_index),
+      where: fragment("media_items_search_index MATCH ?", ^term),
+      select_merge: %{
+        matching_search_term:
+          fragment("""
+            coalesce(snippet(media_items_search_index, 0, '[PF_HIGHLIGHT]', '[/PF_HIGHLIGHT]', '...', 20), '') ||
+            ' ' ||
+            coalesce(snippet(media_items_search_index, 1, '[PF_HIGHLIGHT]', '[/PF_HIGHLIGHT]', '...', 20), '')
+          """)
+      },
+      order_by: [desc: fragment("rank")]
+    )
+  end
 end

lib/pinchflat/podcasts/podcast_helpers.ex

@@ -27,8 +27,7 @@ defmodule Pinchflat.Podcasts.PodcastHelpers do
     limit = Keyword.get(opts, :limit, 1_000)
 
     MediaQuery.new()
-    |> MediaQuery.for_source(source)
-    |> MediaQuery.with_media_filepath()
+    |> where(^dynamic(^MediaQuery.for_source(source) and ^MediaQuery.downloaded()))
     |> order_by(desc: :upload_date)
     |> Repo.maybe_limit(limit)
     |> Repo.all()

lib/pinchflat/sources/sources.ex

@@ -127,7 +127,7 @@ defmodule Pinchflat.Sources do
     Tasks.delete_tasks_for(source)
 
     MediaQuery.new()
-    |> MediaQuery.for_source(source)
+    |> where(^MediaQuery.for_source(source))
     |> Repo.all()
     |> Enum.each(fn media_item ->
       Media.delete_media_item(media_item, delete_files: delete_files)

lib/pinchflat/sources/sources_query.ex

@@ -12,20 +12,26 @@ defmodule Pinchflat.Sources.SourcesQuery do
 
   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
+  # This allows the module to be aliased and query methods to be used
+  # all in one go
+  # usage: use Pinchflat.Sources.SourcesQuery
+  defmacro __using__(_opts) do
+    quote do
+      import Ecto.Query, warn: false
+
+      alias unquote(__MODULE__)
+    end
+  end
 
   def new do
     Source
   end
 
-  def for_media_profile(query, media_profile) do
-    where(query, [s], s.media_profile_id == ^media_profile.id)
+  def for_media_profile(media_profile_id) when is_integer(media_profile_id) do
+    dynamic([s], s.media_profile_id == ^media_profile_id)
+  end
+
+  def for_media_profile(media_profile) do
+    dynamic([s], s.media_profile_id == ^media_profile.id)
   end
 end