Default Phoenix Model

phoenix_user_files.ex

### mix phx.routes

user_path  GET     /users                                 PhoenixPlaygroundWeb.UserController :index
user_path  GET     /users/:id/edit                        PhoenixPlaygroundWeb.UserController :edit
user_path  GET     /users/new                             PhoenixPlaygroundWeb.UserController :new
user_path  GET     /users/:id                             PhoenixPlaygroundWeb.UserController :show
user_path  POST    /users                                 PhoenixPlaygroundWeb.UserController :create
user_path  PATCH   /users/:id                             PhoenixPlaygroundWeb.UserController :update
           PUT     /users/:id                             PhoenixPlaygroundWeb.UserController :update
user_path  DELETE  /users/:id                             PhoenixPlaygroundWeb.UserController :delete



### lib/phoenix_playground_web/controllers/user_controller.ex
defmodule PhoenixPlaygroundWeb.UserController do
  use PhoenixPlaygroundWeb, :controller

  alias PhoenixPlayground.Accounts
  alias PhoenixPlayground.Accounts.User

  action_fallback PhoenixPlaygroundWeb.FallbackController

  def index(conn, _params) do
    users = Accounts.list_users()
    render(conn, "index.json", users: users)
  end

  def create(conn, %{"user" => user_params}) do
    with {:ok, %User{} = user} <- Accounts.create_user(user_params) do
      conn
      |> put_status(:created)
      |> put_resp_header("location", Routes.user_path(conn, :show, user))
      |> render("show.json", user: user)
    end
  end

  def show(conn, %{"id" => id}) do
    user = Accounts.get_user!(id)
    render(conn, "show.json", user: user)
  end

  def update(conn, %{"id" => id, "user" => user_params}) do
    user = Accounts.get_user!(id)

    with {:ok, %User{} = user} <- Accounts.update_user(user, user_params) do
      render(conn, "show.json", user: user)
    end
  end

  def delete(conn, %{"id" => id}) do
    user = Accounts.get_user!(id)

    with {:ok, %User{}} <- Accounts.delete_user(user) do
      send_resp(conn, :no_content, "")
    end
  end
end



### lib/phoenix_playground_web/views/user_view.ex
defmodule PhoenixPlaygroundWeb.UserView do
  use PhoenixPlaygroundWeb, :view
  alias PhoenixPlaygroundWeb.UserView

  def render("index.json", %{users: users}) do
    %{data: render_many(users, UserView, "user.json")}
  end

  def render("show.json", %{user: user}) do
    %{data: render_one(user, UserView, "user.json")}
  end

  def render("user.json", %{user: user}) do
    %{id: user.id,
      name: user.name,
      age: user.age,
      updated_at: user.updated_at,
      version: user.version}
  end
end



### lib/phoenix_playground/accounts/user.ex
defmodule PhoenixPlayground.Accounts.User do
  use Ecto.Schema
  import Ecto.Changeset

  schema "users" do
    # Fields that the user can view and edit
    field :name, :string
    field :age, :integer

    # Fields that the user can view
    field :updated_at, :utc_datetime

    # Fields that the user must send with ever edit (but not create)
    field :version, :string

    # Fields that are updated but the user never sees
    field :audit_log, {:array, :string}
  end

  @doc false
  def changeset(user, attrs) do
    user
    |> cast(attrs, [:name, :age, :updated_at, :version, :audit_log])
    |> validate_required([:name, :age, :updated_at, :version, :audit_log])
  end
end



### lib/phoenix_playground/accounts.ex
defmodule PhoenixPlayground.Accounts do
  @moduledoc """
  The Accounts context.
  """

  import Ecto.Query, warn: false
  alias PhoenixPlayground.Repo

  alias PhoenixPlayground.Accounts.User

  @doc """
  Returns the list of users.

  ## Examples

      iex> list_users()
      [%User{}, ...]

  """
  def list_users do
    Repo.all(User)
  end

  @doc """
  Gets a single user.

  Raises `Ecto.NoResultsError` if the User does not exist.

  ## Examples

      iex> get_user!(123)
      %User{}

      iex> get_user!(456)
      ** (Ecto.NoResultsError)

  """
  def get_user!(id), do: Repo.get!(User, id)

  @doc """
  Creates a user.

  ## Examples

      iex> create_user(%{field: value})
      {:ok, %User{}}

      iex> create_user(%{field: bad_value})
      {:error, %Ecto.Changeset{}}

  """
  def create_user(attrs \\ %{}) do
    %User{}
    |> User.changeset(attrs)
    |> Repo.insert()
  end

  @doc """
  Updates a user.

  ## Examples

      iex> update_user(user, %{field: new_value})
      {:ok, %User{}}

      iex> update_user(user, %{field: bad_value})
      {:error, %Ecto.Changeset{}}

  """
  def update_user(%User{} = user, attrs) do
    user
    |> User.changeset(attrs)
    |> Repo.update()
  end

  @doc """
  Deletes a User.

  ## Examples

      iex> delete_user(user)
      {:ok, %User{}}

      iex> delete_user(user)
      {:error, %Ecto.Changeset{}}

  """
  def delete_user(%User{} = user) do
    Repo.delete(user)
  end

  @doc """
  Returns an `%Ecto.Changeset{}` for tracking user changes.

  ## Examples

      iex> change_user(user)
      %Ecto.Changeset{source: %User{}}

  """
  def change_user(%User{} = user) do
    User.changeset(user, %{})
  end
end