{:buckets, "~> 1.0"},

      {:size, "~> 0.1"},

import * as uploaders from "./uploaders"

  uploaders,

export { default as LiveUploader } from "./live-uploader"

/**

* Uploader implementation that works for both Volume and GCS strategies.

*/

export default function (entries, onViewError) {

  entries.forEach((entry) => {

    let { url } = entry.meta;

    let xhr = new XMLHttpRequest();

    onViewError(() => xhr.abort());

    xhr.onload = () => xhr.status === 200 ? entry.progress(100) : entry.error();

    xhr.onerror = () => entry.error();

    xhr.upload.addEventListener("progress", (event) => {

      if (event.lengthComputable) {

        let percent = Math.round((event.loaded / event.total) * 100);

        if (percent < 100) entry.progress(percent);

      }

    });

    xhr.open("PUT", url, true);

    xhr.send(entry.file);

  });

}

# Configure your cloud storage strategies

config :my_app, MyApp.Cloud,

  adapter: Buckets.Adapters.Volume,

  bucket: "tmp/buckets_volume",

  path: "objects",

  base_url: "http://localhost:4000",

  endpoint: MyAppWeb.Endpoint,

  uploader: "LiveUploader"

  config :my_app, MyApp.Cloud,

    adapter: Buckets.Strategy.GCS,

    bucket: "ex-buckets-test",

    path: "test/objects",

    service_account_key: "buckets-test@elixir-saas.iam.gserviceaccount.com",

    uploader: "LiveUploader"

# Configure cloud storage for tests

config :my_app, MyApp.Cloud,

  adapter: Buckets.Adapters.Volume,

  bucket: "tmp/buckets_volume_test",

  base_url: "http://localhost:4002"

[

  {

    "origin": [

      "http://localhost:4000"

    ],

    "method": [

      "OPTIONS",

      "PUT"

    ],

    "responseHeader": [

      "Content-Type"

    ],

    "maxAgeSeconds": 3600

  }

]

      MyApp.Cloud,

defmodule MyApp.Cloud do

  use Buckets.Cloud, otp_app: :my_app

end

defmodule MyApp.Storage do

  import Ecto.Query

  alias MyApp.Repo

  alias MyApp.Storage.Object

  alias MyApp.Storage.ObjectUploadedByUser

  def get!(object_id) do

    Repo.get!(Object, object_id)

  end

  @doc """

  Gets an object if it was uploaded by the provided user.

  """

  def get_uploaded_by_user(object_id, user) do

    Object

    |> Object.present_query()

    |> ObjectUploadedByUser.uploaded_by_user_query(user)

    |> Repo.get(object_id)

  end

  @doc """

  Lists objects uploaded by a particular user.

  """

  def list_uploaded_by_user(user) do

    Object

    |> Object.present_query()

    |> ObjectUploadedByUser.uploaded_by_user_query(user)

    |> order_by(desc: :inserted_at)

    |> Repo.all()

  end

  @doc """

  Creates an object given an `upload` tuple consisting of the uploaded entry

  and upload metadata.

  """

  def create_from_upload({_entry, _meta} = upload, opts) do

    object = Buckets.Object.from_upload(upload)

    Ecto.Multi.new()

    |> Object.insert_from_remote_object_multi(object)

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

    |> Repo.transaction()

  end

  @doc """

  Sets the deleted_at field on an object.

  """

  def mark_as_deleted!(object) do

    object

    |> Object.delete_changeset()

    |> Repo.update!()

  end

  @doc """

  Permanently deletes objects that were marked as deleted before some

  time given duration opts.

  """

  def delete_marked_permanently(opts \\ []) do

    marked_objects =

      Object

      |> Object.deleted_query(opts)

      |> Repo.all()

    Enum.each(marked_objects, &delete_permanently/1)

  end

  @doc """

  Permanently deletes an object.

  """

  def delete_permanently(object) do

    Repo.transaction(fn ->

      Repo.delete!(object)

      object

      |> Object.remote_object()

      |> MyApp.Cloud.delete()

      |> case do

        {:ok, _response} -> {:ok, object}

        {:error, reason} -> Repo.rollback(reason)

      end

    end)

  end

