v1.1.1

🚀Creating a web app from start to finish

Follow a step by step guide to creating a reminders web application using the Petal Pro boilerplate. We will cover everything from setup to deploying to production.

Note: This tutorial was written using Petal Pro v1.1.1.

Getting up and running

What you need

For this tutorial you will need:

Download

Head to the downloads page and download v1.1.1. You can unzip it in your terminal with the command unzip petal_pro_1.1.1.zip.

Renaming your project

Once it's unzipped we can go ahead and rename the folder to whatever we want to call it. In our case, we're going to call it "remindly".

Terminal
mv petal_pro_1.1.1 remindly

While this changes the folder name, we still need to change the name of all the files and module names (eg. petal_pro_web.ex should be remindly_web.ex, etc). Petal Pro allows you to easily rename your project with a bash script. Open up rename_phoenix_project.sh and you'll see some instructions:

rename_phoenix_project.
...

# 1. Ensure you've checked your files into a git repo (`git init .`, `git add -A`, `git commit -m 'first'`)
# 2. Modify these two values to your new app name
NEW_NAME="YourAppName"
NEW_OTP="your_app_name"
# 3. LINUX USERS ONLY - Scroll down and comment out lines 25/25 and uncomment lines 29/30
# 4. Execute the script in terminal: `sh rename_phoenix_project.sh`

...

Let's follow these instructions in our terminal:

Terminal
git init .
git add -A
git commit -m 'first'

Now, let's put our desired name ("remindly") into the script:

rename_phoenix_project.sh
...

# 1. Ensure you've checked your files into a git repo (`git init .`, `git add -A`, `git commit -m 'first'`)
# 2. Modify these two values to your new app name
NEW_NAME="Remindly"
NEW_OTP="remindly"
# 3. LINUX USERS ONLY - Scroll down and comment out lines 25/25 and uncomment lines 29/30
# 4. Execute the script in terminal: `sh rename_phoenix_project.sh`

...

And finally, run the script:

Terminal
sh rename_phoenix_project.sh

If it produces no output, then you know it's run correctly. You can verify by looking at your git changes - there should be a lot of changes and file renaming.

For Linux users: as per the instructions you will need to do an additional task - simply follow the instructions in the script

If you like you can commit this renaming to git so you have a fresh starting point.

git add -A
git commit -m "Renamed to remindly"

Test run

Let's get the server running so we can see Petal Pro in action. Simply run in your terminal:

mix setup
mix phx.server

And now navigate to http://localhost:4000 in your browser to see the dummy landing page:

Feel free to have a look around. The mix setup command helpfully ran our seeds.ex file, which if you open you will see this code:

if Mix.env() == :dev do
  PetalPro.Repo.delete_all(Log)
  PetalPro.Repo.delete_all(UserToken)
  PetalPro.Repo.delete_all(User)

  UserSeeder.admin()
  UserSeeder.random_users(20)
end

The UserSeeder.admin() command has created an admin for us. You can login as this admin with "admin@test.com" and the password "password". We don't explain too much here, as you'll touch different parts of Petal Pro throughout different parts of this tutorial.

Adding your brand

Configuration

Obviously, the Petal branding will need to be replaced by your own brand. If you do a global search for "SETUP_TODO" you will find the code you need to modify.

The first two mentions you can ignore; one is in the README which is similar to this tutorial. The other is in rename_phoenix_project.sh, which we've already done. The 3rd match is in our config.exs file. In here we can update our web apps details:

config.exs
...

# SETUP_TODO - ensure these details are correct
# Option descriptions:
# app_name: This appears in your email layout and also your meta title tag
# support_email: In your transactional emails there is a "Contact us" email - this is what will appear there
# mailer_default_from_name: The "from" name for your transactional emails
# mailer_default_from_email: The "from" email for your transactional emails
# dark_logo_for_emails: Your logo must reference a URL for email client (not a relative path)
# light_logo_for_emails: Same as above
# seo_description: Will go in your meta description tag
# css_theme_default: Can be "light" or "dark" - if "dark" it will add the class "dark" to the <html> element by default
config :remindly,
  app_name: "Remindly",
  business_name: "Remindly Pty Ltd",
  support_email: "matt@petal.build",
  mailer_default_from_name: "Remindly",
  mailer_default_from_email: "matt@petal.build",
  logo_url_for_emails: "https://res.cloudinary.com/wickedsites/image/upload/v1646277219/petal_marketing/remindly_logo_tsvksl.png",
  seo_description: "Reminder app",
  css_theme_default: "dark"
  
...

