From 5cbc64bd1aa7d361f31ac5b66d0c04f9f50266e2 Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Wed, 28 Aug 2019 12:38:53 -0400 Subject: [PATCH] context: badges, badge_awards --- lib/philomena/badges.ex | 200 +++++++++++++++++++++++++++++++++ lib/philomena/badges/award.ex | 24 ++++ lib/philomena/badges/badge.ex | 21 ++++ test/philomena/badges_test.exs | 119 ++++++++++++++++++++ 4 files changed, 364 insertions(+) create mode 100644 lib/philomena/badges.ex create mode 100644 lib/philomena/badges/award.ex create mode 100644 lib/philomena/badges/badge.ex create mode 100644 test/philomena/badges_test.exs diff --git a/lib/philomena/badges.ex b/lib/philomena/badges.ex new file mode 100644 index 00000000..6ee95705 --- /dev/null +++ b/lib/philomena/badges.ex @@ -0,0 +1,200 @@ +defmodule Philomena.Badges do + @moduledoc """ + The Badges context. + """ + + import Ecto.Query, warn: false + alias Philomena.Repo + + alias Philomena.Badges.Badge + + @doc """ + Returns the list of badges. + + ## Examples + + iex> list_badges() + [%Badge{}, ...] + + """ + def list_badges do + Repo.all(Badge) + end + + @doc """ + Gets a single badge. + + Raises `Ecto.NoResultsError` if the Badge does not exist. + + ## Examples + + iex> get_badge!(123) + %Badge{} + + iex> get_badge!(456) + ** (Ecto.NoResultsError) + + """ + def get_badge!(id), do: Repo.get!(Badge, id) + + @doc """ + Creates a badge. + + ## Examples + + iex> create_badge(%{field: value}) + {:ok, %Badge{}} + + iex> create_badge(%{field: bad_value}) + {:error, %Ecto.Changeset{}} + + """ + def create_badge(attrs \\ %{}) do + %Badge{} + |> Badge.changeset(attrs) + |> Repo.insert() + end + + @doc """ + Updates a badge. + + ## Examples + + iex> update_badge(badge, %{field: new_value}) + {:ok, %Badge{}} + + iex> update_badge(badge, %{field: bad_value}) + {:error, %Ecto.Changeset{}} + + """ + def update_badge(%Badge{} = badge, attrs) do + badge + |> Badge.changeset(attrs) + |> Repo.update() + end + + @doc """ + Deletes a Badge. + + ## Examples + + iex> delete_badge(badge) + {:ok, %Badge{}} + + iex> delete_badge(badge) + {:error, %Ecto.Changeset{}} + + """ + def delete_badge(%Badge{} = badge) do + Repo.delete(badge) + end + + @doc """ + Returns an `%Ecto.Changeset{}` for tracking badge changes. + + ## Examples + + iex> change_badge(badge) + %Ecto.Changeset{source: %Badge{}} + + """ + def change_badge(%Badge{} = badge) do + Badge.changeset(badge, %{}) + end + + alias Philomena.Badges.Award + + @doc """ + Returns the list of badge_awards. + + ## Examples + + iex> list_badge_awards() + [%Award{}, ...] + + """ + def list_badge_awards do + Repo.all(Award) + end + + @doc """ + Gets a single badge_award. + + Raises `Ecto.NoResultsError` if the Badge award does not exist. + + ## Examples + + iex> get_badge_award!(123) + %Award{} + + iex> get_badge_award!(456) + ** (Ecto.NoResultsError) + + """ + def get_badge_award!(id), do: Repo.get!(Award, id) + + @doc """ + Creates a badge_award. + + ## Examples + + iex> create_badge_award(%{field: value}) + {:ok, %Award{}} + + iex> create_badge_award(%{field: bad_value}) + {:error, %Ecto.Changeset{}} + + """ + def create_badge_award(attrs \\ %{}) do + %Award{} + |> Award.changeset(attrs) + |> Repo.insert() + end + + @doc """ + Updates a badge_award. + + ## Examples + + iex> update_badge_award(badge_award, %{field: new_value}) + {:ok, %Award{}} + + iex> update_badge_award(badge_award, %{field: bad_value}) + {:error, %Ecto.Changeset{}} + + """ + def update_badge_award(%Award{} = badge_award, attrs) do + badge_award + |> Award.changeset(attrs) + |> Repo.update() + end + + @doc """ + Deletes a Award. + + ## Examples + + iex> delete_badge_award(badge_award) + {:ok, %Award{}} + + iex> delete_badge_award(badge_award) + {:error, %Ecto.Changeset{}} + + """ + def delete_badge_award(%Award{} = badge_award) do + Repo.delete(badge_award) + end + + @doc """ + Returns an `%Ecto.Changeset{}` for tracking badge_award changes. + + ## Examples + + iex> change_badge_award(badge_award) + %Ecto.Changeset{source: %Award{}} + + """ + def change_badge_award(%Award{} = badge_award) do + Award.changeset(badge_award, %{}) + end +end diff --git a/lib/philomena/badges/award.ex b/lib/philomena/badges/award.ex new file mode 100644 index 00000000..204fe894 --- /dev/null +++ b/lib/philomena/badges/award.ex @@ -0,0 +1,24 @@ +defmodule Philomena.Badges.Award do + use Ecto.Schema + import Ecto.Changeset + + schema "badge_awards" do + belongs_to :user, Philomena.Users.User + belongs_to :awarded_by, Philomena.Users.User + belongs_to :badge, Philomena.Badges.Badge + + field :label, :string + field :awarded_on, :naive_datetime + field :reason, :string + field :badge_name, :string + + timestamps(inserted_at: :created_at) + end + + @doc false + def changeset(badge_award, attrs) do + badge_award + |> cast(attrs, []) + |> validate_required([]) + end +end diff --git a/lib/philomena/badges/badge.ex b/lib/philomena/badges/badge.ex new file mode 100644 index 00000000..379cf7a8 --- /dev/null +++ b/lib/philomena/badges/badge.ex @@ -0,0 +1,21 @@ +defmodule Philomena.Badges.Badge do + use Ecto.Schema + import Ecto.Changeset + + schema "badges" do + field :title, :string + field :description, :string + field :image, :string + field :disable_award, :boolean, default: false + field :priority, :boolean, default: false + + timestamps(inserted_at: :created_at) + end + + @doc false + def changeset(badge, attrs) do + badge + |> cast(attrs, []) + |> validate_required([]) + end +end diff --git a/test/philomena/badges_test.exs b/test/philomena/badges_test.exs new file mode 100644 index 00000000..0911469e --- /dev/null +++ b/test/philomena/badges_test.exs @@ -0,0 +1,119 @@ +defmodule Philomena.BadgesTest do + use Philomena.DataCase + + alias Philomena.Badges + + describe "badges" do + alias Philomena.Badges.Badge + + @valid_attrs %{} + @update_attrs %{} + @invalid_attrs %{} + + def badge_fixture(attrs \\ %{}) do + {:ok, badge} = + attrs + |> Enum.into(@valid_attrs) + |> Badges.create_badge() + + badge + end + + test "list_badges/0 returns all badges" do + badge = badge_fixture() + assert Badges.list_badges() == [badge] + end + + test "get_badge!/1 returns the badge with given id" do + badge = badge_fixture() + assert Badges.get_badge!(badge.id) == badge + end + + test "create_badge/1 with valid data creates a badge" do + assert {:ok, %Badge{} = badge} = Badges.create_badge(@valid_attrs) + end + + test "create_badge/1 with invalid data returns error changeset" do + assert {:error, %Ecto.Changeset{}} = Badges.create_badge(@invalid_attrs) + end + + test "update_badge/2 with valid data updates the badge" do + badge = badge_fixture() + assert {:ok, %Badge{} = badge} = Badges.update_badge(badge, @update_attrs) + end + + test "update_badge/2 with invalid data returns error changeset" do + badge = badge_fixture() + assert {:error, %Ecto.Changeset{}} = Badges.update_badge(badge, @invalid_attrs) + assert badge == Badges.get_badge!(badge.id) + end + + test "delete_badge/1 deletes the badge" do + badge = badge_fixture() + assert {:ok, %Badge{}} = Badges.delete_badge(badge) + assert_raise Ecto.NoResultsError, fn -> Badges.get_badge!(badge.id) end + end + + test "change_badge/1 returns a badge changeset" do + badge = badge_fixture() + assert %Ecto.Changeset{} = Badges.change_badge(badge) + end + end + + describe "badge_awards" do + alias Philomena.Badges.BadgeAward + + @valid_attrs %{} + @update_attrs %{} + @invalid_attrs %{} + + def badge_award_fixture(attrs \\ %{}) do + {:ok, badge_award} = + attrs + |> Enum.into(@valid_attrs) + |> Badges.create_badge_award() + + badge_award + end + + test "list_badge_awards/0 returns all badge_awards" do + badge_award = badge_award_fixture() + assert Badges.list_badge_awards() == [badge_award] + end + + test "get_badge_award!/1 returns the badge_award with given id" do + badge_award = badge_award_fixture() + assert Badges.get_badge_award!(badge_award.id) == badge_award + end + + test "create_badge_award/1 with valid data creates a badge_award" do + assert {:ok, %BadgeAward{} = badge_award} = Badges.create_badge_award(@valid_attrs) + end + + test "create_badge_award/1 with invalid data returns error changeset" do + assert {:error, %Ecto.Changeset{}} = Badges.create_badge_award(@invalid_attrs) + end + + test "update_badge_award/2 with valid data updates the badge_award" do + badge_award = badge_award_fixture() + assert {:ok, %BadgeAward{} = badge_award} = Badges.update_badge_award(badge_award, @update_attrs) + end + + test "update_badge_award/2 with invalid data returns error changeset" do + badge_award = badge_award_fixture() + assert {:error, %Ecto.Changeset{}} = Badges.update_badge_award(badge_award, @invalid_attrs) + assert badge_award == Badges.get_badge_award!(badge_award.id) + end + + test "delete_badge_award/1 deletes the badge_award" do + badge_award = badge_award_fixture() + assert {:ok, %BadgeAward{}} = Badges.delete_badge_award(badge_award) + assert_raise Ecto.NoResultsError, fn -> Badges.get_badge_award!(badge_award.id) end + end + + test "change_badge_award/1 returns a badge_award changeset" do + badge_award = badge_award_fixture() + assert %Ecto.Changeset{} = Badges.change_badge_award(badge_award) + end + end +end