201 changed files with 21715 additions and 14535 deletions
--- a/.drone.yml
+++ b/.drone.yml
@ -17,7 +17,7 @@ steps:
      - .mix

 - name: test
-  image: elixir:1.17.3-otp-27-alpine
+  image: elixir:1.14.1-alpine
  environment:
    TEST_DATABASE_URL: ecto://postgres:postgres@database/cannery_test
    HOST: testing.example.tld
@ -26,8 +26,8 @@ steps:
    MIX_ENV: test
  commands:
  - apk add --no-cache build-base npm git
-  - mix local.rebar --force
-  - mix local.hex --force
+  - mix local.rebar --force --if-missing
+  - mix local.hex --force --if-missing
  - mix deps.get
  - npm set cache .npm
  - npm --prefix ./assets ci --no-audit --prefer-offline
@ -36,16 +36,13 @@ steps:
  - mix test.all

 - name: build and publish stable
-  image: plugins/docker
+  image: thegeeklab/drone-docker-buildx
  privileged: true
  settings:
    repo: shibaobun/cannery
    purge: true
    compress: true
-    platforms:
-      - linux/amd64
-      - linux/arm64
-      - linux/arm/v7
+    platforms: linux/amd64,linux/arm/v7
    username:
      from_secret: docker_username
    password:
@ -56,16 +53,13 @@ steps:
    - stable

 - name: build and publish tagged version
-  image: plugins/docker
+  image: thegeeklab/drone-docker-buildx
  privileged: true
  settings:
    repo: shibaobun/cannery
    purge: true
    compress: true
-    platforms:
-      - linux/amd64
-      - linux/arm64
-      - linux/arm/v7
+    platforms: linux/amd64,linux/arm/v7
    username:
      from_secret: docker_username
    password:
--- a/.formatter.exs
+++ b/.formatter.exs
@ -1,6 +1,6 @@
 [
-  import_deps: [:ecto, :ecto_sql, :phoenix],
-  inputs: ["*.{heex,ex,exs}", "{config,lib,test}/**/*.{heex,ex,exs}", "priv/*/seeds.exs"],
+  import_deps: [:ecto, :phoenix],
+  inputs: ["*.{heex,ex,exs}", "priv/*/seeds.exs", "{config,lib,test}/**/*.{heex,ex,exs}"],
  subdirectories: ["priv/*/migrations"],
  plugins: [Phoenix.LiveView.HTMLFormatter]
 ]
--- a/.tool-versions
+++ b/.tool-versions
@ -1,3 +1,3 @@
-elixir 1.17.3-otp-27
-erlang 27.1.2
-nodejs 23.0.0
+elixir 1.14.1-otp-25
+erlang 25.1.2
+nodejs 18.9.1
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,60 +1,3 @@
-# v0.9.12
- Allow filtering ammo types when creating new packs
- Add SlimSelect to select elements with user content
- Fix registration page not offering all translations
- Update deps
-
-# v0.9.11
- Fix an issue with emails not being able to be sent for real this time
- Fix some dropdowns not filling in the correct data
- Add debounces to more fields
- Update deps
-
-# v0.9.10
- Fix issue with logger failing on oban exceptions
- Fix an issue with emails not being able to be sent
- Update deps
-
-# v0.9.9
- Actually fix bar graph
-
-# v0.9.8
- Make bar graph ignore empty days
- Update dependencies
-
-# v0.9.7
- Fix margin on bottom of page
- Use bar graph instead of line graph
- Improve login page autocomplete behavior
-
-# v0.9.6
- Make ammo packs in containers directly navigable in table view
- Update dependencies
-
-# v0.9.5
- Update dependencies
-
-# v0.9.4
- Code quality fixes
- Fix error/404 pages not rendering properly
- Update dependencies
- Fix Range page title
-
-# v0.9.3
- Update dependencies
- Add pack lot number to search
- Improve tests
- Change invite path slightly
- Disable arm builds since ci fails to build
-
-# v0.9.2
- Add lot number to packs
- Don't show price paid and lot number columns when displaying packs if not used
- Fix additional shotgun fields not being exportable
- Fixes duplicate chamber size column for ammo types
- Hide bullet type field when editing/creating shotgun ammo types
- Fix ammo type creation not displaying all the necessary fields on first load
-
 # v0.9.1
 - Rename ammo type's "type" to "class" to avoid confusion
 - Rename "ammo type" to "type" to avoid confusion
--- a/8
+++ b/8
@ -1,4 +1,4 @@
-FROM elixir:1.17.3-otp-27-alpine AS build
+FROM elixir:1.14.1-alpine AS build

 # install build dependencies
 RUN apk add --no-cache build-base npm git python3
@ -7,8 +7,8 @@ RUN apk add --no-cache build-base npm git python3
 WORKDIR /app

 # install hex + rebar
-RUN mix local.rebar --force && \
-    mix local.hex --force
+RUN mix local.hex --force && \
+    mix local.rebar --force

 # set build ENV
 ENV MIX_ENV=prod
@ -37,7 +37,7 @@ RUN mix do compile, release
 FROM alpine:latest AS app

 RUN apk upgrade --no-cache && \
-    apk add --no-cache bash openssl libssl3 libcrypto3 libgcc libstdc++ ncurses-libs
+    apk add --no-cache bash openssl libssl1.1 libcrypto1.1 libgcc libstdc++ ncurses-libs

 WORKDIR /app

--- a/README.md
+++ b/README.md
@ -94,7 +94,6 @@ license can be found at

 # Links

