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.Accounts.Scope

  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!(%Scope{} = scope, id) do

    Directory

    |> DirectoryUser.belongs_to_user_query(scope.user)

    |> preload(:parent)

    |> Repo.get!(id)

  end

  @doc """

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

  """

  def list_root_directories(%Scope{} = scope) do

    Directory

    |> Directory.present_query()

    |> Directory.root_directory_query()

    |> DirectoryUser.belongs_to_user_directly_query(scope.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!(directory, object_id) 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(%Scope{} = scope, attrs) do

    Ecto.Multi.new()

    |> Directory.create_multi(attrs)

    |> DirectoryUser.assoc_user_multi(scope.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"""

    <Layouts.app flash={@flash} current_scope={@current_scope}>

      <.header>

        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>

      <.live_component

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

        id="directory_form"

        module={DirectoryFormComponent}

        action={@live_action}

        current_scope={@current_scope}

        directory={@directory}

        parent_directory={@current_directory}

      />

      <.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>

    </Layouts.app>

    """

  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, upload_config} = MyApp.Cloud.live_upload(entry)

    {:ok, upload_config, 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

    current_scope = socket.assigns.current_scope

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

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

    current_scope = socket.assigns.current_scope

    {:noreply,

     socket

     |> assign(:current_directory, nil)

     |> assign(:breadcrumbs, [])

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

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

    current_scope = socket.assigns.current_scope

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

  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

    socket.assigns.current_scope

    |> Storage.Drive.get_directory!(directory_id)

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

    socket.assigns.current_directory

    |> Storage.Drive.get_object_in_directory!(object_id)

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

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

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

        <.button variant="primary">Save</.button>

      </.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_scope, 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

defmodule MyApp.Storage.Drive.DirectoryTest do

  use MyApp.DataCase

  alias MyApp.Storage.Drive.Directory

  import MyApp.AccountsFixtures

  import MyApp.StorageFixtures

  describe "changeset/2" do

    test "valid changeset with required fields" do

      changeset = Directory.changeset(%Directory{}, %{name: "My Directory"})

      assert changeset.valid?

      assert get_change(changeset, :name) == "My Directory"

    end

    test "invalid changeset without name" do

      changeset = Directory.changeset(%Directory{}, %{})

      refute changeset.valid?

      assert "can't be blank" in errors_on(changeset).name

    end

  end

  describe "delete_changeset/1" do

    test "sets deleted_at to current time" do

      directory = %Directory{}

      changeset = Directory.delete_changeset(directory)

      deleted_at = get_change(changeset, :deleted_at)

      assert deleted_at

      assert DateTime.diff(DateTime.utc_now(), deleted_at) < 2

    end

  end

  describe "directory_query/2" do

    test "filters by directory id" do

      user = user_fixture()

      dir1 = root_directory_fixture(user)

      _dir2 = root_directory_fixture(user)

      query = Directory |> Directory.directory_query(dir1)

      results = Repo.all(query)

      assert length(results) == 1

      assert hd(results).id == dir1.id

    end

  end

  describe "root_directory_query/1" do

    test "returns only root directories" do

      user = user_fixture()

      root1 = root_directory_fixture(user)

      root2 = root_directory_fixture(user)

      _sub = directory_fixture(%{parent: root1})

      query = Directory |> Directory.root_directory_query()

      results = Repo.all(query)

      root_ids = Enum.map(results, & &1.id)

      assert root1.id in root_ids

      assert root2.id in root_ids

      assert length(results) >= 2

    end

  end

  describe "parent_directory_query/2" do

    test "returns directories with specific parent" do

      user = user_fixture()

      parent = root_directory_fixture(user)

      sub1 = directory_fixture(%{parent: parent})

      sub2 = directory_fixture(%{parent: parent})

      _other = root_directory_fixture(user)

      query = Directory |> Directory.parent_directory_query(parent)

      results = Repo.all(query)

      assert length(results) == 2

      result_ids = Enum.map(results, & &1.id)

      assert sub1.id in result_ids

      assert sub2.id in result_ids

    end

  end

  describe "present_query/1" do

    test "excludes deleted directories" do

      user = user_fixture()

      active = root_directory_fixture(user)

      deleted = root_directory_fixture(user)

      # Mark as deleted

      {:ok, _} =

        deleted

        |> Directory.delete_changeset()

        |> Repo.update()

      query = Directory |> Directory.present_query()

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert active.id in result_ids

      refute deleted.id in result_ids

    end

  end

  describe "deleted_query/2" do

    test "returns all deleted directories when no opts" do

      user = user_fixture()

      _active = root_directory_fixture(user)

      deleted = root_directory_fixture(user)

      # Mark as deleted

      {:ok, deleted} =

        deleted

        |> Directory.delete_changeset()

        |> Repo.update()

      query = Directory |> Directory.deleted_query([])

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert deleted.id in result_ids

    end

    test "returns directories deleted before threshold" do

      user = user_fixture()

      recent = root_directory_fixture(user)

      old = root_directory_fixture(user)

      # Mark both as deleted with different times

      now = DateTime.utc_now()

      {:ok, _recent} =

        recent

        |> Ecto.Changeset.change(deleted_at: DateTime.truncate(now, :second))

        |> Repo.update()

      {:ok, old} =

        old

        |> Ecto.Changeset.change(

          deleted_at: DateTime.truncate(DateTime.add(now, -7200, :second), :second)

        )

        |> Repo.update()

      query = Directory |> Directory.deleted_query(hour: 1)

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert old.id in result_ids

      refute recent.id in result_ids

    end

  end

  describe "recursive_directory_tree_query/4" do

    test "top_down traversal from root includes all descendants" do

      user = user_fixture()

      [root, level1, level2, level3] = nested_directories_fixture(user, 3)

      query =

        Directory

        |> Directory.recursive_directory_tree_query(

          :top_down,

          &Directory.directory_query(&1, root)

        )

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert length(results) == 4

      assert root.id in result_ids

      assert level1.id in result_ids

      assert level2.id in result_ids

      assert level3.id in result_ids

    end

    test "bottom_up traversal from leaf includes all ancestors" do

      user = user_fixture()

      [root, level1, level2, level3] = nested_directories_fixture(user, 3)

      query =

        Directory

        |> Directory.recursive_directory_tree_query(

          :bottom_up,

          &Directory.directory_query(&1, level3)

        )

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert length(results) == 4

      assert root.id in result_ids

      assert level1.id in result_ids

      assert level2.id in result_ids

      assert level3.id in result_ids

    end

    test "respects traverse_query_fun to filter deleted directories" do

      user = user_fixture()

      root = root_directory_fixture(user)

      active_sub = directory_fixture(%{parent: root})

      deleted_sub = directory_fixture(%{parent: root})

      # Mark one as deleted

      {:ok, _} =

        deleted_sub

        |> Directory.delete_changeset()

        |> Repo.update()

      query =

        Directory

        |> Directory.recursive_directory_tree_query(

          :top_down,

          &Directory.directory_query(&1, root),

          traverse_query_fun: &Directory.present_query/1

        )

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert length(results) == 2

      assert root.id in result_ids

      assert active_sub.id in result_ids

      refute deleted_sub.id in result_ids

    end

    test "includes level information in results" do

      user = user_fixture()

      [root, level1, level2, _level3] = nested_directories_fixture(user, 3)

      query =

        Directory

        |> Directory.recursive_directory_tree_query(

          :top_down,

          &Directory.directory_query(&1, root)

        )

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

      results = Repo.all(query)

      levels_by_id = Map.new(results, fn %{id: id, level: level} -> {id, level} end)

      assert levels_by_id[root.id] == 0

      assert levels_by_id[level1.id] == 1

      assert levels_by_id[level2.id] == 2

    end

  end

  describe "create_multi/2" do

    test "creates directory in multi" do

      multi = Ecto.Multi.new()

      attrs = %{name: "Test Directory"}

      multi = Directory.create_multi(multi, attrs)

      assert {:ok, %{directory: directory}} = Repo.transaction(multi)

      assert directory.name == "Test Directory"

    end

    test "fails multi with invalid attrs" do

      multi = Ecto.Multi.new()

      attrs = %{}

      multi = Directory.create_multi(multi, attrs)

      assert {:error, :directory, changeset, _} = Repo.transaction(multi)

      assert "can't be blank" in errors_on(changeset).name

    end

  end

end

defmodule MyApp.Storage.Drive.DirectoryUserTest do

  use MyApp.DataCase

  alias MyApp.Storage.Drive.Directory

  alias MyApp.Storage.Drive.DirectoryUser

  import MyApp.AccountsFixtures

  import MyApp.StorageFixtures

  describe "belongs_to_user_query/2" do

    test "includes directories directly associated with user" do

      user = user_fixture()

      other_user = user_fixture()

      user_dir = root_directory_fixture(user)

      _other_dir = root_directory_fixture(other_user)

      query = Directory |> DirectoryUser.belongs_to_user_query(user)

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert user_dir.id in result_ids

      assert length(results) >= 1

    end

    test "includes subdirectories when user has access to parent" do

      user = user_fixture()

      root = root_directory_fixture(user)

      sub1 = directory_fixture(%{parent: root})

      sub2 = directory_fixture(%{parent: sub1})

      query = Directory |> DirectoryUser.belongs_to_user_query(user)

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert root.id in result_ids

      assert sub1.id in result_ids

      assert sub2.id in result_ids

    end

    test "excludes deleted directories in the path" do

      user = user_fixture()

      root = root_directory_fixture(user)

      active_sub = directory_fixture(%{parent: root})

      deleted_sub = directory_fixture(%{parent: root})

      sub_of_deleted = directory_fixture(%{parent: deleted_sub})

      # Mark middle directory as deleted

      {:ok, _} =

        deleted_sub

        |> Directory.delete_changeset()

        |> Repo.update()

      query = Directory |> DirectoryUser.belongs_to_user_query(user)

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert root.id in result_ids

      assert active_sub.id in result_ids

      refute deleted_sub.id in result_ids

      refute sub_of_deleted.id in result_ids

    end

    test "handles multiple root directories for same user" do

      user = user_fixture()

      root1 = root_directory_fixture(user)

      root2 = root_directory_fixture(user)

      sub1 = directory_fixture(%{parent: root1})

      sub2 = directory_fixture(%{parent: root2})

      query = Directory |> DirectoryUser.belongs_to_user_query(user)

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert root1.id in result_ids

      assert root2.id in result_ids

      assert sub1.id in result_ids

      assert sub2.id in result_ids

      assert length(results) >= 4

    end

  end

  describe "belongs_to_user_directly_query/2" do

    test "only includes directories directly associated with user" do

      user = user_fixture()

      other_user = user_fixture()

      user_dir = root_directory_fixture(user)

      sub_dir = directory_fixture(%{parent: user_dir})

      _other_dir = root_directory_fixture(other_user)

      query = Directory |> DirectoryUser.belongs_to_user_directly_query(user)

      results = Repo.all(query)

      result_ids = Enum.map(results, & &1.id)

      assert user_dir.id in result_ids

      refute sub_dir.id in result_ids

    end

    test "returns empty when user has no direct associations" do

      user = user_fixture()

      other_user = user_fixture()

      _other_dir = root_directory_fixture(other_user)

      query = Directory |> DirectoryUser.belongs_to_user_directly_query(user)

      results = Repo.all(query)

      assert Enum.empty?(results)

    end

  end

  describe "assoc_user_multi/2" do

    test "associates user with directory in multi" do

      user = user_fixture()

      directory = directory_fixture()

      multi =

        Ecto.Multi.new()

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

        |> DirectoryUser.assoc_user_multi(user)

      assert {:ok, %{directory_user: directory_user}} = Repo.transaction(multi)

      assert directory_user.directory_id == directory.id

      assert directory_user.user_id == user.id

    end

    test "creates valid association record" do

      user = user_fixture()

      directory = directory_fixture()

      multi =

        Ecto.Multi.new()

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

        |> DirectoryUser.assoc_user_multi(user)

      {:ok, _} = Repo.transaction(multi)

      # Verify the association works with queries

      query = Directory |> DirectoryUser.belongs_to_user_directly_query(user)

      results = Repo.all(query)

      assert length(results) == 1

      assert hd(results).id == directory.id

    end

  end

end

defmodule MyApp.Storage.Drive.ObjectDirectoryTest do

  use MyApp.DataCase

  alias MyApp.Storage.Object

  alias MyApp.Storage.Drive.ObjectDirectory

  import MyApp.AccountsFixtures

  import MyApp.StorageFixtures

  describe "object_query/1" do

    test "returns query filtered by object id" do

      user = user_fixture()

      directory = root_directory_fixture(user)

      object = storage_object_fixture(%{directory: directory})

      _other_object = storage_object_fixture(%{directory: directory})

      query = ObjectDirectory.object_query(object)

      results = Repo.all(query)

      assert length(results) == 1

      assert hd(results).object_id == object.id

    end

  end

  describe "object_in_directory_query/2" do

    test "filters objects by directory" do

      user = user_fixture()

      dir1 = root_directory_fixture(user)

      dir2 = root_directory_fixture(user)

      obj_in_dir1 = storage_object_fixture(%{directory: dir1})

      _obj_in_dir2 = storage_object_fixture(%{directory: dir2})

      query = Object |> ObjectDirectory.object_in_directory_query(dir1)

      results = Repo.all(query)

      assert length(results) == 1

      assert hd(results).id == obj_in_dir1.id

    end

    test "returns empty when directory has no objects" do

      user = user_fixture()

      empty_dir = root_directory_fixture(user)

      other_dir = root_directory_fixture(user)

      _object = storage_object_fixture(%{directory: other_dir})

      query = Object |> ObjectDirectory.object_in_directory_query(empty_dir)

      results = Repo.all(query)

      assert Enum.empty?(results)

    end

    test "works with complex object queries" do

      user = user_fixture()

      directory = root_directory_fixture(user)

      pdf_object =

        storage_object_fixture(%{

          directory: directory,

          filename: "document.pdf",

          content_type: "application/pdf"

        })

      _image_object =

        storage_object_fixture(%{

          directory: directory,

          filename: "image.jpg",

          content_type: "image/jpeg"

        })

      # Filter by directory and content type

      query =

        Object

        |> where([o], fragment("?->>'content_type' = ?", o.metadata, "application/pdf"))

        |> ObjectDirectory.object_in_directory_query(directory)

      results = Repo.all(query)

      assert length(results) == 1

      assert hd(results).id == pdf_object.id

    end

  end

  describe "insert_for_directory_multi/2" do

    test "associates object with directory in multi" do

      user = user_fixture()

      directory = root_directory_fixture(user)

      {:ok, %{object: object}} =

        Ecto.Multi.new()

        |> Object.insert_from_remote_object_multi(

          Buckets.Object.new(

            Ecto.UUID.generate(),

            "test.pdf",

            stored?: true,

            metadata: %{content_type: "application/pdf", content_size: 1024},

            location: {"test/path", MyApp.Cloud}

          )

        )

        |> ObjectDirectory.insert_for_directory_multi(directory)

        |> Repo.transaction()

      # Verify association was created

      query = Object |> ObjectDirectory.object_in_directory_query(directory)

      results = Repo.all(query)

      assert length(results) == 1

      assert hd(results).id == object.id

    end

  end

  describe "add_to_directory_multi/3" do

    test "adds existing object to directory" do

      user = user_fixture()

      directory = root_directory_fixture(user)

      object = storage_object_fixture()

      multi =

        Ecto.Multi.new()

        |> ObjectDirectory.add_to_directory_multi(object, directory)

      assert {:ok, %{object_directory: obj_dir}} = Repo.transaction(multi)

      assert obj_dir.object_id == object.id

      assert obj_dir.directory_id == directory.id

      # Verify object is now in directory

      query = Object |> ObjectDirectory.object_in_directory_query(directory)

      results = Repo.all(query)

      assert length(results) == 1

      assert hd(results).id == object.id

    end

  end

  describe "delete_from_directory_multi/2" do

    test "removes object from directory" do

      user = user_fixture()

      directory = root_directory_fixture(user)

      object = storage_object_fixture(%{directory: directory})

      # Verify object is in directory

      query = Object |> ObjectDirectory.object_in_directory_query(directory)

      assert length(Repo.all(query)) == 1

      # Remove object from directory

      multi =

        Ecto.Multi.new()

        |> ObjectDirectory.delete_from_directory_multi(object)

      assert {:ok, %{delete_all: {1, nil}}} = Repo.transaction(multi)

      # Verify object is no longer in directory

      query = Object |> ObjectDirectory.object_in_directory_query(directory)

      assert Enum.empty?(Repo.all(query))

      # Verify object still exists

      assert Repo.get(Object, object.id)

    end

    test "handles object with no directory association" do

      object = storage_object_fixture()

      multi =

        Ecto.Multi.new()

        |> ObjectDirectory.delete_from_directory_multi(object)

      assert {:ok, %{delete_all: {0, nil}}} = Repo.transaction(multi)

    end

  end

end

defmodule MyApp.Storage.DriveTest do

  use MyApp.DataCase

  alias MyApp.Accounts.Scope

  alias MyApp.Storage

  alias MyApp.Storage.Drive

  alias MyApp.Storage.Drive.Directory

  import MyApp.AccountsFixtures

  import MyApp.StorageFixtures

  describe "get_directory!/2" do

    test "returns directory when user has direct access" do

      user = user_fixture()

      directory = root_directory_fixture(user)

      assert fetched = Drive.get_directory!(Scope.for_user(user), directory.id)

      assert fetched.id == directory.id

    end

    test "returns subdirectory when user has access to parent" do

      user = user_fixture()

      root = root_directory_fixture(user)

      sub = directory_fixture(%{parent: root})

      assert fetched = Drive.get_directory!(Scope.for_user(user), sub.id)

      assert fetched.id == sub.id

    end

    test "raises when user has no access" do

      user1 = user_fixture()

      user2 = user_fixture()

      directory = root_directory_fixture(user1)

      assert_raise Ecto.NoResultsError, fn ->

        Drive.get_directory!(Scope.for_user(user2), directory.id)

      end

    end

    test "raises when directory is deleted" do

      user = user_fixture()

      directory = root_directory_fixture(user)

      Drive.mark_directory_as_deleted!(directory)

      assert_raise Ecto.NoResultsError, fn ->

        Drive.get_directory!(Scope.for_user(user), directory.id)

      end

    end

  end

  describe "list_root_directories/1" do

    test "returns only root directories for user" do

      user = user_fixture()

      root1 = root_directory_fixture(user, %{name: "A Root"})

      root2 = root_directory_fixture(user, %{name: "B Root"})

      _sub = directory_fixture(%{parent: root1})

      directories = Drive.list_root_directories(Scope.for_user(user))

      assert length(directories) == 2

      assert Enum.map(directories, & &1.id) == [root1.id, root2.id]

    end

    test "excludes deleted directories" do

      user = user_fixture()

      active = root_directory_fixture(user)

      deleted = root_directory_fixture(user)

      Drive.mark_directory_as_deleted!(deleted)

      directories = Drive.list_root_directories(Scope.for_user(user))

      assert length(directories) == 1

      assert hd(directories).id == active.id

    end

    test "excludes directories from other users" do

      user1 = user_fixture()

      user2 = user_fixture()

      user1_dir = root_directory_fixture(user1)

      _user2_dir = root_directory_fixture(user2)

      directories = Drive.list_root_directories(Scope.for_user(user1))

      assert length(directories) == 1

      assert hd(directories).id == user1_dir.id

    end

    test "orders by name ascending" do

      user = user_fixture()

      dir_c = root_directory_fixture(user, %{name: "C Directory"})

      dir_a = root_directory_fixture(user, %{name: "A Directory"})

      dir_b = root_directory_fixture(user, %{name: "B Directory"})

      directories = Drive.list_root_directories(Scope.for_user(user))

      assert Enum.map(directories, & &1.id) == [dir_a.id, dir_b.id, dir_c.id]

    end

  end

  describe "list_directories/1" do

    test "returns subdirectories of parent" do

      user = user_fixture()

      root = root_directory_fixture(user)

      sub1 = directory_fixture(%{parent: root, name: "Sub 1"})

      sub2 = directory_fixture(%{parent: root, name: "Sub 2"})

      _other = root_directory_fixture(user)

      directories = Drive.list_directories(root)

      assert length(directories) == 2

      assert Enum.map(directories, & &1.id) == [sub1.id, sub2.id]

    end

    test "excludes deleted subdirectories" do

      user = user_fixture()

      root = root_directory_fixture(user)

      active = directory_fixture(%{parent: root})

      deleted = directory_fixture(%{parent: root})

      Drive.mark_directory_as_deleted!(deleted)

      directories = Drive.list_directories(root)

      assert length(directories) == 1

      assert hd(directories).id == active.id

    end

  end

  describe "list_breadcrumbs/1" do

    test "returns all parent directories in order" do

      user = user_fixture()

      [root, level1, level2, level3] = nested_directories_fixture(user, 3)

      breadcrumbs = Drive.list_breadcrumbs(level3)

      assert length(breadcrumbs) == 4

      assert Enum.map(breadcrumbs, & &1.id) == [root.id, level1.id, level2.id, level3.id]

      assert Enum.map(breadcrumbs, & &1.name) == ["Root", "Level 1", "Level 2", "Level 3"]

    end

    test "returns single item for root directory" do

      user = user_fixture()

      root = root_directory_fixture(user)