window.addEventListener("my_app:open", (event) => {

  window.open(event.detail.path, "_blank")

})

    |> Object.insert_assocs_multi(opts, [:directory, :uploaded_by_user])

defmodule MyApp.Storage.Drive do

  import Ecto.Query

  alias MyApp.Repo

  alias MyApp.Storage

  alias MyApp.Storage.Drive.Directory

  alias MyApp.Storage.Drive.DirectoryUser

  alias MyApp.Storage.Drive.ObjectDirectory

  alias MyApp.Storage.Object

  @doc """

  Gets a directory if it or any parent is associated with a user.

  """

  def get_directory!(id, user) do

    Directory

    |> DirectoryUser.belongs_to_user_query(user)

    |> preload(:parent)

    |> Repo.get!(id)

  end

  @doc """

  Lists root directories associated with a user that are not deleted.

  """

  def list_root_directories(user) do

    Directory

    |> Directory.present_query()

    |> Directory.root_directory_query()

    |> DirectoryUser.belongs_to_user_directly_query(user)

    |> order_by(asc: :name)

    |> Repo.all()

  end

  @doc """

  Lists directories within a parent directory that are not deleted.

  """

  def list_directories(parent) do

    Directory

    |> Directory.present_query()

    |> Directory.parent_directory_query(parent)

    |> order_by(asc: :name)

    |> Repo.all()

  end

  @doc """

  Lists all parents of a directory in order, used for UI breadcrumbs.

  """

  def list_breadcrumbs(directory) do

    Directory

    |> Directory.recursive_directory_tree_query(

      :bottom_up,

      &Directory.directory_query(&1, directory)

    )

    |> order_by([directory_tree: dt], desc: dt.level)

    |> Repo.all()

  end

  @doc """

  Gets an object in a directory.

  """

  def get_object_in_directory!(object_id, directory) do

    Object

    |> Object.present_query()

    |> ObjectDirectory.object_in_directory_query(directory)

    |> Repo.get(object_id)

  end

  @doc """

  Lists objects in a directory that are not deleted.

  """

  def list_objects_in_directory(directory) do

    Object

    |> Object.present_query()

    |> ObjectDirectory.object_in_directory_query(directory)

    |> order_by(asc: :filename)

    |> Repo.all()

  end

  @doc """

  Creates a root directory associated with a user (does not have a parent).

  """

  def create_root_directory(user, attrs) do

    Ecto.Multi.new()

    |> Directory.create_multi(attrs)

    |> DirectoryUser.assoc_user_multi(user)

    |> Repo.transaction()

  end

  @doc """

  Creates a directory within another directory (its parent).

  """

  def create_directory(parent, attrs) do

    %Directory{parent: parent}

    |> Directory.changeset(attrs)

    |> Repo.insert()

  end

  @doc """

  Updates a directory.

  """

  def update_directory(directory, attrs) do

    directory

    |> Directory.changeset(attrs)

    |> Repo.update()

  end

  @doc """

  Sets the deleted_at field on a directory.

  """

  def mark_directory_as_deleted!(directory) do

    directory

    |> Directory.delete_changeset()

    |> Repo.update!()

  end

  @doc """

  Permanently deletes directories that were marked as deleted before some

  time given duration opts.

  """

  def delete_marked_directories_permanently(opts \\ []) do

    marked_directories =

      Directory

      |> Directory.deleted_query(opts)

      |> Repo.all()

    Enum.each(marked_directories, &delete_directory_permanently/1)

  end

  @doc """

  Permanently deletes a directory.

  """

  def delete_directory_permanently(directory) do

    child_objects =

      Object

      |> ObjectDirectory.object_in_directory_query(directory)

      |> Repo.all()

    child_directories =

      Directory

      |> Directory.parent_directory_query(directory)

      |> Repo.all()

    Enum.each(child_objects, &Storage.delete_permanently/1)

    Enum.each(child_directories, &delete_directory_permanently/1)

    Repo.delete!(directory)

  end

  @doc """

  Moves an object from one directory to another atomically, such that an

  object can never belong to two directories at once.

  """

  def move_object_to_directory(object, directory) do

    Ecto.Multi.new()

    |> ObjectDirectory.delete_from_directory_multi(object)

    |> ObjectDirectory.add_to_directory_multi(object, directory)

    |> Repo.transaction()

  end

