Mastering Backend Development with Phoenix and Erlang

get "/users", UserController, :index
# in a controller
render(conn, "index.html", message: "Hello, world!")

# in a view
def render("index.html", %{message: message}) do
  "<h1>#{message}</h1>"
end
# in a controller
render(conn, "index.html", layout: {MyApp.LayoutView, "default.html"})

# in a layout view
def render("default.html", assigns) do
  "<html><head>...</head><body>#{render(assigns)}</body></html>"
end
# in a template
<div class="comments">
  <%= render("_comment.html", comment: @comment) %>
</div>

# in a partial template
<div class="comment">
  <h2><%= comment.author %></h2>
  <p><%= comment.content %></p>
</div>
defmodule MyApp.User do
  use Ecto.Schema

  schema "users" do
    field :name, :string
    field :email, :string
    has_many :posts, MyApp.Post
  end
end
config :my_app, MyApp.Repo,
  adapter: Ecto.Adapters.Postgres,
  username: "postgres",
  password: "password",
  database: "my_app_dev",
  hostname: "localhost"
alias MyApp.{User, Repo}

user_params = %{name: "Alice", email: "alice@example.com"}
changeset = User.changeset(%User{}, user_params)
Repo.insert(changeset)
user = Repo.get(User, 1)
changeset = User.changeset(user, %{name: "Bob"})
Repo.update(changeset)
mix ecto.gen.migration create_users
priv/repo/migrations/20230429153420_create_users.exs
def up do
  create table(:users) do
    add :name, :string
    add :email, :string
    timestamps()
  end
end
mix ecto.migrate
query = from u in User, select: u
Repo.all(query)
user = %User{name: "Alice", email: "alice@example.com"}
Repo.insert(user)
user = Repo.get(User, 1)
user = %{user | name: "Bob"}
Repo.update(user)
user = Repo.get(User, 1)
Repo.delete(user)
schema "comments" do
  belongs_to :post, Post
  # ...
end
post = Repo.get(Post, 1)
comments = Repo.all(from c in Comment, where: c.post_id == ^post.id)
config :my_app, MyApp.Repo,
  database: "my_app_dev",
  username: "postgres",
  password: "password",
  hostname: "localhost"
Repo.all(from u in User)
changeset = User.changeset(%User{}, %{name: "John Doe", email: "johndoe@example.com"})
Repo.insert(changeset)
Repo.transaction(fn ->
  changeset = User.changeset(%User{}, %{name: "John Doe", email: "johndoe@example.com"})
  user = Repo.insert(changeset)

  session_changeset = Session.changeset(%Session{}, %{user_id: user.id, token: "abc123"})
  Repo.insert(session_changeset)
end)
get_first_element({X, _}) ->
    X.
scope "/api", MyApp do
  pipe_through :api

  resources "/books", BookController
end
defmodule MyApp.BookController do
  use MyApp.Web, :controller

  def index(conn, _params) do
    books = MyApp.Repo.all(Book)
    render(conn, %{data: books})
  end

  def show(conn, %{"id" => id}) do
    book = MyApp.Repo.get(Book, id)
    case book do
      nil -> render(conn, %{error: "Book not found"}, status: :not_found)
      _ -> render(conn, %{data: book})
    end
  end

  def create(conn, %{"title" => title, "author" => author}) do
    changeset = Book.changeset(%Book{}, %{title: title, author: author})
    case MyApp.Repo.insert(changeset) do
      {:ok, book} ->
        render(conn, %{data: book}, status: :created)
      {:error, changeset} ->
        render(conn, %{error: changeset.errors}, status: :unprocessable_entity)
    end
  end

  def update(conn, %{"id" => id, "title" => title, "author" => author}) do
    book = MyApp.Repo.get(Book, id)
    changeset = Book.changeset(book, %{title: title, author: author})
    case MyApp.Repo.update(changeset) do
      {:ok, book} ->
        render(conn, %{data: book})
      {:error, changeset} ->
        render(conn, %{error: changeset.errors}, status: :unprocessable_entity)
    end
  end

  def delete(conn, %{"id" => id}) do
    book = MyApp.Repo.get(Book, id)
    case MyApp.Repo.delete(book) do
      {:ok, _} ->
        send_resp(conn, :no_content, "")
      {:error, _} ->
        render(conn, %{error: "Failed to delete book"}, status: :internal_server_error)
    end
  end
end
def create(conn, %{"book" => book_params}) do
  changeset = Book.changeset(%Book{}, book_params)

  case Repo.insert(changeset) do
    {:ok, book} ->
      conn
      |> put_status(:created)
      |> put_resp_header("location", book_path(conn, :show, book))
      |> render("show.json", book: book)
    {:error, changeset} ->
      conn
      |> put_status(:unprocessable_entity)
      |> render(BooksWeb.ChangesetView, "error.json", changeset: changeset)
  end
