finish updating deps

.drone.yml

@@ -17,7 +17,7 @@ steps:
       - .mix
 
 - name: test
-  image: elixir:1.14.1-alpine
+  image: elixir:1.17.3-otp-27-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 --if-missing
+  - mix local.rebar --force
-  - mix local.hex --force --if-missing
+  - mix local.hex --force
   - mix deps.get
   - npm set cache .npm
   - npm --prefix ./assets ci --no-audit --prefer-offline
@@ -36,13 +36,16 @@ steps:
   - mix test.all
 
 - name: build and publish stable
-  image: thegeeklab/drone-docker-buildx
+  image: plugins/docker
   privileged: true
   settings:
     repo: shibaobun/cannery
     purge: true
     compress: true
-    platforms: linux/amd64,linux/arm/v7
+    platforms:
+      - linux/amd64
+      - linux/arm64
+      - linux/arm/v7
     username:
       from_secret: docker_username
     password:
@@ -53,13 +56,16 @@ steps:
     - stable
 
 - name: build and publish tagged version
-  image: thegeeklab/drone-docker-buildx
+  image: plugins/docker
   privileged: true
   settings:
     repo: shibaobun/cannery
     purge: true
     compress: true
-    platforms: linux/amd64,linux/arm/v7
+    platforms:
+      - linux/amd64
+      - linux/arm64
+      - linux/arm/v7
     username:
       from_secret: docker_username
     password:

.formatter.exs

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

.tool-versions

@@ -1,3 +1,3 @@
-elixir 1.14.1-otp-25
+elixir 1.17.3-otp-27
-erlang 25.1.2
+erlang 27.1.2
-nodejs 18.9.1
+nodejs 23.0.0

CHANGELOG.md

@@ -1,3 +1,83 @@
+# 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
+- Fixes type search
+- Fixes shot records table disappearing after selecting an empty ammo class
+- Code quality improvements
+
+# v0.9.0
+- Add length limits to all string fields
+- Add selectable ammo types
+- Improve onboarding experience slightly
+- Remove show used view from a container since it doesn't really make that much
+  sense
+
+# v0.8.6
+- Fix duplicate entries showing up
+- Show ammo packs under a type in a table by default
+- Only show historical ammo type information when displaying "Show used" in table
+- Only show historical ammo pack information when displaying "Show used" in table
+- Fix some values not being sorted in tables properly
+- Code quality improvements
+- Show link to ammo pack in ammo pack table while viewing ammo type
+
 # v0.8.5
 - Add link in readme to github mirror
 - Fix tables unable to sort on empty dates
@@ -35,7 +115,7 @@
 # v0.8.0
 - Add search to catalog, ammo, container, tag and range index pages
 - Tweak urls for catalog, ammo, containers, tags and shot records
-- Fix bug with shot group chart not drawing lines between days correctly
+- Fix bug with shot record chart not drawing lines between days correctly
 - Improve cards across app (make them line up with each other)
 - Update translations and add spanish!!! (thank you Brea and Hannah!)
 
@@ -47,7 +127,7 @@
 - Fix toggle button styling
 - Miscellanous code improvements
 - Improve container index table
-- Fix bug with ammo not updating after deleting shot group
+- Fix bug with ammo not updating after deleting shot record
 - Replace ammo "added on" with "purchased on"
 - Miscellaneous wording improvements
 - Update translations
@@ -56,8 +136,8 @@
 - Add shading to table component
 - Fix chart to sum by day
 - Fix whitespace when copying invite url
-- Make ammo type show page also display ammo groups as table
+- Make ammo type show page also display packs as table
-- Make container show page also display ammo groups as table
+- Make container show page also display packs as table
 - Display CPR for ammo packs
 - Add original count for ammo packs
 - Add ammo pack CPR and original count to json export
@@ -81,7 +161,7 @@
 - Add ammo type cloning
 - Add container cloning
 - Fix bug with moving ammo packs between containers
-- Add button to set rounds left to 0 when creating a shot group
+- Add button to set rounds left to 0 when creating a shot record
 - Update project dependencies
 
 # v0.5.4
@@ -133,8 +213,8 @@
 # v0.3.0
 - Fix ammo type counts not showing when count is 0
 - Add prompt to create first container before first ammo group
-- Edit and delete shot groups from ammo group show page
+- Edit and delete shot records from ammo group show page
-- Use today's date when adding new shot groups
+- Use today's date when adding new shot records
 - Create multiple ammo groups at one time
 
 # v0.2.3

CONTRIBUTING.md

@@ -17,8 +17,8 @@ If you're multilingual, this project can use your translations! Visit
   functions as short as possible while keeping variable names descriptive! For
   instance, use inline `do:` blocks for short functions and make your aliases as
   short as possible without introducing ambiguity.
-  - I.e. since there's only one `AmmoGroup` in the app, please alias
+  - I.e. since there's only one `Pack` in the app, please alias
-    `AmmoGroup.t()` instead of using `Cannery.Ammo.AmmoGroup.t()`
+    `Pack.t()` instead of using `Cannery.Ammo.Pack.t()`
 - Use pipelines when possible. If only calling a single method, a pipeline isn't
   strictly necessary but still encouraged for future modification.
 - Please add typespecs to your functions! Even your private functions may be

Dockerfile

@@ -1,4 +1,4 @@
-FROM elixir:1.14.1-alpine AS build
+FROM elixir:1.17.3-otp-27-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.hex --force && \
+RUN mix local.rebar --force && \
-    mix local.rebar --force
+    mix local.hex --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 libssl1.1 libcrypto1.1 libgcc libstdc++ ncurses-libs
+    apk add --no-cache bash openssl libssl3 libcrypto3 libgcc libstdc++ ncurses-libs
 
 WORKDIR /app
 

README.md

@@ -13,8 +13,8 @@ The self-hosted firearm tracker website.
 # Features
 
 - Create containers to store your ammunition, and tag them with custom tags
-- Add ammunition types to Cannery, and then ammunition groups to your containers
+- Add ammunition types to Cannery, and then ammo packs to your containers
-- Stage groups of ammo for range day and record your ammo usage
+- Stage ammo packs for range day and track your usage with shot records
 - Invitations via invite tokens or public registration
 
 # Installation
@@ -94,6 +94,7 @@ 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

assets/css/app.scss

@@ -8,6 +8,8 @@ $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 */
@@ -152,3 +154,57 @@ $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);
+}

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, MaintainAttrs, ShotLogChart }
+  hooks: { Date, DateTime, ShotLogChart, SlimSelect }
 })
 
 // Show progress bar on live navigation and form submits

assets/js/maintain_attrs.js

@@ -1,11 +0,0 @@
-// 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)) }
-}

assets/js/shot_log_chart.js

@@ -1,13 +1,12 @@
-import { Chart, Title, Tooltip, Legend, LineController, LineElement, PointElement, TimeScale, LinearScale } from 'chart.js'
+import Chart from 'chart.js/auto'
 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: 'line',
+      type: 'bar',
       data: {
         datasets: [{
           label: el.dataset.label,
@@ -51,13 +50,17 @@ export default {
             stacked: true,
             grace: '15%',
             ticks: {
-              padding: 15
+              padding: 15,
+              precision: 0
             }
           },
           x: {
-            type: 'time',
+            type: 'timeseries',
             time: {
               unit: 'day'
+            },
+            ticks: {
+              source: 'data'
             }
           }
         },

assets/js/slim_select.js

@@ -0,0 +1,23 @@
+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)
+  }
+}

assets/package.json

@@ -3,8 +3,8 @@
   "description": " ",
   "license": "MIT",
   "engines": {
-    "node": "v18.9.1",
+    "node": "v23.0.0",
-    "npm": "8.19.1"
+    "npm": "10.9.0"
   },
   "scripts": {
     "deploy": "NODE_ENV=production webpack --mode production",
@@ -13,37 +13,39 @@
     "test": "standard"
   },
   "dependencies": {
-    "@fortawesome/fontawesome-free": "^6.3.0",
+    "@fortawesome/fontawesome-free": "^6.6.0",
-    "chart.js": "^4.2.1",
+    "chart.js": "^4.4.5",
     "chartjs-adapter-date-fns": "^3.0.0",
-    "date-fns": "^2.29.3",
+    "date-fns": "^4.1.0",
     "phoenix": "file:../deps/phoenix",
     "phoenix_html": "file:../deps/phoenix_html",
     "phoenix_live_view": "file:../deps/phoenix_live_view",
-    "topbar": "^2.0.1"
+    "slim-select": "^2.9.2",
+    "topbar": "^3.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.21.3",
+    "@babel/core": "^7.26.0",
-    "@babel/preset-env": "^7.20.2",
+    "@babel/preset-env": "^7.26.0",
-    "autoprefixer": "^10.4.14",
+    "autoprefixer": "^10.4.20",
-    "babel-loader": "^9.1.2",
+    "babel-loader": "^9.2.1",
-    "copy-webpack-plugin": "^11.0.0",
+    "copy-webpack-plugin": "^12.0.2",
-    "css-loader": "^6.7.3",
+    "css-loader": "^7.1.2",
-    "css-minimizer-webpack-plugin": "^4.2.2",
+    "css-minimizer-webpack-plugin": "^7.0.0",
     "file-loader": "^6.2.0",
-    "mini-css-extract-plugin": "^2.7.5",
+    "glob": "^11.0.0",
-    "npm-check-updates": "^16.7.12",
+    "mini-css-extract-plugin": "^2.9.1",
-    "postcss": "^8.4.21",
+    "npm-check-updates": "^17.1.6",
-    "postcss-import": "^15.1.0",
+    "postcss": "^8.4.47",
-    "postcss-loader": "^7.1.0",
+    "postcss-import": "^16.1.0",
-    "postcss-preset-env": "^8.0.1",
+    "postcss-loader": "^8.1.1",
-    "sass": "^1.59.3",
+    "postcss-preset-env": "^10.0.8",
-    "sass-loader": "^13.2.1",
+    "sass": "^1.80.4",
-    "standard": "^17.0.0",
+    "sass-loader": "^16.0.2",
-    "tailwindcss": "^3.2.7",
+    "standard": "^17.1.2",
-    "terser-webpack-plugin": "^5.3.7",
+    "tailwindcss": "^3.4.14",
-    "webpack": "^5.76.2",
+    "terser-webpack-plugin": "^5.3.10",
-    "webpack-cli": "^5.0.1",
+    "webpack": "^5.95.0",
-    "webpack-dev-server": "^4.13.1"
+    "webpack-cli": "^5.1.4",
+    "webpack-dev-server": "^5.1.0"
   }
 }

assets/webpack.config.js

@@ -45,7 +45,7 @@ module.exports = (env, options) => {
         {
           test: /\.(woff(2)?|ttf|eot|svg|otf)(\?v=[0-9]\.[0-9]\.[0-9])?$/,
           type: 'asset/resource',
-          generator: { filename: 'fonts/[name][ext]' }
+          generator: { filename: 'fonts/[name].[ext]' }
         }
       ]
     },

config/config.exs

@@ -18,7 +18,10 @@ 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: [view: CanneryWeb.ErrorView, accepts: ~w(html json), layout: false],
+  render_errors: [
+    formats: [html: CanneryWeb.ErrorHTML, json: CanneryWeb.ErrorJSON],
+    layout: false
+  ],
   pubsub_server: Cannery.PubSub,
   live_view: [signing_salt: "zOLgd3lr"]
 

config/dev.exs

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

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.ViewHelpers, shibao_mode: System.get_env("SHIBAO_MODE") == "true"
+config :cannery, CanneryWeb.HTMLHelpers, shibao_mode: System.get_env("SHIBAO_MODE") == "true"
 
 # Set default locale
 config :gettext, :default_locale, System.get_env("LOCALE", "en_US")

config/test.exs

@@ -9,8 +9,9 @@ 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,
-  pool_size: 10
+  timeout: 60000
 
 # We don't run a server during test. If one is required,
 # you can enable the server option below.
@@ -26,10 +27,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: :warn
+config :logger, level: :warning
 
 # Initialize plugs at runtime for faster test compilation
 config :phoenix, :plug_init_mode, :runtime
 
 # Disable Oban
-config :cannery, Oban, queues: false, plugins: false
+config :cannery, Oban, queues: false, plugins: false, testing: :manual

lib/cannery.ex

@@ -6,4 +6,34 @@ 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

lib/cannery/accounts.ex

@@ -3,10 +3,9 @@ defmodule Cannery.Accounts do
   The Accounts context.
   """
 
-  import Ecto.Query, warn: false
+  use Cannery, :context
-  alias Cannery.{Mailer, Repo}
+  alias Cannery.Mailer
-  alias Cannery.Accounts.{Invite, Invites, User, UserToken}
+  alias Cannery.Accounts.{Invite, Invites, UserToken}
-  alias Ecto.{Changeset, Multi}
   alias Oban.Job
 
   ## Database getters
@@ -374,8 +373,8 @@ defmodule Cannery.Accounts do
   @doc """
   Deletes the signed token with the given context.
   """
-  @spec delete_session_token(token :: String.t()) :: :ok
+  @spec delete_user_session_token(token :: String.t()) :: :ok
-  def delete_session_token(token) do
+  def delete_user_session_token(token) do
     UserToken.token_and_context_query(token, "session") |> Repo.delete_all()
     :ok
   end
@@ -404,15 +403,15 @@ defmodule Cannery.Accounts do
 
   ## Examples
 
-      iex> is_admin?(%User{role: :admin})
+      iex> admin?(%User{role: :admin})
       true
 
-      iex> is_admin?(%User{})
+      iex> admin?(%User{})
       false
 
   """
-  @spec is_admin?(User.t()) :: boolean()
+  @spec admin?(User.t()) :: boolean()
-  def is_admin?(%User{id: user_id}) do
+  def admin?(%User{id: user_id}) do
     Repo.exists?(from u in User, where: u.id == ^user_id, where: u.role == :admin)
   end
 
@@ -421,16 +420,16 @@ defmodule Cannery.Accounts do
 
   ## Examples
 
-      iex> is_already_admin?(%User{role: :admin})
+      iex> already_admin?(%User{role: :admin})
       true
 
-      iex> is_already_admin?(%User{})
+      iex> already_admin?(%User{})
       false
 
   """
-  @spec is_already_admin?(User.t() | nil) :: boolean()
+  @spec already_admin?(User.t() | nil) :: boolean()
-  def is_already_admin?(%User{role: :admin}), do: true
+  def already_admin?(%User{role: :admin}), do: true
-  def is_already_admin?(_invalid_user), do: false
+  def already_admin?(_invalid_user), do: false
 
   ## Confirmation
 

lib/cannery/accounts/invite.ex

@@ -5,13 +5,8 @@ defmodule Cannery.Accounts.Invite do
   `:uses_left` is defined.
   """
 
-  use Ecto.Schema
+  use Cannery, :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
@@ -48,8 +43,9 @@ defmodule Cannery.Accounts.Invite do
     %__MODULE__{}
     |> change(token: token, created_by_id: user_id)
     |> cast(attrs, [:name, :uses_left, :disabled_at])
-    |> validate_required([:name, :token, :created_by_id])
+    |> validate_length(:name, max: 255)
     |> validate_number(:uses_left, greater_than_or_equal_to: 0)
+    |> validate_required([:name, :token, :created_by_id])
   end
 
   @doc false
@@ -57,7 +53,8 @@ defmodule Cannery.Accounts.Invite do
   def update_changeset(invite, attrs) do
     invite
     |> cast(attrs, [:name, :uses_left, :disabled_at])
-    |> validate_required([:name])
+    |> validate_length(:name, max: 255)
     |> validate_number(:uses_left, greater_than_or_equal_to: 0)
+    |> validate_required([:name])
   end
 end

lib/cannery/accounts/invites.ex

@@ -3,10 +3,8 @@ defmodule Cannery.Accounts.Invites do
   The Invites context.
   """
 
-  import Ecto.Query, warn: false
+  use Cannery, :context
-  alias Ecto.Multi
+  alias Cannery.Accounts.Invite
-  alias Cannery.Accounts.{Invite, User}
-  alias Cannery.Repo
 
   @invite_token_length 20
 

lib/cannery/accounts/user.ex

@@ -3,11 +3,8 @@ defmodule Cannery.Accounts.User do
   A Cannery user
   """
 
-  use Ecto.Schema
+  use Cannery, :schema
-  import Ecto.Changeset
+  alias Cannery.Accounts.Invite
-  import CanneryWeb.Gettext
-  alias Ecto.{Association, Changeset, UUID}
-  alias Cannery.Accounts.{Invite, User}
 
   @derive {Jason.Encoder,
            only: [
@@ -20,8 +17,6 @@ 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
@@ -79,6 +74,7 @@ defmodule Cannery.Accounts.User do
     %User{}
     |> cast(attrs, [:email, :password, :locale])
     |> put_change(:invite_id, if(invite, do: invite.id))
+    |> validate_length(:locale, max: 255)
     |> validate_email()
     |> validate_password(opts)
   end
@@ -209,6 +205,7 @@ defmodule Cannery.Accounts.User do
   def locale_changeset(user_or_changeset, locale) do
     user_or_changeset
     |> cast(%{"locale" => locale}, [:locale])
+    |> validate_length(:locale, max: 255)
     |> validate_required(:locale)
   end
 end

lib/cannery/accounts/user_token.ex

@@ -3,10 +3,7 @@ defmodule Cannery.Accounts.UserToken do
   Schema for a user's session token
   """
 
-  use Ecto.Schema
+  use Cannery, :schema
-  import Ecto.Query
-  alias Cannery.Accounts.User
-  alias Ecto.{Association, UUID}
 
   @hash_algorithm :sha256
   @rand_size 32
@@ -18,8 +15,6 @@ 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

lib/cannery/activity_log.ex

@@ -3,350 +3,435 @@ defmodule Cannery.ActivityLog do
   The ActivityLog context.
   """
 
-  import Ecto.Query, warn: false
+  use Cannery, :context
-  alias Cannery.Ammo.{AmmoGroup, AmmoType}
+  alias Cannery.{ActivityLog.ShotRecord, Ammo.Pack, Ammo.Type}
-  alias Cannery.{Accounts.User, ActivityLog.ShotGroup, Repo}
+
-  alias Ecto.Multi
+  @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()]
 
   @doc """
-  Returns the list of shot_groups.
+  Returns the list of shot_records.
 
   ## Examples
 
-      iex> list_shot_groups(%User{id: 123})
+      iex> list_shot_records(%User{id: 123})
-      [%ShotGroup{}, ...]
+      [%ShotRecord{}, ...]
 
-      iex> list_shot_groups("cool", %User{id: 123})
+      iex> list_shot_records(%User{id: 123}, search: "cool")
-      [%ShotGroup{notes: "My cool shot group"}, ...]
+      [%ShotRecord{notes: "My cool shot record"}, ...]
+
+      iex> list_shot_records(%User{id: 123}, search: "cool", class: :rifle)
+      [%ShotRecord{notes: "Shot some rifle rounds"}, ...]
+
+      iex> list_shot_records(%User{id: 123}, pack_id: 456)
+      [%ShotRecord{pack_id: 456}, ...]
 
   """
-  @spec list_shot_groups(User.t()) :: [ShotGroup.t()]
+  @spec list_shot_records(User.t()) :: [ShotRecord.t()]
-  @spec list_shot_groups(search :: nil | String.t(), User.t()) :: [ShotGroup.t()]
+  @spec list_shot_records(User.t(), list_shot_records_options()) :: [ShotRecord.t()]
-  def list_shot_groups(search \\ nil, user)
+  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
+    )
+    |> 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))
+    |> Repo.all()
+  end
 
-  def list_shot_groups(search, %{id: user_id}) when search |> is_nil() or search == "",
+  @spec list_shot_records_search(Queryable.t(), search :: String.t() | nil) ::
-    do: Repo.all(from sg in ShotGroup, where: sg.user_id == ^user_id)
+          Queryable.t()
+  defp list_shot_records_search(query, search) when search in ["", nil], do: query
 
-  def list_shot_groups(search, %{id: user_id}) when search |> is_binary() do
+  defp list_shot_records_search(query, search) when search |> is_binary() do
     trimmed_search = String.trim(search)
 
-    Repo.all(
+    query
-      from sg in ShotGroup,
+    |> where(
-        left_join: ag in AmmoGroup,
+      [sr: sr, p: p, t: t],
-        on: sg.ammo_group_id == ag.id,
+      fragment(
-        left_join: at in AmmoType,
+        "? @@ websearch_to_tsquery('english', ?)",
-        on: ag.ammo_type_id == at.id,
+        sr.search,
-        where: sg.user_id == ^user_id,
+        ^trimmed_search
-        where:
+      ) or
-          fragment(
+        fragment(
-            "? @@ websearch_to_tsquery('english', ?)",
+          "? @@ websearch_to_tsquery('english', ?)",
-            sg.search,
+          p.search,
-            ^trimmed_search
+          ^trimmed_search
-          ) or
+        ) or
-            fragment(
+        fragment(
-              "? @@ websearch_to_tsquery('english', ?)",
+          "? @@ websearch_to_tsquery('english', ?)",
-              ag.search,
+          t.search,
-              ^trimmed_search
+          ^trimmed_search
-            ) or
+        )
-            fragment(
-              "? @@ websearch_to_tsquery('english', ?)",
-              at.search,
-              ^trimmed_search
-            ),
-        order_by: {
-          :desc,
-          fragment(
-            "ts_rank_cd(?, websearch_to_tsquery('english', ?), 4)",
-            sg.search,
-            ^trimmed_search
-          )
-        }
     )
+    |> order_by([sr: sr], {
+      :desc,
+      fragment(
+        "ts_rank_cd(?, websearch_to_tsquery('english', ?), 4)",
+        sr.search,
+        ^trimmed_search
+      )
+    })
   end
 
-  @spec list_shot_groups_for_ammo_group(AmmoGroup.t(), User.t()) :: [ShotGroup.t()]
+  @spec list_shot_records_class(Queryable.t(), Type.class() | :all | nil) :: Queryable.t()
-  def list_shot_groups_for_ammo_group(
+  defp list_shot_records_class(query, class) when class in [:rifle, :pistol, :shotgun],
-        %AmmoGroup{id: ammo_group_id, user_id: user_id},
+    do: query |> where([t: t], t.class == ^class)
-        %User{id: user_id}
+
-      ) do
+  defp list_shot_records_class(query, _all), do: query
-    Repo.all(
+
-      from sg in ShotGroup,
+  @spec list_shot_records_pack_id(Queryable.t(), Pack.id() | nil) :: Queryable.t()
-        where: sg.ammo_group_id == ^ammo_group_id,
+  defp list_shot_records_pack_id(query, pack_id) when pack_id |> is_binary(),
-        where: sg.user_id == ^user_id
+    do: query |> where([sr: sr], sr.pack_id == ^pack_id)
-    )
+
-  end
+  defp list_shot_records_pack_id(query, _all), do: query
 
   @doc """
-  Gets a single shot_group.
+  Returns a count of shot records.
-
-  Raises `Ecto.NoResultsError` if the Shot group does not exist.
 
   ## Examples
 
-      iex> get_shot_group!(123, %User{id: 123})
+      iex> get_shot_record_count!(%User{id: 123})
-      %ShotGroup{}
+      3
 
-      iex> get_shot_group!(456, %User{id: 123})
+  """
+  @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),
+        distinct: true
+    ) || 0
+  end
+
+  @doc """
+  Gets a single shot_record.
+
+  Raises `Ecto.NoResultsError` if the shot record does not exist.
+
+  ## Examples
+
+      iex> get_shot_record!(123, %User{id: 123})
+      %ShotRecord{}
+
+      iex> get_shot_record!(456, %User{id: 123})
       ** (Ecto.NoResultsError)
 
   """
