load.ex

```elixir
defmodule Riptreaver.API.TargetGroupController do
  use Riptreaver.Web, :controller
  plug PolicyWonk.Enforce, roles: [:admin, :advertiser]
  plug :load_target_groups when action in [:index]
  plug :load_target_group when action in [:show, :update, :delete, :create_target]
  plug PolicyWonk.Enforce, :target_group when action in [:show, :update, :delete]
  alias Riptreaver.{Account, ErrorView}

  def index(conn, _params) do
    %{target_groups: target_groups} = conn.assigns
    render(conn, "index.json", target_groups: target_groups)
  end

  def show(conn, _params) do
    %{target_group: target_group} = conn.assigns
    render(conn, "show.json", target_group: target_group)
  end

  def delete(conn, _params) do
    %{target_group: target_group} = conn.assigns

    case Account.delete_target_group(account(conn), target_group) do
      {:ok, target_group} ->
        render(conn, "show.json", target_group: target_group)
      {:error, changeset} ->
        conn
        |> put_status(:unprocessable_entity)
        |> render(ErrorView, :"422", changeset: changeset)
    end
  end

  def update(conn, %{"target_group" => target_group_params}) do
    %{target_group: target_group} = conn.assigns

    case Account.update_target_group(account(conn), target_group, target_group_params) do
      {:ok, target_group} ->
        render(conn, "show.json", target_group: target_group)
      {:error, changeset} ->
        conn
        |> put_status(:unprocessable_entity)
        |> render(ErrorView, :"422", changeset: changeset)
    end
  end

  def create(conn, %{"target_group" => target_group_params}) do
    case Account.create_target_group(account(conn), target_group_params) do
      {:ok, target_group} ->
        target_group = %{target_group | targets: []}
        render(conn, "show.json", target_group: target_group)
      {:error, changeset} ->
        conn
        |> put_status(:unprocessable_entity)
        |> render(ErrorView, :"422", changeset: changeset)
    end
  end

  def move_targets(conn, %{"id" => target_group_id, "target_ids" => target_ids}) do
    Account.move_targets_to_group! account(conn), target_ids, target_group_id

    target_group =
      conn
      |> account
      |> Account.get_target_group!(target_group_id)
      |> Repo.preload(:targets)

    render(conn, "show.json", target_group: target_group)
  end

  def create_target(conn, %{"target" => target_params}) do
    %{target_group: target_group} = conn.assigns

    case Account.create_target(account(conn), target_group, target_params) do
      {:ok, target} ->
        render(conn, Riptreaver.API.TargetView, "target.json", target: Map.merge(target, Riptreaver.TargetCallStats.transfer_counters(target)))
      {:error, changeset} ->
        conn
        |> put_status(:unprocessable_entity)
        |> render(ErrorView, :"422", changeset: changeset)
    end
  end

  def policy(%{current_user: %{role: :admin}}, :target_group), do: :ok

  def policy(%{current_user: %{role: :advertiser, account: %{id: account_id}},
    target_group: %{account_id: account_id}}, :target_group), do: :ok

  defp load_target_group(conn, _options) do
    %{"id" => id} = conn.params

    target_group =
      conn
      |> account
      |> Account.get_target_group!(id)
      |> Repo.preload(:targets)

    assign(conn, :target_group, target_group)
  end

  defp load_target_groups(conn, _options) do
    target_groups =
      conn
      |> account
      |> Account.list_target_groups
      |> Repo.preload(:targets)

    assign(conn, :target_groups, target_groups)
  end

  defp account(conn) do
    conn.assigns.current_user.account
  end
end

```