cannery/lib/cannery/ammo.ex

450 lines
12 KiB
Elixir
Raw Normal View History

2021-09-02 23:31:14 -04:00
defmodule Cannery.Ammo do
@moduledoc """
The Ammo context.
"""
import Ecto.Query, warn: false
2022-02-16 18:53:24 -05:00
alias Cannery.{Accounts.User, Containers, Repo}
2022-01-31 23:20:57 -05:00
alias Cannery.Ammo.{AmmoGroup, AmmoType}
2022-03-04 23:17:53 -05:00
alias Ecto.Changeset
2022-02-24 00:16:23 -05:00
@ammo_group_create_limit 10_000
2021-09-02 23:31:14 -04:00
@doc """
Returns the list of ammo_types.
## Examples
iex> list_ammo_types(%User{id: 123})
2021-09-02 23:31:14 -04:00
[%AmmoType{}, ...]
"""
@spec list_ammo_types(User.t()) :: [AmmoType.t()]
def list_ammo_types(%User{id: user_id}),
2022-02-15 19:55:48 -05:00
do: Repo.all(from at in AmmoType, where: at.user_id == ^user_id, order_by: at.name)
2021-09-02 23:31:14 -04:00
@doc """
Gets a single ammo_type.
Raises `Ecto.NoResultsError` if the Ammo type does not exist.
## Examples
iex> get_ammo_type!(123, %User{id: 123})
2021-09-02 23:31:14 -04:00
%AmmoType{}
iex> get_ammo_type!(456, %User{id: 123})
2021-09-02 23:31:14 -04:00
** (Ecto.NoResultsError)
"""
@spec get_ammo_type!(AmmoType.id(), User.t()) :: AmmoType.t()
def get_ammo_type!(id, %User{id: user_id}),
do: Repo.one!(from at in AmmoType, where: at.id == ^id and at.user_id == ^user_id)
2021-09-02 23:31:14 -04:00
@doc """
Gets the average cost of a single ammo type
Raises `Ecto.NoResultsError` if the Ammo type does not exist.
## Examples
iex> get_ammo_type!(123, %User{id: 123})
%AmmoType{}
iex> get_ammo_type!(456, %User{id: 123})
** (Ecto.NoResultsError)
"""
@spec get_average_cost_for_ammo_type!(AmmoType.t(), User.t()) :: float()
def get_average_cost_for_ammo_type!(
%AmmoType{id: ammo_type_id, user_id: user_id},
%User{id: user_id}
) do
Repo.one!(
from ag in AmmoGroup,
2022-02-15 21:56:01 -05:00
left_join: sg in assoc(ag, :shot_groups),
where: ag.ammo_type_id == ^ammo_type_id,
where: not (ag.price_paid |> is_nil()),
2022-02-15 21:56:01 -05:00
select: sum(ag.price_paid) / (sum(ag.count) + sum(sg.count))
)
end
@doc """
Gets the total number of rounds for an ammo type
Raises `Ecto.NoResultsError` if the Ammo type does not exist.
## Examples
iex> get_round_count_for_ammo_type(123, %User{id: 123})
%AmmoType{}
iex> get_round_count_for_ammo_type(456, %User{id: 123})
** (Ecto.NoResultsError)
"""
@spec get_round_count_for_ammo_type(AmmoType.t(), User.t()) :: non_neg_integer()
def get_round_count_for_ammo_type(
%AmmoType{id: ammo_type_id, user_id: user_id},
%User{id: user_id}
) do
Repo.one!(
from ag in AmmoGroup,
where: ag.ammo_type_id == ^ammo_type_id,
select: sum(ag.count)
) || 0
end
@doc """
Gets the total number of rounds shot for an ammo type
Raises `Ecto.NoResultsError` if the Ammo type does not exist.
## Examples
iex> get_used_count_for_ammo_type(123, %User{id: 123})
%AmmoType{}
iex> get_used_count_for_ammo_type(456, %User{id: 123})
** (Ecto.NoResultsError)
"""
@spec get_used_count_for_ammo_type(AmmoType.t(), User.t()) :: non_neg_integer()
def get_used_count_for_ammo_type(
%AmmoType{id: ammo_type_id, user_id: user_id},
%User{id: user_id}
) do
Repo.one!(
from ag in AmmoGroup,
left_join: sg in assoc(ag, :shot_groups),
where: ag.ammo_type_id == ^ammo_type_id,
select: sum(sg.count)
) || 0
end
2021-09-02 23:31:14 -04:00
@doc """
Creates a ammo_type.
## Examples
iex> create_ammo_type(%{field: value}, %User{id: 123})
2021-09-02 23:31:14 -04:00
{:ok, %AmmoType{}}
iex> create_ammo_type(%{field: bad_value}, %User{id: 123})
2022-02-01 00:22:44 -05:00
{:error, %Changeset{}}
2021-09-02 23:31:14 -04:00
"""
@spec create_ammo_type(attrs :: map(), User.t()) ::
2022-01-31 23:45:00 -05:00
{:ok, AmmoType.t()} | {:error, Changeset.t(AmmoType.new_ammo_type())}
def create_ammo_type(attrs \\ %{}, %User{id: user_id}) do
%AmmoType{}
|> AmmoType.create_changeset(attrs |> Map.put("user_id", user_id))
|> Repo.insert()
end
2021-09-02 23:31:14 -04:00
@doc """
Updates a ammo_type.
## Examples
iex> update_ammo_type(ammo_type, %{field: new_value}, %User{id: 123})
2021-09-02 23:31:14 -04:00
{:ok, %AmmoType{}}
iex> update_ammo_type(ammo_type, %{field: bad_value}, %User{id: 123})
2022-02-01 00:22:44 -05:00
{:error, %Changeset{}}
2021-09-02 23:31:14 -04:00
"""
@spec update_ammo_type(AmmoType.t(), attrs :: map(), User.t()) ::
2022-01-31 23:45:00 -05:00
{:ok, AmmoType.t()} | {:error, Changeset.t(AmmoType.t())}
def update_ammo_type(%AmmoType{user_id: user_id} = ammo_type, attrs, %User{id: user_id}),
do: ammo_type |> AmmoType.update_changeset(attrs) |> Repo.update()
2021-09-02 23:31:14 -04:00
@doc """
Deletes a ammo_type.
## Examples
iex> delete_ammo_type(ammo_type, %User{id: 123})
2021-09-02 23:31:14 -04:00
{:ok, %AmmoType{}}
iex> delete_ammo_type(ammo_type, %User{id: 123})
2022-02-01 00:22:44 -05:00
{:error, %Changeset{}}
2021-09-02 23:31:14 -04:00
"""
@spec delete_ammo_type(AmmoType.t(), User.t()) ::
2022-01-31 23:45:00 -05:00
{:ok, AmmoType.t()} | {:error, Changeset.t(AmmoType.t())}
def delete_ammo_type(%AmmoType{user_id: user_id} = ammo_type, %User{id: user_id}),
do: ammo_type |> Repo.delete()
2022-01-31 23:20:57 -05:00
@doc """
Deletes a ammo_type.
## Examples
iex> delete_ammo_type(ammo_type, %User{id: 123})
2022-01-31 23:20:57 -05:00
%AmmoType{}
"""
@spec delete_ammo_type!(AmmoType.t(), User.t()) :: AmmoType.t()
def delete_ammo_type!(%AmmoType{user_id: user_id} = ammo_type, %User{id: user_id}),
do: ammo_type |> Repo.delete!()
2021-09-02 23:31:14 -04:00
@doc """
2022-02-01 00:22:44 -05:00
Returns an `%Changeset{}` for tracking ammo_type changes.
2021-09-02 23:31:14 -04:00
## Examples
iex> change_ammo_type(ammo_type)
2022-02-01 00:22:44 -05:00
%Changeset{data: %AmmoType{}}
2021-09-02 23:31:14 -04:00
"""
2022-01-31 23:45:00 -05:00
@spec change_ammo_type(AmmoType.t() | AmmoType.new_ammo_type()) ::
Changeset.t(AmmoType.t() | AmmoType.new_ammo_type())
@spec change_ammo_type(AmmoType.t() | AmmoType.new_ammo_type(), attrs :: map()) ::
Changeset.t(AmmoType.t() | AmmoType.new_ammo_type())
2022-01-31 23:20:57 -05:00
def change_ammo_type(%AmmoType{} = ammo_type, attrs \\ %{}),
do: AmmoType.update_changeset(ammo_type, attrs)
2021-09-02 23:31:14 -04:00
@doc """
2022-02-08 00:21:22 -05:00
Returns the list of ammo_groups for a user and type.
2021-09-02 23:31:14 -04:00
## Examples
2022-02-08 00:21:22 -05:00
iex> list_ammo_groups_for_type(%AmmoType{id: 123}, %User{id: 123})
2022-01-31 23:20:57 -05:00
[%AmmoGroup{}, ...]
2022-02-08 00:21:22 -05:00
"""
@spec list_ammo_groups_for_type(AmmoType.t(), User.t()) :: [AmmoGroup.t()]
def list_ammo_groups_for_type(%AmmoType{id: ammo_type_id, user_id: user_id}, %User{id: user_id}) do
2022-02-08 00:21:22 -05:00
Repo.all(
from ag in AmmoGroup,
left_join: sg in assoc(ag, :shot_groups),
where: ag.ammo_type_id == ^ammo_type_id,
where: ag.user_id == ^user_id,
preload: [shot_groups: sg],
order_by: ag.id
2022-02-08 00:21:22 -05:00
)
end
@doc """
Returns the list of ammo_groups for a user.
## Examples
iex> list_ammo_groups(%User{id: 123})
2021-09-02 23:31:14 -04:00
[%AmmoGroup{}, ...]
"""
2022-02-08 00:21:22 -05:00
@spec list_ammo_groups(User.t()) :: [AmmoGroup.t()]
2022-02-15 17:33:45 -05:00
@spec list_ammo_groups(User.t(), include_empty :: boolean()) :: [AmmoGroup.t()]
def list_ammo_groups(%User{id: user_id}, include_empty \\ false) do
if include_empty do
from ag in AmmoGroup,
left_join: sg in assoc(ag, :shot_groups),
where: ag.user_id == ^user_id,
preload: [shot_groups: sg],
order_by: ag.id
2022-02-15 17:33:45 -05:00
else
from ag in AmmoGroup,
left_join: sg in assoc(ag, :shot_groups),
where: ag.user_id == ^user_id,
where: not (ag.count == 0),
preload: [shot_groups: sg],
order_by: ag.id
2022-02-15 17:33:45 -05:00
end
|> Repo.all()
end
@doc """
Returns the list of staged ammo_groups for a user.
## Examples
iex> list_staged_ammo_groups(%User{id: 123})
[%AmmoGroup{}, ...]
"""
@spec list_staged_ammo_groups(User.t()) :: [AmmoGroup.t()]
def list_staged_ammo_groups(%User{id: user_id}) do
2022-02-15 19:55:48 -05:00
Repo.all(
from ag in AmmoGroup,
left_join: sg in assoc(ag, :shot_groups),
where: ag.user_id == ^user_id,
where: ag.staged == true,
preload: [shot_groups: sg],
order_by: ag.id
2022-02-15 19:55:48 -05:00
)
2021-09-02 23:31:14 -04:00
end
@doc """
Gets a single ammo_group.
Raises `Ecto.NoResultsError` if the Ammo group does not exist.
## Examples
iex> get_ammo_group!(123, %User{id: 123})
2021-09-02 23:31:14 -04:00
%AmmoGroup{}
iex> get_ammo_group!(456, %User{id: 123})
2021-09-02 23:31:14 -04:00
** (Ecto.NoResultsError)
"""
@spec get_ammo_group!(AmmoGroup.id(), User.t()) :: AmmoGroup.t()
def get_ammo_group!(id, %User{id: user_id}) do
Repo.one!(
from ag in AmmoGroup,
left_join: sg in assoc(ag, :shot_groups),
where: ag.id == ^id,
where: ag.user_id == ^user_id,
preload: [shot_groups: sg]
)
end
@doc """
Returns the number of shot rounds for an ammo group
"""
@spec get_used_count(AmmoGroup.t()) :: non_neg_integer()
def get_used_count(%AmmoGroup{} = ammo_group) do
ammo_group
|> Repo.preload(:shot_groups)
2022-03-28 23:05:12 -04:00
|> Map.fetch!(:shot_groups)
|> Enum.map(fn %{count: count} -> count end)
|> Enum.sum()
end
@doc """
Calculates the percentage remaining of an ammo group out of 100
"""
@spec get_percentage_remaining(AmmoGroup.t()) :: non_neg_integer()
def get_percentage_remaining(%AmmoGroup{count: 0}), do: 0
def get_percentage_remaining(%AmmoGroup{count: count} = ammo_group) do
ammo_group = ammo_group |> Repo.preload(:shot_groups)
shot_group_sum =
ammo_group.shot_groups |> Enum.map(fn %{count: count} -> count end) |> Enum.sum()
round(count / (count + shot_group_sum) * 100)
end
2021-09-02 23:31:14 -04:00
@doc """
2022-02-24 00:16:23 -05:00
Creates multiple ammo_groups at once.
2021-09-02 23:31:14 -04:00
## Examples
2022-02-24 00:16:23 -05:00
iex> create_ammo_groups(%{field: value}, 3, %User{id: 123})
{:ok, {3, [%AmmoGroup{}]}}
2021-09-02 23:31:14 -04:00
2022-02-24 00:16:23 -05:00
iex> create_ammo_groups(%{field: bad_value}, 3, %User{id: 123})
2022-02-01 00:22:44 -05:00
{:error, %Changeset{}}
2021-09-02 23:31:14 -04:00
"""
2022-02-24 00:16:23 -05:00
@spec create_ammo_groups(attrs :: map(), multiplier :: non_neg_integer(), User.t()) ::
{:ok, {count :: non_neg_integer(), [AmmoGroup.t()] | nil}}
2022-03-04 23:16:37 -05:00
| {:error, Changeset.t(AmmoGroup.new_ammo_group())}
2022-02-24 00:16:23 -05:00
def create_ammo_groups(
2022-02-16 18:53:24 -05:00
%{"ammo_type_id" => ammo_type_id, "container_id" => container_id} = attrs,
2022-02-24 00:16:23 -05:00
multiplier,
2022-02-16 18:53:24 -05:00
%User{id: user_id} = user
2022-02-24 00:16:23 -05:00
)
when multiplier >= 1 and multiplier <= @ammo_group_create_limit do
2022-02-16 18:53:24 -05:00
# validate ammo type and container ids belong to user
_valid_ammo_type = get_ammo_type!(ammo_type_id, user)
_valid_container = Containers.get_container!(container_id, user)
2022-02-24 00:16:23 -05:00
now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
changesets =
Enum.map(1..multiplier, fn _count ->
%AmmoGroup{} |> AmmoGroup.create_changeset(attrs |> Map.put("user_id", user_id))
end)
if changesets |> Enum.all?(fn %{valid?: valid} -> valid end) do
2022-03-04 23:16:37 -05:00
{count, inserted_ammo_groups} =
Repo.insert_all(
AmmoGroup,
changesets
|> Enum.map(fn changeset ->
changeset
|> Map.get(:changes)
|> Map.merge(%{inserted_at: now, updated_at: now})
end),
returning: true
)
{:ok, {count, inserted_ammo_groups}}
2022-02-24 00:16:23 -05:00
else
2022-03-04 23:16:37 -05:00
changesets
|> Enum.reject(fn %{valid?: valid} -> valid end)
|> List.first()
|> Changeset.apply_action(:insert)
2022-02-24 00:16:23 -05:00
end
end
2021-09-02 23:31:14 -04:00
2022-02-24 00:16:23 -05:00
def create_ammo_groups(invalid_attrs, _multiplier, _user) do
{:error, %AmmoGroup{} |> AmmoGroup.create_changeset(invalid_attrs)}
end
2021-09-02 23:31:14 -04:00
@doc """
Updates a ammo_group.
## Examples
iex> update_ammo_group(ammo_group, %{field: new_value}, %User{id: 123})
2021-09-02 23:31:14 -04:00
{:ok, %AmmoGroup{}}
iex> update_ammo_group(ammo_group, %{field: bad_value}, %User{id: 123})
2022-02-01 00:22:44 -05:00
{:error, %Changeset{}}
2021-09-02 23:31:14 -04:00
"""
@spec update_ammo_group(AmmoGroup.t(), attrs :: map(), User.t()) ::
2022-01-31 23:45:00 -05:00
{:ok, AmmoGroup.t()} | {:error, Changeset.t(AmmoGroup.t())}
def update_ammo_group(%AmmoGroup{user_id: user_id} = ammo_group, attrs, %User{id: user_id}),
do: ammo_group |> AmmoGroup.update_changeset(attrs) |> Repo.update()
2021-09-02 23:31:14 -04:00
@doc """
Deletes a ammo_group.
## Examples
iex> delete_ammo_group(ammo_group, %User{id: 123})
2021-09-02 23:31:14 -04:00
{:ok, %AmmoGroup{}}
iex> delete_ammo_group(ammo_group, %User{id: 123})
2022-02-01 00:22:44 -05:00
{:error, %Changeset{}}
2021-09-02 23:31:14 -04:00
"""
@spec delete_ammo_group(AmmoGroup.t(), User.t()) ::
2022-01-31 23:45:00 -05:00
{:ok, AmmoGroup.t()} | {:error, Changeset.t(AmmoGroup.t())}
def delete_ammo_group(%AmmoGroup{user_id: user_id} = ammo_group, %User{id: user_id}),
do: ammo_group |> Repo.delete()
2022-01-31 23:20:57 -05:00
@doc """
Deletes a ammo_group.
## Examples
iex> delete_ammo_group!(ammo_group, %User{id: 123})
2022-01-31 23:20:57 -05:00
%AmmoGroup{}
"""
@spec delete_ammo_group!(AmmoGroup.t(), User.t()) :: AmmoGroup.t()
def delete_ammo_group!(%AmmoGroup{user_id: user_id} = ammo_group, %User{id: user_id}),
do: ammo_group |> Repo.delete!()
2021-09-02 23:31:14 -04:00
@doc """
2022-02-01 00:22:44 -05:00
Returns an `%Changeset{}` for tracking ammo_group changes.
2021-09-02 23:31:14 -04:00
## Examples
iex> change_ammo_group(ammo_group)
2022-02-01 00:22:44 -05:00
%Changeset{data: %AmmoGroup{}}
2021-09-02 23:31:14 -04:00
"""
2022-01-31 23:20:57 -05:00
@spec change_ammo_group(AmmoGroup.t()) :: Changeset.t(AmmoGroup.t())
@spec change_ammo_group(AmmoGroup.t(), attrs :: map()) :: Changeset.t(AmmoGroup.t())
def change_ammo_group(%AmmoGroup{} = ammo_group, attrs \\ %{}),
do: AmmoGroup.update_changeset(ammo_group, attrs)
2021-09-02 23:31:14 -04:00
end