field :organization_role, :any, virtual: true

  @doc """

  Deliver a notification informing a user they have been added to an organization.

  """

  def deliver_joined_organization_notification(user, organization, url) do

    deliver(user.email, "You are now a member of #{organization.name}", """

    ==============================

    Hi #{user.email},

    You have been added to #{organization.name}'s organization.

    View the organization home page by visiting the URL below:

    #{url}

    ==============================

    """)

  end

defmodule MyApp.Organizations do

  alias MyApp.Repo

  alias MyApp.Accounts.User

  alias MyApp.Accounts.UserNotifier

  alias MyApp.Organizations.Organization

  alias MyApp.Organizations.OrganizationUser

  ## Organizations

  def get_organization(slug, user) do

    Organization

    |> OrganizationUser.organization_with_user_query(user)

    |> Repo.get_by(slug: slug)

  end

  def get_organization!(slug, user) do

    Organization

    |> OrganizationUser.organization_with_user_query(user)

    |> Repo.get_by!(slug: slug)

  end

  def list_organizations(user) do

    Organization

    |> OrganizationUser.organization_with_user_query(user)

    |> Repo.all()

  end

  def create_organization(user, attrs) do

    Ecto.Multi.new()

    |> Organization.create_multi(attrs)

    |> OrganizationUser.create_multi(user, role: :owner)

    |> Repo.transaction()

    |> case do

      {:ok, %{organization: organization}} ->

        {:ok, organization}

      {:error, :organization, %Ecto.Changeset{} = changeset, _multi} ->

        {:error, changeset}

    end

  end

  def update_organization(organization, attrs) do

    organization

    |> Organization.changeset(attrs)

    |> Repo.update()

  end

  ## Members

  def get_user(user_id, organization) do

    User

    |> OrganizationUser.user_with_organization_query(organization)

    |> Repo.get(user_id)

  end

  def get_user!(user_id, organization) do

    User

    |> OrganizationUser.user_with_organization_query(organization)

    |> Repo.get!(user_id)

  end

  def list_users(organization) do

    User

    |> OrganizationUser.user_with_organization_query(organization)

    |> Repo.all()

  end

  def add_user(organization, user, attrs, opts \\ []) do

    run_deliver_email = fn _repo, _multi ->

      if url = opts[:organization_url] do

        UserNotifier.deliver_joined_organization_notification(user, organization, url)

      else

        {:ok, nil}

      end

    end

    Ecto.Multi.new()

    |> Ecto.Multi.put(:organization, organization)

    |> OrganizationUser.create_multi(user, attrs)

    |> Ecto.Multi.run(:deliver_email, run_deliver_email)

    |> Repo.transaction()

  end

  def update_user_role(organization_user, attrs) do

    organization_user = Repo.preload(organization_user, :organization)

    Ecto.Multi.new()

    |> Ecto.Multi.put(:organization, organization_user.organization)

    |> OrganizationUser.update_multi(organization_user, attrs)

    |> Repo.transaction()

    |> case do

      {:ok, %{organization_user: organization_user}} ->

        {:ok, organization_user}

      {:error, :organization_user, %Ecto.Changeset{} = changeset, _multi} ->

        {:error, changeset}

      {:error, :check_role, reason, _multi} ->

        {:error, reason}

    end

  end

  def remove_user(organization, user) do

    OrganizationUser

    |> OrganizationUser.query(organization, user)

    |> OrganizationUser.role_query(not_in: [:owner])

    |> Repo.delete_all()

  end

end

