initial commit

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

lib/eventos_web/controllers/account_controller.ex

@@ -0,0 +1,60 @@
+defmodule EventosWeb.AccountController do
+  use EventosWeb, :controller
+
+  alias Eventos.Accounts
+  alias Eventos.Accounts.Account
+
+  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
+  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)
+  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)
+    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))
+  end
+end

lib/eventos_web/controllers/category_controller.ex

@@ -0,0 +1,60 @@
+defmodule EventosWeb.CategoryController do
+  use EventosWeb, :controller
+
+  alias Eventos.Events
+  alias Eventos.Events.Category
+
+  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)
+  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)
+    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)
+  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)
+    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))
+  end
+end

lib/eventos_web/controllers/coherence/redirects.ex

@@ -0,0 +1,54 @@
+defmodule Coherence.Redirects do
+  @moduledoc """
+  Define controller action redirection functions.
+
+  This module contains default redirect functions for each of the controller
+  actions that perform redirects. By using this Module you get the following
+  functions:
+
+  * session_create/2
+  * session_delete/2
+  * password_create/2
+  * password_update/2,
+  * unlock_create_not_locked/2
+  * unlock_create_invalid/2
+  * unlock_create/2
+  * unlock_edit_not_locked/2
+  * unlock_edit/2
+  * unlock_edit_invalid/2
+  * registration_create/2
+  * invitation_create/2
+  * confirmation_create/2
+  * confirmation_edit_invalid/2
+  * confirmation_edit_expired/2
+  * confirmation_edit/2
+  * confirmation_edit_error/2
+
+  You can override any of the functions to customize the redirect path. Each
+  function is passed the `conn` and `params` arguments from the controller.
+
+  ## Examples
+
+      import EventosWeb.Router.Helpers
+
+      # override the log out action back to the log in page
+      def session_delete(conn, _), do: redirect(conn, to: session_path(conn, :new))
+
+      # redirect the user to the login page after registering
+      def registration_create(conn, _), do: redirect(conn, to: session_path(conn, :new))
+
+      # disable the user_return_to feature on login
+      def session_create(conn, _), do: redirect(conn, to: landing_path(conn, :index))
+
+  """
+  use Redirects
+  # Uncomment the import below if adding overrides
+  # import EventosWeb.Router.Helpers
+
+  # Add function overrides below
+
+  # Example usage
+  # Uncomment the following line to return the user to the login form after logging out
+  # def session_delete(conn, _), do: redirect(conn, to: session_path(conn, :new))
+
+end

lib/eventos_web/controllers/event_accounts_controller.ex

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,60 @@
+defmodule EventosWeb.EventController do
+  use EventosWeb, :controller
+
+  alias Eventos.Events
+  alias Eventos.Events.Event
+
+  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)
+  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)
+    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)
+  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)
+    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))
+  end
+end

lib/eventos_web/controllers/event_request_controller.ex

@@ -0,0 +1,60 @@
+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/group_account_controller.ex

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,60 @@
+defmodule EventosWeb.GroupController do
+  use EventosWeb, :controller
+
+  alias Eventos.Accounts
+  alias Eventos.Accounts.Group
+
+  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)
+  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)
+    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)
+  end
+
+  def update(conn, %{"id" => id, "group" => group_params}) do
+    group = Accounts.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)
+    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))
+  end
+end

lib/eventos_web/controllers/group_request_controller.ex

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,7 @@
+defmodule EventosWeb.PageController do
+  use EventosWeb, :controller
+
+  def index(conn, _params) do
+    render conn, "index.html"
+  end
+end

lib/eventos_web/controllers/tag_controller.ex

@@ -0,0 +1,60 @@
+defmodule EventosWeb.TagController do
+  use EventosWeb, :controller
+
+  alias Eventos.Events
+  alias Eventos.Events.Tag
+
+  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)
+  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)
+    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)
+  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)
+    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))
+  end
+end

lib/eventos_web/controllers/user_controller.ex

@@ -0,0 +1,60 @@
+defmodule EventosWeb.UserController do
+  use EventosWeb, :controller
+
+  alias Eventos.Accounts
+  alias Eventos.Accounts.User
+
+  def index(conn, _params) do
+    users = Accounts.list_users()
+    render(conn, "index.html", 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} ->
+        conn
+        |> put_flash(:info, "User created successfully.")
+        |> redirect(to: user_path(conn, :show, user))
+      {:error, %Ecto.Changeset{} = changeset} ->
+        render(conn, "new.html", changeset: changeset)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    user = Accounts.get_user!(id)
+    render(conn, "show.html", 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)
+  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)
+    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
+end