end
curl -X POST -H "Content-Type: application/json" \
-d '{"title": "The Catcher in the Rye", "author": "J.D. Salinger", "description": "A classic novel about teenage angst."}' \
http://localhost:4000/api/books
HTTP/1.1 201 Created
cache-control: max-age=0, private, must-revalidate
content-length: 98
content-type: application/json; charset=utf-8
date: Fri, 29 Apr 2023 10:00:00 GMT
location: /api/books/1
server: Cowboy
x-request-id: 1

{
  "data": {
    "author": "J.D. Salinger",
    "description": "A classic novel about teenage angst.",
    "id": 1,
    "title": "The Catcher in the Rye"
  }
}
defmodule MyAppWeb.BookController do
  use MyAppWeb, :controller

  def index(conn, _params) do
    books = MyApp.Repo.all(MyApp.Book)
    render(conn, "index.json", data: books)
  end
end
defmodule MyAppWeb.BookController do
  use MyAppWeb, :controller

  def show(conn, %{"id" => id}) do
    book = MyApp.Repo.get(MyApp.Book, id)

    if book do
      render(conn, "show.json", data: book)
    else
      conn
      |> put_status(404)
      |> render("error.json", message: "Book not found")
      |> halt()
    end
  end
end
defmodule MyAppWeb.AuthPlug do
  import Plug.Conn

  def init(opts), do: opts

  def call(conn, _opts) do
    case get_req_header(conn, "authorization") do
      "Bearer " <> token ->
        case MyApp.Auth.validate_token(token) do
          {:ok, user_id} ->
            conn
            |> assign(:current_user, MyApp.Users.get_user(user_id))
            |> assign(:current_token, token)
          _ ->
            conn |> send_resp(401, "Invalid token")
        end
      _ ->
        conn |> send_resp(401, "Missing token")
    end
  end
end
defmodule MyAppWeb.Router do
  use Phoenix.Router

  pipeline :api do
    plug :accepts, ["json"]
    plug MyAppWeb.AuthPlug
  end

  scope "/api", MyAppWeb do
    pipe_through :api

    resources "/books", BookController
  end
end
def index(conn, _params) do
  users = Repo.all(User)
  render(conn, "index.json", data: users)
end
<%= render_many @data, UserView, "user.json" %>
{
  "id": <%= user.id %>,
  "name": "<%= user.name %>",
  "email": "<%= user.email %>"
}
defmodule MyAppWeb.ChatChannel do
  use Phoenix.Channel

  def join("room:" <> room_id, _params, socket) do
    {:ok, socket |> assign(:room_id, room_id)}
  end

  def handle_in("new_message", %{"text" => text}, socket) do
    broadcast(socket, "new_message", %{text: text})
    {:noreply, socket}
  end
end
def handle_in("new_message", %{"body" => body}, socket) do
  # create a new message in the database
  message = create_message(body)

  # broadcast the message to all connected clients
  broadcast! socket, "new_message", %{id: message.id, body: message.body}

  # return the updated socket
  {:ok, socket}
end
defmodule MyApp.RoomChannel do
  use Phoenix.Channel

  def join("room:" <> room_id, _params, socket) do
    # Join the topic for the given room ID
    {:ok, socket |> Phoenix.Channel.subscribe("room:" <> room_id)}
  end

  def handle_in("message", %{"body" => message_body}, socket) do
    # Broadcast the message to all clients subscribed to the topic
    Phoenix.PubSub.broadcast("room:" <> socket.topic, "new_message", %{body: message_body})

    {:reply, :ok, socket}
  end
end
defmodule MyApp.Web.Endpoint do
  use Phoenix.Endpoint

  # ...

  def broadcast_message(message) do
    # Broadcast the message to all connected clients
    MyApp.Web.Endpoint.broadcast!(MyApp.Web.Endpoint, "new_message", %{body: message})
  end
end
# lib/my_app/application.ex

defmodule MyApp.Application do
  use Application

  def start(_type, _args) do
    children = [
      # ...
      {Phoenix.Presence, name: MyApp.Presence}
    ]

    # ...
  end
end
# web/channels/my_channel.ex

defmodule MyApp.MyChannel do
  use Phoenix.Channel

  def join("room:" <> room_id, _message, socket) do
    # Track the presence of the client in the given room
    {:ok, _} = Phoenix.Presence.track(
      socket.assigns.user_id, # Process identifier of the client
      "user:#{socket.assigns.user_id}", # Unique identifier of the client
      %{name: socket.assigns.user_name} # Metadata associated with the client
    )

    # ...
  end

  # ...
end
# web/channels/my_channel.ex

defmodule MyApp.MyChannel do
  use Phoenix.Channel

  def join("room:" <> room_id, _message, socket) do
    # Track the presence of the client in the given room
    {:ok, _} = Phoenix.Presence.track(
      socket.assigns.user_id, # Process identifier of the client
      "user:#{socket.assigns.user_id}", # Unique identifier of the client
      %{name: socket.assigns.user_name} # Metadata associated with the client
    )

    # Get a list of all the clients currently connected to the server
    {:ok, clients} = Phoenix.Presence.list("room:#{room_id}")
    IO.inspect clients

    # ...
  end

  # ...