end

defmodule MyApp.Storage.Drive.Directory do

  use Ecto.Schema

  import Ecto.Changeset

  import Ecto.Query

  alias MyApp.Storage

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

  @foreign_key_type :binary_id

  schema "storage_directories" do

    field :name, :string

    field :deleted_at, :utc_datetime

    belongs_to :parent, Storage.Drive.Directory

    timestamps()

  end

  ## Changesets

  def changeset(directory, attrs) do

    directory

    |> cast(attrs, [:name])

    |> validate_required([:name])

  end

  def delete_changeset(directory) do

    change(directory, deleted_at: DateTime.truncate(DateTime.utc_now(), :second))

  end

  ## Queries

  def directory_query(query, directory) do

    from dir in query, where: [id: ^directory.id]

  end

  def root_directory_query(query) do

    from dir in query, where: is_nil(dir.parent_id)

  end

  def parent_directory_query(query, parent) do

    from dir in query, where: [parent_id: ^parent.id]

  end

  def present_query(query) do

    from dir in query, where: is_nil(dir.deleted_at)

  end

  def deleted_query(query, []) do

    from dir in query, where: not is_nil(dir.deleted_at)

  end

  def deleted_query(query, opts) do

    threshold =

      DateTime.shift(

        DateTime.utc_now(),

        Duration.negate(Duration.new!(opts))

      )

    from dir in query, where: dir.deleted_at < ^threshold

  end

  @doc """

  Queries a directory tree structure using parent_id and recursive CTEs. Useful for

  applying query restraints (for authorization) or listing directories in a hierarchy.

  https://hexdocs.pm/ecto/Ecto.Query.html#recursive_ctes/2

  """

  def recursive_directory_tree_query(query, direction, base_query_fun, opts \\ []) do

    traverse_query_fun = Keyword.get(opts, :traverse_query_fun, & &1)

    # Base case: directories to start recursion with

    directory_tree_base_query =

      from(__MODULE__)

      |> base_query_fun.()

      |> select([d], %{d | level: 0})

      |> traverse_query_fun.()

    # Recurse case: join with directories on parent_id, traversing up or down

    directory_tree_recursion_query =

      case direction do

        :top_down ->

          from(__MODULE__)

          |> join(:inner, [d], dt in "directory_tree", on: d.parent_id == dt.id)

          |> select([d, dt], %{d | level: dt.level + 1})

          |> traverse_query_fun.()

        :bottom_up ->

          from(__MODULE__)

          |> join(:inner, [d], dt in "directory_tree", on: d.id == dt.parent_id)

          |> select([d, dt], %{d | level: dt.level + 1})

          |> traverse_query_fun.()

      end

    directory_tree_query =

      union_all(directory_tree_base_query, ^directory_tree_recursion_query)

    query

    |> recursive_ctes(true)

    |> with_cte("directory_tree", as: ^directory_tree_query)

    |> join(:inner, [d], "directory_tree", on: [id: d.id], as: :directory_tree)

  end

  ## Multis

  def create_multi(multi, attrs) do

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

  end

end

defmodule MyApp.Storage.Drive.DirectoryUser do

  use Ecto.Schema

  import Ecto.Query

  alias MyApp.Accounts

  alias MyApp.Storage

  @primary_key false

  @foreign_key_type :binary_id

  schema "storage_directories_users" do

    belongs_to :directory, Storage.Drive.Directory, primary_key: true

    belongs_to :user, Accounts.User

  end

  ## Queries

  def belongs_to_user_query(query, user) do

    Storage.Drive.Directory.recursive_directory_tree_query(

      query,

      :top_down,

      &belongs_to_user_directly_query(&1, user),

      traverse_query_fun: &Storage.Drive.Directory.present_query/1

    )

  end

  def belongs_to_user_directly_query(query, user) do

    from dir in query,

      join: __MODULE__,

      on: [directory_id: dir.id, user_id: ^user.id]

  end

  ## Multis

  def assoc_user_multi(multi, user) do

    Ecto.Multi.insert(multi, :directory_user, fn %{directory: directory} ->

      %__MODULE__{directory: directory, user: user}

    end)

  end

