Change models, new migrations, fix front and make tests work

Signed-off-by: Thomas Citharel <tcit@tcit.fr>

lib/eventos_web/controllers/account_controller.ex

@@ -3,58 +3,37 @@ defmodule EventosWeb.AccountController do
 
   alias Eventos.Accounts
   alias Eventos.Accounts.Account
+  import Logger
+
+  action_fallback EventosWeb.FallbackController
 
   def index(conn, _params) do
     accounts = Accounts.list_accounts()
-    render(conn, "index.html", accounts: accounts)
-  end
-
-  def new(conn, _params) do
-    changeset = Accounts.change_account(%Account{})
-    render(conn, "new.html", changeset: changeset)
-  end
-
-  def create(conn, %{"account" => account_params}) do
-    case Accounts.create_account(account_params) do
-      {:ok, account} ->
-        conn
-        |> put_flash(:info, "Account created successfully.")
-        |> redirect(to: account_path(conn, :show, account))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "new.html", changeset: changeset)
-    end
+    render(conn, "index.json", accounts: accounts)
   end
 
   def show(conn, %{"id" => id}) do
-    account = Accounts.get_account!(id)
-    render(conn, "show.html", account: account)
-  end
-
-  def edit(conn, %{"id" => id}) do
-    account = Accounts.get_account!(id)
-    changeset = Accounts.change_account(account)
-    render(conn, "edit.html", account: account, changeset: changeset)
+    account = Accounts.get_account_with_everything!(id)
+    render(conn, "show.json", account: account)
   end
 
   def update(conn, %{"id" => id, "account" => account_params}) do
     account = Accounts.get_account!(id)
 
-    case Accounts.update_account(account, account_params) do
-      {:ok, account} ->
-        conn
-        |> put_flash(:info, "Account updated successfully.")
-        |> redirect(to: account_path(conn, :show, account))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "edit.html", account: account, changeset: changeset)
+    with {:ok, %Account{} = account} <- Accounts.update_account(account, account_params) do
+      render(conn, "show.json", account: account)
     end
   end
 
-  def delete(conn, %{"id" => id}) do
-    account = Accounts.get_account!(id)
-    {:ok, _account} = Accounts.delete_account(account)
-
-    conn
-    |> put_flash(:info, "Account deleted successfully.")
-    |> redirect(to: account_path(conn, :index))
+  def delete(conn, %{"id" => id_str}) do
+    {id, _} = Integer.parse(id_str)
+    if Guardian.Plug.current_resource(conn).account.id == id do
+      account = Accounts.get_account!(id)
+      with {:ok, %Account{}} <- Accounts.delete_account(account) do
+        send_resp(conn, :no_content, "")
+      end
+    else
+      send_resp(conn, 401, "")
+    end
   end
 end

lib/eventos_web/controllers/app_controller.ex

@@ -1,9 +0,0 @@
-defmodule EventosWeb.AppController do
-  use EventosWeb, :controller
-
-  plug :put_layout, false
-
-  def app(conn, _params) do
-    render conn, "index.html"
-  end
-end

lib/eventos_web/controllers/category_controller.ex

@@ -4,57 +4,39 @@ defmodule EventosWeb.CategoryController do
   alias Eventos.Events
   alias Eventos.Events.Category
 
+  action_fallback EventosWeb.FallbackController
+
   def index(conn, _params) do
     categories = Events.list_categories()
-    render(conn, "index.html", categories: categories)
-  end
-
-  def new(conn, _params) do
-    changeset = Events.change_category(%Category{})
-    render(conn, "new.html", changeset: changeset)
+    render(conn, "index.json", categories: categories)
   end
 
   def create(conn, %{"category" => category_params}) do
