├── assets
├── .babelrc
├── static
│ ├── favicon.ico
│ ├── images
│ │ └── phoenix.png
│ └── robots.txt
├── postcss.config.js
├── package.json
├── webpack.config.js
├── js
│ ├── app.js
│ └── socket.js
└── css
│ ├── app.css
│ └── phoenix.css
├── test
├── test_helper.exs
├── tutorial_web
│ ├── views
│ │ ├── page_view_test.exs
│ │ ├── layout_view_test.exs
│ │ └── error_view_test.exs
│ └── controllers
│ │ ├── page_controller_test.exs
│ │ ├── product_controller_test.exs
│ │ └── secret_controller_test.exs
├── support
│ ├── channel_case.ex
│ ├── conn_case.ex
│ └── data_case.ex
└── tutorial
│ ├── accounts_test.exs
│ ├── taggable_test.exs
│ ├── secrets_test.exs
│ └── products_test.exs
├── lib
├── tutorial_web
│ ├── templates
│ │ ├── layout
│ │ │ ├── app.html.leex
│ │ │ └── root.html.leex
│ │ ├── page
│ │ │ ├── draggable.html.eex
│ │ │ ├── task_async.html.eex
│ │ │ ├── private.html.eex
│ │ │ ├── index.html.eex
│ │ │ ├── search_form.html.leex
│ │ │ └── calendar.html.leex
│ │ ├── secret
│ │ │ ├── new.html.eex
│ │ │ ├── edit.html.eex
│ │ │ ├── show.html.eex
│ │ │ ├── form.html.eex
│ │ │ └── index.html.eex
│ │ ├── product
│ │ │ ├── index.html.eex
│ │ │ ├── new.html.eex
│ │ │ ├── edit.html.eex
│ │ │ ├── products_loading.html.leex
│ │ │ ├── show.html.eex
│ │ │ ├── product_tagging.html.leex
│ │ │ ├── form.html.leex
│ │ │ └── products.html.leex
│ │ └── pow
│ │ │ ├── session
│ │ │ └── new.html.eex
│ │ │ └── registration
│ │ │ ├── edit.html.eex
│ │ │ └── new.html.eex
│ ├── views
│ │ ├── layout_view.ex
│ │ ├── secret_view.ex
│ │ ├── pow
│ │ │ ├── session_view.ex
│ │ │ └── registration_view.ex
│ │ ├── page_view.ex
│ │ ├── product_view.ex
│ │ ├── error_view.ex
│ │ └── error_helpers.ex
│ ├── plugs
│ │ ├── generate_csrf.ex
│ │ ├── assign_session.ex
│ │ └── set_current_account.ex
│ ├── controllers
│ │ ├── page_controller.ex
│ │ ├── product_controller.ex
│ │ └── secret_controller.ex
│ ├── channels
│ │ ├── app_channel.ex
│ │ └── user_socket.ex
│ ├── live
│ │ ├── modals_live.ex
│ │ ├── calendar_day_component.ex
│ │ ├── draggable_live.ex
│ │ ├── task_starter_live.ex
│ │ ├── calendar_live.ex
│ │ ├── product_form_live.ex
│ │ ├── product_list_live.ex
│ │ ├── modal_component.ex
│ │ ├── search_form_live.ex
│ │ ├── modals_live.html.leex
│ │ └── product_tagging_live.ex
│ ├── gettext.ex
│ ├── endpoint.ex
│ └── router.ex
├── tutorial
│ ├── presence.ex
│ ├── repo.ex
│ ├── secrets
│ │ └── secret.ex
│ ├── accounts
│ │ └── account.ex
│ ├── taggable
│ │ ├── tagging.ex
│ │ └── tag.ex
│ ├── worker.ex
│ ├── products
│ │ ├── product.ex
│ │ └── variant.ex
│ ├── users
│ │ └── user.ex
│ ├── taggable.ex
│ ├── application.ex
│ ├── draggable_server.ex
│ ├── accounts.ex
│ ├── secrets.ex
│ └── products.ex
├── tutorial.ex
├── tutorial_web.ex
└── mix
│ └── tasks
│ ├── swagger.gen.json.ex
│ └── tailwind.gen.html.ex
├── priv
├── repo
│ ├── migrations
│ │ ├── .formatter.exs
│ │ ├── 20200210061018_add_properties_to_products.exs
│ │ ├── 20200211160754_create_tags.exs
│ │ ├── 20200124063237_create_products.exs
│ │ ├── 20200313082034_create_accounts.exs
│ │ ├── 20200210062352_add_index_to_products_properties.exs
│ │ ├── 20200316074930_create_secrets.exs
│ │ ├── 20200315124813_create_users.exs
│ │ ├── 20200203173952_create_variants.exs
│ │ └── 20200211160936_create_taggings.exs
│ └── seeds.exs
├── templates
│ ├── tailwind.gen.html
│ │ ├── view.ex
│ │ ├── new.html.eex
│ │ ├── edit.html.eex
│ │ ├── form.html.eex
│ │ ├── show.html.eex
│ │ ├── index.html.eex
│ │ ├── controller.ex
│ │ └── controller_test.exs
│ └── swagger.gen.json
│ │ ├── changeset_view.ex
│ │ ├── fallback_controller.ex
│ │ ├── view.ex
│ │ ├── controller_test.exs
│ │ └── controller.ex
└── gettext
│ ├── en
│ └── LC_MESSAGES
│ │ └── errors.po
│ └── errors.pot
├── .formatter.exs
├── README.md
├── config
├── test.exs
├── prod.secret.exs
├── config.exs
├── prod.exs
└── dev.exs
├── .gitignore
├── mix.exs
└── mix.lock
/assets/.babelrc:
--------------------------------------------------------------------------------
1 | {
2 | "presets": [
3 | "@babel/preset-env"
4 | ]
5 | }
6 |
--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 | Ecto.Adapters.SQL.Sandbox.mode(Tutorial.Repo, :manual)
3 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/layout/app.html.leex:
--------------------------------------------------------------------------------
1 | <%= render @view_module, @view_template, assigns %>
2 |
--------------------------------------------------------------------------------
/priv/repo/migrations/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | import_deps: [:ecto_sql],
3 | inputs: ["*.exs"]
4 | ]
5 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/page/draggable.html.eex:
--------------------------------------------------------------------------------
1 | <%= live_render @conn, TutorialWeb.DraggableLive %>
2 |
--------------------------------------------------------------------------------
/assets/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andreaseriksson/tutorials/HEAD/assets/static/favicon.ico
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/page/task_async.html.eex:
--------------------------------------------------------------------------------
1 | <%= live_render @conn, TutorialWeb.TaskStarterLive %>
2 |
--------------------------------------------------------------------------------
/lib/tutorial_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.LayoutView do
2 | use TutorialWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/tutorial_web/views/secret_view.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.SecretView do
2 | use TutorialWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/assets/static/images/phoenix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andreaseriksson/tutorials/HEAD/assets/static/images/phoenix.png
--------------------------------------------------------------------------------
/lib/tutorial_web/views/pow/session_view.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.Pow.SessionView do
2 | use TutorialWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/tutorial_web/views/pow/registration_view.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.Pow.RegistrationView do
2 | use TutorialWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/test/tutorial_web/views/page_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.PageViewTest do
2 | use TutorialWeb.ConnCase, async: true
3 | end
4 |
--------------------------------------------------------------------------------
/test/tutorial_web/views/layout_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.LayoutViewTest do
2 | use TutorialWeb.ConnCase, async: true
3 | end
4 |
--------------------------------------------------------------------------------
/lib/tutorial/presence.ex:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.Presence do
2 | use Phoenix.Presence, otp_app: :tutorial, pubsub_server: Tutorial.PubSub
3 | end
4 |
--------------------------------------------------------------------------------
/lib/tutorial/repo.ex:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.Repo do
2 | use Ecto.Repo,
3 | otp_app: :tutorial,
4 | adapter: Ecto.Adapters.Postgres
5 | use Scrivener, page_size: 10
6 | end
7 |
--------------------------------------------------------------------------------
/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | import_deps: [:ecto, :phoenix],
3 | inputs: ["*.{ex,exs}", "priv/*/seeds.exs", "{config,lib,test}/**/*.{ex,exs}"],
4 | subdirectories: ["priv/*/migrations"]
5 | ]
6 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/page/private.html.eex:
--------------------------------------------------------------------------------
1 |
2 | This page should be private and requires an account.
3 |
4 |
5 | Welcome <%= @current_user.email %>
6 |
--------------------------------------------------------------------------------
/priv/templates/tailwind.gen.html/view.ex:
--------------------------------------------------------------------------------
1 | defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>View do
2 | use <%= inspect context.web_module %>, :view
3 | end
4 |
--------------------------------------------------------------------------------
/assets/static/robots.txt:
--------------------------------------------------------------------------------
1 | # See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
2 | #
3 | # To ban all spiders from the entire site uncomment the next two lines:
4 | # User-agent: *
5 | # Disallow: /
6 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/page/index.html.eex:
--------------------------------------------------------------------------------
1 |
2 | <%= live_render @conn, TutorialWeb.SearchFormLive %>
3 |
4 |
5 |
6 | <%= live_render @conn, TutorialWeb.CalendarLive %>
7 |
8 |
9 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Tutorial app in Phoenix Framework by:
2 |
3 |
2 |
5 |
6 | <%= render "form.html", Map.put(assigns, :action, Routes.secret_path(@conn, :create)) %>
7 |
8 |
2 |
5 |
6 | <%= render "form.html", Map.put(assigns, :action, Routes.secret_path(@conn, :update, @secret)) %>
7 |
8 |
2 |
5 |
6 | <%%= render "form.html", Map.put(assigns, :action, Routes.<%= schema.route_helper %>_path(@conn, :create)) %>
7 |
8 |
#{selected} #{rest}"
9 | end
10 | end
11 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20200124063237_create_products.exs:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.Repo.Migrations.CreateProducts do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table(:products) do
6 | add :name, :string
7 | add :description, :text
8 | add :price, :float
9 |
10 | timestamps()
11 | end
12 |
13 | end
14 | end
15 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20200313082034_create_accounts.exs:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.Repo.Migrations.CreateAccounts do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table(:accounts) do
6 | add :name, :string, null: false
7 |
8 | timestamps()
9 | end
10 |
11 | create unique_index(:accounts, [:name])
12 | end
13 | end
14 |
--------------------------------------------------------------------------------
/lib/tutorial_web/views/product_view.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.ProductView do
2 | use TutorialWeb, :view
3 |
4 | def format_search_result(search_result, search_phrase) do
5 | split_at = String.length(search_phrase)
6 | {selected, rest} = String.split_at(search_result, split_at)
7 |
8 | "#{selected} #{rest}"
9 | end
10 | end
11 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20200210062352_add_index_to_products_properties.exs:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.Repo.Migrations.AddIndexToProductsProperties do
2 | use Ecto.Migration
3 |
4 | def up do
5 | execute("CREATE INDEX products_properties ON products USING GIN(properties)")
6 | end
7 |
8 | def down do
9 | execute("DROP INDEX products_properties")
10 | end
11 | end
12 |
--------------------------------------------------------------------------------
/priv/templates/tailwind.gen.html/edit.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 | <%%= render "form.html", Map.put(assigns, :action, Routes.<%= schema.route_helper %>_path(@conn, :update, @<%= schema.singular %>)) %>
7 |
8 |
2 |
6 | <%= live_render @conn, TutorialWeb.ProductListLive %>
7 |
8 |
--------------------------------------------------------------------------------
/lib/tutorial_web/plugs/assign_session.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.AssignSession do
2 | import Plug.Conn, only: [get_session: 2, put_session: 3]
3 |
4 | def init(options), do: options
5 |
6 | def call(conn, _opts) do
7 | case get_session(conn, :session_id) do
8 | nil -> put_session(conn, :session_id, Ecto.UUID.generate())
9 | _ -> conn
10 | end
11 | end
12 | end
13 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/product/new.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 | <%= live_render @conn, TutorialWeb.ProductFormLive,
7 | session: %{"action" => Routes.product_path(@conn, :create), "csrf_token" => Plug.CSRFProtection.get_csrf_token()}
8 | %>
9 |
10 |
2 |
5 |
6 | <%= live_render @conn, TutorialWeb.ProductFormLive,
7 | session: %{"id" => @product.id, "action" => Routes.product_path(@conn, :update, @product), "csrf_token" => Plug.CSRFProtection.get_csrf_token()}
8 | %>
9 |
10 |
4 |
The form couln't be saved! Please check the errors below.
5 |
9 | <%= label %>
10 | <%= input %>
11 | <%= error %>
12 |
13 | <% end %>
14 |
15 | <%%= submit "Save", class: "btn btn-primary mr-2" %>
16 | <%%= link "Back", to: Routes.<%= schema.route_helper %>_path(@conn, :index), class: "btn btn-secondary" %>
17 |
18 | <%% end %>
19 |
--------------------------------------------------------------------------------
/priv/repo/seeds.exs:
--------------------------------------------------------------------------------
1 | # Script for populating the database. You can run it as:
2 | #
3 | # mix run priv/repo/seeds.exs
4 | #
5 | # Inside the script, you can read and write to any of your
6 | # repositories directly:
7 | #
8 | # Tutorial.Repo.insert!(%Tutorial.SomeSchema{})
9 | #
10 | # We recommend using the bang functions (`insert!`, `update!`
11 | # and so on) as they will fail if something goes wrong.
12 |
13 | alias Tutorial.Products
14 |
15 | Enum.each(1..100, fn _ ->
16 | Products.create_product(%{
17 | name: Faker.Beer.En.name,
18 | description: "#{Faker.Beer.En.style} - #{Faker.Beer.En.brand}",
19 | price: (Faker.random_between(200, 1000) / 100.0)
20 | })
21 | end)
22 |
--------------------------------------------------------------------------------
/lib/tutorial_web/live/modals_live.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.ModalsLive do
2 | use Phoenix.LiveView
3 |
4 | # MODAL
5 | def handle_event("submit", %{"id" => id}, socket) do
6 | send_update TutorialWeb.ModalComponent, id: id, action: "CLOSE"
7 | {:noreply, socket}
8 | end
9 |
10 | def handle_event("open-modal", %{"id" => id}, socket) do
11 | send_update TutorialWeb.ModalComponent, id: id, state: "OPEN"
12 | {:noreply, socket}
13 | end
14 |
15 | def handle_event("close-modal", %{"id" => id}, socket) do
16 | :timer.sleep(300) # SO THE CSS ANIMATIONS HAVE TIME TO RUN
17 | send_update TutorialWeb.ModalComponent, id: id, state: "CLOSED", action: nil
18 | {:noreply, socket}
19 | end
20 | end
21 |
--------------------------------------------------------------------------------
/lib/tutorial/worker.ex:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.Worker do
2 | use Task, restart: :transient
3 |
4 | alias Tutorial.PubSub
5 | @topic inspect(__MODULE__)
6 |
7 | def start_link(arg) do
8 | Task.start_link(__MODULE__, :run, [arg])
9 | end
10 |
11 | def run(_arg) do
12 | :timer.sleep(2000)
13 | number = Enum.random(0..3)
14 |
15 | if number == 1 do
16 | IO.puts "CRASH"
17 | raise inspect(number)
18 | end
19 |
20 | number
21 | |> notify_subscribers()
22 | end
23 |
24 | defp notify_subscribers(number) do
25 | Phoenix.PubSub.broadcast(PubSub, @topic, {:message, number})
26 | end
27 |
28 | def subscribe do
29 | Phoenix.PubSub.subscribe(PubSub, @topic)
30 | end
31 | end
32 |
--------------------------------------------------------------------------------
/priv/templates/swagger.gen.json/changeset_view.ex:
--------------------------------------------------------------------------------
1 | defmodule <%= inspect context.web_module %>.ChangesetView do
2 | use <%= inspect context.web_module %>, :view
3 |
4 | @doc """
5 | Traverses and translates changeset errors.
6 |
7 | See `Ecto.Changeset.traverse_errors/2` and
8 | `<%= inspect context.web_module %>.ErrorHelpers.translate_error/1` for more details.
9 | """
10 | def translate_errors(changeset) do
11 | Ecto.Changeset.traverse_errors(changeset, &translate_error/1)
12 | end
13 |
14 | def render("error.json", %{changeset: changeset}) do
15 | # When encoded, the changeset returns its errors
16 | # as a JSON object. So we just pass it forward.
17 | %{errors: translate_errors(changeset)}
18 | end
19 | end
20 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/secret/show.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 |
9 |
10 |
11 | Key:
12 | <%= @secret.key %>
13 |
14 |
15 |
16 | Value:
17 | <%= @secret.value %>
18 |
19 |
20 |
21 |
22 |
Sign in
2 |
3 | <%= form_for @changeset, @action, [as: :user], fn f -> %>
4 | <%= if @changeset.action do %>
5 |
6 |
Oops, something went wrong! Please check the errors below.
7 |
19 | <%= submit "Sign in" %>
20 |
21 | <% end %>
22 |
23 |
24 | <%= link "Register", to: Routes.pow_registration_path(@conn, :new) %>
25 |
--------------------------------------------------------------------------------
/lib/tutorial/products/product.ex:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.Products.Product do
2 | use Ecto.Schema
3 | import Ecto.Changeset
4 |
5 | schema "products" do
6 | field :description, :string
7 | field :name, :string
8 | field :price, :float
9 | field :properties, :map
10 | has_many :variants, Tutorial.Products.Variant
11 | has_many :taggings, Tutorial.Taggable.Tagging
12 | has_many :tags, through: [:taggings, :tag]
13 |
14 | timestamps()
15 | end
16 |
17 | @doc false
18 | def changeset(product, attrs) do
19 | product
20 | |> cast(attrs, [:name, :description, :price, :properties])
21 | |> cast_assoc(:variants)
22 | |> validate_required([:name, :description, :price])
23 | |> validate_length(:name, min: 2)
24 | |> validate_number(:price, greater_than: 0)
25 | end
26 | end
27 |
--------------------------------------------------------------------------------
/lib/tutorial_web/gettext.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.Gettext do
2 | @moduledoc """
3 | A module providing Internationalization with a gettext-based API.
4 |
5 | By using [Gettext](https://hexdocs.pm/gettext),
6 | your module gains a set of macros for translations, for example:
7 |
8 | import TutorialWeb.Gettext
9 |
10 | # Simple translation
11 | gettext("Here is the string to translate")
12 |
13 | # Plural translation
14 | ngettext("Here is the string to translate",
15 | "Here are the strings to translate",
16 | 3)
17 |
18 | # Domain-based translation
19 | dgettext("errors", "Here is the error message to translate")
20 |
21 | See the [Gettext Docs](https://hexdocs.pm/gettext) for detailed usage.
22 | """
23 | use Gettext, otp_app: :tutorial
24 | end
25 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/secret/form.html.eex:
--------------------------------------------------------------------------------
1 | <%= form_for @changeset, @action, [class: "block"], fn f -> %>
2 | <%= if @changeset.action do %>
3 |
4 |
The form couln't be saved! Please check the errors below.
5 |
9 | <%= label f, :key %>
10 | <%= text_input f, :key, class: "form-control" %>
11 | <%= error_tag f, :key %>
12 |
13 |
14 |
15 | <%= label f, :value %>
16 | <%= text_input f, :value, class: "form-control" %>
17 | <%= error_tag f, :value %>
18 |
19 |
20 |
21 | <%= submit "Save", class: "btn btn-primary mr-2" %>
22 | <%= link "Back", to: Routes.secret_path(@conn, :index), class: "btn btn-secondary" %>
23 |
24 | <% end %>
25 |
--------------------------------------------------------------------------------
/priv/templates/tailwind.gen.html/show.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 |
9 | <%= for {k, _} <- schema.attrs do %>
10 |
11 | <%= Phoenix.Naming.humanize(Atom.to_string(k)) %>:
12 | <%%= @<%= schema.singular %>.<%= k %> %>
13 |
14 | <% end %>
15 |
16 |
17 |
2 |
6 |
7 |
8 |
9 | Name
10 | Description
11 | Price
12 |
13 |
15 |
16 |
17 | <%= for _ <- @products do %>
18 |
19 |
24 | <% end %>
25 |
26 |
27 |
6 |
7 | <%= for {search_result, idx} <- Enum.with_index(@search_results) do %>
8 |
" phx-click="pick" phx-value-name="<%= search_result %>">
9 | <%= raw format_search_result(search_result, @search_phrase) %>
10 |
11 | <% end %>
12 |
13 |
Search for states
17 | <% end %>
18 |
--------------------------------------------------------------------------------
/priv/templates/swagger.gen.json/view.ex:
--------------------------------------------------------------------------------
1 | defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>View do
2 | use <%= inspect context.web_module %>, :view
3 | alias <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>View
4 |
5 | def render("index.json", %{<%= schema.plural %>: <%= schema.plural %>}) do
6 | %{data: render_many(<%= schema.plural %>, <%= inspect schema.alias %>View, "<%= schema.singular %>.json")}
7 | end
8 |
9 | def render("show.json", %{<%= schema.singular %>: <%= schema.singular %>}) do
10 | %{data: render_one(<%= schema.singular %>, <%= inspect schema.alias %>View, "<%= schema.singular %>.json")}
11 | end
12 |
13 | def render("<%= schema.singular %>.json", %{<%= schema.singular %>: <%= schema.singular %>}) do
14 | %{id: <%= schema.singular %>.id<%= for {k, _} <- schema.attrs do %>,
15 | <%= k %>: <%= schema.singular %>.<%= k %><% end %>}
16 | end
17 | end
18 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/pow/registration/edit.html.eex:
--------------------------------------------------------------------------------
1 | Edit profile
2 |
3 | <%= form_for @changeset, @action, [as: :user], fn f -> %>
4 | <%= if @changeset.action do %>
5 |
6 |
Oops, something went wrong! Please check the errors below.
7 |
27 | <%= submit "Update" %>
28 |
29 | <% end %>
30 |
31 |
--------------------------------------------------------------------------------
/assets/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "repository": {},
3 | "license": "MIT",
4 | "scripts": {
5 | "deploy": "webpack --mode production",
6 | "watch": "webpack --mode development --watch"
7 | },
8 | "dependencies": {
9 | "@tailwindcss/ui": "^0.1.3",
10 | "alpinejs": "^2.2.3",
11 | "interactjs": "^1.8.5",
12 | "phoenix": "file:../deps/phoenix",
13 | "phoenix_html": "file:../deps/phoenix_html",
14 | "phoenix_live_view": "file:../deps/phoenix_live_view",
15 | "tailwindcss": "^1.2.0"
16 | },
17 | "devDependencies": {
18 | "@babel/core": "^7.0.0",
19 | "@babel/preset-env": "^7.0.0",
20 | "@fullhuman/postcss-purgecss": "^2.0.5",
21 | "babel-loader": "^8.0.0",
22 | "copy-webpack-plugin": "^4.5.0",
23 | "css-loader": "^2.1.1",
24 | "mini-css-extract-plugin": "^0.4.0",
25 | "optimize-css-assets-webpack-plugin": "^5.0.1",
26 | "postcss-loader": "^3.0.0",
27 | "terser-webpack-plugin": "^1.1.0",
28 | "webpack": "4.4.0",
29 | "webpack-cli": "^3.3.2"
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | tutorial-*.tar
24 |
25 | # If NPM crashes, it generates a log, let's ignore it too.
26 | npm-debug.log
27 |
28 | # The directory NPM downloads your dependencies sources to.
29 | /assets/node_modules/
30 |
31 | # Since we are building assets from assets/,
32 | # we ignore priv/static. You may want to comment
33 | # this depending on your deployment strategy.
34 | /priv/static/
35 |
--------------------------------------------------------------------------------
/lib/tutorial/products/variant.ex:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.Products.Variant do
2 | use Ecto.Schema
3 | import Ecto.Changeset
4 |
5 | schema "variants" do
6 | field :name, :string
7 | field :value, :string
8 | field :temp_id, :string, virtual: true
9 | field :delete, :boolean, virtual: true
10 |
11 | belongs_to :product, Tutorial.Products.Product
12 |
13 | timestamps()
14 | end
15 |
16 | @doc false
17 | def changeset(variant, attrs) do
18 | variant
19 | |> Map.put(:temp_id, (variant.temp_id || attrs["temp_id"]))
20 | |> cast(attrs, [:name, :value, :delete])
21 | |> validate_required([:name, :value])
22 | |> unique_constraint(:name, name: :variants_name_value_product_id_index)
23 | |> maybe_mark_for_deletion
24 | end
25 |
26 | defp maybe_mark_for_deletion(%{data: %{id: nil}} = changeset), do: changeset
27 | defp maybe_mark_for_deletion(changeset) do
28 | if get_change(changeset, :delete) do
29 | %{changeset | action: :delete}
30 | else
31 | changeset
32 | end
33 | end
34 | end
35 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/product/show.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 |
9 |
10 |
11 | Name:
12 | <%= @product.name %>
13 |
14 |
15 |
16 | Description:
17 | <%= @product.description %>
18 |
19 |
20 |
21 | Price:
22 | <%= @product.price %>
23 |
24 |
25 |
26 |
27 |
28 | <%= live_render @conn, TutorialWeb.ProductTaggingLive, session: %{"id" => @product.id} %>
29 |
30 |
31 |
Register
2 |
3 | <%= form_for @changeset, @action, [as: :user], fn f -> %>
4 | <%= if @changeset.action do %>
5 |
6 |
Oops, something went wrong! Please check the errors below.
7 |
27 | <%= submit "Register" %>
28 |
29 | <% end %>
30 |
31 |
32 | <%= link "Sign in", to: Routes.pow_session_path(@conn, :new) %>
33 |
--------------------------------------------------------------------------------
/test/support/channel_case.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.ChannelCase do
2 | @moduledoc """
3 | This module defines the test case to be used by
4 | channel tests.
5 |
6 | Such tests rely on `Phoenix.ChannelTest` and also
7 | import other functionality to make it easier
8 | to build common data structures and query the data layer.
9 |
10 | Finally, if the test case interacts with the database,
11 | it cannot be async. For this reason, every test runs
12 | inside a transaction which is reset at the beginning
13 | of the test unless the test case is marked as async.
14 | """
15 |
16 | use ExUnit.CaseTemplate
17 |
18 | using do
19 | quote do
20 | # Import conveniences for testing with channels
21 | use Phoenix.ChannelTest
22 |
23 | # The default endpoint for testing
24 | @endpoint TutorialWeb.Endpoint
25 | end
26 | end
27 |
28 | setup tags do
29 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(Tutorial.Repo)
30 |
31 | unless tags[:async] do
32 | Ecto.Adapters.SQL.Sandbox.mode(Tutorial.Repo, {:shared, self()})
33 | end
34 |
35 | :ok
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/page/calendar.html.leex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | <%= Timex.format!(@current_date, "%B %Y", :strftime) %>
5 |
6 |
10 |
14 |
15 |
16 | <%= for day_name <- @day_names do %>
17 |
18 | <%= day_name %>
19 |
20 | <% end %>
21 |
22 |
23 |
24 | <%= for week <- @week_rows do %>
25 |
26 | <%= for day <- week do %>
27 | <%= live_component @conn, TutorialWeb.CalendarDayComponent, day: day, current_date: @current_date %>
28 | <% end %>
29 |
30 | <% end %>
31 |
32 |
33 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/secret/index.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
8 |
9 | Key
10 | Value
11 |
12 |
14 |
15 |
16 | <%= for secret <- @secrets do %>
17 |
18 | <%= secret.key %>
19 | <%= secret.value %>
20 |
21 |
22 | <%= link "Show", to: Routes.secret_path(@conn, :show, secret) %>
23 | <%= link "Edit", to: Routes.secret_path(@conn, :edit, secret) %>
24 | <%= link "Delete", to: Routes.secret_path(@conn, :delete, secret), method: :delete, data: [confirm: "Are you sure?"] %>
25 |
26 |
27 | <% end %>
28 |
29 |
30 |
2 |
6 |
7 |
8 |
9 | <%= for {k, _} <- schema.attrs do %> <%= Phoenix.Naming.humanize(Atom.to_string(k)) %>
10 | <% end %>
11 |
13 |
14 |
15 | <%%= for <%= schema.singular %> <- @<%= schema.plural %> do %>
16 |
17 | <%= for {k, _} <- schema.attrs do %> <%%= <%= schema.singular %>.<%= k %> %>
18 | <% end %>
19 |
20 | <%%= link "Show", to: Routes.<%= schema.route_helper %>_path(@conn, :show, <%= schema.singular %>) %>
21 | <%%= link "Edit", to: Routes.<%= schema.route_helper %>_path(@conn, :edit, <%= schema.singular %>) %>
22 | <%%= link "Delete", to: Routes.<%= schema.route_helper %>_path(@conn, :delete, <%= schema.singular %>), method: :delete, data: [confirm: "Are you sure?"] %>
23 |
24 |
25 | <%% end %>
26 |
27 |
28 |
3 | <%= for tagging <- @taggings do %>
4 |
5 | <%= tagging.tag.name %>
6 | ×
7 |
8 | <% end %>
9 |
18 |
22 |
23 | <%= for {search_result, idx} <- Enum.with_index(@search_results) do %>
24 |
" phx-click="pick" phx-value-name="<%= search_result %>">
25 | <%= raw format_search_result(search_result, @search_phrase) %>
26 |
27 | <% end %>
28 |
29 |
" class="<%= @day_class %>">
10 | <%= Timex.format!(@day, "%d", :strftime) %>
11 |
12 | """
13 | end
14 |
15 | defp day_class(assigns) do
16 | cond do
17 | today?(assigns) ->
18 | "text-xs p-2 text-gray-600 border border-gray-200 bg-green-200 hover:bg-green-300 cursor-pointer"
19 | current_date?(assigns) ->
20 | "text-xs p-2 text-gray-600 border border-gray-200 bg-blue-100 cursor-pointer"
21 | other_month?(assigns) ->
22 | "text-xs p-2 text-gray-400 border border-gray-200 bg-gray-200 cursor-not-allowed"
23 | true ->
24 | "text-xs p-2 text-gray-600 border border-gray-200 bg-white hover:bg-blue-100 cursor-pointer"
25 | end
26 | end
27 |
28 | defp current_date?(assigns) do
29 | Map.take(assigns.day, [:year, :month, :day]) == Map.take(assigns.current_date, [:year, :month, :day])
30 | end
31 |
32 | defp today?(assigns) do
33 | Map.take(assigns.day, [:year, :month, :day]) == Map.take(Timex.now, [:year, :month, :day])
34 | end
35 |
36 | defp other_month?(assigns) do
37 | Map.take(assigns.day, [:year, :month]) != Map.take(assigns.current_date, [:year, :month])
38 | end
39 | end
40 |
--------------------------------------------------------------------------------
/lib/tutorial_web/live/draggable_live.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.DraggableLive do
2 | use Phoenix.LiveView
3 |
4 | alias Tutorial.DraggableServer
5 | alias Tutorial.Presence
6 |
7 | def mount(_params, %{"session_id" => session_id}, socket) do
8 | if connected?(socket) do
9 | # As soon as a new instance if the LiveView is mounted, track the session id
10 | {:ok, _} = Presence.track(self(), "tutorial:presence", session_id, %{
11 | session_id: session_id,
12 | joined_at: :os.system_time(:seconds)
13 | })
14 |
15 | DraggableServer.subscribe(session_id)
16 | end
17 |
18 | {x, y} = DraggableServer.get_coordinates(session_id)
19 |
20 | assigns = [
21 | x: x,
22 | y: y,
23 | session_id: session_id
24 | ]
25 |
26 | {:ok, assign(socket, assigns)}
27 | end
28 |
29 | def render(assigns) do
30 | ~L"""
31 |
33 | """
34 | end
35 |
36 | def handle_event("moving", %{"x" => x, "y" => y}, socket) do
37 | coordinates = {socket.assigns.x + x, socket.assigns.y + y}
38 | DraggableServer.set_coordinates(socket.assigns.session_id, coordinates)
39 | {:noreply, socket}
40 | end
41 |
42 | def handle_info({:updated_coordinates, {x, y}}, socket) do
43 | assigns = [
44 | x: x,
45 | y: y
46 | ]
47 |
48 | {:noreply, assign(socket, assigns)}
49 | end
50 | end
51 |
--------------------------------------------------------------------------------
/lib/tutorial_web/live/task_starter_live.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.TaskStarterLive do
2 | use Phoenix.LiveView
3 |
4 | alias Tutorial.Worker
5 |
6 | def mount(_params, _session, socket) do
7 | if connected?(socket) do
8 | Worker.subscribe()
9 | end
10 |
11 | assigns = [
12 | loading: false,
13 | result: nil
14 | ]
15 |
16 | {:ok, assign(socket, assigns)}
17 | end
18 |
19 | def render(assigns) do
20 | ~L"""
21 |
22 | Long running task that might crash
23 |
24 |
25 | <%= if @result || @loading do %>
26 | <%= if @loading do %>
27 |
28 |
30 | <% else %>
31 | Result: <%= @result %>
32 | <% end %>
33 | <% end %>
34 |
Tutorial · Fullstack Phoenix
8 | <%= csrf_meta_tag() %>
9 |
20 | <%= for {type, class} <- [{:info, "info"}, {:error, "danger"}] do %>
21 | <%= if get_flash(@conn, type) do %>
22 | <%= get_flash(@conn, type) %>
23 | <% end %>
24 | <% end %>
25 | <%= @inner_content %>
26 |
27 |
32 |
33 |
34 |
35 |
--------------------------------------------------------------------------------
/lib/tutorial_web/endpoint.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.Endpoint do
2 | use Phoenix.Endpoint, otp_app: :tutorial
3 |
4 | @session_options [
5 | store: :cookie,
6 | key: "_tutorial_key",
7 | signing_salt: "4qBWyMiY"
8 | ]
9 |
10 | socket "/live", Phoenix.LiveView.Socket,
11 | websocket: [connect_info: [session: @session_options]]
12 |
13 | socket "/socket", TutorialWeb.UserSocket,
14 | websocket: true,
15 | longpoll: false
16 |
17 | # Serve at "/" the static files from "priv/static" directory.
18 | #
19 | # You should set gzip to true if you are running phx.digest
20 | # when deploying your static files in production.
21 | plug Plug.Static,
22 | at: "/",
23 | from: :tutorial,
24 | gzip: false,
25 | only: ~w(css fonts images js favicon.ico robots.txt)
26 |
27 | # Code reloading can be explicitly enabled under the
28 | # :code_reloader configuration of your endpoint.
29 | if code_reloading? do
30 | socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket
31 | plug Phoenix.LiveReloader
32 | plug Phoenix.CodeReloader
33 | end
34 |
35 | plug Plug.RequestId
36 | plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint]
37 |
38 | plug Plug.Parsers,
39 | parsers: [:urlencoded, :multipart, :json],
40 | pass: ["*/*"],
41 | json_decoder: Phoenix.json_library()
42 |
43 | plug Plug.MethodOverride
44 | plug Plug.Head
45 |
46 | # The session will be stored in the cookie and signed,
47 | # this means its contents can be read but not tampered with.
48 | # Set :encryption_salt if you would also like to encrypt it.
49 | plug Plug.Session, @session_options
50 | plug Pow.Plug.Session, otp_app: :tutorial
51 |
52 | plug TutorialWeb.Router
53 | end
54 |
--------------------------------------------------------------------------------
/config/config.exs:
--------------------------------------------------------------------------------
1 | # This file is responsible for configuring your application
2 | # and its dependencies with the aid of the Mix.Config module.
3 | #
4 | # This configuration file is loaded before any dependency and
5 | # is restricted to this project.
6 |
7 | # General application configuration
8 | use Mix.Config
9 |
10 | config :tutorial,
11 | ecto_repos: [Tutorial.Repo]
12 |
13 | # Configures the endpoint
14 | config :tutorial, TutorialWeb.Endpoint,
15 | url: [host: "localhost"],
16 | secret_key_base: "IgK/07WPhpZdY3pPfPkF1FhjTlAt1hCWCAYgG3nKsNbD89i6Z/lh/Hb1e0XX4W6U",
17 | render_errors: [view: TutorialWeb.ErrorView, accepts: ~w(html json)],
18 | pubsub: [name: Tutorial.PubSub, adapter: Phoenix.PubSub.PG2],
19 | live_view: [
20 | signing_salt: "ne2OraWqFq6nPInMelyiZPZDgIIQmtRN"
21 | ]
22 |
23 | # Configures Elixir's Logger
24 | config :logger, :console,
25 | format: "$time $metadata[$level] $message\n",
26 | metadata: [:request_id]
27 |
28 | # Use Jason for JSON parsing in Phoenix
29 | config :phoenix, :json_library, Jason
30 |
31 | config :tutorial, :phoenix_swagger,
32 | swagger_files: %{
33 | "priv/static/swagger.json" => [
34 | router: TutorialWeb.Router, # phoenix routes will be converted to swagger paths
35 | endpoint: TutorialWeb.Endpoint # (optional) endpoint config used to set host, port and https schemes.
36 | ]
37 | }
38 |
39 | config :phoenix_swagger, json_library: Jason
40 |
41 | config :tutorial, :pow,
42 | user: Tutorial.Users.User,
43 | repo: Tutorial.Repo,
44 | web_module: TutorialWeb
45 |
46 | # Import environment specific config. This must remain at the bottom
47 | # of this file so it overrides the configuration defined above.
48 | import_config "#{Mix.env()}.exs"
49 |
--------------------------------------------------------------------------------
/test/support/data_case.ex:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.DataCase do
2 | @moduledoc """
3 | This module defines the setup for tests requiring
4 | access to the application's data layer.
5 |
6 | You may define functions here to be used as helpers in
7 | your tests.
8 |
9 | Finally, if the test case interacts with the database,
10 | we enable the SQL sandbox, so changes done to the database
11 | are reverted at the end of every test. If you are using
12 | PostgreSQL, you can even run database tests asynchronously
13 | by setting `use TutorialWeb.DataCase, async: true`, although
14 | this option is not recommendded for other databases.
15 | """
16 |
17 | use ExUnit.CaseTemplate
18 |
19 | using do
20 | quote do
21 | alias Tutorial.Repo
22 |
23 | import Ecto
24 | import Ecto.Changeset
25 | import Ecto.Query
26 | import Tutorial.DataCase
27 | end
28 | end
29 |
30 | setup tags do
31 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(Tutorial.Repo)
32 |
33 | unless tags[:async] do
34 | Ecto.Adapters.SQL.Sandbox.mode(Tutorial.Repo, {:shared, self()})
35 | end
36 |
37 | :ok
38 | end
39 |
40 | @doc """
41 | A helper that transforms changeset errors into a map of messages.
42 |
43 | assert {:error, changeset} = Accounts.create_user(%{password: "short"})
44 | assert "password is too short" in errors_on(changeset).password
45 | assert %{password: ["password is too short"]} = errors_on(changeset)
46 |
47 | """
48 | def errors_on(changeset) do
49 | Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
50 | Regex.replace(~r"%{(\w+)}", message, fn _, key ->
51 | opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string()
52 | end)
53 | end)
54 | end
55 | end
56 |
--------------------------------------------------------------------------------
/lib/tutorial/draggable_server.ex:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.DraggableServer do
2 | use GenServer
3 |
4 | alias Tutorial.PubSub
5 |
6 | @default_coordinates {10, 10}
7 |
8 | def init(_opts) do
9 | Phoenix.PubSub.subscribe(PubSub, "tutorial:presence")
10 |
11 | state = %{}
12 | {:ok, state}
13 | end
14 |
15 | def start_link(opts) do
16 | GenServer.start_link(__MODULE__, opts, name: __MODULE__)
17 | end
18 |
19 | def subscribe(session_id), do: Phoenix.PubSub.subscribe(PubSub, "draggable:#{session_id}")
20 |
21 | def set_coordinates(session_id, coordinates) do
22 | GenServer.cast(__MODULE__, {:set_coordinates, session_id, coordinates})
23 | end
24 |
25 | def get_coordinates(session_id) do
26 | GenServer.call(__MODULE__, {:get_cordinates, session_id})
27 | end
28 |
29 | # Internal interface
30 |
31 | def handle_cast({:set_coordinates, session_id, coordinates}, state) do
32 | Phoenix.PubSub.broadcast(PubSub, "draggable:#{session_id}", {:updated_coordinates, coordinates})
33 | {:noreply, Map.put(state, session_id, coordinates)}
34 | end
35 |
36 | def handle_call({:get_cordinates, session_id}, _from, state) do
37 | {:reply, Map.get(state, session_id, @default_coordinates), state}
38 | end
39 |
40 | def handle_info(%Phoenix.Socket.Broadcast{event: "presence_diff", payload: diff}, state) do
41 | state =
42 | state
43 | |> handle_leaves(diff.leaves)
44 |
45 | {:noreply, state}
46 | end
47 |
48 | defp handle_leaves(state, leaves) do
49 | Enum.reduce(leaves, state, fn {session_id, _}, state ->
50 | Tutorial.Presence.list("tutorial:presence")
51 | |> Map.get(session_id)
52 | |> case do
53 | nil -> Map.delete(state, session_id)
54 | _ -> state
55 | end
56 | end)
57 | end
58 | end
59 |
--------------------------------------------------------------------------------
/lib/tutorial_web/views/error_helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.ErrorHelpers do
2 | @moduledoc """
3 | Conveniences for translating and building error messages.
4 | """
5 |
6 | use Phoenix.HTML
7 |
8 | @doc """
9 | Generates tag for inlined form input errors.
10 | """
11 | def error_tag(form, field) do
12 | Enum.map(Keyword.get_values(form.errors, field), fn error ->
13 | field_name = field |> Atom.to_string() |> String.capitalize()
14 | content_tag(:span, "#{field_name} #{translate_error(error)}", class: "block mt-1 text-sm text-red-700", data: [phx_error_for: input_id(form, field)])
15 | end)
16 | end
17 |
18 | @doc """
19 | Translates an error message using gettext.
20 | """
21 | def translate_error({msg, opts}) do
22 | # When using gettext, we typically pass the strings we want
23 | # to translate as a static argument:
24 | #
25 | # # Translate "is invalid" in the "errors" domain
26 | # dgettext("errors", "is invalid")
27 | #
28 | # # Translate the number of files with plural rules
29 | # dngettext("errors", "1 file", "%{count} files", count)
30 | #
31 | # Because the error messages we show in our forms and APIs
32 | # are defined inside Ecto, we need to translate them dynamically.
33 | # This requires us to call the Gettext module passing our gettext
34 | # backend as first argument.
35 | #
36 | # Note we use the "errors" domain, which means translations
37 | # should be written to the errors.po file. The :count option is
38 | # set by Ecto and indicates we should also apply plural rules.
39 | if count = opts[:count] do
40 | Gettext.dngettext(TutorialWeb.Gettext, "errors", msg, msg, count, opts)
41 | else
42 | Gettext.dgettext(TutorialWeb.Gettext, "errors", msg, opts)
43 | end
44 | end
45 | end
46 |
--------------------------------------------------------------------------------
/lib/tutorial_web/router.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.Router do
2 | use TutorialWeb, :router
3 | use Pow.Phoenix.Router
4 |
5 | pipeline :browser do
6 | plug :accepts, ["html"]
7 | plug :fetch_session
8 | plug :fetch_live_flash
9 | plug :put_root_layout, {TutorialWeb.LayoutView, :root}
10 | plug :protect_from_forgery
11 | plug :put_secure_browser_headers
12 | plug TutorialWeb.GenerateCSRF
13 | plug TutorialWeb.AssignSession
14 | end
15 |
16 | pipeline :api do
17 | plug :accepts, ["json"]
18 | end
19 |
20 | pipeline :protected do
21 | plug Pow.Plug.RequireAuthenticated, error_handler: Pow.Phoenix.PlugErrorHandler
22 | plug TutorialWeb.Plugs.SetCurrentAccount
23 | end
24 |
25 | scope "/" do
26 | pipe_through :browser
27 |
28 | pow_routes()
29 | end
30 |
31 | scope "/", TutorialWeb do
32 | pipe_through :browser
33 |
34 | get "/", PageController, :index
35 | get "/draggable", PageController, :draggable
36 | get "/task_async", PageController, :task_async
37 | live "/modals", ModalsLive, :index
38 |
39 | live "/products", ProductListLive # NEEDS TO BE ABOVE
40 | resources "/products", ProductController
41 | end
42 |
43 | scope "/", TutorialWeb do
44 | pipe_through [:protected, :browser]
45 |
46 | get "/private", PageController, :private
47 | resources "/secrets", SecretController
48 | end
49 |
50 | # Other scopes may use custom stacks.
51 | # scope "/api", TutorialWeb do
52 | # pipe_through :api
53 | # end
54 |
55 | scope "/api/swagger" do
56 | forward "/", PhoenixSwagger.Plug.SwaggerUI, otp_app: :tutorial, swagger_file: "swagger.json"
57 | end
58 |
59 | def swagger_info do
60 | %{
61 | info: %{
62 | version: "1.0",
63 | title: "Tutorial App - Fullstack Phoenix"
64 | }
65 | }
66 | end
67 | end
68 |
--------------------------------------------------------------------------------
/assets/js/app.js:
--------------------------------------------------------------------------------
1 | // We need to import the CSS so that webpack will load it.
2 | // The MiniCssExtractPlugin is used to separate it out into
3 | // its own CSS file.
4 | import css from "../css/app.css"
5 |
6 | // webpack automatically bundles all modules in your
7 | // entry points. Those entry points can be configured
8 | // in "webpack.config.js".
9 | //
10 | // Import dependencies
11 | //
12 | import "phoenix_html"
13 |
14 | import "alpinejs"
15 |
16 | import interact from "interactjs"
17 |
18 | // Import local files
19 | //
20 | // Local files can be imported directly using relative paths, for example:
21 | import socket from "./socket"
22 |
23 | import {Socket} from "phoenix"
24 | import LiveSocket from "phoenix_live_view"
25 |
26 | let Hooks = {}
27 | Hooks.Draggable = {
28 | mounted() {
29 | let instance = this
30 |
31 | interact(this.el).draggable({
32 | onmove(event) {
33 | instance.pushEvent("moving", {x: event.dx, y: event.dy})
34 | }
35 | })
36 | }
37 | }
38 |
39 | Hooks.initModal = {
40 | mounted() {
41 | const handleOpenCloseEvent = event => {
42 | if (event.detail.open === false) {
43 | this.el.removeEventListener("modal-change", handleOpenCloseEvent)
44 | this.pushEvent("close-modal", {id: this.el.id})
45 | }
46 | }
47 | this.el.addEventListener("modal-change", handleOpenCloseEvent)
48 | }
49 | }
50 |
51 | Hooks.closeModal = {
52 | mounted() {
53 | const modalId = this.el.dataset.modalId
54 | const el = document.getElementById(modalId)
55 | const event = new CustomEvent('close-modal');
56 | el.dispatchEvent(event)
57 | }
58 | }
59 |
60 | let csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute("content");
61 | let liveSocket = new LiveSocket("/live", Socket, {params: {_csrf_token: csrfToken}, hooks: Hooks});
62 | liveSocket.connect()
63 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/product/form.html.leex:
--------------------------------------------------------------------------------
1 | <%= form_for @changeset, @action, [phx_change: :validate, class: "block", csrf_token: @csrf_token], fn f -> %>
2 |
3 | <%= label f, :name %>
4 | <%= text_input f, :name, class: "form-control" %>
5 | <%= error_tag f, :name %>
6 |
7 |
8 |
9 | <%= label f, :description %>
10 | <%= textarea f, :description, class: "form-control" %>
11 | <%= error_tag f, :description %>
12 |
13 |
14 |
15 | <%= label f, :price %>
16 | <%= number_input f, :price, step: "any", class: "form-control" %>
17 | <%= error_tag f, :price %>
18 |
19 |
20 | Variants
21 |
22 | <%= inputs_for f, :variants, fn v -> %>
23 |
24 |
25 | <%= label v, :name %>
26 | <%= text_input v, :name, class: "form-control" %>
27 | <%= error_tag v, :name %>
28 |
29 |
30 |
31 | <%= label v, :value %>
32 | <%= text_input v, :value, class: "form-control" %>
33 | <%= error_tag v, :value %>
34 |
35 |
36 |
45 |
Add a variant
49 |
50 |
51 | <%= submit "Save", class: "btn btn-primary mr-2", disabled: !@changeset.valid? %>
52 | <%= link "Back", to: Routes.product_path(@conn, :index), class: "btn btn-secondary" %>
53 |
54 | <% end %>
55 |
--------------------------------------------------------------------------------
/lib/tutorial_web.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb do
2 | @moduledoc """
3 | The entrypoint for defining your web interface, such
4 | as controllers, views, channels and so on.
5 |
6 | This can be used in your application as:
7 |
8 | use TutorialWeb, :controller
9 | use TutorialWeb, :view
10 |
11 | The definitions below will be executed for every view,
12 | controller, etc, so keep them short and clean, focused
13 | on imports, uses and aliases.
14 |
15 | Do NOT define functions inside the quoted expressions
16 | below. Instead, define any helper function in modules
17 | and import those modules here.
18 | """
19 |
20 | def controller do
21 | quote do
22 | use Phoenix.Controller, namespace: TutorialWeb
23 |
24 | import Plug.Conn
25 | import TutorialWeb.Gettext
26 | alias TutorialWeb.Router.Helpers, as: Routes
27 | import Phoenix.LiveView.Controller
28 | end
29 | end
30 |
31 | def view do
32 | quote do
33 | use Phoenix.View,
34 | root: "lib/tutorial_web/templates",
35 | namespace: TutorialWeb
36 |
37 | # Import convenience functions from controllers
38 | import Phoenix.Controller, only: [get_flash: 1, get_flash: 2, view_module: 1]
39 |
40 | # Use all HTML functionality (forms, tags, etc)
41 | use Phoenix.HTML
42 |
43 | import TutorialWeb.ErrorHelpers
44 | import TutorialWeb.Gettext
45 | alias TutorialWeb.Router.Helpers, as: Routes
46 | import Phoenix.LiveView.Helpers
47 | end
48 | end
49 |
50 | def router do
51 | quote do
52 | use Phoenix.Router
53 | import Plug.Conn
54 | import Phoenix.Controller
55 | import Phoenix.LiveView.Router
56 | end
57 | end
58 |
59 | def channel do
60 | quote do
61 | use Phoenix.Channel
62 | import TutorialWeb.Gettext
63 | end
64 | end
65 |
66 | @doc """
67 | When used, dispatch to the appropriate controller/view/etc.
68 | """
69 | defmacro __using__(which) when is_atom(which) do
70 | apply(__MODULE__, which, [])
71 | end
72 | end
73 |
--------------------------------------------------------------------------------
/lib/tutorial_web/live/calendar_live.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.CalendarLive do
2 | use Phoenix.LiveView
3 | use Timex
4 |
5 | @week_start_at :mon
6 |
7 | def mount(_params, _session, socket) do
8 | current_date = Timex.now
9 |
10 | assigns = [
11 | conn: socket,
12 | current_date: current_date,
13 | day_names: day_names(@week_start_at),
14 | week_rows: week_rows(current_date)
15 | ]
16 |
17 | {:ok, assign(socket, assigns)}
18 | end
19 |
20 | def render(assigns) do
21 | TutorialWeb.PageView.render("calendar.html", assigns)
22 | end
23 |
24 | defp day_names(:sun), do: [7, 1, 2, 3, 4, 5, 6] |> Enum.map(&Timex.day_shortname/1)
25 | defp day_names(_), do: [1, 2, 3, 4, 5, 6, 7] |> Enum.map(&Timex.day_shortname/1)
26 |
27 | defp week_rows(current_date) do
28 | first =
29 | current_date
30 | |> Timex.beginning_of_month()
31 | |> Timex.beginning_of_week(@week_start_at)
32 |
33 | last =
34 | current_date
35 | |> Timex.end_of_month()
36 | |> Timex.end_of_week(@week_start_at)
37 |
38 | Interval.new(from: first, until: last)
39 | |> Enum.map(& &1)
40 | |> Enum.chunk_every(7)
41 | end
42 |
43 | def handle_event("prev-month", _, socket) do
44 | current_date = Timex.shift(socket.assigns.current_date, months: -1)
45 |
46 | assigns = [
47 | current_date: current_date,
48 | week_rows: week_rows(current_date)
49 | ]
50 |
51 | {:noreply, assign(socket, assigns)}
52 | end
53 |
54 | def handle_event("next-month", _, socket) do
55 | current_date = Timex.shift(socket.assigns.current_date, months: 1)
56 |
57 | assigns = [
58 | current_date: current_date,
59 | week_rows: week_rows(current_date)
60 | ]
61 |
62 | {:noreply, assign(socket, assigns)}
63 | end
64 |
65 | def handle_event("pick-date", %{"date" => date}, socket) do
66 | current_date = Timex.parse!(date, "{YYYY}-{0M}-{D}")
67 |
68 | assigns = [
69 | current_date: current_date
70 | ]
71 |
72 | {:noreply, assign(socket, assigns)}
73 | end
74 | end
75 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/product/products.html.leex:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
8 |
9 | Name
10 | Description
11 | Price
12 |
13 |
15 |
16 |
17 | <%= for product <- @products do %>
18 |
19 | <%= product.name %>
20 | <%= product.description %>
21 | <%= product.price %>
22 |
23 |
24 | <%= link "Show", to: Routes.product_path(@conn, :show, product) %>
25 | <%= link "Edit", to: Routes.product_path(@conn, :edit, product) %>
26 | <%= link "Delete", to: Routes.product_path(@conn, :delete, product), csrf_token: @csrf_token, method: :delete, data: [confirm: "Are you sure?"] %>
27 |
28 |
29 | <% end %>
30 |
31 |
32 |
33 |
34 |
47 |
48 |
23 | <%= if @action == "CLOSE" do %>
24 |
25 | <% end %>
26 |
27 |
28 |
31 |
32 |
45 |
50 | """
51 | end
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/test/tutorial/secrets_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.SecretsTest do
2 | use Tutorial.DataCase
3 |
4 | alias Tutorial.Secrets
5 |
6 | describe "secrets" do
7 | alias Tutorial.Secrets.Secret
8 |
9 | @valid_attrs %{key: "some key", value: "some value"}
10 | @update_attrs %{key: "some updated key", value: "some updated value"}
11 | @invalid_attrs %{key: nil, value: nil}
12 |
13 | def account_fixture() do
14 | {:ok, account} = Tutorial.Accounts.create_account(%{name: "Acme Corp"})
15 | account
16 | end
17 |
18 | def secret_fixture(account, attrs \\ %{}) do
19 | {:ok, secret} =
20 | Secrets.create_secret(
21 | account,
22 | Enum.into(attrs, @valid_attrs)
23 | )
24 |
25 | secret
26 | end
27 |
28 | setup do
29 | account = account_fixture()
30 | secret = secret_fixture(account)
31 | {:ok, %{account: account, secret: secret}}
32 | end
33 |
34 | test "list_secrets/0 returns all secrets", %{account: account, secret: secret} do
35 | assert Secrets.list_secrets(account) == [secret]
36 | end
37 |
38 | test "get_secret!/1 returns the secret with given id", %{account: account, secret: secret} do
39 | assert Secrets.get_secret!(account, secret.id) == secret
40 | end
41 |
42 | test "create_secret/1 with valid data creates a secret", %{account: account} do
43 | assert {:ok, %Secret{} = secret} = Secrets.create_secret(account, @valid_attrs)
44 | assert secret.key == "some key"
45 | assert secret.value == "some value"
46 | end
47 |
48 | test "create_secret/1 with invalid data returns error changeset", %{account: account} do
49 | assert {:error, %Ecto.Changeset{}} = Secrets.create_secret(account, @invalid_attrs)
50 | end
51 |
52 | test "update_secret/2 with valid data updates the secret", %{secret: secret} do
53 | assert {:ok, %Secret{} = secret} = Secrets.update_secret(secret, @update_attrs)
54 | assert secret.key == "some updated key"
55 | assert secret.value == "some updated value"
56 | end
57 |
58 | test "update_secret/2 with invalid data returns error changeset", %{account: account, secret: secret} do
59 | assert {:error, %Ecto.Changeset{}} = Secrets.update_secret(secret, @invalid_attrs)
60 | assert secret == Secrets.get_secret!(account, secret.id)
61 | end
62 |
63 | test "delete_secret/1 deletes the secret", %{account: account, secret: secret} do
64 | assert {:ok, %Secret{}} = Secrets.delete_secret(secret)
65 | assert_raise Ecto.NoResultsError, fn -> Secrets.get_secret!(account, secret.id) end
66 | end
67 |
68 | test "change_secret/1 returns a secret changeset", %{secret: secret} do
69 | assert %Ecto.Changeset{} = Secrets.change_secret(secret)
70 | end
71 | end
72 | end
73 |
--------------------------------------------------------------------------------
/lib/tutorial_web/live/search_form_live.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.SearchFormLive do
2 | use Phoenix.LiveView
3 |
4 | def mount(_params, _session, socket) do
5 | assigns = [
6 | conn: socket,
7 | search_results: [],
8 | search_phrase: "",
9 | current_focus: -1
10 | ]
11 |
12 | {:ok, assign(socket, assigns)}
13 | end
14 |
15 | def render(assigns) do
16 | TutorialWeb.PageView.render("search_form.html", assigns)
17 | end
18 |
19 | def handle_event("search", %{"search_phrase" => search_phrase}, socket) do
20 | assigns = [
21 | search_results: search(search_phrase),
22 | search_phrase: search_phrase
23 | ]
24 |
25 | {:noreply, assign(socket, assigns)}
26 | end
27 |
28 | def handle_event("pick", %{"name" => search_phrase}, socket) do
29 | assigns = [
30 | search_results: [],
31 | search_phrase: search_phrase
32 | ]
33 |
34 | {:noreply, assign(socket, assigns)}
35 | end
36 |
37 | def handle_event("submit", _, socket), do: {:noreply, socket} # PREVENT FORM SUBMIT
38 |
39 | def handle_event("set-focus", %{"keyCode" => 38}, socket) do # UP
40 | current_focus =
41 | Enum.max([(socket.assigns.current_focus - 1), 0])
42 | {:noreply, assign(socket, current_focus: current_focus)}
43 | end
44 |
45 | def handle_event("set-focus", %{"keyCode" => 40}, socket) do # DOWN
46 | current_focus =
47 | Enum.min([(socket.assigns.current_focus + 1), (length(socket.assigns.search_results)-1)])
48 | {:noreply, assign(socket, current_focus: current_focus)}
49 | end
50 |
51 | def handle_event("set-focus", %{"keyCode" => 13}, socket) do # ENTER
52 | case Enum.at(socket.assigns.search_results, socket.assigns.current_focus) do
53 | "" <> search_phrase -> handle_event("pick", %{"name" => search_phrase}, socket)
54 | _ -> {:noreply, socket}
55 | end
56 | end
57 |
58 | # FALLBACK FOR NON RELATED KEY STROKES
59 | def handle_event("set-focus", _, socket), do: {:noreply, socket}
60 |
61 | def search(""), do: []
62 | def search(search_phrase) do
63 | states()
64 | |> Enum.filter(& matches?(&1, search_phrase))
65 | end
66 |
67 | def matches?(first, second) do
68 | String.starts_with?(
69 | String.downcase(first), String.downcase(second)
70 | )
71 | end
72 |
73 | def states do
74 | [
75 | "Alabama", "Alaska", "Arizona", "Arkansas", "California",
76 | "Colorado", "Connecticut", "Delaware", "Florida", "Georgia", "Hawaii",
77 | "Idaho", "Illinois", "Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana",
78 | "Maine", "Maryland", "Massachusetts", "Michigan", "Minnesota",
79 | "Mississippi", "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire",
80 | "New Jersey", "New Mexico", "New York", "North Carolina", "North Dakota",
81 | "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island",
82 | "South Carolina", "South Dakota", "Tennessee", "Texas", "Utah", "Vermont",
83 | "Virginia", "Washington", "West Virginia", "Wisconsin", "Wyoming"
84 | ]
85 | end
86 | end
87 |
--------------------------------------------------------------------------------
/priv/templates/tailwind.gen.html/controller.ex:
--------------------------------------------------------------------------------
1 | defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Controller do
2 | use <%= inspect context.web_module %>, :controller
3 |
4 | alias <%= inspect context.module %>
5 | alias <%= inspect schema.module %>
6 |
7 | def index(conn, _params) do
8 | <%= schema.plural %> = <%= inspect context.alias %>.list_<%= schema.plural %>()
9 | render(conn, "index.html", <%= schema.plural %>: <%= schema.plural %>)
10 | end
11 |
12 | def new(conn, _params) do
13 | changeset = <%= inspect context.alias %>.change_<%= schema.singular %>(%<%= inspect schema.alias %>{})
14 | render(conn, "new.html", changeset: changeset)
15 | end
16 |
17 | def create(conn, %{<%= inspect schema.singular %> => <%= schema.singular %>_params}) do
18 | case <%= inspect context.alias %>.create_<%= schema.singular %>(<%= schema.singular %>_params) do
19 | {:ok, <%= schema.singular %>} ->
20 | conn
21 | |> put_flash(:info, "<%= schema.human_singular %> created successfully.")
22 | |> redirect(to: Routes.<%= schema.route_helper %>_path(conn, :show, <%= schema.singular %>))
23 |
24 | {:error, %Ecto.Changeset{} = changeset} ->
25 | render(conn, "new.html", changeset: changeset)
26 | end
27 | end
28 |
29 | def show(conn, %{"id" => id}) do
30 | <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(id)
31 | render(conn, "show.html", <%= schema.singular %>: <%= schema.singular %>)
32 | end
33 |
34 | def edit(conn, %{"id" => id}) do
35 | <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(id)
36 | changeset = <%= inspect context.alias %>.change_<%= schema.singular %>(<%= schema.singular %>)
37 | render(conn, "edit.html", <%= schema.singular %>: <%= schema.singular %>, changeset: changeset)
38 | end
39 |
40 | def update(conn, %{"id" => id, <%= inspect schema.singular %> => <%= schema.singular %>_params}) do
41 | <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(id)
42 |
43 | case <%= inspect context.alias %>.update_<%= schema.singular %>(<%= schema.singular %>, <%= schema.singular %>_params) do
44 | {:ok, <%= schema.singular %>} ->
45 | conn
46 | |> put_flash(:info, "<%= schema.human_singular %> updated successfully.")
47 | |> redirect(to: Routes.<%= schema.route_helper %>_path(conn, :show, <%= schema.singular %>))
48 |
49 | {:error, %Ecto.Changeset{} = changeset} ->
50 | render(conn, "edit.html", <%= schema.singular %>: <%= schema.singular %>, changeset: changeset)
51 | end
52 | end
53 |
54 | def delete(conn, %{"id" => id}) do
55 | <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(id)
56 | {:ok, _<%= schema.singular %>} = <%= inspect context.alias %>.delete_<%= schema.singular %>(<%= schema.singular %>)
57 |
58 | conn
59 | |> put_flash(:info, "<%= schema.human_singular %> deleted successfully.")
60 | |> redirect(to: Routes.<%= schema.route_helper %>_path(conn, :index))
61 | end
62 | end
63 |
--------------------------------------------------------------------------------
/lib/tutorial_web/live/modals_live.html.leex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Open modal one
5 |
6 |
7 |
8 |
9 | Open modal two
10 |
11 |
12 |
13 |
14 | <%= live_component @socket, TutorialWeb.ModalComponent, id: "modal-one" do %>
15 |
38 | <% end %>
39 |
40 | <%= live_component @socket, TutorialWeb.ModalComponent, id: "modal-two" do %>
41 |
42 |
Card title
43 |
Secondary text
44 |
45 | Lorem ipsum dolor sit amet, consectetur adipisicing elit. Voluptatibus quia, nulla!
46 | Maiores et perferendis eaque, exercitationem praesentium nihil.
47 |
48 |
4 |
5 | [https://fullstackphoenix.com](https://fullstackphoenix.com)
6 |
--------------------------------------------------------------------------------
/lib/tutorial_web/plugs/generate_csrf.ex:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.GenerateCSRF do
2 | import Plug.Conn, only: [put_session: 3]
3 |
4 | def init(_opts), do: nil
5 |
6 | def call(conn, _opts), do: put_session(conn, :csrf_token, Phoenix.Controller.get_csrf_token())
7 | end
8 |
--------------------------------------------------------------------------------
/test/tutorial_web/controllers/page_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule TutorialWeb.PageControllerTest do
2 | use TutorialWeb.ConnCase
3 |
4 | test "GET /", %{conn: conn} do
5 | conn = get(conn, "/")
6 | assert html_response(conn, 200) =~ "Fullstack Phoenix"
7 | end
8 | end
9 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20200210061018_add_properties_to_products.exs:
--------------------------------------------------------------------------------
1 | defmodule Tutorial.Repo.Migrations.AddPropertiesToProducts do
2 | use Ecto.Migration
3 |
4 | def change do
5 | alter table(:products) do
6 | add :properties, :map, default: %{}
7 | end
8 | end
9 | end
10 |
--------------------------------------------------------------------------------
/lib/tutorial.ex:
--------------------------------------------------------------------------------
1 | defmodule Tutorial do
2 | @moduledoc """
3 | Tutorial keeps the contexts that define your domain
4 | and business logic.
5 |
6 | Contexts are also responsible for managing your data, regardless
7 | if it comes from the database, an external API or others.
8 | """
9 | end
10 |
--------------------------------------------------------------------------------
/lib/tutorial_web/templates/secret/new.html.eex:
--------------------------------------------------------------------------------
1 |