end
defmodule MyApp.MyChannel do
  use Phoenix.Channel

  def socket(conn, params, _session) do
    {:ok, %{user_id: params["user_id"]}, topic: "room:123"}
  end

  # ...
end
defmodule MyApp.MyChannel do
  use Phoenix.Channel

  def join("room:" <> room_id, _params, _socket) do
    # Track the presence of the client in the room topic
    Presence.track(socket, "room:#{room_id}", socket.assigns.user_id, %{username: "Alice"})
    {:ok, socket}
  end

  def handle_info(:after_join, socket) do
    # Get a list of all clients that are currently present in the room topic
    users = Presence.list(socket, "room:#{socket.assigns.room_id}")

    # Broadcast a message to all clients in the room topic
    MyApp.Endpoint.broadcast("room:#{socket.assigns.room_id}", "new_user", %{users: users})
    {:noreply, socket}
  end

  def handle_info(:leave, socket) do
    # Remove the client from the presence data for the room topic
    Presence.untrack(socket, "room:#{socket.assigns.room_id}", socket.assigns.user_id)
    {:noreply, socket}
  end

  # ...
end
defp deps do
  [
    # other dependencies
    {:absinthe, "~> 1.5.0"},
    {:absinthe_plug, "~> 1.5.0"}
  ]
end
mix phx.gen.schema --binary-id --migration \
  Post posts title:string content:string
mix ecto.migrate
defmodule MyAppWeb.GraphQL.Schema do
  use Absinthe.Schema
  import_types Absinthe.Plug.Types

  alias MyApp.Repo

  query do
    field :post, type: :post do
      arg :id, non_null(:id)
      resolve &MyApp.PostResolver.get_post/2
    end

    field :posts, list_of(:post) do
      resolve &MyApp.PostResolver.get_posts/2
    end
  end

  object :post do
    field :id, non_null(:id)
    field :title, non_null(:string)
    field :content, non_null(:string)
  end
end
defmodule MyApp.PostResolver do
  alias MyApp.Post

  def get_post(_, %{id: id}) do
    {:ok, Post.get!(id)}
  end

  def get_posts(_, _) do
    {:ok, Post.list()}
  end
end
defmodule MyAppWeb.GraphQLController do
  use MyAppWeb, :controller

  alias MyAppWeb.Endpoint
  alias Absinthe.Plug

  plug Plug.Parser
  plug Plug.ContentType, "application/json"
  plug Plug.Parsers, parsers: [:urlencoded, :multipart, :json]
  plug Plug.Plug.Logger

  def index(conn, _params) do
    Absinthe.Plug.execute(Endpoint, %{query: conn.body_params["query"]})
    |> send response(conn, 200)
  end
end
defmodule Blog.Schema do
  use Absinthe.Schema.Notation

  object :post do
    field :id, :id
    field :title, :string
    field :body, :string
    field :author, :user
    field :comments, list_of(:comment)
  end

  object :user do
    field :id, :id
    field :name, :string
    field :email, :string
    field :posts, list_of(:post)
  end

  object :comment do
    field :id, :id
    field :body, :string
    field :author, :user
    field :post, :post
  end

  query do
    field :post, :post do
      arg :id, non_null(:id)
      resolve &Blog.Resolvers.post/2
    end

    field :user, :user do
      arg :id, non_null(:id)
      resolve &Blog.Resolvers.user/2
    end
  end
end
defmodule Blog.Resolvers do
  def post(_root, %{id: id}, _info) do
    Blog.Post.get!(id)
  end

  # ...
end
type Query {
  post(id: ID!): Post
  allPosts: [Post]
}

type Post {
  id: ID!
  title: String!
  body: String!
  author: Author!
}

type Author {
  id: ID!
  name: String!
  posts: [Post]
}
query {
  post(id: "1") {
    id
    title
    body
    author {
      name
    }
  }
}
{
  "data": {
    "post": {
      "id": "1",
      "title": "My first post",
      "body": "Lorem ipsum dolor sit amet.",
      "author": {
        "name": "John Doe"
      }
    }
  }
}
type Mutation {
  createUser(name: String!, email: String!, password: String!): User!
}
def create_user(%{name: name, email: email, password: password}) do
  changeset = User.changeset(%User{}, %{name: name, email: email, password: password})

  case Repo.insert(changeset) do
    {:ok, user} -> {:ok, user}
    {:error, changeset} -> {:error, changeset}
  end
end
type Subscription {
  newUser: User!
}
def new_user(_, _params, _info) do
  events = User |> Ecto.Query.stream() |> Stream.map(&{:ok, &1})
  {:ok, events}
end
defmodule MyAppWeb.Schema.Subscription do
  use Absinthe.Schema.Notation

  alias MyAppWeb.PubSub, as: PS

  subscription :new_message do
    field :message, :string

    resolve &handle_new_message/2
  end

  def handle_new_message(_args, _info) do
    {:ok, socket} = Absinthe.Phoenix.Socket.subscribe(PS, "room:1")
    {:ok, socket}
  end