-    case Events.create_category(category_params) do
-      {:ok, category} ->
-        conn
-        |> put_flash(:info, "Category created successfully.")
-        |> redirect(to: category_path(conn, :show, category))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "new.html", changeset: changeset)
+    with {:ok, %Category{} = category} <- Events.create_category(category_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", category_path(conn, :show, category))
+      |> render("show.json", category: category)
     end
   end
 
   def show(conn, %{"id" => id}) do
     category = Events.get_category!(id)
-    render(conn, "show.html", category: category)
-  end
-
-  def edit(conn, %{"id" => id}) do
-    category = Events.get_category!(id)
-    changeset = Events.change_category(category)
-    render(conn, "edit.html", category: category, changeset: changeset)
+    render(conn, "show.json", category: category)
   end
 
   def update(conn, %{"id" => id, "category" => category_params}) do
     category = Events.get_category!(id)
 
-    case Events.update_category(category, category_params) do
-      {:ok, category} ->
-        conn
-        |> put_flash(:info, "Category updated successfully.")
-        |> redirect(to: category_path(conn, :show, category))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "edit.html", category: category, changeset: changeset)
+    with {:ok, %Category{} = category} <- Events.update_category(category, category_params) do
+      render(conn, "show.json", category: category)
     end
   end
 
   def delete(conn, %{"id" => id}) do
     category = Events.get_category!(id)
-    {:ok, _category} = Events.delete_category(category)
-
-    conn
-    |> put_flash(:info, "Category deleted successfully.")
-    |> redirect(to: category_path(conn, :index))
+    with {:ok, %Category{}} <- Events.delete_category(category) do
+      send_resp(conn, :no_content, "")
+    end
   end
 end

lib/eventos_web/controllers/event_accounts_controller.ex

@@ -1,60 +0,0 @@
-defmodule EventosWeb.EventAccountsController do
-  use EventosWeb, :controller
-
-  alias Eventos.Events
-  alias Eventos.Events.EventAccounts
-
-  def index(conn, _params) do
-    event_accounts = Events.list_event_accounts()
-    render(conn, "index.html", event_accounts: event_accounts)
-  end
-
-  def new(conn, _params) do
-    changeset = Events.change_event_accounts(%EventAccounts{})
-    render(conn, "new.html", changeset: changeset)
-  end
-
-  def create(conn, %{"event_accounts" => event_accounts_params}) do
-    case Events.create_event_accounts(event_accounts_params) do
-      {:ok, event_accounts} ->
-        conn
-        |> put_flash(:info, "Event accounts created successfully.")
-        |> redirect(to: event_accounts_path(conn, :show, event_accounts))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "new.html", changeset: changeset)
-    end
-  end
-
-  def show(conn, %{"id" => id}) do
-    event_accounts = Events.get_event_accounts!(id)
-    render(conn, "show.html", event_accounts: event_accounts)
-  end
-
-  def edit(conn, %{"id" => id}) do
-    event_accounts = Events.get_event_accounts!(id)
-    changeset = Events.change_event_accounts(event_accounts)
-    render(conn, "edit.html", event_accounts: event_accounts, changeset: changeset)
-  end
-
-  def update(conn, %{"id" => id, "event_accounts" => event_accounts_params}) do
-    event_accounts = Events.get_event_accounts!(id)
-
-    case Events.update_event_accounts(event_accounts, event_accounts_params) do
-      {:ok, event_accounts} ->
-        conn
-        |> put_flash(:info, "Event accounts updated successfully.")
-        |> redirect(to: event_accounts_path(conn, :show, event_accounts))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "edit.html", event_accounts: event_accounts, changeset: changeset)
-    end
-  end
-
-  def delete(conn, %{"id" => id}) do
-    event_accounts = Events.get_event_accounts!(id)
-    {:ok, _event_accounts} = Events.delete_event_accounts(event_accounts)
-
-    conn
-    |> put_flash(:info, "Event accounts deleted successfully.")
-    |> redirect(to: event_accounts_path(conn, :index))
-  end
-end

lib/eventos_web/controllers/event_controller.ex

@@ -4,57 +4,39 @@ defmodule EventosWeb.EventController do
   alias Eventos.Events
   alias Eventos.Events.Event
 
