context: badges, badge_awards

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

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

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

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