Packages
formex
0.4.7
0.6.7
0.6.6
0.6.5
0.6.4
0.6.3
0.6.2
0.6.1
0.6.0
0.5.10
0.5.9
0.5.8
0.5.7
0.5.6
0.5.5
0.5.4
0.5.3
0.5.2
0.5.1
0.5.0
0.4.16
0.4.15
0.4.14
0.4.13
0.4.12
0.4.11
0.4.10
0.4.9
0.4.8
0.4.7
0.4.6
0.4.5
0.4.4
0.4.3
0.4.2
0.4.1
0.4.0
0.3.3
0.3.2
0.3.1
0.3.0
0.2.3
0.2.2
0.2.1
0.2.0
0.1.4
0.1.3
0.1.2
0.1.1
0.1.0
Form library for Phoenix with Ecto support
Current section
Files
Jump to
Current section
Files
lib/formex/controller.ex
defmodule Formex.Controller do
alias Formex.Form
@repo Application.get_env(:formex, :repo)
defmacro __using__(_) do
quote do
import Formex.Builder
import Formex.Controller
end
end
@moduledoc """
Helpers for controller. Imports `Formex.Builder`.
# Installation:
`web/web.ex`
```
def controller do
quote do
use Formex.Controller
end
end
```
# Usage
## CRUD
```
def new(conn, _params) do
form = create_form(App.ArticleType, %Article{})
render(conn, "new.html", form: form)
end
```
```
def create(conn, %{"article" => article_params}) do
App.ArticleType
|> create_form(%Article{}, article_params)
|> insert_form_data
|> case do
{:ok, _article} ->
# ...
{:error, form} ->
# ...
end
end
```
```
def edit(conn, %{"id" => id}) do
article = Repo.get!(Article, id)
form = create_form(App.ArticleType, article)
render(conn, "edit.html", article: article, form: form)
end
```
```
def update(conn, %{"id" => id, "article" => article_params}) do
article = Repo.get!(Article, id)
App.ArticleType
|> create_form(article, article_params)
|> update_form_data
|> case do
{:ok, article} ->
# ...
{:error, form} ->
# ...
end
end
```
## Usage without a database
```
defmodule App.Registration do
use App.Web, :model
embedded_schema do # instead of `schema`
field :email
field :password
end
end
```
```
def register(conn, %{"registration" => registration_params}) do
RegistrationType
|> create_form(%Registration{}, registration_params)
|> handle_form
|> case do
{:ok, registration} ->
# do something with the `registration`
{:error, form} ->
# display errors
render(conn, "index.html", form: form)
end
end
```
"""
@doc """
Works similar to `insert_form_data/1` and `update_form_data/1`, but doesn't require a database.
Should be used with `embedded_schema`.
"""
@spec handle_form(Form.t) :: {:ok, Ecto.Schema.t} | {:error, Form.t}
def handle_form(form) do
if form.changeset.valid? do
{:ok, Ecto.Changeset.apply_changes(form.changeset)}
else
changeset = %{form.changeset | action: :update}
{:error, Map.put(form, :changeset, changeset)}
end
end
@doc """
Invokes `Repo.insert`. In case of `:error`, returns `{:error, form}` (with new `form.changeset`
value) instead of `{:error, changeset}` (as Ecto does)
"""
@spec insert_form_data(Form.t) :: {:ok, Ecto.Schema.t} | {:error, Form.t}
def insert_form_data(form) do
case @repo.insert(form.changeset) do
{:ok, schema} -> {:ok, schema}
{:error, changeset} -> {:error, Map.put(form, :changeset, changeset)}
end
end
@doc """
Invokes `Repo.update`. In case of `:error`, returns `{:error, form}` (with new `form.changeset`
value) instead of `{:error, changeset}` (as Ecto does)
"""
@spec update_form_data(Form.t) :: {:ok, Ecto.Schema.t} | {:error, Form.t}
def update_form_data(form) do
case @repo.update(form.changeset) do
{:ok, schema} -> {:ok, schema}
{:error, changeset} -> {:error, Map.put(form, :changeset, changeset)}
end
end
end