+  action_fallback EventosWeb.FallbackController
+
   def index(conn, _params) do
     events = Events.list_events()
-    render(conn, "index.html", events: events)
-  end
-
-  def new(conn, _params) do
-    changeset = Events.change_event(%Event{})
-    render(conn, "new.html", changeset: changeset)
+    render(conn, "index.json", events: events)
   end
 
   def create(conn, %{"event" => event_params}) do
-    case Events.create_event(event_params) do
-      {:ok, event} ->
-        conn
-        |> put_flash(:info, "Event created successfully.")
-        |> redirect(to: event_path(conn, :show, event))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "new.html", changeset: changeset)
+    with {:ok, %Event{} = event} <- Events.create_event(event_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", event_path(conn, :show, event))
+      |> render("show.json", event: event)
     end
   end
 
   def show(conn, %{"id" => id}) do
     event = Events.get_event!(id)
-    render(conn, "show.html", event: event)
-  end
-
-  def edit(conn, %{"id" => id}) do
-    event = Events.get_event!(id)
-    changeset = Events.change_event(event)
-    render(conn, "edit.html", event: event, changeset: changeset)
+    render(conn, "show.json", event: event)
   end
 
   def update(conn, %{"id" => id, "event" => event_params}) do
     event = Events.get_event!(id)
 
-    case Events.update_event(event, event_params) do
-      {:ok, event} ->
-        conn
-        |> put_flash(:info, "Event updated successfully.")
-        |> redirect(to: event_path(conn, :show, event))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "edit.html", event: event, changeset: changeset)
+    with {:ok, %Event{} = event} <- Events.update_event(event, event_params) do
+      render(conn, "show.json", event: event)
     end
   end
 
   def delete(conn, %{"id" => id}) do
     event = Events.get_event!(id)
-    {:ok, _event} = Events.delete_event(event)
-
-    conn
-    |> put_flash(:info, "Event deleted successfully.")
-    |> redirect(to: event_path(conn, :index))
+    with {:ok, %Event{}} <- Events.delete_event(event) do
+      send_resp(conn, :no_content, "")
+    end
   end
 end

lib/eventos_web/controllers/event_request_controller.ex

@@ -1,60 +0,0 @@
-defmodule EventosWeb.EventRequestController do
-  use EventosWeb, :controller
-
-  alias Eventos.Events
-  alias Eventos.Events.EventRequest
-
-  def index(conn, _params) do
-    event_requests = Events.list_event_requests()
-    render(conn, "index.html", event_requests: event_requests)
-  end
-
-  def new(conn, _params) do
-    changeset = Events.change_event_request(%EventRequest{})
-    render(conn, "new.html", changeset: changeset)
-  end
-
-  def create(conn, %{"event_request" => event_request_params}) do
-    case Events.create_event_request(event_request_params) do
-      {:ok, event_request} ->
-        conn
-        |> put_flash(:info, "Event request created successfully.")
-        |> redirect(to: event_request_path(conn, :show, event_request))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "new.html", changeset: changeset)
-    end
-  end
-
-  def show(conn, %{"id" => id}) do
-    event_request = Events.get_event_request!(id)
-    render(conn, "show.html", event_request: event_request)
-  end
-
-  def edit(conn, %{"id" => id}) do
-    event_request = Events.get_event_request!(id)
-    changeset = Events.change_event_request(event_request)
-    render(conn, "edit.html", event_request: event_request, changeset: changeset)
-  end
-
-  def update(conn, %{"id" => id, "event_request" => event_request_params}) do
-    event_request = Events.get_event_request!(id)
-
-    case Events.update_event_request(event_request, event_request_params) do
-      {:ok, event_request} ->
-        conn
-        |> put_flash(:info, "Event request updated successfully.")
-        |> redirect(to: event_request_path(conn, :show, event_request))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "edit.html", event_request: event_request, changeset: changeset)
-    end
-  end
-
-  def delete(conn, %{"id" => id}) do
-    event_request = Events.get_event_request!(id)
-    {:ok, _event_request} = Events.delete_event_request(event_request)
-
-    conn
-    |> put_flash(:info, "Event request deleted successfully.")
-    |> redirect(to: event_request_path(conn, :index))
-  end
-end

