forked from shibao/cannery
1055 lines
29 KiB
Elixir
1055 lines
29 KiB
Elixir
defmodule Cannery.Ammo do
|
|
@moduledoc """
|
|
The Ammo context.
|
|
"""
|
|
|
|
import CanneryWeb.Gettext
|
|
import Ecto.Query, warn: false
|
|
alias Cannery.{Accounts.User, Containers, Repo}
|
|
alias Cannery.Containers.{Container, ContainerTag, Tag}
|
|
alias Cannery.{ActivityLog, ActivityLog.ShotRecord}
|
|
alias Cannery.Ammo.{Pack, Type}
|
|
alias Ecto.{Changeset, Queryable}
|
|
|
|
@pack_create_limit 10_000
|
|
@pack_preloads [:type]
|
|
@type_preloads [:packs]
|
|
|
|
@type list_types_option :: {:search, String.t() | nil} | {:class, Type.class() | :all}
|
|
@type list_types_options :: [list_types_option()]
|
|
|
|
@doc """
|
|
Returns the list of types.
|
|
|
|
## Examples
|
|
|
|
iex> list_types(%User{id: 123})
|
|
[%Type{}, ...]
|
|
|
|
iex> list_types(%User{id: 123}, search: "cool", class: :shotgun)
|
|
[%Type{name: "My cool type", class: :shotgun}, ...]
|
|
|
|
"""
|
|
@spec list_types(User.t()) :: [Type.t()]
|
|
@spec list_types(User.t(), list_types_options()) :: [Type.t()]
|
|
def list_types(%User{id: user_id}, opts \\ []) do
|
|
from(t in Type,
|
|
as: :t,
|
|
where: t.user_id == ^user_id,
|
|
preload: ^@type_preloads
|
|
)
|
|
|> list_types_class(Keyword.get(opts, :class, :all))
|
|
|> list_types_search(Keyword.get(opts, :search))
|
|
|> Repo.all()
|
|
end
|
|
|
|
@spec list_types_search(Queryable.t(), search :: String.t() | nil) :: Queryable.t()
|
|
defp list_types_search(query, search) when search in ["", nil],
|
|
do: query |> order_by([t: t], t.name)
|
|
|
|
defp list_types_search(query, search) when search |> is_binary() do
|
|
trimmed_search = String.trim(search)
|
|
|
|
query
|
|
|> where(
|
|
[t: t],
|
|
fragment(
|
|
"? @@ websearch_to_tsquery('english', ?)",
|
|
t.search,
|
|
^trimmed_search
|
|
)
|
|
)
|
|
|> order_by(
|
|
[t: t],
|
|
{
|
|
:desc,
|
|
fragment(
|
|
"ts_rank_cd(?, websearch_to_tsquery('english', ?), 4)",
|
|
t.search,
|
|
^trimmed_search
|
|
)
|
|
}
|
|
)
|
|
end
|
|
|
|
@spec list_types_class(Queryable.t(), Type.class() | :all) :: Queryable.t()
|
|
defp list_types_class(query, class) when class in [:rifle, :pistol, :shotgun],
|
|
do: query |> where([t: t], t.class == ^class)
|
|
|
|
defp list_types_class(query, _all), do: query
|
|
|
|
@doc """
|
|
Returns a count of types.
|
|
|
|
## Examples
|
|
|
|
iex> get_types_count!(%User{id: 123})
|
|
3
|
|
|
|
"""
|
|
@spec get_types_count!(User.t()) :: integer()
|
|
def get_types_count!(%User{id: user_id}) do
|
|
Repo.one(
|
|
from t in Type,
|
|
where: t.user_id == ^user_id,
|
|
select: count(t.id),
|
|
distinct: true
|
|
) || 0
|
|
end
|
|
|
|
@doc """
|
|
Gets a single type.
|
|
|
|
Raises `Ecto.NoResultsError` if the type does not exist.
|
|
|
|
## Examples
|
|
|
|
iex> get_type!(123, %User{id: 123})
|
|
%Type{}
|
|
|
|
iex> get_type!(456, %User{id: 123})
|
|
** (Ecto.NoResultsError)
|
|
|
|
"""
|
|
@spec get_type!(Type.id(), User.t()) :: Type.t()
|
|
def get_type!(id, %User{id: user_id}) do
|
|
Repo.one!(
|
|
from t in Type,
|
|
where: t.id == ^id,
|
|
where: t.user_id == ^user_id,
|
|
preload: ^@type_preloads
|
|
)
|
|
end
|
|
|
|
@doc """
|
|
Gets the average cost of a type from packs with price information.
|
|
|
|
## Examples
|
|
|
|
iex> get_average_cost(
|
|
...> %Type{id: 123, user_id: 456},
|
|
...> %User{id: 456}
|
|
...> )
|
|
1.50
|
|
|
|
"""
|
|
@spec get_average_cost(Type.t(), User.t()) :: float() | nil
|
|
def get_average_cost(%Type{id: type_id} = type, user) do
|
|
[type]
|
|
|> get_average_costs(user)
|
|
|> Map.get(type_id)
|
|
end
|
|
|
|
@doc """
|
|
Gets the average cost of types from packs with price information
|
|
for multiple types.
|
|
|
|
## Examples
|
|
|
|
iex> get_average_costs(
|
|
...> [%Type{id: 123, user_id: 456}],
|
|
...> %User{id: 456}
|
|
...> )
|
|
1.50
|
|
|
|
"""
|
|
@spec get_average_costs([Type.t()], User.t()) ::
|
|
%{optional(Type.id()) => float()}
|
|
def get_average_costs(types, %User{id: user_id}) do
|
|
type_ids =
|
|
types
|
|
|> Enum.map(fn %Type{id: type_id, user_id: ^user_id} -> type_id end)
|
|
|
|
sg_total_query =
|
|
from sr in ShotRecord,
|
|
where: not (sr.count |> is_nil()),
|
|
group_by: sr.pack_id,
|
|
select: %{pack_id: sr.pack_id, total: sum(sr.count)}
|
|
|
|
Repo.all(
|
|
from p in Pack,
|
|
as: :pack,
|
|
left_join: sg_query in subquery(sg_total_query),
|
|
on: p.id == sg_query.pack_id,
|
|
where: p.type_id in ^type_ids,
|
|
group_by: p.type_id,
|
|
where: not (p.price_paid |> is_nil()),
|
|
select: {p.type_id, sum(p.price_paid) / sum(p.count + coalesce(sg_query.total, 0))}
|
|
)
|
|
|> Map.new()
|
|
end
|
|
|
|
@type get_round_count_option :: {:type_id, Type.id() | nil} | {:container_id, Container.id()}
|
|
@type get_round_count_options :: [get_round_count_option()]
|
|
|
|
@doc """
|
|
Gets the total number of rounds for a type
|
|
|
|
## Examples
|
|
|
|
iex> get_round_count(%User{id: 456}, type_id: 123)
|
|
35
|
|
|
|
iex> get_round_count(%User{id: 456}, container_id: 123)
|
|
25
|
|
|
|
"""
|
|
@spec get_round_count(User.t()) :: non_neg_integer()
|
|
@spec get_round_count(User.t(), get_round_count_options()) :: non_neg_integer()
|
|
def get_round_count(%User{id: user_id}, opts \\ []) do
|
|
from(p in Pack,
|
|
as: :p,
|
|
where: p.user_id == ^user_id,
|
|
select: sum(p.count),
|
|
distinct: true
|
|
)
|
|
|> get_round_count_type_id(Keyword.get(opts, :type_id))
|
|
|> get_round_count_container_id(Keyword.get(opts, :container_id))
|
|
|> Repo.one() || 0
|
|
end
|
|
|
|
@spec get_round_count_type_id(Queryable.t(), Type.id() | nil) :: Queryable.t()
|
|
defp get_round_count_type_id(query, type_id) when type_id |> is_binary() do
|
|
query |> where([p: p], p.type_id == ^type_id)
|
|
end
|
|
|
|
defp get_round_count_type_id(query, _nil), do: query
|
|
|
|
@spec get_round_count_container_id(Queryable.t(), Container.id() | nil) :: Queryable.t()
|
|
defp get_round_count_container_id(query, container_id) when container_id |> is_binary() do
|
|
query |> where([p: p], p.container_id == ^container_id)
|
|
end
|
|
|
|
defp get_round_count_container_id(query, _nil), do: query
|
|
|
|
@type get_grouped_round_count_option ::
|
|
{:types, [Type.t()] | nil}
|
|
| {:containers, [Container.t()] | nil}
|
|
| {:group_by, atom()}
|
|
@type get_grouped_round_count_options :: [get_grouped_round_count_option()]
|
|
|
|
@doc """
|
|
Gets the total number of rounds for multiple types
|
|
|
|
## Examples
|
|
|
|
iex> get_grouped_round_count(
|
|
...> %User{id: 456},
|
|
...> group_by: :type_id,
|
|
...> types: [%Type{id: 123, user_id: 456}]
|
|
...> )
|
|
%{123 => 35}
|
|
|
|
"""
|
|
@spec get_grouped_round_count(User.t(), get_grouped_round_count_options()) ::
|
|
%{optional(Type.id() | Container.id()) => non_neg_integer()}
|
|
def get_grouped_round_count(%User{id: user_id}, opts) do
|
|
from(p in Pack,
|
|
as: :p,
|
|
where: p.user_id == ^user_id
|
|
)
|
|
|> get_grouped_round_count_filter_ids(
|
|
Keyword.fetch!(opts, :group_by),
|
|
Keyword.get(opts, :types)
|
|
)
|
|
|> get_grouped_round_count_filter_ids(
|
|
Keyword.fetch!(opts, :group_by),
|
|
Keyword.get(opts, :containers)
|
|
)
|
|
|> get_grouped_round_count_group_by(Keyword.fetch!(opts, :group_by))
|
|
|> Repo.all()
|
|
|> Map.new()
|
|
end
|
|
|
|
@spec get_grouped_round_count_group_by(Queryable.t(), atom()) :: Queryable.t()
|
|
defp get_grouped_round_count_group_by(query, group_key) when group_key |> is_atom() do
|
|
query
|
|
|> group_by([p: p], field(p, ^group_key))
|
|
|> select([p: p], {field(p, ^group_key), sum(p.count)})
|
|
end
|
|
|
|
@spec get_grouped_round_count_filter_ids(
|
|
Queryable.t(),
|
|
atom(),
|
|
[Type.t()] | [Container.t()] | nil
|
|
) :: Queryable.t()
|
|
defp get_grouped_round_count_filter_ids(query, group_key, items) when items |> is_list() do
|
|
item_ids = items |> Enum.map(fn %{id: id} -> id end)
|
|
query |> where([p: p], field(p, ^group_key) in ^item_ids)
|
|
end
|
|
|
|
defp get_grouped_round_count_filter_ids(query, _group_key, _nil), do: query
|
|
|
|
@doc """
|
|
Gets the total number of ammo ever bought for a type
|
|
|
|
## Examples
|
|
|
|
iex> get_historical_count(
|
|
...> %Type{id: 123, user_id: 456},
|
|
...> %User{id: 456}
|
|
...> )
|
|
5
|
|
|
|
"""
|
|
@spec get_historical_count(Type.t(), User.t()) :: non_neg_integer()
|
|
def get_historical_count(%Type{id: type_id} = type, user) do
|
|
[type]
|
|
|> get_historical_counts(user)
|
|
|> Map.get(type_id, 0)
|
|
end
|
|
|
|
@doc """
|
|
Gets the total number of ammo ever bought for multiple types
|
|
|
|
## Examples
|
|
|
|
iex> get_historical_counts(
|
|
...> [%Type{id: 123, user_id: 456}],
|
|
...> %User{id: 456}
|
|
...> )
|
|
%{123 => 5}
|
|
|
|
"""
|
|
@spec get_historical_counts([Type.t()], User.t()) ::
|
|
%{optional(Type.id()) => non_neg_integer()}
|
|
def get_historical_counts(types, %User{id: user_id} = user) do
|
|
used_counts = ActivityLog.get_grouped_used_counts(user, types: types, group_by: :type_id)
|
|
round_counts = get_grouped_round_count(user, types: types, group_by: :type_id)
|
|
|
|
types
|
|
|> Enum.filter(fn %Type{id: type_id, user_id: ^user_id} ->
|
|
Map.has_key?(used_counts, type_id) or Map.has_key?(round_counts, type_id)
|
|
end)
|
|
|> Map.new(fn %{id: type_id} ->
|
|
historical_count = Map.get(used_counts, type_id, 0) + Map.get(round_counts, type_id, 0)
|
|
|
|
{type_id, historical_count}
|
|
end)
|
|
end
|
|
|
|
@doc """
|
|
Creates a type.
|
|
|
|
## Examples
|
|
|
|
iex> create_type(%{field: value}, %User{id: 123})
|
|
{:ok, %Type{}}
|
|
|
|
iex> create_type(%{field: bad_value}, %User{id: 123})
|
|
{:error, %Changeset{}}
|
|
|
|
"""
|
|
@spec create_type(attrs :: map(), User.t()) ::
|
|
{:ok, Type.t()} | {:error, Type.changeset()}
|
|
def create_type(attrs \\ %{}, %User{} = user) do
|
|
%Type{}
|
|
|> Type.create_changeset(user, attrs)
|
|
|> Repo.insert()
|
|
|> case do
|
|
{:ok, type} -> {:ok, type |> preload_type()}
|
|
{:error, changeset} -> {:error, changeset}
|
|
end
|
|
end
|
|
|
|
@spec preload_type(Type.t()) :: Type.t()
|
|
@spec preload_type([Type.t()]) :: [Type.t()]
|
|
defp preload_type(type_or_types) do
|
|
type_or_types |> Repo.preload(@type_preloads)
|
|
end
|
|
|
|
@doc """
|
|
Updates a type.
|
|
|
|
## Examples
|
|
|
|
iex> update_type(type, %{field: new_value}, %User{id: 123})
|
|
{:ok, %Type{}}
|
|
|
|
iex> update_type(type, %{field: bad_value}, %User{id: 123})
|
|
{:error, %Changeset{}}
|
|
|
|
"""
|
|
@spec update_type(Type.t(), attrs :: map(), User.t()) ::
|
|
{:ok, Type.t()} | {:error, Type.changeset()}
|
|
def update_type(%Type{user_id: user_id} = type, attrs, %User{id: user_id}) do
|
|
type
|
|
|> Type.update_changeset(attrs)
|
|
|> Repo.update()
|
|
|> case do
|
|
{:ok, type} -> {:ok, type |> preload_type()}
|
|
{:error, changeset} -> {:error, changeset}
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Deletes a type.
|
|
|
|
## Examples
|
|
|
|
iex> delete_type(type, %User{id: 123})
|
|
{:ok, %Type{}}
|
|
|
|
iex> delete_type(type, %User{id: 123})
|
|
{:error, %Changeset{}}
|
|
|
|
"""
|
|
@spec delete_type(Type.t(), User.t()) ::
|
|
{:ok, Type.t()} | {:error, Type.changeset()}
|
|
def delete_type(%Type{user_id: user_id} = type, %User{id: user_id}) do
|
|
type
|
|
|> Repo.delete()
|
|
|> case do
|
|
{:ok, type} -> {:ok, type |> preload_type()}
|
|
{:error, changeset} -> {:error, changeset}
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Deletes a type.
|
|
|
|
## Examples
|
|
|
|
iex> delete_type!(type, %User{id: 123})
|
|
%Type{}
|
|
|
|
"""
|
|
@spec delete_type!(Type.t(), User.t()) :: Type.t()
|
|
def delete_type!(type, user) do
|
|
{:ok, type} = delete_type(type, user)
|
|
type
|
|
end
|
|
|
|
# Packs
|
|
|
|
@type list_packs_option ::
|
|
{:type_id, Type.id()}
|
|
| {:container_id, Container.id()}
|
|
| {:class, Type.class() | :all}
|
|
| {:show_used, boolean() | nil}
|
|
| {:search, String.t() | nil}
|
|
| {:staged, boolean() | nil}
|
|
@type list_packs_options :: [list_packs_option()]
|
|
|
|
@doc """
|
|
Returns the list of packs for a user and type.
|
|
|
|
## Examples
|
|
|
|
iex> list_packs(%User{id: 456})
|
|
[%Pack{}, ...]
|
|
|
|
iex> list_packs(
|
|
...> %User{id: 456},
|
|
...> show_used: true,
|
|
...> type_id: 123,
|
|
...> container_id: 789,
|
|
...> search: "something",
|
|
...> staged: true
|
|
...> )
|
|
[%Pack{}, %Pack{}, ...]
|
|
|
|
"""
|
|
@spec list_packs(User.t()) :: [Pack.t()]
|
|
@spec list_packs(User.t(), list_packs_options()) :: [Pack.t()]
|
|
def list_packs(%User{id: user_id}, opts \\ []) do
|
|
from(p in Pack,
|
|
as: :p,
|
|
join: t in assoc(p, :type),
|
|
on: p.user_id == t.user_id,
|
|
as: :t,
|
|
join: c in Container,
|
|
on: p.container_id == c.id,
|
|
on: p.user_id == c.user_id,
|
|
as: :c,
|
|
where: p.user_id == c.user_id,
|
|
left_join: ct in ContainerTag,
|
|
on: c.id == ct.container_id,
|
|
left_join: tag in Tag,
|
|
on: ct.tag_id == tag.id,
|
|
on: p.user_id == tag.user_id,
|
|
as: :tag,
|
|
where: p.user_id == ^user_id,
|
|
distinct: p.id,
|
|
preload: ^@pack_preloads
|
|
)
|
|
|> list_packs_search(Keyword.get(opts, :search))
|
|
|> list_packs_class(Keyword.get(opts, :class, :all))
|
|
|> list_packs_show_used(Keyword.get(opts, :show_used))
|
|
|> list_packs_staged(Keyword.get(opts, :staged))
|
|
|> list_packs_container_id(Keyword.get(opts, :container_id))
|
|
|> list_packs_type_id(Keyword.get(opts, :type_id))
|
|
|> Repo.all()
|
|
end
|
|
|
|
@spec list_packs_search(Queryable.t(), search :: String.t() | nil) :: Queryable.t()
|
|
defp list_packs_search(query, search) when search in ["", nil], do: query
|
|
|
|
defp list_packs_search(query, search) when search |> is_binary() do
|
|
trimmed_search = String.trim(search)
|
|
|
|
query
|
|
|> where(
|
|
[p: p, t: t, c: c, tag: tag],
|
|
fragment(
|
|
"? @@ websearch_to_tsquery('english', ?)",
|
|
p.search,
|
|
^trimmed_search
|
|
) or
|
|
fragment(
|
|
"? @@ websearch_to_tsquery('english', ?)",
|
|
t.search,
|
|
^trimmed_search
|
|
) or
|
|
fragment(
|
|
"? @@ websearch_to_tsquery('english', ?)",
|
|
c.search,
|
|
^trimmed_search
|
|
) or
|
|
fragment(
|
|
"? @@ websearch_to_tsquery('english', ?)",
|
|
tag.search,
|
|
^trimmed_search
|
|
)
|
|
)
|
|
|> order_by(
|
|
[p: p],
|
|
desc:
|
|
fragment(
|
|
"ts_rank_cd(?, websearch_to_tsquery('english', ?), 4)",
|
|
p.search,
|
|
^trimmed_search
|
|
)
|
|
)
|
|
end
|
|
|
|
@spec list_packs_class(Queryable.t(), Type.class() | :all) :: Queryable.t()
|
|
defp list_packs_class(query, class) when class in [:rifle, :pistol, :shotgun],
|
|
do: query |> where([t: t], t.class == ^class)
|
|
|
|
defp list_packs_class(query, _all), do: query
|
|
|
|
@spec list_packs_show_used(Queryable.t(), show_used :: boolean() | nil) :: Queryable.t()
|
|
defp list_packs_show_used(query, true), do: query
|
|
|
|
defp list_packs_show_used(query, _false),
|
|
do: query |> where([p: p], not (p.count == 0))
|
|
|
|
@spec list_packs_container_id(Queryable.t(), Container.id() | nil) :: Queryable.t()
|
|
defp list_packs_container_id(query, container_id) when container_id |> is_binary(),
|
|
do: query |> where([p: p], p.container_id == ^container_id)
|
|
|
|
defp list_packs_container_id(query, _nil), do: query
|
|
|
|
@spec list_packs_type_id(Queryable.t(), Type.id() | nil) :: Queryable.t()
|
|
defp list_packs_type_id(query, type_id) when type_id |> is_binary(),
|
|
do: query |> where([p: p], p.type_id == ^type_id)
|
|
|
|
defp list_packs_type_id(query, _nil), do: query
|
|
|
|
@spec list_packs_staged(Queryable.t(), staged :: boolean() | nil) :: Queryable.t()
|
|
defp list_packs_staged(query, staged) when staged |> is_boolean(),
|
|
do: query |> where([p: p], p.staged == ^staged)
|
|
|
|
defp list_packs_staged(query, _nil), do: query
|
|
|
|
@type get_packs_count_option ::
|
|
{:container_id, Container.id() | nil}
|
|
| {:type_id, Type.id() | nil}
|
|
| {:show_used, :only_used | boolean() | nil}
|
|
@type get_packs_count_options :: [get_packs_count_option()]
|
|
|
|
@doc """
|
|
Returns a count of packs.
|
|
|
|
## Examples
|
|
|
|
iex> get_packs_count(%User{id: 123})
|
|
3
|
|
|
|
iex> get_packs_count(%User{id: 123}, show_used: true)
|
|
4
|
|
|
|
iex> get_packs_count(%User{id: 123}, container_id: 456)
|
|
1
|
|
|
|
iex> get_packs_count(%User{id: 123}, type_id: 456)
|
|
2
|
|
|
|
"""
|
|
@spec get_packs_count(User.t()) :: integer()
|
|
@spec get_packs_count(User.t(), get_packs_count_options()) :: integer()
|
|
def get_packs_count(%User{id: user_id}, opts \\ []) do
|
|
from(p in Pack,
|
|
as: :p,
|
|
where: p.user_id == ^user_id,
|
|
select: count(p.id),
|
|
distinct: true
|
|
)
|
|
|> get_packs_count_show_used(Keyword.get(opts, :show_used))
|
|
|> get_packs_count_container_id(Keyword.get(opts, :container_id))
|
|
|> get_packs_count_type_id(Keyword.get(opts, :type_id))
|
|
|> Repo.one() || 0
|
|
end
|
|
|
|
@spec get_packs_count_show_used(Queryable.t(), show_used :: :only_used | boolean() | nil) ::
|
|
Queryable.t()
|
|
defp get_packs_count_show_used(query, true), do: query
|
|
|
|
defp get_packs_count_show_used(query, :only_used),
|
|
do: query |> where([p: p], p.count == 0)
|
|
|
|
defp get_packs_count_show_used(query, _false),
|
|
do: query |> where([p: p], p.count > 0)
|
|
|
|
@spec get_packs_count_type_id(Queryable.t(), Type.id() | nil) :: Queryable.t()
|
|
defp get_packs_count_type_id(query, type_id) when type_id |> is_binary(),
|
|
do: query |> where([p: p], p.type_id == ^type_id)
|
|
|
|
defp get_packs_count_type_id(query, _nil), do: query
|
|
|
|
@spec get_packs_count_container_id(Queryable.t(), Container.id() | nil) :: Queryable.t()
|
|
defp get_packs_count_container_id(query, container_id) when container_id |> is_binary(),
|
|
do: query |> where([p: p], p.container_id == ^container_id)
|
|
|
|
defp get_packs_count_container_id(query, _nil), do: query
|
|
|
|
@type get_grouped_packs_count_opt ::
|
|
{:group_by, atom()}
|
|
| {:containers, [Container.t()] | nil}
|
|
| {:types, [Type.t()] | nil}
|
|
| {:show_used, :only_used | boolean() | nil}
|
|
@type get_grouped_packs_counts_opts :: [get_grouped_packs_count_opt()]
|
|
|
|
@doc """
|
|
Returns the count of packs for multiple types.
|
|
|
|
## Examples
|
|
|
|
iex> get_grouped_packs_count(
|
|
...> %User{id: 456},
|
|
...> group_by: :type_id,
|
|
...> types: [%Type{id: 123, user_id: 456}]
|
|
...> )
|
|
3
|
|
|
|
iex> get_grouped_packs_count(
|
|
...> %User{id: 456},
|
|
...> group_by: :type_id,
|
|
...> types: [%Type{id: 123, user_id: 456}],
|
|
...> show_used: true
|
|
...> )
|
|
5
|
|
|
|
iex> get_grouped_packs_count(
|
|
...> %User{id: 456},
|
|
...> group_by: :type_id,
|
|
...> types: [%Type{id: 123, user_id: 456}],
|
|
...> show_used: :only_used
|
|
...> )
|
|
2
|
|
|
|
iex> get_grouped_packs_count(
|
|
...> %User{id: 456},
|
|
...> group_by: :container_id,
|
|
...> containers: [%Container{id: 123, user_id: 456}]
|
|
...> )
|
|
7
|
|
|
|
"""
|
|
@spec get_grouped_packs_count(User.t(), get_grouped_packs_counts_opts()) ::
|
|
%{optional(Type.id() | Container.id()) => non_neg_integer()}
|
|
def get_grouped_packs_count(%User{id: user_id}, opts) do
|
|
from(p in Pack,
|
|
as: :p,
|
|
where: p.user_id == ^user_id
|
|
)
|
|
|> get_grouped_packs_count_group_by(Keyword.fetch!(opts, :group_by))
|
|
|> get_grouped_packs_count_filter_ids(
|
|
Keyword.fetch!(opts, :group_by),
|
|
Keyword.get(opts, :types)
|
|
)
|
|
|> get_grouped_packs_count_filter_ids(
|
|
Keyword.fetch!(opts, :group_by),
|
|
Keyword.get(opts, :containers)
|
|
)
|
|
|> get_grouped_packs_count_show_used(Keyword.get(opts, :show_used))
|
|
|> Repo.all()
|
|
|> Map.new()
|
|
end
|
|
|
|
@spec get_grouped_packs_count_group_by(Queryable.t(), :type_id | :container_id) :: Queryable.t()
|
|
defp get_grouped_packs_count_group_by(query, group_key) when group_key |> is_atom() do
|
|
query
|
|
|> group_by([p: p], field(p, ^group_key))
|
|
|> select([p: p], {field(p, ^group_key), count(p.id)})
|
|
end
|
|
|
|
@spec get_grouped_packs_count_filter_ids(
|
|
Queryable.t(),
|
|
:type_id | :container_id,
|
|
[Type.t()] | [Container.t()] | nil
|
|
) :: Queryable.t()
|
|
defp get_grouped_packs_count_filter_ids(query, group_key, items) when items |> is_list() do
|
|
item_ids = items |> Enum.map(fn %{id: id} -> id end)
|
|
query |> where([p: p], field(p, ^group_key) in ^item_ids)
|
|
end
|
|
|
|
defp get_grouped_packs_count_filter_ids(query, _filter_key, _nil), do: query
|
|
|
|
@spec get_grouped_packs_count_show_used(
|
|
Queryable.t(),
|
|
show_used :: :only_used | boolean() | nil
|
|
) :: Queryable.t()
|
|
defp get_grouped_packs_count_show_used(query, true), do: query
|
|
|
|
defp get_grouped_packs_count_show_used(query, :only_used) do
|
|
query |> where([p: p], p.count == 0)
|
|
end
|
|
|
|
defp get_grouped_packs_count_show_used(query, _false) do
|
|
query |> where([p: p], not (p.count == 0))
|
|
end
|
|
|
|
@doc """
|
|
Gets a single pack.
|
|
|
|
Raises `KeyError` if the pack does not exist.
|
|
|
|
## Examples
|
|
|
|
iex> get_pack!(123, %User{id: 123})
|
|
%Pack{}
|
|
|
|
iex> get_pack!(456, %User{id: 123})
|
|
** (KeyError)
|
|
|
|
"""
|
|
@spec get_pack!(Pack.id(), User.t()) :: Pack.t()
|
|
def get_pack!(id, user) do
|
|
[id] |> get_packs(user) |> Map.fetch!(id)
|
|
end
|
|
|
|
@doc """
|
|
Gets a group of packs by their ID.
|
|
|
|
## Examples
|
|
|
|
iex> get_packs([123, 456], %User{id: 123})
|
|
%{123 => %Pack{}, 456 => %Pack{}}
|
|
|
|
"""
|
|
@spec get_packs([Pack.id()], User.t()) ::
|
|
%{optional(Pack.id()) => Pack.t()}
|
|
def get_packs(ids, %User{id: user_id}) do
|
|
Repo.all(
|
|
from p in Pack,
|
|
where: p.id in ^ids,
|
|
where: p.user_id == ^user_id,
|
|
preload: ^@pack_preloads,
|
|
select: {p.id, p}
|
|
)
|
|
|> Map.new()
|
|
end
|
|
|
|
@doc """
|
|
Calculates the percentage remaining of a pack out of 100
|
|
|
|
## Examples
|
|
|
|
iex> get_percentage_remaining(
|
|
...> %Pack{id: 123, count: 5, user_id: 456},
|
|
...> %User{id: 456}
|
|
...> )
|
|
100
|
|
|
|
"""
|
|
@spec get_percentage_remaining(Pack.t(), User.t()) :: non_neg_integer()
|
|
def get_percentage_remaining(%Pack{id: pack_id} = pack, user) do
|
|
[pack]
|
|
|> get_percentages_remaining(user)
|
|
|> Map.fetch!(pack_id)
|
|
end
|
|
|
|
@doc """
|
|
Calculates the percentages remaining of multiple packs out of 100
|
|
|
|
## Examples
|
|
|
|
iex> get_percentages_remaining(
|
|
...> [%Pack{id: 123, count: 5, user_id: 456}],
|
|
...> %User{id: 456}
|
|
...> )
|
|
%{123 => 100}
|
|
|
|
"""
|
|
@spec get_percentages_remaining([Pack.t()], User.t()) ::
|
|
%{optional(Pack.id()) => non_neg_integer()}
|
|
def get_percentages_remaining(packs, %User{id: user_id} = user) do
|
|
original_counts = get_original_counts(packs, user)
|
|
|
|
packs
|
|
|> Map.new(fn %Pack{id: pack_id, count: count, user_id: ^user_id} ->
|
|
percentage =
|
|
case count do
|
|
0 -> 0
|
|
count -> round(count / Map.fetch!(original_counts, pack_id) * 100)
|
|
end
|
|
|
|
{pack_id, percentage}
|
|
end)
|
|
end
|
|
|
|
@doc """
|
|
Gets the original count for a pack
|
|
|
|
## Examples
|
|
|
|
iex> get_original_count(
|
|
...> %Pack{id: 123, count: 5, user_id: 456},
|
|
...> %User{id: 456}
|
|
...> )
|
|
5
|
|
|
|
"""
|
|
@spec get_original_count(Pack.t(), User.t()) :: non_neg_integer()
|
|
def get_original_count(%Pack{id: pack_id} = pack, current_user) do
|
|
[pack]
|
|
|> get_original_counts(current_user)
|
|
|> Map.fetch!(pack_id)
|
|
end
|
|
|
|
@doc """
|
|
Gets the original counts for multiple packs
|
|
|
|
## Examples
|
|
|
|
iex> get_original_counts(
|
|
...> [%Pack{id: 123, count: 5, user_id: 456}],
|
|
...> %User{id: 456}
|
|
...> )
|
|
%{123 => 5}
|
|
|
|
"""
|
|
@spec get_original_counts([Pack.t()], User.t()) ::
|
|
%{optional(Pack.id()) => non_neg_integer()}
|
|
def get_original_counts(packs, %User{id: user_id} = current_user) do
|
|
used_counts =
|
|
ActivityLog.get_grouped_used_counts(current_user, packs: packs, group_by: :pack_id)
|
|
|
|
packs
|
|
|> Map.new(fn %Pack{id: pack_id, count: count, user_id: ^user_id} ->
|
|
{pack_id, count + Map.get(used_counts, pack_id, 0)}
|
|
end)
|
|
end
|
|
|
|
@doc """
|
|
Calculates the CPR for a single pack
|
|
|
|
## Examples
|
|
|
|
iex> get_cpr(
|
|
...> %Pack{id: 123, price_paid: 5, count: 5, user_id: 456},
|
|
...> %User{id: 456}
|
|
...> )
|
|
1
|
|
|
|
"""
|
|
@spec get_cpr(Pack.t(), User.t()) :: float() | nil
|
|
def get_cpr(%Pack{id: pack_id} = pack, user) do
|
|
[pack]
|
|
|> get_cprs(user)
|
|
|> Map.get(pack_id)
|
|
end
|
|
|
|
@doc """
|
|
Calculates the CPR for multiple packs
|
|
|
|
## Examples
|
|
|
|
iex> get_cprs(
|
|
...> [%Pack{id: 123, price_paid: 5, count: 5, user_id: 456}],
|
|
...> %User{id: 456}
|
|
...> )
|
|
%{123 => 1}
|
|
|
|
"""
|
|
@spec get_cprs([Pack.t()], User.t()) :: %{optional(Pack.id()) => float()}
|
|
def get_cprs(packs, %User{id: user_id} = current_user) do
|
|
original_counts = get_original_counts(packs, current_user)
|
|
|
|
packs
|
|
|> Enum.reject(fn %Pack{price_paid: price_paid, user_id: ^user_id} ->
|
|
price_paid |> is_nil()
|
|
end)
|
|
|> Map.new(fn %{id: pack_id, price_paid: price_paid} ->
|
|
{pack_id, calculate_cpr(price_paid, Map.fetch!(original_counts, pack_id))}
|
|
end)
|
|
end
|
|
|
|
@spec calculate_cpr(price_paid :: float() | nil, count :: integer()) :: float() | nil
|
|
defp calculate_cpr(nil, _count), do: nil
|
|
defp calculate_cpr(_price_paid, 0), do: nil
|
|
defp calculate_cpr(price_paid, total_count), do: price_paid / total_count
|
|
|
|
@doc """
|
|
Creates multiple packs at once.
|
|
|
|
## Examples
|
|
|
|
iex> create_packs(%{field: value}, 3, %User{id: 123})
|
|
{:ok, {3, [%Pack{}]}}
|
|
|
|
iex> create_packs(%{field: bad_value}, 3, %User{id: 123})
|
|
{:error, %Changeset{}}
|
|
|
|
"""
|
|
@spec create_packs(attrs :: map(), multiplier :: non_neg_integer(), User.t()) ::
|
|
{:ok, {count :: non_neg_integer(), [Pack.t()] | nil}}
|
|
| {:error, Pack.changeset()}
|
|
def create_packs(attrs, multiplier, %User{} = user) do
|
|
attrs
|
|
|> Map.new(fn {k, v} -> {to_string(k), v} end)
|
|
|> do_create_packs(multiplier, user)
|
|
end
|
|
|
|
defp do_create_packs(
|
|
%{"type_id" => type_id, "container_id" => container_id} = attrs,
|
|
multiplier,
|
|
user
|
|
)
|
|
when multiplier >= 1 and
|
|
multiplier <= @pack_create_limit and
|
|
type_id |> is_binary() and
|
|
container_id |> is_binary() do
|
|
now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
|
|
|
|
changesets =
|
|
Enum.map(1..multiplier, fn _count ->
|
|
%Pack{}
|
|
|> Pack.create_changeset(
|
|
get_type!(type_id, user),
|
|
Containers.get_container!(container_id, user),
|
|
user,
|
|
attrs
|
|
)
|
|
end)
|
|
|
|
if changesets |> Enum.all?(fn %{valid?: valid} -> valid end) do
|
|
{count, inserted_packs} =
|
|
Repo.insert_all(
|
|
Pack,
|
|
changesets
|
|
|> Enum.map(fn changeset ->
|
|
changeset
|
|
|> Map.get(:changes)
|
|
|> Map.merge(%{inserted_at: now, updated_at: now})
|
|
end),
|
|
returning: true
|
|
)
|
|
|
|
{:ok, {count, inserted_packs |> preload_pack()}}
|
|
else
|
|
changesets
|
|
|> Enum.reject(fn %{valid?: valid} -> valid end)
|
|
|> List.first()
|
|
|> Changeset.apply_action(:insert)
|
|
end
|
|
end
|
|
|
|
defp do_create_packs(
|
|
%{"type_id" => type_id, "container_id" => container_id} = attrs,
|
|
_multiplier,
|
|
user
|
|
)
|
|
when is_binary(type_id) and is_binary(container_id) do
|
|
changeset =
|
|
%Pack{}
|
|
|> Pack.create_changeset(
|
|
get_type!(type_id, user),
|
|
Containers.get_container!(container_id, user),
|
|
user,
|
|
attrs
|
|
)
|
|
|> Changeset.add_error(:multiplier, dgettext("errors", "Invalid multiplier"))
|
|
|
|
{:error, changeset}
|
|
end
|
|
|
|
defp do_create_packs(invalid_attrs, _multiplier, user) do
|
|
{:error, %Pack{} |> Pack.create_changeset(nil, nil, user, invalid_attrs)}
|
|
end
|
|
|
|
@spec preload_pack(Pack.t()) :: Pack.t()
|
|
@spec preload_pack([Pack.t()]) :: [Pack.t()]
|
|
defp preload_pack(pack_or_packs) do
|
|
pack_or_packs |> Repo.preload(@pack_preloads)
|
|
end
|
|
|
|
@doc """
|
|
Updates a pack.
|
|
|
|
## Examples
|
|
|
|
iex> update_pack(pack, %{field: new_value}, %User{id: 123})
|
|
{:ok, %Pack{}}
|
|
|
|
iex> update_pack(pack, %{field: bad_value}, %User{id: 123})
|
|
{:error, %Changeset{}}
|
|
|
|
"""
|
|
@spec update_pack(Pack.t(), attrs :: map(), User.t()) ::
|
|
{:ok, Pack.t()} | {:error, Pack.changeset()}
|
|
def update_pack(
|
|
%Pack{user_id: user_id} = pack,
|
|
attrs,
|
|
%User{id: user_id} = user
|
|
) do
|
|
pack
|
|
|> Pack.update_changeset(attrs, user)
|
|
|> Repo.update()
|
|
|> case do
|
|
{:ok, pack} -> {:ok, pack |> preload_pack()}
|
|
{:error, changeset} -> {:error, changeset}
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Deletes a pack.
|
|
|
|
## Examples
|
|
|
|
iex> delete_pack(pack, %User{id: 123})
|
|
{:ok, %Pack{}}
|
|
|
|
iex> delete_pack(pack, %User{id: 123})
|
|
{:error, %Changeset{}}
|
|
|
|
"""
|
|
@spec delete_pack(Pack.t(), User.t()) ::
|
|
{:ok, Pack.t()} | {:error, Pack.changeset()}
|
|
def delete_pack(%Pack{user_id: user_id} = pack, %User{id: user_id}) do
|
|
pack
|
|
|> Repo.delete()
|
|
|> case do
|
|
{:ok, pack} -> {:ok, pack |> preload_pack()}
|
|
{:error, changeset} -> {:error, changeset}
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Deletes a pack.
|
|
|
|
## Examples
|
|
|
|
iex> delete_pack!(pack, %User{id: 123})
|
|
%Pack{}
|
|
|
|
"""
|
|
@spec delete_pack!(Pack.t(), User.t()) :: Pack.t()
|
|
def delete_pack!(pack, user) do
|
|
{:ok, pack} = delete_pack(pack, user)
|
|
pack
|
|
end
|
|
end
|