- [Website](https://cannery.app): Project website
 - [Gitea](https://gitea.bubbletea.dev/shibao/cannery): Main repo, feature
  requests and bug reports
 - [Github](https://github.com/shibaobun/cannery): Source code mirror, please
--- a/assets/css/app.scss
+++ b/assets/css/app.scss
@ -8,8 +8,6 @@ $fa-font-path: "@fortawesome/fontawesome-free/webfonts";
@import "@fortawesome/fontawesome-free/scss/solid";
@import "@fortawesome/fontawesome-free/scss/brands";

-@import "slim-select/styles";
-
@import "components";

 /* fix firefox scrollbars */
@ -154,57 +152,3 @@ $fa-font-path: "@fortawesome/fontawesome-free/webfonts";
  0% { opacity: 1; }
  100% { opacity: 0; }
 }
-
-.ss-main {
-  @apply input;
-}
-
-.ss-main.input-primary {
-  @apply border-primary-500 hover:border-primary-600 active:border-primary-600;
-}
-
-.ss-content {
-  @apply input;
-}
-
-.ss-content.input-primary {
-  @apply border-primary-500 hover:border-primary-600 active:border-primary-600;
-}
-
-.ss-content.ss-open-above {
-  border-bottom-left-radius: 0px;
-  border-bottom-right-radius: 0px;
-}
-
-.ss-content.ss-open-below {
-  border-top-left-radius: 0px;
-  border-top-right-radius: 0px;
-}
-
-.ss-search input[type="search"] {
-  @apply input;
-}
-
-.ss-content.input-primary .ss-search input[type="search"] {
-  @apply border-primary-500 hover:border-primary-600 active:border-primary-600;
-}
-
-.ss-content.ss-open-above .ss-search {
-  padding: var(--ss-spacing-l) 0 0 0;
-}
-
-.ss-content.ss-open-below .ss-search {
-  padding: 0 0 var(--ss-spacing-l) 0;
-}
-
-.ss-content.ss-open-above .ss-list > *:not(:first-child) {
-  margin: var(--ss-spacing-l) 0 0 0;
-}
-
-.ss-content.ss-open-below .ss-list > *:not(:last-child) {
-  margin: 0 0 var(--ss-spacing-l) 0;
-}
-
-.ss-content .ss-list .ss-option {
-  border-radius: var(--ss-border-radius);
-}
--- a/assets/js/app.js
+++ b/assets/js/app.js
@ -24,16 +24,16 @@ import 'phoenix_html'
 // Establish Phoenix Socket and LiveView configuration.
 import { Socket } from 'phoenix'
 import { LiveSocket } from 'phoenix_live_view'
+import topbar from 'topbar'
+import MaintainAttrs from './maintain_attrs'
+import ShotLogChart from './shot_log_chart'
 import Date from './date'
 import DateTime from './datetime'
-import ShotLogChart from './shot_log_chart'
-import SlimSelect from './slim_select'
-import topbar from 'topbar'

 const csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute('content')
 const liveSocket = new LiveSocket('/live', Socket, {
  params: { _csrf_token: csrfToken },
-  hooks: { Date, DateTime, ShotLogChart, SlimSelect }
+  hooks: { Date, DateTime, MaintainAttrs, ShotLogChart }
 })

 // Show progress bar on live navigation and form submits
--- a/assets/js/maintain_attrs.js
+++ b/assets/js/maintain_attrs.js
@ -0,0 +1,11 @@
+// maintain user adjusted attributes, like textbox length on phoenix liveview
+// update. https://github.com/phoenixframework/phoenix_live_view/issues/1011
+
+export default {
+  attrs () {
+    const attrs = this.el.getAttribute('data-attrs')
+    if (attrs) { return attrs.split(', ') } else { return [] }
+  },
+  beforeUpdate () { this.prevAttrs = this.attrs().map(name => [name, this.el.getAttribute(name)]) },
+  updated () { this.prevAttrs.forEach(([name, val]) => this.el.setAttribute(name, val)) }
+}
--- a/assets/js/shot_log_chart.js
+++ b/assets/js/shot_log_chart.js
@ -1,12 +1,13 @@
-import Chart from 'chart.js/auto'
+import { Chart, Title, Tooltip, Legend, LineController, LineElement, PointElement, TimeScale, LinearScale } from 'chart.js'
 import 'chartjs-adapter-date-fns'
+Chart.register(Title, Tooltip, Legend, LineController, LineElement, PointElement, TimeScale, LinearScale)

 export default {
  initalizeChart (el) {
    const data = JSON.parse(el.dataset.chartData)

    this.el.chart = new Chart(el, {
-      type: 'bar',
+      type: 'line',
      data: {
        datasets: [{
          label: el.dataset.label,
@ -50,17 +51,13 @@ export default {
            stacked: true,
            grace: '15%',
            ticks: {
-              padding: 15,
-              precision: 0
+              padding: 15
            }
          },
          x: {
-            type: 'timeseries',
+            type: 'time',
            time: {
              unit: 'day'
-            },
-            ticks: {
-              source: 'data'
            }
          }
        },
--- a/assets/js/slim_select.js
+++ b/assets/js/slim_select.js
@ -1,23 +0,0 @@
-import SlimSelect from 'slim-select'
-
-export default {
-  initalizeSlimSelect (el) {
-    // eslint-disable-next-line no-new
-    el.slimselect = new SlimSelect({ select: el })
-
-    const main = document.querySelector(`.ss-main[data-id="${el.dataset.id}"]`)
-    main.setAttribute('id', `${el.dataset.id}-main`)
-    main.setAttribute('phx-update', 'ignore')
-
-    const content = document.querySelector(`.ss-content[data-id="${el.dataset.id}"]`)
-    content.setAttribute('id', `${el.dataset.id}-content`)
-    content.setAttribute('phx-update', 'ignore')
-  },
-  updated () {
-    this.el.slimselect?.destroy()
-    this.initalizeSlimSelect(this.el)
-  },
-  mounted () {
-    this.initalizeSlimSelect(this.el)
-  }
-}
--- a/assets/package-lock.json
+++ b/assets/package-lock.json
--- a/assets/package.json
+++ b/assets/package.json
@ -3,8 +3,8 @@
  "description": " ",
  "license": "MIT",
  "engines": {
-    "node": "v23.0.0",
-    "npm": "10.9.0"
+    "node": "v18.9.1",
+    "npm": "8.19.1"
  },
  "scripts": {
    "deploy": "NODE_ENV=production webpack --mode production",
@ -13,39 +13,37 @@
    "test": "standard"
  },
  "dependencies": {
-    "@fortawesome/fontawesome-free": "^6.6.0",
-    "chart.js": "^4.4.5",
+    "@fortawesome/fontawesome-free": "^6.3.0",
+    "chart.js": "^4.2.1",
    "chartjs-adapter-date-fns": "^3.0.0",
-    "date-fns": "^4.1.0",
+    "date-fns": "^2.29.3",
    "phoenix": "file:../deps/phoenix",
    "phoenix_html": "file:../deps/phoenix_html",
    "phoenix_live_view": "file:../deps/phoenix_live_view",
-    "slim-select": "^2.9.2",
-    "topbar": "^3.0.0"
+    "topbar": "^2.0.1"
  },
  "devDependencies": {
-    "@babel/core": "^7.26.0",
-    "@babel/preset-env": "^7.26.0",
-    "autoprefixer": "^10.4.20",
-    "babel-loader": "^9.2.1",
-    "copy-webpack-plugin": "^12.0.2",
-    "css-loader": "^7.1.2",
-    "css-minimizer-webpack-plugin": "^7.0.0",
+    "@babel/core": "^7.21.3",
+    "@babel/preset-env": "^7.20.2",
+    "autoprefixer": "^10.4.14",
+    "babel-loader": "^9.1.2",
+    "copy-webpack-plugin": "^11.0.0",
+    "css-loader": "^6.7.3",
+    "css-minimizer-webpack-plugin": "^4.2.2",
    "file-loader": "^6.2.0",
-    "glob": "^11.0.0",
-    "mini-css-extract-plugin": "^2.9.1",
-    "npm-check-updates": "^17.1.6",
-    "postcss": "^8.4.47",
-    "postcss-import": "^16.1.0",
-    "postcss-loader": "^8.1.1",
-    "postcss-preset-env": "^10.0.8",
-    "sass": "^1.80.4",
-    "sass-loader": "^16.0.2",
-    "standard": "^17.1.2",
-    "tailwindcss": "^3.4.14",
-    "terser-webpack-plugin": "^5.3.10",
-    "webpack": "^5.95.0",
-    "webpack-cli": "^5.1.4",
-    "webpack-dev-server": "^5.1.0"
+    "mini-css-extract-plugin": "^2.7.5",
+    "npm-check-updates": "^16.7.12",
+    "postcss": "^8.4.21",
+    "postcss-import": "^15.1.0",
+    "postcss-loader": "^7.1.0",
+    "postcss-preset-env": "^8.0.1",
+    "sass": "^1.59.3",
+    "sass-loader": "^13.2.1",
+    "standard": "^17.0.0",
+    "tailwindcss": "^3.2.7",
+    "terser-webpack-plugin": "^5.3.7",
+    "webpack": "^5.76.2",
+    "webpack-cli": "^5.0.1",
+    "webpack-dev-server": "^4.13.1"
  }
 }
--- a/config/config.exs
+++ b/config/config.exs
@ -18,10 +18,7 @@ config :cannery, CanneryWeb.Endpoint,
  url: [scheme: "https", host: System.get_env("HOST") || "localhost", port: "443"],
  http: [port: String.to_integer(System.get_env("PORT") || "4000")],
  secret_key_base: "KH59P0iZixX5gP/u+zkxxG8vAAj6vgt0YqnwEB5JP5K+E567SsqkCz69uWShjE7I",
-  render_errors: [
-    formats: [html: CanneryWeb.ErrorHTML, json: CanneryWeb.ErrorJSON],
-    layout: false
-  ],
+  render_errors: [view: CanneryWeb.ErrorView, accepts: ~w(html json), layout: false],
  pubsub_server: Cannery.PubSub,
  live_view: [signing_salt: "zOLgd3lr"]

--- a/config/dev.exs
+++ b/config/dev.exs
@ -59,7 +59,8 @@ config :cannery, CanneryWeb.Endpoint,
    patterns: [
      ~r"priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$",
      ~r"priv/gettext/.*(po)$",
-      ~r"lib/cannery_web/*/.*(ex)$"
+      ~r"lib/cannery_web/(live|views)/.*(ex)$",
+      ~r"lib/cannery_web/templates/.*(eex)$"
    ]
  ]

--- a/config/runtime.exs
+++ b/config/runtime.exs
@ -12,7 +12,7 @@ if System.get_env("PHX_SERVER") && System.get_env("RELEASE_NAME") do
  config :cannery, CanneryWeb.Endpoint, server: true
 end

-config :cannery, CanneryWeb.HTMLHelpers, shibao_mode: System.get_env("SHIBAO_MODE") == "true"
+config :cannery, CanneryWeb.ViewHelpers, shibao_mode: System.get_env("SHIBAO_MODE") == "true"

 # Set default locale
 config :gettext, :default_locale, System.get_env("LOCALE", "en_US")
--- a/config/test.exs
+++ b/config/test.exs
@ -9,9 +9,8 @@ config :bcrypt_elixir, :log_rounds, 1
 # to provide built-in test partitioning in CI environment.
 # Run `mix help test` for more information.
 config :cannery, Cannery.Repo,
-  pool_size: 10,
  pool: Ecto.Adapters.SQL.Sandbox,
-  timeout: 60000
+  pool_size: 10

 # We don't run a server during test. If one is required,
 # you can enable the server option below.
@ -27,10 +26,10 @@ config :cannery, Cannery.Mailer, adapter: Swoosh.Adapters.Test
 config :cannery, Cannery.Accounts, registration: "public"

 # Print only warnings and errors during test
-config :logger, level: :warning
+config :logger, level: :warn

 # Initialize plugs at runtime for faster test compilation
 config :phoenix, :plug_init_mode, :runtime

 # Disable Oban
-config :cannery, Oban, queues: false, plugins: false, testing: :manual
+config :cannery, Oban, queues: false, plugins: false
--- a/lib/cannery.ex
+++ b/lib/cannery.ex
@ -6,34 +6,4 @@ defmodule Cannery do
  Contexts are also responsible for managing your data, regardless
  if it comes from the database, an external API or others.
  """
-
-  def context do
-    quote do
-      use Gettext, backend: CanneryWeb.Gettext
-      import Ecto.Query
-      alias Cannery.Accounts.User
-      alias Cannery.Repo
-      alias Ecto.{Changeset, Multi, Queryable, UUID}
-    end
-  end
-
-  def schema do
-    quote do
-      use Ecto.Schema
-      use Gettext, backend: CanneryWeb.Gettext
-      import Ecto.{Changeset, Query}
-      alias Cannery.Accounts.User
-      alias Ecto.{Association, Changeset, Queryable, UUID}
-
-      @primary_key {:id, :binary_id, autogenerate: true}
-      @foreign_key_type :binary_id
-    end
-  end
-
-  @doc """
-  When used, dispatch to the appropriate context/schema/etc.
-  """
-  defmacro __using__(which) when is_atom(which) do
-    apply(__MODULE__, which, [])
-  end
 end
--- a/lib/cannery/accounts.ex
+++ b/lib/cannery/accounts.ex
@ -3,9 +3,10 @@ defmodule Cannery.Accounts do
  The Accounts context.
  """

-  use Cannery, :context
-  alias Cannery.Mailer
-  alias Cannery.Accounts.{Invite, Invites, UserToken}
+  import Ecto.Query, warn: false
+  alias Cannery.{Mailer, Repo}
+  alias Cannery.Accounts.{Invite, Invites, User, UserToken}
+  alias Ecto.{Changeset, Multi}
  alias Oban.Job

  ## Database getters
@ -373,8 +374,8 @@ defmodule Cannery.Accounts do
  @doc """
  Deletes the signed token with the given context.
  """
-  @spec delete_user_session_token(token :: String.t()) :: :ok
-  def delete_user_session_token(token) do
+  @spec delete_session_token(token :: String.t()) :: :ok
+  def delete_session_token(token) do
    UserToken.token_and_context_query(token, "session") |> Repo.delete_all()
    :ok
  end
@ -403,15 +404,15 @@ defmodule Cannery.Accounts do

  ## Examples

-      iex> admin?(%User{role: :admin})
+      iex> is_admin?(%User{role: :admin})
      true

-      iex> admin?(%User{})
+      iex> is_admin?(%User{})
      false

  """
-  @spec admin?(User.t()) :: boolean()
-  def admin?(%User{id: user_id}) do
+  @spec is_admin?(User.t()) :: boolean()
+  def is_admin?(%User{id: user_id}) do
    Repo.exists?(from u in User, where: u.id == ^user_id, where: u.role == :admin)
  end

@ -420,16 +421,16 @@ defmodule Cannery.Accounts do

  ## Examples

-      iex> already_admin?(%User{role: :admin})
+      iex> is_already_admin?(%User{role: :admin})
      true

-      iex> already_admin?(%User{})
+      iex> is_already_admin?(%User{})
      false

  """
-  @spec already_admin?(User.t() | nil) :: boolean()
-  def already_admin?(%User{role: :admin}), do: true
-  def already_admin?(_invalid_user), do: false
+  @spec is_already_admin?(User.t() | nil) :: boolean()
+  def is_already_admin?(%User{role: :admin}), do: true
+  def is_already_admin?(_invalid_user), do: false

  ## Confirmation

--- a/lib/cannery/accounts/email.ex
+++ b/lib/cannery/accounts/email.ex
@ -3,15 +3,14 @@ defmodule Cannery.Email do
  Emails that can be sent using Swoosh.

  You can find the base email templates at
-  `lib/cannery_web/components/layouts/email_html.html.heex` for html emails and
-  `lib/cannery_web/components/layouts/email_text.txt.eex` for text emails.
+  `lib/cannery_web/templates/layout/email.html.heex` for html emails and
+  `lib/cannery_web/templates/layout/email.txt.heex` for text emails.
  """

-  use Gettext, backend: CanneryWeb.Gettext
-  import Swoosh.Email
-  import Phoenix.Template
+  use Phoenix.Swoosh, view: CanneryWeb.EmailView, layout: {CanneryWeb.LayoutView, :email}
+  import CanneryWeb.Gettext
  alias Cannery.Accounts.User
-  alias CanneryWeb.{EmailHTML, Layouts}
+  alias CanneryWeb.EmailView

  @typedoc """
  Represents an HTML and text body email that can be sent
@ -29,33 +28,21 @@ defmodule Cannery.Email do
  def generate_email("welcome", user, %{"url" => url}) do
    user
    |> base_email(dgettext("emails", "Confirm your Cannery account"))
-    |> html_email(:confirm_email_html, %{user: user, url: url})
-    |> text_email(:confirm_email_text, %{user: user, url: url})
+    |> render_body("confirm_email.html", %{user: user, url: url})
+    |> text_body(EmailView.render("confirm_email.txt", %{user: user, url: url}))
  end

  def generate_email("reset_password", user, %{"url" => url}) do
    user
    |> base_email(dgettext("emails", "Reset your Cannery password"))
-    |> html_email(:reset_password_html, %{user: user, url: url})
-    |> text_email(:reset_password_text, %{user: user, url: url})
+    |> render_body("reset_password.html", %{user: user, url: url})
+    |> text_body(EmailView.render("reset_password.txt", %{user: user, url: url}))
  end

  def generate_email("update_email", user, %{"url" => url}) do
    user
    |> base_email(dgettext("emails", "Update your Cannery email"))
-    |> html_email(:update_email_html, %{user: user, url: url})
-    |> text_email(:update_email_text, %{user: user, url: url})
-  end
-
-  defp html_email(email, atom, assigns) do
-    heex = apply(EmailHTML, atom, [assigns])
-    html = render_to_string(Layouts, "email_html", "html", email: email, inner_content: heex)
-    email |> html_body(html)
-  end
-
-  defp text_email(email, atom, assigns) do
-    heex = apply(EmailHTML, atom, [assigns])
-    text = render_to_string(Layouts, "email_text", "text", email: email, inner_content: heex)
-    email |> text_body(text)
+    |> render_body("update_email.html", %{user: user, url: url})
+    |> text_body(EmailView.render("update_email.txt", %{user: user, url: url}))
  end
 end
--- a/lib/cannery/accounts/email_worker.ex
+++ b/lib/cannery/accounts/email_worker.ex
--- a/lib/cannery/accounts/invite.ex
+++ b/lib/cannery/accounts/invite.ex
@ -5,8 +5,13 @@ defmodule Cannery.Accounts.Invite do
  `:uses_left` is defined.
  """

-  use Cannery, :schema
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Cannery.Accounts.User
+  alias Ecto.{Association, Changeset, UUID}

+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
  schema "invites" do
    field :name, :string
    field :token, :string
--- a/lib/cannery/accounts/invites.ex
+++ b/lib/cannery/accounts/invites.ex
@ -3,8 +3,10 @@ defmodule Cannery.Accounts.Invites do
  The Invites context.
  """

-  use Cannery, :context
-  alias Cannery.Accounts.Invite
+  import Ecto.Query, warn: false
+  alias Ecto.Multi
+  alias Cannery.Accounts.{Invite, User}
+  alias Cannery.Repo

  @invite_token_length 20

--- a/lib/cannery/accounts/user.ex
+++ b/lib/cannery/accounts/user.ex
@ -3,8 +3,11 @@ defmodule Cannery.Accounts.User do
  A Cannery user
  """

-  use Cannery, :schema
-  alias Cannery.Accounts.Invite
+  use Ecto.Schema
+  import Ecto.Changeset
+  import CanneryWeb.Gettext
+  alias Ecto.{Association, Changeset, UUID}
+  alias Cannery.Accounts.{Invite, User}

  @derive {Jason.Encoder,
           only: [
@ -17,6 +20,8 @@ defmodule Cannery.Accounts.User do
             :updated_at
           ]}
  @derive {Inspect, except: [:password]}
+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
  schema "users" do
    field :email, :string
    field :password, :string, virtual: true
--- a/lib/cannery/accounts/user_token.ex
+++ b/lib/cannery/accounts/user_token.ex
@ -3,7 +3,10 @@ defmodule Cannery.Accounts.UserToken do
  Schema for a user's session token
  """

-  use Cannery, :schema
+  use Ecto.Schema
+  import Ecto.Query
+  alias Cannery.Accounts.User
+  alias Ecto.{Association, UUID}

  @hash_algorithm :sha256
  @rand_size 32
@ -15,6 +18,8 @@ defmodule Cannery.Accounts.UserToken do
  @change_email_validity_in_days 7
  @session_validity_in_days 60

+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
  schema "users_tokens" do
    field :token, :binary
    field :context, :string
--- a/lib/cannery/activity_log.ex
+++ b/lib/cannery/activity_log.ex
@ -3,52 +3,43 @@ defmodule Cannery.ActivityLog do
  The ActivityLog context.
  """

-  use Cannery, :context
-  alias Cannery.{ActivityLog.ShotRecord, Ammo.Pack, Ammo.Type}
-
-  @type list_shot_records_option ::
-          {:search, String.t() | nil}
-          | {:class, Type.class() | :all | nil}
-          | {:pack_id, Pack.id() | nil}
-  @type list_shot_records_options :: [list_shot_records_option()]
+  import Ecto.Query, warn: false
+  alias Cannery.Ammo.{Pack, Type}
+  alias Cannery.{Accounts.User, ActivityLog.ShotRecord, Repo}
+  alias Ecto.{Multi, Queryable}

  @doc """
  Returns the list of shot_records.

  ## Examples

-      iex> list_shot_records(%User{id: 123})
+      iex> list_shot_records(:all, %User{id: 123})
      [%ShotRecord{}, ...]

-      iex> list_shot_records(%User{id: 123}, search: "cool")
+      iex> list_shot_records("cool", :all, %User{id: 123})
      [%ShotRecord{notes: "My cool shot record"}, ...]

-      iex> list_shot_records(%User{id: 123}, search: "cool", class: :rifle)
+      iex> list_shot_records("cool", :rifle, %User{id: 123})
      [%ShotRecord{notes: "Shot some rifle rounds"}, ...]

-      iex> list_shot_records(%User{id: 123}, pack_id: 456)
-      [%ShotRecord{pack_id: 456}, ...]
-
  """
-  @spec list_shot_records(User.t()) :: [ShotRecord.t()]
-  @spec list_shot_records(User.t(), list_shot_records_options()) :: [ShotRecord.t()]
-  def list_shot_records(%User{id: user_id}, opts \\ []) do
-    from(sr in ShotRecord,
-      as: :sr,
-      left_join: p in Pack,
-      as: :p,
-      on: sr.pack_id == p.id,
-      on: p.user_id == ^user_id,
-      left_join: t in Type,
-      as: :t,
-      on: p.type_id == t.id,
-      on: t.user_id == ^user_id,
-      where: sr.user_id == ^user_id,
-      distinct: sr.id
+  @spec list_shot_records(Type.class() | :all, User.t()) :: [ShotRecord.t()]
+  @spec list_shot_records(search :: nil | String.t(), Type.class() | :all, User.t()) ::
+          [ShotRecord.t()]
+  def list_shot_records(search \\ nil, type, %{id: user_id}) do
+    from(sg in ShotRecord,
+      as: :sg,
+      left_join: ag in Pack,
+      as: :ag,
+      on: sg.pack_id == ag.id,
+      left_join: at in Type,
+      as: :at,
+      on: ag.type_id == at.id,
+      where: sg.user_id == ^user_id,
+      distinct: sg.id
    )
-    |> list_shot_records_search(Keyword.get(opts, :search))
-    |> list_shot_records_class(Keyword.get(opts, :class))
-    |> list_shot_records_pack_id(Keyword.get(opts, :pack_id))
+    |> list_shot_records_search(search)
+    |> list_shot_records_filter_type(type)
    |> Repo.all()
  end

@ -61,44 +52,45 @@ defmodule Cannery.ActivityLog do

    query
    |> where(
-      [sr: sr, p: p, t: t],
+      [sg: sg, ag: ag, at: at],
      fragment(
        "? @@ websearch_to_tsquery('english', ?)",
-        sr.search,
+        sg.search,
        ^trimmed_search
      ) or
        fragment(
          "? @@ websearch_to_tsquery('english', ?)",
-          p.search,
+          ag.search,
          ^trimmed_search
        ) or
        fragment(
          "? @@ websearch_to_tsquery('english', ?)",
-          t.search,
+          at.search,
          ^trimmed_search
        )
    )
-    |> order_by([sr: sr], {
+    |> order_by([sg: sg], {
      :desc,
      fragment(
        "ts_rank_cd(?, websearch_to_tsquery('english', ?), 4)",
-        sr.search,
+        sg.search,
        ^trimmed_search
      )
    })
  end

-  @spec list_shot_records_class(Queryable.t(), Type.class() | :all | nil) :: Queryable.t()
-  defp list_shot_records_class(query, class) when class in [:rifle, :pistol, :shotgun],
-    do: query |> where([t: t], t.class == ^class)
+  @spec list_shot_records_filter_type(Queryable.t(), Type.class() | :all) ::
+          Queryable.t()
+  defp list_shot_records_filter_type(query, :rifle),
+    do: query |> where([at: at], at.class == :rifle)

-  defp list_shot_records_class(query, _all), do: query
+  defp list_shot_records_filter_type(query, :pistol),
+    do: query |> where([at: at], at.class == :pistol)

-  @spec list_shot_records_pack_id(Queryable.t(), Pack.id() | nil) :: Queryable.t()
-  defp list_shot_records_pack_id(query, pack_id) when pack_id |> is_binary(),
-    do: query |> where([sr: sr], sr.pack_id == ^pack_id)
+  defp list_shot_records_filter_type(query, :shotgun),
+    do: query |> where([at: at], at.class == :shotgun)

-  defp list_shot_records_pack_id(query, _all), do: query
+  defp list_shot_records_filter_type(query, _all), do: query

  @doc """
  Returns a count of shot records.
@ -112,13 +104,25 @@ defmodule Cannery.ActivityLog do
  @spec get_shot_record_count!(User.t()) :: integer()
  def get_shot_record_count!(%User{id: user_id}) do
    Repo.one(
-      from sr in ShotRecord,
-        where: sr.user_id == ^user_id,
-        select: count(sr.id),
+      from sg in ShotRecord,
+        where: sg.user_id == ^user_id,
+        select: count(sg.id),
        distinct: true
    ) || 0
  end

+  @spec list_shot_records_for_pack(Pack.t(), User.t()) :: [ShotRecord.t()]
+  def list_shot_records_for_pack(
+        %Pack{id: pack_id, user_id: user_id},
+        %User{id: user_id}
+      ) do
+    Repo.all(
+      from sg in ShotRecord,
+        where: sg.pack_id == ^pack_id,
+        where: sg.user_id == ^user_id
+    )
+  end
+
  @doc """
  Gets a single shot_record.

@ -136,10 +140,10 @@ defmodule Cannery.ActivityLog do
  @spec get_shot_record!(ShotRecord.id(), User.t()) :: ShotRecord.t()
  def get_shot_record!(id, %User{id: user_id}) do
    Repo.one!(
-      from sr in ShotRecord,
-        where: sr.id == ^id,
-        where: sr.user_id == ^user_id,
-        order_by: sr.date
+      from sg in ShotRecord,
+        where: sg.id == ^id,
+        where: sg.user_id == ^user_id,
+        order_by: sg.date
    )
  end

@ -168,9 +172,9 @@ defmodule Cannery.ActivityLog do
      fn _repo, %{create_shot_record: %{pack_id: pack_id, user_id: user_id}} ->
        pack =
          Repo.one(
-            from p in Pack,
-              where: p.id == ^pack_id,
-              where: p.user_id == ^user_id
+            from ag in Pack,
+              where: ag.id == ^pack_id,
+              where: ag.user_id == ^user_id
          )

        {:ok, pack}
@ -217,7 +221,7 @@ defmodule Cannery.ActivityLog do
    |> Multi.run(
      :pack,
      fn repo, %{update_shot_record: %{pack_id: pack_id, user_id: user_id}} ->
-        {:ok, repo.one(from p in Pack, where: p.id == ^pack_id and p.user_id == ^user_id)}
+        {:ok, repo.one(from ag in Pack, where: ag.id == ^pack_id and ag.user_id == ^user_id)}
      end
    )
    |> Multi.update(
@ -262,7 +266,7 @@ defmodule Cannery.ActivityLog do
    |> Multi.run(
      :pack,
      fn repo, %{delete_shot_record: %{pack_id: pack_id, user_id: user_id}} ->
-        {:ok, repo.one(from p in Pack, where: p.id == ^pack_id and p.user_id == ^user_id)}
+        {:ok, repo.one(from ag in Pack, where: ag.id == ^pack_id and ag.user_id == ^user_id)}
      end
    )
    |> Multi.update(
@ -283,6 +287,36 @@ defmodule Cannery.ActivityLog do
    end
  end

+  @doc """
+  Returns the number of shot rounds for a pack
+  """
+  @spec get_used_count(Pack.t(), User.t()) :: non_neg_integer()
+  def get_used_count(%Pack{id: pack_id} = pack, user) do
+    [pack]
+    |> get_used_counts(user)
+    |> Map.get(pack_id, 0)
+  end
+
+  @doc """
+  Returns the number of shot rounds for multiple packs
+  """
+  @spec get_used_counts([Pack.t()], User.t()) ::
+          %{optional(Pack.id()) => non_neg_integer()}
+  def get_used_counts(packs, %User{id: user_id}) do
+    pack_ids =
+      packs
+      |> Enum.map(fn %{id: pack_id} -> pack_id end)
+
+    Repo.all(
+      from sg in ShotRecord,
+        where: sg.pack_id in ^pack_ids,
+        where: sg.user_id == ^user_id,
+        group_by: sg.pack_id,
+        select: {sg.pack_id, sum(sg.count)}
+    )
+    |> Map.new()
+  end
+
  @doc """
  Returns the last entered shot record date for a pack
  """
@ -303,18 +337,15 @@ defmodule Cannery.ActivityLog do
      |> Enum.map(fn %Pack{id: pack_id, user_id: ^user_id} -> pack_id end)

    Repo.all(
-      from sr in ShotRecord,
-        where: sr.pack_id in ^pack_ids,
-        where: sr.user_id == ^user_id,
-        group_by: sr.pack_id,
-        select: {sr.pack_id, max(sr.date)}
+      from sg in ShotRecord,
+        where: sg.pack_id in ^pack_ids,
+        where: sg.user_id == ^user_id,
+        group_by: sg.pack_id,
+        select: {sg.pack_id, max(sg.date)}
    )
    |> Map.new()
  end

-  @type get_used_count_option :: {:pack_id, Pack.id() | nil} | {:type_id, Type.id() | nil}
-  @type get_used_count_options :: [get_used_count_option()]
-
  @doc """
  Gets the total number of rounds shot for a type

@ -322,116 +353,45 @@ defmodule Cannery.ActivityLog do

  ## Examples

-      iex> get_used_count(%User{id: 123}, type_id: 123)
+      iex> get_used_count_for_type(123, %User{id: 123})
      35

-      iex> get_used_count(%User{id: 123}, pack_id: 456)
-      50
+      iex> get_used_count_for_type(456, %User{id: 123})
+      ** (Ecto.NoResultsError)

  """
-  @spec get_used_count(User.t(), get_used_count_options()) :: non_neg_integer()
-  def get_used_count(%User{id: user_id}, opts) do
-    from(sr in ShotRecord,
-      as: :sr,
-      left_join: p in Pack,
-      on: sr.pack_id == p.id,
-      on: p.user_id == ^user_id,
-      as: :p,
-      where: sr.user_id == ^user_id,
-      where: not (sr.count |> is_nil()),
-      select: sum(sr.count),
-      distinct: true
-    )
-    |> get_used_count_type_id(Keyword.get(opts, :type_id))
-    |> get_used_count_pack_id(Keyword.get(opts, :pack_id))
-    |> Repo.one() || 0
+  @spec get_used_count_for_type(Type.t(), User.t()) :: non_neg_integer()
+  def get_used_count_for_type(%Type{id: type_id} = type, user) do
+    [type]
+    |> get_used_count_for_types(user)
+    |> Map.get(type_id, 0)
  end

-  @spec get_used_count_pack_id(Queryable.t(), Pack.id() | nil) :: Queryable.t()
-  defp get_used_count_pack_id(query, pack_id) when pack_id |> is_binary() do
-    query |> where([sr: sr], sr.pack_id == ^pack_id)
-  end
-
-  defp get_used_count_pack_id(query, _nil), do: query
-
-  @spec get_used_count_type_id(Queryable.t(), Type.id() | nil) :: Queryable.t()
-  defp get_used_count_type_id(query, type_id) when type_id |> is_binary() do
-    query |> where([p: p], p.type_id == ^type_id)
-  end
-
-  defp get_used_count_type_id(query, _nil), do: query
-
-  @type get_grouped_used_counts_option ::
-          {:packs, [Pack.t()] | nil}
-          | {:types, [Type.t()] | nil}
-          | {:group_by, :type_id | :pack_id}
-  @type get_grouped_used_counts_options :: [get_grouped_used_counts_option()]
-
  @doc """
-  Gets the total number of rounds shot for multiple types or packs
+  Gets the total number of rounds shot for multiple types

  ## Examples

-      iex> get_grouped_used_counts(
-      ...>   %User{id: 123},
-      ...>   group_by: :type_id,
-      ...>   types: [%Type{id: 456, user_id: 123}]
-      ...> )
+      iex> get_used_count_for_types(123, %User{id: 123})
      35

-      iex> get_grouped_used_counts(
-      ...>   %User{id: 123},
-      ...>   group_by: :pack_id,
-      ...>   packs: [%Pack{id: 456, user_id: 123}]
-      ...> )
-      22
-
  """
-  @spec get_grouped_used_counts(User.t(), get_grouped_used_counts_options()) ::
-          %{optional(Type.id() | Pack.id()) => non_neg_integer()}
-  def get_grouped_used_counts(%User{id: user_id}, opts) do
-    from(p in Pack,
-      as: :p,
-      left_join: sr in ShotRecord,
-      on: p.id == sr.pack_id,
-      on: p.user_id == ^user_id,
-      as: :sr,
-      where: sr.user_id == ^user_id,
-      where: not (sr.count |> is_nil())
+  @spec get_used_count_for_types([Type.t()], User.t()) ::
+          %{optional(Type.id()) => non_neg_integer()}
+  def get_used_count_for_types(types, %User{id: user_id}) do
+    type_ids =
+      types
+      |> Enum.map(fn %Type{id: type_id, user_id: ^user_id} -> type_id end)
+
+    Repo.all(
+      from ag in Pack,
+        left_join: sg in ShotRecord,
+        on: ag.id == sg.pack_id,
+        where: ag.type_id in ^type_ids,
+        where: not (sg.count |> is_nil()),
+        group_by: ag.type_id,
+        select: {ag.type_id, sum(sg.count)}
    )
-    |> get_grouped_used_counts_group_by(Keyword.fetch!(opts, :group_by))
-    |> get_grouped_used_counts_types(Keyword.get(opts, :types))
-    |> get_grouped_used_counts_packs(Keyword.get(opts, :packs))
-    |> Repo.all()
    |> Map.new()
  end
-
-  @spec get_grouped_used_counts_group_by(Queryable.t(), :type_id | :pack_id) :: Queryable.t()
-  defp get_grouped_used_counts_group_by(query, :type_id) do
-    query
-    |> group_by([p: p], p.type_id)
-    |> select([sr: sr, p: p], {p.type_id, sum(sr.count)})
-  end
-
-  defp get_grouped_used_counts_group_by(query, :pack_id) do
-    query
-    |> group_by([sr: sr], sr.pack_id)
-    |> select([sr: sr], {sr.pack_id, sum(sr.count)})
-  end
-
-  @spec get_grouped_used_counts_types(Queryable.t(), [Type.t()] | nil) :: Queryable.t()
-  defp get_grouped_used_counts_types(query, types) when types |> is_list() do
-    type_ids = types |> Enum.map(fn %Type{id: type_id} -> type_id end)
-    query |> where([p: p], p.type_id in ^type_ids)
-  end
-
-  defp get_grouped_used_counts_types(query, _nil), do: query
-
-  @spec get_grouped_used_counts_packs(Queryable.t(), [Pack.t()] | nil) :: Queryable.t()
-  defp get_grouped_used_counts_packs(query, packs) when packs |> is_list() do
-    pack_ids = packs |> Enum.map(fn %Pack{id: pack_id} -> pack_id end)
-    query |> where([p: p], p.id in ^pack_ids)
-  end
-
-  defp get_grouped_used_counts_packs(query, _nil), do: query
 end
--- a/lib/cannery/activity_log/shot_record.ex
+++ b/lib/cannery/activity_log/shot_record.ex
@ -3,8 +3,11 @@ defmodule Cannery.ActivityLog.ShotRecord do
  A shot record records a group of ammo shot during a range trip
  """

-  use Cannery, :schema
-  alias Cannery.{Ammo, Ammo.Pack}
+  use Ecto.Schema
+  import CanneryWeb.Gettext
+  import Ecto.Changeset
+  alias Cannery.{Accounts.User, Ammo, Ammo.Pack}
+  alias Ecto.{Changeset, UUID}

  @derive {Jason.Encoder,
           only: [
--- a/lib/cannery/ammo.ex
+++ b/lib/cannery/ammo.ex
--- a/lib/cannery/ammo/pack.ex
+++ b/lib/cannery/ammo/pack.ex
@ -6,8 +6,12 @@ defmodule Cannery.Ammo.Pack do
  amount paid for that ammunition, or what condition it is in
  """

-  use Cannery, :schema
-  alias Cannery.{Ammo.Type, Containers, Containers.Container}
+  use Ecto.Schema
+  import CanneryWeb.Gettext
+  import Ecto.Changeset
+  alias Cannery.Ammo.Type
+  alias Cannery.{Accounts.User, Containers, Containers.Container}
+  alias Ecto.{Changeset, UUID}

  @derive {Jason.Encoder,
           only: [
@ -15,17 +19,17 @@ defmodule Cannery.Ammo.Pack do
             :count,
             :notes,
             :price_paid,
-             :lot_number,
             :staged,
             :type_id,
             :container_id
           ]}
+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
  schema "packs" do
    field :count, :integer
    field :notes, :string
    field :price_paid, :float
    field :staged, :boolean, default: false
-    field :lot_number, :string
    field :purchased_on, :date

    belongs_to :type, Type
@ -41,7 +45,6 @@ defmodule Cannery.Ammo.Pack do
          notes: String.t() | nil,
          price_paid: float() | nil,
          staged: boolean(),
-          lot_number: String.t() | nil,
          purchased_on: Date.t(),
          type: Type.t() | nil,
          type_id: Type.id(),
@ -64,62 +67,38 @@ defmodule Cannery.Ammo.Pack do
        ) :: changeset()
  def create_changeset(
        pack,
-        type,
-        container,
+        %Type{id: type_id},
+        %Container{id: container_id, user_id: user_id},
        %User{id: user_id},
        attrs
      )
-      when is_binary(user_id) do
-    type_id =
-      case type do
-        %Type{id: type_id} when is_binary(type_id) ->
-          type_id
-
-        _invalid_type ->
-          nil
-      end
-
-    container_id =
-      case container do
-        %Container{id: container_id, user_id: ^user_id} when is_binary(container_id) ->
-          container_id
-
-        _invalid_container ->
-          nil
-      end
-
+      when is_binary(type_id) and is_binary(container_id) and is_binary(user_id) do
    pack
    |> change(type_id: type_id)
-    |> change(container_id: container_id)
    |> change(user_id: user_id)
-    |> cast(attrs, [:count, :lot_number, :notes, :price_paid, :purchased_on, :staged])
-    |> validate_required(:type_id, message: dgettext("errors", "Please select a valid type"))
-    |> validate_required(:container_id,
-      message: dgettext("errors", "Please select a valid container")
-    )
+    |> change(container_id: container_id)
+    |> cast(attrs, [:count, :price_paid, :notes, :staged, :purchased_on])
    |> validate_number(:count, greater_than: 0)
-    |> validate_number(:price_paid, greater_than_or_equal_to: 0)
-    |> validate_length(:lot_number, max: 255)
    |> validate_required([:count, :staged, :purchased_on, :type_id, :container_id, :user_id])
  end

+  @doc """
+  Invalid changeset, used to prompt user to select type and container
+  """
+  def create_changeset(pack, _invalid_type, _invalid_container, _invalid_user, attrs) do
+    pack
+    |> cast(attrs, [:type_id, :container_id])
+    |> validate_required([:type_id, :container_id])
+    |> add_error(:invalid, dgettext("errors", "Please select a type and container"))
+  end
+
  @doc false
  @spec update_changeset(t() | new_pack(), attrs :: map(), User.t()) :: changeset()
  def update_changeset(pack, attrs, user) do
    pack
-    |> cast(attrs, [
-      :count,
-      :price_paid,
-      :notes,
-      :staged,
-      :purchased_on,
-      :lot_number,
-      :container_id
-    ])
+    |> cast(attrs, [:count, :price_paid, :notes, :staged, :purchased_on, :container_id])
    |> validate_number(:count, greater_than_or_equal_to: 0)
-    |> validate_number(:price_paid, greater_than_or_equal_to: 0)
    |> validate_container_id(user)
-    |> validate_length(:lot_number, max: 255)
    |> validate_required([:count, :staged, :purchased_on, :container_id])
  end

--- a/lib/cannery/ammo/type.ex
+++ b/lib/cannery/ammo/type.ex
@ -5,51 +5,48 @@ defmodule Cannery.Ammo.Type do
  Contains statistical information about the ammunition.
  """

-  use Cannery, :schema
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Cannery.Accounts.User
  alias Cannery.Ammo.Pack
+  alias Ecto.{Changeset, UUID}

  @derive {Jason.Encoder,
           only: [
+             :id,
             :name,
             :desc,
-             :class,
             :bullet_type,
             :bullet_core,
+             :cartridge,
             :caliber,
             :case_material,
+             :jacket_type,
+             :muzzle_velocity,
             :powder_type,
+             :powder_grains_per_charge,
             :grains,
             :pressure,
             :primer_type,
             :firing_type,
-             :manufacturer,
-             :upc,
             :tracer,
             :incendiary,
             :blank,
             :corrosive,
-             :cartridge,
-             :jacket_type,
-             :powder_grains_per_charge,
-             :muzzle_velocity,
-             :wadding,
-             :shot_type,
-             :shot_material,
-             :shot_size,
-             :unfired_length,
-             :brass_height,
-             :chamber_size,
-             :load_grains,
-             :shot_charge_weight,
-             :dram_equivalent
+             :manufacturer,
+             :upc
           ]}
+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
  schema "types" do
    field :name, :string
    field :desc, :string

-    field :class, Ecto.Enum, values: [:rifle, :shotgun, :pistol], default: :rifle
+    field :class, Ecto.Enum, values: [:rifle, :shotgun, :pistol]

    # common fields
+    # https://shootersreference.com/reloadingdata/bullet_abbreviations/
+    field :bullet_type, :string
    field :bullet_core, :string
    # also gauge for shotguns
    field :caliber, :string
@ -68,8 +65,6 @@ defmodule Cannery.Ammo.Type do
    field :corrosive, :boolean, default: false

    # rifle/pistol fields
-    # https://shootersreference.com/reloadingdata/bullet_abbreviations/
-    field :bullet_type, :string
    field :cartridge, :string
    field :jacket_type, :string
    field :powder_grains_per_charge, :integer
@ -100,23 +95,17 @@ defmodule Cannery.Ammo.Type do
          class: class(),
          bullet_type: String.t() | nil,
          bullet_core: String.t() | nil,
+          cartridge: String.t() | nil,
          caliber: String.t() | nil,
          case_material: String.t() | nil,
+          jacket_type: String.t() | nil,
+          muzzle_velocity: integer() | nil,
          powder_type: String.t() | nil,
+          powder_grains_per_charge: integer() | nil,
          grains: integer() | nil,
          pressure: String.t() | nil,
          primer_type: String.t() | nil,
          firing_type: String.t() | nil,
-          manufacturer: String.t() | nil,
-          upc: String.t() | nil,
-          tracer: boolean(),
-          incendiary: boolean(),
-          blank: boolean(),
-          corrosive: boolean(),
-          cartridge: String.t() | nil,
-          jacket_type: String.t() | nil,
-          powder_grains_per_charge: integer() | nil,
-          muzzle_velocity: integer() | nil,
          wadding: String.t() | nil,
          shot_type: String.t() | nil,
          shot_material: String.t() | nil,
@ -127,6 +116,12 @@ defmodule Cannery.Ammo.Type do
          load_grains: integer() | nil,
          shot_charge_weight: String.t() | nil,
          dram_equivalent: String.t() | nil,
+          tracer: boolean(),
+          incendiary: boolean(),
+          blank: boolean(),
+          corrosive: boolean(),
+          manufacturer: String.t() | nil,
+          upc: String.t() | nil,
          user_id: User.id(),
          packs: [Pack.t()] | nil,
          inserted_at: NaiveDateTime.t(),
@ -145,23 +140,17 @@ defmodule Cannery.Ammo.Type do
      :class,
      :bullet_type,
      :bullet_core,
+      :cartridge,
      :caliber,
      :case_material,
+      :jacket_type,
+      :muzzle_velocity,
      :powder_type,
+      :powder_grains_per_charge,
      :grains,
      :pressure,
      :primer_type,
      :firing_type,
-      :manufacturer,
-      :upc,
-      :tracer,
-      :incendiary,
-      :blank,
-      :corrosive,
-      :cartridge,
-      :jacket_type,
-      :powder_grains_per_charge,
-      :muzzle_velocity,
      :wadding,
      :shot_type,
      :shot_material,
@ -171,26 +160,29 @@ defmodule Cannery.Ammo.Type do
      :chamber_size,
      :load_grains,
      :shot_charge_weight,
-      :dram_equivalent
+      :dram_equivalent,
+      :tracer,
+      :incendiary,
+      :blank,
+      :corrosive,
+      :manufacturer,
+      :upc
    ]

  @spec string_fields() :: [atom()]
  defp string_fields,
    do: [
      :name,
-      :desc,
      :bullet_type,
      :bullet_core,
+      :cartridge,
      :caliber,
      :case_material,
+      :jacket_type,
      :powder_type,
      :pressure,
      :primer_type,
      :firing_type,
-      :manufacturer,
-      :upc,
-      :cartridge,
-      :jacket_type,
      :wadding,
      :shot_type,
      :shot_material,
@ -199,7 +191,9 @@ defmodule Cannery.Ammo.Type do
      :brass_height,
      :chamber_size,
      :shot_charge_weight,
-      :dram_equivalent
+      :dram_equivalent,
+      :manufacturer,
+      :upc
    ]

  @doc false
--- a/lib/cannery/containers.ex
+++ b/lib/cannery/containers.ex
@ -3,15 +3,14 @@ defmodule Cannery.Containers do
  The Containers context.
  """

-  use Cannery, :context
-  alias Cannery.Ammo.Pack
+  import CanneryWeb.Gettext
+  import Ecto.Query, warn: false
+  alias Cannery.{Accounts.User, Ammo.Pack, Repo}
  alias Cannery.Containers.{Container, ContainerTag, Tag}
+  alias Ecto.Changeset

  @container_preloads [:tags]

-  @type list_containers_option :: {:search, String.t() | nil}
-  @type list_containers_options :: [list_containers_option()]
-
  @doc """
  Returns the list of containers.

@ -20,31 +19,30 @@ defmodule Cannery.Containers do
      iex> list_containers(%User{id: 123})
      [%Container{}, ...]

-      iex> list_containers(%User{id: 123}, search: "cool")
+      iex> list_containers("cool", %User{id: 123})
      [%Container{name: "my cool container"}, ...]

  """
  @spec list_containers(User.t()) :: [Container.t()]
-  @spec list_containers(User.t(), list_containers_options()) :: [Container.t()]
-  def list_containers(%User{id: user_id}, opts \\ []) do
+  @spec list_containers(search :: nil | String.t(), User.t()) :: [Container.t()]
+  def list_containers(search \\ nil, %User{id: user_id}) do
    from(c in Container,
      as: :c,
      left_join: t in assoc(c, :tags),
-      on: c.user_id == t.user_id,
      as: :t,
      where: c.user_id == ^user_id,
+      order_by: c.name,
      distinct: c.id,
      preload: ^@container_preloads
    )
-    |> list_containers_search(Keyword.get(opts, :search))
+    |> list_containers_search(search)
    |> Repo.all()
  end

-  @spec list_containers_search(Queryable.t(), search :: String.t() | nil) :: Queryable.t()
-  defp list_containers_search(query, search) when search in ["", nil],
-    do: query |> order_by([c: c], c.name)
+  defp list_containers_search(query, nil), do: query
+  defp list_containers_search(query, ""), do: query

-  defp list_containers_search(query, search) when search |> is_binary() do
+  defp list_containers_search(query, search) do
    trimmed_search = String.trim(search)

    query
@ -205,9 +203,9 @@ defmodule Cannery.Containers do
          {:ok, Container.t()} | {:error, Container.changeset()}
  def delete_container(%Container{user_id: user_id} = container, %User{id: user_id}) do
    Repo.one(
-      from p in Pack,
-        where: p.container_id == ^container.id,
-        select: count(p.id)
+      from ag in Pack,
+        where: ag.container_id == ^container.id,
+        select: count(ag.id)
    )
    |> case do
      0 ->
@ -291,9 +289,6 @@ defmodule Cannery.Containers do

  # Container Tags

-  @type list_tags_option :: {:search, String.t() | nil}
-  @type list_tags_options :: [list_tags_option()]
-
  @doc """
  Returns the list of tags.

@ -302,42 +297,38 @@ defmodule Cannery.Containers do
      iex> list_tags(%User{id: 123})
      [%Tag{}, ...]

-      iex> list_tags(%User{id: 123}, search: "cool")
+      iex> list_tags("cool", %User{id: 123})
      [%Tag{name: "my cool tag"}, ...]

  """
  @spec list_tags(User.t()) :: [Tag.t()]
-  @spec list_tags(User.t(), list_tags_options()) :: [Tag.t()]
-  def list_tags(%User{id: user_id}, opts \\ []) do
-    from(t in Tag, as: :t, where: t.user_id == ^user_id)
-    |> list_tags_search(Keyword.get(opts, :search))
-    |> Repo.all()
-  end
+  @spec list_tags(search :: nil | String.t(), User.t()) :: [Tag.t()]
+  def list_tags(search \\ nil, user)

-  @spec list_tags_search(Queryable.t(), search :: String.t() | nil) :: Queryable.t()
-  defp list_tags_search(query, search) when search in ["", nil],
-    do: query |> order_by([t: t], t.name)
+  def list_tags(search, %{id: user_id}) when search |> is_nil() or search == "",
+    do: Repo.all(from t in Tag, where: t.user_id == ^user_id, order_by: t.name)

-  defp list_tags_search(query, search) when search |> is_binary() do
+  def list_tags(search, %{id: user_id}) when search |> is_binary() do
    trimmed_search = String.trim(search)

-    query
-    |> where(
-      [t: t],
-      fragment(
-        "? @@ websearch_to_tsquery('english', ?)",
-        t.search,
-        ^trimmed_search
-      )
+    Repo.all(
+      from t in Tag,
+        where: t.user_id == ^user_id,
+        where:
+          fragment(
+            "? @@ websearch_to_tsquery('english', ?)",
+            t.search,
+            ^trimmed_search
+          ),
+        order_by: {
+          :desc,
+          fragment(
+            "ts_rank_cd(?, websearch_to_tsquery('english', ?), 4)",
+            t.search,
+            ^trimmed_search
+          )
+        }
    )
-    |> order_by([t: t], {
-      :desc,
-      fragment(
-        "ts_rank_cd(?, websearch_to_tsquery('english', ?), 4)",
-        t.search,
-        ^trimmed_search
-      )
-    })
  end

  @doc """
--- a/lib/cannery/containers/container.ex
+++ b/lib/cannery/containers/container.ex
@ -3,8 +3,10 @@ defmodule Cannery.Containers.Container do
  A container that holds ammunition and belongs to a user.
  """

-  use Cannery, :schema
-  alias Cannery.{Containers.ContainerTag, Containers.Tag}
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Ecto.{Changeset, UUID}
+  alias Cannery.{Accounts.User, Containers.ContainerTag, Containers.Tag}

  @derive {Jason.Encoder,
           only: [
@ -15,6 +17,8 @@ defmodule Cannery.Containers.Container do
             :type,
             :tags
           ]}
+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
  schema "containers" do
    field :name, :string
    field :desc, :string
--- a/lib/cannery/containers/container_tag.ex
+++ b/lib/cannery/containers/container_tag.ex
@ -4,9 +4,13 @@ defmodule Cannery.Containers.ContainerTag do
  Cannery.Containers.Tag.
  """

-  use Cannery, :schema
+  use Ecto.Schema
+  import Ecto.Changeset
  alias Cannery.Containers.{Container, Tag}
+  alias Ecto.{Changeset, UUID}

+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
  schema "container_tags" do
    belongs_to :container, Container
    belongs_to :tag, Tag
--- a/lib/cannery/containers/tag.ex
+++ b/lib/cannery/containers/tag.ex
@ -4,7 +4,10 @@ defmodule Cannery.Containers.Tag do
  text and bg colors.
  """

-  use Cannery, :schema
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Cannery.Accounts.User
+  alias Ecto.{Changeset, UUID}

  @derive {Jason.Encoder,
           only: [
@ -13,6 +16,8 @@ defmodule Cannery.Containers.Tag do
             :bg_color,
             :text_color
           ]}
+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
  schema "tags" do
    field :name, :string
    field :bg_color, :string
--- a/lib/cannery/logger.ex
+++ b/lib/cannery/logger.ex
@ -14,17 +14,17 @@ defmodule Cannery.Logger do
      |> Map.put(:stacktrace, Exception.format_stacktrace(stacktrace))
      |> pretty_encode()

-    Logger.error("Oban exception: #{data}")
+    Logger.error(meta.reason, data: data)
  end

  def handle_event([:oban, :job, :start], measure, meta, _config) do
    data = get_oban_job_data(meta, measure) |> pretty_encode()
-    Logger.info("Started oban job: #{data}")
+    Logger.info("Started oban job", data: data)
  end

  def handle_event([:oban, :job, :stop], measure, meta, _config) do
    data = get_oban_job_data(meta, measure) |> pretty_encode()
-    Logger.info("Finished oban job: #{data}")
+    Logger.info("Finished oban job", data: data)
  end

  def handle_event([:oban, :job, unhandled_event], measure, meta, _config) do
@ -33,7 +33,7 @@ defmodule Cannery.Logger do
      |> Map.put(:event, unhandled_event)
      |> pretty_encode()

-    Logger.warning("Unhandled oban job event: #{data}")
+    Logger.warning("Unhandled oban job event", data: data)
  end

  def handle_event(unhandled_event, measure, meta, config) do
@ -45,7 +45,7 @@ defmodule Cannery.Logger do
        config: config
      })

-    Logger.warning("Unhandled telemetry event: #{data}")
+    Logger.warning("Unhandled telemetry event", data: data)
  end

  defp get_oban_job_data(%{job: job}, measure) do
--- a/lib/cannery_web.ex
+++ b/lib/cannery_web.ex
@ -1,62 +1,53 @@
 defmodule CanneryWeb do
  @moduledoc """
  The entrypoint for defining your web interface, such
-  as controllers, components, channels, and so on.
+  as controllers, views, channels and so on.

  This can be used in your application as:

      use CanneryWeb, :controller
-      use CanneryWeb, :html
+      use CanneryWeb, :view

-  The definitions below will be executed for every controller,
-  component, etc, so keep them short and clean, focused
+  The definitions below will be executed for every view,
+  controller, etc, so keep them short and clean, focused
  on imports, uses and aliases.

  Do NOT define functions inside the quoted expressions
-  below. Instead, define additional modules and import
-  those modules here.
+  below. Instead, define any helper function in modules
+  and import those modules here.
  """

-  def static_paths, do: ~w(css js fonts images favicon.ico robots.txt)
-
-  def router do
-    quote do
-      use Phoenix.Router, helpers: false
-
-      # Import common connection and controller functions to use in pipelines
-      import Plug.Conn
-      import Phoenix.Controller
-      import Phoenix.LiveView.Router
-    end
-  end
-
-  def channel do
-    quote do
-      use Phoenix.Channel
-    end
-  end
-
  def controller do
    quote do
-      use Phoenix.Controller,
-        formats: [:html, :json],
-        layouts: [html: CanneryWeb.Layouts]
+      use Phoenix.Controller, namespace: CanneryWeb

-      use Gettext, backend: CanneryWeb.Gettext
-
-      # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
      import Plug.Conn
+      import CanneryWeb.Gettext
+      alias CanneryWeb.Router.Helpers, as: Routes
+    end
+  end

-      unquote(verified_routes())
+  def view do
+    quote do
+      use Phoenix.View,
+        root: "lib/cannery_web/templates",
+        namespace: CanneryWeb
+
+      # Import convenience functions from controllers
+      import Phoenix.Controller,
+        only: [get_flash: 1, get_flash: 2, view_module: 1, view_template: 1]
+
+      # Include shared imports and aliases for views
+      unquote(view_helpers())
    end
  end

  def live_view do
    quote do
-      use Phoenix.LiveView,
-        layout: {CanneryWeb.Layouts, :app}
+      use Phoenix.LiveView, layout: {CanneryWeb.LayoutView, :live}

-      unquote(html_helpers())
+      on_mount CanneryWeb.InitAssigns
+      unquote(view_helpers())
    end
  end

@ -64,45 +55,49 @@ defmodule CanneryWeb do
    quote do
      use Phoenix.LiveComponent

-      unquote(html_helpers())
+      unquote(view_helpers())
    end
  end

-  def html do
+  def component do
    quote do
-      # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
      use Phoenix.Component

-      # Import convenience functions from controllers
-      import Phoenix.Controller,
-        only: [get_csrf_token: 0, view_module: 1, view_template: 1]
-
-      # Include general helpers for rendering HTML
-      unquote(html_helpers())
+      unquote(view_helpers())
    end
  end

-  defp html_helpers do
+  def router do
    quote do
-      use PhoenixHTMLHelpers
-      use Gettext, backend: CanneryWeb.Gettext
-      import Phoenix.{Component, HTML, HTML.Form}
-      import CanneryWeb.{ErrorHelpers, CoreComponents, HTMLHelpers}
+      use Phoenix.Router

-      # Shortcut for generating JS commands
-      alias Phoenix.LiveView.JS
-
-      # Routes generation with the ~p sigil
-      unquote(verified_routes())
+      import Phoenix.{Controller, LiveView.Router}
+      # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
+      import Plug.Conn
    end
  end

-  def verified_routes do
+  def channel do
    quote do
-      use Phoenix.VerifiedRoutes,
-        endpoint: CanneryWeb.Endpoint,
-        router: CanneryWeb.Router,
-        statics: CanneryWeb.static_paths()
+      use Phoenix.Channel
+      # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
+      import CanneryWeb.Gettext
+    end
+  end
+
+  defp view_helpers do
+    quote do
+      # Use all HTML functionality (forms, tags, etc)
+      # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
+      use Phoenix.HTML
+
+      # Import LiveView and .heex helpers (live_render, live_patch, <.form>, etc)
+      # Import basic rendering functionality (render, render_layout, etc)
+      import CanneryWeb.{ErrorHelpers, Gettext, CoreComponents, ViewHelpers}
+      import Phoenix.{Component, View}
+
+      alias CanneryWeb.Endpoint
+      alias CanneryWeb.Router.Helpers, as: Routes
    end
  end

--- a/lib/cannery_web/components/add_shot_record_component.ex
+++ b/lib/cannery_web/components/add_shot_record_component.ex
@ -33,9 +33,7 @@ defmodule CanneryWeb.Components.AddShotRecordComponent do
      ) do
    params = shot_record_params |> process_params(pack)

-    changeset =
-      %ShotRecord{}
-      |> ShotRecord.create_changeset(current_user, pack, params)
+    changeset = %ShotRecord{} |> ShotRecord.create_changeset(current_user, pack, params)

    changeset =
      case changeset |> Changeset.apply_action(:validate) do
--- a/lib/cannery_web/components/add_shot_record_component.html.heex
+++ b/lib/cannery_web/components/add_shot_record_component.html.heex
@ -13,7 +13,7 @@
    phx-submit="save"
  >
    <div
-      :if={@changeset.action && not @changeset.valid?}
+      :if={@changeset.action && not @changeset.valid?()}
      class="invalid-feedback col-span-3 text-center"
    >
      <%= changeset_errors(@changeset) %>
@ -37,12 +37,12 @@

    <%= label(f, :notes, gettext("Notes"), class: "title text-lg text-primary-600") %>
    <%= textarea(f, :notes,
-      class: "input input-primary col-span-2",
      id: "add-shot-record-form-notes",
+      class: "input input-primary col-span-2",
      maxlength: 255,
-      phx_debounce: 300,
-      phx_update: "ignore",
-      placeholder: gettext("Really great weather")
+      placeholder: gettext("Really great weather"),
+      phx_hook: "MaintainAttrs",
+      phx_update: "ignore"
    ) %>
    <%= error_tag(f, :notes, "col-span-3") %>

--- a/lib/cannery_web/components/container_table_component.ex
+++ b/lib/cannery_web/components/container_table_component.ex
@ -71,16 +71,8 @@ defmodule CanneryWeb.Components.ContainerTableComponent do
      current_user: current_user,
      tag_actions: tag_actions,
      actions: actions,
-      pack_count:
-        Ammo.get_grouped_packs_count(current_user,
-          containers: containers,
-          group_by: :container_id
-        ),
-      round_count:
-        Ammo.get_grouped_round_count(current_user,
-          containers: containers,
-          group_by: :container_id
-        )
+      pack_count: Ammo.get_packs_count_for_containers(containers, current_user),
+      round_count: Ammo.get_round_count_for_containers(containers, current_user)
    }

    rows =
@ -117,12 +109,14 @@ defmodule CanneryWeb.Components.ContainerTableComponent do
  end

  @spec get_value_for_key(atom(), Container.t(), extra_data :: map) :: any()
-  defp get_value_for_key(:name, %{name: container_name} = assigns, _extra_data) do
+  defp get_value_for_key(:name, %{id: id, name: container_name}, _extra_data) do
+    assigns = %{id: id, container_name: container_name}
+
    {container_name,
     ~H"""
     <div class="flex flex-wrap justify-center items-center">
-       <.link navigate={~p"/container/#{@id}"} class="link">
-         <%= @name %>
+       <.link navigate={Routes.container_show_path(Endpoint, :show, @id)} class="link">
+         <%= @container_name %>
       </.link>
     </div>
     """}
--- a/lib/cannery_web/components/core_components.ex
+++ b/lib/cannery_web/components/core_components.ex
@ -3,12 +3,11 @@ defmodule CanneryWeb.CoreComponents do
  Provides core UI components.
  """
  use Phoenix.Component
-  use CanneryWeb, :verified_routes
-  use Gettext, backend: CanneryWeb.Gettext
-  import CanneryWeb.HTMLHelpers
+  import CanneryWeb.{Gettext, ViewHelpers}
  alias Cannery.{Accounts, Accounts.Invite, Accounts.User}
  alias Cannery.{Ammo, Ammo.Pack}
  alias Cannery.{Containers.Container, Containers.Tag}
+  alias CanneryWeb.{Endpoint, HomeLive}
  alias CanneryWeb.Router.Helpers, as: Routes
  alias Phoenix.LiveView.{JS, Rendered}

@ -30,13 +29,13 @@ defmodule CanneryWeb.CoreComponents do

  ## Examples

-      <.modal return_to={~p"/\#{<%= schema.plural %>}"}>
+      <.modal return_to={Routes.<%= schema.singular %>_index_path(Endpoint, :index)}>
        <.live_component
          module={<%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.FormComponent}
          id={@<%= schema.singular %>.id || :new}
          title={@page_title}
          action={@live_action}
-          return_to={~p"/\#{<%= schema.singular %>}"}
+          return_to={Routes.<%= schema.singular %>_index_path(Endpoint, :index)}
          <%= schema.singular %>: @<%= schema.singular %>
        />
      </.modal>
--- a/lib/cannery_web/components/core_components/container_card.html.heex
+++ b/lib/cannery_web/components/core_components/container_card.html.heex
@ -5,7 +5,7 @@
    border border-gray-400 rounded-lg shadow-lg hover:shadow-md
    transition-all duration-300 ease-in-out"
 >
-  <.link navigate={~p"/container/#{@container}"} class="link">
+  <.link navigate={Routes.container_show_path(Endpoint, :show, @container)} class="link">
    <h1 class="px-4 py-2 rounded-lg title text-xl">
      <%= @container.name %>
    </h1>
@ -27,15 +27,15 @@
      <%= @container.location %>
    </span>

-    <%= if Ammo.get_packs_count(@current_user, container_id: @container.id) != 0 do %>
+    <%= if @container |> Ammo.get_packs_count_for_container!(@current_user) != 0 do %>
      <span class="rounded-lg title text-lg">
        <%= gettext("Packs:") %>
-        <%= Ammo.get_packs_count(@current_user, container_id: @container.id) %>
+        <%= @container |> Ammo.get_packs_count_for_container!(@current_user) %>
      </span>

      <span class="rounded-lg title text-lg">
        <%= gettext("Rounds:") %>
-        <%= Ammo.get_round_count(@current_user, container_id: @container.id) %>
+        <%= @container |> Ammo.get_round_count_for_container!(@current_user) %>
      </span>
    <% end %>

--- a/lib/cannery_web/components/core_components/invite_card.html.heex
+++ b/lib/cannery_web/components/core_components/invite_card.html.heex
@ -23,7 +23,7 @@
  <% end %>

  <.qr_code
-    content={url(CanneryWeb.Endpoint, ~p"/users/register?invite=#{@invite.token}")}
+    content={Routes.user_registration_url(Endpoint, :new, invite: @invite.token)}
    filename={@invite.name}
  />

@ -36,7 +36,7 @@
      id={"code-#{@invite.id}"}
      class="mx-2 my-1 text-xs px-4 py-2 rounded-lg text-center break-all text-gray-100 bg-primary-800"
      phx-no-format
-    ><%= url(CanneryWeb.Endpoint, ~p"/users/register?invite=#{@invite.token}") %></code>
+    ><%= Routes.user_registration_url(Endpoint, :new, invite: @invite.token) %></code>
    <%= if @code_actions, do: render_slot(@code_actions) %>
  </div>

--- a/lib/cannery_web/components/core_components/pack_card.html.heex
+++ b/lib/cannery_web/components/core_components/pack_card.html.heex
@ -5,7 +5,7 @@
    border border-gray-400 rounded-lg shadow-lg hover:shadow-md
    transition-all duration-300 ease-in-out"
 >
-  <.link navigate={~p"/ammo/show/#{@pack}"} class="mb-2 link">
+  <.link navigate={Routes.pack_show_path(Endpoint, :show, @pack)} class="mb-2 link">
    <h1 class="title text-xl title-primary-500">
      <%= @pack.type.name %>
    </h1>
@ -47,15 +47,10 @@
      <%= gettext("$%{amount}", amount: display_currency(@cpr)) %>
    </span>

-    <span :if={@pack.lot_number} class="rounded-lg title text-lg">
-      <%= gettext("Lot number:") %>
-      <%= @pack.lot_number %>
-    </span>
-
    <span :if={@container} class="rounded-lg title text-lg">
      <%= gettext("Container:") %>

-      <.link navigate={~p"/container/#{@container}"} class="link">
+      <.link navigate={Routes.container_show_path(Endpoint, :show, @container)} class="link">
        <%= @container.name %>
      </.link>
    </span>
--- a/lib/cannery_web/components/core_components/topbar.html.heex
+++ b/lib/cannery_web/components/core_components/topbar.html.heex
@ -1,9 +1,12 @@
 <nav role="navigation" class="mb-8 px-8 py-4 w-full bg-primary-500">
  <div class="flex flex-col sm:flex-row justify-between items-center">
    <div class="mb-4 sm:mb-0 sm:mr-8 flex flex-row justify-start items-center space-x-2">
-      <.link navigate={~p"/"} class="inline mx-2 my-1 leading-5 text-xl text-white">
+      <.link
+        navigate={Routes.live_path(Endpoint, HomeLive)}
+        class="inline mx-2 my-1 leading-5 text-xl text-white"
+      >
        <img
-          src={~p"/images/cannery.svg"}
+          src={Routes.static_path(Endpoint, "/images/cannery.svg")}
          alt={gettext("Cannery logo")}
          class="inline-block h-8 mx-1"
        />
@ -24,43 +27,64 @@
      text-lg text-white text-ellipsis">
      <%= if @current_user do %>
        <li class="mx-2 my-1">
-          <.link navigate={~p"/tags"} class="text-white hover:underline">
+          <.link
+            navigate={Routes.tag_index_path(Endpoint, :index)}
+            class="text-white hover:underline"
+          >
            <%= gettext("Tags") %>
          </.link>
        </li>
        <li class="mx-2 my-1">
-          <.link navigate={~p"/containers"} class="text-white hover:underline">
+          <.link
+            navigate={Routes.container_index_path(Endpoint, :index)}
+            class="text-white hover:underline"
+          >
            <%= gettext("Containers") %>
          </.link>
        </li>
        <li class="mx-2 my-1">
-          <.link navigate={~p"/catalog"} class="text-white hover:underline">
+          <.link
+            navigate={Routes.type_index_path(Endpoint, :index)}
+            class="text-white hover:underline"
+          >
            <%= gettext("Catalog") %>
          </.link>
        </li>
        <li class="mx-2 my-1">
-          <.link navigate={~p"/ammo"} class="text-white hover:underline">
+          <.link
+            navigate={Routes.pack_index_path(Endpoint, :index)}
+            class="text-white hover:underline"
+          >
            <%= gettext("Ammo") %>
          </.link>
        </li>
        <li class="mx-2 my-1">
-          <.link navigate={~p"/range"} class="text-white hover:underline">
+          <.link
+            navigate={Routes.range_index_path(Endpoint, :index)}
+            class="text-white hover:underline"
+          >
            <%= gettext("Range") %>
          </.link>
        </li>
-        <li :if={@current_user |> Accounts.already_admin?()} class="mx-2 my-1">
-          <.link navigate={~p"/invites"} class="text-white hover:underline">
+        <li :if={@current_user |> Accounts.is_already_admin?()} class="mx-2 my-1">
+          <.link
+            navigate={Routes.invite_index_path(Endpoint, :index)}
+            class="text-white hover:underline"
+          >
            <%= gettext("Invites") %>
          </.link>
        </li>
        <li class="mx-2 my-1">
-          <.link href={~p"/users/settings"} class="text-white hover:underline truncate">
+          <.link
+            href={Routes.user_settings_path(Endpoint, :edit)}
+            class="text-white hover:underline truncate"
+          >
            <%= @current_user.email %>
          </.link>
        </li>
        <li class="mx-2 my-1">
          <.link
-            href={~p"/users/log_out"}
+            href={Routes.user_session_path(Endpoint, :delete)}
            method="delete"
            data-confirm={dgettext("prompts", "Are you sure you want to log out?")}
            aria-label={gettext("Log out")}
@ -70,13 +94,13 @@
        </li>
        <li
          :if={
-            @current_user |> Accounts.already_admin?() and
+            @current_user |> Accounts.is_already_admin?() and
              function_exported?(Routes, :live_dashboard_path, 2)
          }
          class="mx-2 my-1"
        >
          <.link
-            navigate={~p"/dashboard"}
+            navigate={Routes.live_dashboard_path(Endpoint, :home)}
            class="text-white hover:underline"
            aria-label={gettext("Live Dashboard")}
          >
@ -85,12 +109,18 @@
        </li>
      <% else %>
        <li :if={Accounts.allow_registration?()} class="mx-2 my-1">
-          <.link href={~p"/users/register"} class="text-white hover:underline truncate">
+          <.link
+            href={Routes.user_registration_path(Endpoint, :new)}
+            class="text-white hover:underline truncate"
+          >
            <%= dgettext("actions", "Register") %>
          </.link>
        </li>
        <li class="mx-2 my-1">
-          <.link href={~p"/users/log_in"} class="text-white hover:underline truncate">
+          <.link
+            href={Routes.user_session_path(Endpoint, :new)}
+            class="text-white hover:underline truncate"
+          >
            <%= dgettext("actions", "Log in") %>
          </.link>
        </li>
--- a/lib/cannery_web/components/email_html.ex
+++ b/lib/cannery_web/components/email_html.ex
@ -1,10 +0,0 @@
-defmodule CanneryWeb.EmailHTML do
-  @moduledoc """
-  Renders email templates
-  """
-
-  use CanneryWeb, :html
-
-  embed_templates "email_html/*.html", suffix: "_html"
-  embed_templates "email_html/*.txt", suffix: "_text"
-end
--- a/lib/cannery_web/components/layouts.ex
+++ b/lib/cannery_web/components/layouts.ex
@ -1,17 +0,0 @@
-defmodule CanneryWeb.Layouts do
-  @moduledoc """
-  The root layouts for the entire application
-  """
-
-  use CanneryWeb, :html
-
-  embed_templates "layouts/*"
-
-  def get_title(%{assigns: %{title: title}}) when title not in [nil, ""] do
-    gettext("Cannery | %{title}", title: title)
-  end
-
-  def get_title(_conn) do
-    gettext("Cannery")
-  end
-end
--- a/lib/cannery_web/components/layouts/empty.html.heex
+++ b/lib/cannery_web/components/layouts/empty.html.heex
@ -1 +0,0 @@
-<%= @inner_block %>
--- a/lib/cannery_web/components/move_pack_component.ex
+++ b/lib/cannery_web/components/move_pack_component.ex
@ -5,6 +5,7 @@ defmodule CanneryWeb.Components.MovePackComponent do

  use CanneryWeb, :live_component
  alias Cannery.{Accounts.User, Ammo, Ammo.Pack, Containers, Containers.Container}
+  alias CanneryWeb.Endpoint
  alias Ecto.Changeset
  alias Phoenix.LiveView.Socket

@ -83,13 +84,13 @@ defmodule CanneryWeb.Components.MovePackComponent do
          <%= display_emoji("😔") %>
        </h2>

-        <.link navigate={~p"/containers/new"} class="btn btn-primary">
+        <.link navigate={Routes.container_index_path(Endpoint, :new)} class="btn btn-primary">
          <%= dgettext("actions", "Add another container!") %>
        </.link>
      <% else %>
        <.live_component
          module={CanneryWeb.Components.TableComponent}
-          id="move-pack-table"
+          id="move_pack_table"
          columns={@columns}
          rows={@rows}
        />
--- a/lib/cannery_web/components/pack_table_component.ex
+++ b/lib/cannery_web/components/pack_table_component.ex
@ -53,9 +53,6 @@ defmodule CanneryWeb.Components.PackTableComponent do
           }
         } = socket
       ) do
-    lot_number_used = packs |> Enum.any?(fn %{lot_number: lot_number} -> !!lot_number end)
-    price_paid_used = packs |> Enum.any?(fn %{price_paid: price_paid} -> !!price_paid end)
-
    columns =
      []
      |> TableComponent.maybe_compose_columns(
@ -80,18 +77,8 @@ defmodule CanneryWeb.Components.PackTableComponent do
        %{label: gettext("Range"), key: :range},
        range != []
      )
-      |> TableComponent.maybe_compose_columns(
-        %{label: gettext("Lot number"), key: :lot_number},
-        lot_number_used
-      )
-      |> TableComponent.maybe_compose_columns(
-        %{label: gettext("CPR"), key: :cpr},
-        price_paid_used
-      )
-      |> TableComponent.maybe_compose_columns(
-        %{label: gettext("Price paid"), key: :price_paid},
-        price_paid_used
-      )
+      |> TableComponent.maybe_compose_columns(%{label: gettext("CPR"), key: :cpr})
+      |> TableComponent.maybe_compose_columns(%{label: gettext("Price paid"), key: :price_paid})
      |> TableComponent.maybe_compose_columns(
        %{label: gettext("% left"), key: :remaining},
        show_used
@ -141,12 +128,7 @@ defmodule CanneryWeb.Components.PackTableComponent do
  def render(assigns) do
    ~H"""
    <div id={@id} class="w-full">
-      <.live_component
-        module={TableComponent}
-        id={"pack-table-#{@id}"}
-        columns={@columns}
-        rows={@rows}
-      />
+      <.live_component module={TableComponent} id={"table-#{@id}"} columns={@columns} rows={@rows} />
    </div>
    """
  end
--- a/lib/cannery_web/components/shot_record_table_component.ex
+++ b/lib/cannery_web/components/shot_record_table_component.ex
@ -74,7 +74,7 @@ defmodule CanneryWeb.Components.ShotRecordTableComponent do
    <div id={@id} class="w-full">
      <.live_component
        module={CanneryWeb.Components.TableComponent}
-        id={"shot-record-table-#{@id}"}
+        id={"table-#{@id}"}
        columns={@columns}
        rows={@rows}
        initial_key={:date}
@ -98,7 +98,7 @@ defmodule CanneryWeb.Components.ShotRecordTableComponent do

    {pack.type.name,
     ~H"""
-     <.link navigate={~p"/ammo/show/#{@pack}"} class="link">
+     <.link navigate={Routes.pack_show_path(Endpoint, :show, @pack)} class="link">
       <%= @pack.type.name %>
     </.link>
     """}
--- a/lib/cannery_web/components/type_table_component.ex
+++ b/lib/cannery_web/components/type_table_component.ex
@ -55,6 +55,7 @@ defmodule CanneryWeb.Components.TypeTableComponent do
        %{label: gettext("Unfired shell length"), key: :unfired_length, type: :string},
        %{label: gettext("Brass height"), key: :brass_height, type: :string},
        %{label: gettext("Chamber size"), key: :chamber_size, type: :string},
+        %{label: gettext("Chamber size"), key: :chamber_size, type: :string},
        %{label: gettext("Grains"), key: :grains, type: :string},
        %{label: gettext("Bullet type"), key: :bullet_type, type: :string},
        %{
@ -151,25 +152,17 @@ defmodule CanneryWeb.Components.TypeTableComponent do
      )
      |> TableComponent.maybe_compose_columns(%{label: gettext("Name"), key: :name, type: :name})

-    round_counts = Ammo.get_grouped_round_count(current_user, types: types, group_by: :type_id)
-    packs_count = Ammo.get_grouped_packs_count(current_user, types: types, group_by: :type_id)
-    average_costs = Ammo.get_average_costs(types, current_user)
+    round_counts = types |> Ammo.get_round_count_for_types(current_user)
+    packs_count = types |> Ammo.get_packs_count_for_types(current_user)
+    average_costs = types |> Ammo.get_average_cost_for_types(current_user)

    [used_counts, historical_round_counts, historical_pack_counts, used_pack_counts] =
      if show_used do
        [
-          ActivityLog.get_grouped_used_counts(current_user, types: types, group_by: :type_id),
-          Ammo.get_historical_counts(types, current_user),
-          Ammo.get_grouped_packs_count(current_user,
-            types: types,
-            group_by: :type_id,
-            show_used: true
-          ),
-          Ammo.get_grouped_packs_count(current_user,
-            types: types,
-            group_by: :type_id,
-            show_used: :only_used
-          )
+          types |> ActivityLog.get_used_count_for_types(current_user),
+          types |> Ammo.get_historical_count_for_types(current_user),
+          types |> Ammo.get_packs_count_for_types(current_user, true),
+          types |> Ammo.get_used_packs_count_for_types(current_user)
        ]
      else
        [nil, nil, nil, nil]
@ -200,12 +193,7 @@ defmodule CanneryWeb.Components.TypeTableComponent do
  def render(assigns) do
    ~H"""
    <div id={@id} class="w-full">
-      <.live_component
-        module={TableComponent}
-        id={"type-table-#{@id}"}
-        columns={@columns}
-        rows={@rows}
-      />
+      <.live_component module={TableComponent} id={"table-#{@id}"} columns={@columns} rows={@rows} />
    </div>
    """
  end
@ -274,11 +262,13 @@ defmodule CanneryWeb.Components.TypeTableComponent do
    end
  end

-  defp get_type_value(:name, _key, %{name: type_name} = assigns, _other_data) do
+  defp get_type_value(:name, _key, %{name: type_name} = type, _other_data) do
+    assigns = %{type: type}
+
    {type_name,
     ~H"""
-     <.link navigate={~p"/type/#{@id}"} class="link">
-       <%= @name %>
+     <.link navigate={Routes.type_show_path(Endpoint, :show, @type)} class="link">
+       <%= @type.name %>
     </.link>
     """}
  end
--- a/lib/cannery_web/controllers/email_controller.ex
+++ b/lib/cannery_web/controllers/email_controller.ex
@ -6,8 +6,7 @@ defmodule CanneryWeb.EmailController do
  use CanneryWeb, :controller
  alias Cannery.Accounts.User

-  plug :put_root_layout, html: {CanneryWeb.Layouts, :email_html}
-  plug :put_layout, false
+  plug :put_layout, {CanneryWeb.LayoutView, :email}

  @sample_assigns %{
    email: %{subject: "Example subject"},
@ -19,6 +18,6 @@ defmodule CanneryWeb.EmailController do
  Debug route used to preview emails
  """
  def preview(conn, %{"id" => template}) do
-    render(conn, String.to_existing_atom(template), @sample_assigns)
+    render(conn, "#{template |> to_string()}.html", @sample_assigns)
  end
 end
--- a/lib/cannery_web/controllers/error_html.ex
+++ b/lib/cannery_web/controllers/error_html.ex
@ -1,16 +0,0 @@
-defmodule CanneryWeb.ErrorHTML do
-  use CanneryWeb, :html
-
-  embed_templates "error_html/*"
-
-  def render(template, _assigns) do
-    error_string =
-      case template do
-        "404.html" -> dgettext("errors", "Not found")
-        "401.html" -> dgettext("errors", "Unauthorized")
-        _other_path -> dgettext("errors", "Internal server error")
-      end
-
-    error(%{error_string: error_string})
-  end
-end
--- a/lib/cannery_web/controllers/error_json.ex
+++ b/lib/cannery_web/controllers/error_json.ex
@ -1,14 +0,0 @@
-defmodule CanneryWeb.ErrorJSON do
-  use Gettext, backend: CanneryWeb.Gettext
-
-  def render(template, _assigns) do
-    error_string =
-      case template do
-        "404.json" -> dgettext("errors", "Not found")
-        "401.json" -> dgettext("errors", "Unauthorized")
-        _other_path -> dgettext("errors", "Internal server error")
-      end
-
-    %{errors: %{detail: error_string}}
-  end
-end
--- a/lib/cannery_web/controllers/export_controller.ex
+++ b/lib/cannery_web/controllers/export_controller.ex
@ -3,22 +3,14 @@ defmodule CanneryWeb.ExportController do
  alias Cannery.{ActivityLog, Ammo, Containers}

  def export(%{assigns: %{current_user: current_user}} = conn, %{"mode" => "json"}) do
-    types = Ammo.list_types(current_user)
+    types = Ammo.list_types(current_user, :all)
+    used_counts = types |> ActivityLog.get_used_count_for_types(current_user)
+    round_counts = types |> Ammo.get_round_count_for_types(current_user)
+    pack_counts = types |> Ammo.get_packs_count_for_types(current_user)

-    used_counts =
-      ActivityLog.get_grouped_used_counts(current_user, types: types, group_by: :type_id)
+    total_pack_counts = types |> Ammo.get_packs_count_for_types(current_user, true)

-    round_counts = Ammo.get_grouped_round_count(current_user, types: types, group_by: :type_id)
-    pack_counts = Ammo.get_grouped_packs_count(current_user, types: types, group_by: :type_id)
-
-    total_pack_counts =
-      Ammo.get_grouped_packs_count(current_user,
-        types: types,
-        group_by: :type_id,
-        show_used: true
-      )
-
-    average_costs = Ammo.get_average_costs(types, current_user)
+    average_costs = types |> Ammo.get_average_cost_for_types(current_user)

    types =
      types
@ -35,11 +27,8 @@ defmodule CanneryWeb.ExportController do
        })
      end)

-    packs = Ammo.list_packs(current_user, show_used: true)
-
-    used_counts =
-      ActivityLog.get_grouped_used_counts(current_user, packs: packs, group_by: :pack_id)
-
+    packs = Ammo.list_packs(nil, :all, current_user, true)
+    used_counts = packs |> ActivityLog.get_used_counts(current_user)
    original_counts = packs |> Ammo.get_original_counts(current_user)
    cprs = packs |> Ammo.get_cprs(current_user)
    percentages_remaining = packs |> Ammo.get_percentages_remaining(current_user)
@ -58,17 +47,20 @@ defmodule CanneryWeb.ExportController do
        })
      end)

-    shot_records = ActivityLog.list_shot_records(current_user)
+    shot_records = ActivityLog.list_shot_records(:all, current_user)

    containers =
      Containers.list_containers(current_user)
      |> Enum.map(fn container ->
+        pack_count = container |> Ammo.get_packs_count_for_container!(current_user)
+        round_count = container |> Ammo.get_round_count_for_container!(current_user)
+
        container
        |> Jason.encode!()
        |> Jason.decode!()
        |> Map.merge(%{
-          "pack_count" => Ammo.get_packs_count(current_user, container_id: container.id),
-          "round_count" => Ammo.get_round_count(current_user, container_id: container.id)
+          "pack_count" => pack_count,
+          "round_count" => round_count
        })
      end)

--- a/lib/cannery_web/controllers/home_controller.ex
+++ b/lib/cannery_web/controllers/home_controller.ex
@ -0,0 +1,11 @@
+defmodule CanneryWeb.HomeController do
+  @moduledoc """
+  Controller for home page
+  """
+
+  use CanneryWeb, :controller
+
+  def index(conn, _params) do
+    render(conn, "index.html")
+  end
+end
--- a/lib/cannery_web/controllers/home_html.ex
+++ b/lib/cannery_web/controllers/home_html.ex
@ -1,5 +0,0 @@
-defmodule CanneryWeb.HomeHTML do
-  use CanneryWeb, :html
-
-  embed_templates "home_html/*"
-end
--- a/lib/cannery_web/controllers/user_auth.ex
+++ b/lib/cannery_web/controllers/user_auth.ex
@ -3,11 +3,12 @@ defmodule CanneryWeb.UserAuth do
  Functions for user session and authentication
  """

-  use CanneryWeb, :verified_routes
-  use Gettext, backend: CanneryWeb.Gettext
  import Plug.Conn
  import Phoenix.Controller
+  import CanneryWeb.Gettext
  alias Cannery.{Accounts, Accounts.User}
+  alias CanneryWeb.HomeLive
+  alias CanneryWeb.Router.Helpers, as: Routes

  # Make the remember me cookie valid for 60 days.
  # If you want bump or reduce this value, also change
@ -38,7 +39,7 @@ defmodule CanneryWeb.UserAuth do
      dgettext("errors", "You must confirm your account and log in to access this page.")
    )
    |> maybe_store_return_to()
-    |> redirect(to: ~p"/users/log_in")
+    |> redirect(to: Routes.user_session_path(conn, :new))
    |> halt()
  end

@ -48,7 +49,8 @@ defmodule CanneryWeb.UserAuth do

    conn
    |> renew_session()
-    |> put_token_in_session(token)
+    |> put_session(:user_token, token)
+    |> put_session(:live_socket_id, "users_sessions:#{Base.url_encode64(token)}")
    |> maybe_write_remember_me_cookie(token, params)
    |> redirect(to: user_return_to || signed_in_path(conn))
  end
@ -94,7 +96,7 @@ defmodule CanneryWeb.UserAuth do
  """
  def log_out_user(conn) do
    user_token = get_session(conn, :user_token)
-    user_token && Accounts.delete_user_session_token(user_token)
+    user_token && Accounts.delete_session_token(user_token)

    if live_socket_id = get_session(conn, :live_socket_id) do
      CanneryWeb.Endpoint.broadcast(live_socket_id, "disconnect", %{})
@ -103,7 +105,7 @@ defmodule CanneryWeb.UserAuth do
    conn
    |> renew_session()
    |> delete_resp_cookie(@remember_me_cookie)
-    |> redirect(to: ~p"/")
+    |> redirect(to: "/")
  end

  @doc """
@ -117,110 +119,19 @@ defmodule CanneryWeb.UserAuth do
  end

  defp ensure_user_token(conn) do
-    if token = get_session(conn, :user_token) do
-      {token, conn}
+    if user_token = get_session(conn, :user_token) do
+      {user_token, conn}
    else
      conn = fetch_cookies(conn, signed: [@remember_me_cookie])

-      if token = conn.cookies[@remember_me_cookie] do
-        {token, put_token_in_session(conn, token)}
+      if user_token = conn.cookies[@remember_me_cookie] do
+        {user_token, put_session(conn, :user_token, user_token)}
      else
        {nil, conn}
      end
    end
  end

-  @doc """
-  Handles mounting and authenticating the current_user in LiveViews.
-
-  ## `on_mount` arguments
-
-    * `:mount_current_user` - Assigns current_user
-      to socket assigns based on user_token, or nil if
-      there's no user_token or no matching user.
-
-    * `:ensure_authenticated` - Authenticates the user from the session,
-      and assigns the current_user to socket assigns based
-      on user_token.
-      Redirects to login page if there's no logged user.
-
-    * `:redirect_if_user_is_authenticated` - Authenticates the user from the session.
-      Redirects to signed_in_path if there's a logged user.
-
-  ## Examples
-
-  Use the `on_mount` lifecycle macro in LiveViews to mount or authenticate
-  the current_user:
-
-      defmodule CanneryWeb.PageLive do
-        use CanneryWeb, :live_view
-
-        on_mount {CanneryWeb.UserAuth, :mount_current_user}
-        ...
-      end
-
-  Or use the `live_session` of your router to invoke the on_mount callback:
-
-      live_session :authenticated, on_mount: [{CanneryWeb.UserAuth, :ensure_authenticated}] do
-        live "/profile", ProfileLive, :index
-      end
-  """
-  def on_mount(:mount_current_user, _params, session, socket) do
-    {:cont, mount_current_user(session, socket)}
-  end
-
-  def on_mount(:ensure_authenticated, _params, session, socket) do
-    socket = mount_current_user(session, socket)
-
-    if socket.assigns.current_user do
-      {:cont, socket}
-    else
-      error_flash = dgettext("errors", "You must log in to access this page.")
-
-      socket =
-        socket
-        |> Phoenix.LiveView.put_flash(:error, error_flash)
-        |> Phoenix.LiveView.redirect(to: ~p"/users/log_in")
-
-      {:halt, socket}
-    end
-  end
-
-  def on_mount(:ensure_admin, _params, session, socket) do
-    socket = mount_current_user(session, socket)
-
-    if socket.assigns.current_user && socket.assigns.current_user.role == :admin do
-      {:cont, socket}
-    else
-      error_flash = dgettext("errors", "You must log in as an administrator to access this page.")
-
-      socket =
-        socket
-        |> Phoenix.LiveView.put_flash(:error, error_flash)
-        |> Phoenix.LiveView.redirect(to: ~p"/users/log_in")
-
-      {:halt, socket}
-    end
-  end
-
-  def on_mount(:redirect_if_user_is_authenticated, _params, session, socket) do
-    socket = mount_current_user(session, socket)
-
-    if socket.assigns.current_user do
-      {:halt, Phoenix.LiveView.redirect(socket, to: signed_in_path(socket))}
-    else
-      {:cont, socket}
-    end
-  end
-
-  defp mount_current_user(session, socket) do
-    Phoenix.Component.assign_new(socket, :current_user, fn ->
-      if user_token = session["user_token"] do
-        Accounts.get_user_by_session_token(user_token)
-      end
-    end)
-  end
-
  @doc """
  Used for routes that require the user to not be authenticated.
  """
@ -250,7 +161,7 @@ defmodule CanneryWeb.UserAuth do
        dgettext("errors", "You must confirm your account and log in to access this page.")
      )
      |> maybe_store_return_to()
-      |> redirect(to: ~p"/users/log_in")
+      |> redirect(to: Routes.user_session_path(conn, :new))
      |> halt()
    end
  end
@ -265,34 +176,16 @@ defmodule CanneryWeb.UserAuth do
      conn
      |> put_flash(:error, dgettext("errors", "You are not authorized to view this page."))
      |> maybe_store_return_to()
-      |> redirect(to: ~p"/")
+      |> redirect(to: Routes.live_path(conn, HomeLive))
      |> halt()
    end
  end

-  def put_user_locale(%{assigns: %{current_user: %{locale: locale}}} = conn, _opts) do
-    default = Application.fetch_env!(:gettext, :default_locale)
-    Gettext.put_locale(locale || default)
-    conn |> put_session(:locale, locale || default)
-  end
-
-  def put_user_locale(conn, _opts) do
-    default = Application.fetch_env!(:gettext, :default_locale)
-    Gettext.put_locale(default)
-    conn |> put_session(:locale, default)
-  end
-
-  defp put_token_in_session(conn, token) do
-    conn
-    |> put_session(:user_token, token)
-    |> put_session(:live_socket_id, "users_sessions:#{Base.url_encode64(token)}")
-  end
-
  defp maybe_store_return_to(%{method: "GET"} = conn) do
    put_session(conn, :user_return_to, current_path(conn))
  end

  defp maybe_store_return_to(conn), do: conn

-  defp signed_in_path(_conn), do: ~p"/"
+  defp signed_in_path(_conn), do: "/"
 end
--- a/lib/cannery_web/controllers/user_confirmation_controller.ex
+++ b/lib/cannery_web/controllers/user_confirmation_controller.ex
@ -1,16 +1,18 @@
 defmodule CanneryWeb.UserConfirmationController do
  use CanneryWeb, :controller
+
+  import CanneryWeb.Gettext
  alias Cannery.Accounts

  def new(conn, _params) do
-    render(conn, :new, page_title: gettext("Confirm your account"))
+    render(conn, "new.html", page_title: gettext("Confirm your account"))
  end

  def create(conn, %{"user" => %{"email" => email}}) do
    if user = Accounts.get_user_by_email(email) do
      Accounts.deliver_user_confirmation_instructions(
        user,
-        fn token -> url(CanneryWeb.Endpoint, ~p"/users/confirm/#{token}") end
+        &Routes.user_confirmation_url(conn, :confirm, &1)
      )
    end

@ -20,10 +22,11 @@ defmodule CanneryWeb.UserConfirmationController do
      :info,
      dgettext(
        "prompts",
-        "If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly."
+        "If your email is in our system and it has not been confirmed yet, " <>
+          "you will receive an email with instructions shortly."
      )
    )
-    |> redirect(to: ~p"/")
+    |> redirect(to: "/")
  end

  # Do not log in the user after confirmation to avoid a
@ -33,7 +36,7 @@ defmodule CanneryWeb.UserConfirmationController do
      {:ok, %{email: email}} ->
        conn
        |> put_flash(:info, dgettext("prompts", "%{email} confirmed successfully.", email: email))
-        |> redirect(to: ~p"/")
+        |> redirect(to: "/")

      :error ->
        # If there is a current user and the account was already confirmed,
@ -42,7 +45,7 @@ defmodule CanneryWeb.UserConfirmationController do
        # a warning message.
        case conn.assigns do
          %{current_user: %{confirmed_at: confirmed_at}} when not is_nil(confirmed_at) ->
-            redirect(conn, to: ~p"/")
+            redirect(conn, to: "/")

          %{} ->
            conn
@ -50,7 +53,7 @@ defmodule CanneryWeb.UserConfirmationController do
              :error,
              dgettext("errors", "User confirmation link is invalid or it has expired.")
            )
-            |> redirect(to: ~p"/")
+            |> redirect(to: "/")
        end
    end
  end
--- a/lib/cannery_web/controllers/user_confirmation_html.ex
+++ b/lib/cannery_web/controllers/user_confirmation_html.ex
@ -1,6 +0,0 @@
-defmodule CanneryWeb.UserConfirmationHTML do
-  use CanneryWeb, :html
-  alias Cannery.Accounts
-
-  embed_templates "user_confirmation_html/*"
-end
--- a/lib/cannery_web/controllers/user_registration_controller.ex
+++ b/lib/cannery_web/controllers/user_registration_controller.ex
@ -1,6 +1,8 @@
 defmodule CanneryWeb.UserRegistrationController do
  use CanneryWeb, :controller
+  import CanneryWeb.Gettext
  alias Cannery.{Accounts, Accounts.Invites}
+  alias CanneryWeb.{Endpoint, HomeLive}
  alias Ecto.Changeset

  def new(conn, %{"invite" => invite_token}) do
@ -9,7 +11,7 @@ defmodule CanneryWeb.UserRegistrationController do
    else
      conn
      |> put_flash(:error, dgettext("errors", "Sorry, this invite was not found or expired"))
-      |> redirect(to: ~p"/")
+      |> redirect(to: Routes.live_path(Endpoint, HomeLive))
    end
  end

@ -19,13 +21,13 @@ defmodule CanneryWeb.UserRegistrationController do
    else
      conn
      |> put_flash(:error, dgettext("errors", "Sorry, public registration is disabled"))
-      |> redirect(to: ~p"/")
+      |> redirect(to: Routes.live_path(Endpoint, HomeLive))
    end
  end

  # renders new user registration page
  defp render_new(conn, invite_token \\ nil) do
-    render(conn, :new,
+    render(conn, "new.html",
      changeset: Accounts.change_user_registration(),
      invite_token: invite_token,
      page_title: gettext("Register")
@ -38,7 +40,7 @@ defmodule CanneryWeb.UserRegistrationController do
    else
      conn
      |> put_flash(:error, dgettext("errors", "Sorry, this invite was not found or expired"))
-      |> redirect(to: ~p"/")
+      |> redirect(to: Routes.live_path(Endpoint, HomeLive))
    end
  end

@ -48,7 +50,7 @@ defmodule CanneryWeb.UserRegistrationController do
    else
      conn
      |> put_flash(:error, dgettext("errors", "Sorry, public registration is disabled"))
-      |> redirect(to: ~p"/")
+      |> redirect(to: Routes.live_path(Endpoint, HomeLive))
    end
  end

@ -57,20 +59,20 @@ defmodule CanneryWeb.UserRegistrationController do
      {:ok, user} ->
        Accounts.deliver_user_confirmation_instructions(
          user,
-          fn token -> url(CanneryWeb.Endpoint, ~p"/users/confirm/#{token}") end
+          &Routes.user_confirmation_url(conn, :confirm, &1)
        )

        conn
        |> put_flash(:info, dgettext("prompts", "Please check your email to verify your account"))
-        |> redirect(to: ~p"/users/log_in")
+        |> redirect(to: Routes.user_session_path(Endpoint, :new))

      {:error, :invalid_token} ->
        conn
        |> put_flash(:error, dgettext("errors", "Sorry, this invite was not found or expired"))
-        |> redirect(to: ~p"/")
+        |> redirect(to: Routes.live_path(Endpoint, HomeLive))

      {:error, %Changeset{} = changeset} ->
-        conn |> render(:new, changeset: changeset, invite_token: invite_token)
+        conn |> render("new.html", changeset: changeset, invite_token: invite_token)
    end
  end
 end
--- a/lib/cannery_web/controllers/user_registration_html.ex
+++ b/lib/cannery_web/controllers/user_registration_html.ex
@ -1,5 +0,0 @@
-defmodule CanneryWeb.UserRegistrationHTML do
-  use CanneryWeb, :html
-
-  embed_templates "user_registration_html/*"
-end
--- a/lib/cannery_web/controllers/user_reset_password_controller.ex
+++ b/lib/cannery_web/controllers/user_reset_password_controller.ex
@ -6,14 +6,14 @@ defmodule CanneryWeb.UserResetPasswordController do
  plug :get_user_by_reset_password_token when action in [:edit, :update]

  def new(conn, _params) do
-    render(conn, :new, page_title: gettext("Forgot your password?"))
+    render(conn, "new.html", page_title: gettext("Forgot your password?"))
  end

  def create(conn, %{"user" => %{"email" => email}}) do
    if user = Accounts.get_user_by_email(email) do
      Accounts.deliver_user_reset_password_instructions(
        user,
-        fn token -> url(CanneryWeb.Endpoint, ~p"/users/reset_password/#{token}") end
+        &Routes.user_reset_password_url(conn, :edit, &1)
      )
    end

@ -23,14 +23,15 @@ defmodule CanneryWeb.UserResetPasswordController do
      :info,
      dgettext(
        "prompts",
-        "If your email is in our system, you will receive instructions to reset your password shortly."
+        "If your email is in our system, you will receive instructions to " <>
+          "reset your password shortly."
      )
    )
-    |> redirect(to: ~p"/")
+    |> redirect(to: "/")
  end

  def edit(conn, _params) do
-    render(conn, :edit,
+    render(conn, "edit.html",
      changeset: Accounts.change_user_password(conn.assigns.user),
      page_title: gettext("Reset your password")
    )
@ -43,10 +44,10 @@ defmodule CanneryWeb.UserResetPasswordController do
      {:ok, _} ->
        conn
        |> put_flash(:info, dgettext("prompts", "Password reset successfully."))
-        |> redirect(to: ~p"/users/log_in")
+        |> redirect(to: Routes.user_session_path(conn, :new))

      {:error, changeset} ->
-        render(conn, :edit, changeset: changeset)
+        render(conn, "edit.html", changeset: changeset)
    end
  end

@ -61,7 +62,7 @@ defmodule CanneryWeb.UserResetPasswordController do
        :error,
        dgettext("errors", "Reset password link is invalid or it has expired.")
      )
-      |> redirect(to: ~p"/")
+      |> redirect(to: "/")
      |> halt()
    end
  end
--- a/lib/cannery_web/controllers/user_reset_password_html.ex
+++ b/lib/cannery_web/controllers/user_reset_password_html.ex
@ -1,6 +0,0 @@
-defmodule CanneryWeb.UserResetPasswordHTML do
-  use CanneryWeb, :html
-  alias Cannery.Accounts
-
-  embed_templates "user_reset_password_html/*"
-end
--- a/lib/cannery_web/controllers/user_session_controller.ex
+++ b/lib/cannery_web/controllers/user_session_controller.ex
@ -5,7 +5,7 @@ defmodule CanneryWeb.UserSessionController do
  alias CanneryWeb.UserAuth

  def new(conn, _params) do
-    render(conn, :new, error_message: nil, page_title: gettext("Log in"))
+    render(conn, "new.html", error_message: nil, page_title: gettext("Log in"))
  end

  def create(conn, %{"user" => user_params}) do
@ -14,7 +14,7 @@ defmodule CanneryWeb.UserSessionController do
    if user = Accounts.get_user_by_email_and_password(email, password) do
      UserAuth.log_in_user(conn, user, user_params)
    else
-      render(conn, :new, error_message: dgettext("errors", "Invalid email or password"))
+      render(conn, "new.html", error_message: dgettext("errors", "Invalid email or password"))
    end
  end

--- a/lib/cannery_web/controllers/user_session_html.ex
+++ b/lib/cannery_web/controllers/user_session_html.ex
@ -1,6 +0,0 @@
-defmodule CanneryWeb.UserSessionHTML do
-  use CanneryWeb, :html
-  alias Cannery.Accounts
-
-  embed_templates "user_session_html/*"
-end
--- a/lib/cannery_web/controllers/user_settings_controller.ex
+++ b/lib/cannery_web/controllers/user_settings_controller.ex
@ -1,12 +1,13 @@
 defmodule CanneryWeb.UserSettingsController do
  use CanneryWeb, :controller
+  import CanneryWeb.Gettext
  alias Cannery.Accounts
-  alias CanneryWeb.UserAuth
+  alias CanneryWeb.{HomeLive, UserAuth}

  plug :assign_email_and_password_changesets

  def edit(conn, _params) do
-    render(conn, :edit, page_title: gettext("Settings"))
+    render(conn, "edit.html", page_title: gettext("Settings"))
  end

  def update(%{assigns: %{current_user: user}} = conn, %{
@ -19,7 +20,7 @@ defmodule CanneryWeb.UserSettingsController do
        Accounts.deliver_update_email_instructions(
          applied_user,
          user.email,
-          fn token -> url(CanneryWeb.Endpoint, ~p"/users/settings/confirm_email/#{token}") end
+          &Routes.user_settings_url(conn, :confirm_email, &1)
        )

        conn
@ -30,10 +31,10 @@ defmodule CanneryWeb.UserSettingsController do
            "A link to confirm your email change has been sent to the new address."
          )
        )
-        |> redirect(to: ~p"/users/settings")
+        |> redirect(to: Routes.user_settings_path(conn, :edit))

      {:error, changeset} ->
-        conn |> render(:edit, email_changeset: changeset)
+        conn |> render("edit.html", email_changeset: changeset)
    end
  end

@ -46,11 +47,11 @@ defmodule CanneryWeb.UserSettingsController do
      {:ok, user} ->
        conn
        |> put_flash(:info, dgettext("prompts", "Password updated successfully."))
-        |> put_session(:user_return_to, ~p"/users/settings")
+        |> put_session(:user_return_to, Routes.user_settings_path(conn, :edit))
        |> UserAuth.log_in_user(user)

      {:error, changeset} ->
-        conn |> render(:edit, password_changeset: changeset)
+        conn |> render("edit.html", password_changeset: changeset)
    end
  end

@ -62,10 +63,10 @@ defmodule CanneryWeb.UserSettingsController do
      {:ok, _user} ->
        conn
        |> put_flash(:info, dgettext("prompts", "Language updated successfully."))
-        |> redirect(to: ~p"/users/settings")
+        |> redirect(to: Routes.user_settings_path(conn, :edit))

      {:error, changeset} ->
-        conn |> render(:edit, locale_changeset: changeset)
+        conn |> render("edit.html", locale_changeset: changeset)
    end
  end

@ -74,7 +75,7 @@ defmodule CanneryWeb.UserSettingsController do
      :ok ->
        conn
        |> put_flash(:info, dgettext("prompts", "Email changed successfully."))
-        |> redirect(to: ~p"/users/settings")
+        |> redirect(to: Routes.user_settings_path(conn, :edit))

      :error ->
        conn
@ -82,7 +83,7 @@ defmodule CanneryWeb.UserSettingsController do
          :error,
          dgettext("errors", "Email change link is invalid or it has expired.")
        )
-        |> redirect(to: ~p"/users/settings")
+        |> redirect(to: Routes.user_settings_path(conn, :edit))
    end
  end

@ -92,11 +93,11 @@ defmodule CanneryWeb.UserSettingsController do

      conn
      |> put_flash(:error, dgettext("prompts", "Your account has been deleted"))
-      |> redirect(to: ~p"/")
+      |> redirect(to: Routes.live_path(conn, HomeLive))
    else
      conn
      |> put_flash(:error, dgettext("errors", "Unable to delete user"))
-      |> redirect(to: ~p"/users/settings")
+      |> redirect(to: Routes.user_settings_path(conn, :edit))
    end
  end

--- a/lib/cannery_web/controllers/user_settings_html.ex
+++ b/lib/cannery_web/controllers/user_settings_html.ex
@ -1,5 +0,0 @@
-defmodule CanneryWeb.UserSettingsHTML do
-  use CanneryWeb, :html
-
-  embed_templates "user_settings_html/*"
-end
--- a/lib/cannery_web/endpoint.ex
+++ b/lib/cannery_web/endpoint.ex
@ -20,7 +20,7 @@ defmodule CanneryWeb.Endpoint do
    at: "/",
    from: :cannery,
    gzip: false,
-    only: CanneryWeb.static_paths()
+    only: ~w(css fonts images js favicon.ico robots.txt)

  # Code reloading can be explicitly enabled under the
  # :code_reloader configuration of your endpoint.
--- a/lib/cannery_web/gettext.ex
+++ b/lib/cannery_web/gettext.ex
@ -5,7 +5,7 @@ defmodule CanneryWeb.Gettext do
  By using [Gettext](https://hexdocs.pm/gettext),
  your module gains a set of macros for translations, for example:

-      use Gettext, backend: CanneryWeb.Gettext
+      import CanneryWeb.Gettext

      # Simple translation
      gettext("Here is the string to translate")
@ -20,5 +20,5 @@ defmodule CanneryWeb.Gettext do

  See the [Gettext Docs](https://hexdocs.pm/gettext) for detailed usage.
  """
-  use Gettext.Backend, otp_app: :cannery
+  use Gettext, otp_app: :cannery
 end
--- a/lib/cannery_web/live/container_live/edit_tags_component.html.heex
+++ b/lib/cannery_web/live/container_live/edit_tags_component.html.heex
@ -44,9 +44,7 @@
      phx-submit="save"
    >
      <%= select(f, :tag_id, tag_options(@tags, @container),
-        class: "text-center col-span-2 input input-primary",
-        id: "#{@id}-tag-select",
-        phx_hook: "SlimSelect"
+        class: "text-center col-span-2 input input-primary"
      ) %>
      <%= error_tag(f, :tag_id, "col-span-3 text-center") %>

--- a/lib/cannery_web/live/container_live/form_component.ex
+++ b/lib/cannery_web/live/container_live/form_component.ex
@ -19,7 +19,7 @@ defmodule CanneryWeb.ContainerLive.FormComponent do

  @impl true
  def handle_event("validate", %{"container" => container_params}, socket) do
-    {:noreply, socket |> assign_changeset(container_params, :validate)}
+    {:noreply, socket |> assign_changeset(container_params)}
  end

  def handle_event(
@ -32,9 +32,14 @@ defmodule CanneryWeb.ContainerLive.FormComponent do

  defp assign_changeset(
         %{assigns: %{action: action, container: container, current_user: user}} = socket,
-         container_params,
-         changeset_action \\ nil
+         container_params
       ) do
+    changeset_action =
+      case action do
+        create when create in [:new, :clone] -> :insert
+        :edit -> :update
+      end
+
    changeset =
      case action do
        create when create in [:new, :clone] ->
@ -45,13 +50,9 @@ defmodule CanneryWeb.ContainerLive.FormComponent do
      end

    changeset =
-      if changeset_action do
-        case changeset |> Changeset.apply_action(changeset_action) do
-          {:ok, _data} -> changeset
-          {:error, changeset} -> changeset
-        end
-      else
-        changeset
+      case changeset |> Changeset.apply_action(changeset_action) do
+        {:ok, _data} -> changeset
+        {:error, changeset} -> changeset
      end

    socket |> assign(:changeset, changeset)
--- a/lib/cannery_web/live/container_live/form_component.html.heex
+++ b/lib/cannery_web/live/container_live/form_component.html.heex
@ -12,7 +12,7 @@
    phx-submit="save"
  >
    <div
-      :if={@changeset.action && not @changeset.valid?}
+      :if={@changeset.action && not @changeset.valid?()}
      class="invalid-feedback col-span-3 text-center"
    >
      <%= changeset_errors(@changeset) %>
@ -21,38 +21,36 @@
    <%= label(f, :name, gettext("Name"), class: "title text-lg text-primary-600") %>
    <%= text_input(f, :name,
      class: "input input-primary col-span-2",
-      maxlength: 255,
-      phx_debounce: 300,
-      placeholder: gettext("My cool ammo can")
+      placeholder: gettext("My cool ammo can"),
+      maxlength: 255
    ) %>
    <%= error_tag(f, :name, "col-span-3 text-center") %>

    <%= label(f, :desc, gettext("Description"), class: "title text-lg text-primary-600") %>
    <%= textarea(f, :desc,
-      class: "input input-primary col-span-2",
      id: "container-form-desc",
-      phx_debounce: 300,
-      phx_update: "ignore",
-      placeholder: gettext("Metal ammo can with the anime girl sticker")
+      class: "input input-primary col-span-2",
+      placeholder: gettext("Metal ammo can with the anime girl sticker"),
+      phx_hook: "MaintainAttrs",
+      phx_update: "ignore"
    ) %>
    <%= error_tag(f, :desc, "col-span-3 text-center") %>

    <%= label(f, :type, gettext("Type"), class: "title text-lg text-primary-600") %>
    <%= text_input(f, :type,
      class: "input input-primary col-span-2",
-      maxlength: 255,
-      phx_debounce: 300,
-      placeholder: gettext("Magazine, Clip, Ammo Box, etc")
+      placeholder: gettext("Magazine, Clip, Ammo Box, etc"),
+      maxlength: 255
    ) %>
    <%= error_tag(f, :type, "col-span-3 text-center") %>

    <%= label(f, :location, gettext("Location"), class: "title text-lg text-primary-600") %>
    <%= textarea(f, :location,
-      class: "input input-primary col-span-2",
      id: "container-form-location",
-      phx_debounce: 300,
-      phx_update: "ignore",
-      placeholder: gettext("On the bookshelf")
+      class: "input input-primary col-span-2",
+      placeholder: gettext("On the bookshelf"),
+      phx_hook: "MaintainAttrs",
+      phx_update: "ignore"
    ) %>
    <%= error_tag(f, :location, "col-span-3 text-center") %>

--- a/lib/cannery_web/live/container_live/index.ex
+++ b/lib/cannery_web/live/container_live/index.ex
@ -105,14 +105,15 @@ defmodule CanneryWeb.ContainerLive.Index do
  end

  def handle_event("search", %{"search" => %{"search_term" => ""}}, socket) do
-    {:noreply, socket |> push_patch(to: ~p"/containers")}
+    {:noreply, socket |> push_patch(to: Routes.container_index_path(Endpoint, :index))}
  end

  def handle_event("search", %{"search" => %{"search_term" => search_term}}, socket) do
-    {:noreply, socket |> push_patch(to: ~p"/containers/search/#{search_term}")}
+    {:noreply,
+     socket |> push_patch(to: Routes.container_index_path(Endpoint, :search, search_term))}
  end

  defp display_containers(%{assigns: %{search: search, current_user: current_user}} = socket) do
-    socket |> assign(:containers, Containers.list_containers(current_user, search: search))
+    socket |> assign(:containers, Containers.list_containers(search, current_user))
  end
 end
--- a/lib/cannery_web/live/container_live/index.html.heex
+++ b/lib/cannery_web/live/container_live/index.html.heex
@ -9,11 +9,11 @@
      <%= display_emoji("😔") %>
    </h2>

-    <.link patch={~p"/containers/new"} class="btn btn-primary">
+    <.link patch={Routes.container_index_path(Endpoint, :new)} class="btn btn-primary">
      <%= dgettext("actions", "Add your first container!") %>
    </.link>
  <% else %>
-    <.link patch={~p"/containers/new"} class="btn btn-primary">
+    <.link patch={Routes.container_index_path(Endpoint, :new)} class="btn btn-primary">
      <%= dgettext("actions", "New Container") %>
    </.link>

@ -28,10 +28,10 @@
      >
        <%= text_input(f, :search_term,
          class: "grow input input-primary",
-          phx_debounce: 300,
-          placeholder: gettext("Search containers"),
+          value: @search,
          role: "search",
-          value: @search
+          phx_debounce: 300,
+          placeholder: gettext("Search containers")
        ) %>
      </.form>

@ -51,7 +51,7 @@
      <%= if @view_table do %>
        <.live_component
          module={CanneryWeb.Components.ContainerTableComponent}
-          id="containers-index-table"
+          id="containers_index_table"
          action={@live_action}
          containers={@containers}
          current_user={@current_user}
@ -59,7 +59,7 @@
          <:tag_actions :let={container}>
            <div class="mx-4 my-2">
              <.link
-                patch={~p"/containers/edit_tags/#{container}"}
+                patch={Routes.container_index_path(Endpoint, :edit_tags, container)}
                class="text-primary-600 link"
                aria-label={
                  dgettext("actions", "Tag %{container_name}", container_name: container.name)
@ -71,7 +71,7 @@
          </:tag_actions>
          <:actions :let={container}>
            <.link
-              patch={~p"/containers/edit/#{container}"}
+              patch={Routes.container_index_path(Endpoint, :edit, container)}
              class="text-primary-600 link"
              aria-label={
                dgettext("actions", "Edit %{container_name}", container_name: container.name)
@ -81,7 +81,7 @@
            </.link>

            <.link
-              patch={~p"/containers/clone/#{container}"}
+              patch={Routes.container_index_path(Endpoint, :clone, container)}
              class="text-primary-600 link"
              aria-label={
                dgettext("actions", "Clone %{container_name}", container_name: container.name)
@ -118,7 +118,7 @@
            <:tag_actions>
              <div class="mx-4 my-2">
                <.link
-                  patch={~p"/containers/edit_tags/#{container}"}
+                  patch={Routes.container_index_path(Endpoint, :edit_tags, container)}
                  class="text-primary-600 link"
                  aria-label={
                    dgettext("actions", "Tag %{container_name}", container_name: container.name)
@ -129,7 +129,7 @@
              </div>
            </:tag_actions>
            <.link
-              patch={~p"/containers/edit/#{container}"}
+              patch={Routes.container_index_path(Endpoint, :edit, container)}
              class="text-primary-600 link"
              aria-label={
                dgettext("actions", "Edit %{container_name}", container_name: container.name)
@ -139,7 +139,7 @@
            </.link>

            <.link
-              patch={~p"/containers/clone/#{container}"}
+              patch={Routes.container_index_path(Endpoint, :clone, container)}
              class="text-primary-600 link"
              aria-label={
                dgettext("actions", "Clone %{container_name}", container_name: container.name)
@ -173,26 +173,26 @@

 <%= case @live_action do %>
  <% modifying when modifying in [:new, :edit, :clone] -> %>
-    <.modal return_to={~p"/containers"}>
+    <.modal return_to={Routes.container_index_path(Endpoint, :index)}>
      <.live_component
        module={CanneryWeb.ContainerLive.FormComponent}
        id={@container.id || :new}
        title={@page_title}
        action={@live_action}
        container={@container}
-        return_to={~p"/containers"}
+        return_to={Routes.container_index_path(Endpoint, :index)}
        current_user={@current_user}
      />
    </.modal>
  <% :edit_tags -> %>
-    <.modal return_to={~p"/containers"}>
+    <.modal return_to={Routes.container_index_path(Endpoint, :index)}>
      <.live_component
        module={CanneryWeb.ContainerLive.EditTagsComponent}
        id={@container.id}
        title={@page_title}
        action={@live_action}
        container={@container}
-        current_path={~p"/containers/edit_tags/#{@container}"}
+        current_path={Routes.container_index_path(Endpoint, :edit_tags, @container)}
        current_user={@current_user}
      />
    </.modal>
--- a/lib/cannery_web/live/container_live/show.ex
+++ b/lib/cannery_web/live/container_live/show.ex
@ -5,6 +5,7 @@ defmodule CanneryWeb.ContainerLive.Show do

  use CanneryWeb, :live_view
  alias Cannery.{Accounts.User, ActivityLog, Ammo, Containers, Containers.Container}
+  alias CanneryWeb.Endpoint
  alias Ecto.Changeset
  alias Phoenix.LiveView.Socket

@ -58,7 +59,10 @@ defmodule CanneryWeb.ContainerLive.Show do
      |> case do
        {:ok, %{name: container_name}} ->
          prompt = dgettext("prompts", "%{name} has been deleted", name: container_name)
-          socket |> put_flash(:info, prompt) |> push_navigate(to: ~p"/containers")
+
+          socket
+          |> put_flash(:info, prompt)
+          |> push_navigate(to: Routes.container_index_path(socket, :index))

        {:error, %{action: :delete, errors: [packs: _error], valid?: false} = changeset} ->
          packs_error = changeset |> changeset_errors(:packs) |> Enum.join(", ")
@ -104,10 +108,8 @@ defmodule CanneryWeb.ContainerLive.Show do
         id,
         current_user
       ) do
-    %{id: container_id, name: container_name} =
-      container = Containers.get_container!(id, current_user)
-
-    packs = Ammo.list_packs(current_user, container_id: container_id, class: class)
+    %{name: container_name} = container = Containers.get_container!(id, current_user)
+    packs = Ammo.list_packs_for_container(container, class, current_user)
    original_counts = packs |> Ammo.get_original_counts(current_user)
    cprs = packs |> Ammo.get_cprs(current_user)
    last_used_dates = packs |> ActivityLog.get_last_used_dates(current_user)
@ -122,8 +124,8 @@ defmodule CanneryWeb.ContainerLive.Show do
    socket
    |> assign(
      container: container,
-      round_count: Ammo.get_round_count(current_user, container_id: container.id),
-      packs_count: Ammo.get_packs_count(current_user, container_id: container.id),
+      round_count: Ammo.get_round_count_for_container!(container, current_user),
+      packs_count: Ammo.get_packs_count_for_container!(container, current_user),
      packs: packs,
      original_counts: original_counts,
      cprs: cprs,
--- a/lib/cannery_web/live/container_live/show.html.heex
+++ b/lib/cannery_web/live/container_live/show.html.heex
@ -30,7 +30,7 @@

  <div class="flex space-x-4 justify-center items-center text-primary-600">
    <.link
-      patch={~p"/container/edit/#{@container}"}
+      patch={Routes.container_show_path(Endpoint, :edit, @container)}
      class="text-primary-600 link"
      aria-label={dgettext("actions", "Edit %{container_name}", container_name: @container.name)}
    >
@ -61,7 +61,10 @@
        <%= display_emoji("😔") %>
      </h2>

-      <.link patch={~p"/container/edit_tags/#{@container}"} class="btn btn-primary">
+      <.link
+        patch={Routes.container_show_path(Endpoint, :edit_tags, @container)}
+        class="btn btn-primary"
+      >
        <%= dgettext("actions", "Why not add one?") %>
      </.link>
    </div>
@ -70,7 +73,10 @@
      <.simple_tag_card :for={tag <- @container.tags} tag={tag} />

      <div class="mx-4 my-2">
-        <.link patch={~p"/container/edit_tags/#{@container}"} class="text-primary-600 link">
+        <.link
+          patch={Routes.container_show_path(Endpoint, :edit_tags, @container)}
+          class="text-primary-600 link"
+        >
          <i class="fa-fw fa-lg fas fa-tags"></i>
        </.link>
      </div>
@ -120,31 +126,16 @@
      <%= if @view_table do %>
        <.live_component
          module={CanneryWeb.Components.PackTableComponent}
-          id="pack-show-table"
+          id="type-show-table"
          packs={@packs}
          current_user={@current_user}
          show_used={false}
        >
          <:type :let={%{name: type_name} = type}>
-            <.link navigate={~p"/type/#{type}"} class="link">
+            <.link navigate={Routes.type_show_path(Endpoint, :show, type)} class="link">
              <%= type_name %>
            </.link>
          </:type>
-          <:actions :let={%{count: pack_count} = pack}>
-            <div class="py-2 px-4 h-full space-x-4 flex justify-center items-center">
-              <.link
-                navigate={~p"/ammo/show/#{pack}"}
-                class="text-primary-600 link"
-                aria-label={
-                  dgettext("actions", "View pack of %{pack_count} bullets",
-                    pack_count: pack_count
-                  )
-                }
-              >
-                <i class="fa-fw fa-lg fas fa-eye"></i>
-              </.link>
-            </div>
-          </:actions>
        </.live_component>
      <% else %>
        <div class="flex flex-wrap justify-center items-stretch">
@ -164,27 +155,27 @@

 <%= case @live_action do %>
  <% :edit -> %>
-    <.modal return_to={~p"/container/#{@container}"}>
+    <.modal return_to={Routes.container_show_path(Endpoint, :show, @container)}>
      <.live_component
        module={CanneryWeb.ContainerLive.FormComponent}
        id={@container.id}
        title={@page_title}
        action={@live_action}
        container={@container}
-        return_to={~p"/container/#{@container}"}
+        return_to={Routes.container_show_path(Endpoint, :show, @container)}
        current_user={@current_user}
      />
    </.modal>
  <% :edit_tags -> %>
-    <.modal return_to={~p"/container/#{@container}"}>
+    <.modal return_to={Routes.container_show_path(Endpoint, :show, @container)}>
      <.live_component
        module={CanneryWeb.ContainerLive.EditTagsComponent}
        id={@container.id}
        title={@page_title}
        action={@live_action}
        container={@container}
-        return_to={~p"/container/#{@container}"}
-        current_path={~p"/container/edit_tags/#{@container}"}
+        return_to={Routes.container_show_path(Endpoint, :show, @container)}
+        current_path={Routes.container_show_path(Endpoint, :edit_tags, @container)}
        current_user={@current_user}
      />
    </.modal>
--- a/lib/cannery_web/live/home_live.ex
+++ b/lib/cannery_web/live/home_live.ex
@ -5,6 +5,7 @@ defmodule CanneryWeb.HomeLive do

  use CanneryWeb, :live_view
  alias Cannery.Accounts
+  alias CanneryWeb.Endpoint

  @version Mix.Project.config()[:version]

--- a/lib/cannery_web/live/home_live.html.heex
+++ b/lib/cannery_web/live/home_live.html.heex
@ -1,6 +1,6 @@
 <div class="mx-auto px-8 sm:px-16 flex flex-col justify-center items-center text-center space-y-4 max-w-3xl">
  <img
-    src={~p"/images/cannery.svg"}
+    src={Routes.static_path(Endpoint, "/images/cannery.svg")}
    alt={gettext("Cannery logo")}
    class="inline-block w-32 hover:-mt-2 hover:mb-2 transition-all duration-500 ease-in-out"
    title={gettext("isn't he cute >:3")}
@ -59,7 +59,7 @@
      </b>
      <p>
        <%= if @admins |> Enum.empty?() do %>
-          <.link href={~p"/users/register"} class="hover:underline">
+          <.link href={Routes.user_registration_path(Endpoint, :new)} class="hover:underline">
            <%= dgettext("prompts", "Register to setup Cannery") %>
          </.link>
        <% else %>
--- a/lib/cannery_web/live/invite_live/form_component.ex
+++ b/lib/cannery_web/live/invite_live/form_component.ex
@ -19,7 +19,7 @@ defmodule CanneryWeb.InviteLive.FormComponent do

  @impl true
  def handle_event("validate", %{"invite" => invite_params}, socket) do
-    {:noreply, socket |> assign_changeset(invite_params, :validate)}
+    {:noreply, socket |> assign_changeset(invite_params)}
  end

  def handle_event("save", %{"invite" => invite_params}, %{assigns: %{action: action}} = socket) do
@ -28,9 +28,14 @@ defmodule CanneryWeb.InviteLive.FormComponent do

  defp assign_changeset(
         %{assigns: %{action: action, current_user: user, invite: invite}} = socket,
-         invite_params,
-         changeset_action \\ nil
+         invite_params
       ) do
+    changeset_action =
+      case action do
+        :new -> :insert
+        :edit -> :update
+      end
+
    changeset =
      case action do
        :new -> Invite.create_changeset(user, "example_token", invite_params)
@ -38,13 +43,9 @@ defmodule CanneryWeb.InviteLive.FormComponent do
      end

    changeset =
-      if changeset_action do
-        case changeset |> Changeset.apply_action(changeset_action) do
-          {:ok, _data} -> changeset
-          {:error, changeset} -> changeset
-        end
-      else
-        changeset
+      case changeset |> Changeset.apply_action(changeset_action) do
+        {:ok, _data} -> changeset
+        {:error, changeset} -> changeset
      end

    socket |> assign(:changeset, changeset)
--- a/lib/cannery_web/live/invite_live/form_component.html.heex
+++ b/lib/cannery_web/live/invite_live/form_component.html.heex
@ -12,7 +12,7 @@
    phx-submit="save"
  >
    <div
-      :if={@changeset.action && not @changeset.valid?}
+      :if={@changeset.action && not @changeset.valid?()}
      class="invalid-feedback col-span-3 text-center"
    >
      <%= changeset_errors(@changeset) %>
@ -22,10 +22,7 @@
      class: "title text-lg text-primary-600",
      maxlength: 255
    ) %>
-    <%= text_input(f, :name,
-      class: "input input-primary col-span-2",
-      phx_debounce: 300
-    ) %>
+    <%= text_input(f, :name, class: "input input-primary col-span-2") %>
    <%= error_tag(f, :name, "col-span-3") %>

    <%= label(f, :uses_left, gettext("Uses left"), class: "title text-lg text-primary-600") %>
--- a/lib/cannery_web/live/invite_live/index.html.heex
+++ b/lib/cannery_web/live/invite_live/index.html.heex
@ -9,11 +9,11 @@
      <%= display_emoji("😔") %>
    </h1>

-    <.link patch={~p"/invites/new"} class="btn btn-primary">
+    <.link patch={Routes.invite_index_path(Endpoint, :new)} class="btn btn-primary">
      <%= dgettext("actions", "Invite someone new!") %>
    </.link>
  <% else %>
-    <.link patch={~p"/invites/new"} class="btn btn-primary">
+    <.link patch={Routes.invite_index_path(Endpoint, :new)} class="btn btn-primary">
      <%= dgettext("actions", "Create Invite") %>
    </.link>
  <% end %>
@ -40,7 +40,7 @@
        </form>
      </:code_actions>
      <.link
-        patch={~p"/invites/edit/#{invite}"}
+        patch={Routes.invite_index_path(Endpoint, :edit, invite)}
        class="text-primary-600 link"
        aria-label={
          dgettext("actions", "Edit invite for %{invite_name}", invite_name: invite.name)
@ -149,14 +149,14 @@
  <% end %>
 </div>

-<.modal :if={@live_action in [:new, :edit]} return_to={~p"/invites"}>
+<.modal :if={@live_action in [:new, :edit]} return_to={Routes.invite_index_path(Endpoint, :index)}>
  <.live_component
    module={CanneryWeb.InviteLive.FormComponent}
    id={@invite.id || :new}
    title={@page_title}
    action={@live_action}
    invite={@invite}
-    return_to={~p"/invites"}
+    return_to={Routes.invite_index_path(Endpoint, :index)}
    current_user={@current_user}
  />
 </.modal>
--- a/lib/cannery_web/live/pack_live/form_component.ex
+++ b/lib/cannery_web/live/pack_live/form_component.ex
@ -9,11 +9,7 @@ defmodule CanneryWeb.PackLive.FormComponent do
  alias Ecto.Changeset
  alias Phoenix.LiveView.Socket

-  @impl true
-  @spec mount(Socket.t()) :: {:ok, Socket.t()}
-  def mount(socket) do
-    {:ok, socket |> assign(:class, :all)}
-  end
+  @pack_create_limit 10_000

  @impl true
  @spec update(
@ -26,30 +22,29 @@ defmodule CanneryWeb.PackLive.FormComponent do

  @spec update(Socket.t()) :: {:ok, Socket.t()}
  def update(%{assigns: %{current_user: current_user}} = socket) do
-    socket =
+    %{assigns: %{types: types, containers: containers}} =
+      socket =
      socket
-      |> assign(:types, Ammo.list_types(current_user))
+      |> assign(:pack_create_limit, @pack_create_limit)
+      |> assign(:types, Ammo.list_types(current_user, :all))
      |> assign_new(:containers, fn -> Containers.list_containers(current_user) end)

-    {:ok, socket |> assign_changeset(%{})}
+    params =
+      if types |> List.first() |> is_nil(),
+        do: %{},
+        else: %{} |> Map.put("type_id", types |> List.first() |> Map.get(:id))
+
+    params =
+      if containers |> List.first() |> is_nil(),
+        do: params,
+        else: params |> Map.put("container_id", containers |> List.first() |> Map.get(:id))
+
+    {:ok, socket |> assign_changeset(params)}
  end

  @impl true
  def handle_event("validate", %{"pack" => pack_params}, socket) do
-    matched_class =
-      case pack_params["class"] do
-        "rifle" -> :rifle
-        "shotgun" -> :shotgun
-        "pistol" -> :pistol
-        _other -> :all
-      end
-
-    socket =
-      socket
-      |> assign_changeset(pack_params, :validate)
-      |> assign(:class, matched_class)
-
-    {:noreply, socket}
+    {:noreply, socket |> assign_changeset(pack_params, :validate)}
  end

  def handle_event(
@ -67,18 +62,11 @@ defmodule CanneryWeb.PackLive.FormComponent do
    containers |> Enum.map(fn %{id: id, name: name} -> {name, id} end)
  end

-  @spec type_options([Type.t()], Type.class() | :all) ::
-          [{String.t(), Type.id()}]
-  defp type_options(types, :all) do
+  @spec type_options([Type.t()]) :: [{String.t(), Type.id()}]
+  defp type_options(types) do
    types |> Enum.map(fn %{id: id, name: name} -> {name, id} end)
  end

-  defp type_options(types, selected_class) do
-    types
-    |> Enum.filter(fn %{class: class} -> class == selected_class end)
-    |> Enum.map(fn %{id: id, name: name} -> {name, id} end)
-  end
-
  # Save Helpers

  defp assign_changeset(
@ -104,13 +92,9 @@ defmodule CanneryWeb.PackLive.FormComponent do
      end

    changeset =
-      if changeset_action do
-        case changeset |> Changeset.apply_action(changeset_action) do
-          {:ok, _data} -> changeset
-          {:error, changeset} -> changeset
-        end
-      else
-        changeset
+      case changeset |> Changeset.apply_action(changeset_action || default_action) do
+        {:ok, _data} -> changeset
+        {:error, changeset} -> changeset
      end

    socket |> assign(:changeset, changeset)
@ -149,15 +133,53 @@ defmodule CanneryWeb.PackLive.FormComponent do
  end

  defp save_pack(
-         %{assigns: %{changeset: changeset, current_user: current_user, return_to: return_to}} =
-           socket,
+         %{assigns: %{changeset: changeset}} = socket,
         action,
         %{"multiplier" => multiplier_str} = pack_params
       )
       when action in [:new, :clone] do
    socket =
-      with {multiplier, _remainder} <- multiplier_str |> Integer.parse(),
-           {:ok, {count, _packs}} <- Ammo.create_packs(pack_params, multiplier, current_user) do
+      case multiplier_str |> Integer.parse() do
+        {multiplier, _remainder}
+        when multiplier >= 1 and multiplier <= @pack_create_limit ->
+          socket |> create_multiple(pack_params, multiplier)
+
+        {multiplier, _remainder} ->
+          error_msg =
+            dgettext(
+              "errors",
+              "Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}",
+              max: @pack_create_limit,
+              multiplier: multiplier
+            )
+
+          save_multiplier_error(socket, changeset, error_msg)
+
+        :error ->
+          error_msg = dgettext("errors", "Could not parse number of copies")
+          save_multiplier_error(socket, changeset, error_msg)
+      end
+
+    {:noreply, socket}
+  end
+
+  @spec save_multiplier_error(Socket.t(), Changeset.t(), String.t()) :: Socket.t()
+  defp save_multiplier_error(socket, changeset, error_msg) do
+    {:error, changeset} =
+      changeset
+      |> Changeset.add_error(:multiplier, error_msg)
+      |> Changeset.apply_action(:insert)
+
+    socket |> assign(:changeset, changeset)
+  end
+
+  defp create_multiple(
+         %{assigns: %{current_user: current_user, return_to: return_to}} = socket,
+         pack_params,
+         multiplier
+       ) do
+    case Ammo.create_packs(pack_params, multiplier, current_user) do
+      {:ok, {count, _packs}} ->
        prompt =
          dngettext(
            "prompts",
@ -167,21 +189,9 @@ defmodule CanneryWeb.PackLive.FormComponent do
          )

        socket |> put_flash(:info, prompt) |> push_navigate(to: return_to)
-      else
-        {:error, %Changeset{} = changeset} ->
-          socket |> assign(changeset: changeset)

-        :error ->
-          error_msg = dgettext("errors", "Could not parse number of copies")
-
-          {:error, changeset} =
-            changeset
-            |> Changeset.add_error(:multiplier, error_msg)
-            |> Changeset.apply_action(:insert)
-
-          socket |> assign(:changeset, changeset)
-      end
-
-    {:noreply, socket}
+      {:error, %Changeset{} = changeset} ->
+        socket |> assign(changeset: changeset)
+    end
  end
 end
--- a/lib/cannery_web/live/pack_live/form_component.html.heex
+++ b/lib/cannery_web/live/pack_live/form_component.html.heex
@ -13,32 +13,15 @@
    class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
  >
    <div
-      :if={@changeset.action && not @changeset.valid?}
+      :if={@changeset.action && not @changeset.valid?()}
      class="invalid-feedback col-span-3 text-center"
    >
      <%= changeset_errors(@changeset) %>
    </div>

-    <%= label(f, :class, gettext("Class"), class: "title text-lg text-primary-600") %>
-    <%= select(
-      f,
-      :class,
-      [
-        {gettext("Any"), :all},
-        {gettext("Rifle"), :rifle},
-        {gettext("Shotgun"), :shotgun},
-        {gettext("Pistol"), :pistol}
-      ],
-      class: "text-center col-span-2 input input-primary",
-      value: @class
-    ) %>
-    <%= error_tag(f, :class, "col-span-3 text-center") %>
-
    <%= label(f, :type_id, gettext("Type"), class: "title text-lg text-primary-600") %>
-    <%= select(f, :type_id, type_options(@types, @class),
-      class: "text-center col-span-2 input input-primary",
-      id: "pack-form-type-select",
-      phx_hook: "SlimSelect"
+    <%= select(f, :type_id, type_options(@types),
+      class: "text-center col-span-2 input input-primary"
    ) %>
    <%= error_tag(f, :type_id, "col-span-3 text-center") %>

@ -56,14 +39,6 @@
    ) %>
    <%= error_tag(f, :price_paid, "col-span-3 text-center") %>

-    <%= label(f, :lot_number, gettext("Lot number"), class: "title text-lg text-primary-600") %>
-    <%= text_input(f, :lot_number,
-      class: "text-center col-span-2 input input-primary",
-      maxlength: 255,
-      phx_debounce: 300
-    ) %>
-    <%= error_tag(f, :price_paid, "col-span-3 text-center") %>
-
    <%= label(f, :purchased_on, gettext("Purchased on"), class: "title text-lg text-primary-600") %>
    <%= date_input(f, :purchased_on,
      class: "input input-primary col-span-2",
@ -74,18 +49,16 @@

    <%= label(f, :notes, gettext("Notes"), class: "title text-lg text-primary-600") %>
    <%= textarea(f, :notes,
-      class: "text-center col-span-2 input input-primary",
      id: "pack-form-notes",
-      phx_debounce: 300,
+      class: "text-center col-span-2 input input-primary",
+      phx_hook: "MaintainAttrs",
      phx_update: "ignore"
    ) %>
    <%= error_tag(f, :notes, "col-span-3 text-center") %>

    <%= label(f, :container, gettext("Container"), class: "title text-lg text-primary-600") %>
    <%= select(f, :container_id, container_options(@containers),
-      class: "text-center col-span-2 input input-primary",
-      id: "pack-form-container-select",
-      phx_hook: "SlimSelect"
+      class: "text-center col-span-2 input input-primary"
    ) %>
    <%= error_tag(f, :container_id, "col-span-3 text-center") %>

@ -95,6 +68,7 @@

        <%= label(f, :multiplier, gettext("Copies"), class: "title text-lg text-primary-600") %>
        <%= number_input(f, :multiplier,
+          max: @pack_create_limit,
          class: "text-center input input-primary",
          value: 1,
          phx_update: "ignore"
--- a/lib/cannery_web/live/pack_live/index.ex
+++ b/lib/cannery_web/live/pack_live/index.ex
@ -113,11 +113,13 @@ defmodule CanneryWeb.PackLive.Index do
  end

  def handle_event("search", %{"search" => %{"search_term" => ""}}, socket) do
-    {:noreply, socket |> push_patch(to: ~p"/ammo")}
+    {:noreply, socket |> push_patch(to: Routes.pack_index_path(Endpoint, :index))}
  end

  def handle_event("search", %{"search" => %{"search_term" => search_term}}, socket) do
-    {:noreply, socket |> push_patch(to: ~p"/ammo/search/#{search_term}")}
+    socket = socket |> push_patch(to: Routes.pack_index_path(Endpoint, :search, search_term))
+
+    {:noreply, socket}
  end

  def handle_event("change_class", %{"type" => %{"class" => "rifle"}}, socket) do
@ -148,8 +150,8 @@ defmodule CanneryWeb.PackLive.Index do
       ) do
    # get total number of packs to determine whether to display onboarding
    # prompts
-    packs_count = Ammo.get_packs_count(current_user, show_used: true)
-    packs = Ammo.list_packs(current_user, search: search, class: class, show_used: show_used)
+    packs_count = Ammo.get_packs_count!(current_user, true)
+    packs = Ammo.list_packs(search, class, current_user, show_used)
    types_count = Ammo.get_types_count!(current_user)
    containers_count = Containers.get_containers_count!(current_user)

--- a/lib/cannery_web/live/pack_live/index.html.heex
+++ b/lib/cannery_web/live/pack_live/index.html.heex
@ -10,7 +10,7 @@
          <%= dgettext("prompts", "You'll need to") %>
        </h2>

-        <.link navigate={~p"/containers/new"} class="btn btn-primary">
+        <.link navigate={Routes.container_index_path(Endpoint, :new)} class="btn btn-primary">
          <%= dgettext("actions", "add a container first") %>
        </.link>
      </div>
@ -20,7 +20,7 @@
          <%= dgettext("prompts", "You'll need to") %>
        </h2>

-        <.link navigate={~p"/catalog/new"} class="btn btn-primary">
+        <.link navigate={Routes.type_index_path(Endpoint, :new)} class="btn btn-primary">
          <%= dgettext("actions", "add a type first") %>
        </.link>
      </div>
@ -30,11 +30,11 @@
        <%= display_emoji("😔") %>
      </h2>

-      <.link patch={~p"/ammo/new"} class="btn btn-primary">
+      <.link patch={Routes.pack_index_path(Endpoint, :new)} class="btn btn-primary">
        <%= dgettext("actions", "Add your first box!") %>
      </.link>
    <% true -> %>
-      <.link patch={~p"/ammo/new"} class="btn btn-primary">
+      <.link patch={Routes.pack_index_path(Endpoint, :new)} class="btn btn-primary">
        <%= dgettext("actions", "Add Ammo") %>
      </.link>

@ -75,10 +75,10 @@
        >
          <%= text_input(f, :search_term,
            class: "grow input input-primary",
-            phx_debounce: 300,
-            placeholder: gettext("Search ammo"),
+            value: @search,
            role: "search",
-            value: @search
+            phx_debounce: 300,
+            placeholder: gettext("Search ammo")
          ) %>
        </.form>

@ -103,7 +103,7 @@
          show_used={@show_used}
        >
          <:type :let={%{name: type_name} = type}>
-            <.link navigate={~p"/type/#{type}"} class="link">
+            <.link navigate={Routes.type_show_path(Endpoint, :show, type)} class="link">
              <%= type_name %>
            </.link>
          </:type>
@ -121,7 +121,7 @@
              </button>

              <.link
-                patch={~p"/ammo/add_shot_record/#{pack}"}
+                patch={Routes.pack_index_path(Endpoint, :add_shot_record, pack)}
                class="mx-2 my-1 text-sm btn btn-primary"
              >
                <%= dgettext("actions", "Record shots") %>
@ -130,11 +130,17 @@
          </:range>
          <:container :let={{pack, %{name: container_name} = container}}>
            <div class="min-w-20 py-2 px-4 h-full flex flew-wrap justify-center items-center">
-              <.link navigate={~p"/container/#{container}"} class="mx-2 my-1 link">
+              <.link
+                navigate={Routes.container_show_path(Endpoint, :show, container)}
+                class="mx-2 my-1 link"
+              >
                <%= container_name %>
              </.link>

-              <.link patch={~p"/ammo/move/#{pack}"} class="mx-2 my-1 text-sm btn btn-primary">
+              <.link
+                patch={Routes.pack_index_path(Endpoint, :move, pack)}
+                class="mx-2 my-1 text-sm btn btn-primary"
+              >
                <%= dgettext("actions", "Move ammo") %>
              </.link>
            </div>
@ -142,31 +148,27 @@
          <:actions :let={%{count: pack_count} = pack}>
            <div class="py-2 px-4 h-full space-x-4 flex justify-center items-center">
              <.link
-                navigate={~p"/ammo/show/#{pack}"}
+                navigate={Routes.pack_show_path(Endpoint, :show, pack)}
                class="text-primary-600 link"
                aria-label={
-                  dgettext("actions", "View pack of %{pack_count} bullets",
-                    pack_count: pack_count
-                  )
+                  dgettext("actions", "View pack of %{pack_count} bullets", pack_count: pack_count)
                }
              >
                <i class="fa-fw fa-lg fas fa-eye"></i>
              </.link>

              <.link
-                patch={~p"/ammo/edit/#{pack}"}
+                patch={Routes.pack_index_path(Endpoint, :edit, pack)}
                class="text-primary-600 link"
                aria-label={
-                  dgettext("actions", "Edit pack of %{pack_count} bullets",
-                    pack_count: pack_count
-                  )
+                  dgettext("actions", "Edit pack of %{pack_count} bullets", pack_count: pack_count)
                }
              >
                <i class="fa-fw fa-lg fas fa-edit"></i>
              </.link>

              <.link
-                patch={~p"/ammo/clone/#{pack}"}
+                patch={Routes.pack_index_path(Endpoint, :clone, pack)}
                class="text-primary-600 link"
                aria-label={
                  dgettext("actions", "Clone pack of %{pack_count} bullets",
@ -200,38 +202,38 @@

 <%= case @live_action do %>
  <% create when create in [:new, :edit, :clone] -> %>
-    <.modal return_to={~p"/ammo"}>
+    <.modal return_to={Routes.pack_index_path(Endpoint, :index)}>
      <.live_component
        module={CanneryWeb.PackLive.FormComponent}
        id={@pack.id || :new}
        title={@page_title}
        action={@live_action}
        pack={@pack}
-        return_to={~p"/ammo"}
+        return_to={Routes.pack_index_path(Endpoint, :index)}
        current_user={@current_user}
      />
    </.modal>
  <% :add_shot_record -> %>
-    <.modal return_to={~p"/ammo"}>
+    <.modal return_to={Routes.pack_index_path(Endpoint, :index)}>
      <.live_component
        module={CanneryWeb.Components.AddShotRecordComponent}
        id={:new}
        title={@page_title}
        action={@live_action}
        pack={@pack}
-        return_to={~p"/ammo"}
+        return_to={Routes.pack_index_path(Endpoint, :index)}
        current_user={@current_user}
      />
    </.modal>
  <% :move -> %>
-    <.modal return_to={~p"/ammo"}>
+    <.modal return_to={Routes.pack_index_path(Endpoint, :index)}>
      <.live_component
        module={CanneryWeb.Components.MovePackComponent}
        id={@pack.id}
        title={@page_title}
        action={@live_action}
        pack={@pack}
-        return_to={~p"/ammo"}
+        return_to={Routes.pack_index_path(Endpoint, :index)}
        current_user={@current_user}
      />
    </.modal>
--- a/lib/cannery_web/live/pack_live/show.ex
+++ b/lib/cannery_web/live/pack_live/show.ex
@ -7,6 +7,7 @@ defmodule CanneryWeb.PackLive.Show do
  alias Cannery.{ActivityLog, ActivityLog.ShotRecord}
  alias Cannery.{Ammo, Ammo.Pack}
  alias Cannery.{ComparableDate, Containers}
+  alias CanneryWeb.Endpoint
  alias Phoenix.LiveView.Socket

  @impl true
@ -52,7 +53,7 @@ defmodule CanneryWeb.PackLive.Show do
    pack |> Ammo.delete_pack!(current_user)

    prompt = dgettext("prompts", "Ammo deleted succesfully")
-    redirect_to = ~p"/ammo"
+    redirect_to = Routes.pack_index_path(socket, :index)

    {:noreply, socket |> put_flash(:info, prompt) |> push_navigate(to: redirect_to)}
  end
@ -92,7 +93,7 @@ defmodule CanneryWeb.PackLive.Show do
      %{label: gettext("Actions"), key: :actions, sortable: false}
    ]

-    shot_records = ActivityLog.list_shot_records(current_user, pack_id: pack.id)
+    shot_records = ActivityLog.list_shot_records_for_pack(pack, current_user)

    rows =
      shot_records
@ -138,7 +139,7 @@ defmodule CanneryWeb.PackLive.Show do
            ~H"""
            <div class="px-4 py-2 space-x-4 flex justify-center items-center">
              <.link
-                patch={~p"/ammo/show/#{@pack}/edit/#{@shot_record}"}
+                patch={Routes.pack_show_path(Endpoint, :edit_shot_record, @pack, @shot_record)}
                class="text-primary-600 link"
                aria-label={
                  dgettext("actions", "Edit shot record of %{shot_record_count} shots",
--- a/lib/cannery_web/live/pack_live/show.html.heex
+++ b/lib/cannery_web/live/pack_live/show.html.heex
@ -48,12 +48,15 @@

  <div class="flex flex-col justify-center items-center">
    <div class="flex flex-wrap justify-center items-center text-primary-600">
-      <.link navigate={~p"/type/#{@pack.type}"} class="mx-4 my-2 btn btn-primary">
+      <.link
+        navigate={Routes.type_show_path(Endpoint, :show, @pack.type)}
+        class="mx-4 my-2 btn btn-primary"
+      >
        <%= dgettext("actions", "View in Catalog") %>
      </.link>

      <.link
-        patch={~p"/ammo/show/edit/#{@pack}"}
+        patch={Routes.pack_show_path(Endpoint, :edit, @pack)}
        class="mx-4 my-2 text-primary-600 link"
        aria-label={
          dgettext("actions", "Edit pack of %{pack_count} bullets", pack_count: @pack.count)
@ -82,11 +85,14 @@
          else: dgettext("actions", "Stage for range") %>
      </button>

-      <.link patch={~p"/ammo/show/move/#{@pack}"} class="btn btn-primary">
+      <.link patch={Routes.pack_show_path(Endpoint, :move, @pack)} class="btn btn-primary">
        <%= dgettext("actions", "Move ammo") %>
      </.link>

-      <.link patch={~p"/ammo/show/add_shot_record/#{@pack}"} class="mx-4 my-2 btn btn-primary">
+      <.link
+        patch={Routes.pack_show_path(Endpoint, :add_shot_record, @pack)}
+        class="mx-4 my-2 btn btn-primary"
+      >
        <%= dgettext("actions", "Record shots") %>
      </.link>
    </div>
@ -115,7 +121,7 @@

    <.live_component
      module={CanneryWeb.Components.TableComponent}
-      id="pack-shot-records-table"
+      id="pack_shot_records_table"
      columns={@columns}
      rows={@rows}
    />
@ -124,50 +130,50 @@

 <%= case @live_action do %>
  <% :edit -> %>
-    <.modal return_to={~p"/ammo/show/#{@pack}"}>
+    <.modal return_to={Routes.pack_show_path(Endpoint, :show, @pack)}>
      <.live_component
        module={CanneryWeb.PackLive.FormComponent}
        id={@pack.id}
        title={@page_title}
        action={@live_action}
        pack={@pack}
-        return_to={~p"/ammo/show/#{@pack}"}
+        return_to={Routes.pack_show_path(Endpoint, :show, @pack)}
        current_user={@current_user}
      />
    </.modal>
  <% :edit_shot_record -> %>
-    <.modal return_to={~p"/ammo/show/#{@pack}"}>
+    <.modal return_to={Routes.pack_show_path(Endpoint, :show, @pack)}>
      <.live_component
        module={CanneryWeb.RangeLive.FormComponent}
        id={@shot_record.id}
        title={@page_title}
        action={@live_action}
        shot_record={@shot_record}
-        return_to={~p"/ammo/show/#{@pack}"}
+        return_to={Routes.pack_show_path(Endpoint, :show, @pack)}
        current_user={@current_user}
      />
    </.modal>
  <% :add_shot_record -> %>
-    <.modal return_to={~p"/ammo/show/#{@pack}"}>
+    <.modal return_to={Routes.pack_show_path(Endpoint, :show, @pack)}>
      <.live_component
        module={CanneryWeb.Components.AddShotRecordComponent}
        id={:new}
        title={@page_title}
        action={@live_action}
        pack={@pack}
-        return_to={~p"/ammo/show/#{@pack}"}
+        return_to={Routes.pack_show_path(Endpoint, :show, @pack)}
        current_user={@current_user}
      />
    </.modal>
  <% :move -> %>
-    <.modal return_to={~p"/ammo/show/#{@pack}"}>
+    <.modal return_to={Routes.pack_show_path(Endpoint, :show, @pack)}>
      <.live_component
        module={CanneryWeb.Components.MovePackComponent}
        id={@pack.id}
        title={@page_title}
        action={@live_action}
        pack={@pack}
-        return_to={~p"/ammo/show/#{@pack}"}
+        return_to={Routes.pack_show_path(Endpoint, :show, @pack)}
        current_user={@current_user}
      />
    </.modal>
--- a/lib/cannery_web/live/range_live/form_component.ex
+++ b/lib/cannery_web/live/range_live/form_component.ex
@ -71,25 +71,24 @@ defmodule CanneryWeb.RangeLive.FormComponent do
           }
         } = socket,
         shot_record_params,
-         changeset_action \\ nil
+         action \\ nil
       ) do
-    changeset =
+    default_action =
      case live_action do
-        :add_shot_record ->
-          shot_record |> ShotRecord.create_changeset(user, pack, shot_record_params)
-
-        editing when editing in [:edit, :edit_shot_record] ->
-          shot_record |> ShotRecord.update_changeset(user, shot_record_params)
+        :add_shot_record -> :insert
+        editing when editing in [:edit, :edit_shot_record] -> :update
      end

    changeset =
-      if changeset_action do
-        case changeset |> Changeset.apply_action(changeset_action) do
-          {:ok, _data} -> changeset
-          {:error, changeset} -> changeset
-        end
-      else
-        changeset
+      case default_action do
+        :insert -> shot_record |> ShotRecord.create_changeset(user, pack, shot_record_params)
+        :update -> shot_record |> ShotRecord.update_changeset(user, shot_record_params)
+      end
+
+    changeset =
+      case changeset |> Changeset.apply_action(action || default_action) do
+        {:ok, _data} -> changeset
+        {:error, changeset} -> changeset
      end

    socket |> assign(:changeset, changeset)
--- a/lib/cannery_web/live/range_live/form_component.html.heex
+++ b/lib/cannery_web/live/range_live/form_component.html.heex
@ -13,7 +13,7 @@
    phx-submit="save"
  >
    <div
-      :if={@changeset.action && not @changeset.valid?}
+      :if={@changeset.action && not @changeset.valid?()}
      class="invalid-feedback col-span-3 text-center"
    >
      <%= changeset_errors(@changeset) %>
@ -29,12 +29,12 @@

    <%= label(f, :notes, gettext("Notes"), class: "title text-lg text-primary-600") %>
    <%= textarea(f, :notes,
-      class: "input input-primary col-span-2",
      id: "shot-record-form-notes",
+      class: "input input-primary col-span-2",
      maxlength: 255,
-      phx_debounce: 300,
-      phx_update: "ignore",
-      placeholder: gettext("Really great weather")
+      placeholder: gettext("Really great weather"),
+      phx_hook: "MaintainAttrs",
+      phx_update: "ignore"
    ) %>
    <%= error_tag(f, :notes, "col-span-3") %>

--- a/lib/cannery_web/live/range_live/index.ex
+++ b/lib/cannery_web/live/range_live/index.ex
@ -5,6 +5,7 @@ defmodule CanneryWeb.RangeLive.Index do

  use CanneryWeb, :live_view
  alias Cannery.{ActivityLog, ActivityLog.ShotRecord, Ammo}
+  alias CanneryWeb.Endpoint
  alias Phoenix.LiveView.Socket

  @impl true
@ -44,7 +45,7 @@ defmodule CanneryWeb.RangeLive.Index do
  defp apply_action(socket, :new, _params) do
    socket
    |> assign(
-      page_title: gettext("Record Shots"),
+      page_title: gettext("New Shot Records"),
      shot_record: %ShotRecord{}
    )
  end
@ -52,7 +53,7 @@ defmodule CanneryWeb.RangeLive.Index do
  defp apply_action(socket, :index, _params) do
    socket
    |> assign(
-      page_title: gettext("Range"),
+      page_title: gettext("Shot Records"),
      search: nil,
      shot_record: nil
    )
@ -62,7 +63,7 @@ defmodule CanneryWeb.RangeLive.Index do
  defp apply_action(socket, :search, %{"search" => search}) do
    socket
    |> assign(
-      page_title: gettext("Range"),
+      page_title: gettext("Shot Records"),
      search: search,
      shot_record: nil
    )
@ -93,11 +94,11 @@ defmodule CanneryWeb.RangeLive.Index do
  end

  def handle_event("search", %{"search" => %{"search_term" => ""}}, socket) do
-    {:noreply, socket |> push_patch(to: ~p"/range")}
+    {:noreply, socket |> push_patch(to: Routes.range_index_path(Endpoint, :index))}
  end

  def handle_event("search", %{"search" => %{"search_term" => search_term}}, socket) do
-    {:noreply, socket |> push_patch(to: ~p"/range/search/#{search_term}")}
+    {:noreply, socket |> push_patch(to: Routes.range_index_path(Endpoint, :search, search_term))}
  end

  def handle_event("change_class", %{"type" => %{"class" => "rifle"}}, socket) do
@ -120,8 +121,8 @@ defmodule CanneryWeb.RangeLive.Index do
  defp display_shot_records(
         %{assigns: %{class: class, search: search, current_user: current_user}} = socket
       ) do
-    shot_records = ActivityLog.list_shot_records(current_user, search: search, class: class)
-    packs = Ammo.list_packs(current_user, staged: true)
+    shot_records = ActivityLog.list_shot_records(search, class, current_user)
+    packs = Ammo.list_staged_packs(current_user)
    chart_data = shot_records |> get_chart_data_for_shot_record()
    original_counts = packs |> Ammo.get_original_counts(current_user)
    cprs = packs |> Ammo.get_cprs(current_user)
--- a/lib/cannery_web/live/range_live/index.html.heex
+++ b/lib/cannery_web/live/range_live/index.html.heex
@ -9,11 +9,11 @@
      <%= display_emoji("😔") %>
    </h1>

-    <.link navigate={~p"/ammo"} class="btn btn-primary">
+    <.link navigate={Routes.pack_index_path(Endpoint, :index)} class="btn btn-primary">
      <%= dgettext("actions", "Why not get some ready to shoot?") %>
    </.link>
  <% else %>
-    <.link navigate={~p"/ammo"} class="btn btn-primary">
+    <.link navigate={Routes.pack_index_path(Endpoint, :index)} class="btn btn-primary">
      <%= dgettext("actions", "Stage ammo") %>
    </.link>

@ -38,7 +38,10 @@
            else: dgettext("actions", "Stage for range") %>
        </button>

-        <.link patch={~p"/range/add_shot_record/#{pack}"} class="btn btn-primary">
+        <.link
+          patch={Routes.range_index_path(Endpoint, :add_shot_record, pack)}
+          class="btn btn-primary"
+        >
          <%= dgettext("actions", "Record shots") %>
        </.link>
      </.pack_card>
@ -80,9 +83,7 @@
        phx-submit="change_class"
        class="flex items-center"
      >
-        <%= label(f, :class, gettext("Class"),
-          class: "title text-primary-600 text-lg text-center"
-        ) %>
+        <%= label(f, :class, gettext("Class"), class: "title text-primary-600 text-lg text-center") %>

        <%= select(
          f,
@ -108,10 +109,10 @@
      >
        <%= text_input(f, :search_term,
          class: "grow input input-primary",
-          phx_debounce: 300,
-          placeholder: gettext("Search shot records"),
+          value: @search,
          role: "search",
-          value: @search
+          phx_debounce: 300,
+          placeholder: gettext("Search shot records")
        ) %>
      </.form>
    </div>
@ -124,14 +125,14 @@
    <% else %>
      <.live_component
        module={CanneryWeb.Components.ShotRecordTableComponent}
-        id="shot-records-index-table"
+        id="shot_records_index_table"
        shot_records={@shot_records}
        current_user={@current_user}
      >
        <:actions :let={shot_record}>
          <div class="px-4 py-2 space-x-4 flex justify-center items-center">
            <.link
-              patch={~p"/range/edit/#{shot_record}"}
+              patch={Routes.range_index_path(Endpoint, :edit, shot_record)}
              class="text-primary-600 link"
              aria-label={
                dgettext("actions", "Edit shot record of %{shot_record_count} shots",
@ -167,26 +168,26 @@

 <%= case @live_action do %>
  <% :edit -> %>
-    <.modal return_to={~p"/range"}>
+    <.modal return_to={Routes.range_index_path(Endpoint, :index)}>
      <.live_component
        module={CanneryWeb.RangeLive.FormComponent}
        id={@shot_record.id}
        title={@page_title}
        action={@live_action}
        shot_record={@shot_record}
-        return_to={~p"/range"}
+        return_to={Routes.range_index_path(Endpoint, :index)}
        current_user={@current_user}
      />
    </.modal>
  <% :add_shot_record -> %>
-    <.modal return_to={~p"/range"}>
+    <.modal return_to={Routes.range_index_path(Endpoint, :index)}>
      <.live_component
        module={CanneryWeb.Components.AddShotRecordComponent}
        id={:new}
        title={@page_title}
        action={@live_action}
        pack={@pack}
-        return_to={~p"/range"}
+        return_to={Routes.range_index_path(Endpoint, :index)}
        current_user={@current_user}
      />
    </.modal>
--- a/lib/cannery_web/live/tag_live/form_component.ex
+++ b/lib/cannery_web/live/tag_live/form_component.ex
@ -17,7 +17,7 @@ defmodule CanneryWeb.TagLive.FormComponent do

  @impl true
  def handle_event("validate", %{"tag" => tag_params}, socket) do
-    {:noreply, socket |> assign_changeset(tag_params, :validate)}
+    {:noreply, socket |> assign_changeset(tag_params)}
  end

  def handle_event("save", %{"tag" => tag_params}, %{assigns: %{action: action}} = socket) do
@ -26,9 +26,14 @@ defmodule CanneryWeb.TagLive.FormComponent do

  defp assign_changeset(
         %{assigns: %{action: action, current_user: user, tag: tag}} = socket,
-         tag_params,
-         changeset_action \\ nil
+         tag_params
       ) do
+    changeset_action =
+      case action do
+        :new -> :insert
+        :edit -> :update
+      end
+
    changeset =
      case action do
        :new -> tag |> Tag.create_changeset(user, tag_params)
@ -36,13 +41,9 @@ defmodule CanneryWeb.TagLive.FormComponent do
      end

    changeset =
-      if changeset_action do
-        case changeset |> Changeset.apply_action(changeset_action) do
-          {:ok, _data} -> changeset
-          {:error, changeset} -> changeset
-        end
-      else
-        changeset
+      case changeset |> Changeset.apply_action(changeset_action) do
+        {:ok, _data} -> changeset
+        {:error, changeset} -> changeset
      end

    socket |> assign(:changeset, changeset)
--- a/lib/cannery_web/live/tag_live/form_component.html.heex
+++ b/lib/cannery_web/live/tag_live/form_component.html.heex
@ -12,18 +12,14 @@
    phx-submit="save"
  >
    <div
-      :if={@changeset.action && not @changeset.valid?}
+      :if={@changeset.action && not @changeset.valid?()}
      class="invalid-feedback col-span-3 text-center"
    >
      <%= changeset_errors(@changeset) %>
    </div>

    <%= label(f, :name, gettext("Name"), class: "title text-lg text-primary-600") %>
-    <%= text_input(f, :name,
-      class: "input input-primary col-span-2",
-      maxlength: 255,
-      phx_debounce: 300
-    ) %>
+    <%= text_input(f, :name, class: "input input-primary col-span-2", maxlength: 255) %>
    <%= error_tag(f, :name, "col-span-3") %>

    <%= label(f, :bg_color, gettext("Background color"), class: "title text-lg text-primary-600") %>
--- a/lib/cannery_web/live/tag_live/index.ex
+++ b/lib/cannery_web/live/tag_live/index.ex
@ -5,7 +5,7 @@ defmodule CanneryWeb.TagLive.Index do

  use CanneryWeb, :live_view
  alias Cannery.{Containers, Containers.Tag}
-  alias CanneryWeb.HTMLHelpers
+  alias CanneryWeb.ViewHelpers

  @impl true
  def mount(%{"search" => search}, _session, socket) do
@ -33,7 +33,7 @@ defmodule CanneryWeb.TagLive.Index do
    socket
    |> assign(
      page_title: gettext("New Tag"),
-      tag: %Tag{bg_color: HTMLHelpers.random_color(), text_color: "#ffffff"}
+      tag: %Tag{bg_color: ViewHelpers.random_color(), text_color: "#ffffff"}
    )
  end

@ -67,14 +67,14 @@ defmodule CanneryWeb.TagLive.Index do
  end

  def handle_event("search", %{"search" => %{"search_term" => ""}}, socket) do
-    {:noreply, socket |> push_patch(to: ~p"/tags")}
+    {:noreply, socket |> push_patch(to: Routes.tag_index_path(Endpoint, :index))}
  end

  def handle_event("search", %{"search" => %{"search_term" => search_term}}, socket) do
-    {:noreply, socket |> push_patch(to: ~p"/tags/search/#{search_term}")}
+    {:noreply, socket |> push_patch(to: Routes.tag_index_path(Endpoint, :search, search_term))}
  end

  defp display_tags(%{assigns: %{search: search, current_user: current_user}} = socket) do
-    socket |> assign(tags: Containers.list_tags(current_user, search: search))
+    socket |> assign(tags: Containers.list_tags(search, current_user))
  end
 end
--- a/lib/cannery_web/live/tag_live/index.html.heex
+++ b/lib/cannery_web/live/tag_live/index.html.heex
@ -11,11 +11,11 @@
      <%= display_emoji("😔") %>
    </h2>

-    <.link patch={~p"/tags/new"} class="btn btn-primary">
+    <.link patch={Routes.tag_index_path(Endpoint, :new)} class="btn btn-primary">
      <%= dgettext("actions", "Make your first tag!") %>
    </.link>
  <% else %>
-    <.link patch={~p"/tags/new"} class="btn btn-primary">
+    <.link patch={Routes.tag_index_path(Endpoint, :new)} class="btn btn-primary">
      <%= dgettext("actions", "New Tag") %>
    </.link>

@ -30,10 +30,10 @@
      >
        <%= text_input(f, :search_term,
          class: "grow input input-primary",
-          phx_debounce: 300,
-          placeholder: gettext("Search tags"),
+          value: @search,
          role: "search",
-          value: @search
+          phx_debounce: 300,
+          placeholder: gettext("Search tags")
        ) %>
      </.form>
    </div>
@ -47,7 +47,7 @@
      <div class="flex flex-row flex-wrap justify-center items-stretch">
        <.tag_card :for={tag <- @tags} tag={tag}>
          <.link
-            patch={~p"/tags/edit/#{tag}"}
+            patch={Routes.tag_index_path(Endpoint, :edit, tag)}
            class="text-primary-600 link"
            aria-label={dgettext("actions", "Edit %{tag_name}", tag_name: tag.name)}
          >
@ -72,14 +72,14 @@
  <% end %>
 </div>

-<.modal :if={@live_action in [:new, :edit]} return_to={~p"/tags"}>
+<.modal :if={@live_action in [:new, :edit]} return_to={Routes.tag_index_path(Endpoint, :index)}>
  <.live_component
    module={CanneryWeb.TagLive.FormComponent}
    id={@tag.id || :new}
    title={@page_title}
    action={@live_action}
    tag={@tag}
-    return_to={~p"/tags"}
+    return_to={Routes.tag_index_path(Endpoint, :index)}
    current_user={@current_user}
  />
 </.modal>
--- a/lib/cannery_web/live/type_live/form_component.ex
+++ b/lib/cannery_web/live/type_live/form_component.ex
@ -19,7 +19,7 @@ defmodule CanneryWeb.TypeLive.FormComponent do

  @impl true
  def handle_event("validate", %{"type" => type_params}, socket) do
-    {:noreply, socket |> assign_changeset(type_params, :validate)}
+    {:noreply, socket |> assign_changeset(type_params)}
  end

  def handle_event(
@ -32,9 +32,14 @@ defmodule CanneryWeb.TypeLive.FormComponent do

  defp assign_changeset(
         %{assigns: %{action: action, type: type, current_user: user}} = socket,
-         type_params,
-         changeset_action \\ nil
+         type_params
       ) do
+    changeset_action =
+      case action do
+        create when create in [:new, :clone] -> :insert
+        :edit -> :update
+      end
+
    changeset =
      case action do
        create when create in [:new, :clone] ->
@ -45,13 +50,9 @@ defmodule CanneryWeb.TypeLive.FormComponent do
      end

    changeset =
-      if changeset_action do
-        case changeset |> Changeset.apply_action(changeset_action) do
-          {:ok, _data} -> changeset
-          {:error, changeset} -> changeset
-        end
-      else
-        changeset
+      case changeset |> Changeset.apply_action(changeset_action) do
+        {:ok, _data} -> changeset
+        {:error, changeset} -> changeset
      end

    socket |> assign(changeset: changeset)
--- a/lib/cannery_web/live/type_live/form_component.html.heex
+++ b/lib/cannery_web/live/type_live/form_component.html.heex
@ -12,7 +12,7 @@
    class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
  >
    <div
-      :if={@changeset.action && not @changeset.valid?}
+      :if={@changeset.action && not @changeset.valid?()}
      class="invalid-feedback col-span-3 text-center"
    >
      <%= dgettext("errors", "Oops, something went wrong! Please check the errors below.") %>
@ -22,11 +22,7 @@
    <%= select(
      f,
      :class,
-      [
-        {gettext("Rifle"), :rifle},
-        {gettext("Shotgun"), :shotgun},
-        {gettext("Pistol"), :pistol}
-      ],
+      [{gettext("Rifle"), :rifle}, {gettext("Shotgun"), :shotgun}, {gettext("Pistol"), :pistol}],
      class: "text-center col-span-2 input input-primary",
      maxlength: 255
    ) %>
@ -35,16 +31,15 @@
    <%= label(f, :name, gettext("Name"), class: "title text-lg text-primary-600") %>
    <%= text_input(f, :name,
      class: "text-center col-span-2 input input-primary",
-      maxlength: 255,
-      phx_debounce: 300
+      maxlength: 255
    ) %>
    <%= error_tag(f, :name, "col-span-3 text-center") %>

    <%= label(f, :desc, gettext("Description"), class: "title text-lg text-primary-600") %>
    <%= textarea(f, :desc,
-      class: "text-center col-span-2 input input-primary",
      id: "type-form-desc",
-      phx_debounce: 300,
+      class: "text-center col-span-2 input input-primary",
+      phx_hook: "MaintainAttrs",
      phx_update: "ignore"
    ) %>
    <%= error_tag(f, :desc, "col-span-3 text-center") %>
@ -58,7 +53,6 @@
      <%= text_input(f, :cartridge,
        class: "text-center col-span-2 input input-primary",
        maxlength: 255,
-        phx_debounce: 300,
        placeholder: gettext("5.56x46mm NATO")
      ) %>
      <%= error_tag(f, :cartridge, "col-span-3 text-center") %>
@ -78,7 +72,6 @@
    <%= text_input(f, :caliber,
      class: "text-center col-span-2 input input-primary",
      maxlength: 255,
-      phx_debounce: 300,
      placeholder: gettext(".223")
    ) %>
    <%= error_tag(f, :caliber, "col-span-3 text-center") %>
@ -89,28 +82,21 @@
      ) %>
      <%= text_input(f, :unfired_length,
        class: "text-center col-span-2 input input-primary",
-        maxlength: 255,
-        phx_debounce: 300
+        maxlength: 255
      ) %>
      <%= error_tag(f, :unfired_length, "col-span-3 text-center") %>

-      <%= label(f, :brass_height, gettext("Brass height"),
-        class: "title text-lg text-primary-600"
-      ) %>
+      <%= label(f, :brass_height, gettext("Brass height"), class: "title text-lg text-primary-600") %>
      <%= text_input(f, :brass_height,
        class: "text-center col-span-2 input input-primary",
-        maxlength: 255,
-        phx_debounce: 300
+        maxlength: 255
      ) %>
      <%= error_tag(f, :brass_height, "col-span-3 text-center") %>

-      <%= label(f, :chamber_size, gettext("Chamber size"),
-        class: "title text-lg text-primary-600"
-      ) %>
+      <%= label(f, :chamber_size, gettext("Chamber size"), class: "title text-lg text-primary-600") %>
      <%= text_input(f, :chamber_size,
        class: "text-center col-span-2 input input-primary",
-        maxlength: 255,
-        phx_debounce: 300
+        maxlength: 255
      ) %>
      <%= error_tag(f, :chamber_size, "col-span-3 text-center") %>
    <% else %>
@ -131,29 +117,24 @@
    ) %>
    <%= error_tag(f, :grains, "col-span-3 text-center") %>

-    <%= if Changeset.get_field(@changeset, :class) in [:rifle, :pistol] do %>
-      <%= label f, :bullet_type, class: "flex title text-lg text-primary-600 space-x-2" do %>
-        <p><%= gettext("Bullet type") %></p>
+    <%= label f, :bullet_type, class: "flex title text-lg text-primary-600 space-x-2" do %>
+      <p><%= gettext("Bullet type") %></p>

-        <.link
-          href="https://shootersreference.com/reloadingdata/bullet_abbreviations/"
-          class="link"
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          <i class="fas fa-md fa-external-link-alt"></i>
-        </.link>
-      <% end %>
-      <%= text_input(f, :bullet_type,
-        class: "text-center col-span-2 input input-primary",
-        maxlength: 255,
-        phx_debounce: 300,
-        placeholder: gettext("FMJ")
-      ) %>
-      <%= error_tag(f, :bullet_type, "col-span-3 text-center") %>
-    <% else %>
-      <%= hidden_input(f, :bullet_type, value: nil) %>
+      <.link
+        href="https://shootersreference.com/reloadingdata/bullet_abbreviations/"
+        class="link"
+        target="_blank"
+        rel="noopener noreferrer"
+      >
+        <i class="fas fa-md fa-external-link-alt"></i>
+      </.link>
    <% end %>
+    <%= text_input(f, :bullet_type,
+      class: "text-center col-span-2 input input-primary",
+      maxlength: 255,
+      placeholder: gettext("FMJ")
+    ) %>
+    <%= error_tag(f, :bullet_type, "col-span-3 text-center") %>

    <%= label(
      f,
@ -167,7 +148,6 @@
    <%= text_input(f, :bullet_core,
      class: "text-center col-span-2 input input-primary",
      maxlength: 255,
-      phx_debounce: 300,
      placeholder: gettext("Steel")
    ) %>
    <%= error_tag(f, :bullet_core, "col-span-3 text-center") %>
@ -177,7 +157,6 @@
      <%= text_input(f, :jacket_type,
        class: "text-center col-span-2 input input-primary",
        maxlength: 255,
-        phx_debounce: 300,
        placeholder: gettext("Bimetal")
      ) %>
      <%= error_tag(f, :jacket_type, "col-span-3 text-center") %>
@ -185,13 +164,10 @@
      <%= hidden_input(f, :jacket_type, value: nil) %>
    <% end %>

-    <%= label(f, :case_material, gettext("Case material"),
-      class: "title text-lg text-primary-600"
-    ) %>
+    <%= label(f, :case_material, gettext("Case material"), class: "title text-lg text-primary-600") %>
    <%= text_input(f, :case_material,
      class: "text-center col-span-2 input input-primary",
      maxlength: 255,
-      phx_debounce: 300,
      placeholder: gettext("Brass")
    ) %>
    <%= error_tag(f, :case_material, "col-span-3 text-center") %>
@ -200,8 +176,7 @@
      <%= label(f, :wadding, gettext("Wadding"), class: "title text-lg text-primary-600") %>
      <%= text_input(f, :wadding,
        class: "text-center col-span-2 input input-primary",
-        maxlength: 255,
-        phx_debounce: 300
+        maxlength: 255
      ) %>
      <%= error_tag(f, :wadding, "col-span-3 text-center") %>

@ -209,7 +184,6 @@
      <%= text_input(f, :shot_type,
        class: "text-center col-span-2 input input-primary",
        maxlength: 255,
-        phx_debounce: 300,
        placeholder: gettext("Target, bird, buck, etc")
      ) %>
      <%= error_tag(f, :shot_type, "col-span-3 text-center") %>
@ -219,16 +193,14 @@
      ) %>
      <%= text_input(f, :shot_material,
        class: "text-center col-span-2 input input-primary",
-        maxlength: 255,
-        phx_debounce: 300
+        maxlength: 255
      ) %>
      <%= error_tag(f, :shot_material, "col-span-3 text-center") %>

      <%= label(f, :shot_size, gettext("Shot size"), class: "title text-lg text-primary-600") %>
      <%= text_input(f, :shot_size,
        class: "text-center col-span-2 input input-primary",
-        maxlength: 255,
-        phx_debounce: 300
+        maxlength: 255
      ) %>
      <%= error_tag(f, :shot_size, "col-span-3 text-center") %>

@ -245,8 +217,7 @@
      ) %>
      <%= text_input(f, :shot_charge_weight,
        class: "text-center col-span-2 input input-primary",
-        maxlength: 255,
-        phx_debounce: 300
+        maxlength: 255
      ) %>
      <%= error_tag(f, :shot_charge_weight, "col-span-3 text-center") %>
    <% else %>
@ -265,8 +236,7 @@
    <%= label(f, :powder_type, gettext("Powder type"), class: "title text-lg text-primary-600") %>
    <%= text_input(f, :powder_type,
      class: "text-center col-span-2 input input-primary",
-      maxlength: 255,
-      phx_debounce: 300
+      maxlength: 255
    ) %>
    <%= error_tag(f, :powder_type, "col-span-3 text-center") %>

@ -288,7 +258,6 @@
    <%= text_input(f, :pressure,
      class: "text-center col-span-2 input input-primary",
      maxlength: 255,
-      phx_debounce: 300,
      placeholder: gettext("+P")
    ) %>
    <%= error_tag(f, :pressure, "col-span-3 text-center") %>
@ -299,8 +268,7 @@
      ) %>
      <%= text_input(f, :dram_equivalent,
        class: "text-center col-span-2 input input-primary",
-        maxlength: 255,
-        phx_debounce: 300
+        maxlength: 255
      ) %>
      <%= error_tag(f, :dram_equivalent, "col-span-3 text-center") %>
    <% else %>
@ -329,7 +297,6 @@
    <%= text_input(f, :primer_type,
      class: "text-center col-span-2 input input-primary",
      maxlength: 255,
-      phx_debounce: 300,
      placeholder: gettext("Boxer")
    ) %>
    <%= error_tag(f, :primer_type, "col-span-3 text-center") %>
@ -338,7 +305,6 @@
    <%= text_input(f, :firing_type,
      class: "text-center col-span-2 input input-primary",
      maxlength: 255,
-      phx_debounce: 300,
      placeholder: gettext("Centerfire")
    ) %>
    <%= error_tag(f, :firing_type, "col-span-3 text-center") %>
@ -370,16 +336,14 @@
    <%= label(f, :manufacturer, gettext("Manufacturer"), class: "title text-lg text-primary-600") %>
    <%= text_input(f, :manufacturer,
      class: "text-center col-span-2 input input-primary",
-      maxlength: 255,
-      phx_debounce: 300
+      maxlength: 255
    ) %>
    <%= error_tag(f, :manufacturer, "col-span-3 text-center") %>

    <%= label(f, :upc, gettext("UPC"), class: "title text-lg text-primary-600") %>
    <%= text_input(f, :upc,
      class: "text-center col-span-2 input input-primary",
-      maxlength: 255,
-      phx_debounce: 300
+      maxlength: 255
    ) %>
    <%= error_tag(f, :upc, "col-span-3 text-center") %>

--- a/lib/cannery_web/live/type_live/index.ex
+++ b/lib/cannery_web/live/type_live/index.ex
@ -78,11 +78,12 @@ defmodule CanneryWeb.TypeLive.Index do
  end

  def handle_event("search", %{"search" => %{"search_term" => ""}}, socket) do
-    {:noreply, socket |> push_patch(to: ~p"/catalog")}
+    {:noreply, socket |> push_patch(to: Routes.type_index_path(Endpoint, :index))}
  end

  def handle_event("search", %{"search" => %{"search_term" => search_term}}, socket) do
-    {:noreply, socket |> push_patch(to: ~p"/catalog/search/#{search_term}")}
+    search_path = Routes.type_index_path(Endpoint, :search, search_term)
+    {:noreply, socket |> push_patch(to: search_path)}
  end

  def handle_event("change_class", %{"type" => %{"class" => "rifle"}}, socket) do
@ -106,7 +107,7 @@ defmodule CanneryWeb.TypeLive.Index do
       ) do
    socket
    |> assign(
-      types: Ammo.list_types(current_user, class: class, search: search),
+      types: Ammo.list_types(search, current_user, class),
      types_count: Ammo.get_types_count!(current_user)
    )
  end
--- a/lib/cannery_web/live/type_live/index.html.heex
+++ b/lib/cannery_web/live/type_live/index.html.heex
@ -9,11 +9,11 @@
      <%= display_emoji("😔") %>
    </h2>

-    <.link patch={~p"/catalog/new"} class="btn btn-primary">
+    <.link patch={Routes.type_index_path(Endpoint, :new)} class="btn btn-primary">
      <%= dgettext("actions", "Add your first type!") %>
    </.link>
  <% else %>
-    <.link patch={~p"/catalog/new"} class="btn btn-primary">
+    <.link patch={Routes.type_index_path(Endpoint, :new)} class="btn btn-primary">
      <%= dgettext("actions", "New Type") %>
    </.link>

@ -26,9 +26,7 @@
        phx-submit="change_class"
        class="flex items-center"
      >
-        <%= label(f, :class, gettext("Class"),
-          class: "title text-primary-600 text-lg text-center"
-        ) %>
+        <%= label(f, :class, gettext("Class"), class: "title text-primary-600 text-lg text-center") %>

        <%= select(
          f,
@ -54,10 +52,10 @@
      >
        <%= text_input(f, :search_term,
          class: "grow input input-primary",
-          phx_debounce: 300,
-          placeholder: gettext("Search catalog"),
+          value: @search,
          role: "search",
-          value: @search
+          phx_debounce: 300,
+          placeholder: gettext("Search catalog")
        ) %>
      </.form>

@ -76,7 +74,7 @@
    <% else %>
      <.live_component
        module={CanneryWeb.Components.TypeTableComponent}
-        id="types-index-table"
+        id="types_index_table"
        action={@live_action}
        types={@types}
        current_user={@current_user}
@ -86,7 +84,7 @@
        <:actions :let={type}>
          <div class="px-4 py-2 space-x-4 flex justify-center items-center">
            <.link
-              navigate={~p"/type/#{type}"}
+              navigate={Routes.type_show_path(Endpoint, :show, type)}
              class="text-primary-600 link"
              aria-label={dgettext("actions", "View %{type_name}", type_name: type.name)}
            >
@ -94,7 +92,7 @@
            </.link>

            <.link
-              patch={~p"/catalog/edit/#{type}"}
+              patch={Routes.type_index_path(Endpoint, :edit, type)}
              class="text-primary-600 link"
              aria-label={dgettext("actions", "Edit %{type_name}", type_name: type.name)}
            >
@ -102,7 +100,7 @@
            </.link>

            <.link
-              patch={~p"/catalog/clone/#{type}"}
+              patch={Routes.type_index_path(Endpoint, :clone, type)}
              class="text-primary-600 link"
              aria-label={dgettext("actions", "Clone %{type_name}", type_name: type.name)}
            >
@ -132,14 +130,17 @@
  <% end %>
 </div>

-<.modal :if={@live_action in [:new, :edit, :clone]} return_to={~p"/catalog"}>
+<.modal
+  :if={@live_action in [:new, :edit, :clone]}
+  return_to={Routes.type_index_path(Endpoint, :index)}
+>
  <.live_component
    module={CanneryWeb.TypeLive.FormComponent}
    id={@type.id || :new}
    title={@page_title}
    action={@live_action}
    type={@type}
-    return_to={~p"/catalog"}
+    return_to={Routes.type_index_path(Endpoint, :index)}
    current_user={@current_user}
    }
  />
--- a/Show More
+++ b/Show More