Bumped version to the correct one LMAO

* Added new uploaded_at column to media items

* Updated indexer to pull upload date

* Updates media item creation to update on conflict

* Added download cutoff date to sources

* Applies cutoff date logic to pending media logic

* Updated docs

.check.exs

@@ -0,0 +1,41 @@
+[
+  ## don't run tools concurrently
+  # parallel: false,
+
+  ## don't print info about skipped tools
+  skipped: false,
+
+  ## always run tools in fix mode (put it in ~/.check.exs locally, not in project config)
+  fix: true,
+
+  ## don't retry automatically even if last run resulted in failures
+  # retry: false,
+
+  ## list of tools (see `mix check` docs for a list of default curated tools)
+  tools: [
+    {:compiler, env: %{"MIX_ENV" => "test"}},
+    {:formatter, env: %{"MIX_ENV" => "test"}},
+    {:sobelow, "mix sobelow --config"},
+    # TODO: delete these and replace them with builtin ex_unit and formatter tools
+    # once Elixir 1.16.2 is released (see: https://github.com/karolsluszniak/ex_check/issues/41#issuecomment-1921390413)
+    {:elixir_tests, "mix test"},
+    {:elixir_formatting, "mix format --check-formatted", fix: "mix format"},
+    {:prettier_formatting, "yarn run prettier . --check", fix: "yarn run prettier . --write"}
+
+    ## curated tools may be disabled (e.g. the check for compilation warnings)
+    # {:compiler, false},
+
+    ## ...or have command & args adjusted (e.g. enable skip comments for sobelow)
+    # {:sobelow, "mix sobelow --exit --skip"},
+
+    ## ...or reordered (e.g. to see output from dialyzer before others)
+    # {:dialyzer, order: -1},
+
+    ## ...or reconfigured (e.g. disable parallel execution of ex_unit in umbrella)
+    # {:ex_unit, umbrella: [parallel: false]},
+
+    ## custom new tools may be added (Mix tasks or arbitrary commands)
+    # {:my_task, "mix my_task", env: %{"MIX_ENV" => "prod"}},
+    # {:my_tool, ["my_tool", "arg with spaces"]}
+  ]
+]

.credo.exs

@@ -0,0 +1,215 @@
+# This file contains the configuration for Credo and you are probably reading
+# this after creating it with `mix credo.gen.config`.
+#
+# If you find anything wrong or unclear in this file, please report an
+# issue on GitHub: https://github.com/rrrene/credo/issues
+#
+%{
+  #
+  # You can have as many configs as you like in the `configs:` field.
+  configs: [
+    %{
+      #
+      # Run any config using `mix credo -C <name>`. If no config name is given
+      # "default" is used.
+      #
+      name: "default",
+      #
+      # These are the files included in the analysis:
+      files: %{
+        #
+        # You can give explicit globs or simply directories.
+        # In the latter case `**/*.{ex,exs}` will be used.
+        #
+        included: [
+          "lib/",
+          "src/",
+          "test/",
+          "web/",
+          "apps/*/lib/",
+          "apps/*/src/",
+          "apps/*/test/",
+          "apps/*/web/"
+        ],
+        excluded: [~r"/_build/", ~r"/deps/", ~r"/node_modules/"]
+      },
+      #
+      # Load and configure plugins here:
+      #
+      plugins: [],
+      #
+      # If you create your own checks, you must specify the source files for
+      # them here, so they can be loaded by Credo before running the analysis.
+      #
+      requires: [],
+      #
+      # If you want to enforce a style guide and need a more traditional linting
+      # experience, you can change `strict` to `true` below:
+      #
+      strict: false,
+      #
+      # To modify the timeout for parsing files, change this value:
+      #
+      parse_timeout: 5000,
+      #
+      # If you want to use uncolored output by default, you can change `color`
+      # to `false` below:
+      #
+      color: true,
+      #
+      # You can customize the parameters of any check by adding a second element
+      # to the tuple.
+      #
+      # To disable a check put `false` as second element:
+      #
+      #     {Credo.Check.Design.DuplicatedCode, false}
+      #
+      checks: %{
+        enabled: [
+          #
+          ## Consistency Checks
+          #
+          {Credo.Check.Consistency.ExceptionNames, []},
+          {Credo.Check.Consistency.LineEndings, []},
+          {Credo.Check.Consistency.ParameterPatternMatching, []},
+          {Credo.Check.Consistency.SpaceAroundOperators, []},
+          {Credo.Check.Consistency.SpaceInParentheses, []},
+          {Credo.Check.Consistency.TabsOrSpaces, []},
+
+          #
+          ## Design Checks
+          #
+          # You can customize the priority of any check
+          # Priority values are: `low, normal, high, higher`
+          #
+          {Credo.Check.Design.AliasUsage, [priority: :low, if_nested_deeper_than: 2, if_called_more_often_than: 0]},
+          {Credo.Check.Design.TagFIXME, []},
+          # You can also customize the exit_status of each check.
+          # If you don't want TODO comments to cause `mix credo` to fail, just
+          # set this value to 0 (zero).
+          #
+          {Credo.Check.Design.TagTODO, [exit_status: 2]},
+
+          #
+          ## Readability Checks
+          #
+          {Credo.Check.Readability.AliasOrder, []},
+          {Credo.Check.Readability.FunctionNames, []},
+          {Credo.Check.Readability.LargeNumbers, []},
+          {Credo.Check.Readability.MaxLineLength, [priority: :low, max_length: 120]},
+          {Credo.Check.Readability.ModuleAttributeNames, []},
+          {Credo.Check.Readability.ModuleDoc, []},
+          {Credo.Check.Readability.ModuleNames, []},
+          {Credo.Check.Readability.ParenthesesInCondition, []},
+          {Credo.Check.Readability.ParenthesesOnZeroArityDefs, []},
+          {Credo.Check.Readability.PipeIntoAnonymousFunctions, []},
+          {Credo.Check.Readability.PredicateFunctionNames, []},
+          {Credo.Check.Readability.PreferImplicitTry, []},
+          {Credo.Check.Readability.RedundantBlankLines, []},
+          {Credo.Check.Readability.Semicolons, []},
+          {Credo.Check.Readability.SpaceAfterCommas, []},
+          {Credo.Check.Readability.StringSigils, []},
+          {Credo.Check.Readability.TrailingBlankLine, []},
+          {Credo.Check.Readability.TrailingWhiteSpace, []},
+          {Credo.Check.Readability.UnnecessaryAliasExpansion, []},
+          {Credo.Check.Readability.VariableNames, []},
+          {Credo.Check.Readability.WithSingleClause, []},
+
+          #
+          ## Refactoring Opportunities
+          #
+          {Credo.Check.Refactor.Apply, []},
+          {Credo.Check.Refactor.CondStatements, []},
+          {Credo.Check.Refactor.FilterCount, []},
+          {Credo.Check.Refactor.FilterFilter, []},
+          {Credo.Check.Refactor.FunctionArity, []},
+          {Credo.Check.Refactor.LongQuoteBlocks, []},
+          {Credo.Check.Refactor.MapJoin, []},
+          {Credo.Check.Refactor.MatchInCondition, []},
+          {Credo.Check.Refactor.NegatedConditionsInUnless, []},
+          {Credo.Check.Refactor.NegatedConditionsWithElse, []},
+          {Credo.Check.Refactor.Nesting, []},
+          {Credo.Check.Refactor.RedundantWithClauseResult, []},
+          {Credo.Check.Refactor.RejectReject, []},
+          {Credo.Check.Refactor.UnlessWithElse, []},
+          {Credo.Check.Refactor.WithClauses, []},
+
+          #
+          ## Warnings
+          #
+          {Credo.Check.Warning.ApplicationConfigInModuleAttribute, []},
+          {Credo.Check.Warning.BoolOperationOnSameValues, []},
+          {Credo.Check.Warning.Dbg, []},
+          {Credo.Check.Warning.ExpensiveEmptyEnumCheck, []},
+          {Credo.Check.Warning.IExPry, []},
+          {Credo.Check.Warning.IoInspect, []},
+          {Credo.Check.Warning.MissedMetadataKeyInLoggerConfig, []},
+          {Credo.Check.Warning.OperationOnSameValues, []},
+          {Credo.Check.Warning.OperationWithConstantResult, []},
+          {Credo.Check.Warning.RaiseInsideRescue, []},
+          {Credo.Check.Warning.SpecWithStruct, []},
+          {Credo.Check.Warning.UnsafeExec, []},
+          {Credo.Check.Warning.UnusedEnumOperation, []},
+          {Credo.Check.Warning.UnusedFileOperation, []},
+          {Credo.Check.Warning.UnusedKeywordOperation, []},
+          {Credo.Check.Warning.UnusedListOperation, []},
+          {Credo.Check.Warning.UnusedPathOperation, []},
+          {Credo.Check.Warning.UnusedRegexOperation, []},
+          {Credo.Check.Warning.UnusedStringOperation, []},
+          {Credo.Check.Warning.UnusedTupleOperation, []},
+          {Credo.Check.Warning.WrongTestFileExtension, []}
+        ],
+        disabled: [
+          #
+          # Checks scheduled for next check update (opt-in for now, just replace `false` with `[]`)
+
+          #
+          # Controversial and experimental checks (opt-in, just move the check to `:enabled`
+          #   and be sure to use `mix credo --strict` to see low priority checks)
+          #
+          {Credo.Check.Refactor.CyclomaticComplexity, []},
+          {Credo.Check.Consistency.MultiAliasImportRequireUse, []},
+          {Credo.Check.Consistency.UnusedVariableNames, []},
+          {Credo.Check.Design.DuplicatedCode, []},
+          {Credo.Check.Design.SkipTestWithoutComment, []},
+          {Credo.Check.Readability.AliasAs, []},
+          {Credo.Check.Readability.BlockPipe, []},
+          {Credo.Check.Readability.ImplTrue, []},
+          {Credo.Check.Readability.MultiAlias, []},
+          {Credo.Check.Readability.NestedFunctionCalls, []},
+          {Credo.Check.Readability.OneArityFunctionInPipe, []},
+          {Credo.Check.Readability.OnePipePerLine, []},
+          {Credo.Check.Readability.SeparateAliasRequire, []},
+          {Credo.Check.Readability.SingleFunctionToBlockPipe, []},
+          {Credo.Check.Readability.SinglePipe, []},
+          {Credo.Check.Readability.Specs, []},
+          {Credo.Check.Readability.StrictModuleLayout, []},
+          {Credo.Check.Readability.WithCustomTaggedTuple, []},
+          {Credo.Check.Refactor.ABCSize, []},
+          {Credo.Check.Refactor.AppendSingleItem, []},
+          {Credo.Check.Refactor.DoubleBooleanNegation, []},
+          {Credo.Check.Refactor.FilterReject, []},
+          {Credo.Check.Refactor.IoPuts, []},
+          {Credo.Check.Refactor.MapMap, []},
+          {Credo.Check.Refactor.ModuleDependencies, []},
+          {Credo.Check.Refactor.NegatedIsNil, []},
+          {Credo.Check.Refactor.PassAsyncInTestCases, []},
+          {Credo.Check.Refactor.PipeChainStart, []},
+          {Credo.Check.Refactor.RejectFilter, []},
+          {Credo.Check.Refactor.VariableRebinding, []},
+          {Credo.Check.Warning.LazyLogging, []},
+          {Credo.Check.Warning.LeakyEnvironment, []},
+          {Credo.Check.Warning.MapGetUnsafePass, []},
+          {Credo.Check.Warning.MixEnv, []},
+          {Credo.Check.Warning.UnsafeToAtom, []}
+
+          # {Credo.Check.Refactor.MapInto, []},
+
+          #
+          # Custom checks can be created using `mix credo.gen.check`.
+          #
+        ]
+      }
+    }
+  ]
+}

.dockerignore

@@ -0,0 +1,45 @@
+# This file excludes paths from the Docker build context.
+#
+# By default, Docker's build context includes all files (and folders) in the
+# current directory. Even if a file isn't copied into the container it is still sent to
+# the Docker daemon.
+#
+# There are multiple reasons to exclude files from the build context:
+#
+# 1. Prevent nested folders from being copied into the container (ex: exclude
+#    /assets/node_modules when copying /assets)
+# 2. Reduce the size of the build context and improve build time (ex. /build, /deps, /doc)
+# 3. Avoid sending files containing sensitive information
+#
+# More information on using .dockerignore is available here:
+# https://docs.docker.com/engine/reference/builder/#dockerignore-file
+
+.dockerignore
+
+# Ignore git, but keep git HEAD and refs to access current commit hash if needed:
+#
+# $ cat .git/HEAD | awk '{print ".git/"$2}' | xargs cat
+# d0b8727759e1e0e7aa3d41707d12376e373d5ecc
+.git
+!.git/HEAD
+!.git/refs
+
+# Common development/test artifacts
+/cover/
+/doc/
+/test/
+/tmp/
+.elixir_ls
+
+# Mix artifacts
+/_build/
+/deps/
+*.ez
+
+# Generated on crash by the VM
+erl_crash.dump
+
+# Static artifacts - These should be fetched and built inside the Docker image
+/assets/node_modules/
+/priv/static/assets/
+/priv/static/cache_manifest.json

.env.sample

@@ -1,3 +0,0 @@
-POSTGRES_HOST=postgres
-POSTGRES_USER=postgres
-POSTGRES_PASSWORD=postgres

.formatter.exs

@@ -2,5 +2,6 @@
   import_deps: [:ecto, :ecto_sql, :phoenix],
   subdirectories: ["priv/*/migrations"],
   plugins: [Phoenix.LiveView.HTMLFormatter],
-  inputs: ["*.{heex,ex,exs}", "{config,lib,test}/**/*.{heex,ex,exs}", "priv/*/seeds.exs"]
+  inputs: ["*.{heex,ex,exs}", "{config,lib,test}/**/*.{heex,ex,exs}", "priv/*/seeds.exs"],
+  line_length: 120
 ]

.github/pull_request_template.md

@@ -0,0 +1,15 @@
+## What's new?
+
+N/A
+
+## What's changed?
+
+N/A
+
+## What's fixed?
+
+N/A
+
+## Any other comments?
+
+N/A

.github/workflows/build_and_push_docker.yml

@@ -0,0 +1,32 @@
+name: Build and Push Docker Image
+
+on:
+  workflow_dispatch:
+    inputs:
+      image_tag:
+        description: 'Docker Image Tag'
+        required: true
+        default: 'dev'
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          push: true
+          file: ./selfhosted.Dockerfile
+          tags: 'keglin/pinchflat:${{ github.event.inputs.image_tag }}'

.github/workflows/lint_and_test.yml

@@ -0,0 +1,55 @@
+name: Perform linting and run tests
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+  workflow_dispatch:
+
+jobs:
+  build-and-test:
+    name: Build, Lint, and Test
+    runs-on: ubuntu-latest
+    if: "! contains(toJSON(github.event.commits.*.message), '[skip ci]')"
+    env:
+      COMPOSE_FILE: ./docker-compose.ci.yml
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Pull prebuilt images
+        run: docker compose pull
+
+      - name: Setup Docker layer caching
+        uses: jpribyl/action-docker-layer-caching@v0.1.1
+        continue-on-error: true
+        with:
+          key: ci-docker-cache-{hash}
+          restore-keys: |
+            ci-docker-cache-
+            layer-ci-docker-cache-
+
+      - name: Build and Run Docker image
+        run: docker compose up --detach
+
+      # NOTE: All exec commands use the -T flag to compensate for
+      # a bug in the GitHub Actions runner where its stdin/stderr
+      # will erroneously report that it's a TTY.
+      # Aside from handling this bug the -T flag is not required
+      # See https://github.com/actions/runner/issues/241 and https://github.com/docker/compose/issues/8537
+      - name: Install Elixir and JS deps
+        run: |
+          docker compose exec -T phx yarn install && cd assets && yarn install && cd ..
+          docker compose exec -T phx mix deps.get
+
+      - name: Create and Migrate database
+        run: |
+          docker compose exec -T phx mix ecto.create
+          docker compose exec -T phx mix ecto.migrate
+
+      - name: Run code checks
+        run: docker compose exec -T phx mix check --no-fix --no-retry

.gitignore

@@ -33,7 +33,15 @@ pinchflat-*.tar
 
 # In case you use Node.js/npm, you want to ignore these.
 npm-debug.log
+/node_modules/
 /assets/node_modules/
 
 /.elixir_ls
 .env
+.DS_Store
+scratchpad.md
+/scratchpad/
+
+# Database files
+*.db
+*.db-*

.iex.exs

@@ -0,0 +1,64 @@
+import Ecto.Query, warn: false
+alias Pinchflat.Repo
+
+alias Pinchflat.Tasks.Task
+alias Pinchflat.Sources.Source
+alias Pinchflat.Media.MediaItem
+alias Pinchflat.Tasks.SourceTasks
+alias Pinchflat.Media.MediaMetadata
+alias Pinchflat.Profiles.MediaProfile
+
+alias Pinchflat.Tasks
+alias Pinchflat.Media
+alias Pinchflat.Profiles
+alias Pinchflat.Sources
+alias Pinchflat.Settings
+
+alias Pinchflat.MediaClient.MediaDownloader
+alias Pinchflat.YtDlp.Backend.Media, as: YtDlpMedia
+alias Pinchflat.YtDlp.Backend.MediaCollection, as: YtDlpCollection
+
+alias Pinchflat.Api.YoutubeRss
+alias Pinchflat.Metadata.MetadataFileHelpers
+
+alias Pinchflat.Utils.FilesystemUtils.FileFollowerServer
+
+defmodule IexHelpers do
+  def playlist_url do
+    "https://www.youtube.com/playlist?list=PLmqC3wPkeL8kSlTCcSMDD63gmSi7evcXS"
+  end
+
+  def channel_url do
+    "https://www.youtube.com/c/TheUselessTrials"
+  end
+
+  def video_url do
+    "https://www.youtube.com/watch?v=bR52O78ZIUw"
+  end
+
+  def last_media_item do
+    Repo.one(from m in MediaItem, limit: 1)
+  end
+
+  def details(type) do
+    source =
+      case type do
+        :playlist -> playlist_url()
+        :channel -> channel_url()
+      end
+
+    YtDlpCollection.get_source_details(source)
+  end
+
+  def ids(type) do
+    source =
+      case type do
+        :playlist -> playlist_url()
+        :channel -> channel_url()
+      end
+
+    YtDlpCollection.get_media_attributes_for_collection(source)
+  end
+end
+
+import IexHelpers

.prettierignore

@@ -0,0 +1,3 @@
+assets/vendor/
+deps/
+_build/

.prettierrc.js

@@ -0,0 +1,13 @@
+module.exports = {
+  printWidth: 100,
+  tabWidth: 2,
+  useTabs: false,
+  semi: false,
+  singleQuote: true,
+  jsxSingleQuote: false,
+  trailingComma: 'none',
+  bracketSpacing: true,
+  arrowParens: 'always',
+  requirePragma: false,
+  endOfLine: 'lf'
+}

.sobelow-conf

@@ -0,0 +1,15 @@
+[
+  verbose: false,
+  private: false,
+  skip: false,
+  router: nil,
+  exit: :medium,
+  format: "txt",
+  out: nil,
+  threshold: :low,
+  # All of these are ignorable because this app is intended to be single-user and self-hosted.
+  # There is an expectation that the user won't intentionally run a FS Traversal on themselves
+  ignore: ["CI.System", "Traversal.FileModule", "Config.HTTPS", "Config.CSP"],
+  ignore_files: [],
+  version: false
+]

LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+                            Preamble
+
+The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate. Many developers of free software are heartened and
+encouraged by the resulting cooperation. However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community. It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server. Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals. This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+0. Definitions.
+
+"This License" refers to version 3 of the GNU Affero General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+1. Source Code.
+
+The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+The Corresponding Source for a work in source code form is that
+same work.
+
+2. Basic Permissions.
+
+All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+"Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+8. Termination.
+
+You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+13. Remote Network Interaction; Use with the GNU General Public License.
+
+Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software. This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source. For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code. There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

README.md

@@ -1,18 +1,39 @@
-# Pinchflat
+# Pinchflat (Alpha)
 
-To start your Phoenix server:
+This is alpha software and anything can break at any time. I make not guarantees about the stability of this software, forward-compatibility of updates, or integrity (both related to and independent of Pinchflat). Essentially, use at your own risk and expect there will be rough edges.
 
-  * Run `mix setup` to install and setup dependencies
-  * Start Phoenix endpoint with `mix phx.server` or inside IEx with `iex -S mix phx.server`
+## What is Pinchflat?
 
