$ mix phx.new auth0_sample --live

- {:plug_cowboy, "~> 2.0"}
+ {:plug_cowboy, "~> 2.0"},
+ {:ueberauth, "~> 0.7.0"},
+ {:ueberauth_auth0, "~> 1.0"}
 ]

$ cd auth0_sample
$ mix setup

config :ueberauth, Ueberauth,
 providers: [
 auth0: {Ueberauth.Strategy.Auth0, []}
 ]

config :ueberauth, Ueberauth.Strategy.Auth0.OAuth,
 domain: System.get_env("AUTH0_DOMAIN"),
 client_id: System.get_env("AUTH0_CLIENT_ID"),
 client_secret: System.get_env("AUTH0_CLIENT_SECRET")

+ import Auth0SampleWeb.UserAuth
+
 pipeline :browser do
 plug :accepts, ["html"]
 plug :fetch_session
@@ -8,16 +10,32 @@ defmodule Auth0SampleWeb.Router do
 plug :put_root_layout, {Auth0SampleWeb.LayoutView, :root}
 plug :protect_from_forgery
 plug :put_secure_browser_headers
+ plug :fetch_current_user # 文字通りcurrent_userを注入します。UserAuth(後述)に実装します。
 end
 
 pipeline :api do
 plug :accepts, ["json"]
 end
 
# Auth0関連のパスです
+ scope "/auth", Auth0SampleWeb do
+ pipe_through :browser
+
+ get "/:provider", AuthController, :request
+ get "/:provider/callback", AuthController, :callback
+ post "/:provider/callback", AuthController, :callback
+ delete "/logout", AuthController, :delete
+ end
+
 scope "/", Auth0SampleWeb do
 pipe_through :browser
 
- live "/", PageLive, :index
+ live "/", HomeLive, :index, session: {Auth0SampleWeb.Helpers, :keep_current_user, []} # ルートパス
+ end
+
+ scope "/", Auth0SampleWeb do
# /pageへのアクセスにはauthenticated_userを必要としています。UserAuth(後述)にrequire_authenticated_userを実装しています。
+ pipe_through [:browser, :require_authenticated_user]
+
+ live "/page", PageLive, :index
 end

defmodule Auth0SampleWeb.AuthController do
 @moduledoc """
 Auth controller responsible for handling Ueberauth responses
 """

 use Auth0SampleWeb, :controller

 plug Ueberauth

 alias Ueberauth.Strategy.Helpers
 alias Auth0Sample.UserFromAuth

 def request(conn, _params) do
 render(conn, "request.html", callback_url: Helpers.callback_url(conn))
 end

 def delete(conn, _params) do
 conn
 |> put_flash(:info, "You have been logged out!")
 |> clear_session()
 |> redirect(to: "/")
 end

 def callback(%{assigns: %{ueberauth_failure: _fails}} = conn, _params) do
 conn
 |> put_flash(:error, "Failed to authenticate.")
 |> redirect(to: "/")
 end

 def callback(%{assigns: %{ueberauth_auth: auth}} = conn, _params) do
 case UserFromAuth.find_or_create(auth) do
 {:ok, user} ->
 conn
 |> put_flash(:info, "Successfully authenticated.")
 |> put_session(:current_user, user)
 |> configure_session(renew: true)
 |> redirect(to: "/")

 {:error, reason} ->
 conn
 |> put_flash(:error, reason)
 |> redirect(to: "/")
 end
 end
end