The next SETUP_TODO is found in the file brand.ex. 

  # SETUP_TODO
  # This module relies on the following images. Replace these images with your logos
  # /priv/static/images/logo_dark.svg
  # /priv/static/images/logo_light.svg
  # /priv/static/images/logo_icon_dark.svg
  # /priv/static/images/logo_icon_light.svg
  # /priv/static/images/favicon.png

You don't need to change anything in this file, but rather it's asking you to update the logos with your own. For this tutorial, I went into Figma and just wrote "Remindly" in an interesting font. You can duplicate my Figma file and replace with your logo if you like.

Once you've exported them all you can drag them into your project:

Now reload your browser and check out your new logo.

Tailwind primary and secondary colors

Petal Components relies heavily on having a primary and secondary brand color set in your tailwind.config.js file.

By default, primary is blue and secondary is pink:

tailwind.config.js
const colors = require("tailwindcss/colors");

module.exports = {
  content: [
    "../lib/*_web/**/*.*ex",
    "./js/**/*.js",
    "../deps/petal_components/**/*.*ex",
  ],
  darkMode: "class",
  theme: {
    extend: {
      colors: {
        primary: colors.blue,
        secondary: colors.pink,
      },
    },
  },
  plugins: [require("@tailwindcss/forms"), require("@tailwindcss/typography")],
};

You can pick any two colors from Taildwind's comprehensive list. Or if you want to go super custom, you try out TailwindInk.

In our case, we'll go for the colors "amber" and "slate":

tailwind.config.js
const colors = require("tailwindcss/colors");

module.exports = {
  content: [
    "../lib/*_web/**/*.*ex",
    "./js/**/*.js",
    "../deps/petal_components/**/*.*ex",
  ],
  darkMode: "class",
  theme: {
    extend: {
      colors: {
        primary: colors.amber,
        secondary: colors.slate,
      },
    },
  },
  plugins: [require("@tailwindcss/forms"), require("@tailwindcss/typography")],
};

If you refresh your landing page, you'll notice the color change.

Public facing pages

Landing page

The landing page consists of content from two core files:

  • lib/remindly_web/components/landing_page.ex - a set of components like <.hero>, <.features>, <.header> etc. The end goal of Petal Pro is to have a comprehensive set of landing page components that can be used like building blocks for your landing page. Ideally, you won't modify these too much but will use them just like Petal Components

  • /lib/remindly_web/templates/page/landing_page.html.heex - a template file that uses the components from landing_page.ex

To keep this tutorial moving quickly, we won't do much design work on the landing page - if you open up landing_page.html.heex we can strip it down to merely a hero component:

landing_page.html.heex
<LandingPage.css />

<% main_menu_items = [] %>

<LandingPage.header
  current_user={assigns[:current_user]}
  conn={@conn}
  current_page={:landing}
  main_menu_items={main_menu_items}
  user_menu_items={user_menu_items(@current_user)}
/>

<LandingPage.hero image_src={Routes.static_path(@conn, "/images/landing_page/hero.svg")}>
  <:title>
    <span><%= gettext("Always be") %></span>
    <span class="text-primary-600">
      <%= gettext("reminded") %>
    </span>
    <span><%= gettext("to do things") %>.</span>
  </:title>

  <:action_buttons>
    <.button
      label={gettext("Get started")}
      link_type="a"
      color="primary"
      to={Routes.user_registration_path(@conn, :new)}
      size="lg"
    />
  </:action_buttons>

  <:description>
    <%= gettext("To be a functioning adult you need to be reminded to do adult-like tasks, like getting a hair cut or going to the dentist.") %>
  </:description>
</LandingPage.hero>

<LandingPage.javascript />

Now refresh your landing page and it should be a lot more simple. It is up to you how detailed you want to be with your landing page.

About page

To complement the landing page it would be nice to have an "About" page. This is a good chance to show off Petal Pro's "Page Builder" functionality.

Usually, when you want to create a new page, you would have to create a new template file or live view file. Then you would create a route and point it either to the template's corresponding controller action, or directly to the live view. To skip these steps, we made it so if you navigate to a path with no route on it then it will show what we call "The Page Builder" 👏. The Page Builder is simply a form that helps you construct a page at that route. Submitting the form will result in the route being automatically added to the router.ex file and either a template or live view file is created for you.

Let's try it out. In your browser go to "localhost:4000/about". This page won't exist so the "Page Builder" will load up. Here is where we can input the details of our new page.

We'll make a change before submitting: for "Page type", change to "Traditional static view" - we won't be needing any live view functionality