defmodule MyApp.Organizations.Organization do

  use Ecto.Schema

  import Ecto.Changeset

  # Matches a valid slug, made up of sequences of lowercase letters and

  # numbers separated by dashes.

  @slug_format ~r/^[a-z0-9]+(\-[a-z0-9]+)*$/

  @primary_key {:id, :binary_id, autogenerate: true}

  @foreign_key_type :binary_id

  schema "organizations" do

    field :name, :string

    field :slug, :string

    field :user_role, :any, virtual: true

    timestamps()

  end

  ## Changesets

  def changeset(organization, attrs, opts \\ []) do

    organization

    |> cast(attrs, [:name, :slug])

    |> cast_default_slug(opts)

    |> validate_required([:name, :slug])

    |> validate_format(:slug, @slug_format,

      message: ~S(must use lowercase letters and numbers separated by dashes: "my-org")

    )

    |> unsafe_validate_unique(:slug, MyApp.Repo)

    |> unique_constraint(:slug)

  end

  def cast_default_slug(changeset, opts) do

    case {opts[:cast_default_slug], fetch_field(changeset, :name)} do

      {true, {:changes, name}} -> put_change(changeset, :slug, name_to_slug(name))

      _otherwise -> changeset

    end

  end

  def name_to_slug(name) do

    name

    |> String.downcase()

    |> String.replace(~r/[^a-z0-9]/, "-")

    |> String.trim("-")

  end

  ## Multis

  def create_multi(multi, attrs) do

    Ecto.Multi.insert(multi, :organization, changeset(%__MODULE__{}, attrs))

  end

  defimpl Phoenix.Param do

    def to_param(organization), do: organization.slug

  end

end

defmodule MyApp.Organizations.OrganizationUser do

  use Ecto.Schema

  import Ecto.Changeset

  import Ecto.Query

  @role_values [:owner, :member]

  @primary_key false

  @foreign_key_type :binary_id

  schema "organizations_users" do

    field :role, Ecto.Enum, values: @role_values

    belongs_to :organization, MyApp.Organizations.Organization, primary_key: true

    belongs_to :user, MyApp.Accounts.User, primary_key: true

    timestamps()

  end

  ## Changesets

  def role_changeset(organization_user, attrs) do

    organization_user

    |> cast(attrs, [:role])

    |> validate_required([:role])

  end

  ## Queries

  def query(query, organization, user) do

    from org_user in query,

      as: :organization_user,

      where: [organization_id: ^organization.id, user_id: ^user.id]

  end

  def organization_query(query, organization) do

    from org_user in query,

      as: :organization_user,

      where: [organization_id: ^organization.id]

  end

  def user_with_organization_query(query, organization) do

    from user in query,

      join: org_user in __MODULE__,

      on: [organization_id: ^organization.id, user_id: user.id],

      as: :organization_user,

      select_merge: %{organization_role: org_user.role}

  end

  def organization_with_user_query(query, user) do

    from org in query,

      join: org_user in __MODULE__,

      on: [organization_id: org.id, user_id: ^user.id],

      as: :organization_user,

      select_merge: %{user_role: org_user.role}

  end

  def role_query(query, opts) do

    case opts do

      role when is_atom(role) ->

        where(query, [organization_user: org_user], org_user.role == ^role)

      [{:in, roles}] ->

        where(query, [organization_user: org_user], org_user.role in ^roles)

      [{:not_in, roles}] ->

        where(query, [organization_user: org_user], org_user.role not in ^roles)

    end

  end

  ## Multis

  def create_multi(multi, user, attrs) do

    Ecto.Multi.insert(multi, :organization_user, fn %{organization: organization} ->

      %__MODULE__{}

      |> Map.merge(%{organization: organization, user: user})

      |> role_changeset(Map.new(attrs))

      |> unique_constraint(:user_id, name: :organizations_users_pkey)

      |> unsafe_validate_unique(:user_id, MyApp.Repo, name: :organizations_users_pkey)

    end)

  end

  def update_multi(multi, organization_user, attrs) do

    multi

    |> Ecto.Multi.update(:organization_user, role_changeset(organization_user, attrs))

    |> Ecto.Multi.run(:check_role, fn repo, %{organization: organization} ->

      query =

        __MODULE__

        |> organization_query(organization)

        |> role_query(:owner)

      if repo.exists?(query) do

        {:ok, nil}

      else

        {:error, :organization_must_have_owner}

      end

    end)

  end

  ## View

  def role_name(:owner), do: "Owner"

  def role_name(:member), do: "Member"

  def role_options() do

    Enum.map(@role_values, &{role_name(&1), &1})

  end

end