end

defmodule MyApp.Storage.Object do

  use Ecto.Schema

  import Ecto.Changeset

  import Ecto.Query

  alias MyApp.Storage

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

  schema "storage_objects" do

    field :uuid, Ecto.UUID

    field :filename, :string

    field :path, :string

    field :deleted_at, :utc_datetime

    embeds_one :metadata, Metadata do

      field :content_type, :string

      field :content_size, :integer

    end

    timestamps()

  end

  ## Changesets

  def insert_changeset(object, attrs) do

    object

    |> cast(attrs, [:uuid, :filename, :path])

    |> cast_embed(:metadata, with: &metadata_changeset/2)

    |> validate_required([:uuid, :filename, :path])

  end

  def metadata_changeset(metadata, attrs) do

    cast(metadata, attrs, [:content_type, :content_size])

  end

  def delete_changeset(object) do

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

  end

  ## Queries

  def present_query(query) do

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

  end

  def deleted_query(query, []) do

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

  end

  def deleted_query(query, opts) do

    threshold =

      DateTime.shift(

        DateTime.utc_now(),

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

      )

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

  end

  ## Multis

  def insert_from_remote_object_multi(multi, %Buckets.Object{} = object) do

    if not object.stored? do

      raise """

      Cannot insert an object that has not yet been stored.

      """

    end

    attrs = %{

      uuid: object.uuid,

      filename: object.filename,

      path: object.location.path,

      metadata: %{

        content_type: object.metadata.content_type,

        content_size: object.metadata.content_size

      }

    }

    Ecto.Multi.insert(multi, :object, insert_changeset(%__MODULE__{}, attrs))

  end

  @doc """

  Inserts object association records given a keyword list. Will raise if passed

  an association that is not explicitly allowed.

  ## Options

      * `:uploaded_by_user` - inserts a `ObjectUploadedByUser` association

  """

  def insert_assocs_multi(multi, opts, allowed) do

    Enum.reduce(opts, multi, fn {key, _value} = assoc, multi ->

      if key not in allowed,

        do: raise("`insert_assocs_multi/3` received invalid key `#{inspect(key)}`.")

      case assoc do

        {:uploaded_by_user, user} ->

          Storage.ObjectUploadedByUser.insert_for_user_multi(multi, user)

      end

    end)

  end

  ## Helpers

  def image?(object) do

    object.metadata.content_type =~ "image/"

  end

  def signed_url(object) do

    signed_url = MyApp.Cloud.url!(remote_object(object))

    signed_url.url

  end

  def remote_object(object) do

    Buckets.Object.new(object.uuid, object.filename,

      metadata: object.metadata,

      location: {object.path, MyApp.Cloud}

    )

  end

end

defmodule MyApp.Storage.ObjectUploadedByUser do

  use Ecto.Schema

  import Ecto.Query

  alias MyApp.Accounts

  alias MyApp.Storage

  @primary_key false

  @foreign_key_type :binary_id

  schema "storage_objects_uploaded_by_users" do

    belongs_to :object, Storage.Object

    belongs_to :uploaded_by_user, Accounts.User

  end

  ## Queries

  def uploaded_by_user_query(query, user) do

    from object in query,

      join: object_uploaded_by_user in __MODULE__,

      on: [object_id: object.id, uploaded_by_user_id: ^user.id]

  end

  ## Multis

  def insert_for_user_multi(multi, user) do

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

      %__MODULE__{object: object, uploaded_by_user: user}

    end)

  end

end