After submitting the form the page should refresh itself because the about.html.heex template file has been added on the file system. The "Page Builder" has done 3 things for us:

  1. Added a new "/about" route in router.ex

  2. Added a new about/2 function in page_controller.ex

  3. Added a new template about.html.heex

Looking at the page, you can see the layout is a little different to our landing page - this is using the "Stacked" layout. Petal Pro's two layouts "Stacked" and "Sidebar" are designed for when a user is logged in - an "App Layout" if you will. Whereas, this "About" page is more of a public, marketing page. So let's change it to use the same layout as our landing page:

<LandingPage.css />

<% main_menu_items = [
    %{label: gettext("About"), path: "/about"},
] %>

<LandingPage.header
  current_user={assigns[:current_user]}
  conn={@conn}
  current_page={:landing}
  main_menu_items={main_menu_items}
  user_menu_items={user_menu_items(@current_user)}
/>

<.container max_width="xl" class="my-20">
  <.h2>About</.h2>
  <.p>
    Lorem ipsum dolor sit, amet consectetur adipisicing elit. Tenetur facilis ratione temporibus sunt odit ad soluta doloribus natus possimus quasi, quidem, illum aut aspernatur vel sint consequatur libero dolore velit.
  </.p>
</.container>

Now it should look more like our landing page. Obviously it looks unfinished, but we've shown how you can use "Page Builder" to speed up your development for these stray pages.

How does the Page Builder know where to insert the route? If you look inside the router.ex file, you will see some comments spread out through the file that look like this: page_builder:live:public . Any comment like this is like a target for the Page Builder to add routes beneath it. When you load the Page Builder it will scan the router for these strings starting with "page_builder:" and then allow you to select one of them from a list. Whichever one you select, the route will be added AFTER that line.

Back on the landing page, let's add a menu item up the top for the "About" page:

landing_page.html.heex
<LandingPage.css />

<% main_menu_items = [
    %{label: gettext("About"), path: "/about"},
] %>

...

And now there should be a menu item in the navbar:

The reminders page

Now that the public facing side of things is looking good enough, we can work on the app itself. When a user signs in we want them to see a list of their reminders that they can check off or delete, with a button to create new ones. Normally this would be a job for a Phoenix generator - luckily Petal Pro has it's own version of the mix phx.gen.live generator - mix petal.gen.live. Our generator produces the same files as the Phoenix one, but the resulting HTML will use Tailwind and Petal Components so we don't have to worry about styling.

Using petal.gen.live

Let's run the generator to create the following schema:

FieldType

label

:string

due_date

:date

is_done

:boolean

user_id

:integer (foreign key)

mix petal.gen.live Reminders Reminder reminders label:string due_date:date is_done:boolean user_id:references:users

Now we need to add these routes to the router. We can use the Page Builder tags to help us know where to put them. Do a search for "page_builder:live:protected" to see live routes that are protected, which means only authenticated users can access this area. Let's paste in the routes here underneath that line.

Now go to "http://localhost:4000/reminders" to see the newly created CRUD functionality.

Assigning reminders to the current user

One issue with the generator is that it doesn't handle foreign keys very well. Currently the reminders page shows ALL reminders from all users. In fact, the user_id is not even being set when create a new reminder, so they're not really owned by anyone - every user who signs in will see them. We need to make it so everything is scoped to the current logged in user:

  • the index page table should only show the current users reminders

  • when you create a new reminder, it should set the user_id to the current user's id

  • the show page should not be allowed to see other users reminders

Firstly, there's a couple of problems with the schema file:

Let's fix those up:

reminder.ex
defmodule Remindly.Reminders.Reminder do
  use Ecto.Schema
  import Ecto.Changeset

  schema "reminders" do
    field :due_date, :date
    field :is_done, :boolean, default: false
    field :label, :string

    belongs_to :user, Remindly.Accounts.User

    timestamps()
  end

  @doc false
  def changeset(reminder, attrs) do
    reminder
    |> cast(attrs, [:label, :due_date, :is_done, :user_id])
    |> validate_required([:label, :due_date, :is_done, :user_id])
  end
end

Note that we've added :user_id to the validate_required function too, as we always want a reminder to belong to someone.

The reminder schema now knows it belongs to a user, but we still have to let the user schema know that it "has_many" reminders. Let's add that in to the user schema file:

user.ex
defmodule Remindly.Accounts.User do
  ...

  schema "users" do
    field :name, :string
    field :email, :string
    # ...other fields omitted for brevity
    
    has_many :reminders, Remindly.Reminders.Reminder

    timestamps()
  end
  
  ...