end
defmodule MyAppWeb.PubSub do
  use Absinthe.Phoenix.PubSub

  def handle_info({:new_message, message}, socket) do
    Absinthe.Phoenix.Socket.broadcast!(socket, "new_message", %{message: message})
    {:noreply, socket}
  end
end
interface Account {
  id: ID!
  name: String!
  email: String!
}

type User implements Account {
  id: ID!
  name: String!
  email: String!
  friends: [User!]!
}

type Group implements Account {
  id: ID!
  name: String!
  email: String!
  members: [User!]!
}

type Event implements Account {
  id: ID!
  name: String!
  email: String!
  attendees: [User!]!
}
union Message = TextMessage | ImageMessage | VideoMessage

type TextMessage {
  id: ID!
  text: String!
  sender: User!
  recipients: [User!]!
}

type ImageMessage {
  id: ID!
  imageUrl: String!
  sender: User!
  recipients: [User!]!
}

type VideoMessage {
  id: ID!
  videoUrl: String!
  sender: User!
  recipients: [User!]!
}
defmodule MyApp.JobQueue do
  use GenServer

  def start_link(_) do
    GenServer.start_link(__MODULE__, %{})
  end

  def init(state) do
    {:ok, state}
  end

  def enqueue_job(job) do
    GenServer.cast(__MODULE__, {:enqueue, job})
  end

  def handle_cast({:enqueue, job}, state) do
    new_state = Map.put(state, :jobs, [job | state[:jobs]])
    {:noreply, new_state}
  end

  def get_next_job() do
    GenServer.call(__MODULE__, :get_next_job)
  end

  def handle_call(:get_next_job, _from, %{jobs: []} = state) do
    {:reply, nil, state}
  end

  def handle_call(:get_next_job, _from, %{jobs: [job | rest]} = state) do
    new_state = Map.put(state, :jobs, rest)
    {:reply, job, new_state}
  end
end
defp deps do
  [
    # other dependencies
    {:exq, "~> 0.15.0"},
    {:redis, "~> 0.10.0"}
  ]
end
config :exq,
  name: MyApp.Exq,
  host: "localhost",
  port: 6379,
  database: 0,
  concurrency: 10,
  queues: ["default"],
  poll_interval: 250
Exq.enqueue("default", "MyApp.Worker", [arg1, arg2, arg3])
defmodule MyApp.Worker do
  use Exq.Worker

  def perform(args) do
    # job logic
  end
end
defmodule MyApp.Worker do
  use Exq.Worker, retry: 3, batch: 10, rate_limit: {5, :minute}

  def perform(args) do
    # job logic
  end
end
mix phx.new my_payment_app
defp deps do
  [
    {:stripe, "~> 2.17"}
  ]
end
mix deps.get
mix phx.gen.html Payment Payment payments amount:integer status:string
defmodule MyPaymentAppWeb.PaymentController do
  use MyPaymentAppWeb, :controller
  require Logger

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

  def create(conn, %{"payment" => payment_params}) do
    amount = payment_params["amount"]
    Logger.info("Creating a payment for amount #{amount}")

    # Call Stripe API to create a payment
    stripe_session = Stripe.checkout_session_create(
      success_url: "https://example.com/success",
      cancel_url: "https://example.com/cancel",
      payment_method_types: ["card"],
      line_items: [
        %{
          name: "Payment",
          amount: amount,
          currency: "usd",
          quantity: 1
        }
      ],
      mode: "payment"
    )

    # Redirect the user to the Stripe checkout page
    redirect(conn, external: stripe_session["url"])
  end
end
defmodule MyPaymentAppWeb.Router do
  use MyPaymentAppWeb, :router

  # ...

  scope "/", MyPaymentAppWeb do
    pipe_through :browser # Use the default browser stack

    get "/", PaymentController, :index
    post "/payments", PaymentController, :create
  end

  # ...
end
mix phx.server
mix phx.new <app_name>
cd <app_name>
mix ecto.create
mix phx.server
{:stripity_stripe, "~> 4.4.0"}
mix deps.get
<h2>New Payment</h2>

<%= form_for @conn, Routes.payment_path(@conn, :create), [method: :post], fn f -> %>
  <div class="form-group">
    <%= label f, :amount, "Amount ($)" %>
    <%= number_field f, :amount, step: "any", class: "form-control" %>
  </div>

  <div class="form-group">
    <%= label f, :card_number, "Card Number" %>
    <%= text_input f, :card_number, class: "form-control" %>
  </div>

  <div class="form-group">
    <%= label f, :exp_month, "Expiration Month" %>
    <%= text_input f, :exp_month, class: "form-control" %>
  </div>

  <div class="form-group">
    <%= label f, :exp_year, "Expiration Year" %>
    <%= text_input f, :exp_year, class: "form-control" %>
  </div>

  <div class="form-group">
    <%= label f, :cvc, "CVC" %>
    <%= text_input f, :cvc, class: "form-control" %>
  </div>

  <%= submit "Pay", class: "btn btn-primary" %>
