Add settings model (#54)

* Adds a basic settings model

* Added more settings methods; Hooked up initial settings runner to app boot

* Update onboarding flow to use settings model instead of session data

lib/pinchflat/application.ex

@@ -10,6 +10,8 @@ defmodule Pinchflat.Application do
     children = [
       PinchflatWeb.Telemetry,
       Pinchflat.Repo,
+      # {Task, &run_startup_tasks/0},
+      Pinchflat.StartupTasks,
       {Oban, Application.fetch_env!(:pinchflat, Oban)},
       {DNSCluster, query: Application.get_env(:pinchflat, :dns_cluster_query) || :ignore},
       {Phoenix.PubSub, name: Pinchflat.PubSub},

lib/pinchflat/profiles/media_profile.ex

@@ -1,6 +1,6 @@
 defmodule Pinchflat.Profiles.MediaProfile do
   @moduledoc """
-  A media profile is a set of settings that can be applied to many media sources
+  A media profile is a set of configuration options that can be applied to many media sources
   """
 
   use Ecto.Schema

lib/pinchflat/settings.ex

@@ -0,0 +1,95 @@
+defmodule Pinchflat.Settings do
+  @moduledoc """
+  The Settings context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Pinchflat.Repo
+
+  alias Pinchflat.Settings.Setting
+
+  @doc """
+  Returns the list of settings.
+
+  Returns [%Setting{}, ...]
+  """
+  def list_settings do
+    Repo.all(Setting)
+  end
+
+  @doc """
+  Creates or updates a setting, returning the parsed value.
+  Raises if an unsupported datatype is used. Optionally allows
+  specifying the datatype.
+
+  Returns value in type of `Ecto.Enum.mappings(Setting, :datatype)`
+  """
+  def set!(name, value) do
+    set!(name, value, infer_datatype(value))
+  end
+
+  def set!(name, value, datatype) do
+    # Only create if doesn't exist
+    case Repo.get_by(Setting, name: to_string(name)) do
+      nil -> create_setting!(name, value, datatype)
+      setting -> update_setting!(setting, value, datatype)
+    end
+  end
+
+  @doc """
+  Gets the parsed value of a setting. Raises if the setting does not exist.
+
+  Returns value in type of `Ecto.Enum.mappings(Setting, :datatype)`
+  """
+  def get!(name) do
+    Setting
+    |> Repo.get_by!(name: to_string(name))
+    |> read_setting()
+  end
+
+  @doc """
+  Attempts to find a setting by name or creates a setting with value
+  if one doesn't exist, returning the parsed value. Optionally allows
+  specifying the datatype.
+
+  Returns value in type of `Ecto.Enum.mappings(Setting, :datatype)`
+  """
+  def fetch!(name, value) do
+    fetch!(name, value, infer_datatype(value))
+  end
+
+  def fetch!(name, value, datatype) do
+    case Repo.get_by(Setting, name: to_string(name)) do
+      nil -> create_setting!(name, value, datatype)
+      setting -> read_setting(setting)
+    end
+  end
+
+  defp change_setting(setting, attrs) do
+    Setting.changeset(setting, attrs)
+  end
+
+  defp create_setting!(name, value, datatype) do
+    %Setting{}
+    |> change_setting(%{name: to_string(name), value: to_string(value), datatype: datatype})
+    |> Repo.insert!()
+    |> read_setting()
+  end
+
+  defp update_setting!(setting, value, datatype) do
+    setting
+    |> change_setting(%{value: to_string(value), datatype: datatype})
+    |> Repo.update!()
+    |> read_setting()
+  end
+
+  defp read_setting(%{value: value, datatype: :string}), do: value
+  defp read_setting(%{value: value, datatype: :boolean}), do: value in ["true", "t", "1"]
+  defp read_setting(%{value: value, datatype: :integer}), do: String.to_integer(value)
+  defp read_setting(%{value: value, datatype: :float}), do: String.to_float(value)
+
+  defp infer_datatype(value) when is_boolean(value), do: :boolean
+  defp infer_datatype(value) when is_integer(value), do: :integer
+  defp infer_datatype(value) when is_float(value), do: :float
+  defp infer_datatype(value) when is_binary(value), do: :string
+end

lib/pinchflat/settings/setting.ex

@@ -0,0 +1,24 @@
+defmodule Pinchflat.Settings.Setting do
+  @moduledoc """
+  A Setting is a key-value pair with a datatype used to track user-level settings.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "settings" do
+    field :name, :string
+    field :value, :string
+    field :datatype, Ecto.Enum, values: ~w(boolean string integer float)a
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(setting, attrs) do
+    setting
+    |> cast(attrs, [:name, :value, :datatype])
+    |> validate_required([:name, :value, :datatype])
+    |> unique_constraint([:name])
+  end
+end

lib/pinchflat/startup_tasks.ex

@@ -0,0 +1,36 @@
+defmodule Pinchflat.StartupTasks do
+  @moduledoc """
+  This module is responsible for running startup tasks on app boot.
+
+  It's a GenServer because that plays REALLY nicely with the existing
+  Phoenix supervision tree.
+  """
+
+  # restart: :temporary means that this process will never be restarted (ie: will run once and then die)
+  use GenServer, restart: :temporary
+
+  alias Pinchflat.Settings
+
+  def start_link(opts \\ []) do
+    GenServer.start_link(__MODULE__, %{}, opts)
+  end
+
+  @doc """
+  Runs application startup tasks.
+
+  Any code defined here will run every time the application starts. You must
+  make sure that the code is idempotent and safe to run multiple times.
+
+  This is a good place to set up default settings, create initial records, stuff like that
+  """
+  @impl true
+  def init(state) do
+    apply_default_settings()
+
+    {:ok, state}
+  end
+
+  defp apply_default_settings do
+    Settings.fetch!(:onboarding, true)
+  end
+end