defmodule MyAppWeb.OrganizationLive.AddMemberComponent do

  use MyAppWeb, :live_component

  alias MyApp.Accounts

  alias MyApp.Organizations

  def render(assigns) do

    ~H"""

    <div>

      <.header>

        Add member

      </.header>

      <.simple_form

        class="mt-6"

        for={@form}

        phx-change="validate"

        phx-submit="save"

        phx-target={@myself}

      >

        <.input

          field={@form[:email]}

          type="email"

          label="Email"

          autocomplete="off"

          placeholder="Enter an email..."

        />

        <.input

          field={@form[:role]}

          type="select"

          label="Role"

          options={Organizations.OrganizationUser.role_options()}

        />

        <:actions>

          <.button type="submit">

            Invite

          </.button>

        </:actions>

      </.simple_form>

    </div>

    """

  end

  def mount(socket) do

    changeset = changeset(%{})

    {:ok, assign(socket, :form, to_form(changeset, as: :form))}

  end

  def handle_event("validate", %{"form" => params}, socket) do

    changeset = Map.put(changeset(params), :action, :validate)

    {:noreply, assign(socket, :form, to_form(changeset, as: :form))}

  end

  def handle_event("save", %{"form" => params}, socket) do

    organization = socket.assigns.organization

    opts = [organization_url: url(~p"/#{organization}")]

    with {:ok, data} <- Ecto.Changeset.apply_action(changeset(params), :validate),

         %Accounts.User{} = user <- Accounts.get_user_by_email(data.email),

         {:ok, _org_user} <- Organizations.add_user(organization, user, params, opts) do

      {:noreply,

       socket

       |> put_flash(:info, "User #{user.email} added to organization.")

       |> push_navigate(to: ~p"/#{organization}/members")}

    else

      {:error, %Ecto.Changeset{} = changeset} ->

        {:noreply, assign(socket, :form, to_form(changeset, as: :form))}

      nil ->

        changeset = changeset_with_error(params, "no user with this email was found")

        {:noreply, assign(socket, :form, to_form(changeset, as: :form))}

      {:error, :organization_user, %Ecto.Changeset{errors: [user_id: _details]}, _multi} ->

        changeset = changeset_with_error(params, "already a member of this organization")

        {:noreply, assign(socket, :form, to_form(changeset, as: :form))}

      {:error, _reason} ->

        {:noreply,

         socket

         |> put_flash(:error, "Failed to add user to organization.")

         |> push_patch(to: ~p"/#{organization}/members")}

    end

  end

  def changeset(params) do

    {%{}, %{email: :string}}

    |> Ecto.Changeset.cast(params, [:email])

    |> Ecto.Changeset.validate_required([:email])

  end

  def changeset_with_error(params, message) do

    params

    |> changeset()

    |> Ecto.Changeset.add_error(:email, message)

    |> Map.put(:action, :validate)

  end

end

defmodule MyAppWeb.OrganizationLive.EditMemberComponent do

  use MyAppWeb, :live_component

  alias MyApp.Organizations

  def render(assigns) do

    ~H"""

    <div>

      <.header>

        Edit member

      </.header>

      <.simple_form for={@form} phx-change="validate" phx-submit="save" phx-target={@myself}>

        <.input

          field={@form[:role]}

          type="select"

          label="Role"

          options={Organizations.OrganizationUser.role_options()}

        />

        <:actions>

          <.button type="submit">

            Save

          </.button>

        </:actions>

      </.simple_form>

    </div>

    """

  end

  def update(assigns, socket) do

    socket = assign(socket, assigns)

    changeset =

      Organizations.OrganizationUser.role_changeset(socket.assigns.organization_user, %{})

    {:ok, assign(socket, :form, to_form(changeset))}

  end

  def handle_event("validate", %{"organization_user" => params}, socket) do

    changeset =

      socket.assigns.organization_user

      |> Organizations.OrganizationUser.role_changeset(params)

      |> Map.put(:action, :validate)

    {:noreply, assign(socket, :form, to_form(changeset))}

  end

  def handle_event("save", %{"organization_user" => params}, socket) do

    case Organizations.update_user_role(socket.assigns.organization_user, params) do

      {:ok, _organization_user} ->

        {:noreply,

         socket

         |> put_flash(:info, "Updated member role.")

         |> push_patch(to: ~p"/#{socket.assigns.organization}/members")}

      {:error, %Ecto.Changeset{} = changeset} ->

        {:noreply, assign(socket, :form, to_form(changeset))}

      {:error, :organization_must_have_owner} ->

        {:noreply,

         socket

         |> put_flash(:error, "Organization must have an owner at all times.")

         |> push_patch(to: ~p"/#{socket.assigns.organization}/members")}

    end

  end