<% end %>
defmodule MyAppWeb.PaymentController do
  use MyAppWeb, :controller

  def new(conn, _params) do
    render conn, "new.html"
  end
end
def deps do
  [
    # ...
    {:stripity_stripe, "~> 4.0"}
  ]
end
defmodule MyApp.PaymentController do
  use MyApp.Web, :controller

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

  def create(conn, %{"stripeToken" => stripe_token}) do
    case Stripe.Charge.create(amount: 1000, currency: "usd", source: stripe_token) do
      {:ok, _charge} ->
        conn
        |> put_flash(:info, "Payment successful")
        |> redirect(to: page_path(conn, :index))

      {:error, %{message: message}} ->
        conn
        |> put_flash(:error, message)
        |> redirect(to: page_path(conn, :index))
    end
  end
end
<h2>Make a payment</h2>

<%= form_for @conn, page_path(@conn, :create), [method: :post] %>
  <script
    src="https://checkout.stripe.com/checkout.js" class="stripe-button"
    data-key="<%= System.get_env("STRIPE_PUBLISHABLE_KEY") %>"
    data-amount="1000"
    data-name="My App"
    data-description="One-time payment"
    data-image="https://stripe.com/img/documentation/checkout/marketplace.png"
    data-locale="auto">
  </script>
<% end %>
scope "/", MyApp do
  # ...
  get "/payments/new", PaymentController, :new
  post "/payments", PaymentController, :create
end
<script src="https://js.stripe.com/v3/"></script>
<script>
  var stripe = Stripe('your_publishable_key');
  var elements = stripe.elements();
  var cardElement = elements.create('card');
  cardElement.mount('#card-element');
</script>
<script>
  var form = document.getElementById('payment-form');
  form.addEventListener('submit', function(event) {
    event.preventDefault();
    stripe.createToken(cardElement).then(function(result) {
      if (result.error) {
        // Handle error
      } else {
        // Send token to server for processing
      }
    });
  });
</script>
<script src="https://js.stripe.com/v3/"></script>
<form action="/charge" method="post" id="payment-form">
  <div class="form-group">
    <label for="card-element">Credit or debit card</label>
    <div id="card-element"></div>
    <div id="card-errors" role="alert"></div>
  </div>

  <div class="form-group">
    <label for="amount">Amount (USD)</label>
    <input type="text" id="amount" name="amount" class="form-control" required>
  </div>

  <button type="submit" class="btn btn-primary">Submit Payment</button>
</form>
<script>
  var stripe = Stripe('YOUR_PUBLISHABLE_KEY');
  var elements = stripe.elements();

  var card = elements.create('card');
  card.mount('#card-element');

  card.addEventListener('change', function(event) {
    var displayError = document.getElementById('card-errors');
    if (event.error) {
      displayError.textContent = event.error.message;
    } else {
      displayError.textContent = '';
    }
  });

  var form = document.getElementById('payment-form');
  form.addEventListener('submit', function(event) {
    event.preventDefault();

    stripe.createToken(card).then(function(result) {
      if (result.error) {
        var errorElement = document.getElementById('card-errors');
        errorElement.textContent = result.error.message;
      } else {
        stripeTokenHandler(result.token);
      }
    });
  });

  function stripeTokenHandler(token) {
    var form = document.getElementById('payment-form');
    var amountElement = document.getElementById('amount');
    var amount = amountElement.value * 100;

    var hiddenInput = document.createElement('input');
    hiddenInput.setAttribute('type', 'hidden');
    hiddenInput.setAttribute('name', 'stripeToken');
    hiddenInput.setAttribute('value', token.id);
    form.appendChild(hiddenInput);

    var hiddenAmountInput = document.createElement('input');
    hiddenAmountInput.setAttribute('type', 'hidden');
    hiddenAmountInput.setAttribute('name', 'amount');
    hiddenAmountInput.setAttribute('value', amount);
    form.appendChild(hiddenAmountInput);

    form.submit();
  }
</script>
defmodule MyApp.PaymentController do
  use MyApp.Web, :controller
  require Stripe

  def charge(conn, %{"stripeToken" => token, "amount" => amount}) do
    Stripe.api_key = System.get_env("STRIPE_SECRET_KEY")
    case Stripe.Charge.create([amount: amount, currency: "usd", source: token]) do
      {:ok, _charge} ->
        conn
        |> put_status(200)
        |> json(%{message: "Payment successful"})
      {:error, %Stripe.Error{message: message}} ->
        conn
        |> put_status(400)
        |> json(%{error: message})
    end
  end
end
def charge_customer(%{ "stripeToken" => token, "amount" => amount }) do
  Stripe.api_key = System.get_env("STRIPE_SECRET_KEY")

  case Charge.create(%{
        "amount" => amount,
        "currency" => "usd",
        "source" => token
      }) do
    {:ok, charge} ->
      IO.puts "Payment successful! Charge ID: #{charge.id}"
    {:error, error} ->
      IO.puts "Payment failed! Error: #{error.message}"
  end