end

defmodule MyApp.Storage.Drive.ObjectDirectory do

  use Ecto.Schema

  import Ecto.Query

  alias MyApp.Storage

  @primary_key false

  @foreign_key_type :binary_id

  schema "storage_objects_directories" do

    belongs_to :object, Storage.Object, primary_key: true

    belongs_to :directory, Storage.Drive.Directory

  end

  ## Queries

  def object_query(object) do

    from __MODULE__, where: [object_id: ^object.id]

  end

  def object_in_directory_query(query, directory) do

    from object in query,

      join: object_dir in __MODULE__,

      on: [object_id: object.id, directory_id: ^directory.id]

  end

  ## Multis

  def insert_for_directory_multi(multi, directory) do

    Ecto.Multi.insert(multi, :object_directory, fn %{object: object} ->

      %__MODULE__{object: object, directory: directory}

    end)

  end

  def add_to_directory_multi(multi, object, directory) do

    Ecto.Multi.insert(multi, :object_directory, %__MODULE__{object: object, directory: directory})

  end

  def delete_from_directory_multi(multi, object) do

    Ecto.Multi.delete_all(multi, :delete_all, object_query(object))

  end

end

      * `:directory` - inserts a `ObjectDirectory` association

        {:directory, directory} ->

          Storage.Drive.ObjectDirectory.insert_for_directory_multi(multi, directory)