-  @spec get_shot_group!(ShotGroup.id(), User.t()) :: ShotGroup.t()
+  @spec get_shot_record!(ShotRecord.id(), User.t()) :: ShotRecord.t()
-  def get_shot_group!(id, %User{id: user_id}) do
+  def get_shot_record!(id, %User{id: user_id}) do
     Repo.one!(
-      from sg in ShotGroup,
+      from sr in ShotRecord,
-        where: sg.id == ^id,
+        where: sr.id == ^id,
-        where: sg.user_id == ^user_id,
+        where: sr.user_id == ^user_id,
-        order_by: sg.date
+        order_by: sr.date
     )
   end
 
   @doc """
-  Creates a shot_group.
+  Creates a shot_record.
 
   ## Examples
 
-      iex> create_shot_group(%{field: value}, %User{id: 123})
+      iex> create_shot_record(%{field: value}, %User{id: 123})
-      {:ok, %ShotGroup{}}
+      {:ok, %ShotRecord{}}
 
-      iex> create_shot_group(%{field: bad_value}, %User{id: 123})
+      iex> create_shot_record(%{field: bad_value}, %User{id: 123})
       {:error, %Ecto.Changeset{}}
 
   """
-  @spec create_shot_group(attrs :: map(), User.t(), AmmoGroup.t()) ::
+  @spec create_shot_record(attrs :: map(), User.t(), Pack.t()) ::
-          {:ok, ShotGroup.t()} | {:error, ShotGroup.changeset() | nil}
+          {:ok, ShotRecord.t()} | {:error, ShotRecord.changeset() | nil}
-  def create_shot_group(attrs, user, ammo_group) do
+  def create_shot_record(attrs, user, pack) do
     Multi.new()
     |> Multi.insert(
-      :create_shot_group,
+      :create_shot_record,
-      %ShotGroup{} |> ShotGroup.create_changeset(user, ammo_group, attrs)
+      %ShotRecord{} |> ShotRecord.create_changeset(user, pack, attrs)
     )
     |> Multi.run(
-      :ammo_group,
+      :pack,
-      fn _repo, %{create_shot_group: %{ammo_group_id: ammo_group_id, user_id: user_id}} ->
+      fn _repo, %{create_shot_record: %{pack_id: pack_id, user_id: user_id}} ->
-        ammo_group =
+        pack =
           Repo.one(
-            from ag in AmmoGroup,
+            from p in Pack,
-              where: ag.id == ^ammo_group_id,
+              where: p.id == ^pack_id,
-              where: ag.user_id == ^user_id
+              where: p.user_id == ^user_id
           )
 
-        {:ok, ammo_group}
+        {:ok, pack}
       end
     )
     |> Multi.update(
-      :update_ammo_group,
+      :update_pack,
-      fn %{create_shot_group: %{count: shot_group_count}, ammo_group: %{count: ammo_group_count}} ->
+      fn %{create_shot_record: %{count: shot_record_count}, pack: %{count: pack_count}} ->
-        ammo_group |> AmmoGroup.range_changeset(%{"count" => ammo_group_count - shot_group_count})
+        pack |> Pack.range_changeset(%{"count" => pack_count - shot_record_count})
       end
     )
     |> Repo.transaction()
     |> case do
-      {:ok, %{create_shot_group: shot_group}} -> {:ok, shot_group}
+      {:ok, %{create_shot_record: shot_record}} -> {:ok, shot_record}
-      {:error, :create_shot_group, changeset, _changes_so_far} -> {:error, changeset}
+      {:error, :create_shot_record, changeset, _changes_so_far} -> {:error, changeset}
       {:error, _other_transaction, _value, _changes_so_far} -> {:error, nil}
     end
   end
 
   @doc """
-  Updates a shot_group.
+  Updates a shot_record.
 
   ## Examples
 
-      iex> update_shot_group(shot_group, %{field: new_value}, %User{id: 123})
+      iex> update_shot_record(shot_record, %{field: new_value}, %User{id: 123})
-      {:ok, %ShotGroup{}}
+      {:ok, %ShotRecord{}}
 
-      iex> update_shot_group(shot_group, %{field: bad_value}, %User{id: 123})
+      iex> update_shot_record(shot_record, %{field: bad_value}, %User{id: 123})
       {:error, %Ecto.Changeset{}}
 
   """