lib/eventos_web/controllers/fallback_controller.ex

@@ -0,0 +1,20 @@
+defmodule EventosWeb.FallbackController do
+  @moduledoc """
+  Translates controller action results into valid `Plug.Conn` responses.
+
+  See `Phoenix.Controller.action_fallback/1` for more details.
+  """
+  use EventosWeb, :controller
+
+  def call(conn, {:error, %Ecto.Changeset{} = changeset}) do
+    conn
+    |> put_status(:unprocessable_entity)
+    |> render(EventosWeb.ChangesetView, "error.json", changeset: changeset)
+  end
+
+  def call(conn, {:error, :not_found}) do
+    conn
+    |> put_status(:not_found)
+    |> render(EventosWeb.ErrorView, :"404")
+  end
+end

lib/eventos_web/controllers/group_account_controller.ex

@@ -1,60 +0,0 @@
-defmodule EventosWeb.GroupAccountController do
-  use EventosWeb, :controller
-
-  alias Eventos.Accounts
-  alias Eventos.Accounts.GroupAccount
-
-  def index(conn, _params) do
-    group_accounts = Accounts.list_group_accounts()
-    render(conn, "index.html", group_accounts: group_accounts)
-  end
-
-  def new(conn, _params) do
-    changeset = Accounts.change_group_account(%GroupAccount{})
-    render(conn, "new.html", changeset: changeset)
-  end
-
-  def create(conn, %{"group_account" => group_account_params}) do
-    case Accounts.create_group_account(group_account_params) do
-      {:ok, group_account} ->
-        conn
-        |> put_flash(:info, "Group account created successfully.")
-        |> redirect(to: group_account_path(conn, :show, group_account))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "new.html", changeset: changeset)
-    end
-  end
-
-  def show(conn, %{"id" => id}) do
-    group_account = Accounts.get_group_account!(id)
-    render(conn, "show.html", group_account: group_account)
-  end
-
-  def edit(conn, %{"id" => id}) do
-    group_account = Accounts.get_group_account!(id)
-    changeset = Accounts.change_group_account(group_account)
-    render(conn, "edit.html", group_account: group_account, changeset: changeset)
-  end
-
-  def update(conn, %{"id" => id, "group_account" => group_account_params}) do
-    group_account = Accounts.get_group_account!(id)
-
-    case Accounts.update_group_account(group_account, group_account_params) do
-      {:ok, group_account} ->
-        conn
-        |> put_flash(:info, "Group account updated successfully.")
-        |> redirect(to: group_account_path(conn, :show, group_account))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "edit.html", group_account: group_account, changeset: changeset)
-    end
-  end
-
-  def delete(conn, %{"id" => id}) do
-    group_account = Accounts.get_group_account!(id)
-    {:ok, _group_account} = Accounts.delete_group_account(group_account)
-
-    conn
-    |> put_flash(:info, "Group account deleted successfully.")
-    |> redirect(to: group_account_path(conn, :index))
-  end
-end

lib/eventos_web/controllers/group_controller.ex

@@ -1,60 +1,42 @@
 defmodule EventosWeb.GroupController do
   use EventosWeb, :controller
 
-  alias Eventos.Accounts
-  alias Eventos.Accounts.Group
+  alias Eventos.Groups
+  alias Eventos.Groups.Group
+
+  action_fallback EventosWeb.FallbackController
 
   def index(conn, _params) do
-    groups = Accounts.list_groups()
-    render(conn, "index.html", groups: groups)
-  end
-
-  def new(conn, _params) do
-    changeset = Accounts.change_group(%Group{})
-    render(conn, "new.html", changeset: changeset)
+    groups = Groups.list_groups()
+    render(conn, "index.json", groups: groups)
   end
 
   def create(conn, %{"group" => group_params}) do