defmodule MyAppWeb.DriveLive do

  use MyAppWeb, :live_view

  import MyAppWeb.DriveLive.Components

  import MyAppWeb.StorageLive.Components

  alias MyApp.Storage

  alias MyAppWeb.DriveLive.DirectoryFormComponent

  alias MyAppWeb.StorageController

  def render(assigns) do

    ~H"""

    <.header class="mb-6">

      Drive

      <:actions>

        <%= if @current_directory do %>

          <.button phx-click={JS.patch(~p"/drive/#{@current_directory}/edit")}>

            Edit

          </.button>

          <.button phx-click={JS.patch(~p"/drive/#{@current_directory}/new")}>

            Create directory

          </.button>

        <% else %>

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

            Create drive

          </.button>

        <% end %>

      </:actions>

    </.header>

    <.breadcrumbs home_path={~p"/drive"} directories={@breadcrumbs} />

    <.form :if={@current_directory} for={%{}} as={:f} class="mt-6" phx-change="validate">

      <.file_upload id="my-file-upload" upload={@uploads.upload} />

    </.form>

    <.table id="files_table" rows={row_items(assigns)} row_click={& &1.row_click}>

      <:col :let={item}>

        <.icon name={item.icon} class="size-5" />

      </:col>

      <:col :let={item}>

        <%= item.name %>

      </:col>

      <:col :let={item}>

        <%= to_string(item[:inserted_at]) %>

      </:col>

      <:action :let={item}>

        <.link :if={item[:delete_click]} phx-click={item.delete_click} data-confirm="Are you sure?">

          Delete

        </.link>

      </:action>

    </.table>

    <.modal

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

      id="directory_modal"

      show

      on_cancel={JS.patch(@patch_path)}

    >

      <.live_component

        id="directory_form"

        module={DirectoryFormComponent}

        action={@live_action}

        current_user={@current_user}

        directory={@directory}

        parent_directory={@current_directory}

      />

    </.modal>

    """

  end

  def mount(_params, _session, socket) do

    {:ok,

     socket

     |> assign(:directory, nil)

     |> allow_upload(:upload,

       accept: ~w(.mp3 .mp4 .png .jpg .jpeg),

       max_file_size: 100_000_000,

       max_entries: 10,

       external: &presign_upload/2,

       progress: &handle_progress/3,

       auto_upload: true

     )}

  end

  def presign_upload(entry, socket) do

    {:ok, url} =

      entry.client_name

      |> Storage.Object.normalize_file_name()

      |> Buckets.url(entry.uuid, Storage.bucket_config())

    {:ok, %{uploader: "GCS", url: url}, socket}

  end

  def handle_progress(_type, entry, socket) do

    if entry.done? do

      directory = socket.assigns.current_directory

      %{object: _object} =

        consume_uploaded_entry(socket, entry, fn meta ->

          Storage.create_from_upload({entry, meta}, directory: directory)

        end)

      {:noreply, assign(socket, :objects, Storage.Drive.list_objects_in_directory(directory))}

    else

      {:noreply, socket}

    end

  end

  def handle_params(%{"id" => directory_id} = params, _uri, socket) do

    user = socket.assigns.current_user

    directory = Storage.Drive.get_directory!(directory_id, user)

    {:noreply,

     socket

     |> assign(:current_directory, directory)

     |> assign(:breadcrumbs, Storage.Drive.list_breadcrumbs(directory))

     |> assign(:directories, Storage.Drive.list_directories(directory))

     |> assign(:objects, Storage.Drive.list_objects_in_directory(directory))

     |> assign(:patch_path, ~p"/drive/#{directory}")

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

  end

  def handle_params(params, _uri, socket) do

    user = socket.assigns.current_user

    {:noreply,

     socket

     |> assign(:current_directory, nil)

     |> assign(:breadcrumbs, [])

     |> assign(:directories, Storage.Drive.list_root_directories(user))

     |> assign(:objects, [])

     |> assign(:patch_path, ~p"/drive")

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

  end

  def apply_action(socket, _params, action) when action in [:new_root, :new] do

    assign(socket, :directory, %Storage.Drive.Directory{})

  end

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

    user = socket.assigns.current_user

    assign(socket, :directory, Storage.Drive.get_directory!(directory_id, user))

  end

  def apply_action(socket, _params, _action) do

    socket

  end

  # Required for uploads

  def handle_event("validate", _params, socket) do

    {:noreply, socket}

  end

  def handle_event("delete_directory", %{"id" => directory_id}, socket) do

    directory_id

    |> Storage.Drive.get_directory!(socket.assigns.current_user)

    |> Storage.Drive.mark_directory_as_deleted!()

    {:noreply, push_patch(socket, to: socket.assigns.patch_path)}

  end

  def handle_event("delete_object", %{"id" => object_id}, socket) do

    object_id

    |> Storage.Drive.get_object_in_directory!(socket.assigns.current_directory)

    |> Storage.mark_as_deleted!()

    {:noreply, push_patch(socket, to: socket.assigns.patch_path)}

  end

  def handle_info({DirectoryFormComponent, _action, _directory}, socket) do

    {:noreply, push_patch(socket, to: socket.assigns.patch_path)}

  end

  ## Private

  def row_items(assigns) do

    row_items =

      case assigns do

        %{current_directory: nil} ->

          assigns.directories

        %{current_directory: %{parent: nil}} ->

          [{:back, :root}] ++ assigns.directories ++ assigns.objects

        %{current_directory: %{parent: parent}} ->

          [{:back, parent}] ++ assigns.directories ++ assigns.objects

      end

    Enum.map(row_items, &to_row(&1, assigns))

  end

  def to_row({:back, :root}, _assigns) do

    %{

      icon: "hero-arrow-uturn-left",

      name: "Drives",

      row_click: JS.patch(~p"/drive")

    }

  end

  def to_row({:back, parent}, _assigns) do

    %{

      icon: "hero-arrow-uturn-left",

      name: parent.name,

      row_click: JS.patch(~p"/drive/#{parent}")

    }

  end

  def to_row(%Storage.Drive.Directory{} = directory, _assigns) do

    %{

      icon: "hero-folder",

      name: directory.name,

      inserted_at: directory.inserted_at,

      row_click: JS.patch(~p"/drive/#{directory}"),

      delete_click: JS.push("delete_directory", value: %{id: directory.id})

    }

  end

  def to_row(%Storage.Object{} = object, %{current_directory: directory}) do

    download_path = StorageController.download_path(object)

    %{

      icon: "hero-document",

      name: object.filename,

      inserted_at: object.inserted_at,

      patch: ~p"/drive/#{directory}/file/#{object}/edit",

      row_click: JS.dispatch("my_app:open", detail: %{path: download_path}),

      delete_click: JS.push("delete_object", value: %{id: object.id})

    }

  end

end

defmodule MyAppWeb.DriveLive.Components do

  use MyAppWeb, :html

  attr :home_path, :string, required: true

  attr :directories, :list, required: true

  def breadcrumbs(assigns) do

    ~H"""

    <nav class="flex" aria-label="Breadcrumb">

      <ol role="list" class="flex items-center space-x-4">

        <li>

          <div>

            <.link patch={@home_path} class="text-gray-400 hover:text-gray-500 flex items-center">

              <.icon name="hero-home-mini" class="h-5 w-5 flex-shrink-0" />

              <span class="sr-only">Home</span>

            </.link>

          </div>

        </li>

        <.breadcrumb_item :for={directory <- @directories} patch={~p"/drive/#{directory}"}>

          <%= directory.name %>

        </.breadcrumb_item>

      </ol>

    </nav>

    """

  end

  attr :rest, :global, include: ~w(patch)

  slot :inner_block, required: true

  def breadcrumb_item(assigns) do

    ~H"""

    <li>

      <div class="flex items-center">

        <.icon name="hero-chevron-right-mini" class="h-5 w-5 flex-shrink-0 text-gray-400" />

        <.link {@rest} class="ml-4 text-sm font-medium text-gray-500 hover:text-gray-700">

          <%= render_slot(@inner_block) %>

        </.link>

      </div>

    </li>

    """

  end

end

defmodule MyAppWeb.DriveLive.DirectoryFormComponent do

  alias MyApp.Storage

  use MyAppWeb, :live_component

  def render(assigns) do

    ~H"""

    <div>

      <.header>

        New directory

      </.header>

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

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

        <:actions>

          <.button>Save</.button>

        </:actions>

      </.simple_form>

    </div>

    """

  end

  def update(assigns, socket) do

    {:ok,

     socket

     |> assign(assigns)

     |> put_form(Storage.Drive.Directory.changeset(assigns.directory, %{}))}

  end

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

    changeset =

      socket.assigns.directory

      |> Storage.Drive.Directory.changeset(params)

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

    {:noreply, put_form(socket, changeset)}

  end

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

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

  end

  def save_directory(socket, params, :new_root) do

    case Storage.Drive.create_root_directory(socket.assigns.current_user, params) do

      {:ok, directory} ->

        send(self(), {__MODULE__, :create_root, directory})

        {:noreply, socket}

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

        {:noreply, put_form(socket, changeset)}

    end

  end

  def save_directory(socket, params, :new) do

    case Storage.Drive.create_directory(socket.assigns.parent_directory, params) do

      {:ok, directory} ->

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

        {:noreply, socket}

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

        {:noreply, put_form(socket, changeset)}

    end

  end

  def save_directory(socket, params, :edit) do

    case Storage.Drive.update_directory(socket.assigns.directory, params) do

      {:ok, directory} ->

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

        {: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

      live "/drive", DriveLive, :index

      live "/drive/new", DriveLive, :new_root

      live "/drive/:id", DriveLive, :index

      live "/drive/:id/new", DriveLive, :new

      live "/drive/:id/edit", DriveLive, :edit

      live "/drive/:id/file/:object_id/edit", DriveLive, :edit_object

defmodule MyApp.Repo.Migrations.CreateStorageObjectsDirectories do

  use Ecto.Migration

  def change do

    create table(:storage_directories, primary_key: false) do

      add :id, :binary_id, primary_key: true

      add :name, :string, null: false

      add :deleted_at, :utc_datetime, null: true

      add :parent_id, references(:storage_directories, type: :binary_id, on_delete: :nothing),

        null: true

      timestamps()

    end

    create index(:storage_directories, [:parent_id])

    create table(:storage_objects_directories, primary_key: false) do

      add :object_id, references(:storage_objects, type: :binary_id, on_delete: :delete_all),

        primary_key: true

      add :directory_id, references(:storage_directories, type: :binary_id, on_delete: :nothing),

        null: false

    end

    create index(:storage_objects_directories, [:directory_id])

    create table(:storage_directories_users, primary_key: false) do

      add :directory_id,

          references(:storage_directories, type: :binary_id, on_delete: :delete_all),

          primary_key: true

      add :user_id, references(:users, type: :binary_id, on_delete: :nothing), null: false

    end

    create index(:storage_directories_users, [:user_id])

  end

end