39 | <% end %>
40 |
--------------------------------------------------------------------------------
/web/templates/tag/index.html.eex:
--------------------------------------------------------------------------------
1 | <%= if success_message = get_flash(@conn, :success) do %>
2 |
3 |
4 |
<%= success_message %>
5 | <%= if restore_link = get_flash(@conn, :restore_link) do %>
6 |
7 | Oops! That's not what I wanted to do. <%= link method: "put", to: restore_link, form: [class: "inline-form", style: "display:inline"] do %>Put it back!<% end %>
8 | <% end %>
9 |
10 | <% end %>
11 |
12 | <%= render Carbon.TagView, "_show_card.html", conn: @conn, tags: @account_tags, occurrences: @account_tag_occurs, tagged: "account" %>
13 | <%= render Carbon.TagView, "_show_card.html", conn: @conn, tags: @contact_tags, occurrences: @contact_tag_occurs, tagged: "contact" %>
14 | <%= render Carbon.TagView, "_show_card.html", conn: @conn, tags: @deal_tags, occurrences: @deal_tag_occurs, tagged: "deal" %>
15 | <%= render Carbon.TagView, "_show_card.html", conn: @conn, tags: @event_tags, occurrences: @event_tag_occurs, tagged: "event" %>
16 | <%= render Carbon.TagView, "_show_card.html", conn: @conn, tags: @project_tags, occurrences: @project_tag_occurs, tagged: "project" %>
17 | <%= render Carbon.TagView, "_show_card.html", conn: @conn, tags: @timesheet_tags, occurrences: @timesheet_tag_occurs, tagged: "timesheet" %>
18 |
19 |
24 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20160730124546_create_user_table.exs:
--------------------------------------------------------------------------------
1 | defmodule Carbon.Repo.Migrations.CreateUserTable do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table :users do
6 | add :lock_version, :integer, default: 1, null: false
7 |
8 | add :handle, :string, null: false
9 | add :name, :string
10 | add :title, :string
11 | add :email_hash, :string, null: false
12 |
13 | add :active, :boolean, null: false, default: true
14 |
15 | timestamps
16 | end
17 |
18 | create unique_index(:users, [:handle])
19 | create unique_index(:users, [:email_hash])
20 |
21 | create table :roles do
22 | add :lock_version, :integer, default: 1, null: false
23 |
24 | add :key, :string, null: false
25 | add :description, :string
26 |
27 | add :active, :boolean, null: false, default: true
28 |
29 | timestamps
30 | end
31 |
32 | create unique_index(:roles, [:key])
33 |
34 | create table(:j_users_roles, primary_key: false) do
35 | add :user_id, references(:users)
36 | add :role_id, references(:roles)
37 | end
38 |
39 | create unique_index(:j_users_roles, [:user_id, :role_id])
40 |
41 | create table :login_tokens do
42 | add :user_id, references(:users)
43 | add :token, :string, null: false
44 | add :type, :string, null: false
45 |
46 | timestamps
47 | end
48 |
49 | create index(:login_tokens, [:token])
50 | end
51 | end
52 |
--------------------------------------------------------------------------------
/web/controllers/session_plug.ex:
--------------------------------------------------------------------------------
1 | defmodule Carbon.SessionPlug do
2 | import Plug.Conn
3 | alias Carbon.{User, Repo}
4 |
5 | @moduledoc """
6 | Intercepts protected routes.
7 |
8 | Checks the connection for a web session or a cookie containing a long-lived
9 | session token. If the web session is present, pass-through. If the long-lived
10 | session token is still valid, assign the user to the web session and
11 | pass-through. Otherwise, halt and redirect to the login page.
12 | """
13 |
14 | @one_week_in_sec 7*24*60*60
15 |
16 | def init(opts), do: opts
17 |
18 | def call(conn, _opts) do
19 | conn
20 | |> maybe_assign_user
21 | |> maybe_redirect_to_login_page
22 | end
23 |
24 | defp maybe_assign_user(conn) do
25 | case get_key(conn, :user_id) do
26 | nil -> conn
27 | user_id -> assign(conn, :current_user, Repo.get!(User, user_id))
28 | end
29 | end
30 |
31 | defp maybe_redirect_to_login_page(%Plug.Conn{assigns: %{current_user: user}} = conn) when user != nil, do: conn
32 | defp maybe_redirect_to_login_page(conn) do
33 | conn
34 | |> Phoenix.Controller.put_flash(:error, "You must be logged in to access this page")
35 | |> Phoenix.Controller.redirect(to: Carbon.Router.Helpers.session_path(conn, :index))
36 | |> halt()
37 | end
38 |
39 | defp get_key(conn, key) do
40 | if Application.get_env(:carbon, :env) == :test do
41 | conn.private[key]
42 | else
43 | get_session(conn, key)
44 | end
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/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 :carbon, Carbon.Endpoint,
10 | http: [port: 4000],
11 | debug_errors: true,
12 | code_reloader: true,
13 | check_origin: false,
14 | watchers: []
15 |
16 | # Watch static and templates for browser reloading.
17 | config :carbon, Carbon.Endpoint,
18 | live_reload: [
19 | patterns: [
20 | ~r{priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$},
21 | ~r{priv/gettext/.*(po)$},
22 | ~r{web/views/.*(ex)$},
23 | ~r{web/templates/.*(eex)$}
24 | ]
25 | ]
26 |
27 | # Do not include metadata nor timestamps in development logs
28 | config :logger, :console, format: "[$level] $message\n"
29 |
30 | # Set a higher stacktrace during development. Avoid configuring such
31 | # in production as building large stacktraces may be expensive.
32 | config :phoenix, :stacktrace_depth, 20
33 |
34 | # Configure your database
35 | config :carbon, Carbon.Repo,
36 | adapter: Ecto.Adapters.Postgres,
37 | username: "postgres",
38 | password: "postgres",
39 | database: "carbon_dev",
40 | hostname: "localhost",
41 | pool_size: 10
42 |
43 | config :carbon, Carbon.Mailer,
44 | adapter: Bamboo.LocalAdapter,
45 | website_entry_point: "http://localhost:4000"
46 |
47 | config :carbon, :env, :dev
48 |
--------------------------------------------------------------------------------
/web/views/error_helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule Carbon.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 | if error = form.errors[field] do
13 | content_tag :span, translate_error(error)
14 | end
15 | end
16 |
17 | @doc """
18 | Translates an error message using gettext.
19 | """
20 | def translate_error({"is invalid", [type: :integer]}) do
21 | Gettext.dgettext(Carbon.Gettext, "errors", "must be an integer")
22 | end
23 | def translate_error({msg, opts}) do
24 | # Because error messages were defined within Ecto, we must
25 | # call the Gettext module passing our Gettext backend. We
26 | # also use the "errors" domain as translations are placed
27 | # in the errors.po file.
28 | # Ecto will pass the :count keyword if the error message is
29 | # meant to be pluralized.
30 | # On your own code and templates, depending on whether you
31 | # need the message to be pluralized or not, this could be
32 | # written simply as:
33 | #
34 | # dngettext "errors", "1 file", "%{count} files", count
35 | # dgettext "errors", "is invalid"
36 | #
37 | if count = opts[:count] do
38 | Gettext.dngettext(Carbon.Gettext, "errors", msg, msg, count, opts)
39 | else
40 | Gettext.dgettext(Carbon.Gettext, "errors", msg, opts)
41 | end
42 | end
43 |
44 | end
45 |
--------------------------------------------------------------------------------
/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 | use Mix.Config
7 |
8 | # General application configuration
9 | config :carbon,
10 | ecto_repos: [Carbon.Repo]
11 |
12 | # Configures the endpoint
13 | config :carbon, Carbon.Endpoint,
14 | url: [host: "localhost"],
15 | root: Path.dirname(__DIR__),
16 | secret_key_base: "u/SYPEI6LdXu/69/HCC+y9CRZ7byzOkQcbOJwkLEPRsTRnN5Dxc3xldEz3DzkJ+K",
17 | render_errors: [view: Carbon.ErrorView, accepts: ~w(html json)],
18 | pubsub: [name: Carbon.PubSub,
19 | adapter: Phoenix.PubSub.PG2]
20 |
21 | # Configures Elixir's Logger
22 | config :logger, :console,
23 | format: "$time $metadata[$level] $message\n",
24 | metadata: [:request_id]
25 |
26 | config :number, currency: [
27 | unit: "$",
28 | precision: 2,
29 | delimiter: "\u00A0",
30 | separator: ",",
31 | format: "%n\%u", # "30.00 $"
32 | negative_format: "-\u00A0%n\u00A0%u" # "- 30.00 $"
33 | ],
34 | delimit: [
35 | precision: 2,
36 | delimiter: " ",
37 | separator: ","
38 | ]
39 |
40 |
41 |
42 | # Import environment specific config. This must remain at the bottom
43 | # of this file so it overrides the configuration defined above.
44 | import_config "#{Mix.env}.exs"
45 |
--------------------------------------------------------------------------------
/web/templates/user/index.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
Users
5 |
6 |
7 | <%= link to: user_path(@conn, :new), class: "ui green button " do %>
8 |
9 | Create user
10 | <% end %>
11 |
12 |
13 |
14 |
15 | <%= for user <- @users do %>
16 | <%= link to: user_path(@conn, :show, user.id), class: "ui card" do %>
17 |
33 | <%= if activity.changes != "" do %>
34 | <%= case activity.action do %>
35 | <%= "create" -> %>
36 | <%= "remove" -> %>
37 | <%= "update" -> %>
38 | <%= "restore" -> %>
39 | <% end %>
40 | <% field_names = activity.changes |> String.split(",") |> Enum.map(&for_humans/1) %>
41 | <%= for { name, reverse_index } <- Enum.zip(field_names, (length field_names)-1..0) do %>
42 | <%= name %><%= if reverse_index > 1, do: ", " %><%= if reverse_index == 1, do: " and " %><%= if reverse_index == 0, do: "." %>
43 | <% end %>
44 | <% end %>
45 |
46 |
47 |
48 | <% end %>
49 |
50 |
--------------------------------------------------------------------------------
/web/views/paginator_helper.ex:
--------------------------------------------------------------------------------
1 | defmodule Carbon.PaginatorHelper do
2 | use Phoenix.HTML
3 | alias Carbon.Paginator
4 |
5 | def paginate(conn, paginator = %Paginator{}, module) do
6 | if paginator.number_of_pages > 1 do
7 | content_tag :div, class: "ui center aligned container" do
8 | [
9 | get_previous_link(conn, paginator, module),
10 | get_links(conn, paginator, module),
11 | get_next_link(conn, paginator, module)
12 | ]
13 | end
14 | end
15 | end
16 |
17 | defp get_previous_link(conn, paginator = %Paginator{}, module) do
18 | css_class = if paginator.page == 1 do "disabled" else "basic" end
19 |
20 | link content_tag(:i, "", class: "ui icon angle left"),
21 | to: generate_url(conn, module, [page: paginator.page-1, length: paginator.length]),
22 | class: "ui button " <> css_class
23 | end
24 |
25 | defp get_next_link(conn, paginator = %Paginator{}, module) do
26 | css_class = if paginator.page == paginator.number_of_pages do "disabled" else "basic" end
27 |
28 | link content_tag(:i, "", class: "ui icon angle right"),
29 | to: generate_url(conn, module, [page: paginator.page+1, length: paginator.length]),
30 | class: "ui button " <> css_class
31 | end
32 |
33 | defp get_links(conn, paginator = %Paginator{}, module) do
34 | links = for page_number <- 1..paginator.number_of_pages do
35 | url_path = generate_url(conn, module, [page: page_number, length: paginator.length])
36 |
37 | css_class = if page_number == paginator.page do " active" else "" end
38 |
39 | link page_number,
40 | to: url_path,
41 | class: "ui button basic" <> css_class
42 | end
43 | links
44 | end
45 |
46 | defp generate_url(conn, module, args) do
47 | Kernel.apply Carbon.Router.Helpers,
48 | String.to_atom("#{module}_path"),
49 | [conn, String.to_atom("#{conn.private.phoenix_action}"), args]
50 | end
51 | end
52 |
--------------------------------------------------------------------------------
/web/web.ex:
--------------------------------------------------------------------------------
1 | defmodule Carbon.Web do
2 | @moduledoc """
3 | A module that keeps using definitions for controllers,
4 | views and so on.
5 |
6 | This can be used in your application as:
7 |
8 | use Carbon.Web, :controller
9 | use Carbon.Web, :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.
17 | """
18 |
19 | def model do
20 | quote do
21 | use Ecto.Schema
22 |
23 | import Ecto
24 | import Ecto.Changeset
25 | import Ecto.Query
26 | end
27 | end
28 |
29 | def controller do
30 | quote do
31 | use Phoenix.Controller
32 |
33 | alias Carbon.Repo
34 | import Ecto
35 | import Ecto.Query
36 |
37 | import Carbon.Router.Helpers
38 | import Carbon.Gettext
39 | end
40 | end
41 |
42 | def view do
43 | quote do
44 | use Phoenix.View, root: "web/templates"
45 |
46 | # Import convenience functions from controllers
47 | import Phoenix.Controller, only: [get_csrf_token: 0, get_flash: 2, view_module: 1]
48 |
49 | # Use all HTML functionality (forms, tags, etc)
50 | use Phoenix.HTML
51 |
52 | import Carbon.Router.Helpers
53 | import Carbon.ErrorHelpers
54 | import Carbon.Gettext
55 | end
56 | end
57 |
58 | def router do
59 | quote do
60 | use Phoenix.Router
61 | end
62 | end
63 |
64 | def channel do
65 | quote do
66 | use Phoenix.Channel
67 |
68 | alias Carbon.Repo
69 | import Ecto
70 | import Ecto.Query
71 | import Carbon.Gettext
72 | end
73 | end
74 |
75 | @doc """
76 | When used, dispatch to the appropriate controller/view/etc.
77 | """
78 | defmacro __using__(which) when is_atom(which) do
79 | apply(__MODULE__, which, [])
80 | end
81 | end
82 |
--------------------------------------------------------------------------------
/web/templates/attachment/index.html.eex:
--------------------------------------------------------------------------------
1 |
4 |
5 |
6 |
Attachments
7 |
<%= @account.name %>
8 |
9 | <%= link to: account_attachment_path(@conn, :new, @account.id) do %>
10 |
Add attachment
11 | <% end %>
12 |
13 |
14 |
15 | <%= for attachment <- @attachments do %>
16 |
17 |
18 | <%= link to: account_attachment_path(@conn, :show, @account.id, attachment.id), data: [turbolinks: false] do %>
19 |
20 | <% end %>
21 |
22 |
23 |
24 | <%= link to: account_attachment_path(@conn, :show, @account.id, attachment.id), data: [turbolinks: false] do %><%= attachment.name %><% end %>
25 |
26 | <%= attachment.inserted_at |> Ecto.DateTime.to_date %>
27 | <%= if attachment.private do %><% end %>
28 |
29 |
30 |
<%= attachment.description %>
31 |
32 | <%= link to: account_attachment_path(@conn, :show, @account.id, attachment.id), data: [turbolinks: false] do %> Download<% end %>
33 | <%= link to: account_attachment_path(@conn, :edit, @account.id, attachment.id) do %> Edit<% end %>
34 | <%= link method: "delete", to: account_attachment_path(@conn, :delete, @account.id, attachment.id) do %> Remove<% end %>
35 |
36 |
37 |
38 | <% end %>
39 |
40 |
--------------------------------------------------------------------------------
/web/templates/attachment/as_card_list.html.eex:
--------------------------------------------------------------------------------
1 | <%= for attachment <- @account.attachments do %>
2 |
3 |
4 |
5 |
<%= link attachment.name, to: account_attachment_path(@conn, :show, @account.id, attachment.id), data: [turbolinks: "false"] %>
31 | <% end %>
32 |
33 |
--------------------------------------------------------------------------------
/test/support/model_case.ex:
--------------------------------------------------------------------------------
1 | defmodule Carbon.ModelCase do
2 | @moduledoc """
3 | This module defines the test case to be used by
4 | model tests.
5 |
6 | You may define functions here to be used as helpers in
7 | your model tests. See `errors_on/2`'s definition as reference.
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 Carbon.Repo
20 |
21 | import Ecto
22 | import Ecto.Changeset
23 | import Ecto.Query
24 | import Carbon.ModelCase
25 | end
26 | end
27 |
28 | setup tags do
29 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(Carbon.Repo)
30 |
31 | unless tags[:async] do
32 | Ecto.Adapters.SQL.Sandbox.mode(Carbon.Repo, {:shared, self()})
33 | end
34 |
35 | :ok
36 | end
37 |
38 | @doc """
39 | Helper for returning list of errors in a struct when given certain data.
40 |
41 | ## Examples
42 |
43 | Given a User schema that lists `:name` as a required field and validates
44 | `:password` to be safe, it would return:
45 |
46 | iex> errors_on(%User{}, %{password: "password"})
47 | [password: "is unsafe", name: "is blank"]
48 |
49 | You could then write your assertion like:
50 |
51 | assert {:password, "is unsafe"} in errors_on(%User{}, %{password: "password"})
52 |
53 | You can also create the changeset manually and retrieve the errors
54 | field directly:
55 |
56 | iex> changeset = User.changeset(%User{}, password: "password")
57 | iex> {:password, "is unsafe"} in changeset.errors
58 | true
59 | """
60 | def errors_on(struct, data) do
61 | struct.__struct__.changeset(struct, data)
62 | |> Ecto.Changeset.traverse_errors(&Carbon.ErrorHelpers.translate_error/1)
63 | |> Enum.flat_map(fn {key, errors} -> for msg <- errors, do: {key, msg} end)
64 | end
65 | end
66 |
--------------------------------------------------------------------------------