-  @spec update_shot_group(ShotGroup.t(), attrs :: map(), User.t()) ::
+  @spec update_shot_record(ShotRecord.t(), attrs :: map(), User.t()) ::
-          {:ok, ShotGroup.t()} | {:error, ShotGroup.changeset() | nil}
+          {:ok, ShotRecord.t()} | {:error, ShotRecord.changeset() | nil}
-  def update_shot_group(
+  def update_shot_record(
-        %ShotGroup{count: count, user_id: user_id} = shot_group,
+        %ShotRecord{count: count, user_id: user_id} = shot_record,
         attrs,
         %User{id: user_id} = user
       ) do
     Multi.new()
     |> Multi.update(
-      :update_shot_group,
+      :update_shot_record,
-      shot_group |> ShotGroup.update_changeset(user, attrs)
+      shot_record |> ShotRecord.update_changeset(user, attrs)
     )
     |> Multi.run(
-      :ammo_group,
+      :pack,
-      fn repo, %{update_shot_group: %{ammo_group_id: ammo_group_id, user_id: user_id}} ->
+      fn repo, %{update_shot_record: %{pack_id: pack_id, user_id: user_id}} ->
-        {:ok,
+        {:ok, repo.one(from p in Pack, where: p.id == ^pack_id and p.user_id == ^user_id)}
-         repo.one(from ag in AmmoGroup, where: ag.id == ^ammo_group_id and ag.user_id == ^user_id)}
       end
     )
     |> Multi.update(
-      :update_ammo_group,
+      :update_pack,
       fn %{
-           update_shot_group: %{count: new_count},
+           update_shot_record: %{count: new_count},
-           ammo_group: %{count: ammo_group_count} = ammo_group
+           pack: %{count: pack_count} = pack
          } ->
         shot_diff_to_add = new_count - count
-        new_ammo_group_count = ammo_group_count - shot_diff_to_add
+        new_pack_count = pack_count - shot_diff_to_add
-        ammo_group |> AmmoGroup.range_changeset(%{"count" => new_ammo_group_count})
+        pack |> Pack.range_changeset(%{"count" => new_pack_count})
       end
     )
     |> Repo.transaction()
     |> case do
-      {:ok, %{update_shot_group: shot_group}} -> {:ok, shot_group}
+      {:ok, %{update_shot_record: shot_record}} -> {:ok, shot_record}
-      {:error, :update_shot_group, changeset, _changes_so_far} -> {:error, changeset}
+      {:error, :update_shot_record, changeset, _changes_so_far} -> {:error, changeset}
       {:error, _other_transaction, _value, _changes_so_far} -> {:error, nil}
     end
   end
 
   @doc """
-  Deletes a shot_group.
+  Deletes a shot_record.
 
   ## Examples
 
-      iex> delete_shot_group(shot_group, %User{id: 123})
+      iex> delete_shot_record(shot_record, %User{id: 123})
-      {:ok, %ShotGroup{}}
+      {:ok, %ShotRecord{}}
 
-      iex> delete_shot_group(shot_group, %User{id: 123})
+      iex> delete_shot_record(shot_record, %User{id: 123})
       {:error, %Ecto.Changeset{}}
 
   """
-  @spec delete_shot_group(ShotGroup.t(), User.t()) ::
+  @spec delete_shot_record(ShotRecord.t(), User.t()) ::
-          {:ok, ShotGroup.t()} | {:error, ShotGroup.changeset()}
+          {:ok, ShotRecord.t()} | {:error, ShotRecord.changeset()}
-  def delete_shot_group(
+  def delete_shot_record(
-        %ShotGroup{user_id: user_id} = shot_group,
+        %ShotRecord{user_id: user_id} = shot_record,
         %User{id: user_id}
       ) do
     Multi.new()
-    |> Multi.delete(:delete_shot_group, shot_group)
+    |> Multi.delete(:delete_shot_record, shot_record)
     |> Multi.run(
-      :ammo_group,
+      :pack,
-      fn repo, %{delete_shot_group: %{ammo_group_id: ammo_group_id, user_id: user_id}} ->
+      fn repo, %{delete_shot_record: %{pack_id: pack_id, user_id: user_id}} ->
-        {:ok,
+        {:ok, repo.one(from p in Pack, where: p.id == ^pack_id and p.user_id == ^user_id)}
-         repo.one(from ag in AmmoGroup, where: ag.id == ^ammo_group_id and ag.user_id == ^user_id)}
       end
     )
     |> Multi.update(
-      :update_ammo_group,
+      :update_pack,
       fn %{
-           delete_shot_group: %{count: count},
+           delete_shot_record: %{count: count},
-           ammo_group: %{count: ammo_group_count} = ammo_group
+           pack: %{count: pack_count} = pack
          } ->
-        new_ammo_group_count = ammo_group_count + count
+        new_pack_count = pack_count + count
-        ammo_group |> AmmoGroup.range_changeset(%{"count" => new_ammo_group_count})
+        pack |> Pack.range_changeset(%{"count" => new_pack_count})
       end
     )
     |> Repo.transaction()
     |> case do
-      {:ok, %{delete_shot_group: shot_group}} -> {:ok, shot_group}
+      {:ok, %{delete_shot_record: shot_record}} -> {:ok, shot_record}
-      {:error, :delete_shot_group, changeset, _changes_so_far} -> {:error, changeset}
+      {:error, :delete_shot_record, changeset, _changes_so_far} -> {:error, changeset}
       {:error, _other_transaction, _value, _changes_so_far} -> {:error, nil}
     end
   end
 
   @doc """
-  Returns the number of shot rounds for an ammo group
+  Returns the last entered shot record date for a pack
   """
-  @spec get_used_count(AmmoGroup.t(), User.t()) :: non_neg_integer()
+  @spec get_last_used_date(Pack.t(), User.t()) :: Date.t() | nil
-  def get_used_count(%AmmoGroup{id: ammo_group_id} = ammo_group, user) do
+  def get_last_used_date(%Pack{id: pack_id} = pack, user) do
-    [ammo_group]
+    [pack]
-    |> get_used_counts(user)
-    |> Map.get(ammo_group_id, 0)
-  end
-
-  @doc """
-  Returns the number of shot rounds for multiple ammo groups
-  """
-  @spec get_used_counts([AmmoGroup.t()], User.t()) ::
-          %{optional(AmmoGroup.id()) => non_neg_integer()}
-  def get_used_counts(ammo_groups, %User{id: user_id}) do
-    ammo_group_ids =
-      ammo_groups
-      |> Enum.map(fn %{id: ammo_group_id} -> ammo_group_id end)
-
-    Repo.all(
-      from sg in ShotGroup,
-        where: sg.ammo_group_id in ^ammo_group_ids,
-        where: sg.user_id == ^user_id,
-        group_by: sg.ammo_group_id,
-        select: {sg.ammo_group_id, sum(sg.count)}
-    )
-    |> Map.new()
-  end
-
-  @doc """
-  Returns the last entered shot group date for an ammo group
-  """
-  @spec get_last_used_date(AmmoGroup.t(), User.t()) :: Date.t() | nil
-  def get_last_used_date(%AmmoGroup{id: ammo_group_id} = ammo_group, user) do
-    [ammo_group]
     |> get_last_used_dates(user)
-    |> Map.get(ammo_group_id)
+    |> Map.get(pack_id)
   end
 
   @doc """
-  Returns the last entered shot group date for an ammo group
+  Returns the last entered shot record date for a pack
   """
-  @spec get_last_used_dates([AmmoGroup.t()], User.t()) :: %{optional(AmmoGroup.id()) => Date.t()}
+  @spec get_last_used_dates([Pack.t()], User.t()) :: %{optional(Pack.id()) => Date.t()}
-  def get_last_used_dates(ammo_groups, %User{id: user_id}) do
+  def get_last_used_dates(packs, %User{id: user_id}) do
-    ammo_group_ids =
+    pack_ids =
-      ammo_groups
+      packs
-      |> Enum.map(fn %AmmoGroup{id: ammo_group_id, user_id: ^user_id} -> ammo_group_id end)
+      |> Enum.map(fn %Pack{id: pack_id, user_id: ^user_id} -> pack_id end)
 
     Repo.all(
-      from sg in ShotGroup,
+      from sr in ShotRecord,
-        where: sg.ammo_group_id in ^ammo_group_ids,
+        where: sr.pack_id in ^pack_ids,
-        where: sg.user_id == ^user_id,
+        where: sr.user_id == ^user_id,
-        group_by: sg.ammo_group_id,
+        group_by: sr.pack_id,
-        select: {sg.ammo_group_id, max(sg.date)}
+        select: {sr.pack_id, max(sr.date)}
     )
     |> Map.new()
   end
 
-  @doc """
+  @type get_used_count_option :: {:pack_id, Pack.id() | nil} | {:type_id, Type.id() | nil}
-  Gets the total number of rounds shot for an ammo type
+  @type get_used_count_options :: [get_used_count_option()]
 
-  Raises `Ecto.NoResultsError` if the Ammo type does not exist.
+  @doc """
+  Gets the total number of rounds shot for a type
+
+  Raises `Ecto.NoResultsError` if the type does not exist.
 
   ## Examples
 
-      iex> get_used_count_for_ammo_type(123, %User{id: 123})
+      iex> get_used_count(%User{id: 123}, type_id: 123)
       35
 
-      iex> get_used_count_for_ammo_type(456, %User{id: 123})
+      iex> get_used_count(%User{id: 123}, pack_id: 456)
-      ** (Ecto.NoResultsError)
+      50
 
   """
-  @spec get_used_count_for_ammo_type(AmmoType.t(), User.t()) :: non_neg_integer()
+  @spec get_used_count(User.t(), get_used_count_options()) :: non_neg_integer()
-  def get_used_count_for_ammo_type(%AmmoType{id: ammo_type_id} = ammo_type, user) do
+  def get_used_count(%User{id: user_id}, opts) do
-    [ammo_type]
+    from(sr in ShotRecord,
-    |> get_used_count_for_ammo_types(user)
+      as: :sr,
-    |> Map.get(ammo_type_id, 0)
+      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
   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 ammo types
+  Gets the total number of rounds shot for multiple types or packs
 
   ## Examples
 
-      iex> get_used_count_for_ammo_types(123, %User{id: 123})
+      iex> get_grouped_used_counts(
+      ...>   %User{id: 123},
+      ...>   group_by: :type_id,
+      ...>   types: [%Type{id: 456, user_id: 123}]
+      ...> )
       35
 
-  """
+      iex> get_grouped_used_counts(
-  @spec get_used_count_for_ammo_types([AmmoType.t()], User.t()) ::
+      ...>   %User{id: 123},
-          %{optional(AmmoType.id()) => non_neg_integer()}
+      ...>   group_by: :pack_id,
-  def get_used_count_for_ammo_types(ammo_types, %User{id: user_id}) do
+      ...>   packs: [%Pack{id: 456, user_id: 123}]
-    ammo_type_ids =
+      ...> )
-      ammo_types
+      22
-      |> Enum.map(fn %AmmoType{id: ammo_type_id, user_id: ^user_id} -> ammo_type_id end)
 
-    Repo.all(
+  """
-      from ag in AmmoGroup,
+  @spec get_grouped_used_counts(User.t(), get_grouped_used_counts_options()) ::
-        left_join: sg in ShotGroup,
+          %{optional(Type.id() | Pack.id()) => non_neg_integer()}
-        on: ag.id == sg.ammo_group_id,
+  def get_grouped_used_counts(%User{id: user_id}, opts) do
-        where: ag.ammo_type_id in ^ammo_type_ids,
+    from(p in Pack,
-        where: not (sg.count |> is_nil()),
+      as: :p,
-        group_by: ag.ammo_type_id,
+      left_join: sr in ShotRecord,
-        select: {ag.ammo_type_id, sum(sg.count)}
+      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())
     )
+    |> 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

lib/cannery/activity_log/shot_record.ex

@@ -1,13 +1,10 @@
-defmodule Cannery.ActivityLog.ShotGroup do
+defmodule Cannery.ActivityLog.ShotRecord do
   @moduledoc """
-  A shot group records a group of ammo shot during a range trip
+  A shot record records a group of ammo shot during a range trip
   """
 
-  use Ecto.Schema
+  use Cannery, :schema
-  import CanneryWeb.Gettext
+  alias Cannery.{Ammo, Ammo.Pack}
-  import Ecto.Changeset
-  alias Cannery.{Accounts.User, Ammo, Ammo.AmmoGroup}
-  alias Ecto.{Changeset, UUID}
 
   @derive {Jason.Encoder,
            only: [
@@ -15,17 +12,17 @@ defmodule Cannery.ActivityLog.ShotGroup do
              :count,
              :date,
              :notes,
-             :ammo_group_id
+             :pack_id
            ]}
   @primary_key {:id, :binary_id, autogenerate: true}
   @foreign_key_type :binary_id
-  schema "shot_groups" do
+  schema "shot_records" do
     field :count, :integer
     field :date, :date
     field :notes, :string
 
     field :user_id, :binary_id
-    field :ammo_group_id, :binary_id
+    field :pack_id, :binary_id
 
     timestamps()
   end
@@ -35,57 +32,57 @@ defmodule Cannery.ActivityLog.ShotGroup do
           count: integer,
           notes: String.t() | nil,
           date: Date.t() | nil,
-          ammo_group_id: AmmoGroup.id(),
+          pack_id: Pack.id(),
           user_id: User.id(),
           inserted_at: NaiveDateTime.t(),
           updated_at: NaiveDateTime.t()
         }
-  @type new_shot_group :: %__MODULE__{}
+  @type new_shot_record :: %__MODULE__{}
   @type id :: UUID.t()
-  @type changeset :: Changeset.t(t() | new_shot_group())
+  @type changeset :: Changeset.t(t() | new_shot_record())
 
   @doc false
   @spec create_changeset(
-          new_shot_group(),
+          new_shot_record(),
           User.t() | any(),
-          AmmoGroup.t() | any(),
+          Pack.t() | any(),
           attrs :: map()
         ) :: changeset()
   def create_changeset(
-        shot_group,
+        shot_record,
         %User{id: user_id},
-        %AmmoGroup{id: ammo_group_id, user_id: user_id} = ammo_group,
+        %Pack{id: pack_id, user_id: user_id} = pack,
         attrs
       ) do
-    shot_group
+    shot_record
     |> change(user_id: user_id)
-    |> change(ammo_group_id: ammo_group_id)
+    |> change(pack_id: pack_id)
     |> cast(attrs, [:count, :notes, :date])
-    |> validate_create_shot_group_count(ammo_group)
+    |> validate_length(:notes, max: 255)
-    |> validate_required([:date, :ammo_group_id, :user_id])
+    |> validate_create_shot_record_count(pack)
+    |> validate_required([:date, :pack_id, :user_id])
   end
 
-  def create_changeset(shot_group, _invalid_user, _invalid_ammo_group, attrs) do
+  def create_changeset(shot_record, _invalid_user, _invalid_pack, attrs) do
-    shot_group
+    shot_record
     |> cast(attrs, [:count, :notes, :date])
-    |> validate_required([:ammo_group_id, :user_id])
+    |> validate_length(:notes, max: 255)
+    |> validate_required([:pack_id, :user_id])
     |> add_error(:invalid, dgettext("errors", "Please select a valid user and ammo pack"))
   end
 
-  defp validate_create_shot_group_count(changeset, %AmmoGroup{count: ammo_group_count}) do
+  defp validate_create_shot_record_count(changeset, %Pack{count: pack_count}) do
     case changeset |> Changeset.get_field(:count) do
       nil ->
         changeset |> Changeset.add_error(:ammo_left, dgettext("errors", "can't be blank"))
 
-      count when count > ammo_group_count ->
+      count when count > pack_count ->
         changeset
         |> Changeset.add_error(:ammo_left, dgettext("errors", "Ammo left must be at least 0"))
 
       count when count <= 0 ->
         error =
-          dgettext("errors", "Ammo left can be at most %{count} rounds",
+          dgettext("errors", "Ammo left can be at most %{count} rounds", count: pack_count - 1)
-            count: ammo_group_count - 1
-          )
 
         changeset |> Changeset.add_error(:ammo_left, error)
 
@@ -95,28 +92,28 @@ defmodule Cannery.ActivityLog.ShotGroup do
   end
 
   @doc false
-  @spec update_changeset(t() | new_shot_group(), User.t(), attrs :: map()) :: changeset()
+  @spec update_changeset(t() | new_shot_record(), User.t(), attrs :: map()) :: changeset()
-  def update_changeset(%__MODULE__{} = shot_group, user, attrs) do
+  def update_changeset(%__MODULE__{} = shot_record, user, attrs) do
-    shot_group
+    shot_record
     |> cast(attrs, [:count, :notes, :date])
+    |> validate_length(:notes, max: 255)
     |> validate_number(:count, greater_than: 0)
     |> validate_required([:count, :date])
-    |> validate_update_shot_group_count(shot_group, user)
+    |> validate_update_shot_record_count(shot_record, user)
   end
 
-  defp validate_update_shot_group_count(
+  defp validate_update_shot_record_count(
          changeset,
-         %__MODULE__{ammo_group_id: ammo_group_id, count: count},
+         %__MODULE__{pack_id: pack_id, count: count},
          user
        ) do
-    %{count: ammo_group_count} = Ammo.get_ammo_group!(ammo_group_id, user)
+    %{count: pack_count} = Ammo.get_pack!(pack_id, user)
 
-    new_shot_group_count = changeset |> Changeset.get_field(:count)
+    new_shot_record_count = changeset |> Changeset.get_field(:count)
-    shot_diff_to_add = new_shot_group_count - count
+    shot_diff_to_add = new_shot_record_count - count
 
-    if shot_diff_to_add > ammo_group_count do
+    if shot_diff_to_add > pack_count do
-      error =
+      error = dgettext("errors", "Count can be at most %{count} shots", count: pack_count + count)
-        dgettext("errors", "Count can be at most %{count} shots", count: ammo_group_count + count)
 
       changeset |> Changeset.add_error(:count, error)
     else

lib/cannery/ammo/ammo_group.ex

@@ -1,125 +0,0 @@
-defmodule Cannery.Ammo.AmmoGroup do
-  @moduledoc """
-  A group of a certain ammunition type.
-
-  Can be placed in a container, and contains auxiliary information such as the
-  amount paid for that ammunition, or what condition it is in
-  """
-
-  use Ecto.Schema
-  import CanneryWeb.Gettext
-  import Ecto.Changeset
-  alias Cannery.Ammo.AmmoType
-  alias Cannery.{Accounts.User, Containers, Containers.Container}
-  alias Ecto.{Changeset, UUID}
-
-  @derive {Jason.Encoder,
-           only: [
-             :id,
-             :count,
-             :notes,
-             :price_paid,
-             :staged,
-             :ammo_type_id,
-             :container_id
-           ]}
-  @primary_key {:id, :binary_id, autogenerate: true}
-  @foreign_key_type :binary_id
-  schema "ammo_groups" do
-    field :count, :integer
-    field :notes, :string
-    field :price_paid, :float
-    field :staged, :boolean, default: false
-    field :purchased_on, :date
-
-    belongs_to :ammo_type, AmmoType
-    field :container_id, :binary_id
-    field :user_id, :binary_id
-
-    timestamps()
-  end
-
-  @type t :: %__MODULE__{
-          id: id(),
-          count: integer,
-          notes: String.t() | nil,
-          price_paid: float() | nil,
-          staged: boolean(),
-          purchased_on: Date.t(),
-          ammo_type: AmmoType.t() | nil,
-          ammo_type_id: AmmoType.id(),
-          container_id: Container.id(),
-          user_id: User.id(),
-          inserted_at: NaiveDateTime.t(),
-          updated_at: NaiveDateTime.t()
-        }
-  @type new_ammo_group :: %__MODULE__{}
-  @type id :: UUID.t()
-  @type changeset :: Changeset.t(t() | new_ammo_group())
-
-  @doc false
-  @spec create_changeset(
-          new_ammo_group(),
-          AmmoType.t() | nil,
-          Container.t() | nil,
-          User.t(),
-          attrs :: map()
-        ) :: changeset()
-  def create_changeset(
-        ammo_group,
-        %AmmoType{id: ammo_type_id},
-        %Container{id: container_id, user_id: user_id},
-        %User{id: user_id},
-        attrs
-      )
-      when is_binary(ammo_type_id) and is_binary(container_id) and is_binary(user_id) do
-    ammo_group
-    |> change(ammo_type_id: ammo_type_id)
-    |> change(user_id: user_id)
-    |> change(container_id: container_id)
-    |> cast(attrs, [:count, :price_paid, :notes, :staged, :purchased_on])
-    |> validate_number(:count, greater_than: 0)
-    |> validate_required([:count, :staged, :purchased_on, :ammo_type_id, :container_id, :user_id])
-  end
-
-  @doc """
-  Invalid changeset, used to prompt user to select ammo type and container
-  """
-  def create_changeset(ammo_group, _invalid_ammo_type, _invalid_container, _invalid_user, attrs) do
-    ammo_group
-    |> cast(attrs, [:ammo_type_id, :container_id])
-    |> validate_required([:ammo_type_id, :container_id])
-    |> add_error(:invalid, dgettext("errors", "Please select an ammo type and container"))
-  end
-
-  @doc false
-  @spec update_changeset(t() | new_ammo_group(), attrs :: map(), User.t()) :: changeset()
-  def update_changeset(ammo_group, attrs, user) do
-    ammo_group
-    |> cast(attrs, [:count, :price_paid, :notes, :staged, :purchased_on, :container_id])
-    |> validate_number(:count, greater_than_or_equal_to: 0)
-    |> validate_container_id(user)
-    |> validate_required([:count, :staged, :purchased_on, :container_id])
-  end
-
-  defp validate_container_id(changeset, user) do
-    container_id = changeset |> Changeset.get_field(:container_id)
-
-    if container_id do
-      Containers.get_container!(container_id, user)
-    end
-
-    changeset
-  end
-
-  @doc """
-  This range changeset is used when "using up" ammo groups, and allows for
-  updating the count to 0
-  """
-  @spec range_changeset(t() | new_ammo_group(), attrs :: map()) :: changeset()
-  def range_changeset(ammo_group, attrs) do
-    ammo_group
-    |> cast(attrs, [:count, :staged])
-    |> validate_required([:count, :staged])
-  end
-end

lib/cannery/ammo/ammo_type.ex

@@ -1,148 +0,0 @@
-defmodule Cannery.Ammo.AmmoType do
-  @moduledoc """
-  An ammunition type.
-
-  Contains statistical information about the ammunition.
-  """
-
-  use Ecto.Schema
-  import Ecto.Changeset
-  alias Cannery.Accounts.User
-  alias Cannery.Ammo.AmmoGroup
-  alias Ecto.{Changeset, UUID}
-
-  @derive {Jason.Encoder,
-           only: [
-             :id,
-             :name,
-             :desc,
-             :bullet_type,
-             :bullet_core,
-             :cartridge,
-             :caliber,
-             :case_material,
-             :jacket_type,
-             :muzzle_velocity,
-             :powder_type,
-             :powder_grains_per_charge,
-             :grains,
-             :pressure,
-             :primer_type,
-             :firing_type,
-             :tracer,
-             :incendiary,
-             :blank,
-             :corrosive,
-             :manufacturer,
-             :upc
-           ]}
-  @primary_key {:id, :binary_id, autogenerate: true}
-  @foreign_key_type :binary_id
-  schema "ammo_types" do
-    field :name, :string
-    field :desc, :string
-
-    # https://en.wikipedia.org/wiki/Bullet#Abbreviations
-    field :bullet_type, :string
-    field :bullet_core, :string
-    field :cartridge, :string
-    field :caliber, :string
-    field :case_material, :string
-    field :jacket_type, :string
-    field :muzzle_velocity, :integer
-    field :powder_type, :string
-    field :powder_grains_per_charge, :integer
-    field :grains, :integer
-    field :pressure, :string
-    field :primer_type, :string
-    field :firing_type, :string
-    field :tracer, :boolean, default: false
-    field :incendiary, :boolean, default: false
-    field :blank, :boolean, default: false
-    field :corrosive, :boolean, default: false
-
-    field :manufacturer, :string
-    field :upc, :string
-
-    field :user_id, :binary_id
-
-    has_many :ammo_groups, AmmoGroup
-
-    timestamps()
-  end
-
-  @type t :: %__MODULE__{
-          id: id(),
-          name: String.t(),
-          desc: String.t() | nil,
-          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,
-          tracer: boolean(),
-          incendiary: boolean(),
-          blank: boolean(),
-          corrosive: boolean(),
-          manufacturer: String.t() | nil,
-          upc: String.t() | nil,
-          user_id: User.id(),
-          ammo_groups: [AmmoGroup.t()] | nil,
-          inserted_at: NaiveDateTime.t(),
-          updated_at: NaiveDateTime.t()
-        }
-  @type new_ammo_type :: %__MODULE__{}
-  @type id :: UUID.t()
-  @type changeset :: Changeset.t(t() | new_ammo_type())
-
-  @spec changeset_fields() :: [atom()]
-  defp changeset_fields,
-    do: [
-      :name,
-      :desc,
-      :bullet_type,
-      :bullet_core,
-      :cartridge,
-      :caliber,
-      :case_material,
-      :jacket_type,
-      :muzzle_velocity,
-      :powder_type,
-      :powder_grains_per_charge,
-      :grains,
-      :pressure,
-      :primer_type,
-      :firing_type,
-      :tracer,
-      :incendiary,
-      :blank,
-      :corrosive,
-      :manufacturer,
-      :upc
-    ]
-
-  @doc false
-  @spec create_changeset(new_ammo_type(), User.t(), attrs :: map()) :: changeset()
-  def create_changeset(ammo_type, %User{id: user_id}, attrs) do
-    ammo_type
-    |> change(user_id: user_id)
-    |> cast(attrs, changeset_fields())
-    |> validate_required([:name, :user_id])
-  end
-
-  @doc false
-  @spec update_changeset(t() | new_ammo_type(), attrs :: map()) :: changeset()
-  def update_changeset(ammo_type, attrs) do
-    ammo_type
-    |> cast(attrs, changeset_fields())
-    |> validate_required(:name)
-  end
-end

lib/cannery/ammo/pack.ex

@@ -0,0 +1,146 @@
+defmodule Cannery.Ammo.Pack do
+  @moduledoc """
+  A group of a certain ammunition type.
+
+  Can be placed in a container, and contains auxiliary information such as the
+  amount paid for that ammunition, or what condition it is in
+  """
+
+  use Cannery, :schema
+  alias Cannery.{Ammo.Type, Containers, Containers.Container}
+
+  @derive {Jason.Encoder,
+           only: [
+             :id,
+             :count,
+             :notes,
+             :price_paid,
+             :lot_number,
+             :staged,
+             :type_id,
+             :container_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
+    field :container_id, :binary_id
+    field :user_id, :binary_id
+
+    timestamps()
+  end
+
+  @type t :: %__MODULE__{
+          id: id(),
+          count: integer,
+          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(),
+          container_id: Container.id(),
+          user_id: User.id(),
+          inserted_at: NaiveDateTime.t(),
+          updated_at: NaiveDateTime.t()
+        }
+  @type new_pack :: %__MODULE__{}
+  @type id :: UUID.t()
+  @type changeset :: Changeset.t(t() | new_pack())
+
+  @doc false
+  @spec create_changeset(
+          new_pack(),
+          Type.t() | nil,
+          Container.t() | nil,
+          User.t(),
+          attrs :: map()
+        ) :: changeset()
+  def create_changeset(
+        pack,
+        type,
+        container,
+        %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
+
+    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")
+    )
+    |> 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 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
+    ])
+    |> 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
+
+  defp validate_container_id(changeset, user) do
+    container_id = changeset |> Changeset.get_field(:container_id)
+
+    if container_id do
+      Containers.get_container!(container_id, user)
+    end
+
+    changeset
+  end
+
+  @doc """
+  This range changeset is used when "using up" packs, and allows for
+  updating the count to 0
+  """
+  @spec range_changeset(t() | new_pack(), attrs :: map()) :: changeset()
+  def range_changeset(pack, attrs) do
+    pack
+    |> cast(attrs, [:count, :staged])
+    |> validate_required([:count, :staged])
+  end
+end

lib/cannery/ammo/type.ex

@@ -0,0 +1,229 @@
+defmodule Cannery.Ammo.Type do
+  @moduledoc """
+  An ammunition type.
+
+  Contains statistical information about the ammunition.
+  """
+
+  use Cannery, :schema
+  alias Cannery.Ammo.Pack
+
+  @derive {Jason.Encoder,
+           only: [
+             :name,
+             :desc,
+             :class,
+             :bullet_type,
+             :bullet_core,
+             :caliber,
+             :case_material,
+             :powder_type,
+             :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
+           ]}
+  schema "types" do
+    field :name, :string
+    field :desc, :string
+
+    field :class, Ecto.Enum, values: [:rifle, :shotgun, :pistol], default: :rifle
+
+    # common fields
+    field :bullet_core, :string
+    # also gauge for shotguns
+    field :caliber, :string
+    field :case_material, :string
+    field :powder_type, :string
+    field :grains, :integer
+    field :pressure, :string
+    field :primer_type, :string
+    field :firing_type, :string
+    field :manufacturer, :string
+    field :upc, :string
+
+    field :tracer, :boolean, default: false
+    field :incendiary, :boolean, default: false
+    field :blank, :boolean, default: false
+    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
+    field :muzzle_velocity, :integer
+
+    # shotgun fields
+    field :wadding, :string
+    field :shot_type, :string
+    field :shot_material, :string
+    field :shot_size, :string
+    field :unfired_length, :string
+    field :brass_height, :string
+    field :chamber_size, :string
+    field :load_grains, :integer
+    field :shot_charge_weight, :string
+    field :dram_equivalent, :string
+
+    field :user_id, :binary_id
+    has_many :packs, Pack
+
+    timestamps()
+  end
+
+  @type t :: %__MODULE__{
+          id: id(),
+          name: String.t(),
+          desc: String.t() | nil,
+          class: class(),
+          bullet_type: String.t() | nil,
+          bullet_core: String.t() | nil,
+          caliber: String.t() | nil,
+          case_material: String.t() | nil,
+          powder_type: String.t() | 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,
+          shot_size: String.t() | nil,
+          unfired_length: String.t() | nil,
+          brass_height: String.t() | nil,
+          chamber_size: String.t() | nil,
+          load_grains: integer() | nil,
+          shot_charge_weight: String.t() | nil,
+          dram_equivalent: String.t() | nil,
+          user_id: User.id(),
+          packs: [Pack.t()] | nil,
+          inserted_at: NaiveDateTime.t(),
+          updated_at: NaiveDateTime.t()
+        }
+  @type new_type :: %__MODULE__{}
+  @type id :: UUID.t()
+  @type changeset :: Changeset.t(t() | new_type())
+  @type class :: :rifle | :shotgun | :pistol | nil
+
+  @spec changeset_fields() :: [atom()]
+  defp changeset_fields,
+    do: [
+      :name,
+      :desc,
+      :class,
+      :bullet_type,
+      :bullet_core,
+      :caliber,
+      :case_material,
+      :powder_type,
+      :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
+    ]
+
+  @spec string_fields() :: [atom()]
+  defp string_fields,
+    do: [
+      :name,
+      :desc,
+      :bullet_type,
+      :bullet_core,
+      :caliber,
+      :case_material,
+      :powder_type,
+      :pressure,
+      :primer_type,
+      :firing_type,
+      :manufacturer,
+      :upc,
+      :cartridge,
+      :jacket_type,
+      :wadding,
+      :shot_type,
+      :shot_material,
+      :shot_size,
+      :unfired_length,
+      :brass_height,
+      :chamber_size,
+      :shot_charge_weight,
+      :dram_equivalent
+    ]
+
+  @doc false
+  @spec create_changeset(new_type(), User.t(), attrs :: map()) :: changeset()
+  def create_changeset(type, %User{id: user_id}, attrs) do
+    changeset =
+      type
+      |> change(user_id: user_id)
+      |> cast(attrs, changeset_fields())
+
+    string_fields()
+    |> Enum.reduce(changeset, fn field, acc -> acc |> validate_length(field, max: 255) end)
+    |> validate_required([:name, :user_id])
+  end
+
+  @doc false
+  @spec update_changeset(t() | new_type(), attrs :: map()) :: changeset()
+  def update_changeset(type, attrs) do
+    changeset =
+      type
+      |> cast(attrs, changeset_fields())
+
+    string_fields()
+    |> Enum.reduce(changeset, fn field, acc -> acc |> validate_length(field, max: 255) end)
+    |> validate_required(:name)
+  end
+end

lib/cannery/containers.ex

@@ -3,14 +3,15 @@ defmodule Cannery.Containers do
   The Containers context.
   """
 
-  import CanneryWeb.Gettext
+  use Cannery, :context
-  import Ecto.Query, warn: false
+  alias Cannery.Ammo.Pack
-  alias Cannery.{Accounts.User, Ammo.AmmoGroup, 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.
 
@@ -19,29 +20,31 @@ defmodule Cannery.Containers do
       iex> list_containers(%User{id: 123})
       [%Container{}, ...]
 
-      iex> list_containers("cool", %User{id: 123})
+      iex> list_containers(%User{id: 123}, search: "cool")
       [%Container{name: "my cool container"}, ...]
 
   """
   @spec list_containers(User.t()) :: [Container.t()]
-  @spec list_containers(search :: nil | String.t(), User.t()) :: [Container.t()]
+  @spec list_containers(User.t(), list_containers_options()) :: [Container.t()]
-  def list_containers(search \\ nil, %User{id: user_id}) do
+  def list_containers(%User{id: user_id}, opts \\ []) 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(search)
+    |> list_containers_search(Keyword.get(opts, :search))
     |> Repo.all()
   end
 
-  defp list_containers_search(query, nil), do: query
+  @spec list_containers_search(Queryable.t(), search :: String.t() | nil) :: Queryable.t()
-  defp list_containers_search(query, ""), do: query
+  defp list_containers_search(query, search) when search in ["", nil],
+    do: query |> order_by([c: c], c.name)
 
-  defp list_containers_search(query, search) do
+  defp list_containers_search(query, search) when search |> is_binary() do
     trimmed_search = String.trim(search)
 
     query
@@ -91,7 +94,7 @@ defmodule Cannery.Containers do
   @doc """
   Gets a single container.
 
-  Raises `Ecto.NoResultsError` if the Container does not exist.
+  Raises `KeyError` if the Container does not exist.
 
   ## Examples
 
@@ -99,18 +102,37 @@ defmodule Cannery.Containers do
       %Container{}
 
       iex> get_container!(456, %User{id: 123})
-      ** (Ecto.NoResultsError)
+      ** (KeyError)
 
   """
   @spec get_container!(Container.id(), User.t()) :: Container.t()
-  def get_container!(id, %User{id: user_id}) do
+  def get_container!(id, user) do
-    Repo.one!(
+    [id]
+    |> get_containers(user)
+    |> Map.fetch!(id)
+  end
+
+  @doc """
+  Gets multiple containers.
+
+
+  ## Examples
+
+      iex> get_containers([123], %User{id: 123})
+      %{123 => %Container{}}
+
+  """
+  @spec get_containers([Container.id()], User.t()) :: %{optional(Container.id()) => Container.t()}
+  def get_containers(ids, %User{id: user_id}) do
+    Repo.all(
       from c in Container,
         where: c.user_id == ^user_id,
-        where: c.id == ^id,
+        where: c.id in ^ids,
         order_by: c.name,
-        preload: ^@container_preloads
+        preload: ^@container_preloads,
+        select: {c.id, c}
     )
+    |> Map.new()
   end
 
   @doc """
@@ -183,9 +205,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 ag in AmmoGroup,
+      from p in Pack,
-        where: ag.container_id == ^container.id,
+        where: p.container_id == ^container.id,
-        select: count(ag.id)
+        select: count(p.id)
     )
     |> case do
       0 ->
@@ -201,7 +223,7 @@ defmodule Cannery.Containers do
 
         container
         |> Container.update_changeset(%{})
-        |> Changeset.add_error(:ammo_groups, error)
+        |> Changeset.add_error(:packs, error)
         |> Changeset.apply_action(:delete)
     end
   end
@@ -269,6 +291,9 @@ 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.
 
@@ -277,38 +302,42 @@ defmodule Cannery.Containers do
       iex> list_tags(%User{id: 123})
       [%Tag{}, ...]
 
-      iex> list_tags("cool", %User{id: 123})
+      iex> list_tags(%User{id: 123}, search: "cool")
       [%Tag{name: "my cool tag"}, ...]
 
   """
   @spec list_tags(User.t()) :: [Tag.t()]
-  @spec list_tags(search :: nil | String.t(), User.t()) :: [Tag.t()]
+  @spec list_tags(User.t(), list_tags_options()) :: [Tag.t()]
-  def list_tags(search \\ nil, user)
+  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
 
-  def list_tags(search, %{id: user_id}) when search |> is_nil() or search == "",
+  @spec list_tags_search(Queryable.t(), search :: String.t() | nil) :: Queryable.t()
-    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 in ["", nil],
+    do: query |> order_by([t: t], t.name)
 
-  def list_tags(search, %{id: user_id}) when search |> is_binary() do
+  defp list_tags_search(query, search) when search |> is_binary() do
     trimmed_search = String.trim(search)
 
-    Repo.all(
+    query
-      from t in Tag,
+    |> where(
-        where: t.user_id == ^user_id,
+      [t: t],
-        where:
+      fragment(
-          fragment(
+        "? @@ websearch_to_tsquery('english', ?)",
-            "? @@ websearch_to_tsquery('english', ?)",
+        t.search,
-            t.search,
+        ^trimmed_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 """

lib/cannery/containers/container.ex

@@ -3,10 +3,8 @@ defmodule Cannery.Containers.Container do
   A container that holds ammunition and belongs to a user.
   """
 
-  use Ecto.Schema
+  use Cannery, :schema
-  import Ecto.Changeset
+  alias Cannery.{Containers.ContainerTag, Containers.Tag}
-  alias Ecto.{Changeset, UUID}
-  alias Cannery.{Accounts.User, Containers.ContainerTag, Containers.Tag}
 
   @derive {Jason.Encoder,
            only: [
@@ -17,8 +15,6 @@ 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
@@ -53,6 +49,8 @@ defmodule Cannery.Containers.Container do
     container
     |> change(user_id: user_id)
     |> cast(attrs, [:name, :desc, :type, :location])
+    |> validate_length(:name, max: 255)
+    |> validate_length(:type, max: 255)
     |> validate_required([:name, :type, :user_id])
   end
 
@@ -61,6 +59,8 @@ defmodule Cannery.Containers.Container do
   def update_changeset(container, attrs) do
     container
     |> cast(attrs, [:name, :desc, :type, :location])
+    |> validate_length(:name, max: 255)
+    |> validate_length(:type, max: 255)
     |> validate_required([:name, :type])
   end
 end

lib/cannery/containers/container_tag.ex

@@ -4,13 +4,9 @@ defmodule Cannery.Containers.ContainerTag do
   Cannery.Containers.Tag.
   """
 
-  use Ecto.Schema
+  use Cannery, :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

lib/cannery/containers/tag.ex

@@ -4,10 +4,7 @@ defmodule Cannery.Containers.Tag do
   text and bg colors.
   """
 
-  use Ecto.Schema
+  use Cannery, :schema
-  import Ecto.Changeset
-  alias Cannery.Accounts.User
-  alias Ecto.{Changeset, UUID}
 
   @derive {Jason.Encoder,
            only: [
@@ -16,8 +13,6 @@ 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
@@ -47,6 +42,9 @@ defmodule Cannery.Containers.Tag do
     tag
     |> change(user_id: user_id)
     |> cast(attrs, [:name, :bg_color, :text_color])
+    |> validate_length(:name, max: 255)
+    |> validate_length(:bg_color, max: 12)
+    |> validate_length(:text_color, max: 12)
     |> validate_required([:name, :bg_color, :text_color, :user_id])
   end
 
@@ -55,6 +53,9 @@ defmodule Cannery.Containers.Tag do
   def update_changeset(tag, attrs) do
     tag
     |> cast(attrs, [:name, :bg_color, :text_color])
+    |> validate_length(:name, max: 255)
+    |> validate_length(:bg_color, max: 12)
+    |> validate_length(:text_color, max: 12)
     |> validate_required([:name, :bg_color, :text_color])
   end
 end

lib/cannery/email.ex

@@ -3,14 +3,15 @@ defmodule Cannery.Email do
   Emails that can be sent using Swoosh.
 
   You can find the base email templates at
-  `lib/cannery_web/templates/layout/email.html.heex` for html emails and
+  `lib/cannery_web/components/layouts/email_html.html.heex` for html emails and
-  `lib/cannery_web/templates/layout/email.txt.heex` for text emails.
+  `lib/cannery_web/components/layouts/email_text.txt.eex` for text emails.
   """
 
-  use Phoenix.Swoosh, view: CanneryWeb.EmailView, layout: {CanneryWeb.LayoutView, :email}
+  use Gettext, backend: CanneryWeb.Gettext
-  import CanneryWeb.Gettext
+  import Swoosh.Email
+  import Phoenix.Template
   alias Cannery.Accounts.User
-  alias CanneryWeb.EmailView
+  alias CanneryWeb.{EmailHTML, Layouts}
 
   @typedoc """
   Represents an HTML and text body email that can be sent
@@ -28,21 +29,33 @@ defmodule Cannery.Email do
   def generate_email("welcome", user, %{"url" => url}) do
     user
     |> base_email(dgettext("emails", "Confirm your Cannery account"))
-    |> render_body("confirm_email.html", %{user: user, url: url})
+    |> html_email(:confirm_email_html, %{user: user, url: url})
-    |> text_body(EmailView.render("confirm_email.txt", %{user: user, url: url}))
+    |> text_email(:confirm_email_text, %{user: user, url: url})
   end
 
   def generate_email("reset_password", user, %{"url" => url}) do
     user
     |> base_email(dgettext("emails", "Reset your Cannery password"))
-    |> render_body("reset_password.html", %{user: user, url: url})
+    |> html_email(:reset_password_html, %{user: user, url: url})
-    |> text_body(EmailView.render("reset_password.txt", %{user: user, url: url}))
+    |> text_email(:reset_password_text, %{user: user, url: url})
   end
 
   def generate_email("update_email", user, %{"url" => url}) do
     user
     |> base_email(dgettext("emails", "Update your Cannery email"))
-    |> render_body("update_email.html", %{user: user, url: url})
+    |> html_email(:update_email_html, %{user: user, url: url})
-    |> text_body(EmailView.render("update_email.txt", %{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)
   end
 end

lib/cannery/logger.ex

@@ -14,17 +14,17 @@ defmodule Cannery.Logger do
       |> Map.put(:stacktrace, Exception.format_stacktrace(stacktrace))
       |> pretty_encode()
 
-    Logger.error(meta.reason, data: data)
+    Logger.error("Oban exception: #{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: data)
+    Logger.info("Started oban job: #{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: data)
+    Logger.info("Finished oban job: #{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: data)
+    Logger.warning("Unhandled oban job event: #{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: data)
+    Logger.warning("Unhandled telemetry event: #{data}")
   end
 
   defp get_oban_job_data(%{job: job}, measure) do

lib/cannery_web.ex

@@ -1,53 +1,62 @@
 defmodule CanneryWeb do
   @moduledoc """
   The entrypoint for defining your web interface, such
-  as controllers, views, channels and so on.
+  as controllers, components, channels, and so on.
 
   This can be used in your application as:
 
       use CanneryWeb, :controller
-      use CanneryWeb, :view
+      use CanneryWeb, :html
 
-  The definitions below will be executed for every view,
+  The definitions below will be executed for every controller,
-  controller, etc, so keep them short and clean, focused
+  component, etc, so keep them short and clean, focused
   on imports, uses and aliases.
 
   Do NOT define functions inside the quoted expressions
-  below. Instead, define any helper function in modules
+  below. Instead, define additional modules and import
-  and import those modules here.
+  those modules here.
   """
 
-  def controller do
+  def static_paths, do: ~w(css js fonts images favicon.ico robots.txt)
-    quote do
-      use Phoenix.Controller, namespace: CanneryWeb
 
+  def router do
+    quote do
+      use Phoenix.Router, helpers: false
+
+      # Import common connection and controller functions to use in pipelines
       import Plug.Conn
-      import CanneryWeb.Gettext
+      import Phoenix.Controller
-      alias CanneryWeb.Router.Helpers, as: Routes
+      import Phoenix.LiveView.Router
     end
   end
 
-  def view do
+  def channel do
     quote do
-      use Phoenix.View,
+      use Phoenix.Channel
-        root: "lib/cannery_web/templates",
+    end
-        namespace: CanneryWeb
+  end
 
-      # Import convenience functions from controllers
+  def controller do
-      import Phoenix.Controller,
+    quote do
-        only: [get_flash: 1, get_flash: 2, view_module: 1, view_template: 1]
+      use Phoenix.Controller,
+        formats: [:html, :json],
+        layouts: [html: CanneryWeb.Layouts]
 
-      # Include shared imports and aliases for views
+      use Gettext, backend: CanneryWeb.Gettext
-      unquote(view_helpers())
+
+      # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
+      import Plug.Conn
+
+      unquote(verified_routes())
     end
   end
 
   def live_view do
     quote do
-      use Phoenix.LiveView, layout: {CanneryWeb.LayoutView, :live}
+      use Phoenix.LiveView,
+        layout: {CanneryWeb.Layouts, :app}
 
-      on_mount CanneryWeb.InitAssigns
+      unquote(html_helpers())
-      unquote(view_helpers())
     end
   end
 
@@ -55,49 +64,45 @@ defmodule CanneryWeb do
     quote do
       use Phoenix.LiveComponent
 
-      unquote(view_helpers())
+      unquote(html_helpers())
     end
   end
 
-  def component do
+  def html do
     quote do
+      # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
       use Phoenix.Component
 
-      unquote(view_helpers())
+      # 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())
     end
   end
 
-  def router do
+  defp html_helpers do
     quote do
-      use Phoenix.Router
+      use PhoenixHTMLHelpers
+      use Gettext, backend: CanneryWeb.Gettext
+      import Phoenix.{Component, HTML, HTML.Form}
+      import CanneryWeb.{ErrorHelpers, CoreComponents, HTMLHelpers}
 
-      import Phoenix.{Controller, LiveView.Router}
+      # Shortcut for generating JS commands
-      # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
+      alias Phoenix.LiveView.JS
-      import Plug.Conn
+
+      # Routes generation with the ~p sigil
+      unquote(verified_routes())
     end
   end
 
-  def channel do
+  def verified_routes do
     quote do
-      use Phoenix.Channel
+      use Phoenix.VerifiedRoutes,
-      # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
+        endpoint: CanneryWeb.Endpoint,
-      import CanneryWeb.Gettext
+        router: CanneryWeb.Router,
-    end
+        statics: CanneryWeb.static_paths()
-  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
 

lib/cannery_web/components/add_shot_record_component.ex

@@ -1,10 +1,10 @@
-defmodule CanneryWeb.Components.AddShotGroupComponent do
+defmodule CanneryWeb.Components.AddShotRecordComponent do
   @moduledoc """
-  Livecomponent that can create a ShotGroup
+  Livecomponent that can create a ShotRecord
   """
 
   use CanneryWeb, :live_component
-  alias Cannery.{Accounts.User, ActivityLog, ActivityLog.ShotGroup, Ammo.AmmoGroup}
+  alias Cannery.{Accounts.User, ActivityLog, ActivityLog.ShotRecord, Ammo.Pack}
   alias Ecto.Changeset
   alias Phoenix.LiveView.{JS, Socket}
 
@@ -12,15 +12,15 @@ defmodule CanneryWeb.Components.AddShotGroupComponent do
   @spec update(
           %{
             required(:current_user) => User.t(),
-            required(:ammo_group) => AmmoGroup.t(),
+            required(:pack) => Pack.t(),
             optional(any()) => any()
           },
           Socket.t()
         ) :: {:ok, Socket.t()}
-  def update(%{ammo_group: ammo_group, current_user: current_user} = assigns, socket) do
+  def update(%{pack: pack, current_user: current_user} = assigns, socket) do
     changeset =
-      %ShotGroup{date: Date.utc_today()}
+      %ShotRecord{date: Date.utc_today()}
-      |> ShotGroup.create_changeset(current_user, ammo_group, %{})
+      |> ShotRecord.create_changeset(current_user, pack, %{})
 
     {:ok, socket |> assign(assigns) |> assign(:changeset, changeset)}
   end
@@ -28,12 +28,14 @@ defmodule CanneryWeb.Components.AddShotGroupComponent do
   @impl true
   def handle_event(
         "validate",
-        %{"shot_group" => shot_group_params},
+        %{"shot_record" => shot_record_params},
-        %{assigns: %{ammo_group: ammo_group, current_user: current_user}} = socket
+        %{assigns: %{pack: pack, current_user: current_user}} = socket
       ) do
-    params = shot_group_params |> process_params(ammo_group)
+    params = shot_record_params |> process_params(pack)
 
-    changeset = %ShotGroup{} |> ShotGroup.create_changeset(current_user, ammo_group, params)
+    changeset =
+      %ShotRecord{}
+      |> ShotRecord.create_changeset(current_user, pack, params)
 
     changeset =
       case changeset |> Changeset.apply_action(:validate) do
@@ -46,17 +48,17 @@ defmodule CanneryWeb.Components.AddShotGroupComponent do
 
   def handle_event(
         "save",
-        %{"shot_group" => shot_group_params},
+        %{"shot_record" => shot_record_params},
         %{
-          assigns: %{ammo_group: ammo_group, current_user: current_user, return_to: return_to}
+          assigns: %{pack: pack, current_user: current_user, return_to: return_to}
         } = socket
       ) do
     socket =
-      shot_group_params
+      shot_record_params
-      |> process_params(ammo_group)
+      |> process_params(pack)
-      |> ActivityLog.create_shot_group(current_user, ammo_group)
+      |> ActivityLog.create_shot_record(current_user, pack)
       |> case do
-        {:ok, _shot_group} ->
+        {:ok, _shot_record} ->
           prompt = dgettext("prompts", "Shots recorded successfully")
           socket |> put_flash(:info, prompt) |> push_navigate(to: return_to)
 
@@ -68,8 +70,8 @@ defmodule CanneryWeb.Components.AddShotGroupComponent do
   end
 
   # calculate count from shots left
-  defp process_params(params, %AmmoGroup{count: count}) do
+  defp process_params(params, %Pack{count: count}) do
-    shot_group_count =
+    shot_record_count =
       if params |> Map.get("ammo_left", "") == "" do
         nil
       else
@@ -77,6 +79,6 @@ defmodule CanneryWeb.Components.AddShotGroupComponent do
         count - new_count
       end
 
-    params |> Map.put("count", shot_group_count)
+    params |> Map.put("count", shot_record_count)
   end
 end

lib/cannery_web/components/add_shot_record_component.html.heex

@@ -6,14 +6,14 @@
   <.form
     :let={f}
     for={@changeset}
-    id="shot-group-form"
+    id="shot-record-form"
     class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
     phx-target={@myself}
     phx-change="validate"
     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,14 +22,14 @@
     <%= label(f, :ammo_left, gettext("Rounds left"), class: "title text-lg text-primary-600") %>
     <%= number_input(f, :ammo_left,
       min: 0,
-      max: @ammo_group.count - 1,
+      max: @pack.count - 1,
       placeholder: gettext("Rounds left"),
       class: "input input-primary"
     ) %>
     <button
       type="button"
       class="mx-2 my-1 text-sm btn btn-primary"
-      phx-click={JS.dispatch("cannery:set-zero", to: "#shot-group-form_ammo_left")}
+      phx-click={JS.dispatch("cannery:set-zero", to: "#shot-record-form_ammo_left")}
     >
       <%= gettext("Used up!") %>
     </button>
@@ -37,11 +37,12 @@
 
     <%= label(f, :notes, gettext("Notes"), class: "title text-lg text-primary-600") %>
     <%= textarea(f, :notes,
-      id: "add-shot-group-form-notes",
       class: "input input-primary col-span-2",
-      placeholder: gettext("Really great weather"),
+      id: "add-shot-record-form-notes",
-      phx_hook: "MaintainAttrs",
+      maxlength: 255,
-      phx_update: "ignore"
+      phx_debounce: 300,
+      phx_update: "ignore",
+      placeholder: gettext("Really great weather")
     ) %>
     <%= error_tag(f, :notes, "col-span-3") %>
 

lib/cannery_web/components/ammo_group_table_component.ex

@@ -1,240 +0,0 @@
-defmodule CanneryWeb.Components.AmmoGroupTableComponent do
-  @moduledoc """
-  A component that displays a list of ammo groups
-  """
-  use CanneryWeb, :live_component
-  alias Cannery.{Accounts.User, Ammo.AmmoGroup, ComparableDate}
-  alias Cannery.{ActivityLog, Ammo, Containers}
-  alias Ecto.UUID
-  alias Phoenix.LiveView.{Rendered, Socket}
-
-  @impl true
-  @spec update(
-          %{
-            required(:id) => UUID.t(),
-            required(:current_user) => User.t(),
-            required(:ammo_groups) => [AmmoGroup.t()],
-            optional(:ammo_type) => Rendered.t(),
-            optional(:range) => Rendered.t(),
-            optional(:container) => Rendered.t(),
-            optional(:actions) => Rendered.t(),
-            optional(any()) => any()
-          },
-          Socket.t()
-        ) :: {:ok, Socket.t()}
-  def update(%{id: _id, ammo_groups: _ammo_group, current_user: _current_user} = assigns, socket) do
-    socket =
-      socket
-      |> assign(assigns)
-      |> assign_new(:ammo_type, fn -> [] end)
-      |> assign_new(:range, fn -> [] end)
-      |> assign_new(:container, fn -> [] end)
-      |> assign_new(:actions, fn -> [] end)
-      |> display_ammo_groups()
-
-    {:ok, socket}
-  end
-
-  defp display_ammo_groups(
-         %{
-           assigns: %{
-             ammo_groups: ammo_groups,
-             current_user: current_user,
-             ammo_type: ammo_type,
-             range: range,
-             container: container,
-             actions: actions
-           }
-         } = socket
-       ) do
-    columns =
-      if actions == [] do
-        []
-      else
-        [%{label: gettext("Actions"), key: :actions, sortable: false}]
-      end
-
-    columns = [
-      %{label: gettext("Purchased on"), key: :purchased_on, type: ComparableDate},
-      %{label: gettext("Last used on"), key: :used_up_on, type: ComparableDate} | columns
-    ]
-
-    columns =
-      if container == [] do
-        columns
-      else
-        [%{label: gettext("Container"), key: :container} | columns]
-      end
-
-    columns =
-      if range == [] do
-        columns
-      else
-        [%{label: gettext("Range"), key: :range} | columns]
-      end
-
-    columns = [
-      %{label: gettext("Count"), key: :count},
-      %{label: gettext("Original Count"), key: :original_count},
-      %{label: gettext("Price paid"), key: :price_paid},
-      %{label: gettext("CPR"), key: :cpr},
-      %{label: gettext("% left"), key: :remaining},
-      %{label: gettext("Notes"), key: :notes}
-      | columns
-    ]
-
-    columns =
-      if ammo_type == [] do
-        columns
-      else
-        [%{label: gettext("Ammo type"), key: :ammo_type} | columns]
-      end
-
-    extra_data = %{
-      current_user: current_user,
-      ammo_type: ammo_type,
-      columns: columns,
-      container: container,
-      original_counts: Ammo.get_original_counts(ammo_groups, current_user),
-      cprs: Ammo.get_cprs(ammo_groups, current_user),
-      last_used_dates: ActivityLog.get_last_used_dates(ammo_groups, current_user),
-      actions: actions,
-      range: range
-    }
-
-    rows =
-      ammo_groups
-      |> Enum.map(fn ammo_group ->
-        ammo_group |> get_row_data_for_ammo_group(extra_data)
-      end)
-
-    socket |> assign(columns: columns, rows: rows)
-  end
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <div id={@id} class="w-full">
-      <.live_component
-        module={CanneryWeb.Components.TableComponent}
-        id={"table-#{@id}"}
-        columns={@columns}
-        rows={@rows}
-      />
-    </div>
-    """
-  end
-
-  @spec get_row_data_for_ammo_group(AmmoGroup.t(), additional_data :: map()) :: map()
-  defp get_row_data_for_ammo_group(ammo_group, %{columns: columns} = additional_data) do
-    columns
-    |> Map.new(fn %{key: key} ->
-      {key, get_value_for_key(key, ammo_group, additional_data)}
-    end)
-  end
-
-  @spec get_value_for_key(atom(), AmmoGroup.t(), additional_data :: map()) ::
-          any() | {any(), Rendered.t()}
-  defp get_value_for_key(
-         :ammo_type,
-         %{ammo_type: %{name: ammo_type_name} = ammo_type},
-         %{ammo_type: ammo_type_block}
-       ) do
-    assigns = %{ammo_type: ammo_type, ammo_type_block: ammo_type_block}
-
-    {ammo_type_name,
-     ~H"""
-     <%= render_slot(@ammo_type_block, @ammo_type) %>
-     """}
-  end
-
-  defp get_value_for_key(:price_paid, %{price_paid: nil}, _additional_data), do: {"", nil}
-
-  defp get_value_for_key(:price_paid, %{price_paid: price_paid}, _additional_data),
-    do: gettext("$%{amount}", amount: display_currency(price_paid))
-
-  defp get_value_for_key(:purchased_on, %{purchased_on: purchased_on} = assigns, _additional_data) do
-    {purchased_on,
-     ~H"""
-     <.date id={"#{@id}-purchased-on"} date={@purchased_on} />
-     """}
-  end
-
-  defp get_value_for_key(:used_up_on, %{id: ammo_group_id}, %{last_used_dates: last_used_dates}) do
-    last_used_date = last_used_dates |> Map.get(ammo_group_id)
-    assigns = %{id: ammo_group_id, last_used_date: last_used_date}
-
-    {last_used_date,
-     ~H"""
-     <%= if @last_used_date do %>
-       <.date id={"#{@id}-last-used-date"} date={@last_used_date} />
-     <% else %>
-       <%= gettext("Never used") %>
-     <% end %>
-     """}
-  end
-
-  defp get_value_for_key(:range, %{staged: staged} = ammo_group, %{range: range}) do
-    assigns = %{range: range, ammo_group: ammo_group}
-
-    {staged,
-     ~H"""
-     <%= render_slot(@range, @ammo_group) %>
-     """}
-  end
-
-  defp get_value_for_key(:remaining, ammo_group, %{current_user: current_user}),
-    do:
-      gettext("%{percentage}%",
-        percentage: ammo_group |> Ammo.get_percentage_remaining(current_user)
-      )
-
-  defp get_value_for_key(:actions, ammo_group, %{actions: actions}) do
-    assigns = %{actions: actions, ammo_group: ammo_group}
-
-    ~H"""
-    <%= render_slot(@actions, @ammo_group) %>
-    """
-  end
-
-  defp get_value_for_key(:container, %{container: nil}, _additional_data), do: {nil, nil}
-
-  defp get_value_for_key(
-         :container,
-         %{container_id: container_id} = ammo_group,
-         %{container: container, current_user: current_user}
-       ) do
-    assigns = %{
-      container:
-        %{name: container_name} = container_id |> Containers.get_container!(current_user),
-      container_block: container,
-      ammo_group: ammo_group
-    }
-
-    {container_name,
-     ~H"""
-     <%= render_slot(@container_block, {@ammo_group, @container}) %>
-     """}
-  end
-
-  defp get_value_for_key(:original_count, %{id: ammo_group_id}, %{
-         original_counts: original_counts
-       }) do
-    Map.fetch!(original_counts, ammo_group_id)
-  end
-
-  defp get_value_for_key(:cpr, %{price_paid: nil}, _additional_data),
-    do: gettext("No cost information")
-
-  defp get_value_for_key(:cpr, %{id: ammo_group_id}, %{cprs: cprs}) do
-    gettext("$%{amount}", amount: display_currency(Map.fetch!(cprs, ammo_group_id)))
-  end
-
-  defp get_value_for_key(:count, %{count: count}, _additional_data),
-    do: if(count == 0, do: gettext("Empty"), else: count)
-
-  defp get_value_for_key(key, ammo_group, _additional_data), do: ammo_group |> Map.get(key)
-
-  @spec display_currency(float()) :: String.t()
-  defp display_currency(float), do: :erlang.float_to_binary(float, decimals: 2)
-end

lib/cannery_web/components/ammo_type_table_component.ex

@@ -1,252 +0,0 @@
-defmodule CanneryWeb.Components.AmmoTypeTableComponent do
-  @moduledoc """
-  A component that displays a list of ammo type
-  """
-  use CanneryWeb, :live_component
-  alias Cannery.{Accounts.User, ActivityLog, Ammo, Ammo.AmmoType}
-  alias Ecto.UUID
-  alias Phoenix.LiveView.{Rendered, Socket}
-
-  @impl true
-  @spec update(
-          %{
-            required(:id) => UUID.t(),
-            required(:current_user) => User.t(),
-            optional(:show_used) => boolean(),
-            optional(:ammo_types) => [AmmoType.t()],
-            optional(:actions) => Rendered.t(),
-            optional(any()) => any()
-          },
-          Socket.t()
-        ) :: {:ok, Socket.t()}
-  def update(%{id: _id, ammo_types: _ammo_types, current_user: _current_user} = assigns, socket) do
-    socket =
-      socket
-      |> assign(assigns)
-      |> assign_new(:show_used, fn -> false end)
-      |> assign_new(:actions, fn -> [] end)
-      |> display_ammo_types()
-
-    {:ok, socket}
-  end
-
-  defp display_ammo_types(
-         %{
-           assigns: %{
-             ammo_types: ammo_types,
-             current_user: current_user,
-             show_used: show_used,
-             actions: actions
-           }
-         } = socket
-       ) do
-    columns =
-      [
-        %{label: gettext("Name"), key: :name, type: :name},
-        %{label: gettext("Bullet type"), key: :bullet_type, type: :string},
-        %{label: gettext("Bullet core"), key: :bullet_core, type: :string},
-        %{label: gettext("Cartridge"), key: :cartridge, type: :string},
-        %{label: gettext("Caliber"), key: :caliber, type: :string},
-        %{label: gettext("Case material"), key: :case_material, type: :string},
-        %{label: gettext("Jacket type"), key: :jacket_type, type: :string},
-        %{label: gettext("Muzzle velocity"), key: :muzzle_velocity, type: :string},
-        %{label: gettext("Powder type"), key: :powder_type, type: :string},
-        %{
-          label: gettext("Powder grains per charge"),
-          key: :powder_grains_per_charge,
-          type: :string
-        },
-        %{label: gettext("Grains"), key: :grains, type: :string},
-        %{label: gettext("Pressure"), key: :pressure, type: :string},
-        %{label: gettext("Primer type"), key: :primer_type, type: :string},
-        %{label: gettext("Firing type"), key: :firing_type, type: :string},
-        %{label: gettext("Tracer"), key: :tracer, type: :boolean},
-        %{label: gettext("Incendiary"), key: :incendiary, type: :boolean},
-        %{label: gettext("Blank"), key: :blank, type: :boolean},
-        %{label: gettext("Corrosive"), key: :corrosive, type: :boolean},
-        %{label: gettext("Manufacturer"), key: :manufacturer, type: :string},
-        %{label: gettext("UPC"), key: "upc", type: :string}
-      ]
-      |> Enum.filter(fn %{key: key, type: type} ->
-        # remove columns if all values match defaults
-        default_value = if type == :boolean, do: false, else: nil
-
-        ammo_types
-        |> Enum.any?(fn ammo_type ->
-          not (ammo_type |> Map.get(key) == default_value)
-        end)
-      end)
-      |> Kernel.++([
-        %{label: gettext("Rounds"), key: :round_count, type: :round_count}
-      ])
-      |> Kernel.++(
-        if show_used do
-          [
-            %{
-              label: gettext("Used rounds"),
-              key: :used_round_count,
-              type: :used_round_count
-            },
-            %{
-              label: gettext("Total ever rounds"),
-              key: :historical_round_count,
-              type: :historical_round_count
-            }
-          ]
-        else
-          []
-        end
-      )
-      |> Kernel.++([%{label: gettext("Packs"), key: :ammo_count, type: :ammo_count}])
-      |> Kernel.++(
-        if show_used do
-          [
-            %{
-              label: gettext("Used packs"),
-              key: :used_packs_count,
-              type: :used_packs_count
-            },
-            %{
-              label: gettext("Total ever packs"),
-              key: :historical_packs_count,
-              type: :historical_packs_count
-            }
-          ]
-        else
-          []
-        end
-      )
-      |> Kernel.++([
-        %{label: gettext("Average CPR"), key: :avg_price_paid, type: :avg_price_paid},
-        %{label: gettext("Actions"), key: "actions", type: :actions, sortable: false}
-      ])
-
-    round_counts = ammo_types |> Ammo.get_round_count_for_ammo_types(current_user)
-
-    used_counts =
-      show_used && ammo_types |> ActivityLog.get_used_count_for_ammo_types(current_user)
-
-    historical_round_counts =
-      show_used && ammo_types |> Ammo.get_historical_count_for_ammo_types(current_user)
-
-    packs_count = ammo_types |> Ammo.get_ammo_groups_count_for_types(current_user)
-
-    historical_packs_count =
-      show_used && ammo_types |> Ammo.get_ammo_groups_count_for_types(current_user, true)
-
-    used_packs_count =
-      show_used && ammo_types |> Ammo.get_used_ammo_groups_count_for_types(current_user)
-
-    average_costs = ammo_types |> Ammo.get_average_cost_for_ammo_types(current_user)
-
-    extra_data = %{
-      actions: actions,
-      current_user: current_user,
-      used_counts: used_counts,
-      round_counts: round_counts,
-      historical_round_counts: historical_round_counts,
-      packs_count: packs_count,
-      used_packs_count: used_packs_count,
-      historical_packs_count: historical_packs_count,
-      average_costs: average_costs
-    }
-
-    rows =
-      ammo_types
-      |> Enum.map(fn ammo_type ->
-        ammo_type |> get_ammo_type_values(columns, extra_data)
-      end)
-
-    socket |> assign(columns: columns, rows: rows)
-  end
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <div id={@id} class="w-full">
-      <.live_component
-        module={CanneryWeb.Components.TableComponent}
-        id={"table-#{@id}"}
-        columns={@columns}
-        rows={@rows}
-      />
-    </div>
-    """
-  end
-
-  defp get_ammo_type_values(ammo_type, columns, extra_data) do
-    columns
-    |> Map.new(fn %{key: key, type: type} ->
-      {key, get_ammo_type_value(type, key, ammo_type, extra_data)}
-    end)
-  end
-
-  defp get_ammo_type_value(:boolean, key, ammo_type, _other_data),
-    do: ammo_type |> Map.get(key) |> humanize()
-
-  defp get_ammo_type_value(:round_count, _key, %{id: ammo_type_id}, %{round_counts: round_counts}),
-    do: Map.get(round_counts, ammo_type_id)
-
-  defp get_ammo_type_value(
-         :historical_round_count,
-         _key,
-         %{id: ammo_type_id},
-         %{historical_round_counts: historical_round_counts}
-       ),
-       do: Map.get(historical_round_counts, ammo_type_id)
-
-  defp get_ammo_type_value(:used_round_count, _key, %{id: ammo_type_id}, %{
-         used_counts: used_counts
-       }),
-       do: Map.get(used_counts, ammo_type_id)
-
-  defp get_ammo_type_value(
-         :historical_packs_count,
-         _key,
-         %{id: ammo_type_id},
-         %{historical_packs_count: historical_packs_count}
-       ),
-       do: Map.get(historical_packs_count, ammo_type_id)
-
-  defp get_ammo_type_value(:used_packs_count, _key, %{id: ammo_type_id}, %{
-         used_packs_count: used_packs_count
-       }),
-       do: Map.get(used_packs_count, ammo_type_id)
-
-  defp get_ammo_type_value(:ammo_count, _key, %{id: ammo_type_id}, %{packs_count: packs_count}),
-    do: Map.get(packs_count, ammo_type_id)
-
-  defp get_ammo_type_value(:avg_price_paid, _key, %{id: ammo_type_id}, %{
-         average_costs: average_costs
-       }) do
-    case Map.get(average_costs, ammo_type_id) do
-      nil -> gettext("No cost information")
-      count -> gettext("$%{amount}", amount: display_currency(count))
-    end
-  end
-
-  defp get_ammo_type_value(:name, _key, ammo_type, _other_data) do
-    assigns = %{ammo_type: ammo_type}
-
-    ~H"""
-    <.link navigate={Routes.ammo_type_show_path(Endpoint, :show, @ammo_type)} class="link">
-      <%= @ammo_type.name %>
-    </.link>
-    """
-  end
-
-  defp get_ammo_type_value(:actions, _key, ammo_type, %{actions: actions}) do
-    assigns = %{actions: actions, ammo_type: ammo_type}
-
-    ~H"""
-    <%= render_slot(@actions, @ammo_type) %>
-    """
-  end
-
-  defp get_ammo_type_value(nil, _key, _ammo_type, _other_data), do: nil
-
-  defp get_ammo_type_value(_other, key, ammo_type, _other_data), do: ammo_type |> Map.get(key)
-
-  @spec display_currency(float()) :: String.t()
-  defp display_currency(float), do: :erlang.float_to_binary(float, decimals: 2)
-end

lib/cannery_web/components/container_table_component.ex

@@ -71,8 +71,16 @@ defmodule CanneryWeb.Components.ContainerTableComponent do
       current_user: current_user,
       tag_actions: tag_actions,
       actions: actions,
-      pack_count: Ammo.get_ammo_groups_count_for_containers(containers, current_user),
+      pack_count:
-      round_count: Ammo.get_round_count_for_containers(containers, current_user)
+        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
+        )
     }
 
     rows =
@@ -109,14 +117,12 @@ defmodule CanneryWeb.Components.ContainerTableComponent do
   end
 
   @spec get_value_for_key(atom(), Container.t(), extra_data :: map) :: any()
-  defp get_value_for_key(:name, %{id: id, name: container_name}, _extra_data) do
+  defp get_value_for_key(:name, %{name: container_name} = assigns, _extra_data) do
-    assigns = %{id: id, container_name: container_name}
-
     {container_name,
      ~H"""
      <div class="flex flex-wrap justify-center items-center">
-       <.link navigate={Routes.container_show_path(Endpoint, :show, @id)} class="link">
+       <.link navigate={~p"/container/#{@id}"} class="link">
-         <%= @container_name %>
+         <%= @name %>
        </.link>
      </div>
      """}

lib/cannery_web/components/core_components.ex

@@ -3,11 +3,12 @@ defmodule CanneryWeb.CoreComponents do
   Provides core UI components.
   """
   use Phoenix.Component
-  import CanneryWeb.{Gettext, ViewHelpers}
+  use CanneryWeb, :verified_routes
+  use Gettext, backend: CanneryWeb.Gettext
+  import CanneryWeb.HTMLHelpers
   alias Cannery.{Accounts, Accounts.Invite, Accounts.User}
-  alias Cannery.{Ammo, Ammo.AmmoGroup}
+  alias Cannery.{Ammo, Ammo.Pack}
-  alias Cannery.{Containers, Containers.Container, Containers.Tag}
+  alias Cannery.{Containers.Container, Containers.Tag}
-  alias CanneryWeb.{Endpoint, HomeLive}
   alias CanneryWeb.Router.Helpers, as: Routes
   alias Phoenix.LiveView.{JS, Rendered}
 
@@ -29,13 +30,13 @@ defmodule CanneryWeb.CoreComponents do
 
   ## Examples
 
-      <.modal return_to={Routes.<%= schema.singular %>_index_path(Endpoint, :index)}>
+      <.modal return_to={~p"/\#{<%= schema.plural %>}"}>
         <.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={Routes.<%= schema.singular %>_index_path(Endpoint, :index)}
+          return_to={~p"/\#{<%= schema.singular %>}"}
           <%= schema.singular %>: @<%= schema.singular %>
         />
       </.modal>
@@ -86,15 +87,15 @@ defmodule CanneryWeb.CoreComponents do
 
   def simple_tag_card(assigns)
 
-  attr :ammo_group, AmmoGroup, required: true
+  attr :pack, Pack, required: true
   attr :current_user, User, required: true
   attr :original_count, :integer, default: nil
   attr :cpr, :integer, default: nil
   attr :last_used_date, Date, default: nil
-  attr :show_container, :boolean, default: false
+  attr :container, Container, default: nil
   slot(:inner_block)
 
-  def ammo_group_card(assigns)
+  def pack_card(assigns)
 
   @spec display_currency(float()) :: String.t()
   defp display_currency(float), do: :erlang.float_to_binary(float, decimals: 2)

lib/cannery_web/components/core_components/ammo_group_card.html.heex

@@ -1,71 +0,0 @@
-<div
-  id={"ammo_group-#{@ammo_group.id}"}
-  class="mx-4 my-2 px-8 py-4
-    flex flex-col justify-center items-center
-    border border-gray-400 rounded-lg shadow-lg hover:shadow-md
-    transition-all duration-300 ease-in-out"
->
-  <.link navigate={Routes.ammo_group_show_path(Endpoint, :show, @ammo_group)} class="mb-2 link">
-    <h1 class="title text-xl title-primary-500">
-      <%= @ammo_group.ammo_type.name %>
-    </h1>
-  </.link>
-
-  <div class="flex flex-col justify-center items-center">
-    <span class="rounded-lg title text-lg">
-      <%= gettext("Count:") %>
-      <%= if @ammo_group.count == 0, do: gettext("Empty"), else: @ammo_group.count %>
-    </span>
-
-    <span
-      :if={@original_count && @original_count != @ammo_group.count}
-      class="rounded-lg title text-lg"
-    >
-      <%= gettext("Original Count:") %>
-      <%= @original_count %>
-    </span>
-
-    <span :if={@ammo_group.notes} class="rounded-lg title text-lg">
-      <%= gettext("Notes:") %>
-      <%= @ammo_group.notes %>
-    </span>
-
-    <span :if={@ammo_group.purchased_on} class="rounded-lg title text-lg">
-      <%= gettext("Purchased on:") %>
-      <.date id={"#{@ammo_group.id}-purchased-on"} date={@ammo_group.purchased_on} />
-    </span>
-
-    <span :if={@last_used_date} class="rounded-lg title text-lg">
-      <%= gettext("Last used on:") %>
-      <.date id={"#{@ammo_group.id}-last-used-on"} date={@last_used_date} />
-    </span>
-
-    <span :if={@ammo_group.price_paid} class="rounded-lg title text-lg">
-      <%= gettext("Price paid:") %>
-      <%= gettext("$%{amount}", amount: display_currency(@ammo_group.price_paid)) %>
-    </span>
-
-    <span :if={@cpr} class="rounded-lg title text-lg">
-      <%= gettext("CPR:") %>
-      <%= gettext("$%{amount}", amount: display_currency(@cpr)) %>
-    </span>
-
-    <span
-      :if={@show_container && Containers.get_container!(@ammo_group.container_id, @current_user)}
-      class="rounded-lg title text-lg"
-    >
-      <%= gettext("Container:") %>
-
-      <.link
-        navigate={Routes.container_show_path(Endpoint, :show, @ammo_group.container_id)}
-        class="link"
-      >
-        <%= Containers.get_container!(@ammo_group.container_id, @current_user).name %>
-      </.link>
-    </span>
-  </div>
-
-  <div :if={@inner_block} class="mt-4 flex space-x-4 justify-center items-center">
-    <%= render_slot(@inner_block) %>
-  </div>
-</div>

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={Routes.container_show_path(Endpoint, :show, @container)} class="link">
+  <.link navigate={~p"/container/#{@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 @container |> Ammo.get_ammo_groups_count_for_container!(@current_user) != 0 do %>
+    <%= if Ammo.get_packs_count(@current_user, container_id: @container.id) != 0 do %>
       <span class="rounded-lg title text-lg">
         <%= gettext("Packs:") %>
-        <%= @container |> Ammo.get_ammo_groups_count_for_container!(@current_user) %>
+        <%= Ammo.get_packs_count(@current_user, container_id: @container.id) %>
       </span>
 
       <span class="rounded-lg title text-lg">
         <%= gettext("Rounds:") %>
-        <%= @container |> Ammo.get_round_count_for_container!(@current_user) %>
+        <%= Ammo.get_round_count(@current_user, container_id: @container.id) %>
       </span>
     <% end %>
 

lib/cannery_web/components/core_components/invite_card.html.heex

@@ -23,7 +23,7 @@
   <% end %>
 
   <.qr_code
-    content={Routes.user_registration_url(Endpoint, :new, invite: @invite.token)}
+    content={url(CanneryWeb.Endpoint, ~p"/users/register?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
-    ><%= Routes.user_registration_url(Endpoint, :new, invite: @invite.token) %></code>
+    ><%= url(CanneryWeb.Endpoint, ~p"/users/register?invite=#{@invite.token}") %></code>
     <%= if @code_actions, do: render_slot(@code_actions) %>
   </div>
 

lib/cannery_web/components/core_components/modal.html.heex

@@ -6,6 +6,7 @@
     p-8 flex flex-col justify-center items-center cursor-auto"
   style="background-color: rgba(0,0,0,0.4);"
   phx-remove={hide_modal()}
+  aria-label={gettext("Close modal")}
 >
   <span class="hidden"></span>
 </.link>
@@ -31,6 +32,7 @@
         text-gray-500 hover:text-gray-800
         transition-all duration-500 ease-in-out"
       phx-remove={hide_modal()}
+      aria-label={gettext("Close modal")}
     >
       <i class="fa-fw fa-lg fas fa-times"></i>
     </.link>

lib/cannery_web/components/core_components/pack_card.html.heex

@@ -0,0 +1,67 @@
+<div
+  id={"pack-#{@pack.id}"}
+  class="mx-4 my-2 px-8 py-4
+    flex flex-col justify-center items-center
+    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">
+    <h1 class="title text-xl title-primary-500">
+      <%= @pack.type.name %>
+    </h1>
+  </.link>
+
+  <div class="flex flex-col justify-center items-center">
+    <span class="rounded-lg title text-lg">
+      <%= gettext("Count:") %>
+      <%= if @pack.count == 0, do: gettext("Empty"), else: @pack.count %>
+    </span>
+
+    <span :if={@original_count && @original_count != @pack.count} class="rounded-lg title text-lg">
+      <%= gettext("Original Count:") %>
+      <%= @original_count %>
+    </span>
+
+    <span :if={@pack.notes} class="rounded-lg title text-lg">
+      <%= gettext("Notes:") %>
+      <%= @pack.notes %>
+    </span>
+
+    <span :if={@pack.purchased_on} class="rounded-lg title text-lg">
+      <%= gettext("Purchased on:") %>
+      <.date id={"#{@pack.id}-purchased-on"} date={@pack.purchased_on} />
+    </span>
+
+    <span :if={@last_used_date} class="rounded-lg title text-lg">
+      <%= gettext("Last used on:") %>
+      <.date id={"#{@pack.id}-last-used-on"} date={@last_used_date} />
+    </span>
+
+    <span :if={@pack.price_paid} class="rounded-lg title text-lg">
+      <%= gettext("Price paid:") %>
+      <%= gettext("$%{amount}", amount: display_currency(@pack.price_paid)) %>
+    </span>
+
+    <span :if={@cpr} class="rounded-lg title text-lg">
+      <%= gettext("CPR:") %>
+      <%= 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">
+        <%= @container.name %>
+      </.link>
+    </span>
+  </div>
+
+  <div :if={@inner_block} class="mt-4 flex space-x-4 justify-center items-center">
+    <%= render_slot(@inner_block) %>
+  </div>
+</div>

lib/cannery_web/components/core_components/toggle_button.html.heex

@@ -1,4 +1,4 @@
-<label for={@id || @action} class="inline-flex relative items-center cursor-pointer">
+<label for={@id || @action} class="relative inline-flex items-center cursor-pointer">
   <input
     id={@id || @action}
     type="checkbox"
@@ -23,7 +23,7 @@
   </div>
   <span
     id={"#{@id || @action}-label"}
-    class="ml-3 text-sm font-medium text-gray-900 dark:text-gray-300"
+    class="ml-3 text-sm font-medium text-gray-900 dark:text-gray-300 whitespace-nowrap"
   >
     <%= render_slot(@inner_block) %>
   </span>

lib/cannery_web/components/core_components/topbar.html.heex

@@ -1,12 +1,9 @@
 <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
+      <.link navigate={~p"/"} class="inline mx-2 my-1 leading-5 text-xl text-white">
-        navigate={Routes.live_path(Endpoint, HomeLive)}
-        class="inline mx-2 my-1 leading-5 text-xl text-white"
-      >
         <img
-          src={Routes.static_path(Endpoint, "/images/cannery.svg")}
+          src={~p"/images/cannery.svg"}
           alt={gettext("Cannery logo")}
           class="inline-block h-8 mx-1"
         />
@@ -27,64 +24,43 @@
       text-lg text-white text-ellipsis">
       <%= if @current_user do %>
         <li class="mx-2 my-1">
-          <.link
+          <.link navigate={~p"/tags"} class="text-white hover:underline">
-            navigate={Routes.tag_index_path(Endpoint, :index)}
-            class="text-white hover:underline"
-          >
             <%= gettext("Tags") %>
           </.link>
         </li>
         <li class="mx-2 my-1">
-          <.link
+          <.link navigate={~p"/containers"} class="text-white hover:underline">
-            navigate={Routes.container_index_path(Endpoint, :index)}
-            class="text-white hover:underline"
-          >
             <%= gettext("Containers") %>
           </.link>
         </li>
         <li class="mx-2 my-1">
-          <.link
+          <.link navigate={~p"/catalog"} class="text-white hover:underline">
-            navigate={Routes.ammo_type_index_path(Endpoint, :index)}
-            class="text-white hover:underline"
-          >
             <%= gettext("Catalog") %>
           </.link>
         </li>
         <li class="mx-2 my-1">
-          <.link
+          <.link navigate={~p"/ammo"} class="text-white hover:underline">
-            navigate={Routes.ammo_group_index_path(Endpoint, :index)}
-            class="text-white hover:underline"
-          >
             <%= gettext("Ammo") %>
           </.link>
         </li>
         <li class="mx-2 my-1">
-          <.link
+          <.link navigate={~p"/range"} class="text-white hover:underline">
-            navigate={Routes.range_index_path(Endpoint, :index)}
-            class="text-white hover:underline"
-          >
             <%= gettext("Range") %>
           </.link>
         </li>
-        <li :if={@current_user |> Accounts.is_already_admin?()} class="mx-2 my-1">
+        <li :if={@current_user |> Accounts.already_admin?()} class="mx-2 my-1">
-          <.link
+          <.link navigate={~p"/invites"} class="text-white hover:underline">
-            navigate={Routes.invite_index_path(Endpoint, :index)}
-            class="text-white hover:underline"
-          >
             <%= gettext("Invites") %>
           </.link>
         </li>
         <li class="mx-2 my-1">
-          <.link
+          <.link href={~p"/users/settings"} class="text-white hover:underline truncate">
-            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={Routes.user_session_path(Endpoint, :delete)}
+            href={~p"/users/log_out"}
             method="delete"
             data-confirm={dgettext("prompts", "Are you sure you want to log out?")}
             aria-label={gettext("Log out")}
@@ -94,13 +70,13 @@
         </li>
         <li
           :if={
-            @current_user |> Accounts.is_already_admin?() and
+            @current_user |> Accounts.already_admin?() and
               function_exported?(Routes, :live_dashboard_path, 2)
           }
           class="mx-2 my-1"
         >
           <.link
-            navigate={Routes.live_dashboard_path(Endpoint, :home)}
+            navigate={~p"/dashboard"}
             class="text-white hover:underline"
             aria-label={gettext("Live Dashboard")}
           >
@@ -109,18 +85,12 @@
         </li>
       <% else %>
         <li :if={Accounts.allow_registration?()} class="mx-2 my-1">
-          <.link
+          <.link href={~p"/users/register"} class="text-white hover:underline truncate">
-            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
+          <.link href={~p"/users/log_in"} class="text-white hover:underline truncate">
-            href={Routes.user_session_path(Endpoint, :new)}
-            class="text-white hover:underline truncate"
-          >
             <%= dgettext("actions", "Log in") %>
           </.link>
         </li>

lib/cannery_web/components/email_html.ex

@@ -0,0 +1,10 @@
+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

lib/cannery_web/components/email_html/confirm_email.txt.eex

@@ -9,4 +9,4 @@
 
 <%= dgettext("emails",
   "If you didn't create an account at %{url}, please ignore this.",
-  url: Routes.live_url(Endpoint, HomeLive)) %>
+  url: ~p"/") %>

lib/cannery_web/components/email_html/reset_password.txt.eex

@@ -7,4 +7,4 @@
 
 <%= dgettext("emails",
   "If you didn't request this change from %{url}, please ignore this.",
-  url: Routes.live_url(Endpoint, HomeLive)) %>
+  url: ~p"/") %>

lib/cannery_web/components/email_html/update_email.txt.eex

@@ -7,4 +7,4 @@
 
 <%= dgettext("emails",
   "If you didn't request this change from %{url}, please ignore this.",
-  url: Routes.live_url(Endpoint, HomeLive)) %>
+  url: ~p"/") %>

lib/cannery_web/components/layouts.ex

@@ -0,0 +1,17 @@
+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

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

@@ -10,7 +10,7 @@
         phx-click="lv:clear-flash"
         phx-value-key="info"
       >
-        <%= live_flash(@flash, "info") %>
+        <%= Phoenix.Flash.get(@flash, :info) %>
       </p>
 
       <p
@@ -20,7 +20,7 @@
         phx-click="lv:clear-flash"
         phx-value-key="error"
       >
-        <%= live_flash(@flash, "error") %>
+        <%= Phoenix.Flash.get(@flash, :error) %>
       </p>
     </div>
   </header>

lib/cannery_web/components/layouts/email_html.html.heex

@@ -9,7 +9,7 @@
 
     <hr style="margin: 2em auto; border-width: 1px; border-color: rgb(212, 212, 216); width: 100%; max-width: 42rem;" />
 
-    <a style="color: rgb(31, 31, 31);" href={Routes.live_url(Endpoint, HomeLive)}>
+    <a style="color: rgb(31, 31, 31);" href={~p"/"}>
       <%= dgettext(
         "emails",
         "This email was sent from Cannery, the self-hosted firearm tracker website."

lib/cannery_web/components/layouts/email_text.txt.eex

@@ -8,4 +8,4 @@
 
 <%= dgettext("emails",
   "This email was sent from Cannery at %{url}, the self-hosted firearm tracker website.",
-  url: Routes.live_url(Endpoint, HomeLive)) %>
+  url: ~p"/") %>

lib/cannery_web/components/layouts/empty.html.heex

@@ -0,0 +1 @@
+<%= @inner_block %>

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

@@ -5,21 +5,12 @@
     <meta http-equiv="X-UA-Compatible" content="IE=edge" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <%= csrf_meta_tag() %>
-    <link
+    <link rel="shortcut icon" type="image/jpg" href={~p"/images/cannery.svg"} />
-      rel="shortcut icon"
-      type="image/jpg"
-      href={Routes.static_path(@conn, "/images/cannery.svg")}
-    />
     <.live_title suffix={" | #{gettext("Cannery")}"}>
       <%= assigns[:page_title] || gettext("Cannery") %>
     </.live_title>
-    <link phx-track-static rel="stylesheet" href={Routes.static_path(@conn, "/css/app.css")} />
+    <link phx-track-static rel="stylesheet" href={~p"/css/app.css"} />
-    <script
+    <script defer phx-track-static type="text/javascript" src={~p"/js/app.js"}>
-      defer
-      phx-track-static
-      type="text/javascript"
-      src={Routes.static_path(@conn, "/js/app.js")}
-    >
     </script>
   </head>
 

lib/cannery_web/components/move_pack_component.ex

@@ -1,11 +1,10 @@
-defmodule CanneryWeb.Components.MoveAmmoGroupComponent do
+defmodule CanneryWeb.Components.MovePackComponent do
   @moduledoc """
-  Livecomponent that can move an ammo group to another container
+  Livecomponent that can move a pack to another container
   """
 
   use CanneryWeb, :live_component
-  alias Cannery.{Accounts.User, Ammo, Ammo.AmmoGroup, Containers, Containers.Container}
+  alias Cannery.{Accounts.User, Ammo, Ammo.Pack, Containers, Containers.Container}
-  alias CanneryWeb.Endpoint
   alias Ecto.Changeset
   alias Phoenix.LiveView.Socket
 
@@ -13,17 +12,16 @@ defmodule CanneryWeb.Components.MoveAmmoGroupComponent do
   @spec update(
           %{
             required(:current_user) => User.t(),
-            required(:ammo_group) => AmmoGroup.t(),
+            required(:pack) => Pack.t(),
             optional(any()) => any()
           },
           Socket.t()
         ) :: {:ok, Socket.t()}
   def update(
-        %{ammo_group: %{container_id: container_id} = ammo_group, current_user: current_user} =
+        %{pack: %{container_id: container_id} = pack, current_user: current_user} = assigns,
-          assigns,
         socket
       ) do
-    changeset = ammo_group |> AmmoGroup.update_changeset(%{}, current_user)
+    changeset = pack |> Pack.update_changeset(%{}, current_user)
 
     containers =
       Containers.list_containers(current_user)
@@ -41,16 +39,15 @@ defmodule CanneryWeb.Components.MoveAmmoGroupComponent do
   def handle_event(
         "move",
         %{"container_id" => container_id},
-        %{assigns: %{ammo_group: ammo_group, current_user: current_user, return_to: return_to}} =
+        %{assigns: %{pack: pack, current_user: current_user, return_to: return_to}} = socket
-          socket
       ) do
     %{name: container_name} = Containers.get_container!(container_id, current_user)
 
     socket =
-      ammo_group
+      pack
-      |> Ammo.update_ammo_group(%{"container_id" => container_id}, current_user)
+      |> Ammo.update_pack(%{"container_id" => container_id}, current_user)
       |> case do
-        {:ok, _ammo_group} ->
+        {:ok, _pack} ->
           prompt = dgettext("prompts", "Ammo moved to %{name} successfully", name: container_name)
           socket |> put_flash(:info, prompt) |> push_navigate(to: return_to)
 
@@ -86,13 +83,13 @@ defmodule CanneryWeb.Components.MoveAmmoGroupComponent do
           <%= display_emoji("😔") %>
         </h2>
 
-        <.link navigate={Routes.container_index_path(Endpoint, :new)} class="btn btn-primary">
+        <.link navigate={~p"/containers/new"} class="btn btn-primary">
           <%= dgettext("actions", "Add another container!") %>
         </.link>
       <% else %>
         <.live_component
           module={CanneryWeb.Components.TableComponent}
-          id="move_ammo_group_table"
+          id="move-pack-table"
           columns={@columns}
           rows={@rows}
         />

lib/cannery_web/components/pack_table_component.ex

@@ -0,0 +1,274 @@
+defmodule CanneryWeb.Components.PackTableComponent do
+  @moduledoc """
+  A component that displays a list of packs
+  """
+  use CanneryWeb, :live_component
+  alias Cannery.{Accounts.User, Ammo.Pack, ComparableDate}
+  alias Cannery.{ActivityLog, Ammo, Containers}
+  alias CanneryWeb.Components.TableComponent
+  alias Ecto.UUID
+  alias Phoenix.LiveView.{Rendered, Socket}
+
+  @impl true
+  @spec update(
+          %{
+            required(:id) => UUID.t(),
+            required(:current_user) => User.t(),
+            required(:packs) => [Pack.t()],
+            required(:show_used) => boolean(),
+            optional(:type) => Rendered.t(),
+            optional(:range) => Rendered.t(),
+            optional(:container) => Rendered.t(),
+            optional(:actions) => Rendered.t(),
+            optional(any()) => any()
+          },
+          Socket.t()
+        ) :: {:ok, Socket.t()}
+  def update(
+        %{id: _id, packs: _pack, current_user: _current_user, show_used: _show_used} = assigns,
+        socket
+      ) do
+    socket =
+      socket
+      |> assign(assigns)
+      |> assign_new(:type, fn -> [] end)
+      |> assign_new(:range, fn -> [] end)
+      |> assign_new(:container, fn -> [] end)
+      |> assign_new(:actions, fn -> [] end)
+      |> display_packs()
+
+    {:ok, socket}
+  end
+
+  defp display_packs(
+         %{
+           assigns: %{
+             packs: packs,
+             current_user: current_user,
+             type: type,
+             range: range,
+             container: container,
+             actions: actions,
+             show_used: show_used
+           }
+         } = 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(
+        %{label: gettext("Actions"), key: :actions, sortable: false},
+        actions != []
+      )
+      |> TableComponent.maybe_compose_columns(%{
+        label: gettext("Last used on"),
+        key: :used_up_on,
+        type: ComparableDate
+      })
+      |> TableComponent.maybe_compose_columns(%{
+        label: gettext("Purchased on"),
+        key: :purchased_on,
+        type: ComparableDate
+      })
+      |> TableComponent.maybe_compose_columns(
+        %{label: gettext("Container"), key: :container},
+        container != []
+      )
+      |> TableComponent.maybe_compose_columns(
+        %{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("% left"), key: :remaining},
+        show_used
+      )
+      |> TableComponent.maybe_compose_columns(
+        %{label: gettext("Original Count"), key: :original_count},
+        show_used
+      )
+      |> TableComponent.maybe_compose_columns(%{
+        label: if(show_used, do: gettext("Current Count"), else: gettext("Count")),
+        key: :count
+      })
+      |> TableComponent.maybe_compose_columns(
+        %{label: gettext("Type"), key: :type},
+        type != []
+      )
+
+    containers =
+      packs
+      |> Enum.map(fn %{container_id: container_id} -> container_id end)
+      |> Containers.get_containers(current_user)
+
+    extra_data = %{
+      current_user: current_user,
+      type: type,
+      columns: columns,
+      container: container,
+      containers: containers,
+      original_counts: Ammo.get_original_counts(packs, current_user),
+      cprs: Ammo.get_cprs(packs, current_user),
+      last_used_dates: ActivityLog.get_last_used_dates(packs, current_user),
+      percentages_remaining: Ammo.get_percentages_remaining(packs, current_user),
+      actions: actions,
+      range: range
+    }
+
+    rows =
+      packs
+      |> Enum.map(fn pack ->
+        pack |> get_row_data_for_pack(extra_data)
+      end)
+
+    socket |> assign(columns: columns, rows: rows)
+  end
+
+  @impl true
+  def render(assigns) do
+    ~H"""
+    <div id={@id} class="w-full">
+      <.live_component
+        module={TableComponent}
+        id={"pack-table-#{@id}"}
+        columns={@columns}
+        rows={@rows}
+      />
+    </div>
+    """
+  end
+
+  @spec get_row_data_for_pack(Pack.t(), additional_data :: map()) :: map()
+  defp get_row_data_for_pack(pack, %{columns: columns} = additional_data) do
+    columns
+    |> Map.new(fn %{key: key} ->
+      {key, get_value_for_key(key, pack, additional_data)}
+    end)
+  end
+
+  @spec get_value_for_key(atom(), Pack.t(), additional_data :: map()) ::
+          any() | {any(), Rendered.t()}
+  defp get_value_for_key(
+         :type,
+         %{type: %{name: type_name} = type},
+         %{type: type_block}
+       ) do
+    assigns = %{type: type, type_block: type_block}
+
+    {type_name,
+     ~H"""
+     <%= render_slot(@type_block, @type) %>
+     """}
+  end
+
+  defp get_value_for_key(:price_paid, %{price_paid: nil}, _additional_data),
+    do: {0, gettext("No cost information")}
+
+  defp get_value_for_key(:price_paid, %{price_paid: price_paid}, _additional_data),
+    do: {price_paid, gettext("$%{amount}", amount: display_currency(price_paid))}
+
+  defp get_value_for_key(:purchased_on, %{purchased_on: purchased_on} = assigns, _additional_data) do
+    {purchased_on,
+     ~H"""
+     <.date id={"#{@id}-purchased-on"} date={@purchased_on} />
+     """}
+  end
+
+  defp get_value_for_key(:used_up_on, %{id: pack_id}, %{last_used_dates: last_used_dates}) do
+    last_used_date = last_used_dates |> Map.get(pack_id)
+    assigns = %{id: pack_id, last_used_date: last_used_date}
+
+    {last_used_date,
+     ~H"""
+     <%= if @last_used_date do %>
+       <.date id={"#{@id}-last-used-date"} date={@last_used_date} />
+     <% else %>
+       <%= gettext("Never used") %>
+     <% end %>
+     """}
+  end
+
+  defp get_value_for_key(:range, %{staged: staged} = pack, %{range: range}) do
+    assigns = %{range: range, pack: pack}
+
+    {staged,
+     ~H"""
+     <%= render_slot(@range, @pack) %>
+     """}
+  end
+
+  defp get_value_for_key(
+         :remaining,
+         %{id: pack_id},
+         %{percentages_remaining: percentages_remaining}
+       ) do
+    percentage = Map.fetch!(percentages_remaining, pack_id)
+    {percentage, gettext("%{percentage}%", percentage: percentage)}
+  end
+
+  defp get_value_for_key(:actions, pack, %{actions: actions}) do
+    assigns = %{actions: actions, pack: pack}
+
+    ~H"""
+    <%= render_slot(@actions, @pack) %>
+    """
+  end
+
+  defp get_value_for_key(:container, %{container: nil}, _additional_data), do: {nil, nil}
+
+  defp get_value_for_key(
+         :container,
+         %{container_id: container_id} = pack,
+         %{container: container_block, containers: containers}
+       ) do
+    container = %{name: container_name} = Map.fetch!(containers, container_id)
+
+    assigns = %{
+      container: container,
+      container_block: container_block,
+      pack: pack
+    }
+
+    {container_name,
+     ~H"""
+     <%= render_slot(@container_block, {@pack, @container}) %>
+     """}
+  end
+
+  defp get_value_for_key(
+         :original_count,
+         %{id: pack_id},
+         %{original_counts: original_counts}
+       ) do
+    Map.fetch!(original_counts, pack_id)
+  end
+
+  defp get_value_for_key(:cpr, %{price_paid: nil}, _additional_data),
+    do: {0, gettext("No cost information")}
+
+  defp get_value_for_key(:cpr, %{id: pack_id}, %{cprs: cprs}) do
+    amount = Map.fetch!(cprs, pack_id)
+    {amount, gettext("$%{amount}", amount: display_currency(amount))}
+  end
+
+  defp get_value_for_key(:count, %{count: count}, _additional_data),
+    do: if(count == 0, do: {0, gettext("Empty")}, else: count)
+
+  defp get_value_for_key(key, pack, _additional_data), do: pack |> Map.get(key)
+
+  @spec display_currency(float()) :: String.t()
+  defp display_currency(float), do: :erlang.float_to_binary(float, decimals: 2)
+end

lib/cannery_web/components/shot_record_table_component.ex

@@ -1,9 +1,9 @@
-defmodule CanneryWeb.Components.ShotGroupTableComponent do
+defmodule CanneryWeb.Components.ShotRecordTableComponent do
   @moduledoc """
-  A component that displays a list of shot groups
+  A component that displays a list of shot records
   """
   use CanneryWeb, :live_component
-  alias Cannery.{Accounts.User, ActivityLog.ShotGroup, Ammo, ComparableDate}
+  alias Cannery.{Accounts.User, ActivityLog.ShotRecord, Ammo, ComparableDate}
   alias Ecto.UUID
   alias Phoenix.LiveView.{Rendered, Socket}
 
@@ -12,26 +12,29 @@ defmodule CanneryWeb.Components.ShotGroupTableComponent do
           %{
             required(:id) => UUID.t(),
             required(:current_user) => User.t(),
-            optional(:shot_groups) => [ShotGroup.t()],
+            optional(:shot_records) => [ShotRecord.t()],
             optional(:actions) => Rendered.t(),
             optional(any()) => any()
           },
           Socket.t()
         ) :: {:ok, Socket.t()}
-  def update(%{id: _id, shot_groups: _shot_groups, current_user: _current_user} = assigns, socket) do
+  def update(
+        %{id: _id, shot_records: _shot_records, current_user: _current_user} = assigns,
+        socket
+      ) do
     socket =
       socket
       |> assign(assigns)
       |> assign_new(:actions, fn -> [] end)
-      |> display_shot_groups()
+      |> display_shot_records()
 
     {:ok, socket}
   end
 
-  defp display_shot_groups(
+  defp display_shot_records(
          %{
            assigns: %{
-             shot_groups: shot_groups,
+             shot_records: shot_records,
              current_user: current_user,
              actions: actions
            }
@@ -45,17 +48,17 @@ defmodule CanneryWeb.Components.ShotGroupTableComponent do
       %{label: gettext("Actions"), key: :actions, sortable: false}
     ]
 
-    ammo_groups =
+    packs =
-      shot_groups
+      shot_records
-      |> Enum.map(fn %{ammo_group_id: ammo_group_id} -> ammo_group_id end)
+      |> Enum.map(fn %{pack_id: pack_id} -> pack_id end)
-      |> Ammo.get_ammo_groups(current_user)
+      |> Ammo.get_packs(current_user)
 
-    extra_data = %{current_user: current_user, actions: actions, ammo_groups: ammo_groups}
+    extra_data = %{current_user: current_user, actions: actions, packs: packs}
 
     rows =
-      shot_groups
+      shot_records
-      |> Enum.map(fn shot_group ->
+      |> Enum.map(fn shot_record ->
-        shot_group |> get_row_data_for_shot_group(columns, extra_data)
+        shot_record |> get_row_data_for_shot_record(columns, extra_data)
       end)
 
     socket
@@ -71,7 +74,7 @@ defmodule CanneryWeb.Components.ShotGroupTableComponent do
     <div id={@id} class="w-full">
       <.live_component
         module={CanneryWeb.Components.TableComponent}
-        id={"table-#{@id}"}
+        id={"shot-record-table-#{@id}"}
         columns={@columns}
         rows={@rows}
         initial_key={:date}
@@ -81,22 +84,22 @@ defmodule CanneryWeb.Components.ShotGroupTableComponent do
     """
   end
 
-  @spec get_row_data_for_shot_group(ShotGroup.t(), columns :: [map()], extra_data :: map()) ::
+  @spec get_row_data_for_shot_record(ShotRecord.t(), columns :: [map()], extra_data :: map()) ::
           map()
-  defp get_row_data_for_shot_group(shot_group, columns, extra_data) do
+  defp get_row_data_for_shot_record(shot_record, columns, extra_data) do
     columns
     |> Map.new(fn %{key: key} ->
-      {key, get_row_value(key, shot_group, extra_data)}
+      {key, get_row_value(key, shot_record, extra_data)}
     end)
   end
 
-  defp get_row_value(:name, %{ammo_group_id: ammo_group_id}, %{ammo_groups: ammo_groups}) do
+  defp get_row_value(:name, %{pack_id: pack_id}, %{packs: packs}) do
-    assigns = %{ammo_group: ammo_group = Map.fetch!(ammo_groups, ammo_group_id)}
+    assigns = %{pack: pack = Map.fetch!(packs, pack_id)}
 
-    {ammo_group.ammo_type.name,
+    {pack.type.name,
      ~H"""
-     <.link navigate={Routes.ammo_group_show_path(Endpoint, :show, @ammo_group)} class="link">
+     <.link navigate={~p"/ammo/show/#{@pack}"} class="link">
-       <%= @ammo_group.ammo_type.name %>
+       <%= @pack.type.name %>
      </.link>
      """}
   end
@@ -108,13 +111,13 @@ defmodule CanneryWeb.Components.ShotGroupTableComponent do
      """}
   end
 
-  defp get_row_value(:actions, shot_group, %{actions: actions}) do
+  defp get_row_value(:actions, shot_record, %{actions: actions}) do
-    assigns = %{actions: actions, shot_group: shot_group}
+    assigns = %{actions: actions, shot_record: shot_record}
 
     ~H"""
-    <%= render_slot(@actions, @shot_group) %>
+    <%= render_slot(@actions, @shot_record) %>
     """
   end
 
-  defp get_row_value(key, shot_group, _extra_data), do: shot_group |> Map.get(key)
+  defp get_row_value(key, shot_record, _extra_data), do: shot_record |> Map.get(key)
 end

lib/cannery_web/components/table_component.ex

@@ -135,4 +135,25 @@ defmodule CanneryWeb.Components.TableComponent do
       sort_mode
     )
   end
+
+  @doc """
+  Conditionally composes elements into the columns list, supports maps and
+  lists. Works tail to front in order for efficiency
+
+      iex> []
+      ...> |> maybe_compose_columns(%{label: "Column 3"}, true)
+      ...> |> maybe_compose_columns(%{label: "Column 2"}, false)
+      ...> |> maybe_compose_columns(%{label: "Column 1"})
+      [%{label: "Column 1"}, %{label: "Column 3"}]
+
+  """
+  @spec maybe_compose_columns(list(), element_to_add :: list() | map()) :: list()
+  @spec maybe_compose_columns(list(), element_to_add :: list() | map(), boolean()) :: list()
+  def maybe_compose_columns(columns, element_or_elements, add? \\ true)
+
+  def maybe_compose_columns(columns, elements, true) when is_list(elements),
+    do: Enum.concat(elements, columns)
+
+  def maybe_compose_columns(columns, element, true) when is_map(element), do: [element | columns]
+  def maybe_compose_columns(columns, _element_or_elements, false), do: columns
 end

lib/cannery_web/components/type_table_component.ex

@@ -0,0 +1,300 @@
+defmodule CanneryWeb.Components.TypeTableComponent do
+  @moduledoc """
+  A component that displays a list of types
+  """
+  use CanneryWeb, :live_component
+  alias Cannery.{Accounts.User, ActivityLog, Ammo, Ammo.Type}
+  alias CanneryWeb.Components.TableComponent
+  alias Ecto.UUID
+  alias Phoenix.LiveView.{Rendered, Socket}
+
+  @impl true
+  @spec update(
+          %{
+            required(:id) => UUID.t(),
+            required(:current_user) => User.t(),
+            optional(:class) => Type.class() | nil,
+            optional(:show_used) => boolean(),
+            optional(:types) => [Type.t()],
+            optional(:actions) => Rendered.t(),
+            optional(any()) => any()
+          },
+          Socket.t()
+        ) :: {:ok, Socket.t()}
+  def update(%{id: _id, types: _types, current_user: _current_user} = assigns, socket) do
+    socket =
+      socket
+      |> assign(assigns)
+      |> assign_new(:show_used, fn -> false end)
+      |> assign_new(:class, fn -> :all end)
+      |> assign_new(:actions, fn -> [] end)
+      |> display_types()
+
+    {:ok, socket}
+  end
+
+  defp display_types(
+         %{
+           assigns: %{
+             types: types,
+             current_user: current_user,
+             show_used: show_used,
+             class: class,
+             actions: actions
+           }
+         } = socket
+       ) do
+    filtered_columns =
+      [
+        %{label: gettext("Cartridge"), key: :cartridge, type: :string},
+        %{
+          label: if(class == :shotgun, do: gettext("Gauge"), else: gettext("Caliber")),
+          key: :caliber,
+          type: :string
+        },
+        %{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("Grains"), key: :grains, type: :string},
+        %{label: gettext("Bullet type"), key: :bullet_type, type: :string},
+        %{
+          label: if(class == :shotgun, do: gettext("Slug core"), else: gettext("Bullet core")),
+          key: :bullet_core,
+          type: :string
+        },
+        %{label: gettext("Jacket type"), key: :jacket_type, type: :string},
+        %{label: gettext("Case material"), key: :case_material, type: :string},
+        %{label: gettext("Wadding"), key: :wadding, type: :string},
+        %{label: gettext("Shot type"), key: :shot_type, type: :string},
+        %{label: gettext("Shot material"), key: :shot_material, type: :string},
+        %{label: gettext("Shot size"), key: :shot_size, type: :string},
+        %{label: gettext("Load grains"), key: :load_grains, type: :string},
+        %{label: gettext("Shot charge weight"), key: :shot_charge_weight, type: :string},
+        %{label: gettext("Powder type"), key: :powder_type, type: :string},
+        %{
+          label: gettext("Powder grains per charge"),
+          key: :powder_grains_per_charge,
+          type: :string
+        },
+        %{label: gettext("Pressure"), key: :pressure, type: :string},
+        %{label: gettext("Dram equivalent"), key: :dram_equivalent, type: :string},
+        %{label: gettext("Muzzle velocity"), key: :muzzle_velocity, type: :string},
+        %{label: gettext("Primer type"), key: :primer_type, type: :string},
+        %{label: gettext("Firing type"), key: :firing_type, type: :string},
+        %{label: gettext("Tracer"), key: :tracer, type: :atom},
+        %{label: gettext("Incendiary"), key: :incendiary, type: :atom},
+        %{label: gettext("Blank"), key: :blank, type: :atom},
+        %{label: gettext("Corrosive"), key: :corrosive, type: :atom},
+        %{label: gettext("Manufacturer"), key: :manufacturer, type: :string}
+      ]
+      |> Enum.filter(fn %{key: key, type: type} ->
+        # remove columns if all values match defaults
+        default_value = if type == :atom, do: false, else: nil
+
+        types
+        |> Enum.any?(fn type -> Map.get(type, key, default_value) != default_value end)
+      end)
+
+    columns =
+      [%{label: gettext("Actions"), key: "actions", type: :actions, sortable: false}]
+      |> TableComponent.maybe_compose_columns(%{
+        label: gettext("Average CPR"),
+        key: :avg_price_paid,
+        type: :avg_price_paid
+      })
+      |> TableComponent.maybe_compose_columns(
+        %{
+          label: gettext("Total ever packs"),
+          key: :historical_pack_count,
+          type: :historical_pack_count
+        },
+        show_used
+      )
+      |> TableComponent.maybe_compose_columns(
+        %{
+          label: gettext("Used packs"),
+          key: :used_pack_count,
+          type: :used_pack_count
+        },
+        show_used
+      )
+      |> TableComponent.maybe_compose_columns(%{
+        label: gettext("Packs"),
+        key: :ammo_count,
+        type: :ammo_count
+      })
+      |> TableComponent.maybe_compose_columns(
+        %{
+          label: gettext("Total ever rounds"),
+          key: :historical_round_count,
+          type: :historical_round_count
+        },
+        show_used
+      )
+      |> TableComponent.maybe_compose_columns(
+        %{
+          label: gettext("Used rounds"),
+          key: :used_round_count,
+          type: :used_round_count
+        },
+        show_used
+      )
+      |> TableComponent.maybe_compose_columns(%{
+        label: gettext("Rounds"),
+        key: :round_count,
+        type: :round_count
+      })
+      |> TableComponent.maybe_compose_columns(filtered_columns)
+      |> TableComponent.maybe_compose_columns(
+        %{label: gettext("Class"), key: :class, type: :atom},
+        class in [:all, nil]
+      )
+      |> 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)
+
+    [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
+          )
+        ]
+      else
+        [nil, nil, nil, nil]
+      end
+
+    extra_data = %{
+      actions: actions,
+      current_user: current_user,
+      used_counts: used_counts,
+      round_counts: round_counts,
+      historical_round_counts: historical_round_counts,
+      packs_count: packs_count,
+      used_pack_counts: used_pack_counts,
+      historical_pack_counts: historical_pack_counts,
+      average_costs: average_costs
+    }
+
+    rows =
+      types
+      |> Enum.map(fn type ->
+        type |> get_type_values(columns, extra_data)
+      end)
+
+    socket |> assign(columns: columns, rows: rows)
+  end
+
+  @impl true
+  def render(assigns) do
+    ~H"""
+    <div id={@id} class="w-full">
+      <.live_component
+        module={TableComponent}
+        id={"type-table-#{@id}"}
+        columns={@columns}
+        rows={@rows}
+      />
+    </div>
+    """
+  end
+
+  defp get_type_values(type, columns, extra_data) do
+    columns
+    |> Map.new(fn %{key: key, type: column_type} ->
+      {key, get_type_value(column_type, key, type, extra_data)}
+    end)
+  end
+
+  defp get_type_value(:atom, key, type, _other_data),
+    do: type |> Map.get(key) |> humanize()
+
+  defp get_type_value(:round_count, _key, %{id: type_id}, %{round_counts: round_counts}),
+    do: Map.get(round_counts, type_id, 0)
+
+  defp get_type_value(
+         :historical_round_count,
+         _key,
+         %{id: type_id},
+         %{historical_round_counts: historical_round_counts}
+       ) do
+    Map.get(historical_round_counts, type_id, 0)
+  end
+
+  defp get_type_value(
+         :used_round_count,
+         _key,
+         %{id: type_id},
+         %{used_counts: used_counts}
+       ) do
+    Map.get(used_counts, type_id, 0)
+  end
+
+  defp get_type_value(
+         :historical_pack_count,
+         _key,
+         %{id: type_id},
+         %{historical_pack_counts: historical_pack_counts}
+       ) do
+    Map.get(historical_pack_counts, type_id, 0)
+  end
+
+  defp get_type_value(
+         :used_pack_count,
+         _key,
+         %{id: type_id},
+         %{used_pack_counts: used_pack_counts}
+       ) do
+    Map.get(used_pack_counts, type_id, 0)
+  end
+
+  defp get_type_value(:ammo_count, _key, %{id: type_id}, %{packs_count: packs_count}),
+    do: Map.get(packs_count, type_id)
+
+  defp get_type_value(
+         :avg_price_paid,
+         _key,
+         %{id: type_id},
+         %{average_costs: average_costs}
+       ) do
+    case Map.get(average_costs, type_id) do
+      nil -> {0, gettext("No cost information")}
+      count -> {count, gettext("$%{amount}", amount: display_currency(count))}
+    end
+  end
+
+  defp get_type_value(:name, _key, %{name: type_name} = assigns, _other_data) do
+    {type_name,
+     ~H"""
+     <.link navigate={~p"/type/#{@id}"} class="link">
+       <%= @name %>
+     </.link>
+     """}
+  end
+
+  defp get_type_value(:actions, _key, type, %{actions: actions}) do
+    assigns = %{actions: actions, type: type}
+
+    ~H"""
+    <%= render_slot(@actions, @type) %>
+    """
+  end
+
+  defp get_type_value(nil, _key, _type, _other_data), do: nil
+
+  defp get_type_value(_other, key, type, _other_data), do: type |> Map.get(key)
+
+  @spec display_currency(float()) :: String.t()
+  defp display_currency(float), do: :erlang.float_to_binary(float, decimals: 2)
+end

lib/cannery_web/controllers/email_controller.ex

@@ -6,7 +6,8 @@ defmodule CanneryWeb.EmailController do
   use CanneryWeb, :controller
   alias Cannery.Accounts.User
 
-  plug :put_layout, {CanneryWeb.LayoutView, :email}
+  plug :put_root_layout, html: {CanneryWeb.Layouts, :email_html}
+  plug :put_layout, false
 
   @sample_assigns %{
     email: %{subject: "Example subject"},
@@ -18,6 +19,6 @@ defmodule CanneryWeb.EmailController do
   Debug route used to preview emails
   """
   def preview(conn, %{"id" => template}) do
-    render(conn, "#{template |> to_string()}.html", @sample_assigns)
+    render(conn, String.to_existing_atom(template), @sample_assigns)
   end
 end

lib/cannery_web/controllers/error_html.ex

@@ -0,0 +1,16 @@
+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

lib/cannery_web/controllers/error_html/error.html.heex

@@ -24,10 +24,7 @@
 
         <hr class="w-full hr" />
 
-        <.link
+        <.link href={~p"/"} class="link title text-primary-600 text-lg">
-          href={Routes.live_path(Endpoint, HomeLive)}
-          class="link title text-primary-600 text-lg"
-        >
           <%= dgettext("errors", "Go back home") %>
         </.link>
       </div>

lib/cannery_web/controllers/error_json.ex

@@ -0,0 +1,14 @@
+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

lib/cannery_web/controllers/export_controller.ex

@@ -3,74 +3,80 @@ defmodule CanneryWeb.ExportController do
   alias Cannery.{ActivityLog, Ammo, Containers}
 
   def export(%{assigns: %{current_user: current_user}} = conn, %{"mode" => "json"}) do
-    ammo_types = Ammo.list_ammo_types(current_user)
+    types = Ammo.list_types(current_user)
-    used_counts = ammo_types |> ActivityLog.get_used_count_for_ammo_types(current_user)
-    round_counts = ammo_types |> Ammo.get_round_count_for_ammo_types(current_user)
-    ammo_group_counts = ammo_types |> Ammo.get_ammo_groups_count_for_types(current_user)
 
-    total_ammo_group_counts =
+    used_counts =
-      ammo_types |> Ammo.get_ammo_groups_count_for_types(current_user, true)
+      ActivityLog.get_grouped_used_counts(current_user, types: types, group_by: :type_id)
 
-    average_costs = ammo_types |> Ammo.get_average_cost_for_ammo_types(current_user)
+    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)
 
-    ammo_types =
+    total_pack_counts =
-      ammo_types
+      Ammo.get_grouped_packs_count(current_user,
-      |> Enum.map(fn %{id: ammo_type_id} = ammo_type ->
+        types: types,
-        ammo_type
+        group_by: :type_id,
+        show_used: true
+      )
+
+    average_costs = Ammo.get_average_costs(types, current_user)
+
+    types =
+      types
+      |> Enum.map(fn %{id: type_id} = type ->
+        type
         |> Jason.encode!()
         |> Jason.decode!()
         |> Map.merge(%{
-          "average_cost" => Map.get(average_costs, ammo_type_id),
+          "average_cost" => Map.get(average_costs, type_id),
-          "round_count" => Map.get(round_counts, ammo_type_id, 0),
+          "round_count" => Map.get(round_counts, type_id, 0),
-          "used_count" => Map.get(used_counts, ammo_type_id, 0),
+          "used_count" => Map.get(used_counts, type_id, 0),
-          "ammo_group_count" => Map.get(ammo_group_counts, ammo_type_id, 0),
+          "pack_count" => Map.get(pack_counts, type_id, 0),
-          "total_ammo_group_count" => Map.get(total_ammo_group_counts, ammo_type_id, 0)
+          "total_pack_count" => Map.get(total_pack_counts, type_id, 0)
         })
       end)
 
-    ammo_groups = Ammo.list_ammo_groups(nil, true, current_user)
+    packs = Ammo.list_packs(current_user, show_used: true)
-    used_counts = ammo_groups |> ActivityLog.get_used_counts(current_user)
-    original_counts = ammo_groups |> Ammo.get_original_counts(current_user)
-    cprs = ammo_groups |> Ammo.get_cprs(current_user)
 
-    ammo_groups =
+    used_counts =
-      ammo_groups
+      ActivityLog.get_grouped_used_counts(current_user, packs: packs, group_by: :pack_id)
-      |> Enum.map(fn %{id: ammo_group_id} = ammo_group ->
-        percentage_remaining = ammo_group |> Ammo.get_percentage_remaining(current_user)
 
-        ammo_group
+    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)
+
+    packs =
+      packs
+      |> Enum.map(fn %{id: pack_id} = pack ->
+        pack
         |> Jason.encode!()
         |> Jason.decode!()
         |> Map.merge(%{
-          "used_count" => Map.get(used_counts, ammo_group_id),
+          "used_count" => Map.get(used_counts, pack_id),
-          "percentage_remaining" => percentage_remaining,
+          "percentage_remaining" => Map.fetch!(percentages_remaining, pack_id),
-          "original_count" => Map.get(original_counts, ammo_group_id),
+          "original_count" => Map.get(original_counts, pack_id),
-          "cpr" => Map.get(cprs, ammo_group_id)
+          "cpr" => Map.get(cprs, pack_id)
         })
       end)
 
-    shot_groups = ActivityLog.list_shot_groups(current_user)
+    shot_records = ActivityLog.list_shot_records(current_user)
 
     containers =
       Containers.list_containers(current_user)
       |> Enum.map(fn container ->
-        ammo_group_count = container |> Ammo.get_ammo_groups_count_for_container!(current_user)
-        round_count = container |> Ammo.get_round_count_for_container!(current_user)
-
         container
         |> Jason.encode!()
         |> Jason.decode!()
         |> Map.merge(%{
-          "ammo_group_count" => ammo_group_count,
+          "pack_count" => Ammo.get_packs_count(current_user, container_id: container.id),
-          "round_count" => round_count
+          "round_count" => Ammo.get_round_count(current_user, container_id: container.id)
         })
       end)
 
     json(conn, %{
       user: current_user,
-      ammo_types: ammo_types,
+      types: types,
-      ammo_groups: ammo_groups,
+      packs: packs,
-      shot_groups: shot_groups,
+      shot_records: shot_records,
       containers: containers
     })
   end

lib/cannery_web/controllers/home_controller.ex

@@ -1,11 +0,0 @@
-defmodule CanneryWeb.HomeController do
-  @moduledoc """
-  Controller for home page
-  """
-
-  use CanneryWeb, :controller
-
-  def index(conn, _params) do
-    render(conn, "index.html")
-  end
-end

lib/cannery_web/controllers/home_html.ex

@@ -0,0 +1,5 @@
+defmodule CanneryWeb.HomeHTML do
+  use CanneryWeb, :html
+
+  embed_templates "home_html/*"
+end

lib/cannery_web/controllers/user_auth.ex

@@ -3,12 +3,11 @@ 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
@@ -39,7 +38,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: Routes.user_session_path(conn, :new))
+    |> redirect(to: ~p"/users/log_in")
     |> halt()
   end
 
@@ -49,8 +48,7 @@ defmodule CanneryWeb.UserAuth do
 
     conn
     |> renew_session()
-    |> put_session(:user_token, token)
+    |> put_token_in_session(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
@@ -96,7 +94,7 @@ defmodule CanneryWeb.UserAuth do
   """
   def log_out_user(conn) do
     user_token = get_session(conn, :user_token)
-    user_token && Accounts.delete_session_token(user_token)
+    user_token && Accounts.delete_user_session_token(user_token)
 
     if live_socket_id = get_session(conn, :live_socket_id) do
       CanneryWeb.Endpoint.broadcast(live_socket_id, "disconnect", %{})
@@ -105,7 +103,7 @@ defmodule CanneryWeb.UserAuth do
     conn
     |> renew_session()
     |> delete_resp_cookie(@remember_me_cookie)
-    |> redirect(to: "/")
+    |> redirect(to: ~p"/")
   end
 
   @doc """
@@ -119,19 +117,110 @@ defmodule CanneryWeb.UserAuth do
   end
 
   defp ensure_user_token(conn) do
-    if user_token = get_session(conn, :user_token) do
+    if token = get_session(conn, :user_token) do
-      {user_token, conn}
+      {token, conn}
     else
       conn = fetch_cookies(conn, signed: [@remember_me_cookie])
 
-      if user_token = conn.cookies[@remember_me_cookie] do
+      if token = conn.cookies[@remember_me_cookie] do
-        {user_token, put_session(conn, :user_token, user_token)}
+        {token, put_token_in_session(conn, 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.
   """
@@ -161,7 +250,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: Routes.user_session_path(conn, :new))
+      |> redirect(to: ~p"/users/log_in")
       |> halt()
     end
   end
@@ -176,16 +265,34 @@ defmodule CanneryWeb.UserAuth do
       conn
       |> put_flash(:error, dgettext("errors", "You are not authorized to view this page."))
       |> maybe_store_return_to()
-      |> redirect(to: Routes.live_path(conn, HomeLive))
+      |> redirect(to: ~p"/")
       |> 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: "/"
+  defp signed_in_path(_conn), do: ~p"/"
 end

lib/cannery_web/controllers/user_confirmation_controller.ex

@@ -1,18 +1,16 @@
 defmodule CanneryWeb.UserConfirmationController do
   use CanneryWeb, :controller
-
-  import CanneryWeb.Gettext
   alias Cannery.Accounts
 
   def new(conn, _params) do
-    render(conn, "new.html", page_title: gettext("Confirm your account"))
+    render(conn, :new, 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,
-        &Routes.user_confirmation_url(conn, :confirm, &1)
+        fn token -> url(CanneryWeb.Endpoint, ~p"/users/confirm/#{token}") end
       )
     end
 
@@ -22,11 +20,10 @@ defmodule CanneryWeb.UserConfirmationController do
       :info,
       dgettext(
         "prompts",
-        "If your email is in our system and it has not been confirmed yet, " <>
+        "If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly."
-          "you will receive an email with instructions shortly."
       )
     )
-    |> redirect(to: "/")
+    |> redirect(to: ~p"/")
   end
 
   # Do not log in the user after confirmation to avoid a
@@ -36,7 +33,7 @@ defmodule CanneryWeb.UserConfirmationController do
       {:ok, %{email: email}} ->
         conn
         |> put_flash(:info, dgettext("prompts", "%{email} confirmed successfully.", email: email))
-        |> redirect(to: "/")
+        |> redirect(to: ~p"/")
 
       :error ->
         # If there is a current user and the account was already confirmed,
@@ -45,7 +42,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: "/")
+            redirect(conn, to: ~p"/")
 
           %{} ->
             conn