defmodule Auth0Sample.UserFromAuth do
 @moduledoc """
 Retrieve the user information from an auth request
 """
 require Logger
 require Jason

 alias Ueberauth.Auth

 def find_or_create(%Auth{provider: :identity} = auth) do
 case validate_pass(auth.credentials) do
 :ok ->
 {:ok, basic_info(auth)}

 {:error, reason} ->
 {:error, reason}
 end
 end

 def find_or_create(%Auth{} = auth) do
 {:ok, basic_info(auth)}
 end

 # github does it this way
 defp avatar_from_auth(%{info: %{urls: %{avatar_url: image}}}), do: image

 # facebook does it this way
 defp avatar_from_auth(%{info: %{image: image}}), do: image

 # default case if nothing matches
 defp avatar_from_auth(auth) do
 Logger.warn("#{auth.provider} needs to find an avatar URL!")
 Logger.debug(Jason.encode!(auth))
 nil
 end

 defp basic_info(auth) do
 %{id: auth.uid, name: name_from_auth(auth), avatar: avatar_from_auth(auth)}
 end

 defp name_from_auth(auth) do
 if auth.info.name do
 auth.info.name
 else
 name =
 [auth.info.first_name, auth.info.last_name]
 |> Enum.filter(&(&1 != nil and &1 != ""))

 if Enum.empty?(name) do
 auth.info.nickname
 else
 Enum.join(name, " ")
 end
 end
 end

 defp validate_pass(%{other: %{password: nil}}) do
 {:error, "Password required"}
 end

 defp validate_pass(%{other: %{password: pw, password_confirmation: pw}}) do
 :ok
 end

 defp validate_pass(%{other: %{password: _}}) do
 {:error, "Passwords do not match"}
 end

 defp validate_pass(_), do: {:error, "Password Required"}
end

defmodule Auth0SampleWeb.UserAuth do
 import Plug.Conn
 import Phoenix.Controller

 def fetch_current_user(conn, _opts) do
 user = get_session(conn, :current_user)
 assign(conn, :current_user, user)
 end

 def require_authenticated_user(conn, _opts) do
 if conn.assigns[:current_user] do
 conn
 else
 conn
 |> put_flash(:error, "You must log in to access this page.")
 |> redirect(to: "/")
 |> halt()
 end
 end
end

<ul>
<%= if @current_user do %>
 <li><%= @current_user.name %></li>
 <li><%= link "Logout", to: Routes.auth_path(@conn, :delete), method: "delete", class: "button" %></li>
<% else %>
 <li><%= link "Log in", to: Routes.auth_path(@conn, :request, "auth0") %></li>
<% end %>
</ul>

 <li><%= link "LiveDashboard", to: Routes.live_dashboard_path(@conn, :home) %></li>
 <% end %>
 </ul>
+ <%= render "_user_menu.html", assigns %>
 </nav>
 <a href="https://phoenixframework.org/" class="phx-logo">
 <img src="<%= Routes.static_path(@conn, "/images/phoenix.png") %>" alt="Phoenix Framework Logo"/>

defmodule Auth0SampleWeb.HomeLive do
 use Auth0SampleWeb, :live_view

 def mount(_params, %{"current_user" => current_user}, socket) do
 {:ok, assign(socket, current_user: current_user)}
 end

 def render(assigns) do
 ~L"""
 <section class="phx-hero">
 <h1>Überauth + Phoenix Example</h1>
 <p>
 This is an application to show an example of how to wire up
 <a href="https://github.com/ueberauth/ueberauth">Überauth</a> with
 <a href="https://github.com/phoenixframework/phoenix">Phoenix</a>.
 </p>
 <%= if @current_user do %>
 <h2>Welcome, <%= @current_user.name %>!</h2>
 <div>
 <img src="<%= @current_user.avatar %>" />
 </div>
 <%= link "page", to: "/page" %>
 <br>
 <% else %>
 <h2>Please log in !!!</h2>
 <% end %>
 </section>
 """
 end
end

defmodule Auth0SampleWeb.Helpers do
 def keep_current_user(conn) do
 %{"current_user" => conn.assigns.current_user}
 end
end

AUTH0_DOMAIN="Settingsタブの値そのまま" \
AUTH0_CLIENT_ID="Settingsタブの値そのまま" \
AUTH0_CLIENT_SECRET="Settingsタブの値そのまま" \
mix phx.server