defmodule MyAppWeb.StorageController do

  use MyAppWeb, :controller

  alias MyApp.Cloud

  alias MyApp.Storage

  def download(conn, %{"id" => object_id, "sig" => sig}) do

    case deterministic_hash(object_id) do

      ^sig ->

        object = Storage.get!(object_id)

        read_result =

          object

          |> Storage.Object.remote_object()

          |> Cloud.read()

        case read_result do

          {:ok, binary} ->

            send_download(conn, {:binary, binary}, filename: object.filename)

          {:error, _reason} ->

            send_resp(conn, 500, "Failed to read file")

        end

      _otherwise ->

        send_resp(conn, 401, "Unauthorized")

    end

  end

  def download_path(%Storage.Object{} = object) do

    ~p"/storage/download/#{object}?sig=#{deterministic_hash(object.id)}"

  end

  def deterministic_hash(object_id) do

    secret_key_base = MyAppWeb.Endpoint.config(:secret_key_base)

    hash = :crypto.mac(:hmac, :sha256, secret_key_base, object_id)

    Base.url_encode64(hash, padding: false)

  end

end

defmodule MyAppWeb.StorageLive do

  use MyAppWeb, :live_view

  import MyAppWeb.StorageLive.Components

  alias MyApp.Storage

  alias MyAppWeb.StorageController

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash}>

      <.form for={%{}} as={:f} phx-change="validate">

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

      </.form>

      <div class="-mx-32">

        <.table id="objects_table" rows={@streams.objects}>

          <:col :let={{_id, object}} label="Filename">

            {object.filename}

          </:col>

          <:col :let={{_id, object}} label="Content type">

            {object.metadata.content_type}

          </:col>

          <:col :let={{_id, object}} label="Preview">

            <%= if Storage.Object.image?(object) do %>

              <img

                src={Storage.Object.signed_url(object)}

                class="size-8 rounded overflow-hidden object-cover"

              />

            <% else %>

              <.icon name="hero-document-text" class="size-8" />

            <% end %>

          </:col>

          <:col :let={{_id, object}} label="Size">

            {Size.humanize!(object.metadata.content_size)}

          </:col>

          <:col :let={{_id, object}} label="Inserted at">

            {Calendar.strftime(object.inserted_at, "%c")}

          </:col>

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

            <.link phx-click="delete" phx-value-id={object.id}>Delete</.link>

          </:action>

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

            <.link href={StorageController.download_path(object)}>Download</.link>

          </:action>

        </.table>

      </div>

    </Layouts.app>

    """

  end

  def mount(_params, _session, socket) do

    {:ok,

     socket

     |> stream_configure(:objects, [])

     |> stream(:objects, Storage.list_uploaded_by_user(socket.assigns.current_scope.user))

     |> allow_upload(:upload,

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

       max_file_size: 100_000_000,

       max_entries: 10,

       external: &presign_upload/2,

       progress: &handle_progress/3,

       auto_upload: true

     )}

  end

  # By default, this app is configured for use with `Buckets.Strategy.Volume`.

  #

  # For direct uploads to GCS, you must specify additional parameters for signing the upload URL:

  #

  #     MyApp.Cloud.live_upload(entry, gcs_signed_url: [verb: "PUT", expires: 900])

  #

  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

      %{object: object} =

        consume_uploaded_entry(socket, entry, fn meta ->

          Storage.create_from_upload({entry, meta},

            uploaded_by_user: socket.assigns.current_scope.user

          )

        end)

      {:noreply, stream_insert(socket, :objects, object, at: 0)}

    else

      {:noreply, socket}

    end

  end

  # Required for uploads

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

    {:noreply, socket}

  end

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

    case Storage.get_uploaded_by_user(object_id, socket.assigns.current_scope.user) do

      nil ->

        {:noreply, put_flash(socket, :info, "Unable to delete object.")}

      object ->

        Storage.mark_as_deleted!(object)

        {:noreply,

         socket

         |> stream_delete(:objects, object)

         |> put_flash(:info, "Deleted object.")}

    end

  end

end

defmodule MyAppWeb.StorageLive.Components do

  use MyAppWeb, :html

  @doc """

  Renders a file upload input for live uploading files.

  """

  attr :id, :string, required: true

  attr :upload, Phoenix.LiveView.UploadConfig, required: true

  def file_upload(assigns) do

    ~H"""

    <div class="bg-zinc-900 rounded-2xl p-4 grid grid-cols-1 gap-2">

      <label

        id={@id}

        for={@upload.ref}

        phx-drop-target={@upload.ref}

        class={[

          "sm:h-48",

          "col-span-1 lg:col-span-2 relative",

          "flex flex-col items-center justify-center rounded-lg p-6",

          "border-2 border-dashed border-white drop:border-zinc-400 hover:border-zinc-400",

          "text-white drop:text-zinc-300 hover:text-zinc-300"

        ]}

      >

        <p class="text-center hidden sm:inline-block">

          Drag & drop files here.

        </p>

        <p :for={error <- upload_errors(@upload)} class="mt-2 text-sm text-rose-600">

          {error_for(error)}

        </p>

        <div class="sm:absolute sm:right-2 sm:bottom-2">

          <.button

            type="button"

            class="flex gap-2 items-center"

            onclick={"document.getElementById(#{inspect(@id)}).click()"}

          >

            <.icon name="hero-cloud-arrow-up-mini" class="h-5 w-5 text-zinc-900 dark:text-zinc-100" />

            Browse files

          </.button>

        </div>

        <.live_file_input upload={@upload} class="sr-only" />

      </label>

      <div :if={@upload.entries != []} class="col-span-1 relative">

        <div>

          <div class="flex-1 overflow-y-scroll">

            <.file_upload_entry

              :for={entry <- @upload.entries}

              entry={entry}

              errors={upload_errors(@upload, entry)}

            />

          </div>

        </div>

      </div>

    </div>

    """

  end

  @doc """

  Renders a file upload entry.

  """

  attr :entry, Phoenix.LiveView.UploadEntry, required: true

  attr :errors, :list, default: []

  def file_upload_entry(assigns) do

    ~H"""

    <div class="border border-white dark:border-zinc-800 rounded mt-2 p-2">

      <div class="flex gap-2">

        <div class="h-5 flex items-center">

          <.icon name="hero-document" class="h-5 w-5 text-white" />

        </div>

        <div class="flex-1 min-w-0">

          <div class="h-5 flex w-full items-center gap-4">

            <span class="text-sm text-white truncate">{@entry.client_name}</span>

            <span class="text-sm text-white whitespace-nowrap">

              {Size.humanize!(@entry.client_size)}

            </span>

          </div>

        </div>

      </div>

      <div class="mt-2">

        <.progress :if={@entry.progress not in [0, 100]} class="w-32" value={@entry.progress} />

        <span :for={error <- @errors} class="text-sm text-rose-600">{error_for(error)}</span>

      </div>

    </div>

    """

  end

  defp error_for(:too_large), do: "File is too large."

  defp error_for(:not_accepted), do: "File type not allowed."

  defp error_for(:too_many_files), do: "Too many files."

  defp error_for(error), do: to_string(error)

  @doc """

  Renders a small progress bar.

  """

  attr :value, :integer, required: true

  attr :class, :string, default: nil

  def progress(assigns) do

    ~H"""

    <div class={["h-2 overflow-hidden rounded-full border border-white", @class]}>

      <div class="h-full transition-[width] bg-white" style={"width: #{@value}%;"} />

    </div>

    """

  end

end

    import Buckets.Router

    # Here, we are defining a volume to accept files for the purpose of

    # local development. However, you may use this same approach to save files

    # to a persistent volume in production.

    buckets_volume(MyApp.Cloud, cache_control: :timer.hours(72))

    get "/storage/download/:id", StorageController, :download

      live "/storage", StorageLive

defmodule MyApp.Repo.Migrations.CreateStorageObjects do

  use Ecto.Migration

  def change do

    create table(:storage_objects, primary_key: false) do

      add :id, :binary_id, primary_key: true

      add :uuid, :binary_id, null: false

      add :filename, :string, null: false

      add :path, :string, null: false

      add :metadata, :map, null: false

      add :deleted_at, :utc_datetime, null: true

      timestamps()

    end

    create unique_index(:storage_objects, [:uuid])

    create table(:storage_objects_uploaded_by_users, primary_key: false) do

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

        primary_key: true

      add :uploaded_by_user_id, references(:users, type: :binary_id, on_delete: :nothing),

        null: false

    end

    create index(:storage_objects_uploaded_by_users, [:uploaded_by_user_id])

  end

end

defmodule MyApp.Storage.ObjectTest do

  use MyApp.DataCase

  alias MyApp.Storage.Object

  describe "insert_changeset/2" do

    test "valid attributes" do

      attrs = %{

        uuid: Ecto.UUID.generate(),

        filename: "test.pdf",

        path: "path/to/file",

        metadata: %{

          content_type: "application/pdf",

          content_size: 1024

        }

      }

      changeset = Object.insert_changeset(%Object{}, attrs)

      assert changeset.valid?

    end

    test "requires uuid, filename, and path" do

      changeset = Object.insert_changeset(%Object{}, %{})

      refute changeset.valid?

      assert %{

               uuid: ["can't be blank"],

               filename: ["can't be blank"],

               path: ["can't be blank"]

             } = errors_on(changeset)

    end

    test "casts metadata" do

      attrs = %{

        uuid: Ecto.UUID.generate(),

        filename: "test.pdf",

        path: "path/to/file",

        metadata: %{

          content_type: "application/pdf",

          content_size: 1024

        }

      }

      changeset = Object.insert_changeset(%Object{}, attrs)

      assert changeset.valid?

      assert get_change(changeset, :metadata).changes.content_type == "application/pdf"

      assert get_change(changeset, :metadata).changes.content_size == 1024

    end

  end

  describe "delete_changeset/1" do

    test "sets deleted_at timestamp" do

      object = %Object{}

      changeset = Object.delete_changeset(object)

      deleted_at = get_change(changeset, :deleted_at)

      assert deleted_at

      assert %DateTime{} = deleted_at

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

    end

  end

  describe "present_query/1" do

    test "filters out deleted objects" do

      {:ok, active_object} =

        %Object{}

        |> Object.insert_changeset(%{

          uuid: Ecto.UUID.generate(),

          filename: "active.pdf",

          path: "path/active",

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

        })

        |> Repo.insert()

      {:ok, deleted_object} =

        %Object{}

        |> Object.insert_changeset(%{

          uuid: Ecto.UUID.generate(),

          filename: "deleted.pdf",

          path: "path/deleted",

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

        })

        |> Repo.insert()

      {:ok, _} =

        deleted_object

        |> Object.delete_changeset()

        |> Repo.update()

      present_objects =

        Object

        |> Object.present_query()

        |> Repo.all()

      assert length(present_objects) == 1

      assert hd(present_objects).id == active_object.id

    end

  end

  describe "deleted_query/2" do

    test "returns deleted objects" do

      {:ok, _active_object} =

        %Object{}

        |> Object.insert_changeset(%{

          uuid: Ecto.UUID.generate(),

          filename: "active.pdf",

          path: "path/active",

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

        })

        |> Repo.insert()

      {:ok, deleted_object} =

        %Object{}

        |> Object.insert_changeset(%{

          uuid: Ecto.UUID.generate(),

          filename: "deleted.pdf",

          path: "path/deleted",

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

        })

        |> Repo.insert()

      {:ok, deleted_object} =

        deleted_object

        |> Object.delete_changeset()

        |> Repo.update()

      deleted_objects =

        Object

        |> Object.deleted_query([])

        |> Repo.all()

      assert length(deleted_objects) == 1

      assert hd(deleted_objects).id == deleted_object.id

    end

    test "filters by deletion time threshold" do

      {:ok, recently_deleted} =

        %Object{}

        |> Object.insert_changeset(%{

          uuid: Ecto.UUID.generate(),

          filename: "recent.pdf",

          path: "path/recent",

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

        })

        |> Repo.insert()

      {:ok, old_deleted} =

        %Object{}

        |> Object.insert_changeset(%{

          uuid: Ecto.UUID.generate(),

          filename: "old.pdf",

          path: "path/old",

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

        })

        |> Repo.insert()

      # Mark as deleted with different timestamps

      {:ok, _recently_deleted} =

        recently_deleted

        |> Object.delete_changeset()

        |> Repo.update()

      # Artificially set old deletion time

      {:ok, old_deleted} =

        old_deleted

        |> change(

          deleted_at: DateTime.truncate(DateTime.add(DateTime.utc_now(), -3600, :second), :second)

        )

        |> Repo.update()

      # Query for objects deleted more than 30 minutes ago

      old_deleted_objects =

        Object

        |> Object.deleted_query(minute: 30)

        |> Repo.all()

      assert length(old_deleted_objects) == 1

      assert hd(old_deleted_objects).id == old_deleted.id

    end

  end

  describe "image?/1" do

    test "returns true for image content types" do

      object = %Object{

        metadata: %Object.Metadata{

          content_type: "image/jpeg"

        }

      }

      assert Object.image?(object)

      object = %Object{

        metadata: %Object.Metadata{

          content_type: "image/png"

        }

      }

      assert Object.image?(object)

    end

    test "returns false for non-image content types" do

      object = %Object{

        metadata: %Object.Metadata{

          content_type: "application/pdf"

        }

      }

      refute Object.image?(object)

      object = %Object{

        metadata: %Object.Metadata{

          content_type: "text/plain"

        }

      }

      refute Object.image?(object)

    end

  end

  describe "remote_object/1" do

    test "creates Buckets.Object from storage object" do

      object = %Object{

        uuid: "test-uuid-123",

        filename: "test.pdf",

        path: "path/to/file",

        metadata: %Object.Metadata{

          content_type: "application/pdf",

          content_size: 1024

        }

      }

      remote = Object.remote_object(object)

      assert remote.uuid == "test-uuid-123"

      assert remote.filename == "test.pdf"

      assert %Buckets.Location{path: "path/to/file"} = remote.location

      assert remote.metadata.content_type == "application/pdf"

      assert remote.metadata.content_size == 1024

    end

  end

end

defmodule MyApp.Storage.ObjectUploadedByUserTest do

  use MyApp.DataCase

  alias MyApp.Storage.Object

  alias MyApp.Storage.ObjectUploadedByUser

  import MyApp.AccountsFixtures

  describe "uploaded_by_user_query/2" do

    test "filters objects by user" do

      user1 = user_fixture()

      user2 = user_fixture()

      # Create objects for different users

      {:ok, %{object: object1}} = create_object_for_user(user1)

      {:ok, %{object: _object2}} = create_object_for_user(user2)

      # Query for user1's objects

      objects =

        Object

        |> ObjectUploadedByUser.uploaded_by_user_query(user1)

        |> Repo.all()

      assert length(objects) == 1

      assert hd(objects).id == object1.id

    end

    test "returns empty list for user with no objects" do

      user = user_fixture()

      other_user = user_fixture()

      # Create object for other user

      {:ok, %{object: _object}} = create_object_for_user(other_user)

      # Query for user with no objects

      objects =

        Object

        |> ObjectUploadedByUser.uploaded_by_user_query(user)

        |> Repo.all()

      assert objects == []

    end

  end

  describe "insert_for_user_multi/2" do

    test "creates association between object and user" do

      user = user_fixture()

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

        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}

          )

        )

        |> ObjectUploadedByUser.insert_for_user_multi(user)

        |> Repo.transaction()

      assert assoc.object_id == object.id

      assert assoc.uploaded_by_user_id == user.id

      # Verify the association is queryable

      objects =

        Object

        |> ObjectUploadedByUser.uploaded_by_user_query(user)

        |> Repo.all()

      assert length(objects) == 1

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

    end

  end

  defp create_object_for_user(user) do

    Ecto.Multi.new()

    |> Object.insert_from_remote_object_multi(

      Buckets.Object.new(

        Ecto.UUID.generate(),

        "test-#{System.unique_integer([:positive])}.pdf",

        stored?: true,

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

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

      )

    )

    |> ObjectUploadedByUser.insert_for_user_multi(user)

    |> Repo.transaction()

  end

end

defmodule MyApp.StorageTest do

  use MyApp.DataCase

  alias MyApp.Storage

  alias MyApp.Storage.Object

  import MyApp.AccountsFixtures

  describe "get!/1" do

    test "returns the object with given id" do

      object = storage_object_fixture()

      assert Storage.get!(object.id).id == object.id

    end

    test "raises if object does not exist" do

      assert_raise Ecto.NoResultsError, fn ->

        Storage.get!(Ecto.UUID.generate())

      end

    end

  end

  describe "get_uploaded_by_user/2" do

    test "returns object if uploaded by user" do

      user = user_fixture()

      object = storage_object_fixture(uploaded_by_user: user)

      assert fetched = Storage.get_uploaded_by_user(object.id, user)

      assert fetched.id == object.id

    end

    test "returns nil if object was uploaded by different user" do

      user1 = user_fixture()

      user2 = user_fixture()

      object = storage_object_fixture(uploaded_by_user: user1)

      assert nil == Storage.get_uploaded_by_user(object.id, user2)

    end

    test "returns nil if object is deleted" do

      user = user_fixture()

      object = storage_object_fixture(uploaded_by_user: user)

      Storage.mark_as_deleted!(object)

      assert nil == Storage.get_uploaded_by_user(object.id, user)

    end

  end

  describe "list_uploaded_by_user/1" do

    test "returns all objects uploaded by user ordered by newest first" do

      user = user_fixture()

      # Create older object with manually set timestamp

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

        Ecto.Multi.new()

        |> Object.insert_from_remote_object_multi(

          Buckets.Object.new(

            Ecto.UUID.generate(),

            "older.pdf",

            stored?: true,

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

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

          )

        )

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

        |> Repo.transaction()

      # Update older object to have older timestamp

      {:ok, older_object} =

        older_object

        |> Ecto.Changeset.change(

          inserted_at:

            NaiveDateTime.truncate(

              NaiveDateTime.add(NaiveDateTime.utc_now(), -3600, :second),

              :second

            )

        )

        |> Repo.update()

      newer_object = storage_object_fixture(uploaded_by_user: user)

      objects = Storage.list_uploaded_by_user(user)

      assert length(objects) == 2

      assert [first, second] = objects

      assert first.id == newer_object.id

      assert second.id == older_object.id

    end

    test "excludes deleted objects" do

      user = user_fixture()

      active_object = storage_object_fixture(uploaded_by_user: user)

      deleted_object = storage_object_fixture(uploaded_by_user: user)

      Storage.mark_as_deleted!(deleted_object)

      objects = Storage.list_uploaded_by_user(user)

      assert length(objects) == 1

      assert hd(objects).id == active_object.id

    end

    test "excludes objects uploaded by other users" do

      user1 = user_fixture()

      user2 = user_fixture()

      user1_object = storage_object_fixture(uploaded_by_user: user1)

      _user2_object = storage_object_fixture(uploaded_by_user: user2)

      objects = Storage.list_uploaded_by_user(user1)

      assert length(objects) == 1

      assert hd(objects).id == user1_object.id

    end

  end

  describe "mark_as_deleted!/1" do

    test "sets deleted_at timestamp" do

      object = storage_object_fixture()

      assert is_nil(object.deleted_at)

      updated = Storage.mark_as_deleted!(object)

      assert updated.deleted_at

      assert %DateTime{} = updated.deleted_at

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

    end

  end

  describe "delete_marked_permanently/1" do

    test "deletes objects marked as deleted before threshold" do

      # Create objects with different deletion times

      recent_object = storage_object_fixture()

      old_object = storage_object_fixture()

      # Mark both as deleted

      Storage.mark_as_deleted!(recent_object)

      # Artificially set old deletion time

      {:ok, old_object} =

        old_object

        |> Ecto.Changeset.change(

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

        )

        |> Repo.update()

      # Delete objects marked more than 1 hour ago

      Storage.delete_marked_permanently(hour: 1)

      # Recent object should still exist

      assert Storage.get!(recent_object.id)

      # Old object should be gone

      assert_raise Ecto.NoResultsError, fn ->

        Storage.get!(old_object.id)

      end

    end

  end

  defp storage_object_fixture(opts \\ []) do

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

      Ecto.Multi.new()

      |> Object.insert_from_remote_object_multi(

        Buckets.Object.new(

          Ecto.UUID.generate(),

          "test-#{System.unique_integer([:positive])}.pdf",

          stored?: true,

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

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

        )

      )

      |> then(fn multi ->

        case Keyword.get(opts, :uploaded_by_user) do

          nil -> multi

          user -> Object.insert_assocs_multi(multi, [uploaded_by_user: user], [:uploaded_by_user])

        end

      end)

      |> Repo.transaction()

    object

  end

end

defmodule MyAppWeb.StorageControllerTest do

  use MyAppWeb.ConnCase

  alias MyApp.Storage

  alias MyApp.Storage.Object

  alias MyAppWeb.StorageController

  import MyApp.AccountsFixtures

  describe "download/2" do

    setup %{conn: conn} do

      user = user_fixture()

      conn = log_in_user(conn, user)

      {:ok, conn: conn, user: user}

    end

    test "downloads file with valid signature", %{conn: conn} do

      object = storage_object_fixture()

      sig = StorageController.deterministic_hash(object.id)

      # Create directory and write test file directly to storage location

      remote_object = Storage.Object.remote_object(object)

      file_path = Path.join(["tmp/buckets_volume_test", remote_object.location.path])

      File.mkdir_p!(Path.dirname(file_path))

      File.write!(file_path, "test file content")

      conn = get(conn, ~p"/storage/download/#{object.id}?sig=#{sig}")

      assert response(conn, 200)

      assert get_resp_header(conn, "content-disposition") == [

               "attachment; filename=\"#{object.filename}\""

             ]

    end

    test "returns 401 with invalid signature", %{conn: conn} do

      object = storage_object_fixture()

      conn = get(conn, ~p"/storage/download/#{object.id}?sig=invalid")

      assert response(conn, 401) == "Unauthorized"

    end

    test "returns 401 with signature for different object", %{conn: conn} do

      object1 = storage_object_fixture()

      object2 = storage_object_fixture()

      sig = StorageController.deterministic_hash(object2.id)

      conn = get(conn, ~p"/storage/download/#{object1.id}?sig=#{sig}")

      assert response(conn, 401) == "Unauthorized"

    end

  end

  describe "download_path/1" do

    test "generates path with object id and signature" do

      object = storage_object_fixture()

      path = StorageController.download_path(object)

      assert path =~ "/storage/download/#{object.id}"

      assert path =~ "sig="

      # Verify the signature is correct

      sig = StorageController.deterministic_hash(object.id)

      assert path == "/storage/download/#{object.id}?sig=#{sig}"

    end

  end

  describe "deterministic_hash/1" do

    test "generates consistent hash for same input" do

      object_id = Ecto.UUID.generate()

      hash1 = StorageController.deterministic_hash(object_id)

      hash2 = StorageController.deterministic_hash(object_id)

      assert hash1 == hash2

    end

    test "generates different hashes for different inputs" do

      id1 = Ecto.UUID.generate()

      id2 = Ecto.UUID.generate()

      hash1 = StorageController.deterministic_hash(id1)

      hash2 = StorageController.deterministic_hash(id2)

      assert hash1 != hash2

    end

    test "generates url-safe base64 encoded hash" do

      object_id = Ecto.UUID.generate()

      hash = StorageController.deterministic_hash(object_id)

      # Should be valid base64

      assert {:ok, _} = Base.url_decode64(hash, padding: false)

      # Should not contain URL-unsafe characters

      refute hash =~ ~r/[+\/=]/

    end

  end

  defp storage_object_fixture(opts \\ []) do

    user = Keyword.get_lazy(opts, :user, &user_fixture/0)

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

      Ecto.Multi.new()

      |> Object.insert_from_remote_object_multi(

        Buckets.Object.new(

          Ecto.UUID.generate(),

          Keyword.get(opts, :filename, "test-#{System.unique_integer([:positive])}.pdf"),

          stored?: true,

          metadata: %{

            content_type: Keyword.get(opts, :content_type, "application/pdf"),

            content_size: Keyword.get(opts, :content_size, 1024)

          },

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

        )

      )

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

      |> MyApp.Repo.transaction()

    object

  end

end