manganese_aws_kit

defmodule Manganese.AwsKit.Structs.StorageObjectReference do
  @moduledoc """

  """

  alias Manganese.AwsKit.Structs


  @typedoc """

  A reference to a stored object in a specific AWS S3 region and bucket.

  """
  @type t :: %Structs.StorageObjectReference{
    region: String.t,
    bucket: String.t,
    path: String.t
  }
  @enforce_keys [
    :region,
    :bucket,
    :path
  ]
  defstruct [
    :region,
    :bucket,
    :path
  ]


  # Deserialization

  @doc """

  """
  @spec from_map(map) :: t
  def from_map(%{
    "region" => region,
    "bucket" => bucket,
    "path" => path
  }) do
    %Structs.StorageObjectReference{
      region: region,
      bucket: bucket,
      path: path
    }
  end


  # Serialization

  @doc """

  """
  @spec to_map(t) :: map
  def to_map(%Structs.StorageObjectReference{
    region: region,
    bucket: bucket,
    path: path
  }) do
    %{
      "region" => region,
      "bucket" => bucket,
      "path" => path
    }
  end

  @doc """

  """
  @spec to_url(t) :: String.t
  def to_url(%Structs.StorageObjectReference{
    region: region,
    bucket: bucket,
    path: path
  }) do
    "https://s3." <> region <> ".amazonaws.com/" <> bucket <> "/" <> path
  end


  # Ecto type
  @behaviour Ecto.Type

  @impl Ecto.Type
  def type, do: :map

  @impl Ecto.Type
  def cast(%Structs.StorageObjectReference{} = reference), do: { :ok, reference }
  def cast(%{} = map), do: { :ok, from_map map }
  def cast(nil), do: { :ok, nil }
  def cast(_), do: :error

  @impl Ecto.Type
  def load(%{} = map), do: { :ok, from_map map }
  def load(nil), do: { :ok, nil }
  def load(_), do: :error

  @impl Ecto.Type
  def dump(%Structs.StorageObjectReference{} = reference), do: { :ok, to_map reference }
  def dump(nil), do: { :ok, nil }
  def dump(_), do: :error
end