-Now you can visit [`localhost:4000`](http://localhost:4000) from your browser.
+TODO: expand on this.
 
-Ready to run in production? Please [check our deployment guides](https://hexdocs.pm/phoenix/deployment.html).
+Pinchflat is a lightweight self-contained app for downloading YouTube content. For now, it is not intended as a way to consume content, but instead as a way to download content to disk using specified rules and schedules.
 
-## Learn more
+I have plans for more to come, but for now this is the focus. Think of Pinchflat as nothing more than an automated way to get content from YouTube to your disk.
 
-  * Official website: https://www.phoenixframework.org/
-  * Guides: https://hexdocs.pm/phoenix/overview.html
-  * Docs: https://hexdocs.pm/phoenix
-  * Forum: https://elixirforum.com/c/phoenix-forum
-  * Source: https://github.com/phoenixframework/phoenix
+## Installation
+
+Pinchflat is designed to be self-hosted. I'm building it for my own needs which means it's designed to work well with Unraid, but it should work on any computer/server that can run Docker images.
+
+I'll update with Unraid instructions once I get something in the Community Apps store. Until then, here's how you build it with Docker:
+
+```bash
+docker build . --file selfhosted.Dockerfile -t pinchflat:dev
+
+docker run \
+  -p 8945:8945 \
+  -v /Users/work/Desktop/test_volumes/config:/config \
+  -v /Users/work/Desktop/test_volumes/downloads:/downloads \
+  pinchflat:dev
+```
+
+## Authentication
+
+Currently HTTP basic auth is optionally supported. To use it, set the `BASIC_AUTH_USERNAME` and `BASIC_AUTH_PASSWORD` environment variables when starting the container. If you don't set both of these, no authentication will be required.
+
+## License
+
+See `LICENSE` file
+
+```
+
+```

assets/css/app.css

@@ -1,5 +1,31 @@
-@import "tailwindcss/base";
-@import "tailwindcss/components";
-@import "tailwindcss/utilities";
+@import 'tailwindcss/base';
+@import 'tailwindcss/components';
+@import 'tailwindcss/utilities';
+
+@import './satoshi';
 
 /* This file is for your main application CSS */
+[x-cloak] {
+  display: none !important;
+}
+
+@layer base {
+  body {
+    @apply relative z-1 bg-whiten font-satoshi text-base font-normal text-body;
+  }
+}
+
+@layer components {
+}
+
+@layer utilities {
+  /* Chrome, Safari and Opera */
+  .no-scrollbar::-webkit-scrollbar {
+    display: none;
+  }
+
+  .no-scrollbar {
+    -ms-overflow-style: none; /* IE and Edge */
+    scrollbar-width: none; /* Firefox */
+  }
+}

assets/css/satoshi.css

@@ -0,0 +1,102 @@
+/**
+ * @license
+ *
+ * Font Family: Satoshi
+ * Designed by: Deni Anggara
+ * URL: https://www.fontshare.com/fonts/satoshi
+ * © 2023 Indian Type Foundry
+ *
+ * Font Styles:
+ * Satoshi Light
+ * Satoshi Light Italic
+ * Satoshi Regular
+ * Satoshi Italic
+ * Satoshi Medium
+ * Satoshi Medium Italic
+ * Satoshi Bold
+ * Satoshi Bold Italic
+ * Satoshi Black
+ * Satoshi Black Italic
+ *
+*/
+
+@font-face {
+  font-family: 'Satoshi';
+  src: url('/fonts/satoshi/Satoshi-Light.woff2'), url('/fonts/satoshi/Satoshi-Light.woff'),
+    url('/fonts/satoshi/Satoshi-Light.ttf');
+  font-weight: 300;
+  font-display: swap;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: 'Satoshi';
+  src: url('/fonts/satoshi/Satoshi-LightItalic.woff2'),
+    url('/fonts/satoshi/Satoshi-LightItalic.woff'), url('/fonts/satoshi/Satoshi-LightItalic.ttf');
+  font-weight: 300;
+  font-display: swap;
+  font-style: italic;
+}
+
+@font-face {
+  font-family: 'Satoshi';
+  src: url('/fonts/satoshi/Satoshi-Regular.woff2'), url('/fonts/satoshi/Satoshi-Regular.woff'),
+    url('/fonts/satoshi/Satoshi-Regular.ttf');
+  font-weight: 400;
+  font-display: swap;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: 'Satoshi';
+  src: url('/fonts/satoshi/Satoshi-Italic.woff2'), url('/fonts/satoshi/Satoshi-Italic.woff'),
+    url('/fonts/satoshi/Satoshi-Italic.ttf');
+  font-weight: 400;
+  font-display: swap;
+  font-style: italic;
+}
+
+@font-face {
+  font-family: 'Satoshi';
+  src: url('/fonts/satoshi/Satoshi-Medium.woff2'), url('/fonts/satoshi/Satoshi-Medium.woff'),
+    url('/fonts/satoshi/Satoshi-Medium.ttf');
+  font-weight: 500;
+  font-display: swap;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: 'Satoshi';
+  src: url('/fonts/satoshi/Satoshi-MediumItalic.woff2'),
+    url('/fonts/satoshi/Satoshi-MediumItalic.woff'), url('/fonts/satoshi/Satoshi-MediumItalic.ttf');
+  font-weight: 500;
+  font-display: swap;
+  font-style: italic;
+}
+
+@font-face {
+  font-family: 'Satoshi';
+  src: url('/fonts/satoshi/Satoshi-Bold.woff2'), url('/fonts/satoshi/Satoshi-Bold.woff'),
+    url('/fonts/satoshi/Satoshi-Bold.ttf');
+  font-weight: 700;
+  font-display: swap;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: 'Satoshi';
+  src: url('/fonts/satoshi/Satoshi-BoldItalic.woff2'), url('/fonts/satoshi/Satoshi-BoldItalic.woff'),
+    url('/fonts/satoshi/Satoshi-BoldItalic.ttf');
+  font-weight: 700;
+  font-display: swap;
+  font-style: italic;
+}
+
+@font-face {
+  font-family: 'Satoshi';
+  src: url('/fonts/satoshi/Satoshi-BlackItalic.woff2'),
+    url('/fonts/satoshi/Satoshi-BlackItalic.woff'), url('/fonts/satoshi/Satoshi-BlackItalic.ttf');
+  font-weight: 900;
+  font-display: swap;
+  font-style: italic;
+}

assets/js/app.js

@@ -16,19 +16,32 @@
 //
 
 // Include phoenix_html to handle method=PUT/DELETE in forms and buttons.
-import "phoenix_html"
+import 'phoenix_html'
 // Establish Phoenix Socket and LiveView configuration.
-import {Socket} from "phoenix"
-import {LiveSocket} from "phoenix_live_view"
-import topbar from "../vendor/topbar"
+import { Socket } from 'phoenix'
+import { LiveSocket } from 'phoenix_live_view'
+import topbar from '../vendor/topbar'
+import Alpine from 'alpinejs'
 
-let csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute("content")
-let liveSocket = new LiveSocket("/live", Socket, {params: {_csrf_token: csrfToken}})
+window.Alpine = Alpine
+Alpine.start()
+
+let csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute('content')
+let liveSocket = new LiveSocket('/live', Socket, {
+  params: { _csrf_token: csrfToken },
+  dom: {
+    onBeforeElUpdated(from, to) {
+      if (from._x_dataStack) {
+        window.Alpine.clone(from, to)
+      }
+    }
+  }
+})
 
 // Show progress bar on live navigation and form submits
-topbar.config({barColors: {0: "#29d"}, shadowColor: "rgba(0, 0, 0, .3)"})
-window.addEventListener("phx:page-loading-start", _info => topbar.show(300))
-window.addEventListener("phx:page-loading-stop", _info => topbar.hide())
+topbar.config({ barColors: { 0: '#29d' }, shadowColor: 'rgba(0, 0, 0, .3)' })
+window.addEventListener('phx:page-loading-start', (_info) => topbar.show(300))
+window.addEventListener('phx:page-loading-stop', (_info) => topbar.hide())
 
 // connect if there are any LiveViews on the page
 liveSocket.connect()
@@ -38,4 +51,3 @@ liveSocket.connect()
 // >> liveSocket.enableLatencySim(1000)  // enabled for duration of browser session
 // >> liveSocket.disableLatencySim()
 window.liveSocket = liveSocket
-

assets/package.json

@@ -0,0 +1,7 @@
+{
+  "description": "Use this one for actual JS deps used in-app",
+  "dependencies": {
+    "alpinejs": "^3.13.5"
+  },
+  "license": "<See the LICENSE file>"
+}

assets/tailwind.config.js

@@ -1,68 +1,352 @@
 // See the Tailwind configuration guide for advanced usage
 // https://tailwindcss.com/docs/configuration
 
-const plugin = require("tailwindcss/plugin")
-const fs = require("fs")
-const path = require("path")
+const plugin = require('tailwindcss/plugin')
+const defaultTheme = require('tailwindcss/defaultTheme')
+const fs = require('fs')
+const path = require('path')
 
 module.exports = {
-  content: [
-    "./js/**/*.js",
-    "../lib/pinchflat_web.ex",
-    "../lib/pinchflat_web/**/*.*ex"
-  ],
+  content: ['./js/**/*.js', '../lib/pinchflat_web.ex', '../lib/pinchflat_web/**/*.*ex'],
+  darkMode: 'class',
   theme: {
+    fontFamily: {
+      satoshi: ['Satoshi', 'sans-serif'],
+      ...defaultTheme.fontFamily
+    },
+    screens: {
+      '2xsm': '375px',
+      xsm: '425px',
+      '3xl': '2000px',
+      ...defaultTheme.screens
+    },
     extend: {
       colors: {
-        brand: "#FD4F00",
+        current: 'currentColor',
+        transparent: 'transparent',
+        white: '#FFFFFF',
+        black: '#1C2434',
+        'black-2': '#010101',
+        body: '#64748B',
+        bodydark: '#AEB7C0',
+        bodydark1: '#DEE4EE',
+        bodydark2: '#8A99AF',
+        primary: '#3C50E0',
+        secondary: '#80CAEE',
+        stroke: '#E2E8F0',
+        gray: '#EFF4FB',
+        graydark: '#333A48',
+        'gray-2': '#F7F9FC',
+        'gray-3': '#FAFAFA',
+        whiten: '#F1F5F9',
+        whiter: '#F5F7FD',
+        boxdark: '#24303F',
+        'boxdark-2': '#1A222C',
+        strokedark: '#2E3A47',
+        'form-strokedark': '#3d4d60',
+        'form-input': '#1d2a39',
+        'meta-1': '#DC3545',
+        'meta-2': '#EFF2F7',
+        'meta-3': '#10B981',
+        'meta-4': '#313D4A',
+        'meta-5': '#259AE6',
+        'meta-6': '#FFBA00',
+        'meta-7': '#FF6766',
+        'meta-8': '#F0950C',
+        'meta-9': '#E5E7EB',
+        success: '#219653',
+        danger: '#D34053',
+        warning: '#FFA70B'
+      },
+      fontSize: {
+        'title-xxl': ['44px', '55px'],
+        'title-xl': ['36px', '45px'],
+        'title-xl2': ['33px', '45px'],
+        'title-lg': ['28px', '35px'],
+        'title-md': ['24px', '30px'],
+        'title-md2': ['26px', '30px'],
+        'title-sm': ['20px', '26px'],
+        'title-xsm': ['18px', '24px']
+      },
+      spacing: {
+        4.5: '1.125rem',
+        5.5: '1.375rem',
+        6.5: '1.625rem',
+        7.5: '1.875rem',
+        8.5: '2.125rem',
+        9.5: '2.375rem',
+        10.5: '2.625rem',
+        11: '2.75rem',
+        11.5: '2.875rem',
+        12.5: '3.125rem',
+        13: '3.25rem',
+        13.5: '3.375rem',
+        14: '3.5rem',
+        14.5: '3.625rem',
+        15: '3.75rem',
+        15.5: '3.875rem',
+        16: '4rem',
+        16.5: '4.125rem',
+        17: '4.25rem',
+        17.5: '4.375rem',
+        18: '4.5rem',
+        18.5: '4.625rem',
+        19: '4.75rem',
+        19.5: '4.875rem',
+        21: '5.25rem',
+        21.5: '5.375rem',
+        22: '5.5rem',
+        22.5: '5.625rem',
+        24.5: '6.125rem',
+        25: '6.25rem',
+        25.5: '6.375rem',
+        26: '6.5rem',
+        27: '6.75rem',
+        27.5: '6.875rem',
+        29: '7.25rem',
+        29.5: '7.375rem',
+        30: '7.5rem',
+        31: '7.75rem',
+        32.5: '8.125rem',
+        34: '8.5rem',
+        34.5: '8.625rem',
+        35: '8.75rem',
+        36.5: '9.125rem',
+        37.5: '9.375rem',
+        39: '9.75rem',
+        39.5: '9.875rem',
+        40: '10rem',
+        42.5: '10.625rem',
+        44: '11rem',
+        45: '11.25rem',
+        46: '11.5rem',
+        47.5: '11.875rem',
+        49: '12.25rem',
+        50: '12.5rem',
+        52: '13rem',
+        52.5: '13.125rem',
+        54: '13.5rem',
+        54.5: '13.625rem',
+        55: '13.75rem',
+        55.5: '13.875rem',
+        59: '14.75rem',
+        60: '15rem',
+        62.5: '15.625rem',
+        65: '16.25rem',
+        67: '16.75rem',
+        67.5: '16.875rem',
+        70: '17.5rem',
+        72.5: '18.125rem',
+        73: '18.25rem',
+        75: '18.75rem',
+        90: '22.5rem',
+        94: '23.5rem',
+        95: '23.75rem',
+        100: '25rem',
+        115: '28.75rem',
+        125: '31.25rem',
+        132.5: '33.125rem',
+        150: '37.5rem',
+        171.5: '42.875rem',
+        180: '45rem',
+        187.5: '46.875rem',
+        203: '50.75rem',
+        230: '57.5rem',
+        242.5: '60.625rem'
+      },
+      maxWidth: {
+        2.5: '0.625rem',
+        3: '0.75rem',
+        4: '1rem',
+        11: '2.75rem',
+        13: '3.25rem',
+        14: '3.5rem',
+        15: '3.75rem',
+        22.5: '5.625rem',
+        25: '6.25rem',
+        30: '7.5rem',
+        34: '8.5rem',
+        35: '8.75rem',
+        40: '10rem',
+        42.5: '10.625rem',
+        44: '11rem',
+        45: '11.25rem',
+        60: '15rem',
+        70: '17.5rem',
+        90: '22.5rem',
+        94: '23.5rem',
+        125: '31.25rem',
+        132.5: '33.125rem',
+        142.5: '35.625rem',
+        150: '37.5rem',
+        180: '45rem',
+        203: '50.75rem',
+        230: '57.5rem',
+        242.5: '60.625rem',
+        270: '67.5rem',
+        280: '70rem',
+        292.5: '73.125rem'
+      },
+      maxHeight: {
+        35: '8.75rem',
+        70: '17.5rem',
+        90: '22.5rem',
+        550: '34.375rem',
+        300: '18.75rem'
+      },
+      minWidth: {
+        22.5: '5.625rem',
+        42.5: '10.625rem',
+        47.5: '11.875rem',
+        75: '18.75rem'
+      },
+      zIndex: {
+        999999: '999999',
+        99999: '99999',
+        9999: '9999',
+        999: '999',
+        99: '99',
+        9: '9',
+        1: '1'
+      },
+      opacity: {
+        65: '.65'
+      },
+      transitionProperty: { width: 'width', stroke: 'stroke' },
+      borderWidth: {
+        6: '6px'
+      },
+      boxShadow: {
+        default: '0px 8px 13px -3px rgba(0, 0, 0, 0.07)',
+        card: '0px 1px 3px rgba(0, 0, 0, 0.12)',
+        'card-2': '0px 1px 2px rgba(0, 0, 0, 0.05)',
+        switcher:
+          '0px 2px 4px rgba(0, 0, 0, 0.2), inset 0px 2px 2px #FFFFFF, inset 0px -1px 1px rgba(0, 0, 0, 0.1)',
+        'switch-1': '0px 0px 5px rgba(0, 0, 0, 0.15)',
+        1: '0px 1px 3px rgba(0, 0, 0, 0.08)',
+        2: '0px 1px 4px rgba(0, 0, 0, 0.12)',
+        3: '0px 1px 5px rgba(0, 0, 0, 0.14)',
+        4: '0px 4px 10px rgba(0, 0, 0, 0.12)',
+        5: '0px 1px 1px rgba(0, 0, 0, 0.15)',
+        6: '0px 3px 15px rgba(0, 0, 0, 0.1)',
+        7: '-5px 0 0 #313D4A, 5px 0 0 #313D4A',
+        8: '1px 0 0 #313D4A, -1px 0 0 #313D4A, 0 1px 0 #313D4A, 0 -1px 0 #313D4A, 0 3px 13px rgb(0 0 0 / 8%)'
+      },
+      dropShadow: {
+        1: '0px 1px 0px #E2E8F0',
+        2: '0px 1px 4px rgba(0, 0, 0, 0.12)'
+      },
+      keyframes: {
+        linspin: {
+          '100%': { transform: 'rotate(360deg)' }
+        },
+        easespin: {
+          '12.5%': { transform: 'rotate(135deg)' },
+          '25%': { transform: 'rotate(270deg)' },
+          '37.5%': { transform: 'rotate(405deg)' },
+          '50%': { transform: 'rotate(540deg)' },
+          '62.5%': { transform: 'rotate(675deg)' },
+          '75%': { transform: 'rotate(810deg)' },
+          '87.5%': { transform: 'rotate(945deg)' },
+          '100%': { transform: 'rotate(1080deg)' }
+        },
+        'left-spin': {
+          '0%': { transform: 'rotate(130deg)' },
+          '50%': { transform: 'rotate(-5deg)' },
+          '100%': { transform: 'rotate(130deg)' }
+        },
+        'right-spin': {
+          '0%': { transform: 'rotate(-130deg)' },
+          '50%': { transform: 'rotate(5deg)' },
+          '100%': { transform: 'rotate(-130deg)' }
+        },
+        rotating: {
+          '0%, 100%': { transform: 'rotate(360deg)' },
+          '50%': { transform: 'rotate(0deg)' }
+        },
+        topbottom: {
+          '0%, 100%': { transform: 'translate3d(0, -100%, 0)' },
+          '50%': { transform: 'translate3d(0, 0, 0)' }
+        },
+        bottomtop: {
+          '0%, 100%': { transform: 'translate3d(0, 0, 0)' },
+          '50%': { transform: 'translate3d(0, -100%, 0)' }
+        }
+      },
+      animation: {
+        linspin: 'linspin 1568.2353ms linear infinite',
+        easespin: 'easespin 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both',
+        'left-spin': 'left-spin 1333ms cubic-bezier(0.4, 0, 0.2, 1) infinite both',
+        'right-spin': 'right-spin 1333ms cubic-bezier(0.4, 0, 0.2, 1) infinite both',
+        'ping-once': 'ping 5s cubic-bezier(0, 0, 0.2, 1)',
+        rotating: 'rotating 30s linear infinite',
+        topbottom: 'topbottom 60s infinite alternate linear',
+        bottomtop: 'bottomtop 60s infinite alternate linear',
+        'spin-1.5': 'spin 1.5s linear infinite',
+        'spin-2': 'spin 2s linear infinite',
+        'spin-3': 'spin 3s linear infinite'
       }
-    },
+    }
   },
   plugins: [
-    require("@tailwindcss/forms"),
+    require('@tailwindcss/forms'),
     // Allows prefixing tailwind classes with LiveView classes to add rules
     // only when LiveView classes are applied, for example:
     //
     //     <div class="phx-click-loading:animate-ping">
     //
-    plugin(({addVariant}) => addVariant("phx-no-feedback", [".phx-no-feedback&", ".phx-no-feedback &"])),
-    plugin(({addVariant}) => addVariant("phx-click-loading", [".phx-click-loading&", ".phx-click-loading &"])),
-    plugin(({addVariant}) => addVariant("phx-submit-loading", [".phx-submit-loading&", ".phx-submit-loading &"])),
-    plugin(({addVariant}) => addVariant("phx-change-loading", [".phx-change-loading&", ".phx-change-loading &"])),
+    plugin(({ addVariant }) =>
+      addVariant('phx-no-feedback', ['.phx-no-feedback&', '.phx-no-feedback &'])
+    ),
+    plugin(({ addVariant }) =>
+      addVariant('phx-click-loading', ['.phx-click-loading&', '.phx-click-loading &'])
+    ),
+    plugin(({ addVariant }) =>
+      addVariant('phx-submit-loading', ['.phx-submit-loading&', '.phx-submit-loading &'])
+    ),
+    plugin(({ addVariant }) =>
+      addVariant('phx-change-loading', ['.phx-change-loading&', '.phx-change-loading &'])
+    ),
 
     // Embeds Heroicons (https://heroicons.com) into your app.css bundle
     // See your `CoreComponents.icon/1` for more information.
     //
-    plugin(function({matchComponents, theme}) {
-      let iconsDir = path.join(__dirname, "./vendor/heroicons/optimized")
+    plugin(function ({ matchComponents, theme }) {
+      let iconsDir = path.join(__dirname, './vendor/heroicons/optimized')
       let values = {}
       let icons = [
-        ["", "/24/outline"],
-        ["-solid", "/24/solid"],
-        ["-mini", "/20/solid"]
+        ['', '/24/outline'],
+        ['-solid', '/24/solid'],
+        ['-mini', '/20/solid']
       ]
       icons.forEach(([suffix, dir]) => {
-        fs.readdirSync(path.join(iconsDir, dir)).forEach(file => {
-          let name = path.basename(file, ".svg") + suffix
-          values[name] = {name, fullPath: path.join(iconsDir, dir, file)}
+        fs.readdirSync(path.join(iconsDir, dir)).forEach((file) => {
+          let name = path.basename(file, '.svg') + suffix
+          values[name] = { name, fullPath: path.join(iconsDir, dir, file) }
         })
       })
-      matchComponents({
-        "hero": ({name, fullPath}) => {
-          let content = fs.readFileSync(fullPath).toString().replace(/\r?\n|\r/g, "")
-          return {
-            [`--hero-${name}`]: `url('data:image/svg+xml;utf8,${content}')`,
-            "-webkit-mask": `var(--hero-${name})`,
-            "mask": `var(--hero-${name})`,
-            "mask-repeat": "no-repeat",
-            "background-color": "currentColor",
-            "vertical-align": "middle",
-            "display": "inline-block",
-            "width": theme("spacing.5"),
-            "height": theme("spacing.5")
+      matchComponents(
+        {
+          hero: ({ name, fullPath }) => {
+            let content = fs
+              .readFileSync(fullPath)
+              .toString()
+              .replace(/\r?\n|\r/g, '')
+            return {
+              [`--hero-${name}`]: `url('data:image/svg+xml;utf8,${content}')`,
+              '-webkit-mask': `var(--hero-${name})`,
+              mask: `var(--hero-${name})`,
+              'mask-repeat': 'no-repeat',
+              'background-color': 'currentColor',
+              'vertical-align': 'middle',
+              display: 'inline-block',
+              width: theme('spacing.5'),
+              height: theme('spacing.5')
+            }
           }
-        }
-      }, {values})
+        },
+        { values }
+      )
     })
   ]
 }

assets/yarn.lock

@@ -2,3 +2,21 @@
 # yarn lockfile v1
 
 
+"@vue/reactivity@~3.1.1":
+  version "3.1.5"
+  resolved "https://registry.yarnpkg.com/@vue/reactivity/-/reactivity-3.1.5.tgz#dbec4d9557f7c8f25c2635db1e23a78a729eb991"
+  integrity sha512-1tdfLmNjWG6t/CsPldh+foumYFo3cpyCHgBYQ34ylaMsJ+SNHQ1kApMIa8jN+i593zQuaw3AdWH0nJTARzCFhg==
+  dependencies:
+    "@vue/shared" "3.1.5"
+
+"@vue/shared@3.1.5":
+  version "3.1.5"
+  resolved "https://registry.yarnpkg.com/@vue/shared/-/shared-3.1.5.tgz#74ee3aad995d0a3996a6bb9533d4d280514ede03"
+  integrity sha512-oJ4F3TnvpXaQwZJNF3ZK+kLPHKarDmJjJ6jyzVNDKH9md1dptjC7lWR//jrGuLdek/U6iltWxqAnYOu8gCiOvA==
+
+alpinejs@^3.13.5:
+  version "3.13.5"
+  resolved "https://registry.yarnpkg.com/alpinejs/-/alpinejs-3.13.5.tgz#c06f067e847a295085b4c6f76c42a6a35499d953"
+  integrity sha512-1d2XeNGN+Zn7j4mUAKXtAgdc4/rLeadyTMWeJGXF5DzwawPBxwTiBhFFm6w/Ei8eJxUZeyNWWSD9zknfdz1kEw==
+  dependencies:
+    "@vue/reactivity" "~3.1.1"

config/config.exs

@@ -9,11 +9,25 @@ import Config
 
 config :pinchflat,
   ecto_repos: [Pinchflat.Repo],
-  generators: [timestamp_type: :utc_datetime]
+  generators: [timestamp_type: :utc_datetime],
+  # Specifying backend data here makes mocking and local testing SUPER easy
+  yt_dlp_executable: System.find_executable("yt-dlp"),
+  yt_dlp_runner: Pinchflat.YtDlp.Backend.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",
+  tmpfile_directory: Path.join([System.tmp_dir!(), "pinchflat", "data"]),
+  # Setting BASIC_AUTH_USERNAME and BASIC_AUTH_PASSWORD implies you want to use basic auth.
+  # If either is unset, basic auth will not be used.
+  basic_auth_username: System.get_env("BASIC_AUTH_USERNAME"),
+  basic_auth_password: System.get_env("BASIC_AUTH_PASSWORD"),
+  file_watcher_poll_interval: 1000
 
 # Configures the endpoint
 config :pinchflat, PinchflatWeb.Endpoint,
-  url: [host: "localhost"],
+  url: [host: "localhost", port: 8945],
+  # NOTE: this must be updated if ever deployed traditionally (ie: not self-hosted)
+  check_origin: false,
   adapter: Phoenix.Endpoint.Cowboy2Adapter,
   render_errors: [
     formats: [html: PinchflatWeb.ErrorHTML, json: PinchflatWeb.ErrorJSON],
@@ -22,6 +36,21 @@ config :pinchflat, PinchflatWeb.Endpoint,
   pubsub_server: Pinchflat.PubSub,
   live_view: [signing_salt: "/t5878kO"]
 
+config :pinchflat, Oban,
+  engine: Oban.Engines.Lite,
+  repo: Pinchflat.Repo,
+  # Keep old jobs for 30 days for display in the UI
+  plugins: [{Oban.Plugins.Pruner, max_age: 30 * 24 * 60 * 60}],
+  # TODO: consider making this an env var or something?
+  queues: [
+    default: 10,
+    fast_indexing: 6,
+    media_indexing: 2,
+    media_collection_indexing: 2,
+    media_fetching: 2,
+    media_local_metadata: 8
+  ]
+
 # Configures the mailer
 #
 # By default it uses the "Local" adapter which stores the emails

config/dev.exs

@@ -1,14 +1,15 @@
 import Config
 
+config :pinchflat,
+  media_directory: Path.join([File.cwd!(), "tmp", "media"]),
+  metadata_directory: Path.join([File.cwd!(), "tmp", "metadata"]),
+  tmpfile_directory: Path.join([File.cwd!(), "tmp", "tmpfiles"])
+
 # Configure your database
 config :pinchflat, Pinchflat.Repo,
-  username: System.get_env("POSTGRES_USER"),
-  password: System.get_env("POSTGRES_PASSWORD"),
-  hostname: System.get_env("POSTGRES_HOST"),
-  database: "pinchflat_dev",
-  stacktrace: true,
+  database: Path.expand("../priv/repo/pinchflat_dev.db", Path.dirname(__ENV__.file)),
   show_sensitive_data_on_connection_error: true,
-  pool_size: 10
+  pool_size: 5
 
 # For development, we disable any cache and enable
 # debugging and code reloading.
@@ -20,7 +21,6 @@ config :pinchflat, PinchflatWeb.Endpoint,
   # Binding to loopback ipv4 address prevents access from other machines.
   # Change to `ip: {0, 0, 0, 0}` to allow access from other machines.
   http: [port: 4008],
-  check_origin: false,
   code_reloader: true,
   debug_errors: true,
   secret_key_base: "QLKKs3ypkUgJ/fMnWZaIYqpMbnA4IlPVEm3tvezsblhFDv4b67rdp+AmTpAFFURK",

config/runtime.exs

@@ -1,4 +1,5 @@
 import Config
+require Logger
 
 # config/runtime.exs is executed for all environments, including
 # during releases. It is executed after compilation and before the
@@ -20,21 +21,41 @@ if System.get_env("PHX_SERVER") do
   config :pinchflat, PinchflatWeb.Endpoint, server: true
 end
 
+config :pinchflat,
+  basic_auth_username: System.get_env("BASIC_AUTH_USERNAME"),
+  basic_auth_password: System.get_env("BASIC_AUTH_PASSWORD")
+
 if config_env() == :prod do
-  database_url =
-    System.get_env("DATABASE_URL") ||
+  config_path =
+    System.get_env("CONFIG_PATH") ||
       raise """
-      environment variable DATABASE_URL is missing.
-      For example: ecto://USER:PASS@HOST/DATABASE
+      environment variable CONFIG_PATH is missing.
+      For example: /etc/pinchflat/config
       """
 
-  maybe_ipv6 = if System.get_env("ECTO_IPV6") in ~w(true 1), do: [:inet6], else: []
+  db_path = System.get_env("DATABASE_PATH", Path.join([config_path, "db", "pinchflat.db"]))
+  log_path = System.get_env("LOG_PATH", Path.join([config_path, "logs", "pinchflat.log"]))
+  metadata_path = System.get_env("METADATA_PATH", Path.join([config_path, "metadata"]))
+
+  # We want to force _some_ level of useful logging in production
+  acceptable_log_levels = ~w(debug info)a
+  log_level = String.to_existing_atom(System.get_env("LOG_LEVEL", "info"))
+
+  if log_level in acceptable_log_levels do
+    config :logger, level: log_level
+  else
+    Logger.error("Invalid log level: #{log_level}. Defaulting to info.")
+    config :logger, level: :info
+  end
+
+  config :pinchflat,
+    yt_dlp_executable: System.find_executable("yt-dlp"),
+    metadata_directory: metadata_path,
+    dns_cluster_query: System.get_env("DNS_CLUSTER_QUERY")
 
   config :pinchflat, Pinchflat.Repo,
-    # ssl: true,
-    url: database_url,
-    pool_size: String.to_integer(System.get_env("POOL_SIZE") || "10"),
-    socket_options: maybe_ipv6
+    database: db_path,
+    pool_size: String.to_integer(System.get_env("POOL_SIZE") || "5")
 
   # The secret key base is used to sign/encrypt cookies and other secrets.
   # A default value is used in config/dev.exs and config/test.exs but you
@@ -42,29 +63,52 @@ if config_env() == :prod do
   # to check this value into version control, so we use an environment
   # variable instead.
   secret_key_base =
-    System.get_env("SECRET_KEY_BASE") ||
-      raise """
-      environment variable SECRET_KEY_BASE is missing.
-      You can generate one by calling: mix phx.gen.secret
-      """
+    if System.get_env("SECRET_KEY_BASE") do
+      System.get_env("SECRET_KEY_BASE")
+    else
+      if System.get_env("RUN_CONTEXT") == "selfhosted" do
+        # Using the default SECRET_KEY_BASE in a conventional production environment
+        # is dangerous. Please set the SECRET_KEY_BASE environment variable if you're
+        # deploying this to an internet-facing server. If you're running this in a
+        # private network, it's likely safe to use the default value. If you want
+        # to be extra safe, run `mix phx.gen.secret` and set the SECRET_KEY_BASE
+        # environment variable to the output of that command.
 
-  host = System.get_env("PHX_HOST") || "example.com"
-  port = String.to_integer(System.get_env("PORT") || "4000")
-
-  config :pinchflat, :dns_cluster_query, System.get_env("DNS_CLUSTER_QUERY")
+        "ZkuQMStdmUzBv+gO3m3XZrtQW76e+AX3QIgTLajw3b/HkTLMEx+DOXr2WZsSS+n8"
+      else
+        raise """
+        environment variable SECRET_KEY_BASE is missing.
+        You can generate one by calling: mix phx.gen.secret
+        """
+      end
+    end
 
   config :pinchflat, PinchflatWeb.Endpoint,
-    url: [host: host, port: 443, scheme: "https"],
     http: [
       # Enable IPv6 and bind on all interfaces.
       # Set it to  {0, 0, 0, 0, 0, 0, 0, 1} for local network only access.
       # See the documentation on https://hexdocs.pm/plug_cowboy/Plug.Cowboy.html
       # for details about using IPv6 vs IPv4 and loopback vs public addresses.
       ip: {0, 0, 0, 0, 0, 0, 0, 0},
-      port: port
+      port: String.to_integer(System.get_env("PORT") || "4000")
     ],
     secret_key_base: secret_key_base
 
+  config :pinchflat, :logger, [
+    {:handler, :file_log, :logger_std_h,
+     %{
+       config: %{
+         type: :file,
+         file: String.to_charlist(log_path),
+         filesync_repeat_interval: 5000,
+         file_check: 5000,
+         max_no_files: 5,
+         max_no_bytes: 10_000_000
+       },
+       formatter: Logger.Formatter.new()
+     }}
+  ]
+
   # ## SSL Support
   #
   # To get SSL working, you will need to add the `https` key

config/test.exs

@@ -1,17 +1,24 @@
 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"]),
+  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"]),
+  file_watcher_poll_interval: 50
+
+config :pinchflat, Oban, testing: :manual
+
 # Configure your database
 #
 # The MIX_TEST_PARTITION environment variable can be used
 # to provide built-in test partitioning in CI environment.
 # Run `mix help test` for more information.
 config :pinchflat, Pinchflat.Repo,
-  username: "postgres",
-  password: "postgres",
-  hostname: "localhost",
-  database: "pinchflat_test#{System.get_env("MIX_TEST_PARTITION")}",
-  pool: Ecto.Adapters.SQL.Sandbox,
-  pool_size: 10
+  database: Path.expand("../priv/repo/pinchflat_test.db", Path.dirname(__ENV__.file)),
+  pool_size: 5,
+  pool: Ecto.Adapters.SQL.Sandbox
 
 # We don't run a server during test. If one is required,
 # you can enable the server option below.

dev.Dockerfile

@@ -3,7 +3,8 @@ FROM elixir:latest
 
 # Install debian packages
 RUN apt-get update -qq
-RUN apt-get install -y inotify-tools postgresql-client ffmpeg 
+RUN apt-get install -y inotify-tools ffmpeg \
+  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
@@ -11,16 +12,24 @@ RUN bash nodesource_setup.sh
 RUN apt-get install nodejs
 RUN npm install -g yarn
 
-# Install Phoenix packages
+# Install baseline Elixir packages
 RUN mix local.hex --force
 RUN mix local.rebar --force
 
+# Download YT-DLP
+# NOTE: If you're seeing weird issues, consider using the FFMPEG released by yt-dlp
+RUN python3 -m pip install -U --pre yt-dlp --break-system-packages
+
 # Create app directory and copy the Elixir projects into it.
 WORKDIR /app
 COPY . ./
 
 # Needs permissions to be updated AFTER the copy step
-RUN chmod +x ./docker-run.sh
+RUN chmod +x ./docker-run.dev.sh
+
+# Install Elixir deps
+RUN mix deps.get
+# Gives us iex shell history
+ENV ERL_AFLAGS="-kernel shell_history enabled"
 
-# # Compile the project.
 EXPOSE 4008

docker-compose.ci.yml

@@ -0,0 +1,13 @@
+version: '3'
+services:
+  phx:
+    build:
+      context: .
+      dockerfile: dev.Dockerfile
+    environment:
+      - MIX_ENV=test
+    volumes:
+      - '.:/app'
+    ports:
+      - '4008:4008'
+    command: tail -F /dev/null

docker-compose.yml

@@ -1,23 +1,14 @@
 version: '3'
 services:
-  postgres:
-    image: 'postgres:16-alpine'
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-
   phx:
-    build: .
+    build:
+      context: .
+      dockerfile: dev.Dockerfile
     volumes:
       - '.:/app'
     ports:
       - '4008:4008'
-    depends_on:
-      - postgres
-    # command: 'sh -c "trap : TERM INT; tail -f /dev/null & wait"'
     command:
-      - ./docker-run.sh
+      - ./docker-run.dev.sh
     stdin_open: true
     tty: true
-    env_file:
-      - .env

docker-run.dev.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -e
+
+# Ensure the app's deps are installed
+mix deps.get
+
+# Install JS deps
+echo "\nInstalling JS..."
+cd assets && yarn install
+cd ..
+
+# Potentially Set up the database
+mix ecto.create
+mix ecto.migrate
+
+# Start the phoenix web server (interactive)
+echo "\n Launching Phoenix web server..."
+iex -S mix phx.server

docker-run.sh

@@ -1,28 +0,0 @@
-#!/bin/sh
-
-set -e
-
-# Ensure the app's deps are installed
-mix deps.get
-
-# Install JS deps
-echo "\nInstalling JS..."
-cd assets && yarn install
-cd ..
-
-# Wait for Postgres to become available.
-export PGPASSWORD=$(echo $POSTGRES_PASSWORD)
-until psql -h postgres -U $POSTGRES_USER -c '\q' 2>/dev/null; do
-  echo >&2 "Postgres is unavailable - sleeping"
-  sleep 1
-done
-
-echo "\nPostgres is available: continuing with database setup..."
-
-# Potentially Set up the database
-mix ecto.create
-mix ecto.migrate
-
-# Start the phoenix web server
-echo "\n Launching Phoenix web server..."
-mix phx.server

ideas.md

@@ -0,0 +1,6 @@
+- Write media datbase ID as metadata/to file/whatever so it gives us an option to retroactively match media to the DB down the line. Useful if someone moves the media without informing the UI
+  - Use a UUID for the media database ID (or at least alongside it)
+- Look into this and its recommended plugins https://hexdocs.pm/ex_check/readme.html
+- Add output template option for the source's friendly name
+- TODO: Install Elixir 1.16.2 when available to fix bug with `ex_check` https://github.com/karolsluszniak/ex_check/issues/41#issuecomment-1921390413
+  - delete `{:elixir_tests, "mix test"}` and formatting check

lib/pinchflat/api/youtube_rss.ex

@@ -0,0 +1,51 @@
+defmodule Pinchflat.Api.YoutubeRss do
+  @moduledoc """
+  Methods for interacting with YouTube RSS feeds
+  """
+
+  require Logger
+
+  alias Pinchflat.Sources.Source
+
+  @doc """
+  Fetches the recent media IDs from a YouTube RSS feed for a given source.
+
+  Returns {:ok, [binary()]} | {:error, binary()}
+  """
+  def get_recent_media_ids_from_rss(%Source{} = source) do
+    Logger.debug("Fetching recent media IDs from YouTube RSS feed for source: #{source.collection_id}")
+
+    case http_client().get(rss_url_for_source(source)) do
+      {:ok, response} ->
+        response = to_string(response)
+        media_id_regex = ~r/<yt:videoId>(.*?)<\/yt:videoId>/
+
+        # Don't get on me about using regex to search XML.
+        # The content is known, well-formed, and simple.
+        media_ids =
+          media_id_regex
+          |> Regex.scan(response)
+          |> Enum.map(fn [_, id] -> String.trim(id) end)
+          |> Enum.filter(&(String.length(&1) > 0))
+          |> Enum.uniq()
+
+        Logger.debug("Media ids fetched from RSS: #{inspect(media_ids)}")
+
+        {:ok, media_ids}
+
+      {:error, _reason} ->
+        {:error, "Failed to fetch RSS feed"}
+    end
+  end
+
+  defp rss_url_for_source(source) do
+    case source.collection_type do
+      :channel -> "https://www.youtube.com/feeds/videos.xml?channel_id=#{source.collection_id}"
+      :playlist -> "https://www.youtube.com/feeds/videos.xml?playlist_id=#{source.collection_id}"
+    end
+  end
+
+  defp http_client do
+    Application.get_env(:pinchflat, :http_client, Pinchflat.HTTP.HTTPClient)
+  end
+end

lib/pinchflat/application.ex

@@ -10,6 +10,9 @@ defmodule Pinchflat.Application do
     children = [
       PinchflatWeb.Telemetry,
       Pinchflat.Repo,
+      # Must be before startup tasks
+      {Oban, Application.fetch_env!(:pinchflat, Oban)},
+      Pinchflat.StartupTasks,
       {DNSCluster, query: Application.get_env(:pinchflat, :dns_cluster_query) || :ignore},
       {Phoenix.PubSub, name: Pinchflat.PubSub},
       # Start the Finch HTTP client for sending emails
@@ -20,6 +23,9 @@ defmodule Pinchflat.Application do
       PinchflatWeb.Endpoint
     ]
 
+    :ok = Oban.Telemetry.attach_default_logger()
+    Logger.add_handlers(:pinchflat)
+
     # See https://hexdocs.pm/elixir/Supervisor.html
     # for other strategies and supported options
     opts = [strategy: :one_for_one, name: Pinchflat.Supervisor]

lib/pinchflat/http/http_behaviour.ex

@@ -0,0 +1,10 @@
+defmodule Pinchflat.HTTP.HTTPBehaviour do
+  @moduledoc """
+  This module defines the behaviour for HTTP clients. Literally just
+  so I can use Mox to create an HTTP mock
+  """
+
+  @callback get(String.t()) :: {:ok, String.t()} | {:error, String.t()}
+  @callback get(String.t(), Keyword.t()) :: {:ok, String.t()} | {:error, String.t()}
+  @callback get(String.t(), Keyword.t(), Keyword.t()) :: {:ok, String.t()} | {:error, String.t()}
+end

lib/pinchflat/http/http_client.ex

@@ -0,0 +1,35 @@
+defmodule Pinchflat.HTTP.HTTPClient do
+  @moduledoc """
+  This module provides a simple interface for making HTTP requests.
+
+  Made to be easily swappable with other HTTP clients. If you need more complexity
+  or security, check out HTTPoison or Mint.
+  """
+
+  alias Pinchflat.HTTP.HTTPBehaviour
+
+  @behaviour HTTPBehaviour
+
+  @doc """
+  Makes a GET request to the given URL and returns the response.
+
+  NOTE: I can't really test this with Mox and I can't think of a way to test this
+  that isn't ultimately redundant. I'm just going to leave it untested for now and
+  focus more on testing the consumers of this module.
+
+  Returns {:ok, String.t()} | {:error, String.t()}
+  """
+  @impl HTTPBehaviour
+  def get(url, headers \\ [], opts \\ []) do
+    case :httpc.request(:get, {url, headers}, [], opts) do
+      {:ok, {{_version, 200, _reason_phrase}, _headers, body}} ->
+        {:ok, body}
+
+      {:ok, {{_version, status_code, reason_phrase}, _headers, _body}} ->
+        {:error, "HTTP request failed with status code #{status_code}: #{reason_phrase}"}
+
+      {:error, reason} ->
+        {:error, "HTTP request failed: #{reason}"}
+    end
+  end
+end

lib/pinchflat/media.ex

@@ -0,0 +1,307 @@
+defmodule Pinchflat.Media do
+  @moduledoc """
+  The Media context.
+  """
+
+  import Ecto.Query, warn: false
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Tasks
+  alias Pinchflat.Media.MediaItem
+  alias Pinchflat.Sources.Source
+  alias Pinchflat.Media.MediaMetadata
+
+  @doc """
+  Returns the list of media_items.
+
+  Returns [%MediaItem{}, ...].
+  """
+  def list_media_items do
+    Repo.all(MediaItem)
+  end
+
+  @doc """
+  Returns a list of media_items for a given source.
+
+  Returns [%MediaItem{}, ...].
+  """
+  def list_media_items_for(%Source{} = source) do
+    MediaItem
+    |> where([mi], mi.source_id == ^source.id)
+    |> Repo.all()
+  end
+
+  @doc """
+  Fetches all media items belonging to a given source that have a media_id in the given list.
+  Useful for determining the what media items we DON'T already have for fast indexing.
+
+  NOTE: These queries are getting a little tedious. When I have the time, I should see about
+  implementing a query pattern and having these compose queries from a common base. This would
+  also let me compose simple queries in the module using them for one-off methods
+
+  Returns [%MediaItem{}, ...].
+  """
+  def list_media_items_by_media_id_for(%Source{} = source, media_ids) do
+    MediaItem
+    |> where([mi], mi.source_id == ^source.id and mi.media_id in ^media_ids)
+    |> 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 the format selection rules of the parent media_profile.
+
+  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, opts \\ []) do
+    limit = Keyword.get(opts, :limit, nil)
+    media_profile = Repo.preload(source, :media_profile).media_profile
+
+    MediaItem
+    |> where([mi], mi.source_id == ^source.id and is_nil(mi.media_filepath))
+    |> where(^build_format_clauses(media_profile))
+    |> where(^maybe_apply_cutoff_date(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)
+
+    MediaItem
+    |> where([mi], mi.source_id == ^source.id and not is_nil(mi.media_filepath))
+    |> Repo.maybe_limit(limit)
+    |> 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.
+
+  Intentionally does not take the `download_media` setting of the source into account.
+
+  Returns boolean()
+  """
+  def pending_download?(%MediaItem{} = media_item) do
+    media_item = Repo.preload(media_item, source: :media_profile)
+
+    MediaItem
+    |> where([mi], mi.id == ^media_item.id and is_nil(mi.media_filepath))
+    |> where(^build_format_clauses(media_item.source.media_profile))
+    |> where(^maybe_apply_cutoff_date(media_item.source))
+    |> Repo.exists?()
+  end
+
+  @doc """
+  Returns a list of media_items that match the search term. Adds a `matching_search_term`
+  virtual field to the result set.
+
+  Has explit handling for blank search terms because SQLite doesn't like empty MATCH clauses.
+
+  Returns [%MediaItem{}, ...].
+  """
+  def search(_search_term, _opts \\ [])
+  def search("", _opts), do: []
+  def search(nil, _opts), do: []
+
+  def search(search_term, opts) do
+    limit = Keyword.get(opts, :limit, 50)
+
+    from(mi in MediaItem,
+      join: mi_search_index in assoc(mi, :media_items_search_index),
+      where: fragment("media_items_search_index MATCH ?", ^search_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")],
+      limit: ^limit
+    )
+    |> Repo.all()
+  end
+
+  @doc """
+  Gets a single media_item.
+
+  Returns %MediaItem{}. Raises `Ecto.NoResultsError` if the Media item does not exist.
+  """
+  def get_media_item!(id), do: Repo.get!(MediaItem, id)
+
+  @doc """
+  Produces a flat list of the filesystem paths for a media_item's downloaded files
+
+  Returns [binary()]
+  """
+  def media_filepaths(media_item) do
+    mapped_struct = Map.from_struct(media_item)
+
+    MediaItem.filepath_attributes()
+    |> Enum.map(fn
+      :subtitle_filepaths = field -> Enum.map(mapped_struct[field], fn [_, filepath] -> filepath end)
+      field -> List.wrap(mapped_struct[field])
+    end)
+    |> List.flatten()
+    |> Enum.filter(&is_binary/1)
+  end
+
+  @doc """
+  Produces a flat list of the filesystem paths for a media_item's metadata files.
+  Returns an empty list if the media_item has no metadata.
+
+  Returns [binary()] | []
+  """
+  def metadata_filepaths(media_item) do
+    metadata = Repo.preload(media_item, :metadata).metadata || %MediaMetadata{}
+    mapped_struct = Map.from_struct(metadata)
+
+    MediaMetadata.filepath_attributes()
+    |> Enum.map(fn field -> mapped_struct[field] end)
+    |> Enum.filter(&is_binary/1)
+  end
+
+  @doc """
+  Creates a media_item.
+
+  Returns {:ok, %MediaItem{}} | {:error, %Ecto.Changeset{}}
+  """
+  def create_media_item(attrs) do
+    %MediaItem{}
+    |> MediaItem.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Creates a media item from the attributes returned by the video backend
+  (read: yt-dlp).
+
+  Unlike `create_media_item`, this will attempt an update if the media_item
+  already exists. This is so that future indexing can pick up attributes that
+  we may not have asked for in the past (eg: upload_date)
+
+  Returns {:ok, %MediaItem{}} | {:error, %Ecto.Changeset{}}
+  """
+  def create_media_item_from_backend_attrs(source, media_attrs_struct) do
+    attrs = Map.merge(%{source_id: source.id}, Map.from_struct(media_attrs_struct))
+
+    %MediaItem{}
+    |> MediaItem.changeset(attrs)
+    |> Repo.insert(
+      on_conflict: [
+        set: Map.to_list(attrs)
+      ],
+      conflict_target: [:source_id, :media_id]
+    )
+  end
+
+  @doc """
+  Updates a media_item.
+
+  Returns {:ok, %MediaItem{}} | {:error, %Ecto.Changeset{}}
+  """
+  def update_media_item(%MediaItem{} = media_item, attrs) do
+    media_item
+    |> MediaItem.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a media_item and its associated tasks.
+  Can optionally delete the media_item's files.
+
+  Returns {:ok, %MediaItem{}} | {:error, %Ecto.Changeset{}}
+  """
+  def delete_media_item(%MediaItem{} = media_item, opts \\ []) do
+    delete_files = Keyword.get(opts, :delete_files, false)
+
+    if delete_files do
+      {:ok, _} = delete_all_attachments(media_item)
+    end
+
+    Tasks.delete_tasks_for(media_item)
+    Repo.delete(media_item)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking media_item changes.
+  """
+  def change_media_item(%MediaItem{} = media_item, attrs \\ %{}) do
+    MediaItem.changeset(media_item, attrs)
+  end
+
+  defp delete_all_attachments(media_item) do
+    media_item = Repo.preload(media_item, :metadata)
+
+    media_item
+    |> media_filepaths()
+    |> Enum.concat(metadata_filepaths(media_item))
+    |> Enum.each(&File.rm/1)
+
+    # rmdir will attempt to delete the directory, but only if it is empty
+    if media_item.media_filepath do
+      File.rmdir(Path.dirname(media_item.media_filepath))
+    end
+
+    if media_item.metadata && media_item.metadata.metadata_filepath do
+      File.rmdir(Path.dirname(media_item.metadata.metadata_filepath))
+    end
+
+    {:ok, media_item}
+  end
+
+  defp maybe_apply_cutoff_date(source) do
+    if source.download_cutoff_date do
+      dynamic([mi], mi.upload_date >= ^source.download_cutoff_date)
+    else
+      dynamic(true)
+    end
+  end
+
+  defp build_format_clauses(media_profile) do
+    mapped_struct = Map.from_struct(media_profile)
+
+    Enum.reduce(mapped_struct, dynamic(true), fn attr, dynamic ->
+      case {attr, media_profile} do
+        {{:shorts_behaviour, :only}, %{livestream_behaviour: :only}} ->
+          dynamic(
+            [mi],
+            ^dynamic and (mi.livestream == true or mi.short_form_content == true)
+          )
+
+        # Technically redundant, but makes the other clauses easier to parse
+        # (redundant because this condition is the same as the condition above, just flipped)
+        {{:livestream_behaviour, :only}, %{shorts_behaviour: :only}} ->
+          dynamic
+
+        {{:shorts_behaviour, :only}, _} ->
+          dynamic([mi], ^dynamic and mi.short_form_content == true)
+
+        {{:livestream_behaviour, :only}, _} ->
+          dynamic([mi], ^dynamic and mi.livestream == true)
+
+        {{: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)
+  end
+end

lib/pinchflat/media/media_item.ex

@@ -0,0 +1,87 @@
+defmodule Pinchflat.Media.MediaItem do
+  @moduledoc """
+  The MediaItem schema.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  alias Pinchflat.Tasks.Task
+  alias Pinchflat.Sources.Source
+  alias Pinchflat.Media.MediaMetadata
+  alias Pinchflat.Media.MediaItemSearchIndex
+
+  @allowed_fields [
+    # these fields are captured on indexing (and again on download)
+    :title,
+    :media_id,
+    :description,
+    :original_url,
+    :livestream,
+    :source_id,
+    :short_form_content,
+    :upload_date,
+    # these fields are captured only on download
+    :media_downloaded_at,
+    :media_filepath,
+    :media_size_bytes,
+    :subtitle_filepaths,
+    :thumbnail_filepath,
+    :metadata_filepath
+  ]
+  # Pretty much all the fields captured at index are required.
+  @required_fields ~w(
+    title
+    original_url
+    livestream
+    media_id
+    source_id
+    upload_date
+    short_form_content
+    )a
+
+  schema "media_items" do
+    field :title, :string
+    field :media_id, :string
+    field :description, :string
+    field :original_url, :string
+    field :livestream, :boolean, default: false
+    field :short_form_content, :boolean, default: false
+    field :media_downloaded_at, :utc_datetime
+    field :upload_date, :date
+
+    field :media_filepath, :string
+    field :media_size_bytes, :integer
+    field :thumbnail_filepath, :string
+    field :metadata_filepath, :string
+    # This is an array of [iso-2 language, filepath] pairs. Probably could
+    # be an associated record, but I don't see the benefit right now.
+    # Will very likely revisit because I can't leave well-enough alone.
+    field :subtitle_filepaths, {:array, {:array, :string}}, default: []
+
+    field :matching_search_term, :string, virtual: true
+
+    belongs_to :source, Source
+
+    has_one :metadata, MediaMetadata, on_replace: :update
+    has_one :media_items_search_index, MediaItemSearchIndex, foreign_key: :id
+
+    has_many :tasks, Task
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(media_item, attrs) do
+    media_item
+    |> cast(attrs, @allowed_fields)
+    |> cast_assoc(:metadata, with: &MediaMetadata.changeset/2, required: false)
+    |> validate_required(@required_fields)
+    |> unique_constraint([:media_id, :source_id])
+  end
+
+  @doc false
+  def filepath_attributes do
+    ~w(media_filepath thumbnail_filepath metadata_filepath subtitle_filepaths)a
+  end
+end

lib/pinchflat/media/media_items_search_index.ex

@@ -0,0 +1,16 @@
+defmodule Pinchflat.Media.MediaItemSearchIndex do
+  @moduledoc """
+  The MediaItem fts5 search index. Not made to be directly interacted with,
+  but I figured it'd be better to have it in-app so it's not a mystery.
+  """
+
+  use Ecto.Schema
+
+  @primary_key {:id, :id, autogenerate: true, source: :rowid}
+  schema "media_items_search_index" do
+    field :title, :string
+    field :description, :string
+
+    field :rank, :float, virtual: true
+  end
+end

lib/pinchflat/media/media_metadata.ex

@@ -0,0 +1,37 @@
+defmodule Pinchflat.Media.MediaMetadata do
+  @moduledoc """
+  The MediaMetadata schema.
+
+  Look. Don't @ me about Metadata vs. Metadatum. I'm very sensitive.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  alias Pinchflat.Media.MediaItem
+
+  @allowed_fields ~w(metadata_filepath thumbnail_filepath)a
+  @required_fields ~w(metadata_filepath thumbnail_filepath)a
+
+  schema "media_metadata" do
+    field :metadata_filepath, :string
+    field :thumbnail_filepath, :string
+
+    belongs_to :media_item, MediaItem
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(media_metadata, attrs) do
+    media_metadata
+    |> cast(attrs, @allowed_fields)
+    |> validate_required(@required_fields)
+    |> unique_constraint([:media_item_id])
+  end
+
+  @doc false
+  def filepath_attributes do
+    ~w(metadata_filepath thumbnail_filepath)a
+  end
+end

lib/pinchflat/metadata/metadata_file_helpers.ex

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

lib/pinchflat/metadata/metadata_parser.ex

@@ -0,0 +1,67 @@
+defmodule Pinchflat.Metadata.MetadataParser do
+  @moduledoc """
+  yt-dlp offers a LOT of metadata in its JSON response, some of which
+  needs to be extracted and included in various models.
+
+  For now, also squirrel all of it away in the `media_metadata` table.
+  I might revisit this or pare it down later, but I'd rather need it
+  and not have it, ya know?
+  """
+
+  @doc """
+  Parses the given JSON response from yt-dlp and returns a map of
+  the needful media_item attributes, along with anything needed for
+  its associations.
+
+  Returns map()
+  """
+  def parse_for_media_item(metadata) do
+    Map.new()
+    |> Map.merge(parse_media_metadata(metadata))
+    |> Map.merge(parse_subtitle_metadata(metadata))
+    |> Map.merge(parse_thumbnail_metadata(metadata))
+    |> Map.merge(parse_infojson_metadata(metadata))
+  end
+
+  defp parse_media_metadata(metadata) do
+    %{
+      media_id: metadata["id"],
+      title: metadata["title"],
+      original_url: metadata["original_url"],
+      description: metadata["description"],
+      media_filepath: metadata["filepath"],
+      livestream: metadata["was_live"]
+    }
+  end
+
+  defp parse_subtitle_metadata(metadata) do
+    subtitle_filepaths =
+      (metadata["requested_subtitles"] || %{})
+      |> Enum.map(fn {lang, attrs} -> [lang, attrs["filepath"]] end)
+      |> Enum.sort(fn [lang_a, _], [lang_b, _] -> lang_a < lang_b end)
+
+    %{
+      subtitle_filepaths: subtitle_filepaths
+    }
+  end
+
+  defp parse_thumbnail_metadata(metadata) do
+    thumbnail_filepath =
+      (metadata["thumbnails"] || %{})
+      # Reverse so that higher resolution thumbnails come first.
+      # This _shouldn't_ matter yet, but I'd rather default to the best
+      # in case I'm wrong.
+      |> Enum.reverse()
+      |> Enum.find_value(fn attrs -> attrs["filepath"] end)
+
+    %{
+      thumbnail_filepath: thumbnail_filepath
+    }
+  end
+
+  defp parse_infojson_metadata(metadata) do
+    %{
+      metadata_filepath: metadata["infojson_filename"]
+    }
+  end
+end

lib/pinchflat/profiles.ex

@@ -0,0 +1,74 @@
+defmodule Pinchflat.Profiles do
+  @moduledoc """
+  The Profiles context.
+  """
+
+  import Ecto.Query, warn: false
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Sources
+  alias Pinchflat.Profiles.MediaProfile
+
+  @doc """
+  Returns the list of media_profiles.
+
+  Returns [%MediaProfile{}, ...]
+  """
+  def list_media_profiles do
+    Repo.all(MediaProfile)
+  end
+
+  @doc """
+  Gets a single media_profile.
+
+  Returns %MediaProfile{}. Raises `Ecto.NoResultsError` if the Media profile does not exist.
+  """
+  def get_media_profile!(id), do: Repo.get!(MediaProfile, id)
+
+  @doc """
+  Creates a media_profile.
+
+  Returns {:ok, %MediaProfile{}} | {:error, %Ecto.Changeset{}}
+  """
+  def create_media_profile(attrs) do
+    %MediaProfile{}
+    |> MediaProfile.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a media_profile.
+
+  Returns {:ok, %MediaProfile{}} | {:error, %Ecto.Changeset{}}
+  """
+  def update_media_profile(%MediaProfile{} = media_profile, attrs) do
+    media_profile
+    |> MediaProfile.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a media_profile, all its sources, and all their media items.
+  Can optionally delete the media files.
+
+  Returns {:ok, %MediaProfile{}} | {:error, %Ecto.Changeset{}}
+  """
+  def delete_media_profile(%MediaProfile{} = media_profile, opts \\ []) do
+    delete_files = Keyword.get(opts, :delete_files, false)
+
+    media_profile
+    |> Sources.list_sources_for()
+    |> Enum.each(fn source ->
+      Sources.delete_source(source, delete_files: delete_files)
+    end)
+
+    Repo.delete(media_profile)
+  end
+
+  @doc """
+  Returns `%Ecto.Changeset{}`
+  """
+  def change_media_profile(%MediaProfile{} = media_profile, attrs \\ %{}) do
+    MediaProfile.changeset(media_profile, attrs)
+  end
+end

lib/pinchflat/profiles/media_profile.ex

@@ -0,0 +1,70 @@
+defmodule Pinchflat.Profiles.MediaProfile do
+  @moduledoc """
+  A media profile is a set of configuration options that can be applied to many media sources
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  alias Pinchflat.Sources.Source
+
+  @allowed_fields ~w(
+    name
+    output_path_template
+    download_subs
+    download_auto_subs
+    embed_subs
+    sub_langs
+    download_thumbnail
+    embed_thumbnail
+    download_metadata
+    embed_metadata
+    shorts_behaviour
+    livestream_behaviour
+    preferred_resolution
+  )a
+
+  @required_fields ~w(name output_path_template)a
+
+  schema "media_profiles" do
+    field :name, :string
+
+    field :output_path_template, :string,
+      default: "/{{ source_custom_name }}/{{ title }}/{{ title }} [{{ id }}].{{ ext }}"
+
+    field :download_subs, :boolean, default: true
+    field :download_auto_subs, :boolean, default: true
+    field :embed_subs, :boolean, default: true
+    field :sub_langs, :string, default: "en"
+
+    field :download_thumbnail, :boolean, default: true
+    field :embed_thumbnail, :boolean, default: true
+
+    field :download_metadata, :boolean, default: true
+    field :embed_metadata, :boolean, default: true
+
+    # NOTE: these do NOT speed up indexing - the indexer still has to go
+    # through the entire collection to determine if a media is a short or
+    # a livestream.
+    # NOTE: these can BOTH be set to :only which will download shorts and
+    # livestreams _only_ and ignore regular media. The redundant case
+    # is when one is set to :only and the other is set to :exclude.
+    # 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
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(media_profile, attrs) do
+    media_profile
+    |> cast(attrs, @allowed_fields)
+    |> validate_required(@required_fields)
+    |> unique_constraint(:name)
+  end
+end

lib/pinchflat/profiles/output_path_builder.ex

@@ -0,0 +1,45 @@
+defmodule Pinchflat.Profiles.OutputPathBuilder do
+  @moduledoc """
+  Builds yt-dlp-friendly output paths for downloaded media
+  """
+
+  alias Pinchflat.RenderedString.Parser, as: TemplateParser
+
+  @doc """
+  Builds the actual final filepath from a given template. Optionally, you can pass in
+  a map of additional options to be used in the template.
+
+  Translates liquid-style templates into yt-dlp-style templates,
+  leaving yt-dlp syntax intact.
+  """
+  def build(template_string, additional_template_options \\ %{}) do
+    combined_options = Map.merge(custom_yt_dlp_option_map(), additional_template_options)
+
+    TemplateParser.parse(template_string, combined_options, &identifier_fn/2)
+  end
+
+  # The `nil` case simply wraps the identifier in yt-dlp-style syntax. This assumes that
+  # the identifier is a valid yt-dlp option. The upside is that this gives the user
+  # access to ALL single-word yt-dlp options in the (imo) more friendly/forgiving liquid-style syntax.
+  #
+  # For all "custom" variables, we use the `Map.get/3` function to look up the value in the provided.
+  # See `custom_yt_dlp_option_map` for a list of those.
+  defp identifier_fn(identifier, variables) do
+    case Map.get(variables, identifier) do
+      nil -> "%(#{identifier})S"
+      value -> value
+    end
+  end
+
+  # This isn't the only source for custom options, since they can be passed in my the caller.
+  # `download_option_builder` is the most likely place for other custom options to be added,
+  # but if in doubt just search the codebase for `OutputPathBuilder.build`.
+  defp custom_yt_dlp_option_map do
+    %{
+      # Individual parts of the upload date
+      "upload_year" => "%(upload_date>%Y)S",
+      "upload_month" => "%(upload_date>%m)S",
+      "upload_day" => "%(upload_date>%d)S"
+    }
+  end
+end

lib/pinchflat/release.ex

@@ -0,0 +1,28 @@
+defmodule Pinchflat.Release do
+  @moduledoc """
+  Used for executing DB release tasks when run in production without Mix
+  installed.
+  """
+  @app :pinchflat
+
+  def migrate do
+    load_app()
+
+    for repo <- repos() do
+      {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true))
+    end
+  end
+
+  def rollback(repo, version) do
+    load_app()
+    {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version))
+  end
+
+  defp repos do
+    Application.fetch_env!(@app, :ecto_repos)
+  end
+
+  defp load_app do
+    Application.load(@app)
+  end
+end

lib/pinchflat/rendered_string/base.ex

@@ -0,0 +1,52 @@
+defmodule Pinchflat.RenderedString.Base do
+  @moduledoc """
+  A base module for parsing rendered strings, designed as a macro to be used
+  in other modules. See https://elixirforum.com/t/help-to-parse-a-template-with-nimbleparsec/47980
+
+  NOTE: if the needs here get any more complicated, look into using a Liquid
+  template parser. No need to reinvent the wheel any more than I already have.
+
+  NOTE: this is effectively tested by the `Pinchflat.RenderedString.Parser`'s tests
+  """
+
+  defmacro __using__(_opts) do
+    quote location: :keep do
+      import NimbleParsec
+
+      opening_tag = string("{{")
+      closing_tag = string("}}")
+      optional_whitespaces = ascii_string(~c[ \t\n\r], min: 0)
+
+      # Capture everything up to the opening object
+      text =
+        lookahead_not(opening_tag)
+        # ... as long as it's a character
+        |> utf8_char([])
+        # ... and there's at least one character
+        |> times(min: 1)
+        # ... and then convert it to a string
+        |> reduce({List, :to_string, []})
+        # ... finally bag it and tag it
+        |> unwrap_and_tag(:text)
+
+      identifier =
+        utf8_string([?a..?z, ?A..?Z, ?_, ?0..?9], min: 1)
+        |> reduce({Enum, :join, []})
+        |> unwrap_and_tag(:identifier)
+
+      defparsecp(:expression, identifier)
+
+      # when spotting interpolation, ignore the opening tag and any whitespace
+      interpolation =
+        ignore(concat(opening_tag, optional_whitespaces))
+        # ... then parse the expression (identifier)
+        |> parsec(:expression)
+        # ... then ignore any whitespace and the closing tags after the expression
+        |> ignore(concat(optional_whitespaces, closing_tag))
+        # ... once again we bag it and tag it
+        |> unwrap_and_tag(:interpolation)
+
+      defparsec(:do_parse, choice([interpolation, text]) |> repeat() |> eos())
+    end
+  end
+end

lib/pinchflat/rendered_string/parser.ex

@@ -0,0 +1,42 @@
+defmodule Pinchflat.RenderedString.Parser do
+  @moduledoc """
+  Parses liquid-ish-style strings into a rendered string
+
+  Used for turning filepath templates into real filepaths
+  """
+
+  use Pinchflat.RenderedString.Base
+
+  @doc """
+  Parses a string into a rendered string, using the provided variables. Optionally
+  takes a custom fetcher function for handling missing variables.
+
+  Variable identifiers are surrounded by {{ and }}. The variable keys MUST be strings.
+  If an identifier is not found in the provided variables, it will be removed from the string.
+
+  Returns `{:ok, binary()}` or `{:error, binary()}`.
+  """
+  def parse(string, variables, value_fetch_fn \\ &default_fetcher/2) do
+    # `do_parse` comes from `RenderedString.Base`
+    case do_parse(string) do
+      {:ok, parsed, _, _, _, _} ->
+        {:ok, build_string(parsed, variables, value_fetch_fn)}
+
+      {:error, message, _, _, _, _} ->
+        {:error, message}
+    end
+  end
+
+  defp build_string(parsed, variables, value_fetch_fn) do
+    Enum.reduce(parsed, "", fn element, acc ->
+      case element do
+        {:text, text} -> acc <> text
+        {:interpolation, {:identifier, identifier}} -> acc <> value_fetch_fn.(identifier, variables)
+      end
+    end)
+  end
+
+  def default_fetcher(identifier, variables) do
+    Map.get(variables, identifier, "")
+  end
+end

lib/pinchflat/repo.ex

@@ -1,5 +1,30 @@
 defmodule Pinchflat.Repo do
   use Ecto.Repo,
     otp_app: :pinchflat,
-    adapter: Ecto.Adapters.Postgres
+    adapter: Ecto.Adapters.SQLite3
+
+  import Ecto.Query, warn: false
+
+  @doc """
+  It's not immediately obvious if an Oban job qualifies as unique, so this method
+  attempts creating a job and checks for the `conflict?` field in the returned job.
+
+  Returns {:ok, %Oban.Job{}} | {:duplicate, %Oban.Job{}} | {:error, any()}.
+  """
+  def insert_unique_job(job_struct) do
+    case Oban.insert(job_struct) do
+      {:ok, %Oban.Job{conflict?: false} = job} -> {:ok, job}
+      {:ok, %Oban.Job{conflict?: true} = job} -> {:duplicate, job}
+      err -> err
+    end
+  end
+
+  @doc """
+  Applies a limit to a query if provided, otherwise returns the query as-is.
+
+  Returns %Ecto.Query{}.
+  """
+  def maybe_limit(query, limit) do
+    if limit, do: limit(query, ^limit), else: query
+  end
 end

lib/pinchflat/settings.ex

@@ -0,0 +1,95 @@
+defmodule Pinchflat.Settings do
+  @moduledoc """
+  The Settings context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Pinchflat.Repo
+
+  alias Pinchflat.Settings.Setting
+
+  @doc """
+  Returns the list of settings.
+
+  Returns [%Setting{}, ...]
+  """
+  def list_settings do
+    Repo.all(Setting)
+  end
+
+  @doc """
+  Creates or updates a setting, returning the parsed value.
+  Raises if an unsupported datatype is used. Optionally allows
+  specifying the datatype.
+
+  Returns value in type of `Ecto.Enum.mappings(Setting, :datatype)`
+  """
+  def set!(name, value) do
+    set!(name, value, infer_datatype(value))
+  end
+
+  def set!(name, value, datatype) do
+    # Only create if doesn't exist
+    case Repo.get_by(Setting, name: to_string(name)) do
+      nil -> create_setting!(name, value, datatype)
+      setting -> update_setting!(setting, value, datatype)
+    end
+  end
+
+  @doc """
+  Gets the parsed value of a setting. Raises if the setting does not exist.
+
+  Returns value in type of `Ecto.Enum.mappings(Setting, :datatype)`
+  """
+  def get!(name) do
+    Setting
+    |> Repo.get_by!(name: to_string(name))
+    |> read_setting()
+  end
+
+  @doc """
+  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 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/settings/setting.ex

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

lib/pinchflat/sources.ex

@@ -0,0 +1,263 @@
+defmodule Pinchflat.Sources do
+  @moduledoc """
+  The Sources context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Pinchflat.Repo
+
+  alias Pinchflat.Media
+  alias Pinchflat.Tasks
+  alias Pinchflat.Sources.Source
+  alias Pinchflat.Tasks.SourceTasks
+  alias Pinchflat.Profiles.MediaProfile
+  alias Pinchflat.YtDlp.Backend.MediaCollection
+
+  @doc """
+  Returns the list of sources. Returns [%Source{}, ...]
+  """
+  def list_sources do
+    Repo.all(Source)
+  end
+
+  @doc """
+  Returns the list of sources for a media_profile.
+
+  Returns [%Source{}, ...]
+  """
+  def list_sources_for(%MediaProfile{} = media_profile) do
+    Repo.all(from s in Source, where: s.media_profile_id == ^media_profile.id)
+  end
+
+  @doc """
+  Gets a single source.
+
+  Returns %Source{}. Raises `Ecto.NoResultsError` if the Source does not exist.
+  """
+  def get_source!(id), do: Repo.get!(Source, id)
+
+  @doc """
+  Creates a source. May attempt to pull additional source details from the
+  original_url (if provided). Will attempt to start indexing the source's
+  media if successfully inserted.
+
+  Runs an initial `change_source` check to ensure most of the source is valid
+  before making an expensive API call. Runs it through `Repo.insert` even
+  though we know it's going to fail so it picks up any addl. database errors
+  and fulfills our return contract.
+
+  Returns {:ok, %Source{}} | {:error, %Ecto.Changeset{}}
+  """
+  def create_source(attrs) do
+    case change_source(%Source{}, attrs, :initial) do
+      %Ecto.Changeset{valid?: true} ->
+        %Source{}
+        |> change_source_from_url(attrs)
+        |> maybe_change_indexing_frequency()
+        |> commit_and_handle_tasks()
+
+      changeset ->
+        Repo.insert(changeset)
+    end
+  end
+
+  @doc """
+  Updates a source. May attempt to pull additional source details from the
+  original_url (if changed). May attempt to start indexing the source's
+  media if the indexing frequency has been changed.
+
+  Existing indexing tasks will be cancelled if the indexing frequency has been
+  changed (logic in `SourceTasks.kickoff_indexing_task`)
+
+  Runs an initial `change_source` check to ensure most of the source is valid
+  before making an expensive API call. Runs it through `Repo.update` even
+  though we know it's going to fail so it picks up any addl. database errors
+  and fulfills our return contract.
+
+  Returns {:ok, %Source{}} | {:error, %Ecto.Changeset{}}
+  """
+  def update_source(%Source{} = source, attrs) do
+    case change_source(source, attrs, :initial) do
+      %Ecto.Changeset{valid?: true} ->
+        source
+        |> change_source_from_url(attrs)
+        |> maybe_change_indexing_frequency()
+        |> commit_and_handle_tasks()
+
+      changeset ->
+        Repo.update(changeset)
+    end
+  end
+
+  @doc """
+  Deletes a source, its media items, and its associated tasks (of any state).
+  Can optionally delete the source's media files.
+
+  Returns {:ok, %Source{}} | {:error, %Ecto.Changeset{}}
+  """
+  def delete_source(%Source{} = source, opts \\ []) do
+    delete_files = Keyword.get(opts, :delete_files, false)
+
+    source
+    |> Media.list_media_items_for()
+    |> Enum.each(fn media_item ->
+      Media.delete_media_item(media_item, delete_files: delete_files)
+    end)
+
+    Tasks.delete_tasks_for(source)
+    Repo.delete(source)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking source changes.
+  """
+  def change_source(%Source{} = source, attrs \\ %{}, validation_stage \\ :pre_insert) do
+    Source.changeset(source, attrs, validation_stage)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking source changes and additionally
+  fetches source details from the original_url (if provided). If the source
+  details cannot be fetched, an error is added to the changeset.
+
+  Note that this fetches source details as long as the `original_url` is present.
+  This means that it'll go for it even if a changeset is otherwise invalid. This
+  is pretty easy to change, but for MVP I'm not concerned.
+
+  NOTE: When operating in the ideal path, this effectively adds an API call
+  to the source creation/update process. Should be used only when needed.
+  """
+  def change_source_from_url(%Source{} = source, attrs) do
+    case change_source(source, attrs) do
+      %Ecto.Changeset{changes: %{original_url: _}} = changeset ->
+        add_source_details_to_changeset(source, changeset)
+
+      changeset ->
+        changeset
+    end
+  end
+
+  defp add_source_details_to_changeset(source, changeset) do
+    %Ecto.Changeset{changes: changes} = changeset
+
+    case MediaCollection.get_source_details(changes.original_url) do
+      {:ok, source_details} ->
+        add_source_details_by_collection_type(source, changeset, source_details)
+
+      {:error, runner_error, _status_code} ->
+        Ecto.Changeset.add_error(
+          changeset,
+          :original_url,
+          "could not fetch source details from URL",
+          error: runner_error
+        )
+    end
+  end
+
+  defp add_source_details_by_collection_type(source, changeset, source_details) do
+    %Ecto.Changeset{changes: changes} = changeset
+
+    collection_changes =
+      if source_details.playlist_id == source_details.channel_id do
+        %{
+          collection_type: :channel,
+          collection_id: source_details.channel_id,
+          collection_name: source_details.channel_name
+        }
+      else
+        %{
+          collection_type: :playlist,
+          collection_id: source_details.playlist_id,
+          collection_name: source_details.playlist_name
+        }
+      end
+
+    change_source(source, Map.merge(changes, collection_changes))
+  end
+
+  defp maybe_change_indexing_frequency(changeset) do
+    fast_index = Ecto.Changeset.get_field(changeset, :fast_index)
+
+    if fast_index do
+      Ecto.Changeset.put_change(
+        changeset,
+        :index_frequency_minutes,
+        Source.index_frequency_when_fast_indexing()
+      )
+    else
+      changeset
+    end
+  end
+
+  defp commit_and_handle_tasks(changeset) do
+    case Repo.insert_or_update(changeset) do
+      {:ok, %Source{} = source} ->
+        maybe_handle_media_tasks(changeset, source)
+        maybe_run_indexing_task(changeset, source)
+
+      err ->
+        err
+    end
+  end
+
+  # If the source is NOT new (ie: updated) and the download_media flag has changed,
+  # enqueue or dequeue media download tasks as necessary.
+  defp maybe_handle_media_tasks(changeset, source) do
+    case {changeset.data, changeset.changes} do
+      {%{__meta__: %{state: :loaded}}, %{download_media: true}} ->
+        SourceTasks.enqueue_pending_media_tasks(source)
+
+      {%{__meta__: %{state: :loaded}}, %{download_media: false}} ->
+        SourceTasks.dequeue_pending_media_tasks(source)
+
+      _ ->
+        :ok
+    end
+
+    {:ok, source}
+  end
+
+  defp maybe_run_indexing_task(changeset, source) do
+    case changeset.data do
+      # If the changeset is new (not persisted), attempt indexing no matter what
+      %{__meta__: %{state: :built}} ->
+        SourceTasks.kickoff_indexing_task(source)
+
+      # If the record has been persisted, only run indexing if the
+      # indexing frequency has been changed and is now greater than 0
+      %{__meta__: %{state: :loaded}} ->
+        maybe_update_slow_indexing_task(changeset, source)
+        maybe_update_fast_indexing_task(changeset, source)
+    end
+
+    {:ok, source}
+  end
+
+  defp maybe_update_slow_indexing_task(changeset, source) do
+    case changeset.changes do
+      %{index_frequency_minutes: mins} when mins > 0 ->
+        SourceTasks.kickoff_indexing_task(source)
+
+      %{index_frequency_minutes: _} ->
+        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
+        Tasks.delete_pending_tasks_for(source, "MediaIndexingWorker")
+        Tasks.delete_pending_tasks_for(source, "MediaCollectionIndexingWorker")
+
+      _ ->
+        :ok
+    end
+  end
+
+  defp maybe_update_fast_indexing_task(changeset, source) do
+    case changeset.changes do
+      %{fast_index: true} ->
+        SourceTasks.kickoff_fast_indexing_task(source)
+
+      %{fast_index: false} ->
+        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
+
+      _ ->
+        :ok
+    end
+  end
+end

lib/pinchflat/sources/source.ex

@@ -0,0 +1,97 @@
+defmodule Pinchflat.Sources.Source do
+  @moduledoc """
+  The Source schema.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+  import Pinchflat.Utils.ChangesetUtils
+
+  alias Pinchflat.Tasks.Task
+  alias Pinchflat.Media.MediaItem
+  alias Pinchflat.Profiles.MediaProfile
+
+  @allowed_fields ~w(
+    collection_name
+    collection_id
+    collection_type
+    custom_name
+    index_frequency_minutes
+    fast_index
+    download_media
+    last_indexed_at
+    original_url
+    download_cutoff_date
+    media_profile_id
+  )a
+
+  # Expensive API calls are made when a source is inserted/updated so
+  # we want to ensure that the source is valid before making the call.
+  # This way, we check that the other attributes are valid before ensuring
+  # that all fields are valid.
+  @initially_required_fields ~w(
+    index_frequency_minutes
+    fast_index
+    download_media
+    original_url
+    media_profile_id
+  )a
+
+  @pre_insert_required_fields @initially_required_fields ++
+                                ~w(
+                                  custom_name
+                                  collection_name
+                                  collection_id
+                                  collection_type
+                                )a
+
+  schema "sources" do
+    field :custom_name, :string
+    field :collection_name, :string
+    field :collection_id, :string
+    field :collection_type, Ecto.Enum, values: [:channel, :playlist]
+    field :index_frequency_minutes, :integer, default: 60 * 24
+    field :fast_index, :boolean, default: false
+    field :download_media, :boolean, default: true
+    field :last_indexed_at, :utc_datetime
+    # Only download media items that were published after this date
+    field :download_cutoff_date, :date
+    field :original_url, :string
+
+    belongs_to :media_profile, MediaProfile
+
+    has_many :tasks, Task
+    has_many :media_items, MediaItem, foreign_key: :source_id
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(source, attrs, validation_stage) do
+    # See above for rationale
+    required_fields =
+      if validation_stage == :initial do
+        @initially_required_fields
+      else
+        @pre_insert_required_fields
+      end
+
+    source
+    |> cast(attrs, @allowed_fields)
+    |> dynamic_default(:custom_name, fn cs -> get_field(cs, :collection_name) end)
+    |> validate_required(required_fields)
+    |> unique_constraint([:collection_id, :media_profile_id])
+  end
+
+  @doc false
+  def index_frequency_when_fast_indexing do
+    # 30 days in minutes
+    60 * 24 * 30
+  end
+
+  @doc false
+  def fast_index_frequency do
+    # minutes
+    15
+  end
+end

lib/pinchflat/startup_tasks.ex

@@ -0,0 +1,50 @@
+defmodule Pinchflat.StartupTasks do
+  @moduledoc """
+  This module is responsible for running startup tasks on app boot.
+
+  It's a GenServer because that plays REALLY nicely with the existing
+  Phoenix supervision tree.
+  """
+
+  # 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.Settings
+  alias Pinchflat.Workers.DataBackfillWorker
+
+  def start_link(opts \\ []) do
+    GenServer.start_link(__MODULE__, %{}, opts)
+  end
+
+  @doc """
+  Runs application startup tasks.
+
+  Any code defined here will run every time the application starts. You must
+  make sure that the code is idempotent and safe to run multiple times.
+
+  This is a good place to set up default settings, create initial records, stuff like that.
+  Should be fast - anything with the potential to be slow should be kicked off as a job instead.
+  """
+  @impl true
+  def init(state) do
+    apply_default_settings()
+    enqueue_backfill_worker()
+
+    {:ok, state}
+  end
+
+  defp apply_default_settings do
+    Settings.fetch!(:onboarding, true)
+    Settings.fetch!(:pro_enabled, false)
+  end
+
+  defp enqueue_backfill_worker do
+    DataBackfillWorker.cancel_pending_backfill_jobs()
+
+    %{}
+    |> DataBackfillWorker.new()
+    |> Repo.insert_unique_job()
+  end
+end

lib/pinchflat/tasks.ex

@@ -0,0 +1,161 @@
+defmodule Pinchflat.Tasks do
+  @moduledoc """
+  The Tasks context.
+  """
+  import Ecto.Query, warn: false
+  alias Pinchflat.Repo
+
+  alias Pinchflat.Tasks.Task
+  alias Pinchflat.Media.MediaItem
+  alias Pinchflat.Sources.Source
+
+  @doc """
+  Returns the list of tasks. Returns [%Task{}, ...]
+  """
+  def list_tasks do
+    Repo.all(Task)
+  end
+
+  @doc """
+  Returns the list of tasks for a given record type and ID. Optionally allows you to specify
+  which worker or job states to include.
+
+  Returns [%Task{}, ...]
+  """
+  def list_tasks_for(attached_record_type, attached_record_id, worker_name \\ nil, job_states \\ Oban.Job.states()) do
+    stringified_states = Enum.map(job_states, &to_string/1)
+
+    worker_name_finder =
+      if worker_name do
+        # Workers are the full module name - we want to match on the string ENDING with
+        # the passed worker name and it should be preceeded with a . so we aren't matching
+        # on a substring. You can pass in more fragments of the worker name if you need
+        # to disambiguate. eg: "TestWorker" or "FooBar.TestWorker"
+        worker_finder = "%.#{worker_name}"
+
+        dynamic([_t, j], fragment("? LIKE ?", j.worker, ^worker_finder))
+      else
+        true
+      end
+
+    Repo.all(
+      from t in Task,
+        join: j in assoc(t, :job),
+        where: field(t, ^attached_record_type) == ^attached_record_id,
+        where: ^worker_name_finder,
+        where: j.state in ^stringified_states
+    )
+  end
+
+  @doc """
+  Returns the list of pending tasks for a given record type and ID. Optionally allows you to specify
+  which worker to include.
+
+  Returns [%Task{}, ...]
+  """
+  def list_pending_tasks_for(attached_record_type, attached_record_id, worker_name \\ nil) do
+    list_tasks_for(
+      attached_record_type,
+      attached_record_id,
+      worker_name,
+      [:available, :scheduled, :retryable]
+    )
+  end
+
+  @doc """
+  Gets a single task.
+
+  Returns %Task{}. Raises `Ecto.NoResultsError` if the Task does not exist.
+  """
+  def get_task!(id), do: Repo.get!(Task, id)
+
+  @doc """
+  Creates a task.
+
+  Accepts map() | %Oban.Job{}, %Source{} | %Oban.Job{}, %MediaItem{}.
+  Returns {:ok, %Task{}} | {:error, %Ecto.Changeset{}}.
+  """
+  def create_task(attrs) do
+    %Task{}
+    |> Task.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  # This function's signature is designed to help simplify
+  # usage of `create_job_with_task/2`
+  def create_task(%Oban.Job{} = job, attached_record) do
+    attached_record_attr =
+      case attached_record do
+        %Source{} = source -> %{source_id: source.id}
+        %MediaItem{} = media_item -> %{media_item_id: media_item.id}
+      end
+
+    %Task{}
+    |> Task.changeset(Map.merge(%{job_id: job.id}, attached_record_attr))
+    |> Repo.insert()
+  end
+
+  @doc """
+  Creates a job from given attrs, creating a task with an attached record
+  if successful. Returns an error if the job already exists.
+
+  Returns {:ok, %Task{}} | {:error, :duplicate_job} | {:error, %Ecto.Changeset{}}.
+  """
+  def create_job_with_task(job_attrs, task_attached_record) do
+    case Repo.insert_unique_job(job_attrs) do
+      {:ok, job} -> create_task(job, task_attached_record)
+      {:duplicate, _} -> {:error, :duplicate_job}
+      err -> err
+    end
+  end
+
+  @doc """
+  Deletes a task. Also cancels any attached job.
+
+  Returns {:ok, %Task{}} | {:error, %Ecto.Changeset{}}.
+  """
+  def delete_task(%Task{} = task) do
+    :ok = Oban.cancel_job(task.job_id)
+
+    Repo.delete(task)
+  end
+
+  @doc """
+  Deletes all tasks attached to a given record, cancelling any attached jobs.
+  Optionally allows you to specify which worker to include.
+
+  Returns :ok
+  """
+  def delete_tasks_for(attached_record, worker_name \\ nil) do
+    tasks =
+      case attached_record do
+        %Source{} = source -> list_tasks_for(:source_id, source.id, worker_name)
+        %MediaItem{} = media_item -> list_tasks_for(:media_item_id, media_item.id, worker_name)
+      end
+
+    Enum.each(tasks, &delete_task/1)
+  end
+
+  @doc """
+  Deletes all _pending_ tasks attached to a given record, cancelling any attached jobs.
+  Optionally allows you to specify which worker to include.
+
+  Returns :ok
+  """
+  def delete_pending_tasks_for(attached_record, worker_name \\ nil) do
+    tasks =
+      case attached_record do
+        %Source{} = source -> list_pending_tasks_for(:source_id, source.id, worker_name)
+        %MediaItem{} = media_item -> list_pending_tasks_for(:media_item_id, media_item.id, worker_name)
+      end
+
+    Enum.each(tasks, &delete_task/1)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking task changes.
+  """
+  def change_task(%Task{} = task, attrs \\ %{}) do
+    Task.changeset(task, attrs)
+  end
+end

lib/pinchflat/tasks/media_item_tasks.ex

@@ -0,0 +1,61 @@
+defmodule Pinchflat.Tasks.MediaItemTasks do
+  @moduledoc """
+  Contains methods used by OR used to create/manage tasks for media items.
+
+  Tasks/workers are meant to be thin wrappers so most of the actual work they
+  do is also defined here. Essentially, a one-stop-shop for media-related tasks/workers.
+  """
+  alias Pinchflat.Media
+  alias Pinchflat.Tasks
+  alias Pinchflat.Sources.Source
+  alias Pinchflat.Workers.MediaDownloadWorker
+
+  alias Pinchflat.YtDlp.Backend.Media, as: YtDlpMedia
+
+  @doc """
+  Fetches the file size of a media item and saves it to the database.
+
+  Returns {:ok, media_item} | {:error, any()}
+  """
+  def compute_and_save_media_filesize(media_item) do
+    case File.stat(media_item.media_filepath) do
+      {:ok, %{size: size}} ->
+        Media.update_media_item(media_item, %{media_size_bytes: size})
+
+      err ->
+        err
+    end
+  end
+
+  @doc """
+  Indexes a single media item for a source and enqueues a download job if the
+  media should be downloaded. This method creates the media item record so it's
+  the one-stop-shop for adding a media item (and possibly downloading it) just
+  by a URL and source.
+
+  Returns {:ok, media_item} | {:error, any()}
+  """
+  def index_and_enqueue_download_for_media_item(%Source{} = source, url) do
+    maybe_media_item = create_media_item_from_url(source, url)
+
+    case maybe_media_item do
+      {:ok, media_item} ->
+        if source.download_media && Media.pending_download?(media_item) do
+          %{id: media_item.id}
+          |> MediaDownloadWorker.new()
+          |> Tasks.create_job_with_task(media_item)
+        end
+
+        {:ok, media_item}
+
+      err ->
+        err
+    end
+  end
+
+  defp create_media_item_from_url(source, url) do
+    {:ok, media_attrs} = YtDlpMedia.get_media_attributes(url)
+
+    Media.create_media_item_from_backend_attrs(source, media_attrs)
+  end
+end

lib/pinchflat/tasks/source_tasks.ex

@@ -0,0 +1,217 @@
+defmodule Pinchflat.Tasks.SourceTasks do
+  @moduledoc """
+  Contains methods used by OR used to create/manage tasks for sources.
+
+  Tasks/workers are meant to be thin wrappers so most of the actual work they
+  do is also defined here. Essentially, a one-stop-shop for source-related tasks/workers.
+  """
+
+  require Logger
+
+  alias Pinchflat.Media
+  alias Pinchflat.Tasks
+  alias Pinchflat.Sources
+  alias Pinchflat.Sources.Source
+  alias Pinchflat.Api.YoutubeRss
+  alias Pinchflat.Media.MediaItem
+  alias Pinchflat.Workers.FastIndexingWorker
+  alias Pinchflat.Workers.MediaDownloadWorker
+  alias Pinchflat.Workers.MediaIndexingWorker
+  alias Pinchflat.YtDlp.Backend.MediaCollection
+  alias Pinchflat.Workers.MediaCollectionIndexingWorker
+  alias Pinchflat.Utils.FilesystemUtils.FileFollowerServer
+
+  alias Pinchflat.YtDlp.Backend.Media, as: YtDlpMedia
+
+  @doc """
+  Starts tasks for indexing a source's media regardless of the source's indexing
+  frequency. It's assumed the caller will check for indexing frequency.
+
+  Returns {:ok, %Task{}}.
+  """
+  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")
+
+    %{id: source.id}
+    # Schedule this one immediately, but future ones will be on an interval
+    |> MediaCollectionIndexingWorker.new()
+    |> Tasks.create_job_with_task(source)
+  end
+
+  @doc """
+  Starts tasks for running a fast indexing task for a source's media
+  regardless of the source's fast_index state. It's assumed the
+  caller will check for fast_index.
+
+  This is used for running fast index tasks on update. On creation, the
+  fast index is enqueued after the slow index is complete.
+
+  Returns {:ok, %Task{}}.
+  """
+  def kickoff_fast_indexing_task(%Source{} = source) do
+    Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
+
+    %{id: source.id}
+    # Schedule this one immediately, but future ones will be on an interval
+    |> FastIndexingWorker.new()
+    |> Tasks.create_job_with_task(source)
+  end
+
+  @doc """
+  Fetches new media IDs from a source's YouTube RSS feed and kicks off indexing tasks
+  for any new media items. See comments in `MediaIndexingWorker` for more info on the
+  order of operations and how this fits into the indexing process.
+
+  Returns :ok
+  """
+  def kickoff_indexing_tasks_from_youtube_rss_feed(%Source{} = source) do
+    {:ok, media_ids} = YoutubeRss.get_recent_media_ids_from_rss(source)
+    existing_media_items = Media.list_media_items_by_media_id_for(source, media_ids)
+    new_media_ids = media_ids -- Enum.map(existing_media_items, & &1.media_id)
+
+    Enum.each(new_media_ids, fn media_id ->
+      url = "https://www.youtube.com/watch?v=#{media_id}"
+
+      %{id: source.id, media_url: url}
+      |> MediaIndexingWorker.new()
+      |> Tasks.create_job_with_task(source)
+    end)
+  end
+
+  @doc """
+  Given a media source, creates (indexes) the media by creating media_items for each
+  media ID in the source. Afterward, kicks off a download task for each pending media
+  item belonging to the source. You can't tell me the method name isn't descriptive!
+
+  Indexing is slow and usually returns a list of all media data at once for record creation.
+  To help with this, we use a file follower to watch the file that yt-dlp writes to
+  so we can create media items as they come in. This parallelizes the process and adds
+  clarity to the user experience. This has a few things to be aware of which are documented
+  below in the file watcher setup method.
+
+  NOTE: downloads are only enqueued if the source is set to download media. Downloads are
+  also enqueued for ALL pending media items, not just the ones that were indexed in this
+  job run. This should ensure that any stragglers are caught if, for some reason, they
+  weren't enqueued or somehow got de-queued.
+
+  Since indexing returns all media data EVERY TIME, we that that opportunity to update
+  indexing metadata for media items that have already been created.
+
+  Returns [%MediaItem{}, ...]
+  """
+  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} = get_media_attributes_for_collection_and_setup_file_watcher(source)
+    result = Enum.map(media_attributes, fn media_attrs -> create_media_item_from_attributes(source, media_attrs) end)
+
+    Sources.update_source(source, %{last_indexed_at: DateTime.utc_now()})
+    enqueue_pending_media_tasks(source)
+
+    result
+  end
+
+  @doc """
+  Starts tasks for downloading media for any of a sources _pending_ media items.
+  Jobs are not enqueued if the source is set to not download media. This will return :ok.
+
+  NOTE: this starts a download for each media item that is pending,
+  not just the ones that were indexed in this job run. This should ensure
+  that any stragglers are caught if, for some reason, they weren't enqueued
+  or somehow got de-queued.
+
+  Returns :ok
+  """
+  def enqueue_pending_media_tasks(%Source{download_media: true} = source) do
+    source
+    |> Media.list_pending_media_items_for()
+    |> Enum.each(fn media_item ->
+      %{id: media_item.id}
+      |> MediaDownloadWorker.new()
+      |> Tasks.create_job_with_task(media_item)
+    end)
+  end
+
+  def enqueue_pending_media_tasks(%Source{download_media: false} = _source) do
+    :ok
+  end
+
+  @doc """
+  Deletes ALL pending tasks for a source's media items.
+
+  Returns :ok
+  """
+  def dequeue_pending_media_tasks(%Source{} = source) do
+    source
+    |> Media.list_pending_media_items_for()
+    |> Enum.each(&Tasks.delete_pending_tasks_for/1)
+  end
+
+  # The file follower is a GenServer that watches a file for new lines and
+  # processes them. This works well, but we have to be resilliant to partially-written
+  # 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 `get_media_attributes_for_collection` method completes it'll return the FULL result to
+  # 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 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
+    result = MediaCollection.get_media_attributes_for_collection(source.original_url, file_listener_handler: handler)
+
+    FileFollowerServer.stop(pid)
+
+    result
+  end
+
+  defp setup_file_follower_watcher(pid, filepath, source) do
+    FileFollowerServer.watch_file(pid, filepath, fn line ->
+      case Phoenix.json_library().decode(line) do
+        {:ok, media_attrs} ->
+          Logger.debug("FileFollowerServer Handler: Got media attributes: #{inspect(media_attrs)}")
+
+          media_struct = YtDlpMedia.response_to_struct(media_attrs)
+          create_media_item_and_enqueue_download(source, media_struct)
+
+        err ->
+          Logger.debug("FileFollowerServer Handler: Error decoding JSON: #{inspect(err)}")
+
+          err
+      end
+    end)
+  end
+
+  defp create_media_item_and_enqueue_download(source, media_attrs) do
+    maybe_media_item = create_media_item_from_attributes(source, media_attrs)
+
+    case maybe_media_item do
+      %MediaItem{} = media_item ->
+        if source.download_media && Media.pending_download?(media_item) do
+          Logger.debug("FileFollowerServer Handler: Enqueuing download task for #{inspect(media_attrs)}")
+
+          %{id: media_item.id}
+          |> MediaDownloadWorker.new()
+          |> Tasks.create_job_with_task(media_item)
+        end
+
+      changeset ->
+        changeset
+    end
+  end
+
+  defp create_media_item_from_attributes(source, media_attrs) do
+    case Media.create_media_item_from_backend_attrs(source, media_attrs) do
+      {:ok, media_item} -> media_item
+      {:error, changeset} -> changeset
+    end
+  end
+end

lib/pinchflat/tasks/task.ex

@@ -0,0 +1,26 @@
+defmodule Pinchflat.Tasks.Task do
+  @moduledoc """
+  The Task schema.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  alias Pinchflat.Media.MediaItem
+  alias Pinchflat.Sources.Source
+
+  schema "tasks" do
+    belongs_to :job, Oban.Job
+    belongs_to :source, Source
+    belongs_to :media_item, MediaItem
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(task, attrs) do
+    task
+    |> cast(attrs, [:job_id, :source_id, :media_item_id])
+    |> validate_required([:job_id])
+  end
+end

lib/pinchflat/utils/changeset_utils.ex

@@ -0,0 +1,19 @@
+defmodule Pinchflat.Utils.ChangesetUtils do
+  @moduledoc """
+  Utility methods for working with changesets
+  """
+
+  import Ecto.Changeset
+
+  @doc """
+  Sets the default value of a field if it is nil by applying the given function.
+
+  Returns %Ecto.Changeset{}.
+  """
+  def dynamic_default(changeset, key, value_fn) do
+    case get_field(changeset, key) do
+      nil -> put_change(changeset, key, value_fn.(changeset))
+      _ -> changeset
+    end
+  end
+end

lib/pinchflat/utils/filesystem_utils.ex

@@ -0,0 +1,23 @@
+defmodule Pinchflat.Utils.FilesystemUtils do
+  @moduledoc """
+  Utility methods for working with the filesystem
+  """
+
+  alias Pinchflat.Utils.StringUtils
+
+  @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.
+
+  Returns binary()
+  """
+  def generate_metadata_tmpfile(type) do
+    tmpfile_directory = Application.get_env(:pinchflat, :tmpfile_directory)
+    filepath = Path.join([tmpfile_directory, "#{StringUtils.random_string(64)}.#{type}"])
+
+    :ok = File.mkdir_p!(Path.dirname(filepath))
+    :ok = File.write(filepath, "")
+
+    filepath
+  end
+end

lib/pinchflat/utils/filesystem_utils/file_follower_server.ex

@@ -0,0 +1,121 @@
+defmodule Pinchflat.Utils.FilesystemUtils.FileFollowerServer do
+  @moduledoc """
+  A GenServer that watches a file for new lines and processes them as they come in.
+  This is useful for tailing log files and other similar tasks. If there's no activity
+  for a certain amount of time, the server will stop itself.
+  """
+  use GenServer
+
+  require Logger
+
+  @poll_interval_ms Application.compile_env(:pinchflat, :file_watcher_poll_interval)
+  @activity_timeout_ms 60_000
+
+  # Client API
+  @doc """
+  Starts the file follower server
+
+  Returns {:ok, pid} or {:error, reason}
+  """
+  def start_link() do
+    GenServer.start_link(__MODULE__, [])
+  end
+
+  @doc """
+  Starts the file watcher for a given filepath and handler function.
+
+  Returns :ok
+  """
+  def watch_file(process, filepath, handler) do
+    GenServer.cast(process, {:watch_file, filepath, handler})
+  end
+
+  @doc """
+  Stops the file watcher and closes the file.
+
+  Returns :ok
+  """
+  def stop(process) do
+    GenServer.cast(process, :stop)
+  end
+
+  # Server Callbacks
+  @impl true
+  def init(_opts) do
+    # Start with a blank state because, based on the common calling
+    # pattern for this module, we'll need a reference to the server's
+    # PID before we start watching any files so we can later stop the
+    # server gracefully.
+    {:ok, %{}}
+  end
+
+  @impl true
+  def handle_cast({:watch_file, filepath, handler}, _old_state) do
+    {:ok, io_device} = :file.open(filepath, [:raw, :read_ahead, :binary])
+
+    state = %{
+      io_device: io_device,
+      last_activity: DateTime.utc_now(),
+      handler: handler
+    }
+
+    Process.send(self(), :read_new_lines, [])
+
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_cast(:stop, state) do
+    Logger.debug("Gracefully stopping file follower")
+    :file.close(state.io_device)
+
+    {:stop, :normal, state}
+  end
+
+  @impl true
+  def handle_info(:read_new_lines, state) do
+    last_activity = state.last_activity
+
+    # If there's no new lines written for a certain amount of time, stop the server
+    if DateTime.diff(DateTime.utc_now(), last_activity, :millisecond) > @activity_timeout_ms do
+      Logger.debug("No activity for #{@activity_timeout_ms}ms. Requesting stop.")
+      stop(self())
+
+      {:noreply, state}
+    else
+      attempt_process_new_lines(state)
+    end
+  end
+
+  defp attempt_process_new_lines(state) do
+    io_device = state.io_device
+
+    # This reads one line at a time. If a line is found, it
+    # will be passed to the handler, we'll note the time of
+    # the last activity, and then we'll immediately call this
+    # again to read the next line.
+    #
+    # If there are no lines, it waits for the poll interval
+    # before trying again.
+    case :file.read_line(io_device) do
+      {:ok, line} ->
+        state.handler.(line)
+
+        Process.send(self(), :read_new_lines, [])
+
+        {:noreply, %{state | last_activity: DateTime.utc_now()}}
+
+      :eof ->
+        Logger.debug("EOF reached, waiting before trying to read new lines")
+        Process.send_after(self(), :read_new_lines, @poll_interval_ms)
+
+        {:noreply, state}
+
+      {:error, reason} ->
+        Logger.error("Error reading file: #{reason}")
+        stop(self())
+
+        {:noreply, state}
+    end
+  end
+end

lib/pinchflat/utils/function_utils.ex

@@ -0,0 +1,15 @@
+defmodule Pinchflat.Utils.FunctionUtils do
+  @moduledoc """
+  Utility methods for working with functions
+  """
+
+  @doc """
+  Wraps the provided term in an :ok tuple. Useful for fulfilling a contract, but
+  other usage should be assessed to see if it's the right fit.
+
+  Returns {:ok, term}
+  """
+  def wrap_ok(value) do
+    {:ok, value}
+  end
+end

lib/pinchflat/utils/string_utils.ex

@@ -0,0 +1,44 @@
+defmodule Pinchflat.Utils.StringUtils do
+  @moduledoc """
+  Utility methods for working with strings
+  """
+
+  @doc """
+  Converts a string to kebab-case (ie: `hello world` -> `hello-world`)
+
+  Returns binary()
+  """
+  def to_kebab_case(string) do
+    string
+    |> String.replace(~r/[\s_]/, "-")
+    |> String.downcase()
+  end
+
+  @doc """
+  Returns a random string of the given length. Base 16 encoded, lower case.
+
+  Returns binary()
+  """
+  def random_string(length \\ 32) do
+    :crypto.strong_rand_bytes(length)
+    |> Base.encode16(case: :lower)
+    |> String.slice(0..(length - 1))
+  end
+
+  @doc """
+  Truncates a string to the given length and adds `...` if the string is longer than the given length.
+  Will break on a word boundary. Nothing happens if the string is shorter than the given length.
+
+  Returns binary()
+  """
+  def truncate(string, length) do
+    if String.length(string) > length do
+      string
+      |> String.slice(0..(length - 1))
+      |> String.replace(~r/\s+\S*$/, "")
+      |> Kernel.<>("...")
+    else
+      string
+    end
+  end
+end

lib/pinchflat/workers/data_backfill_worker.ex

@@ -0,0 +1,75 @@
+defmodule Pinchflat.Workers.DataBackfillWorker do
+  @moduledoc false
+
+  use Oban.Worker,
+    queue: :media_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
+  alias Pinchflat.Media.MediaItem
+
+  @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.Workers.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")
+    backfill_shorts_data()
+
+    reschedule_backfill()
+
+    :ok
+  end
+
+  defp backfill_shorts_data do
+    query =
+      from(
+        m in MediaItem,
+        where: fragment("? like ?", m.original_url, "%/shorts/%"),
+        where: m.short_form_content == false
+      )
+
+    {count, _} = Repo.update_all(query, set: [short_form_content: true])
+
+    Logger.info("Backfill worker set short_form_content to true for #{count} media items.")
+  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/workers/fast_indexing_worker.ex

@@ -0,0 +1,46 @@
+defmodule Pinchflat.Workers.FastIndexingWorker do
+  @moduledoc false
+
+  use Oban.Worker,
+    queue: :fast_indexing,
+    unique: [period: :infinity, states: [:available, :scheduled, :retryable]],
+    tags: ["media_source", "fast_indexing"]
+
+  alias __MODULE__
+  alias Pinchflat.Tasks
+  alias Pinchflat.Sources
+  alias Pinchflat.Sources.Source
+  alias Pinchflat.Tasks.SourceTasks
+
+  @impl Oban.Worker
+  @doc """
+  Kicks off the fast indexing process for a source, reschedules the job to run again
+  once complete. See `MediaCollectionIndexingWorker` and `MediaIndexingWorker` comments
+  for more
+
+  Returns :ok | {:ok, :job_exists} | {:ok, %Task{}}
+  """
+  def perform(%Oban.Job{args: %{"id" => source_id}}) do
+    source = Sources.get_source!(source_id)
+
+    if source.fast_index do
+      SourceTasks.kickoff_indexing_tasks_from_youtube_rss_feed(source)
+
+      reschedule_indexing(source)
+    else
+      :ok
+    end
+  end
+
+  defp reschedule_indexing(source) do
+    next_run_in = Source.fast_index_frequency() * 60
+
+    %{id: source.id}
+    |> FastIndexingWorker.new(schedule_in: next_run_in)
+    |> Tasks.create_job_with_task(source)
+    |> case do
+      {:ok, task} -> {:ok, task}
+      {:error, :duplicate_job} -> {:ok, :job_exists}
+    end
+  end
+end

lib/pinchflat/workers/filesystem_data_worker.ex

@@ -0,0 +1,27 @@
+defmodule Pinchflat.Workers.FilesystemDataWorker do
+  @moduledoc false
+
+  use Oban.Worker,
+    queue: :media_local_metadata,
+    tags: ["media_item", "media_metadata", "local_metadata"],
+    max_attempts: 1
+
+  alias Pinchflat.Media
+  alias Pinchflat.Tasks.MediaItemTasks
+
+  @impl Oban.Worker
+  @doc """
+  For a given media item, compute and save metadata about the file on-disk.
+
+  Returns :ok
+  """
+  def perform(%Oban.Job{args: %{"id" => media_item_id}}) do
+    media_item = Media.get_media_item!(media_item_id)
+
+    MediaItemTasks.compute_and_save_media_filesize(media_item)
+
+    # Don't retry on failure - if it didn't work immediately there's no
+    # reason to believe it will work later.
+    :ok
+  end
+end

lib/pinchflat/workers/media_collection_indexing_worker.ex

@@ -0,0 +1,109 @@
+defmodule Pinchflat.Workers.MediaCollectionIndexingWorker do
+  @moduledoc false
+
+  use Oban.Worker,
+    queue: :media_collection_indexing,
+    unique: [period: :infinity, states: [:available, :scheduled, :retryable]],
+    tags: ["media_source", "media_collection_indexing"]
+
+  alias __MODULE__
+  alias Pinchflat.Tasks
+  alias Pinchflat.Sources
+  alias Pinchflat.Sources.Source
+  alias Pinchflat.Tasks.SourceTasks
+  alias Pinchflat.Workers.FastIndexingWorker
+
+  @impl Oban.Worker
+  @doc """
+  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, but rescheduling is determined by the
+  `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_.
+  This has some benefits but also side effects to be aware of:
+
+  - Benefit: No chance for jobs to overlap if a job takes longer than the
+    scheduled interval. Less likely to hit API rate limits.
+  - Side effect: Intervals are "soft" and _always_ walk forward. This may cause
+    user confusion since a 30-minute job scheduled for every hour will
+    actually run every 1 hour and 30 minutes. The tradeoff of not inundating
+    the API with requests and also not overlapping jobs is worth it, IMO.
+
+  Order of operations:
+    1. The user saves a source
+    2. This job is automatically scheduled immediately. This happens in all cases.
+    3. This job indexes all content for the given source. A download job is
+       enqueued for each media item that should be downloaded. This can be impacted
+       by the `download_media` field on the source as well as the profile's
+       shorts/livestream behaviour. At this step we also attach a file reader
+       to the `yt-dlp` output file so we can create media items as they come in
+       for a little speedup (see SourceTasks comments for more)
+    4. If this job is meant to reschedule (ie: has an index frequency > 0),
+       it reschedules itself. If not, it runs once and does not reschedule
+    5. If the source uses fast indexing, that job is kicked off as well. It
+       uses RSS to run a smaller, faster, and more frequent index. That job
+       handles rescheduling itself but largely has a similar behaviour to this
+       job in that it kicks off index and maybe download jobs. The biggest difference
+       is that an index job is kicked off _for each new media item_ as opposed
+       to one larger index job. Check out `MediaIndexingWorker` comments for more.
+    6. If the job reschedules, the cycle from step 3 repeats until the heat death
+       of the universe. The user changing things like the index frequency can
+       dequeue or reschedule jobs as well
+
+  NOTE: Since indexing can take a LONG time, I should check what happens if an
+  application restart occurs while a job is running. Will the job be lost?
+
+  IDEA: Should I use paging and do indexing in chunks? Is that even faster?
+
+  Returns :ok | {:ok, %Task{}}
+  """
+  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
+        SourceTasks.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
+        SourceTasks.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
+        :ok
+    end
+  end
+
+  defp reschedule_indexing(source) do
+    next_run_in = source.index_frequency_minutes * 60
+
+    %{id: source.id}
+    |> MediaCollectionIndexingWorker.new(schedule_in: next_run_in)
+    |> Tasks.create_job_with_task(source)
+    |> case do
+      {:ok, task} -> {:ok, task}
+      {:error, :duplicate_job} -> {:ok, :job_exists}
+    end
+  end
+
+  defp maybe_enqueue_fast_indexing_task(source) do
+    if source.fast_index do
+      Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
+
+      next_run_in = Source.fast_index_frequency() * 60
+
+      %{id: source.id}
+      |> FastIndexingWorker.new(schedule_in: next_run_in)
+      |> Tasks.create_job_with_task(source)
+    end
+  end
+end

lib/pinchflat/workers/media_download_worker.ex

@@ -0,0 +1,56 @@
+defmodule Pinchflat.Workers.MediaDownloadWorker do
+  @moduledoc false
+
+  use Oban.Worker,
+    queue: :media_fetching,
+    unique: [period: :infinity, states: [:available, :scheduled, :retryable, :executing]],
+    tags: ["media_item", "media_fetching"]
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Media
+  alias Pinchflat.Tasks
+  alias Pinchflat.MediaClient.MediaDownloader
+  alias Pinchflat.Workers.FilesystemDataWorker
+
+  @impl Oban.Worker
+  @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.
+
+  Returns :ok | {:ok, %MediaItem{}} | {:error, any, ...any}
+  """
+  def perform(%Oban.Job{args: %{"id" => media_item_id}}) do
+    media_item =
+      media_item_id
+      |> Media.get_media_item!()
+      |> Repo.preload(:source)
+
+    # If the source is set to not download media, perform a no-op
+    if media_item.source.download_media do
+      download_media_and_schedule_jobs(media_item)
+    else
+      :ok
+    end
+  end
+
+  defp download_media_and_schedule_jobs(media_item) do
+    case MediaDownloader.download_for_media_item(media_item) do
+      {:ok, _} ->
+        schedule_filesystem_data_worker(media_item)
+        {:ok, media_item}
+
+      err ->
+        err
+    end
+  end
+
+  defp schedule_filesystem_data_worker(media_item) do
+    %{id: media_item.id}
+    |> FilesystemDataWorker.new()
+    |> Tasks.create_job_with_task(media_item)
+    |> case do
+      {:ok, task} -> {:ok, task}
+      {:error, :duplicate_job} -> {:ok, :job_exists}
+    end
+  end
+end

lib/pinchflat/workers/media_indexing_worker.ex

@@ -0,0 +1,53 @@
+defmodule Pinchflat.Workers.MediaIndexingWorker do
+  @moduledoc false
+
+  use Oban.Worker,
+    queue: :media_indexing,
+    unique: [period: :infinity, states: [:available, :scheduled, :retryable]],
+    tags: ["media_source", "media_indexing"]
+
+  require Logger
+
+  alias Pinchflat.Sources
+  alias Pinchflat.Tasks.MediaItemTasks
+
+  @impl Oban.Worker
+  @doc """
+  Similar to `MediaCollectionIndexingWorker`, but for individual media items.
+  Does not reschedule or check anything to do with a source's indexing
+  frequency - only collects initial metadata then kicks off a download.
+  `MediaCollectionIndexingWorker` should be preferred in general, but this is
+  useful for downloading one-off media items based on a URL (like for fast indexing).
+
+  Only downloads media that _should_ be downloaded (ie: the source is set to download
+  and the media matches the profile's format preferences)
+
+  Order of operations:
+    1. SourceTasks.kickoff_indexing_tasks_from_youtube_rss_feed/1 (which is running
+       in its own worker) periodically checks the YouTube RSS feed for new media
+    2. If new media is found, it enqueues a MediaIndexingWorker (this module) for each new media
+       item
+    3. This worker fetches the media metadata and uses that to determine if it should be
+       downloaded. If so, it enqueues a MediaDownloadWorker
+
+  Each is a worker because they all either need to be scheduled periodically or call out to
+  an external service and will be long-running. They're split into different jobs to separate
+  retry logic for each step and allow us to better optimize various queues (eg: the indexing
+  steps can keep running while the slow download steps are worked through).
+
+  Returns :ok
+  """
+  def perform(%Oban.Job{args: %{"id" => source_id, "media_url" => media_url}}) do
+    source = Sources.get_source!(source_id)
+
+    case MediaItemTasks.index_and_enqueue_download_for_media_item(source, media_url) do
+      {:ok, media_item} ->
+        Logger.debug("Indexed and enqueued download for url: #{media_url} (media item: #{media_item.id})")
+
+      {:error, reason} ->
+        Logger.debug("Failed to index and enqueue download for url: #{media_url} (reason: #{inspect(reason)})")
+    end
+
+    :ok
+  end
+end

lib/pinchflat/yt_dlp/backend/backend_command_runner.ex

@@ -0,0 +1,11 @@
+defmodule Pinchflat.YtDlp.Backend.BackendCommandRunner do
+  @moduledoc """
+  A behaviour for running CLI commands against a downloader backend (yt-dlp).
+
+  Used so we can implement Mox for testing without actually running the
+  yt-dlp command.
+  """
+
+  @callback run(binary(), keyword(), binary()) :: {:ok, binary()} | {:error, binary(), integer()}
+  @callback run(binary(), keyword(), binary(), keyword()) :: {:ok, binary()} | {:error, binary(), integer()}
+end

lib/pinchflat/yt_dlp/backend/command_runner.ex

@@ -0,0 +1,82 @@
+defmodule Pinchflat.YtDlp.Backend.CommandRunner do
+  @moduledoc """
+  Runs yt-dlp commands using the `System.cmd/3` function
+  """
+
+  require Logger
+
+  alias Pinchflat.Utils.StringUtils
+  alias Pinchflat.Utils.FilesystemUtils, as: FSUtils
+  alias Pinchflat.YtDlp.Backend.BackendCommandRunner
+
+  @behaviour BackendCommandRunner
+
+  @doc """
+  Runs a yt-dlp command and returns the string output. Saves the output to
+  a file and then returns its contents because yt-dlp will return warnings
+  to stdout even if the command is successful, but these will break JSON parsing.
+
+  Additional Opts:
+    - :output_filepath - the path to save the output to. If not provided, a temporary
+      file will be created and used. Useful for if you need a reference to the file
+      for a file watcher.
+
+  Returns {:ok, binary()} | {:error, output, status}.
+  """
+  @impl BackendCommandRunner
+  def run(url, command_opts, output_template, addl_opts \\ []) do
+    # This approach lets us mock the command for testing
+    command = backend_executable()
+    # These must stay in exactly this order, hence why I'm giving it its own variable.
+    # 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]
+    formatted_command_opts = [url] ++ parse_options(command_opts ++ print_to_file_opts)
+
+    Logger.info("[yt-dlp] called with: #{Enum.join(formatted_command_opts, " ")}")
+
+    case System.cmd(command, formatted_command_opts, stderr_to_stdout: true) do
+      {_, 0} ->
+        # IDEA: consider deleting the file after reading it
+        # (even on error? especially on error?)
+        File.read(output_filepath)
+
+      {output, status} ->
+        {:error, output, status}
+    end
+  end
+
+  # 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
+  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
+    Application.get_env(:pinchflat, :yt_dlp_executable)
+  end
+end

lib/pinchflat/yt_dlp/backend/media.ex

@@ -0,0 +1,116 @@
+defmodule Pinchflat.YtDlp.Backend.Media do
+  @moduledoc """
+  Contains utilities for working with singular pieces of media
+  """
+
+  @enforce_keys [
+    :media_id,
+    :title,
+    :description,
+    :original_url,
+    :livestream,
+    :short_form_content,
+    :upload_date
+  ]
+
+  defstruct [
+    :media_id,
+    :title,
+    :description,
+    :original_url,
+    :livestream,
+    :short_form_content,
+    :upload_date
+  ]
+
+  alias __MODULE__
+  alias Pinchflat.Utils.FunctionUtils
+
+  @doc """
+  Downloads a single piece of media (and possibly its metadata) directly to its
+  final destination. Returns the parsed JSON output from yt-dlp.
+
+  Returns {:ok, map()} | {:error, any, ...}.
+  """
+  def download(url, command_opts \\ []) do
+    opts = [:no_simulate] ++ command_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
+      err -> err
+    end
+  end
+
+  @doc """
+  Returns a map representing the media at the given URL.
+
+  Returns {:ok, [map()]} | {:error, any, ...}.
+  """
+  def get_media_attributes(url) do
+    runner = Application.get_env(:pinchflat, :yt_dlp_runner)
+    command_opts = [:simulate, :skip_download]
+    output_template = indexing_output_template()
+
+    case runner.run(url, command_opts, output_template) do
+      {:ok, output} ->
+        output
+        |> Phoenix.json_library().decode!()
+        |> response_to_struct()
+        |> FunctionUtils.wrap_ok()
+
+      res ->
+        res
+    end
+  end
+
+  @doc """
+  Returns the output template for yt-dlp's indexing command.
+  """
+  def indexing_output_template do
+    "%(.{id,title,was_live,webpage_url,description,aspect_ratio,duration,upload_date})j"
+  end
+
+  @doc """
+  Transforms a response from yt-dlp into a struct. Interprets the response to
+  determine if the media is short-form content.
+
+  Returns %Media{}.
+  """
+  def response_to_struct(response) do
+    %Media{
+      media_id: response["id"],
+      title: response["title"],
+      description: response["description"],
+      original_url: response["webpage_url"],
+      livestream: response["was_live"],
+      short_form_content: short_form_content?(response),
+      upload_date: parse_upload_date(response["upload_date"])
+    }
+  end
+
+  defp short_form_content?(response) do
+    if String.contains?(response["webpage_url"], "/shorts/") do
+      true
+    else
+      # Sometimes shorts are returned without /shorts/ in the URL,
+      # so we need to do our best to determine if it's a short. This
+      # WILL returns false positives, but it's a best-effort approach
+      # that should work for most cases. The aspect_ratio check is
+      # based on a gut feeling and may need to be tweaked.
+      response["duration"] <= 60 && response["aspect_ratio"] < 0.8
+    end
+  end
+
+  defp parse_upload_date(upload_date) do
+    <<year::binary-size(4)>> <> <<month::binary-size(2)>> <> <<day::binary-size(2)>> = upload_date
+
+    Date.from_iso8601!("#{year}-#{month}-#{day}")
+  end
+
+  defp backend_runner do
+    # This approach lets us mock the command for testing
+    Application.get_env(:pinchflat, :yt_dlp_runner)
+  end
+end

lib/pinchflat/yt_dlp/backend/media_collection.ex

@@ -0,0 +1,81 @@
+defmodule Pinchflat.YtDlp.Backend.MediaCollection do
+  @moduledoc """
+  Contains utilities for working with collections of
+  media (aka: a source [ie: channels, playlists]).
+  """
+
+  require Logger
+
+  alias Pinchflat.Utils.FunctionUtils
+  alias Pinchflat.Utils.FilesystemUtils
+  alias Pinchflat.YtDlp.Backend.Media, as: YtDlpMedia
+
+  @doc """
+  Returns a list of maps representing the media in the collection.
+
+  Options:
+    - :file_listener_handler - a function that will be called with the path to the
+      file that will be written to when yt-dlp is done. This is useful for
+      setting up a file watcher to know when the file is ready to be read.
+
+  Returns {:ok, [map()]} | {:error, any, ...}.
+  """
+  def get_media_attributes_for_collection(url, addl_opts \\ []) do
+    runner = Application.get_env(:pinchflat, :yt_dlp_runner)
+    command_opts = [:simulate, :skip_download]
+    output_template = YtDlpMedia.indexing_output_template()
+    output_filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
+    file_listener_handler = Keyword.get(addl_opts, :file_listener_handler, false)
+
+    if file_listener_handler do
+      file_listener_handler.(output_filepath)
+    end
+
+    case runner.run(url, command_opts, output_template, output_filepath: output_filepath) do
+      {:ok, output} ->
+        output
+        |> String.split("\n", trim: true)
+        |> Enum.map(&Phoenix.json_library().decode!/1)
+        |> Enum.map(&YtDlpMedia.response_to_struct/1)
+        |> FunctionUtils.wrap_ok()
+
+      res ->
+        res
+    end
+  end
+
+  @doc """
+  Gets a source's ID and name from its URL.
+
+  yt-dlp does not _really_ have source-specific functions, so
+  instead we're fetching just the first video (using playlist_end: 1)
+  and parsing the source ID and name from _its_ metadata
+
+  Returns {:ok, map()} | {:error, any, ...}.
+  """
+  def get_source_details(source_url) do
+    opts = [:simulate, :skip_download, playlist_end: 1]
+    output_template = "%(.{channel,channel_id,playlist_id,playlist_title})j"
+
+    with {:ok, output} <- backend_runner().run(source_url, opts, output_template),
+         {:ok, parsed_json} <- Phoenix.json_library().decode(output) do
+      {:ok, format_source_details(parsed_json)}
+    else
+      err -> err
+    end
+  end
+
+  defp format_source_details(response) do
+    %{
+      channel_id: response["channel_id"],
+      channel_name: response["channel"],
+      playlist_id: response["playlist_id"],
+      playlist_name: response["playlist_title"]
+    }
+  end
+
+  defp backend_runner do
+    # This approach lets us mock the command for testing
+    Application.get_env(:pinchflat, :yt_dlp_runner)
+  end
+end

lib/pinchflat/yt_dlp/download_option_builder.ex

@@ -0,0 +1,131 @@
+defmodule Pinchflat.YtDlp.DownloadOptionBuilder do
+  @moduledoc """
+  Builds the options for yt-dlp to download media based on the given media profile.
+  """
+
+  alias Pinchflat.Media.MediaItem
+  alias Pinchflat.Profiles.OutputPathBuilder
+
+  @doc """
+  Builds the options for yt-dlp to download media based on the given media's profile.
+
+  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
+
+    built_options =
+      default_options() ++
+        subtitle_options(media_profile) ++
+        thumbnail_options(media_profile) ++
+        metadata_options(media_profile) ++
+        quality_options(media_profile) ++
+        output_options(media_item_with_preloads)
+
+    {:ok, built_options}
+  end
+
+  defp default_options do
+    [:no_progress, :windows_filenames]
+  end
+
+  defp subtitle_options(media_profile) do
+    mapped_struct = Map.from_struct(media_profile)
+
+    Enum.reduce(mapped_struct, [], fn attr, acc ->
+      case {attr, media_profile} do
+        {{:download_subs, true}, _} ->
+          # Force SRT for now - MAY provide as an option in the future
+          acc ++ [:write_subs, convert_subs: "srt"]
+
+        {{:download_auto_subs, true}, %{download_subs: true}} ->
+          acc ++ [:write_auto_subs]
+
+        {{:embed_subs, true}, %{preferred_resolution: pr}} when pr != :audio ->
+          acc ++ [:embed_subs]
+
+        {{:sub_langs, sub_langs}, %{download_subs: true}} ->
+          acc ++ [sub_langs: sub_langs]
+
+        {{:sub_langs, sub_langs}, %{embed_subs: true}} ->
+          acc ++ [sub_langs: sub_langs]
+
+        _ ->
+          acc
+      end
+    end)
+  end
+
+  defp thumbnail_options(media_profile) do
+    mapped_struct = Map.from_struct(media_profile)
+
+    Enum.reduce(mapped_struct, [], fn attr, acc ->
+      case {attr, media_profile} do
+        {{:download_thumbnail, true}, _} ->
+          acc ++ [:write_thumbnail]
+
+        {{:embed_thumbnail, true}, %{preferred_resolution: pr}} when pr != :audio ->
+          acc ++ [:embed_thumbnail]
+
+        _ ->
+          acc
+      end
+    end)
+  end
+
+  defp metadata_options(media_profile) do
+    mapped_struct = Map.from_struct(media_profile)
+
+    Enum.reduce(mapped_struct, [], fn attr, acc ->
+      case {attr, media_profile} do
+        {{:download_metadata, true}, _} ->
+          acc ++ [:write_info_json, :clean_info_json]
+
+        {{:embed_metadata, true}, %{preferred_resolution: pr}} when pr != :audio ->
+          acc ++ [:embed_metadata]
+
+        _ ->
+          acc
+      end
+    end)
+  end
+
+  defp quality_options(media_profile) do
+    codec_options = "+codec:avc:m4a"
+
+    case media_profile.preferred_resolution do
+      # Also be aware that :audio disabled all embedding options for thumbnails, subtitles, and metadata
+      :audio -> [format_sort: "ext", format: "bestaudio"]
+      :"360p" -> [format_sort: "res:360,#{codec_options}"]
+      :"480p" -> [format_sort: "res:480,#{codec_options}"]
+      :"720p" -> [format_sort: "res:720,#{codec_options}"]
+      :"1080p" -> [format_sort: "res:1080,#{codec_options}"]
+      :"1440p" -> [format_sort: "res:1440,#{codec_options}"]
+      :"2160p" -> [format_sort: "res:2160,#{codec_options}"]
+    end
+  end
+
+  defp output_options(media_item_with_preloads) do
+    media_profile = media_item_with_preloads.source.media_profile
+    additional_options_map = output_options_map(media_item_with_preloads)
+    {:ok, output_path} = OutputPathBuilder.build(media_profile.output_path_template, additional_options_map)
+
+    [
+      output: Path.join(base_directory(), output_path)
+    ]
+  end
+
+  defp output_options_map(media_item_with_preloads) do
+    source = media_item_with_preloads.source
+
+    %{
+      "source_custom_name" => source.custom_name,
+      "source_collection_type" => source.collection_type
+    }
+  end
+
+  defp base_directory do
+    Application.get_env(:pinchflat, :media_directory)
+  end
+end

lib/pinchflat/yt_dlp/media_downloader.ex

@@ -0,0 +1,65 @@
+defmodule Pinchflat.MediaClient.MediaDownloader do
+  @moduledoc """
+  This is the integration layer for actually downloading media.
+  It takes into account the media profile's settings in order
+  to download the media with the desired options.
+  """
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Media
+  alias Pinchflat.Media.MediaItem
+
+  alias Pinchflat.YtDlp.Backend.Media, as: YtDlpMedia
+  alias Pinchflat.YtDlp.DownloadOptionBuilder, as: YtDlpDownloadOptionBuilder
+  alias Pinchflat.Metadata.MetadataParser, as: YtDlpMetadataParser
+  alias Pinchflat.Metadata.MetadataFileHelpers, as: YtDlpMetadataHelpers
+
+  @doc """
+  Downloads media for a media item, updating the media item based on the metadata
+  returned by yt-dlp. Also saves the entire metadata response to the associated
+  media_metadata record.
+
+  NOTE: related methods (like the download worker) won't download if the media item's source
+  is set to not download media. However, I'm not enforcing that here since I need this for testing.
+  This may change in the future but I'm not stressed.
+
+  Returns {:ok, %MediaItem{}} | {:error, any, ...any}
+  """
+  def download_for_media_item(%MediaItem{} = media_item) do
+    item_with_preloads = Repo.preload(media_item, [:metadata, source: :media_profile])
+
+    case download_with_options(media_item.original_url, item_with_preloads) do
+      {:ok, parsed_json} ->
+        {parser, helpers} = {YtDlpMetadataParser, YtDlpMetadataHelpers}
+
+        parsed_attrs =
+          parsed_json
+          |> parser.parse_for_media_item()
+          |> Map.merge(%{
+            media_downloaded_at: DateTime.utc_now(),
+            metadata: %{
+              metadata_filepath: helpers.compress_and_store_metadata_for(media_item, parsed_json),
+              thumbnail_filepath: helpers.download_and_store_thumbnail_for(media_item, parsed_json)
+            }
+          })
+
+        # Don't forgor to use preloaded associations or updates to
+        # associations won't work!
+        Media.update_media_item(item_with_preloads, parsed_attrs)
+
+      err ->
+        err
+    end
+  end
+
+  # def download_for_source(source, url) do
+  #   # Create MI from source and URL
+  #   media_item = nil
+  # end
+
+  defp download_with_options(url, item_with_preloads) do
+    {:ok, options} = YtDlpDownloadOptionBuilder.build(item_with_preloads)
+
+    YtDlpMedia.download(url, options)
+  end
+end

lib/pinchflat_web.ex

@@ -45,14 +45,20 @@ defmodule PinchflatWeb do
       import Plug.Conn
       import PinchflatWeb.Gettext
 
+      alias Pinchflat.Settings
+      alias PinchflatWeb.Layouts
+
       unquote(verified_routes())
     end
   end
 
   def live_view do
     quote do
-      use Phoenix.LiveView,
-        layout: {PinchflatWeb.Layouts, :app}
+      use Phoenix.Component, global_prefixes: ~w(x-)
+
+      use Phoenix.LiveView
+
+      alias Pinchflat.Settings
 
       unquote(html_helpers())
     end
@@ -62,18 +68,22 @@ defmodule PinchflatWeb do
     quote do
       use Phoenix.LiveComponent
 
+      alias Pinchflat.Settings
+
       unquote(html_helpers())
     end
   end
 
   def html do
     quote do
-      use Phoenix.Component
+      use Phoenix.Component, global_prefixes: ~w(x-)
 
       # Import convenience functions from controllers
       import Phoenix.Controller,
         only: [get_csrf_token: 0, view_module: 1, view_template: 1]
 
+      alias Pinchflat.Settings
+
       # Include general helpers for rendering HTML
       unquote(html_helpers())
     end
@@ -84,8 +94,15 @@ defmodule PinchflatWeb do
       # HTML escaping functionality
       import Phoenix.HTML
       # Core UI components and translation
-      import PinchflatWeb.CoreComponents
       import PinchflatWeb.Gettext
+      import PinchflatWeb.CoreComponents
+      import PinchflatWeb.CustomComponents.TabComponents
+      import PinchflatWeb.CustomComponents.TextComponents
+      import PinchflatWeb.CustomComponents.TableComponents
+      import PinchflatWeb.CustomComponents.ButtonComponents
+
+      alias Pinchflat.Settings
+      alias Pinchflat.Utils.StringUtils
 
       # Shortcut for generating JS commands
       alias Phoenix.LiveView.JS

lib/pinchflat_web/components/core_components.ex

@@ -16,9 +16,11 @@ defmodule PinchflatWeb.CoreComponents do
   """
   use Phoenix.Component
 
-  alias Phoenix.LiveView.JS
   import PinchflatWeb.Gettext
 
+  alias Phoenix.LiveView.JS
+  alias PinchflatWeb.CustomComponents.TextComponents
+
   @doc """
   Renders a modal.
 
@@ -38,6 +40,7 @@ defmodule PinchflatWeb.CoreComponents do
   """
   attr :id, :string, required: true
   attr :show, :boolean, default: false
+  attr :allow_close, :boolean, default: true
   attr :on_cancel, JS, default: %JS{}
   slot :inner_block, required: true
 
@@ -48,9 +51,9 @@ defmodule PinchflatWeb.CoreComponents do
       phx-mounted={@show && show_modal(@id)}
       phx-remove={hide_modal(@id)}
       data-cancel={JS.exec(@on_cancel, "phx-remove")}
-      class="relative z-50 hidden"
+      class="relative z-99999 hidden"
     >
-      <div id={"#{@id}-bg"} class="bg-zinc-50/90 fixed inset-0 transition-opacity" aria-hidden="true" />
+      <div id={"#{@id}-bg"} class="bg-black-2/80 fixed inset-0 transition-opacity" aria-hidden="true" />
       <div
         class="fixed inset-0 overflow-y-auto"
         aria-labelledby={"#{@id}-title"}
@@ -60,28 +63,28 @@ defmodule PinchflatWeb.CoreComponents do
         tabindex="0"
       >
         <div class="flex min-h-full items-center justify-center">
-          <div class="w-full max-w-3xl p-4 sm:p-6 lg:py-8">
-            <.focus_wrap
+          <div class="w-full max-w-3xl p-2 sm:p-6 lg:py-8">
+            <div
               id={"#{@id}-container"}
-              phx-window-keydown={JS.exec("data-cancel", to: "##{@id}")}
+              phx-window-keydown={@allow_close && JS.exec("data-cancel", to: "##{@id}")}
               phx-key="escape"
-              phx-click-away={JS.exec("data-cancel", to: "##{@id}")}
-              class="shadow-zinc-700/10 ring-zinc-700/10 relative hidden rounded-2xl bg-white p-14 shadow-lg ring-1 transition"
+              phx-click-away={@allow_close && JS.exec("data-cancel", to: "##{@id}")}
+              class="shadow-zinc-700/10 ring-zinc-700/10 relative hidden rounded-2xl bg-graydark p-8 sm:p-14 shadow-lg ring-1 transition"
             >
-              <div class="absolute top-6 right-5">
+              <div :if={@allow_close} class="absolute top-6 right-5">
                 <button
                   phx-click={JS.exec("data-cancel", to: "##{@id}")}
                   type="button"
-                  class="-m-3 flex-none p-3 opacity-20 hover:opacity-40"
+                  class="-m-3 flex-none p-3 opacity-60 hover:opacity-80"
                   aria-label={gettext("close")}
                 >
-                  <.icon name="hero-x-mark-solid" class="h-5 w-5" />
+                  <.icon name="hero-x-mark-solid" class="h-5 w-5 text-white" />
                 </button>
               </div>
               <div id={"#{@id}-content"}>
                 <%= render_slot(@inner_block) %>
               </div>
-            </.focus_wrap>
+            </div>
           </div>
         </div>
       </div>
@@ -112,24 +115,29 @@ defmodule PinchflatWeb.CoreComponents do
     <div
       :if={msg = render_slot(@inner_block) || Phoenix.Flash.get(@flash, @kind)}
       id={@id}
-      phx-click={JS.push("lv:clear-flash", value: %{key: @kind}) |> hide("##{@id}")}
+      class="pb-8"
       role="alert"
-      class={[
-        "fixed top-2 right-2 mr-2 w-80 sm:w-96 z-50 rounded-lg p-3 ring-1",
-        @kind == :info && "bg-emerald-50 text-emerald-800 ring-emerald-500 fill-cyan-900",
-        @kind == :error && "bg-rose-50 text-rose-900 shadow-md ring-rose-500 fill-rose-900"
-      ]}
       {@rest}
     >
-      <p :if={@title} class="flex items-center gap-1.5 text-sm font-semibold leading-6">
-        <.icon :if={@kind == :info} name="hero-information-circle-mini" class="h-4 w-4" />
-        <.icon :if={@kind == :error} name="hero-exclamation-circle-mini" class="h-4 w-4" />
-        <%= @title %>
-      </p>
-      <p class="mt-2 text-sm leading-5"><%= msg %></p>
-      <button type="button" class="group absolute top-1 right-1 p-2" aria-label={gettext("close")}>
-        <.icon name="hero-x-mark-solid" class="h-5 w-5 opacity-40 group-hover:opacity-70" />
-      </button>
+      <div class={[
+        "flex justify-between w-full border-l-6 bg-opacity-[50%] p-5 shadow-md dark:bg-opacity-40 dark:text-white",
+        @kind == :info && "border-[#34D399] bg-[#34D399]",
+        @kind == :error && "border-[#F87171] bg-[#F87171]"
+      ]}>
+        <main>
+          <h5 :if={@title} class="mb-2 text-lg font-bold">
+            <%= @title %>
+          </h5>
+          <p class="mt-2 text-md leading-5 opacity-80"><%= msg %></p>
+        </main>
+        <button
+          type="button"
+          aria-label={gettext("close")}
+          phx-click={JS.push("lv:clear-flash", value: %{key: @kind}) |> hide("##{@id}")}
+        >
+          <.icon name="hero-x-mark-solid" class="h-7 w-7 opacity-70 hover:opacity-100" />
+        </button>
+      </div>
     </div>
     """
   end
@@ -146,7 +154,7 @@ defmodule PinchflatWeb.CoreComponents do
 
   def flash_group(assigns) do
     ~H"""
-    <div id={@id}>
+    <div class="flex flex-col gap-7.5" id={@id}>
       <.flash kind={:info} title="Success!" flash={@flash} />
       <.flash kind={:error} title="Error!" flash={@flash} />
       <.flash
@@ -168,8 +176,7 @@ defmodule PinchflatWeb.CoreComponents do
         phx-connected={hide("#server-error")}
         hidden
       >
-        Hang in there while we get back on track
-        <.icon name="hero-arrow-path" class="ml-1 h-3 w-3 animate-spin" />
+        Hang in there while we get back on track <.icon name="hero-arrow-path" class="ml-1 h-3 w-3 animate-spin" />
       </.flash>
     </div>
     """
@@ -201,46 +208,14 @@ defmodule PinchflatWeb.CoreComponents do
   def simple_form(assigns) do
     ~H"""
     <.form :let={f} for={@for} as={@as} {@rest}>
-      <div class="mt-10 space-y-8 bg-white">
-        <%= render_slot(@inner_block, f) %>
-        <div :for={action <- @actions} class="mt-2 flex items-center justify-between gap-6">
-          <%= render_slot(action, f) %>
-        </div>
+      <%= render_slot(@inner_block, f) %>
+      <div :for={action <- @actions} class="mt-2 flex items-center justify-between gap-6">
+        <%= render_slot(action, f) %>
       </div>
     </.form>
     """
   end
 
-  @doc """
-  Renders a button.
-
-  ## Examples
-
-      <.button>Send!</.button>
-      <.button phx-click="go" class="ml-2">Send!</.button>
-  """
-  attr :type, :string, default: nil
-  attr :class, :string, default: nil
-  attr :rest, :global, include: ~w(disabled form name value)
-
-  slot :inner_block, required: true
-
-  def button(assigns) do
-    ~H"""
-    <button
-      type={@type}
-      class={[
-        "phx-submit-loading:opacity-75 rounded-lg bg-zinc-900 hover:bg-zinc-700 py-2 px-3",
-        "text-sm font-semibold leading-6 text-white active:text-white/80",
-        @class
-      ]}
-      {@rest}
-    >
-      <%= render_slot(@inner_block) %>
-    </button>
-    """
-  end
-
   @doc """
   Renders an input with label and error messages.
 
@@ -269,24 +244,25 @@ defmodule PinchflatWeb.CoreComponents do
   attr :id, :any, default: nil
   attr :name, :any
   attr :label, :string, default: nil
+  attr :label_suffix, :string, default: nil
   attr :value, :any
+  attr :help, :string, default: nil
 
   attr :type, :string,
     default: "text",
     values: ~w(checkbox color date datetime-local email file hidden month number password
-               range radio search select tel text textarea time url week)
+               toggle range radio search select tel text textarea time url week)
 
-  attr :field, Phoenix.HTML.FormField,
-    doc: "a form field struct retrieved from the form, for example: @form[:email]"
+  attr :field, Phoenix.HTML.FormField, doc: "a form field struct retrieved from the form, for example: @form[:email]"
 
   attr :errors, :list, default: []
   attr :checked, :boolean, doc: "the checked flag for checkbox inputs"
   attr :prompt, :string, default: nil, doc: "the prompt for select inputs"
   attr :options, :list, doc: "the options to pass to Phoenix.HTML.Form.options_for_select/2"
   attr :multiple, :boolean, default: false, doc: "the multiple flag for select inputs"
+  attr :inputclass, :string, default: ""
 
-  attr :rest, :global,
-    include: ~w(accept autocomplete capture cols disabled form list max maxlength min minlength
+  attr :rest, :global, include: ~w(accept autocomplete capture cols disabled form list max maxlength min minlength
                 multiple pattern placeholder readonly required rows size step)
 
   slot :inner_block
@@ -308,7 +284,7 @@ defmodule PinchflatWeb.CoreComponents do
 
     ~H"""
     <div phx-feedback-for={@name}>
-      <label class="flex items-center gap-4 text-sm leading-6 text-zinc-600">
+      <label class="flex items-center gap-4 text-sm leading-6">
         <input type="hidden" name={@name} value="false" />
         <input
           type="checkbox"
@@ -316,30 +292,81 @@ defmodule PinchflatWeb.CoreComponents do
           name={@name}
           value="true"
           checked={@checked}
-          class="rounded border-zinc-300 text-zinc-900 focus:ring-0"
+          class={["rounded focus:ring-0", @inputclass]}
           {@rest}
         />
         <%= @label %>
+        <span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
       </label>
+      <.help :if={@help}><%= @help %></.help>
       <.error :for={msg <- @errors}><%= msg %></.error>
     </div>
     """
   end
 
+  def input(%{type: "toggle"} = assigns) do
+    assigns =
+      assign_new(assigns, :checked, fn ->
+        Phoenix.HTML.Form.normalize_value("checkbox", assigns[:value])
+      end)
+
+    ~H"""
+    <div x-data={"{ enabled: #{@checked}}"}>
+      <.label for={@id}>
+        <%= @label %>
+        <span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
+      </.label>
+      <div class="relative">
+        <input type="hidden" name={@name} value="false" />
+        <input
+          type="checkbox"
+          id={@id}
+          name={@name}
+          value="true"
+          x-bind:checked="enabled"
+          class="sr-only"
+          @change="enabled = !enabled"
+          {@rest}
+        />
+        <div class="inline-block cursor-pointer" @click="enabled = !enabled">
+          <div x-bind:class="enabled && '!bg-primary'" class="block h-8 w-14 rounded-full bg-black"></div>
+          <div
+            x-bind:class="enabled && '!right-1 !translate-x-full'"
+            class={[
+              "absolute left-1 top-1 flex h-6 w-6 items-center justify-center rounded-full bg-white transition",
+              @inputclass
+            ]}
+          >
+          </div>
+        </div>
+        <.help :if={@help}><%= @help %></.help>
+        <.error :for={msg <- @errors}><%= msg %></.error>
+      </div>
+    </div>
+    """
+  end
+
   def input(%{type: "select"} = assigns) do
     ~H"""
     <div phx-feedback-for={@name}>
-      <.label for={@id}><%= @label %></.label>
+      <.label for={@id}>
+        <%= @label %><span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
+      </.label>
       <select
         id={@id}
         name={@name}
-        class="mt-2 block w-full rounded-md border border-gray-300 bg-white shadow-sm focus:border-zinc-400 focus:ring-0 sm:text-sm"
+        class={[
+          "relative z-20 w-full appearance-none rounded border border-stroke bg-transparent py-3 pl-5 pr-12 outline-none transition",
+          "focus:border-primary active:border-primary dark:border-form-strokedark dark:bg-form-input text-black dark:text-white",
+          @inputclass
+        ]}
         multiple={@multiple}
         {@rest}
       >
         <option :if={@prompt} value=""><%= @prompt %></option>
         <%= Phoenix.HTML.Form.options_for_select(@options, @value) %>
       </select>
+      <.help :if={@help}><%= @help %></.help>
       <.error :for={msg <- @errors}><%= msg %></.error>
     </div>
     """
@@ -348,18 +375,22 @@ defmodule PinchflatWeb.CoreComponents do
   def input(%{type: "textarea"} = assigns) do
     ~H"""
     <div phx-feedback-for={@name}>
-      <.label for={@id}><%= @label %></.label>
+      <.label for={@id}>
+        <%= @label %><span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
+      </.label>
       <textarea
         id={@id}
         name={@name}
         class={[
           "mt-2 block w-full rounded-lg text-zinc-900 focus:ring-0 sm:text-sm sm:leading-6",
           "min-h-[6rem] phx-no-feedback:border-zinc-300 phx-no-feedback:focus:border-zinc-400",
+          @inputclass,
           @errors == [] && "border-zinc-300 focus:border-zinc-400",
           @errors != [] && "border-rose-400 focus:border-rose-400"
         ]}
         {@rest}
       ><%= Phoenix.HTML.Form.normalize_value("textarea", @value) %></textarea>
+      <.help :if={@help}><%= @help %></.help>
       <.error :for={msg <- @errors}><%= msg %></.error>
     </div>
     """
@@ -369,25 +400,42 @@ defmodule PinchflatWeb.CoreComponents do
   def input(assigns) do
     ~H"""
     <div phx-feedback-for={@name}>
-      <.label for={@id}><%= @label %></.label>
+      <.label for={@id}>
+        <%= @label %><span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
+      </.label>
       <input
         type={@type}
         name={@name}
         id={@id}
         value={Phoenix.HTML.Form.normalize_value(@type, @value)}
         class={[
-          "mt-2 block w-full rounded-lg text-zinc-900 focus:ring-0 sm:text-sm sm:leading-6",
-          "phx-no-feedback:border-zinc-300 phx-no-feedback:focus:border-zinc-400",
-          @errors == [] && "border-zinc-300 focus:border-zinc-400",
+          "w-full rounded-lg border-[1.5px] border-stroke bg-transparent px-5 py-3 font-normal text-black",
+          "outline-none transition focus:border-primary active:border-primary disabled:cursor-default disabled:bg-whiter",
+          "dark:border-form-strokedark dark:bg-form-input dark:text-white dark:focus:border-primary",
+          @inputclass,
           @errors != [] && "border-rose-400 focus:border-rose-400"
         ]}
         {@rest}
       />
+      <.help :if={@help}><%= @help %></.help>
       <.error :for={msg <- @errors}><%= msg %></.error>
     </div>
     """
   end
 
+  @doc """
+  Renders help text.
+  """
+  slot :inner_block, required: true
+
+  def help(assigns) do
+    ~H"""
+    <p class="mt-1 text-sm leading-5">
+      <%= render_slot(@inner_block) %>
+    </p>
+    """
+  end
+
   @doc """
   Renders a label.
   """
@@ -396,7 +444,7 @@ defmodule PinchflatWeb.CoreComponents do
 
   def label(assigns) do
     ~H"""
-    <label for={@for} class="block text-sm font-semibold leading-6 text-zinc-800">
+    <label for={@for} class="mt-5 mb-2 inline-block text-md font-medium text-black dark:text-white">
       <%= render_slot(@inner_block) %>
     </label>
     """
@@ -409,7 +457,7 @@ defmodule PinchflatWeb.CoreComponents do
 
   def error(assigns) do
     ~H"""
-    <p class="mt-3 flex gap-3 text-sm leading-6 text-rose-600 phx-no-feedback:hidden">
+    <p class="mt-1 mb-5 flex gap-3 text-md leading-6 text-rose-600 phx-no-feedback:hidden">
       <.icon name="hero-exclamation-circle-mini" class="mt-0.5 h-5 w-5 flex-none" />
       <%= render_slot(@inner_block) %>
     </p>
@@ -425,7 +473,7 @@ defmodule PinchflatWeb.CoreComponents do
   slot :subtitle
   slot :actions
 
-  def header(assigns) do
+  def old_header(assigns) do
     ~H"""
     <header class={[@actions != [] && "flex items-center justify-between gap-6", @class]}>
       <div>
@@ -446,10 +494,10 @@ defmodule PinchflatWeb.CoreComponents do
 
   ## Examples
 
-      <.table id="users" rows={@users}>
+      <.old_table id="users" rows={@users}>
         <:col :let={user} label="id"><%= user.id %></:col>
         <:col :let={user} label="username"><%= user.username %></:col>
-      </.table>
+      </.old_table>
   """
   attr :id, :string, required: true
   attr :rows, :list, required: true
@@ -466,56 +514,51 @@ defmodule PinchflatWeb.CoreComponents do
 
   slot :action, doc: "the slot for showing user actions in the last table column"
 
-  def table(assigns) do
+  def old_table(assigns) do
     assigns =
       with %{rows: %Phoenix.LiveView.LiveStream{}} <- assigns do
         assign(assigns, row_id: assigns.row_id || fn {id, _item} -> id end)
       end
 
     ~H"""
-    <div class="overflow-y-auto px-4 sm:overflow-visible sm:px-0">
-      <table class="w-[40rem] mt-11 sm:w-full">
-        <thead class="text-sm text-left leading-6 text-zinc-500">
-          <tr>
-            <th :for={col <- @col} class="p-0 pb-4 pr-6 font-normal"><%= col[:label] %></th>
-            <th :if={@action != []} class="relative p-0 pb-4">
-              <span class="sr-only"><%= gettext("Actions") %></span>
-            </th>
-          </tr>
-        </thead>
-        <tbody
-          id={@id}
-          phx-update={match?(%Phoenix.LiveView.LiveStream{}, @rows) && "stream"}
-          class="relative divide-y divide-zinc-100 border-t border-zinc-200 text-sm leading-6 text-zinc-700"
-        >
-          <tr :for={row <- @rows} id={@row_id && @row_id.(row)} class="group hover:bg-zinc-50">
-            <td
-              :for={{col, i} <- Enum.with_index(@col)}
-              phx-click={@row_click && @row_click.(row)}
-              class={["relative p-0", @row_click && "hover:cursor-pointer"]}
-            >
-              <div class="block py-4 pr-6">
-                <span class="absolute -inset-y-px right-0 -left-4 group-hover:bg-zinc-50 sm:rounded-l-xl" />
-                <span class={["relative", i == 0 && "font-semibold text-zinc-900"]}>
-                  <%= render_slot(col, @row_item.(row)) %>
-                </span>
-              </div>
-            </td>
-            <td :if={@action != []} class="relative w-14 p-0">
-              <div class="relative whitespace-nowrap py-4 text-right text-sm font-medium">
-                <span class="absolute -inset-y-px -right-4 left-0 group-hover:bg-zinc-50 sm:rounded-r-xl" />
-                <span
-                  :for={action <- @action}
-                  class="relative ml-4 font-semibold leading-6 text-zinc-900 hover:text-zinc-700"
-                >
-                  <%= render_slot(action, @row_item.(row)) %>
-                </span>
-              </div>
-            </td>
-          </tr>
-        </tbody>
-      </table>
-    </div>
+    <table class="w-[40rem] mt-11 sm:w-full">
+      <thead class="text-sm text-left leading-6 text-zinc-500">
+        <tr>
+          <th :for={col <- @col} class="p-0 pb-4 pr-6 font-normal"><%= col[:label] %></th>
+          <th :if={@action != []} class="relative p-0 pb-4">
+            <span class="sr-only"><%= gettext("Actions") %></span>
+          </th>
+        </tr>
+      </thead>
+      <tbody
+        id={@id}
+        phx-update={match?(%Phoenix.LiveView.LiveStream{}, @rows) && "stream"}
+        class="relative divide-y divide-zinc-100 border-t border-zinc-200 text-sm leading-6 text-zinc-700"
+      >
+        <tr :for={row <- @rows} id={@row_id && @row_id.(row)} class="group hover:bg-zinc-50">
+          <td
+            :for={{col, i} <- Enum.with_index(@col)}
+            phx-click={@row_click && @row_click.(row)}
+            class={["relative p-0", @row_click && "hover:cursor-pointer"]}
+          >
+            <div class="block py-4 pr-6">
+              <span class="absolute -inset-y-px right-0 -left-4 group-hover:bg-zinc-50 sm:rounded-l-xl" />
+              <span class={["relative", i == 0 && "font-semibold text-zinc-900"]}>
+                <%= render_slot(col, @row_item.(row)) %>
+              </span>
+            </div>
+          </td>
+          <td :if={@action != []} class="relative w-14 p-0">
+            <div class="relative whitespace-nowrap py-4 text-right text-sm font-medium">
+              <span class="absolute -inset-y-px -right-4 left-0 group-hover:bg-zinc-50 sm:rounded-r-xl" />
+              <span :for={action <- @action} class="relative ml-4 font-semibold leading-6 text-zinc-900 hover:text-zinc-700">
+                <%= render_slot(action, @row_item.(row)) %>
+              </span>
+            </div>
+          </td>
+        </tr>
+      </tbody>
+    </table>
     """
   end
 
@@ -535,34 +578,62 @@ defmodule PinchflatWeb.CoreComponents do
 
   def list(assigns) do
     ~H"""
-    <div class="mt-14">
-      <dl class="-my-4 divide-y divide-zinc-100">
+    <div class="mt-2 mb-14">
+      <dl class="-my-4 divide-y dark:divide-strokedark">
         <div :for={item <- @item} class="flex gap-4 py-4 text-sm leading-6 sm:gap-8">
-          <dt class="w-1/4 flex-none text-zinc-500"><%= item.title %></dt>
-          <dd class="text-zinc-700"><%= render_slot(item) %></dd>
+          <dt class="w-1/4 flex-none dark:text-white"><%= item.title %></dt>
+          <dd class="dark:text-white"><%= render_slot(item) %></dd>
         </div>
       </dl>
     </div>
     """
   end
 
+  @doc """
+  Renders a data list from a given map. Used in development to
+  quickly show the attributes of a database record.
+  """
+  attr :map, :map, required: true
+
+  def list_items_from_map(assigns) do
+    attrs =
+      Enum.filter(assigns.map, fn
+        {_, %{__struct__: s}} when s not in [Date, DateTime] ->
+          false
+
+        {_, [%{__meta__: _} | _]} ->
+          false
+
+        _ ->
+          true
+      end)
+
+    assigns = assign(assigns, iterable_attributes: attrs)
+
+    ~H"""
+    <ul>
+      <li :for={{k, v} <- @iterable_attributes} class="mb-2">
+        <strong><%= k %>:</strong>
+        <TextComponents.inline_code><%= v %></TextComponents.inline_code>
+      </li>
+    </ul>
+    """
+  end
+
   @doc """
   Renders a back navigation link.
 
   ## Examples
 
-      <.back navigate={~p"/posts"}>Back to posts</.back>
+      <.back href={~p"/posts"}>Back to posts</.back>
   """
-  attr :navigate, :any, required: true
+  attr :href, :any, required: true
   slot :inner_block, required: true
 
   def back(assigns) do
     ~H"""
     <div class="mt-16">
-      <.link
-        navigate={@navigate}
-        class="text-sm font-semibold leading-6 text-zinc-900 hover:text-zinc-700"
-      >
+      <.link href={@href} class="text-sm font-semibold leading-6 text-zinc-900 hover:text-zinc-700">
         <.icon name="hero-arrow-left-solid" class="h-3 w-3" />
         <%= render_slot(@inner_block) %>
       </.link>
@@ -602,10 +673,11 @@ defmodule PinchflatWeb.CoreComponents do
   def show(js \\ %JS{}, selector) do
     JS.show(js,
       to: selector,
-      transition:
-        {"transition-all transform ease-out duration-300",
-         "opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95",
-         "opacity-100 translate-y-0 sm:scale-100"}
+      transition: {
+        "transition-all transform ease-out duration-300",
+        "opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95",
+        "opacity-100 translate-y-0 sm:scale-100"
+      }
     )
   end
 
@@ -613,10 +685,11 @@ defmodule PinchflatWeb.CoreComponents do
     JS.hide(js,
       to: selector,
       time: 200,
-      transition:
-        {"transition-all transform ease-in duration-200",
-         "opacity-100 translate-y-0 sm:scale-100",
-         "opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"}
+      transition: {
+        "transition-all transform ease-in duration-200",
+        "opacity-100 translate-y-0 sm:scale-100",
+        "opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
+      }
     )
   end
 
@@ -629,7 +702,6 @@ defmodule PinchflatWeb.CoreComponents do
     )
     |> show("##{id}-container")
     |> JS.add_class("overflow-hidden", to: "body")
-    |> JS.focus_first(to: "##{id}-content")
   end
 
   def hide_modal(js \\ %JS{}, id) do
@@ -641,7 +713,6 @@ defmodule PinchflatWeb.CoreComponents do
     |> hide("##{id}-container")
     |> JS.hide(to: "##{id}", transition: {"block", "block", "hidden"})
     |> JS.remove_class("overflow-hidden", to: "body")
-    |> JS.pop_focus()
   end
 
   @doc """

lib/pinchflat_web/components/custom_components/button_components.ex

@@ -0,0 +1,41 @@
+defmodule PinchflatWeb.CustomComponents.ButtonComponents do
+  @moduledoc false
+  use Phoenix.Component
+
+  @doc """
+  Render a button
+
+  ## Examples
+
+      <.button color="bg-primary" rounding="rounded-sm">
+        <span>Click me</span>
+      </.button>
+  """
+  attr :color, :string, default: "bg-primary"
+  attr :rounding, :string, default: "rounded-sm"
+  attr :class, :string, default: ""
+  attr :type, :string, default: "submit"
+  attr :disabled, :boolean, default: false
+  attr :rest, :global
+
+  slot :inner_block, required: true
+
+  def button(assigns) do
+    ~H"""
+    <button
+      class={[
+        "text-center font-medium text-white",
+        "#{@rounding} inline-flex items-center justify-center px-8 py-4",
+        "#{@color}",
+        "hover:bg-opacity-90 lg:px-8 xl:px-10",
+        "disabled:bg-opacity-50 disabled:cursor-not-allowed disabled:text-gray-2",
+        @class
+      ]}
+      disabled={@disabled}
+      {@rest}
+    >
+      <%= render_slot(@inner_block) %>
+    </button>
+    """
+  end
+end

lib/pinchflat_web/components/custom_components/tab_components.ex

@@ -0,0 +1,37 @@
+defmodule PinchflatWeb.CustomComponents.TabComponents do
+  @moduledoc false
+  use Phoenix.Component
+
+  @doc """
+  Takes a list of tabs and renders them in a tabbed layout.
+  """
+  slot :tab, required: true do
+    attr :title, :string, required: true
+  end
+
+  def tabbed_layout(assigns) do
+    ~H"""
+    <div
+      x-data="{ openTab: 0, activeClasses: 'text-meta-5 border-meta-5', inactiveClasses: 'border-transparent' }"
+      class="w-full"
+    >
+      <div class="mb-6 flex flex-wrap gap-5 border-b border-strokedark sm:gap-10">
+        <a
+          :for={{tab, idx} <- Enum.with_index(@tab)}
+          href="#"
+          @click.prevent={"openTab = #{idx}"}
+          x-bind:class={"openTab === #{idx} ? activeClasses : inactiveClasses"}
+          class="border-b-2 py-4 text-sm font-medium hover:text-meta-5 md:text-base"
+        >
+          <span class="text-xl"><%= tab.title %></span>
+        </a>
+      </div>
+      <div>
+        <div :for={{tab, idx} <- Enum.with_index(@tab)} x-show={"openTab === #{idx}"} class="font-medium leading-relaxed">
+          <%= render_slot(tab) %>
+        </div>
+      </div>
+    </div>
+    """
+  end
+end

lib/pinchflat_web/components/custom_components/table_components.ex

@@ -0,0 +1,53 @@
+defmodule PinchflatWeb.CustomComponents.TableComponents do
+  @moduledoc false
+  use Phoenix.Component
+
+  @doc """
+  Renders a table component with the given rows and columns.
+
+  ## Examples
+
+      <.table rows={@users}>
+        <:col :let={user} label="Name"><%= user.name %></:col>
+      </.table>
+  """
+  attr :rows, :list, required: true
+  attr :table_class, :string, default: ""
+
+  attr :row_item, :any,
+    default: &Function.identity/1,
+    doc: "the function for mapping each row before calling the :col and :action slots"
+
+  slot :col, required: true do
+    attr :label, :string
+    attr :class, :string
+  end
+
+  def table(assigns) do
+    ~H"""
+    <table class={["w-full table-auto", @table_class]}>
+      <thead>
+        <tr class="bg-gray-2 text-left dark:bg-meta-4">
+          <th :for={col <- @col} class="px-4 py-4 font-medium text-black dark:text-white xl:pl-11">
+            <%= col[:label] %>
+          </th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr :for={{row, i} <- Enum.with_index(@rows)}>
+          <td
+            :for={col <- @col}
+            class={[
+              "px-4 py-5 pl-9 dark:border-strokedark xl:pl-11",
+              i + 1 > length(@rows) && "border-b border-[#eee] dark:border-π",
+              col[:class]
+            ]}
+          >
+            <%= render_slot(col, @row_item.(row)) %>
+          </td>
+        </tr>
+      </tbody>
+    </table>
+    """
+  end
+end

lib/pinchflat_web/components/custom_components/text_components.ex

@@ -0,0 +1,48 @@
+defmodule PinchflatWeb.CustomComponents.TextComponents do
+  @moduledoc false
+  use Phoenix.Component
+
+  alias PinchflatWeb.CoreComponents
+
+  @doc """
+  Renders a code block with the given content.
+  """
+  slot :inner_block
+
+  def inline_code(assigns) do
+    ~H"""
+    <code class="inline-block text-sm font-mono text-gray bg-boxdark rounded-md p-0.5 mx-0.5 text-nowrap">
+      <%= render_slot(@inner_block) %>
+    </code>
+    """
+  end
+
+  @doc """
+  Renders a reference link with the given href and content.
+  """
+  attr :href, :string, required: true
+  slot :inner_block
+
+  def inline_link(assigns) do
+    ~H"""
+    <.link href={@href} target="_blank" class="text-blue-500 hover:text-blue-300">
+      <%= render_slot(@inner_block) %>
+    </.link>
+    """
+  end
+
+  @doc """
+  Renders an icon as a link with the given href.
+  """
+  attr :href, :string, required: true
+  attr :icon, :string, required: true
+  attr :class, :string, default: ""
+
+  def icon_link(assigns) do
+    ~H"""
+    <.link href={@href} class={["hover:text-secondary duration-200 ease-in-out", @class]}>
+      <CoreComponents.icon name={@icon} />
+    </.link>
+    """
+  end
+end

lib/pinchflat_web/components/layouts.ex

@@ -2,4 +2,30 @@ defmodule PinchflatWeb.Layouts do
   use PinchflatWeb, :html
 
   embed_templates "layouts/*"
+  embed_templates "layouts/partials/*"
+
+  attr :icon, :string, required: true
+  attr :text, :string, required: true
+  attr :href, :any, required: true
+  attr :target, :any, default: "_self"
+
+  def sidebar_item(assigns) do
+    # I'm testing out grouping classes here. Tentative order: font, layout, color, animation, state-modifiers
+    ~H"""
+    <li>
+      <.link
+        href={@href}
+        target={@target}
+        class={[
+          "font-medium text-bodydark1",
+          "group relative flex items-center gap-2.5 rounded-sm px-4 py-2 duration-300 ease-in-out",
+          "duration-300 ease-in-out",
+          "hover:bg-graydark dark:hover:bg-meta-4"
+        ]}
+      >
+        <.icon name={@icon} /> <%= @text %>
+      </.link>
+    </li>
+    """
+  end
 end

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

@@ -1,32 +1,13 @@
-<header class="px-4 sm:px-6 lg:px-8">
-  <div class="flex items-center justify-between border-b border-zinc-100 py-3 text-sm">
-    <div class="flex items-center gap-4">
-      <a href="/">
-        <img src={~p"/images/logo.svg"} width="36" />
-      </a>
-      <p class="bg-brand/5 text-brand rounded-full px-2 font-medium leading-6">
-        v<%= Application.spec(:phoenix, :vsn) %>
-      </p>
-    </div>
-    <div class="flex items-center gap-4 font-semibold leading-6 text-zinc-900">
-      <a href="https://twitter.com/elixirphoenix" class="hover:text-zinc-700">
-        @elixirphoenix
-      </a>
-      <a href="https://github.com/phoenixframework/phoenix" class="hover:text-zinc-700">
-        GitHub
-      </a>
-      <a
-        href="https://hexdocs.pm/phoenix/overview.html"
-        class="rounded-lg bg-zinc-100 px-2 py-1 hover:bg-zinc-200/80"
-      >
-        Get Started <span aria-hidden="true">&rarr;</span>
-      </a>
-    </div>
+<div class="flex h-screen overflow-hidden">
+  <.sidebar />
+
+  <div class="relative flex flex-1 flex-col overflow-y-auto overflow-x-hidden">
+    <.header params={@conn.params} />
+    <main>
+      <div class="mx-auto max-w-screen-2xl p-4 md:p-6 2xl:p-10">
+        <.flash_group flash={@flash} />
+        <%= @inner_content %>
+      </div>
+    </main>
   </div>
-</header>
-<main class="px-4 py-20 sm:px-6 lg:px-8">
-  <div class="mx-auto max-w-2xl">
-    <.flash_group flash={@flash} />
-    <%= @inner_content %>
-  </div>
-</main>
+</div>

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

@@ -0,0 +1,19 @@
+<div class="flex h-screen overflow-hidden">
+  <div class="relative flex flex-1 flex-col overflow-y-auto overflow-x-hidden">
+    <header class="sticky top-0 z-999 flex w-full bg-white drop-shadow-1 dark:bg-boxdark dark:drop-shadow-none">
+      <div class="flex flex-grow items-center px-4 py-4 shadow-2 md:px-6 2xl:px-11">
+        <div class="flex items-center">
+          <img src={~p"/images/logo.png?cachebust=2024-02-29"} alt="Pinchflat" class="w-9 h-9" />
+          <h2 class="text-xl font-bold text-white pl-2">Pinchflat</h2>
+        </div>
+      </div>
+    </header>
+
+    <main>
+      <div class="mx-auto max-w-screen-2xl p-4 md:p-6 2xl:p-10">
+        <.flash_group flash={@flash} />
+        <%= @inner_content %>
+      </div>
+    </main>
+  </div>
+</div>

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

@@ -0,0 +1,26 @@
+<.modal id="donate-modal" allow_close={true}>
+  <section x-data="{ inputValue: '' }">
+    <h3 class="text-2xl text-white">Donate</h3>
+    <p class="text-sm">Thank you for your support :&rpar;</p>
+    <p class="mt-4">
+      If you find the project valuable and want to support its development, a
+      <.inline_link href="https://www.paypal.me/kieraneglin">donation</.inline_link>
+      would be greatly appreciated.
+    </p>
+    <p class="mt-4">
+      Plus, $5 USD from any donation over $10 USD will be donated to
+      <.inline_link href="https://www.eff.org/">The Electronic Frontier Foundation</.inline_link>
+      who defend your online liberties and backed
+      <.inline_code>youtube-dl</.inline_code>
+      when Google took them down<.inline_link href="https://github.com/github/dmca/blob/9a85e0f021f7967af80e186b890776a50443f06c/2020/11/2020-11-16-RIAA-reversal-effletter.pdf">
+        <.icon name="hero-arrow-top-right-on-square" class="h-3 w-3" />
+      </.inline_link>.
+    </p>
+
+    <.link href="https://www.paypal.me/kieraneglin" target="_blank">
+      <.button color="bg-primary" class="w-full mt-8">
+        Donate
+      </.button>
+    </.link>
+  </section>
+</.modal>

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

@@ -0,0 +1,32 @@
+<header class="sticky top-0 z-999 flex w-full bg-white drop-shadow-1 dark:bg-boxdark dark:drop-shadow-none">
+  <div class="flex flex-grow items-center justify-between lg:justify-end px-4 py-4 shadow-2 md:px-6 2xl:px-11">
+    <div class="flex items-center gap-2 sm:gap-4 lg:hidden">
+      <button
+        class="z-99999 block rounded-sm border border-stroke bg-white p-1.5 shadow-sm dark:border-strokedark dark:bg-boxdark lg:hidden"
+        @click.stop="sidebarVisible = !sidebarVisible"
+      >
+        <.icon name="hero-bars-3" />
+      </button>
+      <a class="hidden sm:flex items-center lg:hidden" href="/">
+        <img src={~p"/images/logo.png?cachebust=2024-02-29"} alt="Pinchflat" class="w-9 h-9" />
+        <h2 class="text-xl font-bold text-white pl-2">Pinchflat</h2>
+      </a>
+    </div>
+    <div class="bg-meta-4 rounded-md">
+      <div class="relative">
+        <span class="absolute left-2 top-1/2 -translate-y-1/2 flex">
+          <.icon name="hero-magnifying-glass" />
+        </span>
+        <form action={~p"/search"}>
+          <input
+            type="text"
+            name="q"
+            value={@params["q"]}
+            placeholder="Type to search..."
+            class="w-full bg-transparent pl-9 pr-4 border-0 focus:ring-0 focus:outline-none lg:w-125"
+          />
+        </form>
+      </div>
+    </div>
+  </div>
+</header>

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

@@ -0,0 +1,58 @@
+<aside
+  x-bind:class="sidebarVisible ? 'translate-x-0' : '-translate-x-full'"
+  class={[
+    "-translate-x-full absolute left-0 top-0 z-9999 flex h-screen w-60 flex-col overflow-y-hidden justify-between",
+    "bg-black duration-300 ease-linear shadow-lg sm:shadow-none dark:bg-boxdark lg:static lg:translate-x-0"
+  ]}
+  @click.outside="sidebarVisible = false"
+>
+  <section>
+    <div class="flex items-center justify-between gap-2 px-6 py-5.5 lg:py-6.5">
+      <a href="/" class="flex items-center">
+        <img src={~p"/images/logo.png?cachebust=2024-02-29"} alt="Pinchflat" class="w-9 h-9" />
+        <h2 class="text-xl font-bold text-white pl-2">Pinchflat</h2>
+      </a>
+
+      <button class="block lg:hidden" @click.stop="sidebarVisible = !sidebarVisible">
+        <.icon name="hero-arrow-left" class="fill-current" />
+      </button>
+    </div>
+    <div class="no-scrollbar flex flex-col overflow-y-auto duration-300 ease-linear">
+      <nav class="mt-5 px-4 py-4 lg:mt-9 lg:px-6">
+        <h3 class="mb-4 ml-4 text-sm font-medium text-bodydark2">MENU</h3>
+        <div class="flex flex-col justify-between">
+          <ul class="mb-6 flex flex-col gap-1.5">
+            <.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"} />
+          </ul>
+        </div>
+      </nav>
+    </div>
+  </section>
+  <section>
+    <nav class="mt-5 px-4 py-4 lg:mt-9 lg:px-6">
+      <ul class="mb-6 flex flex-col gap-1.5">
+        <.sidebar_item
+          icon="hero-code-bracket"
+          text="Github"
+          target="_blank"
+          href="https://github.com/kieraneglin/pinchflat"
+        />
+        <li>
+          <span
+            class={[
+              "font-medium text-bodydark1",
+              "group relative flex items-center gap-2.5 rounded-sm px-4 py-2 duration-300 ease-in-out",
+              "duration-300 ease-in-out cursor-pointer",
+              "hover:bg-graydark dark:hover:bg-meta-4"
+            ]}
+            phx-click={show_modal("donate-modal")}
+          >
+            <.icon name="hero-currency-dollar" /> Donate
+          </span>
+        </li>
+      </ul>
+    </nav>
+  </section>
+</aside>

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

@@ -0,0 +1,40 @@
+defmodule Pinchflat.UpgradeButtonLive do
+  use PinchflatWeb, :live_view
+
+  def render(assigns) do
+    ~H"""
+    <form phx-change="check_matching_text">
+      <.input type="text" name="unlock-pro-textbox" value="" />
+    </form>
+
+    <.button
+      class="w-full mt-4"
+      type="button"
+      disabled={@button_disabled}
+      phx-click={hide_modal("upgrade-modal")}
+      x-on:click="setTimeout(() => { proEnabled = true }, 200)"
+    >
+      Unlock Pro
+    </.button>
+    """
+  end
+
+  def mount(_params, _session, socket) do
+    {:ok, assign(socket, :button_disabled, true)}
+  end
+
+  def handle_event("check_matching_text", %{"unlock-pro-textbox" => text}, socket) do
+    normalized_text =
+      text
+      |> String.trim()
+      |> String.downcase()
+
+    if normalized_text == "got it!" do
+      Settings.set!(:pro_enabled, true)
+
+      {:noreply, update(socket, :button_disabled, fn _ -> false end)}
+    else
+      {:noreply, update(socket, :button_disabled, fn _ -> true end)}
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+<.modal id="upgrade-modal" allow_close={false}>
+  <section>
+    <h3 class="text-2xl text-white">Pro Mode</h3>
+    <p class="text-sm">Don't worry - Pinchflat is completely free :&rpar;</p>
+    <p class="mt-4">
+      If you find the project valuable and want to support its development, a
+      <.inline_link href="https://www.paypal.me/kieraneglin">donation</.inline_link>
+      would be greatly appreciated.
+    </p>
+    <p class="mt-4">
+      Plus, $5 USD from any donation over $10 USD will be donated to
+      <.inline_link href="https://www.eff.org/">The Electronic Frontier Foundation</.inline_link>
+      who defend your online liberties and backed
+      <.inline_code>youtube-dl</.inline_code>
+      when Google took them down<.inline_link href="https://github.com/github/dmca/blob/9a85e0f021f7967af80e186b890776a50443f06c/2020/11/2020-11-16-RIAA-reversal-effletter.pdf">
+        <.icon name="hero-arrow-top-right-on-square" class="h-3 w-3" />
+      </.inline_link>. <strong>You do not need to donate to unlock Pro</strong>. It's just a way to say thanks!
+    </p>
+
+    <p class="mt-4">
+      To unlock Pro, simply type
+      <.inline_code>got it!</.inline_code>
+      into the text box and press the button.
+    </p>
+
+    <%= live_render(@conn, Pinchflat.UpgradeButtonLive) %>
+  </section>
+</.modal>

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

@@ -1,17 +1,26 @@
 <!DOCTYPE html>
-<html lang="en" class="[scrollbar-gutter:stable]">
+<html lang="en">
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta name="csrf-token" content={get_csrf_token()} />
-    <.live_title suffix=" · Phoenix Framework">
+    <.live_title>
       <%= assigns[:page_title] || "Pinchflat" %>
     </.live_title>
     <link phx-track-static rel="stylesheet" href={~p"/assets/app.css"} />
+    <link rel="icon" type="image/x-icon" href={~p"/favicon.ico?cachebust=2024-02-29"} />
     <script defer phx-track-static type="text/javascript" src={~p"/assets/app.js"}>
     </script>
   </head>
-  <body class="bg-white antialiased">
+  <body
+    x-data={"{ sidebarVisible: false, proEnabled: #{Settings.get!(:pro_enabled)} }"}
+    class="dark text-bodydark bg-boxdark-2"
+  >
     <%= @inner_content %>
+
+    <.donate_modal conn={@conn} />
+    <template x-if="!proEnabled">
+      <.upgrade_modal conn={@conn} />
+    </template>
   </body>
 </html>

lib/pinchflat_web/controllers/media_items/media_item_controller.ex

@@ -0,0 +1,32 @@
+defmodule PinchflatWeb.MediaItems.MediaItemController do
+  use PinchflatWeb, :controller
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Media
+
+  def show(conn, %{"id" => id}) do
+    media_item =
+      id
+      |> Media.get_media_item!()
+      |> Repo.preload([:source, tasks: [:job]])
+
+    render(conn, :show, media_item: media_item)
+  end
+
+  def delete(conn, %{"id" => id} = params) do
+    delete_files = Map.get(params, "delete_files", false)
+    media_item = Media.get_media_item!(id)
+    {: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, flash_message)
+    |> redirect(to: ~p"/sources/#{media_item.source_id}")
+  end
+end

lib/pinchflat_web/controllers/media_items/media_item_html.ex

@@ -0,0 +1,5 @@
+defmodule PinchflatWeb.MediaItems.MediaItemHTML do
+  use PinchflatWeb, :html
+
+  embed_templates "media_item_html/*"
+end

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

@@ -0,0 +1,58 @@
+<div class="mb-6 flex gap-3 flex-row items-center justify-between">
+  <div class="flex gap-3 items-center">
+    <.link href={~p"/sources/#{@media_item.source_id}"}>
+      <.icon name="hero-arrow-left" class="w-10 h-10 hover:dark:text-white" />
+    </.link>
+    <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4">
+      Media Item #<%= @media_item.id %>
+    </h2>
+  </div>
+</div>
+<div class="rounded-sm border border-stroke bg-white py-5 pt-6 shadow-default dark:border-strokedark dark:bg-boxdark sm:px-7.5">
+  <div class="max-w-full overflow-x-auto">
+    <.tabbed_layout>
+      <:tab title="Attributes">
+        <div class="flex flex-col gap-10 dark:text-white">
+          <h3 class="font-bold text-xl">Attributes</h3>
+          <section>
+            <strong>Source:</strong>
+            <.inline_link href={~p"/sources/#{@media_item.source_id}"}>
+              <%= @media_item.source.custom_name %>
+            </.inline_link>
+          </section>
+
+          <.list_items_from_map map={Map.from_struct(@media_item)} />
+        </div>
+
+        <section class="flex justify-center my-10">
+          <.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."
+          >
+            <.button color="bg-meta-1" rounding="rounded-full">
+              Delete Files
+            </.button>
+          </.link>
+        </section>
+      </:tab>
+      <:tab title="Tasks">
+        <%= if match?([_|_], @media_item.tasks) do %>
+          <.table rows={@media_item.tasks} table_class="text-black dark:text-white">
+            <:col :let={task} label="Worker">
+              <%= task.job.worker %>
+            </:col>
+            <:col :let={task} label="State">
+              <%= task.job.state %>
+            </:col>
+            <:col :let={task} label="Scheduled At">
+              <%= Calendar.strftime(task.job.scheduled_at, "%y-%m-%d %I:%M:%S %p %Z") %>
+            </:col>
+          </.table>
+        <% else %>
+          <p class="text-black dark:text-white">Nothing Here!</p>
+        <% end %>
+      </:tab>
+    </.tabbed_layout>
+  </div>
+</div>

lib/pinchflat_web/controllers/media_profiles/media_profile_controller.ex

@@ -0,0 +1,88 @@
+defmodule PinchflatWeb.MediaProfiles.MediaProfileController do
+  use PinchflatWeb, :controller
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Profiles
+  alias Pinchflat.Profiles.MediaProfile
+
+  def index(conn, _params) do
+    media_profiles = Profiles.list_media_profiles()
+    render(conn, :index, media_profiles: media_profiles)
+  end
+
+  def new(conn, _params) do
+    changeset = Profiles.change_media_profile(%MediaProfile{})
+
+    render(conn, :new, changeset: changeset, layout: get_onboarding_layout())
+  end
+
+  def create(conn, %{"media_profile" => media_profile_params}) do
+    case Profiles.create_media_profile(media_profile_params) do
+      {:ok, media_profile} ->
+        redirect_location =
+          if Settings.get!(:onboarding), do: ~p"/?onboarding=1", else: ~p"/media_profiles/#{media_profile}"
+
+        conn
+        |> put_flash(:info, "Media profile created successfully.")
+        |> redirect(to: redirect_location)
+
+      {:error, %Ecto.Changeset{} = changeset} ->
+        render(conn, :new, changeset: changeset, layout: get_onboarding_layout())
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    media_profile =
+      id
+      |> Profiles.get_media_profile!()
+      |> Repo.preload(:sources)
+
+    render(conn, :show, media_profile: media_profile)
+  end
+
+  def edit(conn, %{"id" => id}) do
+    media_profile = Profiles.get_media_profile!(id)
+    changeset = Profiles.change_media_profile(media_profile)
+
+    render(conn, :edit, media_profile: media_profile, changeset: changeset)
+  end
+
+  def update(conn, %{"id" => id, "media_profile" => media_profile_params}) do
+    media_profile = Profiles.get_media_profile!(id)
+
+    case Profiles.update_media_profile(media_profile, media_profile_params) do
+      {:ok, media_profile} ->
+        conn
+        |> put_flash(:info, "Media profile updated successfully.")
+        |> redirect(to: ~p"/media_profiles/#{media_profile}")
+
+      {:error, %Ecto.Changeset{} = changeset} ->
+        render(conn, :edit, media_profile: media_profile, changeset: changeset)
+    end
+  end
+
+  def delete(conn, %{"id" => id} = params) do
+    delete_files = Map.get(params, "delete_files", false)
+    media_profile = Profiles.get_media_profile!(id)
+    {:ok, _media_profile} = Profiles.delete_media_profile(media_profile, delete_files: delete_files)
+
+    flash_message =
+      if delete_files do
+        "Media profile, its sources, and its files deleted successfully."
+      else
+        "Media profile and its sources deleted successfully. Files were not deleted."
+      end
+
+    conn
+    |> put_flash(:info, flash_message)
+    |> redirect(to: ~p"/media_profiles")
+  end
+
+  defp get_onboarding_layout do
+    if Settings.get!(:onboarding) do
+      {Layouts, :onboarding}
+    else
+      {Layouts, :app}
+    end
+  end
+end

lib/pinchflat_web/controllers/media_profiles/media_profile_html.ex

@@ -0,0 +1,55 @@
+defmodule PinchflatWeb.MediaProfiles.MediaProfileHTML do
+  use PinchflatWeb, :html
+
+  embed_templates "media_profile_html/*"
+
+  @doc """
+  Renders a media_profile form.
+  """
+  attr :changeset, Ecto.Changeset, required: true
+  attr :action, :string, required: true
+
+  def media_profile_form(assigns)
+
+  def friendly_format_type_options do
+    [
+      {"Include (default)", :include},
+      {"Exclude", :exclude},
+      {"Only", :only}
+    ]
+  end
+
+  def friendly_resolution_options do
+    [
+      {"4k", "2160p"},
+      {"1080p", "1080p"},
+      {"720p", "720p"},
+      {"480p", "480p"},
+      {"360p", "360p"},
+      {"Audio Only", "audio"}
+    ]
+  end
+
+  def custom_output_template_options do
+    %{
+      upload_day: nil,
+      upload_month: nil,
+      upload_year: nil,
+      source_custom_name: "the name of the sources that use this profile",
+      source_collection_type: "the collection type of the sources that use this profile. Either 'channel' or 'playlist'"
+    }
+  end
+
+  def common_output_template_options do
+    ~w(
+      id
+      ext
+      title
+      fulltitle
+      uploader
+      channel
+      upload_date
+      duration_string
+    )a
+  end
+end

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

@@ -0,0 +1,14 @@
+<div class="mb-6 flex gap-3 flex-row items-center">
+  <.link href={~p"/media_profiles"}>
+    <.icon name="hero-arrow-left" class="w-10 h-10 hover:dark:text-white" />
+  </.link>
+  <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4">Edit Media Profile</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_profile_form changeset={@changeset} action={~p"/media_profiles/#{@media_profile}"} />
+    </div>
+  </div>
+</div>

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

@@ -0,0 +1,34 @@
+<div class="mb-6 flex gap-3 flex-row items-center justify-between">
+  <h2 class="text-title-md2 font-bold text-black dark:text-white">
+    Media Profiles
+  </h2>
+  <nav>
+    <.link href={~p"/media_profiles/new"}>
+      <.button color="bg-primary" rounding="rounded-full">
+        <span class="font-bold text-xl mx-2">+</span> New <span class="hidden sm:inline pl-1">Media Profile</span>
+      </.button>
+    </.link>
+  </nav>
+</div>
+
+<div class="rounded-sm border border-stroke bg-white shadow-default dark:border-strokedark dark:bg-boxdark">
+  <div class="max-w-full overflow-x-auto">
+    <div class="flex flex-col gap-10 min-w-max">
+      <.table rows={@media_profiles} table_class="text-black dark:text-white">
+        <:col :let={media_profile} label="Name">
+          <%= media_profile.name %>
+        </:col>
+        <:col :let={media_profile} label="Output Template">
+          <code class="text-sm"><%= media_profile.output_path_template %></code>
+        </:col>
+        <:col :let={media_profile} label="Preferred Resolution">
+          <%= media_profile.preferred_resolution %>
+        </:col>
+        <:col :let={media_profile} label="" class="flex place-content-evenly">
+          <.icon_link href={~p"/media_profiles/#{media_profile.id}"} icon="hero-eye" class="mx-1" />
+          <.icon_link href={~p"/media_profiles/#{media_profile.id}/edit"} icon="hero-pencil-square" class="mx-1" />
+        </:col>
+      </.table>
+    </div>
+  </div>
+</div>

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

@@ -0,0 +1,120 @@
+<.simple_form :let={f} for={@changeset} action={@action}>
+  <.error :if={@changeset.action}>
+    Oops, something went wrong! Please check the errors below.
+  </.error>
+
+  <h3 class="my-4 text-2xl text-black dark:text-white">
+    General Options
+  </h3>
+  <.input
+    field={f[:name]}
+    type="text"
+    label="Name"
+    placeholder="New Profile"
+    help="Something descriptive. Does not impact indexing or downloading (required)"
+  />
+
+  <.input
+    field={f[:output_path_template]}
+    type="text"
+    inputclass="font-mono"
+    label="Output path template"
+    help="Must end with .{{ ext }}. See below for more details. I promise the default is good for most cases (required)"
+  />
+
+  <h3 class="mt-8 text-2xl text-black dark:text-white">
+    Subtitle Options
+  </h3>
+  <.input
+    field={f[:download_subs]}
+    type="toggle"
+    label="Download Subtitles"
+    help="Downloads subtitle files alongside media file"
+  />
+  <.input
+    field={f[:download_auto_subs]}
+    type="toggle"
+    label="Download Autogenerated Subtitles"
+    help="Prefers normal subs but will download autogenerated if needed"
+  />
+  <.input
+    field={f[:embed_subs]}
+    type="toggle"
+    label="Embed Subtitles"
+    help="Embeds subtitles in the video file itself, if supported (recommended)"
+  />
+  <.input
+    field={f[:sub_langs]}
+    type="text"
+    label="Subtitle Languages"
+    help="Use commas for multiple languages (eg: en,de)"
+  />
+
+  <h3 class="mt-8 text-2xl text-black dark:text-white">
+    Thumbnail Options
+  </h3>
+  <.input
+    field={f[:download_thumbnail]}
+    type="toggle"
+    label="Download Thumbnail"
+    help="Downloads thumbnail alongside media file"
+  />
+  <.input
+    field={f[:embed_thumbnail]}
+    type="toggle"
+    label="Embed Thumbnail"
+    help="Embeds thumbnail in the video file itself, if supported (recommended)"
+  />
+
+  <h3 class="mt-8 text-2xl text-black dark:text-white">
+    Metadata Options
+  </h3>
+  <.input
+    field={f[:download_metadata]}
+    type="toggle"
+    label="Download Metadata"
+    help="Downloads metadata file alongside media file"
+  />
+  <.input
+    field={f[:embed_metadata]}
+    type="toggle"
+    label="Embed Metadata"
+    help="Embeds metadata in the video file itself, if supported (recommended)"
+  />
+
+  <h3 class="mt-8 text-2xl text-black dark:text-white">
+    Release Format Options
+  </h3>
+
+  <.input
+    field={f[:shorts_behaviour]}
+    options={friendly_format_type_options()}
+    type="select"
+    label="Include Shorts?"
+    help="Experimental. Please report any issues on GitHub"
+  />
+  <.input
+    field={f[:livestream_behaviour]}
+    options={friendly_format_type_options()}
+    type="select"
+    label="Include Livestreams?"
+  />
+
+  <h3 class="mt-8 text-2xl text-black dark:text-white">
+    Quality Options
+  </h3>
+
+  <.input
+    field={f[:preferred_resolution]}
+    options={friendly_resolution_options()}
+    type="select"
+    label="Preferred Resolution"
+    help="Will grab the closest available resolution if your preferred is not available. Setting to 'Audio Only' negates embedding options."
+  />
+
+  <.button class="my-10 sm:mb-7.5 w-full sm:w-auto">Save Media profile</.button>
+
+  <div class="rounded-sm dark:bg-meta-4 p-4 md:p-6 mb-5">
+    <.output_template_help />
+  </div>
+</.simple_form>

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

@@ -0,0 +1,14 @@
+<div class="mb-6 flex gap-3 flex-row items-center">
+  <.link :if={!Settings.get!(:onboarding)} href={~p"/media_profiles"}>
+    <.icon name="hero-arrow-left" class="w-10 h-10 hover:dark:text-white" />
+  </.link>
+  <h2 class="text-title-md2 font-bold text-black dark:text-white ml-4">New Media Profile</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_profile_form changeset={@changeset} action={~p"/media_profiles"} />
+    </div>
+  </div>
+</div>

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

@@ -0,0 +1,73 @@
+<%!-- The heex HTML formatter is really struggling with this file - I apologize in advance --%>
+<aside>
+  <h2 class="text-xl font-bold mb-2">Output Template Syntax</h2>
+  <section class="ml-2 md:ml-4 mb-4 max-w-prose">
+    <p>When generating an output template, you have 3 options for syntax:</p>
+    <ul class="list-disc list-inside ml-2 md:ml-5">
+      <li>
+        Liquid-style:
+        <.inline_code>/{{ channel }}/{{ title }} - {{ id }}.{{ ext }}</.inline_code>
+      </li>
+      <li>
+        <code class="text-sm">yt-dlp</code>-style
+        <.inline_link href="https://github.com/yt-dlp/yt-dlp?tab=readme-ov-file#output-template">
+          <.icon name="hero-arrow-top-right-on-square" class="h-4 w-4" />
+        </.inline_link>:
+        <.inline_code>/%(channel)s/%(duration>%H-%M-%S)s-%(id)s.%(ext)s</.inline_code>
+      </li>
+      <li>
+        Any bare words:
+        <.inline_code>/videos/1080p/{{ id }}.{{ ext }}</.inline_code>
+      </li>
+    </ul>
+    <p class="my-2">
+      Apart from custom aliases, the liquid-style syntax maps 1:1 to the <code class="text-sm">yt-dlp</code>-style syntax behind-the-scenes. This means that
+      <em>any</em>
+      single-word <code class="text-sm">yt-dlp</code>
+      option can be used as liquid-style and it's automatically made filepath-safe. For example, the
+      <.inline_code>{{ duration }}</.inline_code>
+      option is translated to
+      <.inline_code>%(duration)S</.inline_code>
+    </p>
+    <p class="my-2">
+      <strong>Major 🔑:</strong>
+      these syntaxes can be mixed and matched freely! I prefer to use liquid-style and bare words
+      but I'll include <code class="text-sm">yt-dlp</code>-style when I need more control. For example:
+      <.inline_code>/1080p/{{ channel }}/{{ title }}-(%(subtitles.en.-1.ext)s).{{ ext }}</.inline_code>
+    </p>
+    <p class="my-2">
+      <strong>NOTE:</strong>
+      Your template <em>must</em>
+      end with an extension option (<.inline_code>.{{ ext }}</.inline_code>
+      or
+      <.inline_code>.%(ext)S</.inline_code>).
+      Downloading won't work as expected without it.
+    </p>
+  </section>
+
+  <h2 class="text-xl font-bold mb-2">Template Options</h2>
+  <section class="ml-2 md:ml-4 mb-4">
+    <p class="max-w-prose">
+      Any single-word <code class="text-sm">yt-dlp</code>
+      option
+      <.inline_link href="https://github.com/yt-dlp/yt-dlp?tab=readme-ov-file#output-template">
+        <.icon name="hero-arrow-top-right-on-square" class="h-4 w-4" />
+      </.inline_link>
+      can be used with the curly braced liquid-style syntax.
+      This is just a list of the most common options as well as some custom aliases
+    </p>
+    <h3 class="text-lg font-bold mb-2">Custom Aliases</h3>
+    <ul class="list-disc list-inside ml-2 md:ml-5">
+      <li :for={{k, v} <- custom_output_template_options()}>
+        <.inline_code>{{ <%= k %> }}</.inline_code>
+        <span :if={v}>- <%= v %></span>
+      </li>
+    </ul>
+    <h3 class="text-lg font-bold mb-2">Common Options</h3>
+    <ul class="list-disc list-inside ml-2 md:ml-5">
+      <li :for={opt <- common_output_template_options()}>
+        <.inline_code>{{ <%= opt %> }}</.inline_code>
+      </li>
+    </ul>
+  </section>
+</aside>

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

@@ -0,0 +1,67 @@
+<div class="mb-6 flex gap-3 flex-row items-center justify-between">
+  <div class="flex items-center">
+    <.link href={~p"/media_profiles"}>
+      <.icon name="hero-arrow-left" class="w-10 h-10 hover:dark:text-white" />
+    </.link>
+    <h2 class="text-title-md2 font-bold text-black dark:text-white ml-2">
+      Media Profile <span class="hidden sm:inline">#<%= @media_profile.id %></span>
+    </h2>
+  </div>
+
+  <nav>
+    <.link href={~p"/media_profiles/#{@media_profile}/edit"}>
+      <.button color="bg-primary" rounding="rounded-full">
+        <.icon name="hero-pencil-square" class="mr-2" />Edit <span class="hidden sm:inline pl-1">Media Profile</span>
+      </.button>
+    </.link>
+  </nav>
+</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">
+    <.tabbed_layout>
+      <:tab title="Attributes">
+        <div class="flex flex-col gap-10 text-white">
+          <h3 class="font-bold text-xl">Attributes for "<%= @media_profile.name %>"</h3>
+          <.list_items_from_map map={Map.from_struct(@media_profile)} />
+        </div>
+
+        <section class="flex flex-col md:flex-row items-center md:justify-around my-10">
+          <.link
+            href={~p"/media_profiles/#{@media_profile}"}
+            method="delete"
+            data-confirm="Are you sure you want to delete this profile and all its sources (leaving files in place)? This cannot be undone."
+          >
+            <.button color="bg-meta-1" rounding="rounded-full">
+              Delete Profile and its Sources
+            </.button>
+          </.link>
+          <.link
+            href={~p"/media_profiles/#{@media_profile}?delete_files=true"}
+            method="delete"
+            data-confirm="Are you sure you want to delete this profile, all its sources, and its files on disk? This cannot be undone."
+            class="mt-5 md:mt-0"
+          >
+            <.button color="bg-meta-1" rounding="rounded-full">
+              Delete Profile, Sources, and Files
+            </.button>
+          </.link>
+        </section>
+      </:tab>
+      <:tab title="Sources">
+        <.table rows={@media_profile.sources} table_class="text-black dark:text-white">
+          <:col :let={source} label="Name">
+            <%= source.custom_name || source.collection_name %>
+          </:col>
+          <:col :let={source} label="Type"><%= source.collection_type %></:col>
+          <:col :let={source} label="Should Download?">
+            <.icon name={if source.download_media, do: "hero-check", else: "hero-x-mark"} />
+          </:col>
+          <:col :let={source} label="" class="flex place-content-evenly">
+            <.icon_link href={~p"/sources/#{source.id}"} icon="hero-eye" class="mx-1" />
+            <.icon_link href={~p"/sources/#{source.id}/edit"} icon="hero-pencil-square" class="mx-1" />
+          </:col>
+        </.table>
+      </:tab>
+    </.tabbed_layout>
+  </div>
+</div>