end

Great, the association is now complete. Now let's make it so when you create a new reminder, the user_id gets populated with the logged in user's id.

The code for creating the reminder is located in lib/remindly_web/live/reminder_live/form_component.ex :

form_component.ex
defmodule RemindlyWeb.ReminderLive.FormComponent do
  ...

  defp save_reminder(socket, :new, reminder_params) do
    case Reminders.create_reminder(reminder_params) do
      {:ok, _reminder} ->
        {:noreply,
         socket
         |> put_flash(:info, "Reminder created successfully")
         |> push_redirect(to: socket.assigns.return_to)}

      {:error, %Ecto.Changeset{} = changeset} ->
        {:noreply, assign(socket, changeset: changeset)}
    end
  end
  
  ...
end

Let's modify this to ensure the :user_id is set in the params:

defmodule RemindlyWeb.ReminderLive.FormComponent do
  ...

  defp save_reminder(socket, :new, reminder_params) do
    reminder_params = Map.put(reminder_params, "user_id", socket.assigns.current_user.id)

    case Reminders.create_reminder(reminder_params) do
      {:ok, _reminder} ->
        {:noreply,
         socket
         |> put_flash(:info, "Reminder created successfully")
         |> push_redirect(to: socket.assigns.return_to)}

      {:error, %Ecto.Changeset{} = changeset} ->
        {:noreply, assign(socket, changeset: changeset)}
    end
  end
  
  ...
end

Now when you try and create a new reminder, you get an error:

The current_user isn't in socket.assigns. This can be confusing because it is usually in the socket's assigns. The reason it isn't is because form_component.ex is a live_component, not a live_view. Thus it has it's own state and it's up to us to pass the assigns into it. We can see in index.html.heex the assigns being passed into it:

So all we need to do is pass in the current_user to this live_component function:

index.html.heex
...

<%= if @live_action in [:new, :edit] do %>
  <.modal title={"#{Atom.to_string(@live_action) |> String.capitalize()} Reminder"}>
    <.live_component
      module={RemindlyWeb.ReminderLive.FormComponent}
      id={@reminder.id || :new}
      action={@live_action}
      reminder={@reminder}
      return_to={Routes.reminder_index_path(@socket, :index)}
      current_user={@current_user}
    />
  </.modal>
<% end %>

...

And now creating a new reminder works correctly 🎊.

The next problem I see is that the date picker starts too far in the past - ideally it'll show todays date. So let's add in a default date for the form. This also will be done in the RemindlyWeb.ReminderLive.Index live view:

defmodule RemindlyWeb.ReminderLive.Index do
  ...
  
  defp apply_action(socket, :new, _params) do
    socket
    |> assign(:page_title, "New Reminder")
    |> assign(:reminder, %Reminder{due_date: Timex.now() |> Timex.to_date()})
  end
  
  ...
end