-    case Accounts.create_group(group_params) do
-      {:ok, group} ->
-        conn
-        |> put_flash(:info, "Group created successfully.")
-        |> redirect(to: group_path(conn, :show, group))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "new.html", changeset: changeset)
+    with {:ok, %Group{} = group} <- Groups.create_group(group_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", group_path(conn, :show, group))
+      |> render("show.json", group: group)
     end
   end
 
   def show(conn, %{"id" => id}) do
-    group = Accounts.get_group!(id)
-    render(conn, "show.html", group: group)
-  end
-
-  def edit(conn, %{"id" => id}) do
-    group = Accounts.get_group!(id)
-    changeset = Accounts.change_group(group)
-    render(conn, "edit.html", group: group, changeset: changeset)
+    group = Groups.get_group!(id)
+    render(conn, "show.json", group: group)
   end
 
   def update(conn, %{"id" => id, "group" => group_params}) do
-    group = Accounts.get_group!(id)
+    group = Groups.get_group!(id)
 
-    case Accounts.update_group(group, group_params) do
-      {:ok, group} ->
-        conn
-        |> put_flash(:info, "Group updated successfully.")
-        |> redirect(to: group_path(conn, :show, group))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "edit.html", group: group, changeset: changeset)
+    with {:ok, %Group{} = group} <- Groups.update_group(group, group_params) do
+      render(conn, "show.json", group: group)
     end
   end
 
   def delete(conn, %{"id" => id}) do
-    group = Accounts.get_group!(id)
-    {:ok, _group} = Accounts.delete_group(group)
-
-    conn
-    |> put_flash(:info, "Group deleted successfully.")
-    |> redirect(to: group_path(conn, :index))
+    group = Groups.get_group!(id)
+    with {:ok, %Group{}} <- Groups.delete_group(group) do
+      send_resp(conn, :no_content, "")
+    end
   end
 end

lib/eventos_web/controllers/group_request_controller.ex

@@ -1,60 +0,0 @@
-defmodule EventosWeb.GroupRequestController do
-  use EventosWeb, :controller
-
-  alias Eventos.Accounts
-  alias Eventos.Accounts.GroupRequest
-
-  def index(conn, _params) do
-    group_request = Accounts.list_group_requests()
-    render(conn, "index.html", group_request: group_request)
-  end
-
-  def new(conn, _params) do
-    changeset = Accounts.change_group_request(%GroupRequest{})
-    render(conn, "new.html", changeset: changeset)
-  end
-
-  def create(conn, %{"group_request" => group_request_params}) do
-    case Accounts.create_group_request(group_request_params) do
-      {:ok, group_request} ->
-        conn
-        |> put_flash(:info, "Group request created successfully.")
-        |> redirect(to: group_request_path(conn, :show, group_request))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "new.html", changeset: changeset)
-    end
-  end
-
-  def show(conn, %{"id" => id}) do
-    group_request = Accounts.get_group_request!(id)
-    render(conn, "show.html", group_request: group_request)
-  end
-
-  def edit(conn, %{"id" => id}) do
-    group_request = Accounts.get_group_request!(id)
-    changeset = Accounts.change_group_request(group_request)
-    render(conn, "edit.html", group_request: group_request, changeset: changeset)
-  end
-
-  def update(conn, %{"id" => id, "group_request" => group_request_params}) do
-    group_request = Accounts.get_group_request!(id)
-
-    case Accounts.update_group_request(group_request, group_request_params) do
-      {:ok, group_request} ->
-        conn
-        |> put_flash(:info, "Group request updated successfully.")
-        |> redirect(to: group_request_path(conn, :show, group_request))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "edit.html", group_request: group_request, changeset: changeset)
-    end
-  end
-
-  def delete(conn, %{"id" => id}) do
-    group_request = Accounts.get_group_request!(id)
-    {:ok, _group_request} = Accounts.delete_group_request(group_request)
-
-    conn
-    |> put_flash(:info, "Group request deleted successfully.")
-    |> redirect(to: group_request_path(conn, :index))
-  end
-end