end

defmodule MyAppWeb.OrganizationLive.FormComponent do

  use MyAppWeb, :live_component

  alias MyApp.Organizations

  def render(assigns) do

    ~H"""

    <div>

      <.header>

        <%= @title %>

      </.header>

      <.simple_form for={@form} phx-change="validate" phx-submit="save" phx-target={@myself}>

        <.input field={@form[:name]} label="Name" />

        <.input field={@form[:slug]} label="Slug" />

        <:actions>

          <.button>Save</.button>

        </:actions>

      </.simple_form>

    </div>

    """

  end

  def update(assigns, socket) do

    {:ok,

     socket

     |> assign(assigns)

     |> put_form(Organizations.Organization.changeset(assigns.organization, %{}))}

  end

  def handle_event("validate", %{"organization" => params, "_target" => target}, socket) do

    cast_default_slug = socket.assigns.action == :new and "name" in target

    changeset =

      socket.assigns.organization

      |> Organizations.Organization.changeset(params, cast_default_slug: cast_default_slug)

      |> Map.put(:action, :validate)

    {:noreply, put_form(socket, changeset)}

  end

  def handle_event("save", %{"organization" => params}, socket) do

    save_organization(socket, params, socket.assigns.action)

  end

  def save_organization(socket, params, :new) do

    case Organizations.create_organization(socket.assigns.current_user, params) do

      {:ok, organization} ->

        send(self(), {__MODULE__, :create, organization})

        {:noreply, socket}

      {:error, %Ecto.Changeset{} = changeset} ->

        {:noreply, put_form(socket, changeset)}

    end

  end

  def save_organization(socket, params, :edit) do

    case Organizations.update_organization(socket.assigns.organization, params) do

      {:ok, organization} ->

        send(self(), {__MODULE__, :update, organization})

        {:noreply, socket}

      {:error, %Ecto.Changeset{} = changeset} ->

        {:noreply, put_form(socket, changeset)}

    end

  end

  def put_form(socket, changeset) do

    assign(socket, :form, to_form(changeset))

  end

end

defmodule MyAppWeb.OrganizationLive.Index do

  use MyAppWeb, :live_view

  alias MyApp.Organizations

  alias MyAppWeb.OrganizationLive.FormComponent

  def render(assigns) do

    ~H"""

    <.header>

      Organizations

      <:actions>

        <.button phx-click={JS.patch(~p"/organizations/new")}>

          Create organization

        </.button>

      </:actions>

    </.header>

    <.table

      id="organizations_table"

      rows={@streams.organizations}

      row_click={fn {_id, org} -> JS.navigate(~p"/#{org}") end}

    >

      <:col :let={{_id, org}} label="Slug">

        <%= org.slug %>

      </:col>

      <:col :let={{_id, org}} label="Name">

        <%= org.name %>

      </:col>

      <:action :let={{_id, org}}>

        <.link navigate={~p"/#{org}/members"}>

          Manage members

        </.link>

      </:action>

      <:action :let={{_id, org}}>

        <.link navigate={~p"/#{org}/settings"}>

          Settings

        </.link>

      </:action>

    </.table>

    <.modal

      :if={@live_action in [:new, :edit]}

      id="organization_form_modal"

      show

      on_cancel={JS.patch(~p"/organizations")}

    >

      <.live_component

        id="organization_form"

        module={FormComponent}

        title={@page_title}

        action={@live_action}

        organization={@organization}

        current_user={@current_user}

      />

    </.modal>

    """

  end

  def mount(_params, _session, socket) do

    {:ok, stream_configure(socket, :organizations, [])}

  end

  def handle_params(params, _uri, socket) do

    {:noreply,

     socket

     |> stream(:organizations, Organizations.list_organizations(socket.assigns.current_user))

     |> assign(:organization, nil)

     |> apply_action(params, socket.assigns.live_action)}

  end

  def apply_action(socket, _params, :index) do

    socket

  end

  def apply_action(socket, _params, :new) do

    socket

    |> assign(:page_title, "New organization")

    |> assign(:organization, %Organizations.Organization{})

  end

  def apply_action(socket, %{"slug" => slug}, :edit) do

    user = socket.assigns.current_user

    socket

    |> assign(:page_title, "Edit organization")

    |> assign(:organization, Organizations.get_organization!(slug, user))

  end

  def handle_event("", _params, socket) do

    {:noreply, socket}

  end

  def handle_info({FormComponent, :create, _organization}, socket) do

    {:noreply, push_navigate(socket, to: ~p"/organizations")}

  end