end
mix phx.gen.html Payment Payment payments \
  token:string amount:integer \
  --no-context --no-schema --no-test
defmodule MyAppWeb.PaymentsController do
  use MyAppWeb, :controller

  alias MyApp.Payment

  def create(conn, %{"payment" => %{"token" => token, "amount" => amount}}) do
    Stripe.api_key = System.get_env("STRIPE_SECRET_KEY")
    case Stripe.Charge.create(amount: amount, currency: "usd", source: token) do
      {:ok, _charge} ->
        conn
        |> put_flash(:info, "Payment processed successfully.")
        |> redirect(to: page_path(conn, :index))
      {:error, %{type: type, message: message}} ->
        conn
        |> put_flash(:error, message)
        |> render("new.html")
    end
  end
end
def new(conn, _params) do
  changeset = Payment.changeset(%Payment{})
  render(conn, "new.html", changeset: changeset)
end
defmodule MyAppWeb.PaymentController do
  use MyAppWeb, :controller
  alias MyApp.Payment

  def create(conn, %{"payment" => payment_params}) do
    changeset = Payment.changeset(%Payment{}, payment_params)

    case Repo.insert(changeset) do
      {:ok, payment} ->
        # If payment info is valid, create a charge with Stripe
        charge_params = %{
          "source" => payment_params["stripe_token"],
          "amount" => payment_params["amount"],
          "currency" => "usd",
          "description" => "Payment for MyAppWeb service"
        }

        Stripe.Charge.create(charge_params, System.get_env("STRIPE_SECRET_KEY"))

        conn
        |> put_flash(:info, "Payment successful!")
        |> redirect(to: "/")
      {:error, changeset} ->
        # If payment info is invalid, return an error message to the user
        conn
        |> put_flash(:error, "Payment information is invalid.")
        |> render("new.html", changeset: changeset)
    end
  end
end
def charge(conn, %{"stripeToken" => token, "amount" => amount}) do
  Stripe.api_key = System.get_env("STRIPE_SECRET_KEY")

  amount_cents = Decimal.to_integer(amount * 100)

  case Stripe.Charge.create(%{
    "amount" => amount_cents,
    "currency" => "usd",
    "source" => token
  }) do
    {:ok, charge} ->
      # Payment succeeded, update database or perform other actions
      conn
      |> put_flash(:info, "Payment successful!")
      |> redirect(to: "/")
    {:error, error} ->
      # Payment failed, display error message to user
      conn
      |> put_flash(:error, error.message)
      |> redirect(to: "/checkout")
  end
end
defp deps do
  [
    # ...
    {:stripe, "~> 3.0"}
  ]
end
def charge_payment(amount, token) do
  Stripe.api_key = System.get_env("STRIPE_SECRET_KEY")

  charge_params = %{
    amount: amount,
    currency: "usd",
    source: token,
  }

  case Stripe.Charge.create(charge_params) do
    {:ok, charge} ->
      # Payment was successful
      {:ok, charge.id}

    {:error, %Stripe.Error{message: message}} ->
      # Payment failed
      {:error, message}
  end
end
def authorize_payment(amount, token) do
  Stripe.api_key = System.get_env("STRIPE_SECRET_KEY")

  token_params = %{
    card: %{
      number: token.card_number,
      exp_month: token.expiration_month,
      exp_year: token.expiration_year,
      cvc: token.cvc
    }
  }

  case Stripe.Token.create(token_params) do
    {:ok, %{id: token_id}} ->
      charge_params = %{
        amount: amount,
        currency: "usd",
        source: token_id,
        capture: false
      }

      case Stripe.Charge.create(charge_params) do
        {:ok, charge} ->
          # Authorization was successful
          {:ok, charge.id}

        {:error, %Stripe.Error{message: message}} ->
          # Authorization failed
          {:error, message}
      end

    {:error, %Stripe.Error{message: message}} ->
      # Token creation failed
      {:error, message}
  end
end
def charge_customer(token, amount) do
  {:ok, %{"id" => charge_id}} = Stripe.Charge.create(%{
    "source" => token,
    "amount" => amount,
    "currency" => "usd",
    "capture" => false
  })
  charge_id
end
def capture_charge(charge_id) do
  {:ok, %{"status" => "succeeded"}} = Stripe.Charge.capture(charge_id)
  :ok
end
defmodule MyAppWeb.PaymentController do
  use MyAppWeb, :controller

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

  def create(conn, %{"stripeToken" => token, "amount" => amount}) do
    case charge_customer(token, amount) do
      {:ok, charge_id} ->
        capture_charge(charge_id)
        conn
        |> put_flash(:info, "Payment succeeded!")
        |> redirect(to: page_path(conn, :index))

      _ ->
        conn
        |> put_flash(:error, "Payment failed.")
        |> redirect(to: page_path(conn, :index))
    end
  end