lib/eventos_web/controllers/page_controller.ex

@@ -1,6 +1,7 @@
 defmodule EventosWeb.PageController do
   use EventosWeb, :controller
-  import Logger
+
+  plug :put_layout, false
 
   def index(conn, _params) do
     render conn, "index.html"

lib/eventos_web/controllers/session_controller.ex

@@ -1,30 +1,42 @@
 defmodule EventosWeb.SessionController do
   use EventosWeb, :controller
-  alias Eventos.Accounts.User
-  alias Eventos.Accounts
 
-  def sign_in(conn, %{"email" => email, "password" => password}) do
-    with %User{} = user <- Accounts.find(email) do
-      # Attempt to authenticate the user
-      with {:ok, token, _claims} <- Accounts.authenticate(%{user: user, password: password}) do
-        # Render the token
-        user = Eventos.Repo.preload user, :account
-        render conn, "token.json", %{token: token, user: user}
-      end
-      send_resp(conn, 400, "Bad login")
+  alias Eventos.Events
+  alias Eventos.Events.Session
+
+  action_fallback EventosWeb.FallbackController
+
+  def index(conn, _params) do
+    sessions = Events.list_sessions()
+    render(conn, "index.json", sessions: sessions)
+  end
+
+  def create(conn, %{"session" => session_params}) do
+    with {:ok, %Session{} = session} <- Events.create_session(session_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", session_path(conn, :show, session))
+      |> render("show.json", session: session)
     end
-    send_resp(conn, 400, "No such user")
   end
 
-  def sign_out(conn, _params) do
-    conn
-    |> Eventos.Guardian.Plug.sign_out()
-    |> send_resp(204, "")
+  def show(conn, %{"id" => id}) do
+    session = Events.get_session!(id)
+    render(conn, "show.json", session: session)
   end
 
-  def show(conn, _params) do
-    user = Eventos.Guardian.Plug.current_resource(conn)
+  def update(conn, %{"id" => id, "session" => session_params}) do
+    session = Events.get_session!(id)
 
-    send_resp(conn, 200, Poison.encode!(%{user: user}))
+    with {:ok, %Session{} = session} <- Events.update_session(session, session_params) do
+      render(conn, "show.json", session: session)
+    end
   end
-end
+
+  def delete(conn, %{"id" => id}) do
+    session = Events.get_session!(id)
+    with {:ok, %Session{}} <- Events.delete_session(session) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/eventos_web/controllers/tag_controller.ex

@@ -4,57 +4,39 @@ defmodule EventosWeb.TagController do
   alias Eventos.Events
   alias Eventos.Events.Tag
 
+  action_fallback EventosWeb.FallbackController
+
   def index(conn, _params) do
     tags = Events.list_tags()
-    render(conn, "index.html", tags: tags)
-  end
-
-  def new(conn, _params) do
-    changeset = Events.change_tag(%Tag{})
-    render(conn, "new.html", changeset: changeset)
+    render(conn, "index.json", tags: tags)
   end
 
   def create(conn, %{"tag" => tag_params}) do
-    case Events.create_tag(tag_params) do
-      {:ok, tag} ->
-        conn
-        |> put_flash(:info, "Tag created successfully.")
-        |> redirect(to: tag_path(conn, :show, tag))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "new.html", changeset: changeset)
+    with {:ok, %Tag{} = tag} <- Events.create_tag(tag_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", tag_path(conn, :show, tag))
+      |> render("show.json", tag: tag)
     end
   end
 
   def show(conn, %{"id" => id}) do
     tag = Events.get_tag!(id)
-    render(conn, "show.html", tag: tag)
-  end
-
-  def edit(conn, %{"id" => id}) do
-    tag = Events.get_tag!(id)
-    changeset = Events.change_tag(tag)
-    render(conn, "edit.html", tag: tag, changeset: changeset)
+    render(conn, "show.json", tag: tag)
   end
 
   def update(conn, %{"id" => id, "tag" => tag_params}) do
     tag = Events.get_tag!(id)
 
-    case Events.update_tag(tag, tag_params) do
-      {:ok, tag} ->
-        conn
-        |> put_flash(:info, "Tag updated successfully.")
-        |> redirect(to: tag_path(conn, :show, tag))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "edit.html", tag: tag, changeset: changeset)
+    with {:ok, %Tag{} = tag} <- Events.update_tag(tag, tag_params) do
+      render(conn, "show.json", tag: tag)
     end
   end
 
   def delete(conn, %{"id" => id}) do
     tag = Events.get_tag!(id)