We use the Timex library (included in Petal Pro) to get todays date. Now the default is set correctly when creating new reminders (although since we're using UTC time, it maybe 1 day off depending on where you live, but good enough for this tutorial).

Adding a "Done" checkbox

The "Is done" column with true or false is a bit ugly.

Let's move it to the front column and make it a checkbox. Working in the file index.html.heex, let's begin by rearranging the headers:

index.html.heex
<thead>
  <tr>
    <th>Done?</th>
    <th>Label</th>
    <th>Due date</th>
    <th></th>
  </tr>
</thead>

Next, we'll rearrange the table cells and also add a checkbox in the first cell. Since we want it to submit every time we modify the checkbox, we'll wrap it in a form and add a phx-change event listener on it. So every time the form changes an event will be sent to the live view.

<%= for reminder <- @reminders do %>
  <tr id={"reminder-#{reminder.id}"}>
    <td>
      <.form let={f} for={Reminders.change_reminder(reminder)} phx-change="toggle_reminder">
        <%= hidden_input f, :id %>
        <.checkbox form={f} field={:is_done} />
      </.form>
    </td>
    <td><%= reminder.label %></td>
    <td><%= reminder.due_date %></td>
    <td class="text-right">
      <.button color="white" variant="outline" size="xs" link_type="live_redirect" label="Show" to={Routes.reminder_show_path(@socket, :show, reminder)} />
      <.button color="white" variant="outline" size="xs" link_type="live_patch" label="Edit" to={Routes.reminder_index_path(@socket, :edit, reminder)} />
      <.button color="danger" variant="outline" link_type="button" size="xs" label="Delete" phx-click="delete" phx-value-id={reminder.id} data-confirm="Are you sure?" />
    </td>
  </tr>
<% end %>

Now we just need to create the event handler for "toggle_reminder". Add this event handler underneath the event handler for "delete":

index.ex
@impl true
def handle_event("toggle_reminder", %{"reminder" => reminder_params}, socket) do
  reminder = Reminders.get_reminder!(reminder_params["id"])

  case Reminders.update_reminder(reminder, %{is_done: !reminder.is_done}) do
    {:ok, reminder} ->
      updated_reminders = Util.replace_object_in_list(socket.assigns.reminders, reminder)
      {:noreply, assign(socket, reminders: updated_reminders)}
    {:error, _changeset} ->
      {:noreply, put_flash(socket, :error, "Something went wrong.")}
  end
end

Now our checkbox is in sync. Live view works so fast you can barely notice it's not a Single Page App. However, this won't always be the case once if someone is a long way from the server and has some latency.

With LiveView you can simulate latency. If you look in app.js you'll find a comment with a command to run the in the browser console. This will add 1 second of latency: liveSocket.enableLatencySim(1000).

Is feels the same, but you can see the delay more clearly with the console open. LiveView adds classes when it's performing some kind of communication with the server. Petal Pro comes with some helper classes "show-if-loading" and "hide-if-loading" that we can make use of. Let's hide the checkbox button and show a spinner until LiveView has saved the update in the database:

index.html.heex
...

<.form let={f} for={get_changeset(reminder)} phx-change="toggle_reminder">
  <%= hidden_input f, :id %>
  <.checkbox form={f} field={:is_done} class="hide-if-loading" />
  <.spinner size="xs" class="show-if-loading" />
</.form>

...

Nice, although our spinner is still too big even with the smallest size selected. Let's override the sizing classes to make it smaller.

index.html.heex
...

<.form let={f} for={get_changeset(reminder)} phx-change="toggle_reminder">
  <%= hidden_input f, :id %>
  <.checkbox form={f} field={:is_done} class="hide-if-loading" />
  <.spinner class="show-if-loading !w-4 !h-4" />
</.form>

...

With that working correctly, we can disable the latency in the browser console: liveSocket.disableLatencySim().

Adding a menu item

In Petal Pro we try to keep our menu items in one file, called menus.ex. Each menu item has a function that looks like this:

def get_link(:dashboard, _current_user) do
  %{
    name: :dashboard,
    label: gettext("Dashboard"),
    path: Routes.live_path(Endpoint, RemindlyWeb.DashboardLive),
    icon: :template
  }
end

The icon is passed directly Heroicons.Outline.render: <Heroicons.Outline.render icon={menu_item.icon} />. You can browse Heroicons and when you've found one you like, just write the atom version of it. For example, the icon "bookmark-alt" would be :bookmark_alt.

From these function definitions, we can construct menus. There are two core menus - the main menu, which appears on this side panel, and also the user menu, which is in this dropdown.

Since we want to modify the sidebar, we want to change the main menu for a logged in user. Let's replace :dashboard with :reminders:

menus.ex
defmodule RemindlyWeb.Menus do
  ...
  
  # Signed in main menu
  def main_menu_items(current_user),
    do:
      build_menu(
        [
          :reminders
        ],
        current_user
      )
  
  ...
end

However, this won't work as we still need to write a definition function for :reminders. Scroll down the file until you see the get_link/2 function for :dashboard. Let's overwrite this function and replace it with our reminders menu item:

menus.ex
defmodule RemindlyWeb.Menus do
  ...
  
  # Replace the get_link(:dashboard, ...) function with this:
  def get_link(:reminders, _current_user) do
    %{
      name: :reminders,
      label: gettext("Reminders"),
      path: Routes.reminder_index_path(Endpoint, :index),
      icon: :clock
    }
  end
  
  ...
end

Next we want this new route to be our kind of "home" route for logged in users (eg redirect here after being signed in, or when you click the logo in a layout). To set this, go to helpers.ex and look for the home_path/2 function:

helpers.ex
  def home_path(nil), do: "/"
  def home_path(current_user), do: 
    RemindlyWeb.Menus.get_link(:dashboard, current_user).path

You can see we're looking for :dashboard menu item, which we just replaced. So let's update this to be the new :reminders menu item:

helpers.ex
  def home_path(nil), do: "/"
  def home_path(current_user), do: 
    RemindlyWeb.Menus.get_link(:reminders, current_user).path

Now refresh the page and we can see the sidebar has updated!

However, it's not highlighted 😤. To highlight it, we need to pass the current_page attribute to the <.layout> component. Open up index.html.heex for reminders and you'll see the <.layout> call up the top.

We need to match this atom to the name field in the menus get_link/2 function. Let's set the current page for both index.html.heex and show.html.heex.

And now our menu item should be highlighted both on the index page and when you click "Show" for an individual reminder.

User activity logging

We've found that at some point you need to implement some kind of logging functionality. You or your client will want to see some stats on how your users are using your web application.

Petal Pro puts logging at the forefront, and encourages you to log as much as you can. By default, it will store logs in your postgres database, but there's no reason why you can't shoot them off to a 3rd party provider.

To showcase Petal Pro logging, we'll create a log every time a user creates a reminder and toggles it complete. If you look in the file log.ex, you will see we have a list of actions that can be logged. Let's add our new log actions:

log.ex
defmodule Remindly.Logs.Log do
  ...

  @action_options [
    "update_profile",
    "register",
    "sign_in",
    "sign_out",
    "confirm_new_email",
    "delete_user",
    "create_reminder", 
    "complete_reminder"
  ]
  
  ...

Now we can do the actual logging. Go to form_component.ex and add a log in the create action.

form_component.ex
  defp save_reminder(socket, :new, reminder_params) do
    reminder_params = Map.put(reminder_params, "user_id", socket.assigns.current_user.id)

    case Reminders.create_reminder(reminder_params) do
      {:ok, reminder} ->
        Remindly.Logs.log_async("create_reminder", %{
          user: socket.assigns.current_user,
          metadata: %{
            reminder_id: reminder.id,
            reminder_label: reminder.label
          }
        })

        {:noreply,
         socket
         |> put_flash(:info, "Reminder created successfully")
         |> push_redirect(to: socket.assigns.return_to)}

      {:error, %Ecto.Changeset{} = changeset} ->
        {:noreply, assign(socket, changeset: changeset)}
    end
  end

Usually for new tables like "reminders" I'd create a migration and add a foreign key to the logs table (log.reminder_id), but for now we can make use of a JSON column on the logs table called metadata. In here we can store any kind of map I want. We'll store the ID and label of the reminder here so we can track it if need be.

Now create a new reminder and we'll check that our logs have updated. Logs are in the admin section - try clicking the user menu (your avatar up the top right), and select "Admin".

Then click logs on the sidebar menu. Here you should see a new log for creating a reminder.

Let's do another log for when we complete a reminder. We'll need to modify our toggle_reminder function in index.ex.

index.ex
@impl true
def handle_event("toggle_reminder", %{"reminder" => reminder_params}, socket) do
  reminder = Reminders.get_reminder!(reminder_params["id"])

  case Reminders.update_reminder(reminder, %{is_done: !reminder.is_done}) do
    {:ok, reminder} ->
      if reminder.is_done do
        Remindly.Logs.log_async("complete_reminder", %{
          user: socket.assigns.current_user,
          metadata: %{
            reminder_id: reminder.id,
            reminder_label: reminder.label
          }
        })
      end

      updated_reminders = Util.replace_object_in_list(socket.assigns.reminders, reminder)
      {:noreply, assign(socket, reminders: updated_reminders)}
    {:error, _changeset} ->
      {:noreply, put_flash(socket, :error, "Something went wrong.")}
  end
end

Now, when we toggle a reminder to "done", a new log will appear.

Live logs

You might have noticed a toggle for "Live logs" on the logs screen. If you turn this on, you will actually get a live feed of what's happening in your web app. You can try it out by opening two browser windows side by side: one on logs with "Live logs" checked, and one on the reminders screen. If you toggle the reminder on and off, you will see the logs appearing on the admin screen in real time:

Reminder emails

Next we need to implement an email reminder that gets sent the day a reminder is overdue. If we head to dev we can see a list of our transactional emails.

We want to create a new one and show it in here so we can visualise it while we develop it. Before we do, let's do a quick overview of how emails work in Petal Pro. Open up email.ex and you will see a list of functions that generate Swoosh email structs. Eg:

def confirm_register_email(email, url) do
  base_email()
  |> to(email)
  |> subject("Confirm instructions")
  |> render_body("confirm_register_email.html", %{url: url})
  |> premail()
end

If I run this function in IEX I can see the Swoosh struct:

An Swoosh.Email struct can be delivered to an email address by a Swoosh mailer (see mailer.ex). Eg:

  Remindly.Email.confirm_register_email(user.email, url)
  |> Remindly.Mailer.deliver()

So email.ex creates the Swoosh structs and the functions for actually delivering emails like the previous code example are in user_notifier.ex. Think of email.ex functions like view templates, and user_notifer.ex functions like controller actions.

So our steps will be:

  1. Create the function to generate a Swoosh struct in email.ex

  2. Ensure it looks good by creating a new action in email_testing_controller.ex that simply renders the html_body value of the struct

  3. Create a new user_notifier.ex function for use in our application

  4. Create a CRON job that runs once a day that finds overdue reminders and emails the user using the user_notifier.ex function

Designing the email

In email.ex, let's create a function for our new email:

email.ex
defmodule Remindly.Email do
  ...
  
  def reminder(email, reminder, reminder_url) do
    base_email()
    |> to(email)
    |> subject("Reminder!")
    |> render_body("reminder.html", %{reminder: reminder, url: reminder_url})
    |> premail()
  end
  
  ...
end

Now it expects a template reminder.html.heex. Let's add one to the /lib/remindly_web/templates/email folder:

reminder.html.heex
<h1>Reminder</h1>

<p><%= @reminder.label %></p>

<EmailHelpers.button_centered to={@url}>
  View
</EmailHelpers.button_centered>

Now we can try seeing how it looks. Open up email_testing_controller.ex and do two things:

  1. Append "reminder" to the end of @email_templates

  2. Create a new generate_email/2 function for our new email

defmodule RemindlyWeb.EmailTestingController do
  ...
  
  @email_templates [
    "template",
    "register_confirm_email",
    "reset_password",
    "change_email",
    "reminder"
  ]
  
  defp generate_email("reminder", current_user) do
    reminder = %Remindly.Reminders.Reminder{
      user_id: current_user.id,
      label: "Do the washing.",
      due_date: Timex.now() |> Timex.to_date()
    }

    Email.reminder(current_user.email, reminder, "/")
  end
  
  ...
end

Now if you refresh the "Email templates" page you can see your new email design:

The only problem is the logo is wrong. Since emails can be opened in all kinds of email clients, the logo must be hosted online somewhere. I recommend uploading your logo in png format to some kind of image hosting you like. We personally like Cloudinary so let's chuck our logo up there and then paste the URL into our config file.

config.exs
config :remindly,
  app_name: "Remindly",
  business_name: "Remindly Pty Ltd",
  support_email: "matt@petal.build",
  mailer_default_from_name: "Remindly",
  mailer_default_from_email: "matt@petal.build",
  logo_url_for_emails: "https://res.cloudinary.com/wickedsites/image/upload/v1646277219/petal_marketing/remindly_logo_tsvksl.png",
  seo_description: "Reminder app",
  css_theme_default: "dark"

After restarting the server:

Great, now that the email is ready to go we can implement the user_notifier.ex function that accepts a reminder ecto struct as a parameter and sends the reminder email for us:

defmodule Remindly.Accounts.UserNotifier do
  ...
  
  def deliver_reminder(reminder) do
    reminder = Remindly.Repo.preload(reminder, :user)
    url = RemindlyWeb.Router.Helpers.reminder_show_url(RemindlyWeb.Endpoint, :show, reminder)

    Email.reminder(reminder.user.email, reminder, url)
    |> deliver
  end
  
  ...
end

Now we can test a sent email in IEX:

iex -S mix phx.server
reminder = DB.last(Remindly.Reminders.Reminder)
user = DB.last(User)
Remindly.Accounts.UserNotifier.deliver_reminder(reminder)

Click on "Sent emails" in the sidebar to see that it worked properly. If we cmd-click the button it should take us to the right reminder.

Sending the email for overdue reminders

With an email ready to be sent to people who have been lazy, let's create a CRON job to send off the emails. We use Oban for jobs, which supports a CRON schedule. Here's what we'll do:

  1. We create a worker Remindly.Workers.ReminderWorker, which has a function perform/1 that will find overdue reminders and send the reminder emails

  2. We tell Oban to run this worker once per day

Reminder worker

Petal Pro comes with an example worker you can check out (example_worker.ex). In the same folder, let's create reminder_worker.ex:

And then fill it with this:

reminder_worker.ex
defmodule Remindly.Workers.ReminderWorker do
  @moduledoc """
  Run this with:
  Oban.insert(Remindly.Workers.ReminderWorker.new(%{}))
  """
  use Oban.Worker, queue: :default
  alias Remindly.{Repo, Reminders}
  require Logger

  @impl Oban.Worker
  def perform(%Oban.Job{} = _job) do
    today = Timex.now() |> Timex.to_date()
    Logger.info("ReminderWorker: Sending reminders for #{today}")

    # TODO: Find all overdue reminders and send the user an email

    :ok
  end
end

Now we have a skeleton worker we can work with. Try testing it out in IEX:

Oban.insert(Remindly.Workers.ReminderWorker.new(%{}))

Now we need to find all the overdue reminders. This is a job for the context file reminders.ex. In there we can add the following function:

defmodule Remindly.Reminders do
  ...
  
  def list_overdue_reminders do
    today = Timex.now() |> Timex.to_date()

    Repo.all(
      from r in Reminder,
        where: r.due_date < ^today,
        where: r.is_done == false
    )
  end
  
  ...

Normally we'd write a test for this, but for brevity we'll assume it works correctly (or you can test it in IEX if you like).

Back to the worker, let's finish it off:

reminder_worker.ex
defmodule Remindly.Workers.ReminderWorker do
  @moduledoc """
  Run this with:
  Oban.insert(Remindly.Workers.ReminderWorker.new(%{}))
  """
  use Oban.Worker, queue: :default
  alias Remindly.{Repo, Reminders}
  require Logger

  @impl Oban.Worker
  def perform(%Oban.Job{} = _job) do
    today = Timex.now() |> Timex.to_date()
    Logger.info("ReminderWorker: Sending reminders for #{today}")

    Reminders.list_overdue_reminders()
    |> Repo.preload(:user)
    |> Enum.each(fn reminder ->
      Logger.info("Reminding #{reminder.user.name} to #{reminder.label}")
      Remindly.Accounts.UserNotifier.deliver_reminder(reminder)
    end)

    :ok
  end
end

We can test it by setting one of our reminders in the past (making sure it's unchecked) and then running the worker in IEX again.

You can double check by also looking at the "Sent emails" page again.

CRON job

Now that we know our worker works, we want to schedule it to run every day. This is a simple task thanks to Oban - just modify config.exs:

...

config :remindly, Oban,
  repo: Remindly.Repo,
  queues: [default: 5],
  plugins: [
    {Oban.Plugins.Pruner, max_age: (3600 * 24)},
    {Oban.Plugins.Cron,
      crontab: [
        {"@daily", Remindly.Workers.ReminderWorker}
        # {"* * * * *", Remindly.EveryMinuteWorker},
        # {"0 * * * *", Remindly.EveryHourWorker},
        # {"0 */6 * * *", Remindly.EverySixHoursWorker},
        # {"0 0 * * SUN", Remindly.EverySundayWorker},
        # More examples: https://crontab.guru/examples.html
      ]}
  ]
  
...

To keep it simple we'll use the @daily code for scheduling. If you want to fine tune it to the exact minute, you can use the usual CRON syntax (you might need a website to help you generate it).

And that's it! Our job will now run daily.

Deployment with Fly.io

We have found Fly.io to be the best combination of cheap and easy. Petal Pro has been set up for users to quickly deploy on Fly.io's servers.

If you haven't already, download the Fly.io CLI. Then you will need to register or sign in.

Once signed in, you can create a new project with:

fly launch

We'll call the app remindly. Hit Y to setting up a DB as we'll need that. I'll go the cheapest option for a server - not sure my reminders app will catch on. When it asks "Do you want to deploy now", hit N - we need to make a couple of changes before we deploy.

Firstly, open Dockerfile and look for RUN mix assets.deploy.

Since we're using tailwind, this step involves the Tailwind CLI scanning our files for CSS classname that it will include in the final app.css file. A problem with the default Fly Dockerfile is that it runs this command before the lib directory has been copied over, so it misses all of our CSS classnames in our HEEX files!

To fix this, simply move the assets.deploy command underneath the COPY lib lib command.

Secondly, we need a service to send our emails out. We've found that the simplest and cheapest solution is Amazon SES, and so Petal defaults to using this. We don't really use Amazon for much else, but it's email service is cheap and the emails don't get sent to spam as easily as other services we've tried.

Setting up Amazon SES is beyond the scope of this video - you can google how to do it. The end result should be you being able to provide the following secrets that we'll provide to our production server: 

fly secrets set AWS_ACCESS_KEY="xxx" AWS_SECRET="xxx" AWS_REGION="xxx"

Finally we can run fly deploy.

After deploying you can run fly open to see it in your browser. If you've made it this far, congratulations! You've just gone from nothing to production. Obviously this app needs some touching up, but it gives you an idea of how to do things. We look forward to seeing what people create with Petal Pro.

If you have any feedback, head here to see how to get in touch.

PreviousWhat is Petal Pro?NextUsers & Authentication

Last updated