lots of things done: thread - reply - category - seeds

lib/myapp/data/category.ex

@@ -0,0 +1,24 @@
+defmodule MyApp.Data.Category do
+  use Ecto.Schema
+  import Ecto.Query
+  import Ecto.Changeset
+  alias MyApp.Repo
+  alias MyApp.Data
+
+  @derive {Poison.Encoder, except: [:__meta__]}
+  schema "category" do
+    field :category, :string
+    field :title, :string
+  end
+
+  def changeset(category, params \\ %{}) do
+    category
+    |> cast(params, [:category, :title])
+    |> validate_required([:category, :title])
+  end
+
+  def get_categories() do
+    Repo.all(Data.Category)
+  end
+
+end

lib/myapp/data/reply.ex

@@ -0,0 +1,32 @@
+defmodule MyApp.Data.Reply do
+  use Ecto.Schema
+  import Ecto.Query
+  import Ecto.Changeset
+  alias MyApp.Repo
+  alias MyApp.Data
+
+  @derive {Poison.Encoder, except: [:__meta__]}
+  schema "reply" do
+    field :user_id, :integer # references :user
+    field :thread_id, :integer # references :thread
+    field :content, :string
+    field :edited, :boolean, default: false
+    field :quote, :boolean, default: false
+    timestamps()
+  end
+
+  def changeset(reply, params \\ %{}) do
+    reply
+    |> cast(params, [:user_id, :thread_id, :content, :edited, :quote])
+    |> validate_required([:user_id, :thread_id, :content])
+    |> foreign_key_constraint(:user_id)
+    |> foreign_key_constraint(:thread_id)
+  end
+
+  def insert_reply(params) do
+    changeset(%Data.Reply{}, params)
+    |> Repo.insert
+    |> Data.Util.process_insert_or_update
+  end
+
+end

lib/myapp/data/thread.ex

@@ -8,21 +8,43 @@ defmodule MyApp.Data.Thread do
   @derive {Poison.Encoder, except: [:__meta__]}
   schema "thread" do
     field :title, :string
+    field :category_id, :integer # references :category
     field :content, :string
-    field :view_count, :integer
-    field :user_id, :integer
+    field :view_count, :integer, default: 0
+    field :user_id, :integer # references :user
     field :last_reply_id, :integer
     field :sticky, :boolean, default: false
     field :locked, :boolean, default: false
+    field :edited, :boolean, default: false
 
-    belongs_to :user, Data.User, define_field: false
     timestamps()
   end
 
   def changeset(thread, params \\ %{}) do
     thread
-    |> cast(params, [:title, :content, :user_id, :view_count, :last_reply_id, :sticky, :locked])
-    |> validate_required([:title, :content, :user_id])
+    |> cast(params, [:id, :title, :category_id, :content, :user_id, :view_count, :last_reply_id, :sticky, :locked, :edited])
+    |> validate_required([:title, :category_id, :content, :user_id])
+    |> foreign_key_constraint(:category_id)
+  end
+
+  def insert_thread(params) do
+    changeset(%Data.Thread{}, params)
+    |> Repo.insert
+    |> Data.Util.process_insert_or_update
+  end
+
+  def update_thread(params) do
+    Repo.get(Data.Thread, Map.get(params, "id"))
+    |> process_update(params)
+  end
+
+  # TODO: check user permissions for sticky/locked
+  defp process_update(thread, _params) when is_nil(thread), do: {:error, "Invalid thread"}
+  defp process_update(thread, params) when not is_nil(thread) do
+    changeset(thread, Map.take(params, ["content", "edited", "sticky", "locked"]))
+    |> IO.inspect
+    |> Repo.update
+    |> Data.Util.process_insert_or_update
   end
 
 end

lib/myapp/data/user.ex

@@ -5,12 +5,11 @@ defmodule MyApp.Data.User do
   alias MyApp.Repo
   alias MyApp.Data
 
-  @derive {Poison.Encoder, except: [:__meta__]}
+  @derive {Poison.Encoder, except: [:__meta__, :__struct__]}
   schema "user" do
     field :battle_net_id, :integer
     field :battletag, :string
 
-    has_many :threads, Data.Thread
     timestamps()
   end
 
@@ -55,29 +54,22 @@ defmodule MyApp.Data.User do
   end
 
   defp insert_user(params) do
-    cs = changeset(%Data.User{}, params)
-    cs
+    changeset(%Data.User{}, params)
     |> Repo.insert
-    |> process_insert_or_update
+    |> Data.Util.process_insert_or_update
+    |> filter_values
   end
 
   # it's possible for a user's battle tag to change - if so update it
   defp update_battletag(user, params) do
-    cs = Data.User.changeset(Map.merge(%Data.User{}, user), %{battletag: Map.get(params, "battletag")})
-    cs
+    changeset(Map.merge(%Data.User{}, user), %{battletag: Map.get(params, "battletag")})
     |> Repo.update
-    |> process_insert_or_update
+    |> Data.Util.process_insert_or_update
+    |> filter_values
   end
 
-  defp process_insert_or_update({:error, changeset}), do: {:error, map_changeset(changeset)}
-  defp process_insert_or_update({:ok, user}) do
-    {:ok, Map.take(user, [:id, :battle_net_id, :battletag])} # only grab the fields we need
-  end
-
-  defp map_changeset(changeset) do
-    Enum.map(changeset.errors, fn {key, val} ->
-      %{key => elem(val, 0)}
-    end)
-  end
+  # take certain values after insertion
+  defp filter_values({:error, error}), do: {:error, error}
+  defp filter_values({:ok, user}), do: {:ok, Map.take(user, [:id, :battle_net_id, :battletag])}
 
 end

lib/myapp/data/util.ex

@@ -0,0 +1,12 @@
+defmodule MyApp.Data.Util do
+
+  def map_changeset(changeset) do
+    Enum.map(changeset.errors, fn {key, val} ->
+      %{key => elem(val, 0)}
+    end)
+  end
+
+  def process_insert_or_update({:error, changeset}), do: {:error, map_changeset(changeset)}
+  def process_insert_or_update({:ok, data}), do: {:ok, data}
+
+end