end
def create_authorization(conn, %{"payment_token" => token, "amount" => amount}) do
  Stripe.api_key = System.get_env("STRIPE_SECRET_KEY")

  case Stripe.Charge.create(%{
         amount: amount,
         currency: "usd",
         source: token,
         capture: false
       }) do
    {:ok, %Stripe.Charge{ id: charge_id }} ->
      conn
      |> put_flash(:info, "Payment authorized")
      |> redirect(to: "/payments/#{charge_id}")
    {:error, error} ->
      conn
      |> put_flash(:error, "Payment authorization failed")
      |> render("new.html", error: error.message)
  end
end
def capture_payment(conn, %{"charge_id" => charge_id}) do
  Stripe.api_key = System.get_env("STRIPE_SECRET_KEY")

  case Stripe.Charge.capture(charge_id) do
    {:ok, %Stripe.Charge{ id: captured_charge_id }} ->
      conn
      |> put_flash(:info, "Payment captured")
      |> redirect(to: "/payments/#{captured_charge_id}")
    {:error, error} ->
      conn
      |> put_flash(:error, "Payment capture failed")
      |> render("show.html", error: error.message)
  end
end
<div class="card">
  <div class="card-content">
    <span class="card-title">Payment Details</span>
    <p>Amount: <%= @payment.amount %> <%= @payment.currency %></p>
    <p>Card: **** **** **** <%= @payment.card_last4 %></p>
    <p>Status: <%= @payment.status %></p>
  </div>
  <div class="card-action">
    <% if @payment.status == "succeeded" && !@payment.captured? do %>
      <%= form_for @conn, Routes.payment_path(@conn, :capture_payment, @payment.charge_id), [method: :post], fn f -> %>
        <%= submit "Capture Payment", class: "btn" %>
      <% end %>
    <% end %>
  </div>
</div>
def create(conn, %{"stripeToken" => token, "amount" => amount}) do
  Stripe.api_key = System.get_env("STRIPE_SECRET_KEY")

  charge_params = %{
    "amount" => amount,
    "currency" => "usd",
    "source" => token,
    "capture" => false
  }

  case Stripe.Charge.create(charge_params) do
    {:ok, %{"id" => charge_id}} ->
      # Save the charge ID to the database for later capture
      MyApp.save_charge_id(charge_id)

      conn
      |> put_flash(:info, "Payment authorized. We will capture the payment when your order is shipped.")
      |> redirect(to: "/")

    {:error, %{type: _type, message: message}} ->
      conn
      |> put_flash(:error, message)
      |> render("new.html", amount: amount)
  end
end
def capture_payment(charge_id) do
  Stripe.api_key = System.get_env("STRIPE_SECRET_KEY")

  case Stripe.Charge.capture(charge_id) do
    {:ok, _charge} ->
      # Payment captured successfully
      :ok

    {:error, %{type: _type, message: message}} ->
      # Payment capture failed
      {:error, message}
  end
end
def create(conn, %{"payment" => payment_params}) do
  case Stripe.Charge.create(%{
        "source" => payment_params["stripeToken"],
        "amount" => payment_params["amount"],
        "currency" => "usd",
        "description" => payment_params["description"]
      }) do
    {:ok, %{"id" => charge_id}} ->
      conn
      |> put_flash(:info, "Payment authorized!")
      |> redirect(to: payment_path(conn, :show, charge_id))

    {:error, %Stripe.Error{message: message}} ->
      conn
      |> put_flash(:error, "Payment failed: #{message}")
      |> render("new.html", payment: payment_params)
  end
end

Mastering Backend Development with Phoenix and Erlang

Chapter 1: Introduction to Phoenix and Erlang

Overview of Phoenix and Erlang

The advantages of using Phoenix and Erlang for backend development

Comparison with other backend technologies like Node.js, Ruby on Rails, and Django

Brief history of Phoenix and Erlang

The importance of scalability and fault-tolerance in web applications

Introduction to OTP (Open Telecom Platform) and its role in building fault-tolerant systems

Setting up a development environment for Phoenix and Erlang

Overview of Elixir programming language, which is used to build Phoenix applications

Basic concepts of functional programming, and how they apply to Phoenix and Erlang

An introduction to the Phoenix framework, its architecture, and its key components

Overview of key Phoenix features such as channels, presence, and PubSub

Introduction to the Ecto ORM (Object-Relational Mapper) and its role in database management with Phoenix

Overview of testing and debugging tools for Phoenix and Erlang applications

Conclusion and summary of the chapter

Chapter 2: Understanding the Phoenix Framework

Overview of the Phoenix framework

Comparison of Phoenix with other web frameworks such as Ruby on Rails and Django

Introduction to the MVC (Model-View-Controller) architecture and how it applies to Phoenix

Routing and controllers in Phoenix, including a discussion of Phoenix router, controller actions, and plugs

Views and templates in Phoenix, including an overview of Phoenix templates, layout files, and partials

Introduction to the Ecto ORM (Object-Relational Mapper) and its role in database management with Phoenix

Overview of Ecto models and schemas, and how to create and interact with them

Creating and managing database migrations with Ecto

Using Ecto queries to interact with the database and perform CRUD (Create, Read, Update, Delete) operations

Understanding Ecto associations, and how to use them to represent relationships between different database tables

