Execute authorized actions in a composable way.

An Action can be built up over the course of a request, providing a means to specify authorization parameters in the steps leading up to actually executing the job.

When authorization fails, there is an opportunity to handle it using a fallback function before returning the final result.

Authorization is performed by deferring to a Bodyguard.Policy.

Fields

• :context – Context for the action
• :policy – Implementation of Bodyguard.Policy behaviour; defaults to the :context
• :user – The user to authorize
• :name – The name of the authorized action
• :auth_run? – If an authorization check has been performed
• :auth_result – Result of the authorization check
• :authorized? – If authorization has succeeded (default false)
• :job – Function to execute if authorization passes; signature job(action)
• :fallback – Function to execute if authorization fails; signature fallback(action)
• :assigns – Generic parameters along for the ride

Controller Example

defmodule MyApp.Web.PostController do
  use MyApp.Web, :controller
  import Bodyguard.Action
  alias MyApp.Blog

  action_fallback MyApp.FallbackController
  plug Bodyguard.Plug.BuildAction, context: Blog, user: &get_current_user/1

  def index(conn, _) do
    run conn.assigns.action, fn(action) ->
      posts = Blog.list_posts(action.user)
      render(conn, "index.html", posts: posts)
    end
  end

  defp get_current_user(conn) do
    # ...
  end
end

Verbose Example

import Bodyguard.Action
alias MyApp.Blog

act(Blog)
|> put_user(get_current_user())
|> put_policy(Blog.SomeSpecialPolicy)
|> assign(:drafts, true)
|> authorize(:list_posts)
|> put_job(fn action ->
  Blog.list_posts(action.user, drafts_only: action.assigns.drafts)
end)
|> put_fallback(fn _action -> {:error, :not_found} end)
|> run()