├── assets
├── css
│ └── app.css
├── static
│ ├── favicon.ico
│ ├── images
│ │ └── phoenix.png
│ └── robots.txt
├── package.json
├── js
│ ├── app.js
│ └── socket.js
└── brunch-config.js
├── test
├── test_helper.exs
├── coherence_demo_web
│ ├── views
│ │ ├── page_view_test.exs
│ │ ├── layout_view_test.exs
│ │ └── error_view_test.exs
│ └── controllers
│ │ ├── page_controller_test.exs
│ │ └── post_controller_test.exs
├── support
│ ├── channel_case.ex
│ ├── conn_case.ex
│ └── data_case.ex
└── coherence_demo
│ └── blogs
│ └── blogs_test.exs
├── lib
├── coherence_demo_web
│ ├── views
│ │ ├── page_view.ex
│ │ ├── post_view.ex
│ │ ├── layout_view.ex
│ │ ├── coherence
│ │ │ ├── coherence_view.ex
│ │ │ ├── email_view.ex
│ │ │ ├── layout_view.ex
│ │ │ ├── session_view.ex
│ │ │ ├── unlock_view.ex
│ │ │ ├── invitation_view.ex
│ │ │ ├── password_view.ex
│ │ │ ├── confirmation_view.ex
│ │ │ ├── registration_view.ex
│ │ │ └── coherence_view_helpers.ex
│ │ ├── user_view.ex
│ │ ├── error_view.ex
│ │ └── error_helpers.ex
│ ├── controllers
│ │ ├── page_controller.ex
│ │ ├── coherence
│ │ │ └── redirects.ex
│ │ ├── post_controller.ex
│ │ └── user_controller.ex
│ ├── templates
│ │ ├── post
│ │ │ ├── new.html.eex
│ │ │ ├── edit.html.eex
│ │ │ ├── show.html.eex
│ │ │ ├── form.html.eex
│ │ │ └── index.html.eex
│ │ ├── coherence
│ │ │ ├── layout
│ │ │ │ └── email.html.eex
│ │ │ ├── registration
│ │ │ │ ├── edit.html.eex
│ │ │ │ ├── new.html.eex
│ │ │ │ ├── show.html.eex
│ │ │ │ └── form.html.eex
│ │ │ ├── email
│ │ │ │ ├── confirmation.html.eex
│ │ │ │ ├── invitation.html.eex
│ │ │ │ ├── unlock.html.eex
│ │ │ │ └── password.html.eex
│ │ │ ├── password
│ │ │ │ ├── new.html.eex
│ │ │ │ └── edit.html.eex
│ │ │ ├── confirmation
│ │ │ │ └── new.html.eex
│ │ │ ├── unlock
│ │ │ │ └── new.html.eex
│ │ │ ├── invitation
│ │ │ │ ├── new.html.eex
│ │ │ │ └── edit.html.eex
│ │ │ └── session
│ │ │ │ └── new.html.eex
│ │ ├── user
│ │ │ ├── new.html.eex
│ │ │ ├── edit.html.eex
│ │ │ ├── index.html.eex
│ │ │ ├── show.html.eex
│ │ │ └── form.html.eex
│ │ ├── page
│ │ │ └── index.html.eex
│ │ └── layout
│ │ │ └── app.html.eex
│ ├── emails
│ │ └── coherence
│ │ │ ├── coherence_mailer.ex
│ │ │ └── user_email.ex
│ ├── gettext.ex
│ ├── channels
│ │ └── user_socket.ex
│ ├── coherence_web.ex
│ ├── router.ex
│ ├── endpoint.ex
│ └── coherence_messages.ex
├── coherence_demo.ex
├── coherence_demo
│ ├── repo.ex
│ ├── blogs
│ │ ├── post.ex
│ │ └── blogs.ex
│ ├── coherence
│ │ ├── user.ex
│ │ ├── invitation.ex
│ │ ├── rememberable.ex
│ │ └── schemas.ex
│ └── application.ex
└── coherence_demo_web.ex
├── priv
├── repo
│ ├── seeds.exs
│ └── migrations
│ │ ├── 20170803154232_create_posts.exs
│ │ ├── 20170803154909_create_coherence_invitable.exs
│ │ ├── 20170803154910_create_coherence_rememberable.exs
│ │ └── 20170803154908_create_coherence_user.exs
└── gettext
│ ├── en
│ └── LC_MESSAGES
│ │ └── errors.po
│ └── errors.pot
├── config
├── test.exs
├── config.exs
├── dev.exs
└── prod.exs
├── .gitignore
├── README.md
├── mix.exs
└── mix.lock
/assets/css/app.css:
--------------------------------------------------------------------------------
1 | /* This file is for your main application css. */
--------------------------------------------------------------------------------
/assets/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/smpallen99/coherence_demo/master/assets/static/favicon.ico
--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 |
3 | Ecto.Adapters.SQL.Sandbox.mode(CoherenceDemo.Repo, :manual)
4 |
5 |
--------------------------------------------------------------------------------
/assets/static/images/phoenix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/smpallen99/coherence_demo/master/assets/static/images/phoenix.png
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.PageView do
2 | use CoherenceDemoWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/post_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.PostView do
2 | use CoherenceDemoWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.LayoutView do
2 | use CoherenceDemoWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/coherence/coherence_view.ex:
--------------------------------------------------------------------------------
1 | defmodule Coherence.CoherenceView do
2 | use CoherenceDemoWeb.Coherence, :view
3 | end
4 |
--------------------------------------------------------------------------------
/test/coherence_demo_web/views/page_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.PageViewTest do
2 | use CoherenceDemoWeb.ConnCase, async: true
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/coherence/email_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Coherence.EmailView do
2 | use CoherenceDemoWeb.Coherence, :view
3 | end
4 |
--------------------------------------------------------------------------------
/test/coherence_demo_web/views/layout_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.LayoutViewTest do
2 | use CoherenceDemoWeb.ConnCase, async: true
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/coherence/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Coherence.LayoutView do
2 | use CoherenceDemoWeb.Coherence, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/coherence/session_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Coherence.SessionView do
2 | use CoherenceDemoWeb.Coherence, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/coherence/unlock_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Coherence.UnlockView do
2 | use CoherenceDemoWeb.Coherence, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/coherence/invitation_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Coherence.InvitationView do
2 | use CoherenceDemoWeb.Coherence, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/coherence/password_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Coherence.PasswordView do
2 | use CoherenceDemoWeb.Coherence, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/coherence/confirmation_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Coherence.ConfirmationView do
2 | use CoherenceDemoWeb.Coherence, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/coherence/registration_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Coherence.RegistrationView do
2 | use CoherenceDemoWeb.Coherence, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/user_view.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.UserView do
2 | use CoherenceDemoWeb, :view
3 | alias CoherenceDemo.Coherence.User
4 |
5 | end
6 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/controllers/page_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.PageController do
2 | use CoherenceDemoWeb, :controller
3 |
4 | def index(conn, _params) do
5 | render conn, "index.html"
6 | end
7 | end
8 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/post/new.html.eex:
--------------------------------------------------------------------------------
1 | New Post
2 |
3 | <%= render "form.html", Map.put(assigns, :action, post_path(@conn, :create)) %>
4 |
5 | <%= link "Back", to: post_path(@conn, :index) %>
6 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/emails/coherence/coherence_mailer.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Coherence.Mailer do
2 | @moduledoc false
3 | if Coherence.Config.mailer?() do
4 | use Swoosh.Mailer, otp_app: :coherence
5 | end
6 | end
7 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/post/edit.html.eex:
--------------------------------------------------------------------------------
1 | Edit Post
2 |
3 | <%= render "form.html", Map.put(assigns, :action, post_path(@conn, :update, @post)) %>
4 |
5 | <%= link "Back", to: post_path(@conn, :index) %>
6 |
--------------------------------------------------------------------------------
/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/coherence_demo_web/templates/coherence/layout/email.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
3 | <%= @email.subject %>
4 |
5 |
6 | <%= render @view_module, @view_template, assigns %>
7 |
8 |
9 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/user/new.html.eex:
--------------------------------------------------------------------------------
1 | New user
2 |
3 | <%= render "form.html", changeset: @changeset,
4 | action: user_path(@conn, :create) %>
5 |
6 | <%= link "Back", to: user_path(@conn, :index) %>
7 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/user/edit.html.eex:
--------------------------------------------------------------------------------
1 | Edit user
2 |
3 | <%= render "form.html", changeset: @changeset,
4 | action: user_path(@conn, :update, @user) %>
5 |
6 | <%= link "Back", to: user_path(@conn, :index) %>
7 |
--------------------------------------------------------------------------------
/test/coherence_demo_web/controllers/page_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.PageControllerTest do
2 | use CoherenceDemoWeb.ConnCase
3 |
4 | test "GET /", %{conn: conn} do
5 | conn = get conn, "/"
6 | assert html_response(conn, 200) =~ "Welcome to Phoenix!"
7 | end
8 | end
9 |
--------------------------------------------------------------------------------
/lib/coherence_demo.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo do
2 | @moduledoc """
3 | CoherenceDemo 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/coherence_demo_web/templates/coherence/registration/edit.html.eex:
--------------------------------------------------------------------------------
1 | <%= dgettext "coherence", "Edit Account" %>
2 |
3 | <%= render "form.html", changeset: @changeset,
4 | label: dgettext("coherence", "Update"), required: [],
5 | action: registration_path(@conn, :update) %>
6 |
--------------------------------------------------------------------------------
/priv/repo/seeds.exs:
--------------------------------------------------------------------------------
1 | CoherenceDemo.Repo.delete_all CoherenceDemo.Coherence.User
2 |
3 | CoherenceDemo.Coherence.User.changeset(%CoherenceDemo.Coherence.User{}, %{name: "Demo User", email: "demouser@example.com", password: "secret", password_confirmation: "secret"})
4 | |> CoherenceDemo.Repo.insert!
5 | |> Coherence.Controller.confirm!
6 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/coherence/registration/new.html.eex:
--------------------------------------------------------------------------------
1 | <%= dgettext "coherence", "Register Account" %>
2 |
3 | <%= render "form.html", changeset: @changeset,
4 | label: dgettext("coherence", "Register"), required: [required: ""],
5 | action: registration_path(@conn, :create) %>
6 |
--------------------------------------------------------------------------------
/lib/coherence_demo/repo.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.Repo do
2 | use Ecto.Repo, otp_app: :coherence_demo
3 |
4 | @doc """
5 | Dynamically loads the repository url from the
6 | DATABASE_URL environment variable.
7 | """
8 | def init(_, opts) do
9 | {:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))}
10 | end
11 | end
12 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20170803154232_create_posts.exs:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.Repo.Migrations.CreatePosts do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table(:posts, primary_key: false) do
6 | add :id, :binary_id, primary_key: true
7 | add :title, :string
8 | add :body, :text
9 |
10 | timestamps()
11 | end
12 |
13 | end
14 | end
15 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/post/show.html.eex:
--------------------------------------------------------------------------------
1 | Show Post
2 |
3 |
4 |
5 |
6 | Title:
7 | <%= @post.title %>
8 |
9 |
10 |
11 | Body:
12 | <%= @post.body %>
13 |
14 |
15 |
16 |
17 | <%= link "Edit", to: post_path(@conn, :edit, @post) %>
18 | <%= link "Back", to: post_path(@conn, :index) %>
19 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/coherence/email/confirmation.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
<%= dgettext "coherence", "Hello %{name}!", name: @name %>
3 |
4 | <%= dgettext "coherence", "Your new account is almost ready. Click the link below to confirm you new account." %>
5 |
6 |
7 | <%= dgettext "coherence", "Confirm my Account" %>
8 |
9 |
<%= dgettext "coherence", "Thank you!" %>
10 |
2 |
<%= dgettext "coherence", "Hello %{name}!", name: @name %>
3 |
4 | <%= dgettext "coherence", "You have been invited to create an Account. Use the link below to create an account." %>
5 |
6 |
7 | <%= dgettext "coherence", "Create my Account" %>
8 |
9 |
<%= dgettext "coherence", "Thank you!" %>
10 |
2 |
<%= dgettext "coherence", "Hello %{name}!", name: @name %>
3 |
4 | <%= dgettext "coherence", "You requested unlock instructions for your locked account. Please click the link below to unlock your account." %>
5 |
6 |
7 | <%= dgettext "coherence", "Unlock my Account" %>
8 |
9 |
<%= dgettext "coherence", "Thank you!" %>
10 |
2 |
<%= dgettext "coherence", "Hello %{name}!", name: @name %>
3 |
4 | <%= dgettext "coherence", "Someone has requested a link to change your password, and you can do this through the link below." %>
5 |
6 |
7 | <%= dgettext "coherence", "Change my password" %>
8 |
9 |
10 | <%= dgettext "coherence", "If you didn't request this, please ignore this email." %>
11 |
12 |
13 | <%= dgettext "coherence", "Your password won't change until you access the link above and create a new one." %>
14 |
15 |
2 |
<%= gettext "Welcome to %{name}!", name: "Coherence" %>
3 |
An full-featured authentication package
4 |
<%= dgettext "coherence", "Send reset password link" %>
4 |
5 | <%= form_for @changeset, password_path(@conn, :create), [as: :password], fn f -> %>
6 |
7 |
8 | <%= required_label f, :email, class: "control-label" %>
9 | <%= text_input f, :email, class: "form-control", required: "" %>
10 | <%= error_tag f, :email %>
11 |
12 |
13 |
14 | <%= submit dgettext("coherence", "Reset Password"), class: "btn btn-primary" %>
15 | <%= link dgettext("coherence", "Cancel"), to: Coherence.Config.logged_out_url("/"), class: "btn" %>
16 |
17 | <% end %>
18 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # App artifacts
2 | /_build
3 | /db
4 | /deps
5 | /*.ez
6 |
7 | # Generated on crash by the VM
8 | erl_crash.dump
9 |
10 | # Generated on crash by NPM
11 | npm-debug.log
12 |
13 | # Static artifacts
14 | /assets/node_modules
15 |
16 | # Since we are building assets from assets/,
17 | # we ignore priv/static. You may want to comment
18 | # this depending on your deployment strategy.
19 | /priv/static/
20 |
21 | # Files matching config/*.secret.exs pattern contain sensitive
22 | # data and you should not commit them into version control.
23 | #
24 | # Alternatively, you may comment the line below and commit the
25 | # secrets files as long as you replace their contents by environment
26 | # variables.
27 | /config/*.secret.exs
--------------------------------------------------------------------------------
/test/coherence_demo_web/views/error_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.ErrorViewTest do
2 | use CoherenceDemoWeb.ConnCase, async: true
3 |
4 | # Bring render/3 and render_to_string/3 for testing custom views
5 | import Phoenix.View
6 |
7 | test "renders 404.html" do
8 | assert render_to_string(CoherenceDemoWeb.ErrorView, "404.html", []) ==
9 | "Page not found"
10 | end
11 |
12 | test "render 500.html" do
13 | assert render_to_string(CoherenceDemoWeb.ErrorView, "500.html", []) ==
14 | "Internal server error"
15 | end
16 |
17 | test "render any other" do
18 | assert render_to_string(CoherenceDemoWeb.ErrorView, "505.html", []) ==
19 | "Internal server error"
20 | end
21 | end
22 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/coherence/confirmation/new.html.eex:
--------------------------------------------------------------------------------
1 | <%= dgettext "coherence", "Resend Confirmation Instructions" %>
4 |
5 | <%= form_for @changeset, confirmation_path(@conn, :create), [as: :confirmation], fn f -> %>
6 |
7 |
8 | <%= required_label f, dgettext("coherence", "Email"), class: "control-label" %>
9 | <%= text_input f, :email, class: "form-control", required: "" %>
10 | <%= error_tag f, :email %>
11 |
12 |
13 |
14 | <%= submit dgettext("coherence", "Resend Email"), class: "btn btn-primary" %>
15 | <%= link dgettext("coherence", "Cancel"), to: Coherence.Config.logged_out_url("/"), class: "btn" %>
16 |
17 | <% end %>
18 |
--------------------------------------------------------------------------------
/assets/js/app.js:
--------------------------------------------------------------------------------
1 | // Brunch automatically concatenates all files in your
2 | // watched paths. Those paths can be configured at
3 | // config.paths.watched in "brunch-config.js".
4 | //
5 | // However, those files will only be executed if
6 | // explicitly imported. The only exception are files
7 | // in vendor, which are never wrapped in imports and
8 | // therefore are always executed.
9 |
10 | // Import dependencies
11 | //
12 | // If you no longer want to use a dependency, remember
13 | // to also remove its path from "config.paths.watched".
14 | import "phoenix_html"
15 |
16 | // Import local files
17 | //
18 | // Local files can be imported directly using relative
19 | // paths "./socket" or full ones "web/static/js/socket".
20 |
21 | // import socket from "./socket"
22 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/post/form.html.eex:
--------------------------------------------------------------------------------
1 | <%= form_for @changeset, @action, fn f -> %>
2 | <%= if @changeset.action do %>
3 |
4 |
Oops, something went wrong! Please check the errors below.
5 |
9 | <%= label f, :title, class: "control-label" %>
10 | <%= text_input f, :title, class: "form-control" %>
11 | <%= error_tag f, :title %>
12 |
13 |
14 |
15 | <%= label f, :body, class: "control-label" %>
16 | <%= textarea f, :body, class: "form-control" %>
17 | <%= error_tag f, :body %>
18 |
19 |
20 |
21 | <%= submit "Submit", class: "btn btn-primary" %>
22 |
23 | <% end %>
24 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20170803154910_create_coherence_rememberable.exs:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.Repo.Migrations.CreateCoherenceRememberable do
2 | use Ecto.Migration
3 | def change do
4 | create table(:rememberables, primary_key: false) do
5 | add :id, :binary_id, primary_key: true
6 |
7 | add :series_hash, :string
8 | add :token_hash, :string
9 | add :token_created_at, :utc_datetime
10 | add :user_id, references(:users, on_delete: :delete_all, type: :binary_id)
11 |
12 | timestamps()
13 | end
14 | create index(:rememberables, [:user_id])
15 | create index(:rememberables, [:series_hash])
16 | create index(:rememberables, [:token_hash])
17 | create unique_index(:rememberables, [:user_id, :series_hash, :token_hash])
18 |
19 | end
20 | end
21 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/gettext.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.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 CoherenceDemoWeb.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: :coherence_demo
24 | end
25 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/coherence/registration/show.html.eex:
--------------------------------------------------------------------------------
1 | <%= dgettext "coherence", "Show account" %>
2 |
3 |
4 | <%= dgettext "coherence", "Name:" %>
5 | <%= @user.name %>
6 |
7 | <%= unless (login_field = Coherence.Config.login_field) == :email do %>
8 |
9 | <%= humanize login_field %>
10 | <%= Map.get(@user, login_field) %>
11 |
12 | <% end %>
13 |
14 |
15 | <%= dgettext "coherence", "Email:" %>
16 | <%= @user.email %>
17 |
18 |
19 |
20 |
21 | <%= link dgettext("coherence", "Edit"), to: registration_path(@conn, :edit) %> |
22 | <%= link dgettext("coherence", "Delete"),
23 | to: registration_path(@conn, :delete),
24 | method: :delete,
25 | data: [confirm: dgettext("coherence", "Are you sure?")] %>
26 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/coherence/unlock/new.html.eex:
--------------------------------------------------------------------------------
1 |
6 | <%= required_label f, dgettext("coherence", "Email"), class: "control-label" %>
7 | <%= text_input f, :email, class: "form-control", required: "" %>
8 | <%= error_tag f, :email %>
9 |
10 |
11 |
12 | <%= required_label f, dgettext("coherence", "Password"), class: "control-label" %>
13 | <%= password_input f, :password, class: "form-control", required: "" %>
14 | <%= error_tag f, :password %>
15 |
16 |
17 |
18 | <%= submit dgettext("coherence", "Send Instructions"), class: "btn btn-primary" %>
19 | <%= link dgettext("coherence", "Cancel"), to: Coherence.Config.logged_out_url("/"), class: "btn" %>
20 |
21 |
22 | <% end %>
23 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/post/index.html.eex:
--------------------------------------------------------------------------------
1 | Listing Posts
2 |
3 |
4 |
5 |
6 | Title
7 | Body
8 |
9 |
11 |
12 |
13 | <%= for post <- @posts do %>
14 |
15 | <%= post.title %>
16 | <%= post.body %>
17 |
18 |
19 | <%= link "Show", to: post_path(@conn, :show, post), class: "btn btn-default btn-xs" %>
20 | <%= link "Edit", to: post_path(@conn, :edit, post), class: "btn btn-default btn-xs" %>
21 | <%= link "Delete", to: post_path(@conn, :delete, post), method: :delete, data: [confirm: "Are you sure?"], class: "btn btn-danger btn-xs" %>
22 |
23 |
24 | <% end %>
25 |
26 |
27 |
28 | <%= link "New Post", to: post_path(@conn, :new) %>
29 |
--------------------------------------------------------------------------------
/lib/coherence_demo/coherence/user.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.Coherence.User do
2 | @moduledoc false
3 | use Ecto.Schema
4 | use Coherence.Schema
5 |
6 |
7 | @primary_key {:id, :binary_id, autogenerate: true}
8 | @foreign_key_type :binary_id
9 |
10 |
11 | schema "users" do
12 | field :name, :string
13 | field :email, :string
14 | coherence_schema()
15 |
16 | timestamps()
17 | end
18 |
19 | def changeset(model, params \\ %{}) do
20 | model
21 | |> cast(params, [:name, :email] ++ coherence_fields())
22 | |> validate_required([:name, :email])
23 | |> validate_format(:email, ~r/@/)
24 | |> unique_constraint(:email)
25 | |> validate_coherence(params)
26 | end
27 |
28 | def changeset(model, params, :password) do
29 | model
30 | |> cast(params, ~w(password password_confirmation reset_password_token reset_password_sent_at))
31 | |> validate_coherence_password_reset(params)
32 | end
33 | end
34 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/coherence/password/edit.html.eex:
--------------------------------------------------------------------------------
1 | <%= dgettext "coherence", "Create a New Password" %>
4 |
5 | <%= form_for @changeset, password_path(@conn, :update, @changeset.data), [as: :password], fn f -> %>
6 |
7 | <%= hidden_input f, :reset_password_token %>
8 |
9 |
10 | <%= required_label f, dgettext("coherence", "Password"), class: "control-label" %>
11 | <%= password_input f, :password, class: "form-control", required: "" %>
12 | <%= error_tag f, :password %>
13 |
14 |
15 |
16 | <%= required_label f, dgettext("coherence", "Password Confirmation"), class: "control-label" %>
17 | <%= password_input f, :password_confirmation, class: "form-control", required: "" %>
18 | <%= error_tag f, :password_confirmation %>
19 |
20 |
21 |
22 | <%= submit dgettext("coherence", "Update Password"), class: "btn btn-primary" %>
23 | <%= link dgettext("coherence", "Cancel"), to: Coherence.Config.logged_out_url("/"), class: "btn" %>
24 |
25 | <% end %>
26 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/user/index.html.eex:
--------------------------------------------------------------------------------
1 | Listing users
2 |
3 |
4 |
5 |
6 | Name
7 | Email
8 | Locked?
9 | Confirmed?
10 | Sign in count
11 |
12 |
14 |
15 |
16 | <%= for user <- @users do %>
17 |
18 | <%= user.name %>
19 | <%= user.email %>
20 | <%= User.locked? user %>
21 | <%= User.confirmed? user %>
22 | <%= user.sign_in_count %>
23 |
24 |
25 | <%= link "Show", to: user_path(@conn, :show, user), class: "btn btn-default btn-xs" %>
26 | <%= link "Edit", to: user_path(@conn, :edit, user), class: "btn btn-default btn-xs" %>
27 | <%= link "Delete", to: user_path(@conn, :delete, user), method: :delete, data: [confirm: "Are you sure?"], class: "btn btn-danger btn-xs" %>
28 |
29 |
30 | <% end %>
31 |
32 |
33 |
34 | <%= link "New user", to: user_path(@conn, :new) %>
35 |
--------------------------------------------------------------------------------
/test/support/channel_case.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.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 datastructures 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 CoherenceDemoWeb.Endpoint
25 | end
26 | end
27 |
28 |
29 | setup tags do
30 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(CoherenceDemo.Repo)
31 | unless tags[:async] do
32 | Ecto.Adapters.SQL.Sandbox.mode(CoherenceDemo.Repo, {:shared, self()})
33 | end
34 | :ok
35 | end
36 |
37 | end
38 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/user/show.html.eex:
--------------------------------------------------------------------------------
1 | Show user
2 |
3 |
4 |
5 |
6 | Name:
7 | <%= @user.name %>
8 |
9 |
10 |
11 | Email:
12 | <%= @user.email %>
13 |
14 |
15 |
16 | Locked?
17 | <%= if User.locked? @user do %>
18 | Yes -
19 | <%= link "Unlock User!", to: user_path(@conn, :unlock, @user.id), "method": :put %>
20 | <% else %>
21 | No
22 | <% end %>
23 |
24 |
25 |
26 | Confirmed?
27 | <%= if User.confirmed? @user do %>
28 | Yes
29 | <% else %>
30 | No -
31 | <%= link "Confirm User!", to: user_path(@conn, :confirm, @user.id), "method": :put %>
32 | <% end %>
33 |
34 |
35 |
36 | Active?
37 | <%= if @user.active do %>
38 | Yes
39 | <% else %>
40 | No
41 | <% end %>
42 |
43 |
44 |
45 | Sign in count:
46 | <%= @user.sign_in_count %>
47 |
48 |
49 |
50 |
51 | <%= link "Edit", to: user_path(@conn, :edit, @user) %> |
52 | <%= link "Back", to: user_path(@conn, :index) %>
53 |
--------------------------------------------------------------------------------
/lib/coherence_demo/application.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.Application do
2 | use Application
3 |
4 | # See https://hexdocs.pm/elixir/Application.html
5 | # for more information on OTP Applications
6 | def start(_type, _args) do
7 | import Supervisor.Spec
8 |
9 | # Define workers and child supervisors to be supervised
10 | children = [
11 | # Start the Ecto repository
12 | supervisor(CoherenceDemo.Repo, []),
13 | # Start the endpoint when the application starts
14 | supervisor(CoherenceDemoWeb.Endpoint, []),
15 | # Start your own worker by calling: CoherenceDemo.Worker.start_link(arg1, arg2, arg3)
16 | # worker(CoherenceDemo.Worker, [arg1, arg2, arg3]),
17 | ]
18 |
19 | # See https://hexdocs.pm/elixir/Supervisor.html
20 | # for other strategies and supported options
21 | opts = [strategy: :one_for_one, name: CoherenceDemo.Supervisor]
22 | Supervisor.start_link(children, opts)
23 | end
24 |
25 | # Tell Phoenix to update the endpoint configuration
26 | # whenever the application is updated.
27 | def config_change(changed, _new, removed) do
28 | CoherenceDemoWeb.Endpoint.config_change(changed, removed)
29 | :ok
30 | end
31 | end
32 |
--------------------------------------------------------------------------------
/lib/coherence_demo/coherence/invitation.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.Coherence.Invitation do
2 | @moduledoc """
3 | Schema to support inviting a someone to create an account.
4 | """
5 | use Ecto.Schema
6 | import Ecto.Changeset
7 |
8 |
9 | @primary_key {:id, :binary_id, autogenerate: true}
10 | @foreign_key_type :binary_id
11 |
12 |
13 | schema "invitations" do
14 | field :name, :string
15 | field :email, :string
16 | field :token, :string
17 |
18 | timestamps()
19 | end
20 |
21 | @doc """
22 | Creates a changeset based on the `model` and `params`.
23 |
24 | If no params are provided, an invalid changeset is returned
25 | with no validation performed.
26 | """
27 | @spec changeset(Ecto.Schema.t, Map.t) :: Ecto.Changeset.t
28 | def changeset(model, params \\ %{}) do
29 | model
30 | |> cast(params, ~w(name email token))
31 | |> validate_required([:name, :email])
32 | |> unique_constraint(:email)
33 | |> validate_format(:email, ~r/@/)
34 | end
35 |
36 | @doc """
37 | Creates a changeset for a new schema
38 | """
39 | @spec new_changeset(Map.t) :: Ecto.Changeset.t
40 | def new_changeset(params \\ %{}) do
41 | changeset %__MODULE__{}, params
42 | end
43 | end
44 |
--------------------------------------------------------------------------------
/test/support/conn_case.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.ConnCase do
2 | @moduledoc """
3 | This module defines the test case to be used by
4 | tests that require setting up a connection.
5 |
6 | Such tests rely on `Phoenix.ConnTest` and also
7 | import other functionality to make it easier
8 | to build common datastructures 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 connections
21 | use Phoenix.ConnTest
22 | import CoherenceDemoWeb.Router.Helpers
23 |
24 | # The default endpoint for testing
25 | @endpoint CoherenceDemoWeb.Endpoint
26 | end
27 | end
28 |
29 |
30 | setup tags do
31 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(CoherenceDemo.Repo)
32 | unless tags[:async] do
33 | Ecto.Adapters.SQL.Sandbox.mode(CoherenceDemo.Repo, {:shared, self()})
34 | end
35 | {:ok, conn: Phoenix.ConnTest.build_conn()}
36 | end
37 |
38 | end
39 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/user/form.html.eex:
--------------------------------------------------------------------------------
1 | <%= form_for @changeset, @action, fn f -> %>
2 | <%= if @changeset.action do %>
3 |
4 |
Oops, something went wrong! Please check the errors below.
5 |
9 | <%= label f, :name, class: "control-label" %>
10 | <%= text_input f, :name, class: "form-control" %>
11 | <%= error_tag f, :name %>
12 |
13 |
14 |
15 | <%= label f, :email, class: "control-label" %>
16 | <%= text_input f, :email, class: "form-control" %>
17 | <%= error_tag f, :email %>
18 |
19 |
20 |
21 | <%= label f, :password, class: "control-label" %>
22 | <%= password_input f, :password, class: "form-control" %>
23 | <%= error_tag f, :password %>
24 |
25 |
26 |
27 | <%= label f, :password_confirmation, class: "control-label" %>
28 | <%= password_input f, :password_confirmation, class: "form-control" %>
29 | <%= error_tag f, :password_confirmation %>
30 |
31 |
32 |
33 | <%= submit "Submit", class: "btn btn-primary" %>
34 |
35 | <% end %>
36 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/coherence/invitation/new.html.eex:
--------------------------------------------------------------------------------
1 | <%= form_for @changeset, invitation_path(@conn, :create), [as: :invitation], fn f -> %>
2 | <%= if @changeset.action do %>
3 |
4 |
<%= dgettext "coherence", "Oops, something went wrong! Please check the errors below." %>
5 |
8 | <%= required_label f, dgettext("coherence", "Name"), class: "control-label" %>
9 | <%= text_input f, :name, class: "form-control", required: "" %>
10 | <%= error_tag f, :name %>
11 |
12 |
13 |
14 | <%= required_label f, dgettext("coherence", "Email"), class: "control-label" %>
15 | <%= text_input f, :email, class: "form-control", required: "" %>
16 | <%= error_tag f, :email %>
17 |
18 |
19 |
20 | <%= submit dgettext("coherence", "Send Invitation"), class: "btn btn-primary" %>
21 | <%= link dgettext("coherence", "Cancel"), to: Coherence.Config.logged_out_url("/"), class: "btn" %>
22 | <%= if invitation = @conn.assigns[:invitation] do %>
23 | <%= link dgettext("coherence", "Resend Invitation!"), to: invitation_path(@conn, :resend, invitation.id), class: "btn" %>
24 | <% end %>
25 |
26 | <% end %>
27 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20170803154908_create_coherence_user.exs:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.Repo.Migrations.CreateCoherenceUser do
2 | use Ecto.Migration
3 | def change do
4 | create table(:users, primary_key: false) do
5 | add :id, :binary_id, primary_key: true
6 |
7 | add :name, :string
8 | add :email, :string
9 | # rememberable
10 | add :remember_created_at, :utc_datetime
11 | # unlockable_with_token
12 | add :unlock_token, :string
13 | # recoverable
14 | add :reset_password_token, :string
15 | add :reset_password_sent_at, :utc_datetime
16 | # lockable
17 | add :failed_attempts, :integer, default: 0
18 | add :locked_at, :utc_datetime
19 | # trackable
20 | add :sign_in_count, :integer, default: 0
21 | add :current_sign_in_at, :utc_datetime
22 | add :last_sign_in_at, :utc_datetime
23 | add :current_sign_in_ip, :string
24 | add :last_sign_in_ip, :string
25 | # confirmable
26 | add :confirmation_token, :string
27 | add :confirmed_at, :utc_datetime
28 | add :confirmation_sent_at, :utc_datetime
29 | # authenticatable
30 | add :password_hash, :string
31 | add :active, :boolean, null: false, default: true
32 |
33 | timestamps()
34 | end
35 | create unique_index(:users, [:email])
36 |
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/channels/user_socket.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.UserSocket do
2 | use Phoenix.Socket
3 |
4 | ## Channels
5 | # channel "room:*", CoherenceDemoWeb.RoomChannel
6 |
7 | ## Transports
8 | transport :websocket, Phoenix.Transports.WebSocket
9 | # transport :longpoll, Phoenix.Transports.LongPoll
10 |
11 | # Socket params are passed from the client and can
12 | # be used to verify and authenticate a user. After
13 | # verification, you can put default assigns into
14 | # the socket that will be set for all channels, ie
15 | #
16 | # {:ok, assign(socket, :user_id, verified_user_id)}
17 | #
18 | # To deny connection, return `:error`.
19 | #
20 | # See `Phoenix.Token` documentation for examples in
21 | # performing token verification on connect.
22 | def connect(_params, socket) do
23 | {:ok, socket}
24 | end
25 |
26 | # Socket id's are topics that allow you to identify all sockets for a given user:
27 | #
28 | # def id(socket), do: "user_socket:#{socket.assigns.user_id}"
29 | #
30 | # Would allow you to broadcast a "disconnect" event and terminate
31 | # all active sockets and channels for a given user:
32 | #
33 | # CoherenceDemoWeb.Endpoint.broadcast("user_socket:#{user.id}", "disconnect", %{})
34 | #
35 | # Returning `nil` makes this socket anonymous.
36 | def id(_socket), do: nil
37 | end
38 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/coherence_web.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Coherence do
2 | @moduledoc false
3 |
4 | def view do
5 | quote do
6 | use Phoenix.View, root: "lib/coherence_demo_web/templates"
7 | # Import convenience functions from controllers
8 |
9 | import Phoenix.Controller, only: [get_csrf_token: 0, get_flash: 2, view_module: 1]
10 |
11 | # Use all HTML functionality (forms, tags, etc)
12 | use Phoenix.HTML
13 |
14 | import CoherenceDemoWeb.Router.Helpers
15 | import CoherenceDemoWeb.ErrorHelpers
16 | import CoherenceDemoWeb.Gettext
17 | import CoherenceDemoWeb.Coherence.ViewHelpers
18 | end
19 | end
20 |
21 | def controller do
22 | quote do
23 | use Phoenix.Controller, except: [layout_view: 2]
24 | use Coherence.Config
25 | use Timex
26 |
27 | import Ecto
28 | import Ecto.Query
29 | import Plug.Conn
30 | import CoherenceDemoWeb.Router.Helpers
31 | import CoherenceDemoWeb.Gettext
32 | import Coherence.Controller
33 |
34 | alias Coherence.Config
35 | alias Coherence.Controller
36 |
37 | require Redirects
38 | end
39 | end
40 |
41 | @doc """
42 | When used, dispatch to the appropriate controller/view/etc.
43 | """
44 | defmacro __using__(which) when is_atom(which) do
45 | apply(__MODULE__, which, [])
46 | end
47 | end
48 |
--------------------------------------------------------------------------------
/lib/coherence_demo/coherence/rememberable.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.Coherence.Rememberable do
2 | @moduledoc false
3 | use Ecto.Schema
4 |
5 | import Ecto.Changeset
6 | import Ecto.Query
7 |
8 | alias Coherence.Config
9 |
10 |
11 | @primary_key {:id, :binary_id, autogenerate: true}
12 | @foreign_key_type :binary_id
13 |
14 |
15 | schema "rememberables" do
16 | field :series_hash, :string
17 | field :token_hash, :string
18 | field :token_created_at, Timex.Ecto.DateTime
19 | belongs_to :user, Module.concat(Config.module, Config.user_schema), type: :binary_id
20 |
21 | timestamps()
22 | end
23 |
24 | use Coherence.Rememberable
25 |
26 | @doc """
27 | Creates a changeset based on the `model` and `params`.
28 |
29 | If no params are provided, an invalid changeset is returned
30 | with no validation performed.
31 | """
32 | @spec changeset(Ecto.Schema.t, Map.t) :: Ecto.Changeset.t
33 | def changeset(model, params \\ %{}) do
34 | model
35 | |> cast(params, ~w(series_hash token_hash token_created_at user_id))
36 | |> validate_required(~w(series_hash token_hash token_created_at user_id)a)
37 | end
38 |
39 | @doc """
40 | Creates a changeset for a new schema
41 | """
42 | @spec new_changeset(Map.t) :: Ecto.Changeset.t
43 | def new_changeset(params \\ %{}) do
44 | changeset %Rememberable{}, params
45 | end
46 |
47 | end
48 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # CoherenceDemo
2 |
3 | A Coherence Demo project illustrating how to use [Coherence](https://github.com/smpallen99/coherence).
4 |
5 | This project demonstrates some of the features of Coherence on a very simple project.
6 |
7 | > Updated for Phoenix 1.3
8 |
9 | ## Installation
10 |
11 | ```bash
12 | $ git clone https://github.com/smpallen99/coherence_demo.git
13 | $ cd coherence_demo
14 | $ mix do deps.get, deps.compile
15 | $ mix ecto.setup
16 | $ cd assets && npm install
17 | $ iex -S mix phx.server
18 | ```
19 |
20 | Visit http://localhost:4008/ in your browser
21 |
22 | Default login created with `mix ecto.setup` is demouser@example.com / secret
23 |
24 | Note, you will need to setup an sendgrid API key in config/config.exs to get the outgoing emails to work
25 |
26 | ## How was this project created
27 |
28 | ```bash
29 | $ mix phx.new coherence_demo --binary-id
30 | $ cd coherence_demo
31 | $ mix ecto.setup
32 |
33 | # edit mix.exs and add coherence deps
34 | $ mix coherence.install --full --invitable --registerable --rememberable --confirmable --user-active-field
35 |
36 | # edit web/router.ex and add the coherence routes per the instructions
37 | # edit priv/repo/seeds.exs -- add User seeds
38 | # edit web/templates/layout/app.html.eex -- add some nav stuff
39 |
40 | # added the `user_controller`, view, and templates manually
41 | # added some custom routes for the lock/unlock/etc behaviour
42 |
43 | $mix ecto.setup
44 | ```
45 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/views/error_helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.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 | content_tag :span, translate_error(error), class: "help-block"
14 | end)
15 | end
16 |
17 | @doc """
18 | Translates an error message using gettext.
19 | """
20 | def translate_error({msg, opts}) do
21 | # Because error messages were defined within Ecto, we must
22 | # call the Gettext module passing our Gettext backend. We
23 | # also use the "errors" domain as translations are placed
24 | # in the errors.po file.
25 | # Ecto will pass the :count keyword if the error message is
26 | # meant to be pluralized.
27 | # On your own code and templates, depending on whether you
28 | # need the message to be pluralized or not, this could be
29 | # written simply as:
30 | #
31 | # dngettext "errors", "1 file", "%{count} files", count
32 | # dgettext "errors", "is invalid"
33 | #
34 | if count = opts[:count] do
35 | Gettext.dngettext(CoherenceDemoWeb.Gettext, "errors", msg, msg, count, opts)
36 | else
37 | Gettext.dgettext(CoherenceDemoWeb.Gettext, "errors", msg, opts)
38 | end
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/router.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.Router do
2 | use CoherenceDemoWeb, :router
3 | use Coherence.Router
4 |
5 | pipeline :browser do
6 | plug :accepts, ["html"]
7 | plug :fetch_session
8 | plug :fetch_flash
9 | plug :protect_from_forgery
10 | plug :put_secure_browser_headers
11 | plug Coherence.Authentication.Session
12 | end
13 |
14 | pipeline :protected do
15 | plug :accepts, ["html"]
16 | plug :fetch_session
17 | plug :fetch_flash
18 | plug :protect_from_forgery
19 | plug :put_secure_browser_headers
20 | plug Coherence.Authentication.Session, protected: true # Add this
21 | end
22 |
23 | pipeline :api do
24 | plug :accepts, ["json"]
25 | end
26 |
27 | # Add this block
28 | scope "/" do
29 | pipe_through :browser
30 | coherence_routes()
31 | end
32 |
33 | # Add this block
34 | scope "/" do
35 | pipe_through :protected
36 | coherence_routes :protected
37 | end
38 |
39 | scope "/", CoherenceDemoWeb do
40 | pipe_through :browser # Use the default browser stack
41 |
42 | get "/", PageController, :index
43 | end
44 |
45 | scope "/", CoherenceDemoWeb do
46 | pipe_through :protected # Use the default browser stack
47 |
48 | resources "/posts", PostController
49 | resources "/users", UserController
50 | put "/lock/:id", UserController, :lock
51 | put "/unlock/:id", UserController, :unlock
52 | put "/confirm/:id", UserController, :confirm
53 | end
54 |
55 | # Other scopes may use custom stacks.
56 | # scope "/api", CoherenceDemoWeb do
57 | # pipe_through :api
58 | # end
59 | end
60 |
--------------------------------------------------------------------------------
/test/support/data_case.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.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 | it cannot be async. For this reason, every test runs
11 | inside a transaction which is reset at the beginning
12 | of the test unless the test case is marked as async.
13 | """
14 |
15 | use ExUnit.CaseTemplate
16 |
17 | using do
18 | quote do
19 | alias CoherenceDemo.Repo
20 |
21 | import Ecto
22 | import Ecto.Changeset
23 | import Ecto.Query
24 | import CoherenceDemo.DataCase
25 | end
26 | end
27 |
28 | setup tags do
29 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(CoherenceDemo.Repo)
30 |
31 | unless tags[:async] do
32 | Ecto.Adapters.SQL.Sandbox.mode(CoherenceDemo.Repo, {:shared, self()})
33 | end
34 |
35 | :ok
36 | end
37 |
38 | @doc """
39 | A helper that transform changeset errors to a map of messages.
40 |
41 | assert {:error, changeset} = Accounts.create_user(%{password: "short"})
42 | assert "password is too short" in errors_on(changeset).password
43 | assert %{password: ["password is too short"]} = errors_on(changeset)
44 |
45 | """
46 | def errors_on(changeset) do
47 | Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
48 | Enum.reduce(opts, message, fn {key, value}, acc ->
49 | String.replace(acc, "%{#{key}}", to_string(value))
50 | end)
51 | end)
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/assets/brunch-config.js:
--------------------------------------------------------------------------------
1 | exports.config = {
2 | // See http://brunch.io/#documentation for docs.
3 | files: {
4 | javascripts: {
5 | joinTo: "js/app.js"
6 |
7 | // To use a separate vendor.js bundle, specify two files path
8 | // http://brunch.io/docs/config#-files-
9 | // joinTo: {
10 | // "js/app.js": /^js/,
11 | // "js/vendor.js": /^(?!js)/
12 | // }
13 | //
14 | // To change the order of concatenation of files, explicitly mention here
15 | // order: {
16 | // before: [
17 | // "vendor/js/jquery-2.1.1.js",
18 | // "vendor/js/bootstrap.min.js"
19 | // ]
20 | // }
21 | },
22 | stylesheets: {
23 | joinTo: "css/app.css"
24 | },
25 | templates: {
26 | joinTo: "js/app.js"
27 | }
28 | },
29 |
30 | conventions: {
31 | // This option sets where we should place non-css and non-js assets in.
32 | // By default, we set this to "/assets/static". Files in this directory
33 | // will be copied to `paths.public`, which is "priv/static" by default.
34 | assets: /^(static)/
35 | },
36 |
37 | // Phoenix paths configuration
38 | paths: {
39 | // Dependencies and current project directories to watch
40 | watched: ["static", "css", "js", "vendor"],
41 | // Where to compile files to
42 | public: "../priv/static"
43 | },
44 |
45 | // Configure your plugins
46 | plugins: {
47 | babel: {
48 | // Do not use ES6 compiler in vendor code
49 | ignore: [/vendor/]
50 | }
51 | },
52 |
53 | modules: {
54 | autoRequire: {
55 | "js/app.js": ["js/app"]
56 | }
57 | },
58 |
59 | npm: {
60 | enabled: true
61 | }
62 | };
63 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/coherence/session/new.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
<%= gettext "Default Login Credentials" %>
4 |
5 |
6 |
<%= gettext "Email" %>: demouser@example.com
7 |
<%= gettext "Password" %>: secret
8 |
9 |
16 | <%= required_label f, login_field, class: "control-label" %>
17 | <%= text_input f, login_field, class: "form-control", required: "" %>
18 | <%= error_tag f, login_field %>
19 |
20 |
21 |
22 | <%= required_label f, dgettext("coherence", "Password"), class: "control-label" %>
23 | <%= password_input f, :password, class: "form-control", required: "" %>
24 | <%= error_tag f, :password %>
25 |
26 |
27 | <%= if @remember do %>
28 |
29 | <%= dgettext "coherence", "Remember Me?" %>
31 |
32 |
36 | <%= submit dgettext("coherence", "Sign In"), class: "btn btn-primary" %>
37 | <%= link dgettext("coherence", "Cancel"), to: Coherence.Config.logged_out_url("/"), class: "btn" %>
38 |
39 |
40 |
41 |
42 | <%= coherence_links(@conn, :new_session) %>
43 |
44 |
45 | <% end %>
46 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/layout/app.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Hello CoherenceDemo!
11 |
16 |
35 |
36 |
<%= get_flash(@conn, :info) %>
37 |
<%= get_flash(@conn, :error) %>
38 |
39 |
40 | <%= render @view_module, @view_template, assigns %>
41 |
42 |
43 |
7 |
<%= dgettext "coherence", "Oops, something went wrong! Please check the errors below." %>
8 |
14 | <%= required_label f, dgettext("coherence", "Email"), class: "control-label" %>
15 | <%= text_input f, :name, class: "form-control", required: "" %>
16 | <%= error_tag f, :name %>
17 |
18 |
19 | <%= unless (login_field = Coherence.Config.login_field) == :email do %>
20 |
21 | <%= required_label f, login_field, class: "control-label" %>
22 | <%= text_input f, login_field, class: "form-control", required: "" %>
23 | <%= error_tag f, login_field %>
24 |
25 | <% end %>
26 |
27 |
28 | <%= required_label f, dgettext("coherence", "Email"), class: "control-label" %>
29 | <%= text_input f, :email, class: "form-control", required: "" %>
30 | <%= error_tag f, :email %>
31 |
32 |
33 |
34 | <%= required_label f, dgettext("coherence", "Password"), class: "control-label" %>
35 | <%= password_input f, :password, class: "form-control", required: "" %>
36 | <%= error_tag f, :password %>
37 |
38 |
39 |
40 | <%= required_label f, dgettext("coherence", "Password Confirmation"), class: "control-label" %>
41 | <%= password_input f, :password_confirmation, class: "form-control", required: "" %>
42 | <%= error_tag f, :password_confirmation %>
43 |
44 |
45 |
46 | <%= submit dgettext("coherence", "Create"), class: "btn btn-primary" %>
47 | <%= link dgettext("coherence", "Cancel"), to: Coherence.Config.logged_out_url("/"), class: "btn" %>
48 |
49 | <% end %>
50 |
--------------------------------------------------------------------------------
/config/dev.exs:
--------------------------------------------------------------------------------
1 | use Mix.Config
2 |
3 | # For development, we disable any cache and enable
4 | # debugging and code reloading.
5 | #
6 | # The watchers configuration can be used to run external
7 | # watchers to your application. For example, we use it
8 | # with brunch.io to recompile .js and .css sources.
9 | config :coherence_demo, CoherenceDemoWeb.Endpoint,
10 | http: [port: 4008],
11 | debug_errors: true,
12 | code_reloader: true,
13 | check_origin: false,
14 | watchers: [node: ["node_modules/brunch/bin/brunch", "watch", "--stdin",
15 | cd: Path.expand("../assets", __DIR__)]]
16 |
17 | # ## SSL Support
18 | #
19 | # In order to use HTTPS in development, a self-signed
20 | # certificate can be generated by running the following
21 | # command from your terminal:
22 | #
23 | # openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 -subj "/C=US/ST=Denial/L=Springfield/O=Dis/CN=www.example.com" -keyout priv/server.key -out priv/server.pem
24 | #
25 | # The `http:` config above can be replaced with:
26 | #
27 | # https: [port: 4000, keyfile: "priv/server.key", certfile: "priv/server.pem"],
28 | #
29 | # If desired, both `http:` and `https:` keys can be
30 | # configured to run both http and https servers on
31 | # different ports.
32 |
33 | # Watch static and templates for browser reloading.
34 | config :coherence_demo, CoherenceDemoWeb.Endpoint,
35 | live_reload: [
36 | patterns: [
37 | ~r{priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$},
38 | ~r{priv/gettext/.*(po)$},
39 | ~r{lib/coherence_demo_web/views/.*(ex)$},
40 | ~r{lib/coherence_demo_web/templates/.*(eex)$}
41 | ]
42 | ]
43 |
44 | # Do not include metadata nor timestamps in development logs
45 | config :logger, :console, format: "[$level] $message\n"
46 |
47 | # Set a higher stacktrace during development. Avoid configuring such
48 | # in production as building large stacktraces may be expensive.
49 | config :phoenix, :stacktrace_depth, 20
50 |
51 | # Configure your database
52 | config :coherence_demo, CoherenceDemo.Repo,
53 | adapter: Ecto.Adapters.Postgres,
54 | username: "postgres",
55 | password: "postgres",
56 | database: "coherence_demo_dev",
57 | hostname: "localhost",
58 | pool_size: 10
59 |
--------------------------------------------------------------------------------
/lib/coherence_demo/blogs/blogs.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.Blogs do
2 | @moduledoc """
3 | The Blogs context.
4 | """
5 |
6 | import Ecto.Query, warn: false
7 | alias CoherenceDemo.Repo
8 |
9 | alias CoherenceDemo.Blogs.Post
10 |
11 | @doc """
12 | Returns the list of posts.
13 |
14 | ## Examples
15 |
16 | iex> list_posts()
17 | [%Post{}, ...]
18 |
19 | """
20 | def list_posts do
21 | Repo.all(Post)
22 | end
23 |
24 | @doc """
25 | Gets a single post.
26 |
27 | Raises `Ecto.NoResultsError` if the Post does not exist.
28 |
29 | ## Examples
30 |
31 | iex> get_post!(123)
32 | %Post{}
33 |
34 | iex> get_post!(456)
35 | ** (Ecto.NoResultsError)
36 |
37 | """
38 | def get_post!(id), do: Repo.get!(Post, id)
39 |
40 | @doc """
41 | Creates a post.
42 |
43 | ## Examples
44 |
45 | iex> create_post(%{field: value})
46 | {:ok, %Post{}}
47 |
48 | iex> create_post(%{field: bad_value})
49 | {:error, %Ecto.Changeset{}}
50 |
51 | """
52 | def create_post(attrs \\ %{}) do
53 | %Post{}
54 | |> Post.changeset(attrs)
55 | |> Repo.insert()
56 | end
57 |
58 | @doc """
59 | Updates a post.
60 |
61 | ## Examples
62 |
63 | iex> update_post(post, %{field: new_value})
64 | {:ok, %Post{}}
65 |
66 | iex> update_post(post, %{field: bad_value})
67 | {:error, %Ecto.Changeset{}}
68 |
69 | """
70 | def update_post(%Post{} = post, attrs) do
71 | post
72 | |> Post.changeset(attrs)
73 | |> Repo.update()
74 | end
75 |
76 | @doc """
77 | Deletes a Post.
78 |
79 | ## Examples
80 |
81 | iex> delete_post(post)
82 | {:ok, %Post{}}
83 |
84 | iex> delete_post(post)
85 | {:error, %Ecto.Changeset{}}
86 |
87 | """
88 | def delete_post(%Post{} = post) do
89 | Repo.delete(post)
90 | end
91 |
92 | @doc """
93 | Returns an `%Ecto.Changeset{}` for tracking post changes.
94 |
95 | ## Examples
96 |
97 | iex> change_post(post)
98 | %Ecto.Changeset{source: %Post{}}
99 |
100 | """
101 | def change_post(%Post{} = post) do
102 | Post.changeset(post, %{})
103 | end
104 | end
105 |
--------------------------------------------------------------------------------
/test/coherence_demo/blogs/blogs_test.exs:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemo.BlogsTest do
2 | use CoherenceDemo.DataCase
3 |
4 | alias CoherenceDemo.Blogs
5 |
6 | describe "posts" do
7 | alias CoherenceDemo.Blogs.Post
8 |
9 | @valid_attrs %{body: "some body", title: "some title"}
10 | @update_attrs %{body: "some updated body", title: "some updated title"}
11 | @invalid_attrs %{body: nil, title: nil}
12 |
13 | def post_fixture(attrs \\ %{}) do
14 | {:ok, post} =
15 | attrs
16 | |> Enum.into(@valid_attrs)
17 | |> Blogs.create_post()
18 |
19 | post
20 | end
21 |
22 | test "list_posts/0 returns all posts" do
23 | post = post_fixture()
24 | assert Blogs.list_posts() == [post]
25 | end
26 |
27 | test "get_post!/1 returns the post with given id" do
28 | post = post_fixture()
29 | assert Blogs.get_post!(post.id) == post
30 | end
31 |
32 | test "create_post/1 with valid data creates a post" do
33 | assert {:ok, %Post{} = post} = Blogs.create_post(@valid_attrs)
34 | assert post.body == "some body"
35 | assert post.title == "some title"
36 | end
37 |
38 | test "create_post/1 with invalid data returns error changeset" do
39 | assert {:error, %Ecto.Changeset{}} = Blogs.create_post(@invalid_attrs)
40 | end
41 |
42 | test "update_post/2 with valid data updates the post" do
43 | post = post_fixture()
44 | assert {:ok, post} = Blogs.update_post(post, @update_attrs)
45 | assert %Post{} = post
46 | assert post.body == "some updated body"
47 | assert post.title == "some updated title"
48 | end
49 |
50 | test "update_post/2 with invalid data returns error changeset" do
51 | post = post_fixture()
52 | assert {:error, %Ecto.Changeset{}} = Blogs.update_post(post, @invalid_attrs)
53 | assert post == Blogs.get_post!(post.id)
54 | end
55 |
56 | test "delete_post/1 deletes the post" do
57 | post = post_fixture()
58 | assert {:ok, %Post{}} = Blogs.delete_post(post)
59 | assert_raise Ecto.NoResultsError, fn -> Blogs.get_post!(post.id) end
60 | end
61 |
62 | test "change_post/1 returns a post changeset" do
63 | post = post_fixture()
64 | assert %Ecto.Changeset{} = Blogs.change_post(post)
65 | end
66 | end
67 | end
68 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/templates/coherence/registration/form.html.eex:
--------------------------------------------------------------------------------
1 | <%= form_for @changeset, @action, [as: :registration], fn f -> %>
2 |
3 | <%= if @changeset.action do %>
4 |
5 |
<%= dgettext "coherence", "Oops, something went wrong! Please check the errors below." %>
6 |
10 | <%= required_label f, dgettext("coherence", "Name"), class: "control-label" %>
11 | <%= text_input f, :name, class: "form-control", required: "" %>
12 | <%= error_tag f, :name %>
13 |
14 |
15 | <%= unless (login_field = Coherence.Config.login_field) == :email do %>
16 |
17 | <%= required_label f, login_field, class: "control-label" %>
18 | <%= text_input f, login_field, class: "form-control", required: "" %>
19 | <%= error_tag f, login_field %>
20 |
21 | <% end %>
22 |
23 |
24 | <%= required_label f, dgettext("coherence", "Email"), class: "control-label" %>
25 | <%= text_input f, :email, class: "form-control", required: "" %>
26 | <%= error_tag f, :email %>
27 |
28 |
29 | <%= if Coherence.Config.require_current_password and not is_nil(@changeset.data.id) do %>
30 |
31 | <%= required_label f, :current_password, class: "control-label" %>
32 | <%= password_input f, :current_password, [class: "form-control"] ++ @required %>
33 | <%= error_tag f, :current_password %>
34 |
35 | <% end %>
36 |
37 |
38 | <%= required_label f, dgettext("coherence", "Password"), class: "control-label" %>
39 | <%= password_input f, :password, [class: "form-control"] ++ @required %>
40 | <%= error_tag f, :password %>
41 |
42 |
43 |
44 | <%= required_label f, dgettext("coherence", "Password Confirmation"), class: "control-label" %>
45 | <%= password_input f, :password_confirmation, [class: "form-control"] ++ @required %>
46 | <%= error_tag f, :password_confirmation %>
47 |
48 |
49 |
50 | <%= submit @label, class: "btn btn-primary" %>
51 | <%= link dgettext("coherence", "Cancel"), to: Coherence.Config.logged_out_url("/"), class: "btn" %>
52 |
53 | <% end %>
54 |
--------------------------------------------------------------------------------
/assets/js/socket.js:
--------------------------------------------------------------------------------
1 | // NOTE: The contents of this file will only be executed if
2 | // you uncomment its entry in "assets/js/app.js".
3 |
4 | // To use Phoenix channels, the first step is to import Socket
5 | // and connect at the socket path in "lib/web/endpoint.ex":
6 | import {Socket} from "phoenix"
7 |
8 | let socket = new Socket("/socket", {params: {token: window.userToken}})
9 |
10 | // When you connect, you'll often need to authenticate the client.
11 | // For example, imagine you have an authentication plug, `MyAuth`,
12 | // which authenticates the session and assigns a `:current_user`.
13 | // If the current user exists you can assign the user's token in
14 | // the connection for use in the layout.
15 | //
16 | // In your "lib/web/router.ex":
17 | //
18 | // pipeline :browser do
19 | // ...
20 | // plug MyAuth
21 | // plug :put_user_token
22 | // end
23 | //
24 | // defp put_user_token(conn, _) do
25 | // if current_user = conn.assigns[:current_user] do
26 | // token = Phoenix.Token.sign(conn, "user socket", current_user.id)
27 | // assign(conn, :user_token, token)
28 | // else
29 | // conn
30 | // end
31 | // end
32 | //
33 | // Now you need to pass this token to JavaScript. You can do so
34 | // inside a script tag in "lib/web/templates/layout/app.html.eex":
35 | //
36 | //
37 | //
38 | // You will need to verify the user token in the "connect/2" function
39 | // in "lib/web/channels/user_socket.ex":
40 | //
41 | // def connect(%{"token" => token}, socket) do
42 | // # max_age: 1209600 is equivalent to two weeks in seconds
43 | // case Phoenix.Token.verify(socket, "user socket", token, max_age: 1209600) do
44 | // {:ok, user_id} ->
45 | // {:ok, assign(socket, :user, user_id)}
46 | // {:error, reason} ->
47 | // :error
48 | // end
49 | // end
50 | //
51 | // Finally, pass the token on connect as below. Or remove it
52 | // from connect if you don't care about authentication.
53 |
54 | socket.connect()
55 |
56 | // Now that you are connected, you can join channels with a topic:
57 | let channel = socket.channel("topic:subtopic", {})
58 | channel.join()
59 | .receive("ok", resp => { console.log("Joined successfully", resp) })
60 | .receive("error", resp => { console.log("Unable to join", resp) })
61 |
62 | export default socket
63 |
--------------------------------------------------------------------------------
/config/prod.exs:
--------------------------------------------------------------------------------
1 | use Mix.Config
2 |
3 | # For production, we often load configuration from external
4 | # sources, such as your system environment. For this reason,
5 | # you won't find the :http configuration below, but set inside
6 | # CoherenceDemoWeb.Endpoint.init/2 when load_from_system_env is
7 | # true. Any dynamic configuration should be done there.
8 | #
9 | # Don't forget to configure the url host to something meaningful,
10 | # Phoenix uses this information when generating URLs.
11 | #
12 | # Finally, we also include the path to a cache manifest
13 | # containing the digested version of static files. This
14 | # manifest is generated by the mix phx.digest task
15 | # which you typically run after static files are built.
16 | config :coherence_demo, CoherenceDemoWeb.Endpoint,
17 | load_from_system_env: true,
18 | url: [host: "example.com", port: 80],
19 | cache_static_manifest: "priv/static/cache_manifest.json"
20 |
21 | # Do not print debug messages in production
22 | config :logger, level: :info
23 |
24 | # ## SSL Support
25 | #
26 | # To get SSL working, you will need to add the `https` key
27 | # to the previous section and set your `:url` port to 443:
28 | #
29 | # config :coherence_demo, CoherenceDemoWeb.Endpoint,
30 | # ...
31 | # url: [host: "example.com", port: 443],
32 | # https: [:inet6,
33 | # port: 443,
34 | # keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"),
35 | # certfile: System.get_env("SOME_APP_SSL_CERT_PATH")]
36 | #
37 | # Where those two env variables return an absolute path to
38 | # the key and cert in disk or a relative path inside priv,
39 | # for example "priv/ssl/server.key".
40 | #
41 | # We also recommend setting `force_ssl`, ensuring no data is
42 | # ever sent via http, always redirecting to https:
43 | #
44 | # config :coherence_demo, CoherenceDemoWeb.Endpoint,
45 | # force_ssl: [hsts: true]
46 | #
47 | # Check `Plug.SSL` for all available options in `force_ssl`.
48 |
49 | # ## Using releases
50 | #
51 | # If you are doing OTP releases, you need to instruct Phoenix
52 | # to start the server for all endpoints:
53 | #
54 | # config :phoenix, :serve_endpoints, true
55 | #
56 | # Alternatively, you can configure exactly which server to
57 | # start per endpoint:
58 | #
59 | # config :coherence_demo, CoherenceDemoWeb.Endpoint, server: true
60 | #
61 |
62 | # Finally import the config/prod.secret.exs
63 | # which should be versioned separately.
64 | import_config "prod.secret.exs"
65 |
--------------------------------------------------------------------------------
/priv/gettext/en/LC_MESSAGES/errors.po:
--------------------------------------------------------------------------------
1 | ## `msgid`s in this file come from POT (.pot) files.
2 | ##
3 | ## Do not add, change, or remove `msgid`s manually here as
4 | ## they're tied to the ones in the corresponding POT file
5 | ## (with the same domain).
6 | ##
7 | ## Use `mix gettext.extract --merge` or `mix gettext.merge`
8 | ## to merge POT files into PO files.
9 | msgid ""
10 | msgstr ""
11 | "Language: en\n"
12 |
13 | ## From Ecto.Changeset.cast/4
14 | msgid "can't be blank"
15 | msgstr ""
16 |
17 | ## From Ecto.Changeset.unique_constraint/3
18 | msgid "has already been taken"
19 | msgstr ""
20 |
21 | ## From Ecto.Changeset.put_change/3
22 | msgid "is invalid"
23 | msgstr ""
24 |
25 | ## From Ecto.Changeset.validate_acceptance/3
26 | msgid "must be accepted"
27 | msgstr ""
28 |
29 | ## From Ecto.Changeset.validate_format/3
30 | msgid "has invalid format"
31 | msgstr ""
32 |
33 | ## From Ecto.Changeset.validate_subset/3
34 | msgid "has an invalid entry"
35 | msgstr ""
36 |
37 | ## From Ecto.Changeset.validate_exclusion/3
38 | msgid "is reserved"
39 | msgstr ""
40 |
41 | ## From Ecto.Changeset.validate_confirmation/3
42 | msgid "does not match confirmation"
43 | msgstr ""
44 |
45 | ## From Ecto.Changeset.no_assoc_constraint/3
46 | msgid "is still associated with this entry"
47 | msgstr ""
48 |
49 | msgid "are still associated with this entry"
50 | msgstr ""
51 |
52 | ## From Ecto.Changeset.validate_length/3
53 | msgid "should be %{count} character(s)"
54 | msgid_plural "should be %{count} character(s)"
55 | msgstr[0] ""
56 | msgstr[1] ""
57 |
58 | msgid "should have %{count} item(s)"
59 | msgid_plural "should have %{count} item(s)"
60 | msgstr[0] ""
61 | msgstr[1] ""
62 |
63 | msgid "should be at least %{count} character(s)"
64 | msgid_plural "should be at least %{count} character(s)"
65 | msgstr[0] ""
66 | msgstr[1] ""
67 |
68 | msgid "should have at least %{count} item(s)"
69 | msgid_plural "should have at least %{count} item(s)"
70 | msgstr[0] ""
71 | msgstr[1] ""
72 |
73 | msgid "should be at most %{count} character(s)"
74 | msgid_plural "should be at most %{count} character(s)"
75 | msgstr[0] ""
76 | msgstr[1] ""
77 |
78 | msgid "should have at most %{count} item(s)"
79 | msgid_plural "should have at most %{count} item(s)"
80 | msgstr[0] ""
81 | msgstr[1] ""
82 |
83 | ## From Ecto.Changeset.validate_number/3
84 | msgid "must be less than %{number}"
85 | msgstr ""
86 |
87 | msgid "must be greater than %{number}"
88 | msgstr ""
89 |
90 | msgid "must be less than or equal to %{number}"
91 | msgstr ""
92 |
93 | msgid "must be greater than or equal to %{number}"
94 | msgstr ""
95 |
96 | msgid "must be equal to %{number}"
97 | msgstr ""
98 |
--------------------------------------------------------------------------------
/priv/gettext/errors.pot:
--------------------------------------------------------------------------------
1 | ## This file is a PO Template file.
2 | ##
3 | ## `msgid`s here are often extracted from source code.
4 | ## Add new translations manually only if they're dynamic
5 | ## translations that can't be statically extracted.
6 | ##
7 | ## Run `mix gettext.extract` to bring this file up to
8 | ## date. Leave `msgstr`s empty as changing them here as no
9 | ## effect: edit them in PO (`.po`) files instead.
10 |
11 | ## From Ecto.Changeset.cast/4
12 | msgid "can't be blank"
13 | msgstr ""
14 |
15 | ## From Ecto.Changeset.unique_constraint/3
16 | msgid "has already been taken"
17 | msgstr ""
18 |
19 | ## From Ecto.Changeset.put_change/3
20 | msgid "is invalid"
21 | msgstr ""
22 |
23 | ## From Ecto.Changeset.validate_acceptance/3
24 | msgid "must be accepted"
25 | msgstr ""
26 |
27 | ## From Ecto.Changeset.validate_format/3
28 | msgid "has invalid format"
29 | msgstr ""
30 |
31 | ## From Ecto.Changeset.validate_subset/3
32 | msgid "has an invalid entry"
33 | msgstr ""
34 |
35 | ## From Ecto.Changeset.validate_exclusion/3
36 | msgid "is reserved"
37 | msgstr ""
38 |
39 | ## From Ecto.Changeset.validate_confirmation/3
40 | msgid "does not match confirmation"
41 | msgstr ""
42 |
43 | ## From Ecto.Changeset.no_assoc_constraint/3
44 | msgid "is still associated with this entry"
45 | msgstr ""
46 |
47 | msgid "are still associated with this entry"
48 | msgstr ""
49 |
50 | ## From Ecto.Changeset.validate_length/3
51 | msgid "should be %{count} character(s)"
52 | msgid_plural "should be %{count} character(s)"
53 | msgstr[0] ""
54 | msgstr[1] ""
55 |
56 | msgid "should have %{count} item(s)"
57 | msgid_plural "should have %{count} item(s)"
58 | msgstr[0] ""
59 | msgstr[1] ""
60 |
61 | msgid "should be at least %{count} character(s)"
62 | msgid_plural "should be at least %{count} character(s)"
63 | msgstr[0] ""
64 | msgstr[1] ""
65 |
66 | msgid "should have at least %{count} item(s)"
67 | msgid_plural "should have at least %{count} item(s)"
68 | msgstr[0] ""
69 | msgstr[1] ""
70 |
71 | msgid "should be at most %{count} character(s)"
72 | msgid_plural "should be at most %{count} character(s)"
73 | msgstr[0] ""
74 | msgstr[1] ""
75 |
76 | msgid "should have at most %{count} item(s)"
77 | msgid_plural "should have at most %{count} item(s)"
78 | msgstr[0] ""
79 | msgstr[1] ""
80 |
81 | ## From Ecto.Changeset.validate_number/3
82 | msgid "must be less than %{number}"
83 | msgstr ""
84 |
85 | msgid "must be greater than %{number}"
86 | msgstr ""
87 |
88 | msgid "must be less than or equal to %{number}"
89 | msgstr ""
90 |
91 | msgid "must be greater than or equal to %{number}"
92 | msgstr ""
93 |
94 | msgid "must be equal to %{number}"
95 | msgstr ""
96 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/emails/coherence/user_email.ex:
--------------------------------------------------------------------------------
1 | Code.ensure_loaded Phoenix.Swoosh
2 |
3 | defmodule CoherenceDemoWeb.Coherence.UserEmail do
4 | @moduledoc false
5 | use Phoenix.Swoosh, view: CoherenceDemoWeb.Coherence.EmailView, layout: {CoherenceDemoWeb.Coherence.LayoutView, :email}
6 | alias Swoosh.Email
7 | require Logger
8 | alias Coherence.Config
9 | import CoherenceDemoWeb.Gettext
10 |
11 | defp site_name, do: Config.site_name(inspect Config.module)
12 |
13 | def password(user, url) do
14 | %Email{}
15 | |> from(from_email())
16 | |> to(user_email(user))
17 | |> add_reply_to()
18 | |> subject(dgettext("coherence", "%{site_name} - Reset password instructions", site_name: site_name()))
19 | |> render_body("password.html", %{url: url, name: first_name(user.name)})
20 | end
21 |
22 | def confirmation(user, url) do
23 | %Email{}
24 | |> from(from_email())
25 | |> to(user_email(user))
26 | |> add_reply_to()
27 | |> subject(dgettext("coherence", "%{site_name} - Confirm your new account", site_name: site_name()))
28 | |> render_body("confirmation.html", %{url: url, name: first_name(user.name)})
29 | end
30 |
31 | def invitation(invitation, url) do
32 | %Email{}
33 | |> from(from_email())
34 | |> to(user_email(invitation))
35 | |> add_reply_to()
36 | |> subject(dgettext("coherence", "%{site_name} - Invitation to create a new account", site_name: site_name()))
37 | |> render_body("invitation.html", %{url: url, name: first_name(invitation.name)})
38 | end
39 |
40 | def unlock(user, url) do
41 | %Email{}
42 | |> from(from_email())
43 | |> to(user_email(user))
44 | |> add_reply_to()
45 | |> subject(dgettext("coherence", "%{site_name} - Unlock Instructions", site_name: site_name()))
46 | |> render_body("unlock.html", %{url: url, name: first_name(user.name)})
47 | end
48 |
49 | defp add_reply_to(mail) do
50 | case Coherence.Config.email_reply_to do
51 | nil -> mail
52 | true -> reply_to mail, from_email()
53 | address -> reply_to mail, address
54 | end
55 | end
56 |
57 | defp first_name(name) do
58 | case String.split(name, " ") do
59 | [first_name | _] -> first_name
60 | _ -> name
61 | end
62 | end
63 |
64 | defp user_email(user) do
65 | {user.name, user.email}
66 | end
67 |
68 | defp from_email do
69 | case Coherence.Config.email_from do
70 | nil ->
71 | Logger.error ~s|Need to configure :coherence, :email_from_name, "Name", and :email_from_email, "me@example.com"|
72 | nil
73 | {name, email} = email_tuple ->
74 | if is_nil(name) or is_nil(email) do
75 | Logger.error ~s|Need to configure :coherence, :email_from_name, "Name", and :email_from_email, "me@example.com"|
76 | nil
77 | else
78 | email_tuple
79 | end
80 | end
81 | end
82 | end
83 |
--------------------------------------------------------------------------------
/test/coherence_demo_web/controllers/post_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.PostControllerTest do
2 | use CoherenceDemoWeb.ConnCase
3 |
4 | alias CoherenceDemo.Blogs
5 |
6 | @create_attrs %{body: "some body", title: "some title"}
7 | @update_attrs %{body: "some updated body", title: "some updated title"}
8 | @invalid_attrs %{body: nil, title: nil}
9 |
10 | def fixture(:post) do
11 | {:ok, post} = Blogs.create_post(@create_attrs)
12 | post
13 | end
14 |
15 | describe "index" do
16 | test "lists all posts", %{conn: conn} do
17 | conn = get conn, post_path(conn, :index)
18 | assert html_response(conn, 200) =~ "Listing Posts"
19 | end
20 | end
21 |
22 | describe "new post" do
23 | test "renders form", %{conn: conn} do
24 | conn = get conn, post_path(conn, :new)
25 | assert html_response(conn, 200) =~ "New Post"
26 | end
27 | end
28 |
29 | describe "create post" do
30 | test "redirects to show when data is valid", %{conn: conn} do
31 | conn = post conn, post_path(conn, :create), post: @create_attrs
32 |
33 | assert %{id: id} = redirected_params(conn)
34 | assert redirected_to(conn) == post_path(conn, :show, id)
35 |
36 | conn = get conn, post_path(conn, :show, id)
37 | assert html_response(conn, 200) =~ "Show Post"
38 | end
39 |
40 | test "renders errors when data is invalid", %{conn: conn} do
41 | conn = post conn, post_path(conn, :create), post: @invalid_attrs
42 | assert html_response(conn, 200) =~ "New Post"
43 | end
44 | end
45 |
46 | describe "edit post" do
47 | setup [:create_post]
48 |
49 | test "renders form for editing chosen post", %{conn: conn, post: post} do
50 | conn = get conn, post_path(conn, :edit, post)
51 | assert html_response(conn, 200) =~ "Edit Post"
52 | end
53 | end
54 |
55 | describe "update post" do
56 | setup [:create_post]
57 |
58 | test "redirects when data is valid", %{conn: conn, post: post} do
59 | conn = put conn, post_path(conn, :update, post), post: @update_attrs
60 | assert redirected_to(conn) == post_path(conn, :show, post)
61 |
62 | conn = get conn, post_path(conn, :show, post)
63 | assert html_response(conn, 200) =~ "some updated body"
64 | end
65 |
66 | test "renders errors when data is invalid", %{conn: conn, post: post} do
67 | conn = put conn, post_path(conn, :update, post), post: @invalid_attrs
68 | assert html_response(conn, 200) =~ "Edit Post"
69 | end
70 | end
71 |
72 | describe "delete post" do
73 | setup [:create_post]
74 |
75 | test "deletes chosen post", %{conn: conn, post: post} do
76 | conn = delete conn, post_path(conn, :delete, post)
77 | assert redirected_to(conn) == post_path(conn, :index)
78 | assert_error_sent 404, fn ->
79 | get conn, post_path(conn, :show, post)
80 | end
81 | end
82 | end
83 |
84 | defp create_post(_) do
85 | post = fixture(:post)
86 | {:ok, post: post}
87 | end
88 | end
89 |
--------------------------------------------------------------------------------
/lib/coherence_demo_web/controllers/user_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule CoherenceDemoWeb.UserController do
2 | use CoherenceDemoWeb, :controller
3 | use Timex
4 |
5 | alias Coherence.Controller
6 | alias CoherenceDemo.Coherence.User
7 |
8 | def index(conn, _params) do
9 | users = Repo.all(User)
10 | render(conn, "index.html", users: users)
11 | end
12 |
13 | def new(conn, _params) do
14 | changeset = User.changeset(%User{})
15 | render(conn, "new.html", changeset: changeset)
16 | end
17 |
18 | def create(conn, %{"user" => user_params}) do
19 | changeset = User.changeset(%User{}, user_params)
20 |
21 | case Repo.insert(changeset) do
22 | {:ok, _user} ->
23 | conn
24 | |> put_flash(:info, "User created successfully.")
25 | |> redirect(to: user_path(conn, :index))
26 | {:error, changeset} ->
27 | render(conn, "new.html", changeset: changeset)
28 | end
29 | end
30 |
31 | def show(conn, %{"id" => id}) do
32 | user = Repo.get!(User, id)
33 | render(conn, "show.html", user: user)
34 | end
35 |
36 | def edit(conn, %{"id" => id}) do
37 | user = Repo.get!(User, id)
38 | changeset = User.changeset(user)
39 | render(conn, "edit.html", user: user, changeset: changeset)
40 | end
41 |
42 | def update(conn, %{"id" => id, "user" => user_params}) do
43 | user = Repo.get!(User, id)
44 | changeset = User.changeset(user, user_params)
45 |
46 | case Repo.update(changeset) do
47 | {:ok, user} ->
48 | conn
49 | |> put_flash(:info, "User updated successfully.")
50 | |> redirect(to: user_path(conn, :show, user))
51 | {:error, changeset} ->
52 | render(conn, "edit.html", user: user, changeset: changeset)
53 | end
54 | end
55 |
56 | def delete(conn, %{"id" => id}) do
57 | user = Repo.get!(User, id)
58 |
59 | # Here we use delete! (with a bang) because we expect
60 | # it to always work (and if it does not, it will raise).
61 | Repo.delete!(user)
62 |
63 | conn
64 | |> put_flash(:info, "User deleted successfully.")
65 | |> redirect(to: user_path(conn, :index))
66 | end
67 |
68 | def confirm(conn, %{"id" => id}) do
69 | case Repo.get User, id do
70 | nil ->
71 | conn
72 | |> put_flash(:error, "User not found")
73 | |> redirect(to: user_path(conn, :index))
74 | user ->
75 | case Controller.confirm! user do
76 | {:error, changeset} ->
77 | conn
78 | |> put_flash(:error, format_errors(changeset))
79 | _ ->
80 | put_flash(conn, :info, "User confirmed!")
81 | end
82 | |> redirect(to: user_path(conn, :show, user.id))
83 | end
84 | end
85 |
86 | def lock(conn, %{"id" => id}) do
87 | locked_at = DateTime.utc_now
88 | |> Timex.shift(years: 10)
89 |
90 | case Repo.get User, id do
91 | nil ->
92 | conn
93 | |> put_flash(:error, "User not found")
94 | |> redirect(to: user_path(conn, :index))
95 | user ->
96 | case Controller.lock! user, locked_at do
97 | {:error, changeset} ->
98 | conn
99 | |> put_flash(:error, format_errors(changeset))
100 | _ ->
101 | put_flash(conn, :info, "User locked!")
102 | end
103 | |> redirect(to: user_path(conn, :show, user.id))
104 | end
105 | end
106 |
107 | def unlock(conn, %{"id" => id}) do
108 | case Repo.get User, id do
109 | nil ->
110 | conn
111 | |> put_flash(:error, "User not found")
112 | |> redirect(to: user_path(conn, :index))
113 | user ->
114 | case Controller.unlock! user do
115 | {:error, changeset} ->
116 | conn
117 | |> put_flash(:error, format_errors(changeset))
118 | _ ->
119 | put_flash(conn, :info, "User unlocked!")
120 | end
121 | |> redirect(to: user_path(conn, :show, user.id))
122 | end
123 | end
124 | defp format_errors(changeset) do
125 | for error <- changeset.errors do
126 | case error do
127 | {:locked_at, {err, _}} -> err
128 | {_field, {err, _}} when is_binary(err) or is_atom(err) ->
129 | "#{err}"
130 | other -> inspect other
131 | end
132 | end
133 | |> Enum.join("