@@ -53,7 +50,7 @@ defmodule CanneryWeb.UserConfirmationController do
               :error,
               dgettext("errors", "User confirmation link is invalid or it has expired.")
             )
-            |> redirect(to: "/")
+            |> redirect(to: ~p"/")
         end
     end
   end

lib/cannery_web/controllers/user_confirmation_html.ex

@@ -0,0 +1,6 @@
+defmodule CanneryWeb.UserConfirmationHTML do
+  use CanneryWeb, :html
+  alias Cannery.Accounts
+
+  embed_templates "user_confirmation_html/*"
+end

lib/cannery_web/controllers/user_confirmation_html/new.html.heex

@@ -7,7 +7,7 @@
     :let={f}
     for={%{}}
     as={:user}
-    action={Routes.user_confirmation_path(@conn, :create)}
+    action={~p"/users/confirm"}
     class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
   >
     <%= label(f, :email, gettext("Email"), class: "title text-lg text-primary-600") %>
@@ -21,14 +21,10 @@
   <hr class="hr" />
 
   <div class="flex flex-row justify-center items-center space-x-4">
-    <.link
+    <.link :if={Accounts.allow_registration?()} href={~p"/users/register"} class="btn btn-primary">
-      :if={Accounts.allow_registration?()}
-      href={Routes.user_registration_path(@conn, :new)}
-      class="btn btn-primary"
-    >
       <%= dgettext("actions", "Register") %>
     </.link>
