I'm still doing Dockyard's tutorial of Elixir and Phoenix.
So far I've progressed to building a blog context. Now I'm trying to add a comment context to the app. This would also allow the user to post a comment and list all the comments below a post.
This exercise is designed to teach you about how to create one-to-many relations in Phoenix.
Although the concept is easy to grasp, there are a few steps you need to take and quite a few files you need to change.
The rest of this post shows how I did it. The idea is to remind myself and show other beginners of Phoenix how to do it on a nitty-gritty level. I can't guarantee this is best practice.
SPOILER ALERT If you are also doing this exercise, I strongly recommend you to work on it on your own first.
Steps
For the sake of clarity, suppose we are adding comments to posts.
- generate a new context (
comments), edit migration file and migrate
- change schemas to specify the association between them
- change
posts repo file to preload comments
- change router file to specify which controller function should handle requests made to
comments
- change
comment controller to handle those requests
- change
post controller to add comment_changeset
- change
post template to display and edit comments
1. generate a new context; edit migration file and migrate
Generate a context by doing this:
mix phx.gen.context Comments Comment comments content:text post_id:references:posts
Generate a migration file (I forgot if the last command would generate a migration file. So this may or may not be necessary.):
mix ecto.gen.migration add_comments
In the generated empty migration file, add this. This defines a comments table of two fields. null: false makes sure a comment must point to a post.
1def change do
2 create table(:comments) do
3 add :content, :text
4 add :post_id, references(:posts, on_delete: :nothing), null: false
5
6 timestamps()
7 end
Run the migration file.
2. schemas
In lib/blog/posts/post.ex (this file defines the posts schema). Add:
1defmodule Blog.Posts.Post do
2 # ...
3
4 schema "posts" do
5 # ... other fields ...
6 has_many :comments, Blog.Comments.Comment
7 # ...
8 end
9 # ...
In lib/blog/comments/comment.ex (this file defines the comments schema).
1defmodule Blog.Comments.Comment do
2 use Ecto.Schema
3 import Ecto.Changeset
4
5 schema "comments" do
6 field :content, :string
7 # ADD belongs_to
8 belongs_to :post, Blog.Posts.Post
9
10 timestamps()
11 end
12
13 @doc false
14 def changeset(comment, attrs) do
15 comment
16 # ADD post_id
17 |> cast(attrs, [:content, :post_id])
18 |> validate_required([:content])
19 |> foreign_key_constraint(:post_id)
20 end
21end
post_id is added to the cast function so that the created comments will accept and store a post_id value.
3. posts repo
In lib/blog/posts.ex add preload to preload comments. This file defines the Blog.Posts module along with functions to get, create and change posts.
This way, comments associated with the post record will be preloaded. So that the HEEx template will have something to display.
1def get_post!(id) do
2 Repo.get!(Post, id)
3 |> Repo.preload(:comments) # ADDED
4end
4. router
In lib/blog_web/router.ex (where the router is defined), add a route to handle the post request made to /comments. This request is used to create a comment.
1scope "/", BlogWeb do
2 pipe_through :browser
3
4 get "/", PageController, :home
5 post "/comments", CommentController, :create # ADDED
6 resources "/posts", PostController
7end
5. comment controller
At lib/blog_web/controllers/comment_controller.ex create a comment controller. This is actually directly taken from Dockyard tutorial.
1defmodule BlogWeb.CommentController do
2 use BlogWeb, :controller
3
4 alias Blog.Posts
5 alias Blog.Comments
6
7 def create(conn, %{"comment" => comment_params}) do
8 case Comments.create_comment(comment_params) do
9 {:ok, comment} ->
10 conn
11 |> put_flash(:info, "Comment created successfully.")
12 |> redirect(to: ~p"/posts/#{comment.post_id}")
13
14 {:error, %Ecto.Changeset{} = comment_changeset} ->
15 post = Posts.get_post!(comment_params["post_id"])
16 render(conn, :show, post: post, comment_changeset: comment_changeset)
17 end
18 end
19end
6. post controller
In lib/blog_web_controllers/post_controller.ex, because we are trying to show comments below each blog post, we need to add a comment_changeset to the show function.
1def show(conn, %{"id" => id}) do
2 post = Posts.get_post!(id)
3 comment_changeset = Comments.change_comment(%Comment{})
4 render(conn, :show,
5 post: post,
6 comment_changeset: comment_changeset
7 )
8end
7. template
In lib/blog_web/controllers/post_html/show.html.heex, we need to add these lines to be able to create and display the comments. (A lot of the code in this part is also taken from the tutorial.)
1<.simple_form :let={f} for={@comment_changeset} action={~p"/comments"}>
2 <.input type="hidden" field={f[:post_id]} value={@post.id} />
3 <.input field={f[:content]} type="text" label="Content" />
4 <:actions>
5 <.button>Comment</.button>
6 </:actions>
7</.simple_form>
8
9<%= for comment <- @post.comments do %>
10 <p><%= comment.content %></p>
11<% end %>
