paper_vote.ex

defmodule Api.PaperVote do
  @moduledoc """
    TODO: Write.
  """

  use Api.Web, :model

  alias Api.{Crypto, Team, Category, User}

  @required_attrs [
    :hmac_secret,
  ]
  @required_assocs [
    :category_id,
    :created_by,
  ]

  @valid_attrs @required_attrs ++ [
    :redeemed_at,

    :annulled_at,
  ]
  @valid_assocs @required_assocs ++ [
    :redeeming_admin,
    :redeeming_member,
    :team_id,

    :annulled_by,
  ]

  schema "paper_votes" do
    field :hmac_secret, :string
    belongs_to :category, Category
    belongs_to :created_by, User

    field :redeemed_at, :utc_datetime
    belongs_to :redeeming_admin, User
    belongs_to :redeeming_member, User
    belongs_to :team, Team

    field :annulled_at, :utc_datetime
    belongs_to :annulled_by, User

    timestamps()
  end

  def hmac(paper_vote) do
    Crypto.hmac(paper_vote.hmac_secret, paper_vote.id)
  end

  def changeset(struct, params \\ %{}) do
    struct
    |> cast(params, @valid_attrs)
    |> cast_assoc(:category)
    |> cast_assoc(:created_by)
    |> cast_assoc(:redeeming_admin)
    |> cast_assoc(:redeeming_member)
    |> cast_assoc(:annulled_by)
    |> validate_required(@required_attrs)
  end
end

paper_vote_test.exs

defmodule Api.PaperVoteTest do
  use Api.ModelCase

  alias Api.PaperVote

  setup %{} do
    user = create_user() |> Map.from_struct()
    admin = create_admin() |> Map.from_struct()
    category = create_category() |> Map.from_struct()
    team = create_team(user) |> Map.from_struct()
    {:ok, %{
      user: user,
      admin: admin,
      category: category,
      team: team,
      base_attrs: %{
        hmac_secret: "you'll never guess me",
        category: category,
        created_by: admin,
      }
    }}
  end

  test "changeset create", %{base_attrs: base_attrs} do
    assert PaperVote.changeset(%PaperVote{}, base_attrs).valid?
  end

  test "changeset redeem", %{base_attrs: base_attrs, user: user, team: team, admin: admin} do
    assert PaperVote.changeset(%PaperVote{}, Map.merge(base_attrs, %{
      redeemed_at: DateTime.utc_now(),
      redeeming_admin: admin,
      redeeming_member: user,
      team: team,
    })).valid?
  end

  test "changeset annul", %{base_attrs: base_attrs, admin: admin} do
    assert PaperVote.changeset(%PaperVote{}, Map.merge(base_attrs, %{
      annulled_at: DateTime.utc_now(),
      annulled_by: admin,
    })).valid?
  end

  test "roundtrip", %{admin: admin, category: category, user: user, team: team} do
    pv =
      %PaperVote{}
      |> PaperVote.changeset(%{
        hmac_secret: "you'll never guess me",
        category: category,
        created_by: admin,
        redeemed_at: DateTime.utc_now(),
        redeeming_admin: admin,
        redeeming_member: user,
        team: team,
        annulled_at: DateTime.utc_now(),
        annulled_by: admin,
      })
      |> Repo.insert!

    assert Map.from_struct(pv) == %{}
  end
end