-    <.link href={Routes.user_session_path(@conn, :new)} class="btn btn-primary">
+    <.link href={~p"/users/log_in"} class="btn btn-primary">
       <%= dgettext("actions", "Log in") %>
     </.link>
   </div>

lib/cannery_web/controllers/user_registration_controller.ex

@@ -1,8 +1,6 @@
 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
@@ -11,7 +9,7 @@ defmodule CanneryWeb.UserRegistrationController do
     else
       conn
       |> put_flash(:error, dgettext("errors", "Sorry, this invite was not found or expired"))
-      |> redirect(to: Routes.live_path(Endpoint, HomeLive))
+      |> redirect(to: ~p"/")
     end
   end
 
@@ -21,13 +19,13 @@ defmodule CanneryWeb.UserRegistrationController do
     else
       conn
       |> put_flash(:error, dgettext("errors", "Sorry, public registration is disabled"))
-      |> redirect(to: Routes.live_path(Endpoint, HomeLive))
+      |> redirect(to: ~p"/")
     end
   end
 
   # renders new user registration page
   defp render_new(conn, invite_token \\ nil) do
-    render(conn, "new.html",
+    render(conn, :new,
       changeset: Accounts.change_user_registration(),
       invite_token: invite_token,
       page_title: gettext("Register")
@@ -40,7 +38,7 @@ defmodule CanneryWeb.UserRegistrationController do
     else
       conn
       |> put_flash(:error, dgettext("errors", "Sorry, this invite was not found or expired"))
-      |> redirect(to: Routes.live_path(Endpoint, HomeLive))
+      |> redirect(to: ~p"/")
     end
   end
 
@@ -50,7 +48,7 @@ defmodule CanneryWeb.UserRegistrationController do
     else
       conn
       |> put_flash(:error, dgettext("errors", "Sorry, public registration is disabled"))
-      |> redirect(to: Routes.live_path(Endpoint, HomeLive))
+      |> redirect(to: ~p"/")
     end
   end
 
@@ -59,20 +57,20 @@ defmodule CanneryWeb.UserRegistrationController do
       {:ok, user} ->
         Accounts.deliver_user_confirmation_instructions(
           user,
-          &Routes.user_confirmation_url(conn, :confirm, &1)
+          fn token -> url(CanneryWeb.Endpoint, ~p"/users/confirm/#{token}") end
         )
 
         conn
         |> put_flash(:info, dgettext("prompts", "Please check your email to verify your account"))
-        |> redirect(to: Routes.user_session_path(Endpoint, :new))
+        |> redirect(to: ~p"/users/log_in")
 
       {:error, :invalid_token} ->
         conn
         |> put_flash(:error, dgettext("errors", "Sorry, this invite was not found or expired"))
-        |> redirect(to: Routes.live_path(Endpoint, HomeLive))
+        |> redirect(to: ~p"/")
 
       {:error, %Changeset{} = changeset} ->
-        conn |> render("new.html", changeset: changeset, invite_token: invite_token)
+        conn |> render(:new, changeset: changeset, invite_token: invite_token)
     end
   end
 end

lib/cannery_web/controllers/user_registration_html.ex

@@ -0,0 +1,5 @@
+defmodule CanneryWeb.UserRegistrationHTML do
+  use CanneryWeb, :html
+
+  embed_templates "user_registration_html/*"
+end

lib/cannery_web/controllers/user_registration_html/new.html.heex

@@ -6,10 +6,10 @@
   <.form
     :let={f}
     for={@changeset}
-    action={Routes.user_registration_path(@conn, :create)}
+    action={~p"/users/register"}
     class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
   >
-    <p :if={@changeset.action && not @changeset.valid?()} class="alert alert-danger col-span-3">
+    <p :if={@changeset.action && not @changeset.valid?} class="alert alert-danger col-span-3">
       <%= dgettext("errors", "Oops, something went wrong! Please check the errors below.") %>
     </p>
 
@@ -29,7 +29,12 @@
     <%= select(
       f,
       :locale,
-      [{gettext("English"), "en_US"}],
+      [
+        {"English", "en_US"},
+        {"Deutsch", "de"},
+        {"Français", "fr"},
+        {"Español", "es"}
+      ],
       class: "input input-primary col-span-2"
     ) %>
     <%= error_tag(f, :locale) %>
@@ -40,10 +45,10 @@
   <hr class="hr" />
 
   <div class="flex flex-row justify-center items-center space-x-4">
-    <.link href={Routes.user_session_path(@conn, :new)} class="btn btn-primary">
+    <.link href={~p"/users/log_in"} class="btn btn-primary">
       <%= dgettext("actions", "Log in") %>
     </.link>
-    <.link href={Routes.user_reset_password_path(@conn, :new)} class="btn btn-primary">
+    <.link href={~p"/users/reset_password"} class="btn btn-primary">
       <%= dgettext("actions", "Forgot your password?") %>
     </.link>
   </div>

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.html", page_title: gettext("Forgot your password?"))
+    render(conn, :new, 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,
-        &Routes.user_reset_password_url(conn, :edit, &1)
+        fn token -> url(CanneryWeb.Endpoint, ~p"/users/reset_password/#{token}") end
       )
     end
 
@@ -23,15 +23,14 @@ defmodule CanneryWeb.UserResetPasswordController do
       :info,
       dgettext(
         "prompts",
-        "If your email is in our system, you will receive instructions to " <>
+        "If your email is in our system, you will receive instructions to reset your password shortly."
-          "reset your password shortly."
       )
     )
-    |> redirect(to: "/")
+    |> redirect(to: ~p"/")
   end
 
   def edit(conn, _params) do
-    render(conn, "edit.html",
+    render(conn, :edit,
       changeset: Accounts.change_user_password(conn.assigns.user),
       page_title: gettext("Reset your password")
     )
@@ -44,10 +43,10 @@ defmodule CanneryWeb.UserResetPasswordController do
       {:ok, _} ->
         conn
         |> put_flash(:info, dgettext("prompts", "Password reset successfully."))
-        |> redirect(to: Routes.user_session_path(conn, :new))
+        |> redirect(to: ~p"/users/log_in")
 
       {:error, changeset} ->
-        render(conn, "edit.html", changeset: changeset)
+        render(conn, :edit, changeset: changeset)
     end
   end
 
@@ -62,7 +61,7 @@ defmodule CanneryWeb.UserResetPasswordController do
         :error,
         dgettext("errors", "Reset password link is invalid or it has expired.")
       )
-      |> redirect(to: "/")
+      |> redirect(to: ~p"/")
       |> halt()
     end
   end

lib/cannery_web/controllers/user_reset_password_html.ex

@@ -0,0 +1,6 @@
+defmodule CanneryWeb.UserResetPasswordHTML do
+  use CanneryWeb, :html
+  alias Cannery.Accounts
+
+  embed_templates "user_reset_password_html/*"
+end

lib/cannery_web/controllers/user_reset_password_html/edit.html.heex

@@ -6,10 +6,10 @@
   <.form
     :let={f}
     for={@changeset}
-    action={Routes.user_reset_password_path(@conn, :update, @token)}
+    action={~p"/users/reset_password/#{@token}"}
     class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
   >
-    <p :if={@changeset.action && not @changeset.valid?()} class="alert alert-danger col-span-3">
+    <p :if={@changeset.action && not @changeset.valid?} class="alert alert-danger col-span-3">
       <%= dgettext("errors", "Oops, something went wrong! Please check the errors below.") %>
     </p>
 
@@ -34,14 +34,10 @@
   <hr class="hr" />
 
   <div class="flex flex-row justify-center items-center space-x-4">
-    <.link
+    <.link :if={Accounts.allow_registration?()} href={~p"/users/register"} class="btn btn-primary">
-      :if={Accounts.allow_registration?()}
-      href={Routes.user_registration_path(@conn, :new)}
-      class="btn btn-primary"
-    >
       <%= dgettext("actions", "Register") %>
     </.link>
-    <.link href={Routes.user_session_path(@conn, :new)} class="btn btn-primary">
+    <.link href={~p"/users/log_in"} class="btn btn-primary">
       <%= dgettext("actions", "Log in") %>
     </.link>
   </div>

lib/cannery_web/controllers/user_reset_password_html/new.html.heex

@@ -7,7 +7,7 @@
     :let={f}
     for={%{}}
     as={:user}
-    action={Routes.user_reset_password_path(@conn, :create)}
+    action={~p"/users/reset_password"}
     class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
   >
     <%= label(f, :email, gettext("Email"), class: "title text-lg text-primary-600") %>
@@ -21,14 +21,10 @@
   <hr class="hr" />
 
   <div class="flex flex-row justify-center items-center space-x-4">
-    <.link
+    <.link :if={Accounts.allow_registration?()} href={~p"/users/register"} class="btn btn-primary">
-      :if={Accounts.allow_registration?()}
-      href={Routes.user_registration_path(@conn, :new)}
-      class="btn btn-primary"
-    >
       <%= dgettext("actions", "Register") %>
     </.link>
-    <.link href={Routes.user_session_path(@conn, :new)} class="btn btn-primary">
+    <.link href={~p"/users/log_in"} class="btn btn-primary">
       <%= dgettext("actions", "Log in") %>
     </.link>
   </div>

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.html", error_message: nil, page_title: gettext("Log in"))
+    render(conn, :new, 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.html", error_message: dgettext("errors", "Invalid email or password"))
+      render(conn, :new, error_message: dgettext("errors", "Invalid email or password"))
     end
   end
 

lib/cannery_web/controllers/user_session_html.ex

@@ -0,0 +1,6 @@
+defmodule CanneryWeb.UserSessionHTML do
+  use CanneryWeb, :html
+  alias Cannery.Accounts
+
+  embed_templates "user_session_html/*"
+end

lib/cannery_web/controllers/user_session_html/new.html.heex

@@ -6,8 +6,8 @@
   <.form
     :let={f}
     for={@conn}
-    action={Routes.user_session_path(@conn, :create)}
+    action={~p"/users/log_in"}
-    as="user"
+    as={:user}
     class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
   >
     <p :if={@error_message} class="alert alert-danger col-span-3">
@@ -15,10 +15,18 @@
     </p>
 
     <%= label(f, :email, gettext("Email"), class: "title text-lg text-primary-600") %>
-    <%= email_input(f, :email, required: true, class: "input input-primary col-span-2") %>
+    <%= email_input(f, :email,
+      autocomplete: :email,
+      class: "input input-primary col-span-2",
+      required: true
+    ) %>
 
     <%= label(f, :password, gettext("Password"), class: "title text-lg text-primary-600") %>
-    <%= password_input(f, :password, required: true, class: "input input-primary col-span-2") %>
+    <%= password_input(f, :password,
+      autocomplete: "current-password",
+      class: "input input-primary col-span-2",
+      required: true
+    ) %>
 
     <%= label(f, :remember_me, gettext("Keep me logged in for 60 days"),
       class: "title text-lg text-primary-600"
@@ -31,14 +39,10 @@
   <hr class="hr" />
 
   <div class="flex flex-row justify-center items-center space-x-4">
-    <.link
+    <.link :if={Accounts.allow_registration?()} href={~p"/users/register"} class="btn btn-primary">
-      :if={Accounts.allow_registration?()}
-      href={Routes.user_registration_path(@conn, :new)}
-      class="btn btn-primary"
-    >
       <%= dgettext("actions", "Register") %>
     </.link>
-    <.link href={Routes.user_reset_password_path(@conn, :new)} class="btn btn-primary">
+    <.link href={~p"/users/reset_password"} class="btn btn-primary">
       <%= dgettext("actions", "Forgot your password?") %>
     </.link>
   </div>

lib/cannery_web/controllers/user_settings_controller.ex

@@ -1,13 +1,12 @@
 defmodule CanneryWeb.UserSettingsController do
   use CanneryWeb, :controller
-  import CanneryWeb.Gettext
   alias Cannery.Accounts
-  alias CanneryWeb.{HomeLive, UserAuth}
+  alias CanneryWeb.UserAuth
 
   plug :assign_email_and_password_changesets
 
   def edit(conn, _params) do
-    render(conn, "edit.html", page_title: gettext("Settings"))
+    render(conn, :edit, page_title: gettext("Settings"))
   end
 
   def update(%{assigns: %{current_user: user}} = conn, %{
@@ -20,7 +19,7 @@ defmodule CanneryWeb.UserSettingsController do
         Accounts.deliver_update_email_instructions(
           applied_user,
           user.email,
-          &Routes.user_settings_url(conn, :confirm_email, &1)
+          fn token -> url(CanneryWeb.Endpoint, ~p"/users/settings/confirm_email/#{token}") end
         )
 
         conn
@@ -31,10 +30,10 @@ defmodule CanneryWeb.UserSettingsController do
             "A link to confirm your email change has been sent to the new address."
           )
         )
-        |> redirect(to: Routes.user_settings_path(conn, :edit))
+        |> redirect(to: ~p"/users/settings")
 
       {:error, changeset} ->
-        conn |> render("edit.html", email_changeset: changeset)
+        conn |> render(:edit, email_changeset: changeset)
     end
   end
 
@@ -47,11 +46,11 @@ defmodule CanneryWeb.UserSettingsController do
       {:ok, user} ->
         conn
         |> put_flash(:info, dgettext("prompts", "Password updated successfully."))
-        |> put_session(:user_return_to, Routes.user_settings_path(conn, :edit))
+        |> put_session(:user_return_to, ~p"/users/settings")
         |> UserAuth.log_in_user(user)
 
       {:error, changeset} ->
-        conn |> render("edit.html", password_changeset: changeset)
+        conn |> render(:edit, password_changeset: changeset)
     end
   end
 
@@ -63,10 +62,10 @@ defmodule CanneryWeb.UserSettingsController do
       {:ok, _user} ->
         conn
         |> put_flash(:info, dgettext("prompts", "Language updated successfully."))
-        |> redirect(to: Routes.user_settings_path(conn, :edit))
+        |> redirect(to: ~p"/users/settings")
 
       {:error, changeset} ->
-        conn |> render("edit.html", locale_changeset: changeset)
+        conn |> render(:edit, locale_changeset: changeset)
     end
   end
 
@@ -75,7 +74,7 @@ defmodule CanneryWeb.UserSettingsController do
       :ok ->
         conn
         |> put_flash(:info, dgettext("prompts", "Email changed successfully."))
-        |> redirect(to: Routes.user_settings_path(conn, :edit))
+        |> redirect(to: ~p"/users/settings")
 
       :error ->
         conn
@@ -83,7 +82,7 @@ defmodule CanneryWeb.UserSettingsController do
           :error,
           dgettext("errors", "Email change link is invalid or it has expired.")
         )
-        |> redirect(to: Routes.user_settings_path(conn, :edit))
+        |> redirect(to: ~p"/users/settings")
     end
   end
 
@@ -93,11 +92,11 @@ defmodule CanneryWeb.UserSettingsController do
 
       conn
       |> put_flash(:error, dgettext("prompts", "Your account has been deleted"))
-      |> redirect(to: Routes.live_path(conn, HomeLive))
+      |> redirect(to: ~p"/")
     else
       conn
       |> put_flash(:error, dgettext("errors", "Unable to delete user"))
-      |> redirect(to: Routes.user_settings_path(conn, :edit))
+      |> redirect(to: ~p"/users/settings")
     end
   end
 

lib/cannery_web/controllers/user_settings_html.ex

@@ -0,0 +1,5 @@
+defmodule CanneryWeb.UserSettingsHTML do
+  use CanneryWeb, :html
+
+  embed_templates "user_settings_html/*"
+end

lib/cannery_web/controllers/user_settings_html/edit.html.heex

@@ -8,7 +8,7 @@
   <.form
     :let={f}
     for={@email_changeset}
-    action={Routes.user_settings_path(@conn, :update)}
+    action={~p"/users/settings"}
     class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
   >
     <h3 class="title text-primary-600 text-lg text-center col-span-3">
@@ -16,7 +16,7 @@
     </h3>
 
     <div
-      :if={@email_changeset.action && not @email_changeset.valid?()}
+      :if={@email_changeset.action && not @email_changeset.valid?}
       class="alert alert-danger col-span-3"
     >
       <%= dgettext("errors", "Oops, something went wrong! Please check the errors below.") %>
@@ -50,7 +50,7 @@
   <.form
     :let={f}
     for={@password_changeset}
-    action={Routes.user_settings_path(@conn, :update)}
+    action={~p"/users/settings"}
     class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
   >
     <h3 class="title text-primary-600 text-lg text-center col-span-3">
@@ -58,7 +58,7 @@
     </h3>
 
     <div
-      :if={@password_changeset.action && not @password_changeset.valid?()}
+      :if={@password_changeset.action && not @password_changeset.valid?}
       class="alert alert-danger col-span-3"
     >
       <%= dgettext("errors", "Oops, something went wrong! Please check the errors below.") %>
@@ -104,7 +104,7 @@
   <.form
     :let={f}
     for={@locale_changeset}
-    action={Routes.user_settings_path(@conn, :update)}
+    action={~p"/users/settings"}
     class="flex flex-col space-y-4 sm:space-y-0 sm:grid sm:grid-cols-3 sm:gap-4 justify-center items-center"
   >
     <%= label(f, :locale, dgettext("actions", "Change Language"),
@@ -112,7 +112,7 @@
     ) %>
 
     <div
-      :if={@locale_changeset.action && not @locale_changeset.valid?()}
+      :if={@locale_changeset.action && not @locale_changeset.valid?}
       class="alert alert-danger col-span-3"
     >
       <%= dgettext("errors", "Oops, something went wrong! Please check the errors below.") %>
@@ -124,12 +124,12 @@
       f,
       :locale,
       [
-        {gettext("English"), "en_US"},
+        {"English", "en_US"},
-        {gettext("German"), "de"},
+        {"Deutsch", "de"},
-        {gettext("French"), "fr"},
+        {"Français", "fr"},
-        {gettext("Spanish"), "es"}
+        {"Español", "es"}
       ],
-      class: "mx-2 my-1 min-w-md input input-primary col-span-3"
+      class: "my-1 min-w-md input input-primary col-span-3"
     ) %>
     <%= error_tag(f, :locale, "col-span-3") %>
 
@@ -142,17 +142,13 @@
   <hr class="hr" />
 
   <div class="flex justify-center items-center">
-    <.link
+    <.link href={~p"/export/json"} class="mx-4 my-2 btn btn-primary" target="_blank">
-      href={Routes.export_path(@conn, :export, :json)}
-      class="mx-4 my-2 btn btn-primary"
-      target="_blank"
-    >
       <%= dgettext("actions", "Export Data as JSON") %>
     </.link>
 
     <.link
-      href={Routes.user_settings_path(@conn, :delete, @current_user)}
+      href={~p"/users/settings/#{@current_user}"}
-      method={:delete}
+      method="delete"
       class="mx-4 my-2 btn btn-alert"
       data-confirm={dgettext("prompts", "Are you sure you want to delete your account?")}
     >

lib/cannery_web/endpoint.ex

@@ -20,7 +20,7 @@ defmodule CanneryWeb.Endpoint do
     at: "/",
     from: :cannery,
     gzip: false,
-    only: ~w(css fonts images js favicon.ico robots.txt)
+    only: CanneryWeb.static_paths()
 
   # Code reloading can be explicitly enabled under the
   # :code_reloader configuration of your endpoint.

lib/cannery_web/error_helpers.ex

@@ -3,8 +3,8 @@ defmodule CanneryWeb.ErrorHelpers do
   Conveniences for translating and building error messages.
   """
 
-  use Phoenix.HTML
+  use PhoenixHTMLHelpers
-  import Phoenix.Component
+  import Phoenix.{Component, HTML.Form}
   alias Ecto.Changeset
   alias Phoenix.{HTML.Form, LiveView.Rendered}
 
@@ -65,7 +65,7 @@ defmodule CanneryWeb.ErrorHelpers do
     changeset
     |> changeset_error_map()
     |> Enum.map_join(". ", fn {key, errors} ->
-      "#{key |> humanize()}: #{errors |> Enum.join(", ")}"
+      "#{key |> Phoenix.Naming.humanize()}: #{errors |> Enum.join(", ")}"
     end)
   end
 

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:
 
-      import CanneryWeb.Gettext
+      use Gettext, backend: 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, otp_app: :cannery
+  use Gettext.Backend, otp_app: :cannery
 end

lib/cannery_web/html_helpers.ex

@@ -1,8 +1,6 @@
-defmodule CanneryWeb.ViewHelpers do
+defmodule CanneryWeb.HTMLHelpers do
   @moduledoc """
-  Contains common helpers that can be used in liveviews and regular views. These
+  Contains common helpers that are used for rendering
-  are automatically imported into any Phoenix View using `use CanneryWeb,
-  :view`
   """
 
   use Phoenix.Component

lib/cannery_web/live/ammo_group_live/form_component.ex

@@ -1,198 +0,0 @@
-defmodule CanneryWeb.AmmoGroupLive.FormComponent do
-  @moduledoc """
-  Livecomponent that can update or create an Cannery.Ammo.AmmoGroup
-  """
-
-  use CanneryWeb, :live_component
-  alias Cannery.Ammo.{AmmoGroup, AmmoType}
-  alias Cannery.{Accounts.User, Ammo, Containers, Containers.Container}
-  alias Ecto.Changeset
-  alias Phoenix.LiveView.Socket
-
-  @ammo_group_create_limit 10_000
-
-  @impl true
-  @spec update(
-          %{:ammo_group => AmmoGroup.t(), :current_user => User.t(), optional(any) => any},
-          Socket.t()
-        ) :: {:ok, Socket.t()}
-  def update(%{ammo_group: _ammo_group} = assigns, socket) do
-    socket |> assign(assigns) |> update()
-  end
-
-  @spec update(Socket.t()) :: {:ok, Socket.t()}
-  def update(%{assigns: %{current_user: current_user}} = socket) do
-    %{assigns: %{ammo_types: ammo_types, containers: containers}} =
-      socket =
-      socket
-      |> assign(:ammo_group_create_limit, @ammo_group_create_limit)
-      |> assign(:ammo_types, Ammo.list_ammo_types(current_user))
-      |> assign_new(:containers, fn -> Containers.list_containers(current_user) end)
-
-    params =
-      if ammo_types |> List.first() |> is_nil(),
-        do: %{},
-        else: %{} |> Map.put("ammo_type_id", ammo_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", %{"ammo_group" => ammo_group_params}, socket) do
-    {:noreply, socket |> assign_changeset(ammo_group_params, :validate)}
-  end
-
-  def handle_event(
-        "save",
-        %{"ammo_group" => ammo_group_params},
-        %{assigns: %{action: action}} = socket
-      ) do
-    save_ammo_group(socket, action, ammo_group_params)
-  end
-
-  # HTML Helpers
-
-  @spec container_options([Container.t()]) :: [{String.t(), Container.id()}]
-  defp container_options(containers) do
-    containers |> Enum.map(fn %{id: id, name: name} -> {name, id} end)
-  end
-
-  @spec ammo_type_options([AmmoType.t()]) :: [{String.t(), AmmoType.id()}]
-  defp ammo_type_options(ammo_types) do
-    ammo_types |> Enum.map(fn %{id: id, name: name} -> {name, id} end)
-  end
-
-  # Save Helpers
-
-  defp assign_changeset(
-         %{assigns: %{action: action, ammo_group: ammo_group, current_user: user}} = socket,
-         ammo_group_params,
-         changeset_action \\ nil
-       ) do
-    default_action =
-      case action do
-        create when create in [:new, :clone] -> :insert
-        :edit -> :update
-      end
-
-    changeset =
-      case default_action do
-        :insert ->
-          ammo_type = maybe_get_ammo_type(ammo_group_params, user)
-          container = maybe_get_container(ammo_group_params, user)
-          ammo_group |> AmmoGroup.create_changeset(ammo_type, container, user, ammo_group_params)
-
-        :update ->
-          ammo_group |> AmmoGroup.update_changeset(ammo_group_params, user)
-      end
-
-    changeset =
-      case changeset |> Changeset.apply_action(changeset_action || default_action) do
-        {:ok, _data} -> changeset
-        {:error, changeset} -> changeset
-      end
-
-    socket |> assign(:changeset, changeset)
-  end
-
-  defp maybe_get_container(%{"container_id" => container_id}, user)
-       when is_binary(container_id) do
-    container_id |> Containers.get_container!(user)
-  end
-
-  defp maybe_get_container(_params_not_found, _user), do: nil
-
-  defp maybe_get_ammo_type(%{"ammo_type_id" => ammo_type_id}, user)
-       when is_binary(ammo_type_id) do
-    ammo_type_id |> Ammo.get_ammo_type!(user)
-  end
-
-  defp maybe_get_ammo_type(_params_not_found, _user), do: nil
-
-  defp save_ammo_group(
-         %{assigns: %{ammo_group: ammo_group, current_user: current_user, return_to: return_to}} =
-           socket,
-         :edit,
-         ammo_group_params
-       ) do
-    socket =
-      case Ammo.update_ammo_group(ammo_group, ammo_group_params, current_user) do
-        {:ok, _ammo_group} ->
-          prompt = dgettext("prompts", "Ammo updated successfully")
-          socket |> put_flash(:info, prompt) |> push_navigate(to: return_to)
-
-        {:error, %Changeset{} = changeset} ->
-          socket |> assign(:changeset, changeset)
-      end
-
-    {:noreply, socket}
-  end
-
-  defp save_ammo_group(
-         %{assigns: %{changeset: changeset}} = socket,
-         action,
-         %{"multiplier" => multiplier_str} = ammo_group_params
-       )
-       when action in [:new, :clone] do
-    socket =
-      case multiplier_str |> Integer.parse() do
-        {multiplier, _remainder}
-        when multiplier >= 1 and multiplier <= @ammo_group_create_limit ->
-          socket |> create_multiple(ammo_group_params, multiplier)
-
-        {multiplier, _remainder} ->
-          error_msg =
-            dgettext(
-              "errors",
-              "Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}",
-              max: @ammo_group_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,
-         ammo_group_params,
-         multiplier
-       ) do
-    case Ammo.create_ammo_groups(ammo_group_params, multiplier, current_user) do
-      {:ok, {count, _ammo_groups}} ->
-        prompt =
-          dngettext(
-            "prompts",
-            "Ammo added successfully",
-            "Ammo added successfully",
-            count
-          )
-
-        socket |> put_flash(:info, prompt) |> push_navigate(to: return_to)
-
-      {:error, %Changeset{} = changeset} ->
-        socket |> assign(changeset: changeset)
-    end
-  end
-end