-    {:ok, _tag} = Events.delete_tag(tag)
-
-    conn
-    |> put_flash(:info, "Tag deleted successfully.")
-    |> redirect(to: tag_path(conn, :index))
+    with {:ok, %Tag{}} <- Events.delete_tag(tag) do
+      send_resp(conn, :no_content, "")
+    end
   end
 end

lib/eventos_web/controllers/track_controller.ex

@@ -0,0 +1,42 @@
+defmodule EventosWeb.TrackController do
+  use EventosWeb, :controller
+
+  alias Eventos.Events
+  alias Eventos.Events.Track
+
+  action_fallback EventosWeb.FallbackController
+
+  def index(conn, _params) do
+    tracks = Events.list_tracks()
+    render(conn, "index.json", tracks: tracks)
+  end
+
+  def create(conn, %{"track" => track_params}) do
+    with {:ok, %Track{} = track} <- Events.create_track(track_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", track_path(conn, :show, track))
+      |> render("show.json", track: track)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    track = Events.get_track!(id)
+    render(conn, "show.json", track: track)
+  end
+
+  def update(conn, %{"id" => id, "track" => track_params}) do
+    track = Events.get_track!(id)
+
+    with {:ok, %Track{} = track} <- Events.update_track(track, track_params) do
+      render(conn, "show.json", track: track)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    track = Events.get_track!(id)
+    with {:ok, %Track{}} <- Events.delete_track(track) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/eventos_web/controllers/user_controller.ex

@@ -4,88 +4,66 @@ defmodule EventosWeb.UserController do
 
   alias Eventos.Accounts
   alias Eventos.Accounts.User
+  alias Eventos.Repo
+
+  action_fallback EventosWeb.FallbackController
 
   def index(conn, _params) do
-    users = Accounts.list_users()
-    render(conn, "index.html", users: users)
+    users = Accounts.list_users_with_accounts()
+    render(conn, "index.json", users: users)
   end
 
-  def new(conn, _params) do
-    changeset = Accounts.change_user(%User{})
-    render(conn, "new.html", changeset: changeset)
-  end
-
-  def create(conn, %{"user" => user_params}) do
-    case Accounts.create_user(user_params) do
-      {:ok, user} ->
+  def register(conn, %{"username" => username, "email" => email, "password" => password}) do
+    case Accounts.register(%{email: email, password: password, username: username}) do
+      {:ok, %User{} = user} ->
+        Logger.debug(inspect user)
+        {:ok, token, _claims} = EventosWeb.Guardian.encode_and_sign(user)
         conn
-        |> put_flash(:info, "User created successfully.")
-        |> redirect(to: user_path(conn, :show, user))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "new.html", changeset: changeset)
+        |> put_status(:created)
+        |> render "show_with_token.json", %{token: token, user: user}
+      {:error, error} ->
+        conn
+        |> put_resp_content_type("application/json")
+        |> send_resp(400, Poison.encode!(%{"msg" => handle_changeset_errors(error)}))
     end
   end
 
-  def show(conn, %{"id" => id}) do
-    user = Accounts.get_user!(id)
-    render(conn, "show.html", user: user)
+  def show_current_account(conn, _params) do
+    user = Guardian.Plug.current_resource(conn)
+    |> Repo.preload :account
+    render(conn, "show_simple.json", user: user)
   end
 