end

defmodule MyAppWeb.OrganizationLive.Members do

  use MyAppWeb, :live_view

  alias MyApp.Repo

  alias MyApp.Organizations

  alias MyAppWeb.OrganizationLive.AddMemberComponent

  alias MyAppWeb.OrganizationLive.EditMemberComponent

  def render(assigns) do

    ~H"""

    <.header>

      <%= @organization.name %> members

      <:subtitle>

        Manage your organization members here. <.link

          navigate={~p"/#{@organization}/settings"}

          class="underline"

        >Manage settings</.link>.

      </:subtitle>

      <:actions>

        <.button phx-click={JS.patch(~p"/#{@organization}/members/add")}>

          Add member

        </.button>

      </:actions>

    </.header>

    <div class="mt-10">

      <.header>

        Members

      </.header>

      <.table

        id="organization_users_table"

        rows={@streams.users}

        row_click={

          if @organization.user_role == :owner do

            fn {_id, user} -> JS.patch(~p"/#{@organization}/members/#{user}/edit") end

          end

        }

      >

        <:col :let={{_id, user}} label="Email">

          <%= user.email %>

        </:col>

        <:col :let={{_id, user}} label="Role">

          <%= Organizations.OrganizationUser.role_name(user.organization_role) %>

        </:col>

        <:action :let={{_id, user}} :if={@organization.user_role == :owner}>

          <.link patch={~p"/#{@organization}/members/#{user}/edit"}>

            Edit

          </.link>

        </:action>

        <:action :let={{id, user}} :if={@organization.user_role == :owner}>

          <.link

            phx-click={JS.hide(to: id) |> JS.push("remove", value: %{id: user.id})}

            data-confirm={"Are you sure you want to remove #{user.email} from your organization?"}

          >

            Remove

          </.link>

        </:action>

      </.table>

    </div>

    <.modal

      :if={@live_action == :add}

      id="add_member_modal"

      show

      on_cancel={JS.patch(~p"/#{@organization}/members")}

    >

      <.live_component

        id="add_member_form"

        module={AddMemberComponent}

        organization={@organization}

        current_user={@current_user}

      />

    </.modal>

    <.modal

      :if={@live_action == :edit}

      id="edit_member_modal"

      show

      on_cancel={JS.patch(~p"/#{@organization}/members")}

    >

      <.live_component

        id="edit_member_form"

        module={EditMemberComponent}

        organization={@organization}

        organization_user={@organization_user}

      />

    </.modal>

    """

  end

  def mount(_params, _session, socket) do

    {:ok, stream_configure(socket, :users, [])}

  end

  def handle_params(params, _uri, socket) do

    users = Organizations.list_users(socket.assigns.organization)

    {:noreply,

     socket

     |> stream(:users, users, reset: true)

     |> apply_action(params, socket.assigns.live_action)}

  end

  def apply_action(socket, _params, :index) do

    assign(socket, :page_title, "Members")

  end

  def apply_action(socket, _params, :add) do

    assign(socket, :page_title, "Add member")

  end

  def apply_action(socket, %{"id" => user_id}, :edit) do

    organization = socket.assigns.organization

    if organization.user_role == :owner do

      organization_user =

        Repo.get_by!(Organizations.OrganizationUser,

          organization_id: organization.id,

          user_id: user_id

        )

      socket

      |> assign(:page_title, "Edit member")

      |> assign(:organization_user, organization_user)

    else

      socket

      |> put_flash(:error, "You must be an organization owner to edit this member.")

      |> push_patch(to: ~p"/#{organization}/members")

    end

  end

  def handle_event("remove", %{"id" => user_id}, socket) do

    organization = socket.assigns.organization

    user = Organizations.get_user!(user_id, organization)

    case Organizations.remove_user(organization, user) do

      {0, _} ->

        {:noreply, put_flash(socket, :error, "Organization owners may not be removed.")}

      {1, _} ->

        {:noreply, stream_delete(socket, :users, user)}

    end

  end

