SessionPlug.ex

defmodule Server.SessionPlug do
  @behaviour Plug
  import Plug.Conn

  require Logger

  def init(opts), do: opts

  def call(conn, _) do
    Logger.info "SessionPlug: Looking for session for player"
    player = conn |> get_session(:player)
    if player do
        Logger.info "Found player! #{inspect player.id}"
        conn |> assign(:token, Phoenix.Token.sign(Server.Endpoint, "token", player.email))
    else
        conn
    end
  end
end

the thing that sets the things:

def login(conn, player) do
    Logger.info "logging in: #{inspect player.email}"
    token = Phoenix.Token.sign(Server.Endpoint, "token", player.email)

    conn = configure_session(conn, renew: true)
    conn = put_session(conn, :player, player)
    Logger.info "Session player: #{inspect get_session(conn, :player)}"
    conn = put_session(conn, :player_id, player)
    Logger.info "Session player_id: #{inspect get_session(conn, :player_id)}"
    conn = put_session(conn, :token, token)
    Logger.info "Session token: #{inspect get_session(conn, :token)}"
    conn = assign(conn, :token, token)
  end

defmodule Server.IndexController do
  use Server.Web, :controller
  alias Server.Router.Helpers
  alias Server.Player

  require Logger

  def index(conn, _params) do
    render conn, "index.html"
  end

  def login_form(conn, _) do
    conn = conn |> fetch_session
    IO.inspect get_session(conn, :token)
    changeset = Player.changeset(%Player{}, %{})
    render conn, "login.html", changeset: changeset
  end

  def play(conn, _) do
    Logger.info "#{inspect conn.assigns}"
    render conn, "play.html", %{token: get_session(conn, :token)}
  end

  def about(conn, _) do
    render conn, "about.html"
  end

  def signup(conn, _) do
    changeset = Player.new_account(%Player{}, %{})
    render conn, "signup.html", changeset: changeset
  end

  def register(conn, %{"player" => player_params}) do
    changeset = Player.new_account(%Player{}, player_params)

    case Repo.insert(changeset) do
      {:ok, _class} ->
        conn
        |> put_flash(:info, "Account Created!")
        |> redirect(to: index_path(conn, :index))
      {:error, changeset} ->
        conn
        |> put_flash(:error, "Cant create an account with those details.")
        render(conn, "signup.html", changeset: changeset)
    end
  end

  def login(conn, %{"player" => player}) do
    Logger.info "attemping to login as #{inspect player["email"]}"

      case Server.Repo.get_by(Player, email: player["email"]) do
        user ->
            Logger.info "\n\nFound user! #{inspect user.email}"
            Server.Auth.login(conn, user)

            # redirect conn, to: "/play"
            conn |> put_flash(:info, "You have logged in, #{user.email}")
            render conn, "login.html", %{changeset: Player.new_account(%Player{}, player)}

        {:error, _} ->
            conn |> put_flash(:error, "unable to log the user in, no record found")
            Logger.info "\n\nCould not find user, passed through."
            conn.put_flash(:error, "unable to find an account. Sorry.")
            render conn, "login.html"

        nil ->
          conn |> put_flash(:info, "unable to log the user in, no record found")
          render conn, "login.html"
      end
  end

  def logout(conn, _) do
    Server.Auth.logout(conn)
    conn.redirect(to: Helpers.index_path(conn, :index))
    conn.halt()
  end
end

  pipeline :browser do
    plug :accepts, ["html"]
    plug :fetch_session
    plug :fetch_flash
    plug :protect_from_forgery
    plug :put_secure_browser_headers
    plug Server.SessionPlug, repo: Server.Repo
  end