-  def edit(conn, %{"id" => id}) do
-    user = Accounts.get_user!(id)
-    changeset = Accounts.change_user(user)
-    render(conn, "edit.html", user: user, changeset: changeset)
+  defp handle_changeset_errors(errors) do
+    Enum.map(errors, fn {field, detail} ->
+      "#{field} " <> render_detail(detail)
+    end)
+    |> Enum.join
+  end
+
+
+  defp render_detail({message, values}) do
+    Enum.reduce values, message, fn {k, v}, acc ->
+      String.replace(acc, "%{#{k}}", to_string(v))
+    end
+  end
+
+  defp render_detail(message) do
+    message
   end
 
   def update(conn, %{"id" => id, "user" => user_params}) do
     user = Accounts.get_user!(id)
 
-    case Accounts.update_user(user, user_params) do
-      {:ok, user} ->
-        conn
-        |> put_flash(:info, "User updated successfully.")
-        |> redirect(to: user_path(conn, :show, user))
-      {:error, %Ecto.Changeset{} = changeset} ->
-        render(conn, "edit.html", user: user, changeset: changeset)
+    with {:ok, %User{} = user} <- Accounts.update_user(user, user_params) do
+      render(conn, "show.json", user: user)
     end
   end
 
   def delete(conn, %{"id" => id}) do
     user = Accounts.get_user!(id)
-    {:ok, _user} = Accounts.delete_user(user)
-
-    conn
-    |> put_flash(:info, "User deleted successfully.")
-    |> redirect(to: user_path(conn, :index))
-  end
-
-  def register(conn, %{"email" => email, "password" => password, "username" => username}) do
-
-    {:ok, {privkey, pubkey}} = RsaEx.generate_keypair("4096")
-    account_change = Ecto.Changeset.change(%Eventos.Accounts.Account{}, %{
-      username: username,
-      description: "tata",
-      display_name: "toto",
-      domain: nil,
-      private_key: privkey,
-      public_key: pubkey,
-      uri: "",
-      url: ""
-    })
-
-    user_change = Eventos.Accounts.User.registration_changeset(%Eventos.Accounts.User{}, %{
-      email: email,
-      password: password,
-      password_confirmation: password
-    })
-
-    account_with_user = Ecto.Changeset.put_assoc(account_change, :user, user_change)
-
-    Eventos.Repo.insert!(account_with_user)
-
-    user = Eventos.Accounts.find(email)
-    user = Eventos.Repo.preload user, :account
-
-    render conn, "user.json", %{user: user}
+    with {:ok, %User{}} <- Accounts.delete_user(user) do
+      send_resp(conn, :no_content, "")
+    end
   end
 end

lib/eventos_web/controllers/user_session_controller.ex

@@ -0,0 +1,28 @@
+defmodule EventosWeb.UserSessionController do
+  use EventosWeb, :controller
+  alias Eventos.Accounts.User
+  alias Eventos.Accounts
+  import Logger
+
+  def sign_in(conn, %{"email" => email, "password" => password}) do
+    case Accounts.find_by_email(email) do
+      %User{} = user ->
+        # Attempt to authenticate the user
+        case Accounts.authenticate(%{user: user, password: password}) do
+          {:ok, token, _claims} ->
+            # Render the token
+            render conn, "token.json", %{token: token, user: user}
+          _ ->
+            send_resp(conn, 400, Poison.encode!(%{"error_msg" => "Bad login", "display_error" => "session.error.bad_login", "error_code" => 400}))
+        end
+      _ ->
+        send_resp(conn, 400, Poison.encode!(%{"error_msg" => "No such user", "display_error" => "session.error.bad_login", "error_code" => 400}))
+    end
+  end
+
+  def sign_out(conn, _params) do
+    conn
+    |> Guardian.Plug.sign_out()
+    |> send_resp(204, "")
+  end
+end