end

defmodule MyAppWeb.OrganizationLive.Settings do

  use MyAppWeb, :live_view

  alias MyAppWeb.OrganizationLive.FormComponent

  def render(assigns) do

    ~H"""

    <.header>

      <%= @organization.name %> settings

      <:subtitle>

        Manage your organization settings here. <.link

          navigate={~p"/#{@organization}/members"}

          class="underline"

        >Manage members</.link>.

      </:subtitle>

    </.header>

    <div class="mt-10">

      <.live_component

        id="organization_form"

        module={FormComponent}

        title="Details"

        action={:edit}

        organization={@organization}

        current_user={@current_user}

      />

    </div>

    """

  end

  def handle_info({FormComponent, :update, organization}, socket) do

    {:noreply, push_navigate(socket, to: ~p"/#{organization}/settings")}

  end

end

defmodule MyAppWeb.OrganizationLive.Show do

  use MyAppWeb, :live_view

  def render(assigns) do

    ~H"""

    <.header>

      <%= @organization.name %>

      <:subtitle>

        Build your organization home page here.

      </:subtitle>

    </.header>

    """

  end

end

      live "/organizations", OrganizationLive.Index, :index

      live "/organizations/new", OrganizationLive.Index, :new

      live "/organizations/:slug/edit", OrganizationLive.Index, :edit

  ## Within Organization

  scope "/:slug", MyAppWeb do

    pipe_through [:browser, :require_authenticated_user, :require_organization_access]

    live_session :require_authenticated_user_in_org,

      on_mount: [

        {MyAppWeb.UserAuth, :ensure_authenticated},

        {MyAppWeb.UserAuth, :ensure_organization_access}

      ] do

      live "/", OrganizationLive.Show

      live "/members", OrganizationLive.Members, :index

      live "/members/add", OrganizationLive.Members, :add

      live "/members/:id/edit", OrganizationLive.Members, :edit

      live "/settings", OrganizationLive.Settings

    end

  end

  alias MyApp.Organizations

  def on_mount(:ensure_organization_access, params, _session, socket) do

    organization =

      Organizations.get_organization(

        params["slug"],

        socket.assigns.current_user

      )

    if organization do

      {:cont, Phoenix.Component.assign(socket, :organization, organization)}

    else

      socket =

        socket

        |> Phoenix.LiveView.put_flash(

          :error,

          "Organization does not exist or you do not have access."

        )

        |> Phoenix.LiveView.redirect(to: ~p"/users/log_in")

      {:halt, socket}

    end

  end

  @doc """

  """

  def require_organization_access(conn, _opts) do

    organization =

      Organizations.get_organization(

        conn.path_params["slug"],

        conn.assigns.current_user

      )

    if organization do

      assign(conn, :organization, organization)

    else

      conn

      |> put_flash(:error, "Organization does not exist or you do not have access.")

      |> maybe_store_return_to()

      |> redirect(to: ~p"/users/log_in")

      |> halt()

    end

  end

defmodule MyApp.Repo.Migrations.AddOrganizations do

  use Ecto.Migration

  def change do

    create table(:organizations, primary_key: false) do

      add :id, :binary_id, primary_key: true

      add :name, :string, null: false

      add :slug, :citext, null: false

      timestamps()

    end

    create unique_index(:organizations, [:slug])

    create table(:organizations_users, primary_key: false) do

      add :role, :string, null: false

      add :organization_id, references(:organizations, type: :binary_id, on_delete: :delete_all),

        primary_key: true

      add :user_id, references(:users, type: :binary_id, on_delete: :delete_all),

        primary_key: true

      timestamps()

    end

    create index(:organizations_users, [:organization_id])

    create index(:organizations_users, [:user_id])

  end

end