Introduction to the Repo module, which provides an interface for working with the database

Discussion of common Ecto queries and patterns for working with databases in Phoenix applications

Conclusion and summary of the chapter

Chapter 3: Introduction to Erlang and OTP

Overview of Erlang and OTP

Brief history of Erlang and its key features, including concurrency, distribution, and fault tolerance

Functional programming in Erlang, including an introduction to Erlang syntax and data types

Processes and message passing in Erlang, including a discussion of Erlang processes, message queues, and the actor model of concurrency

Introduction to OTP (Open Telecom Platform) and its role in building fault-tolerant systems

Supervisors and fault tolerance in OTP, including an overview of OTP supervisors, supervisors strategies, and how to use them to manage and recover from failures in distributed systems

Introduction to OTP GenServers, which provide a simple and flexible way to implement concurrent servers in Erlang and Elixir

Discussion of common OTP patterns and best practices for building fault-tolerant and scalable systems with Erlang and OTP

Introduction to the Observer tool, which provides a graphical user interface for monitoring and debugging Erlang systems

Conclusion and summary of the chapter

Chapter 4: Building a RESTful API with Phoenix

Overview of RESTful APIs, including an introduction to REST principles and common HTTP methods

Creating a RESTful API with Phoenix, including a discussion of Phoenix router, controller actions, and plugs

Handling requests and responses in Phoenix, including an overview of request and response structures, and how to handle errors and status codes

Introduction to authentication and authorization in RESTful APIs, including an overview of different authentication mechanisms such as token-based authentication and OAuth2

Implementing authentication and authorization in Phoenix, including an overview of plug-based authentication and how to use it to authenticate API requests

Introduction to JSON API specification, which provides a standardized way of building RESTful APIs

Creating JSON API responses in Phoenix, including an overview of Phoenix’s JSON rendering capabilities and best practices for building efficient and scalable JSON APIs

Discussion of common RESTful API patterns and best practices for designing, building, and testing RESTful APIs with Phoenix

Conclusion and summary of the chapter

Chapter 5: Building Real-time Applications with Phoenix and WebSockets

Overview of WebSockets, including a discussion of the WebSocket protocol and its advantages over traditional HTTP requests

Introduction to Phoenix Channels, which provides a high-level abstraction for building real-time applications with WebSockets

Creating real-time applications with Phoenix and WebSockets, including a discussion of channels, channel topics, and client-server communication

Handling WebSocket events and messages in Phoenix, including an overview of the different types of events and messages that can be sent and received over a WebSocket connection

Broadcasting messages to connected clients in Phoenix, including an overview of broadcasting techniques such as broadcasting to specific topics and broadcasting to all connected clients

Introduction to presence tracking, which allows you to track the presence of clients in a real-time application and respond to changes in the presence data

Implementing presence tracking in Phoenix, including an overview of the Presence module and how to use it to track the presence of clients in a real-time application

Discussion of common real-time application patterns and best practices for designing, building, and testing real-time applications with Phoenix and WebSockets

Conclusion and summary of the chapter

Chapter 6: Scaling and Deploying Phoenix Applications

Overview of scaling and deploying Phoenix applications, including a discussion of common scaling challenges and strategies for addressing them

Load balancing and clustering, including an overview of load balancing techniques such as round-robin load balancing and sticky sessions, and a discussion of clustering techniques such as Erlang clustering and Kubernetes

Deploying Phoenix applications to production, including an overview of deployment strategies such as rolling deployments and blue-green deployments, and a discussion of tools such as Docker and Ansible that can be used to automate deployment

Introduction to monitoring and troubleshooting Phoenix applications, including an overview of monitoring tools such as Prometheus and Grafana, and a discussion of common troubleshooting strategies such as logging and debugging

Implementing monitoring and troubleshooting in Phoenix, including an overview of Phoenix’s built-in monitoring tools and how to use them to monitor and troubleshoot your application

Discussion of common scalability and deployment patterns and best practices for designing, building, and testing scalable and deployable Phoenix applications

Conclusion and summary of the chapter

Chapter 7: Introduction to GraphQL

Overview of GraphQL, including a discussion of its benefits and how it differs from traditional REST APIs

Creating a GraphQL API with Phoenix, including an overview of the Phoenix GraphQL library and how to use it to create a GraphQL API

Defining GraphQL Schemas and Resolvers

Conclusion

Querying data with GraphQL, including an introduction to GraphQL queries and how to use them to retrieve data from a GraphQL API

Mutations and subscriptions with GraphQL, including an introduction to GraphQL mutations and how to use them to modify data in a GraphQL API, as well as an introduction to GraphQL subscriptions and how they can be used to build real-time applications

Advanced topics in GraphQL, including an overview of GraphQL schema design and how to use GraphQL interfaces and unions to build flexible APIs

Best practices for working with GraphQL, including a discussion of common performance and security considerations, as well as strategies for testing and documenting GraphQL APIs

Conclusion and summary of the chapter

Chapter 8: Using OTP for Concurrency and Fault Tolerance