hugo/bDS2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: hopefully last part of persistence

Browse Source
This commit is contained in:
Chili Palmer
2026-04-23 16:06:36 +02:00
parent 82f2ed57dd
commit d3dda2bd40
3 changed files with 297 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
lib/bds/media.ex
View File

@@ -1,7 +1,10 @@
defmodule BDS.Media do
@moduledoc false
import Ecto.Query
alias BDS.Media.Media
alias BDS.Media.Translation
alias BDS.Projects
alias BDS.Repo
alias BDS.Sidecar
@@ -46,6 +49,7 @@ defmodule BDS.Media do
:ok = File.mkdir_p(Path.dirname(destination))
:ok = File.cp(source_path, destination)
:ok = write_sidecar(project, media)
:ok = ensure_thumbnails(project, media)
media
end)
|> case do
@@ -95,23 +99,98 @@ defmodule BDS.Media do
{:error, :not_found}
media ->
translations = Repo.all(from translation in Translation, where: translation.translation_for == ^media.id)
delete_file_if_present(media.project_id, media.file_path)
delete_file_if_present(media.project_id, media.sidecar_path)
delete_thumbnail_files(media.project_id, media)
Enum.each(translations, fn translation ->
delete_file_if_present(media.project_id, translation_sidecar_path(media, translation.language))
Repo.delete!(translation)
end)
Repo.delete!(media)
{:ok, :deleted}
end
end
def upsert_media_translation(media_id, language, attrs) do
case Repo.get(Media, media_id) do
nil ->
{:error, :not_found}
media ->
project = Projects.get_project!(media.project_id)
now = System.system_time(:second)
translation =
Repo.get_by(Translation, translation_for: media.id, language: language) ||
%Translation{id: Ecto.UUID.generate(), created_at: now}
translation_attrs = %{
id: translation.id,
project_id: media.project_id,
translation_for: media.id,
language: language,
title: attr(attrs, :title),
alt: attr(attrs, :alt),
caption: attr(attrs, :caption),
created_at: translation.created_at || now,
updated_at: now
}
Repo.transaction(fn ->
updated_translation =
translation
|> Translation.changeset(translation_attrs)
|> Repo.insert_or_update!()
:ok = write_translation_sidecar(project, media, updated_translation)
updated_translation
end)
|> case do
{:ok, updated_translation} -> {:ok, updated_translation}
{:error, reason} -> {:error, reason}
end
end
end
def thumbnail_paths(%Media{id: id}) do
prefix = String.slice(id, 0, 2)
%{
small: Path.join(["thumbnails", prefix, "#{id}-small.webp"]),
medium: Path.join(["thumbnails", prefix, "#{id}-medium.webp"]),
large: Path.join(["thumbnails", prefix, "#{id}-large.webp"]),
ai: Path.join(["thumbnails", prefix, "#{id}-ai.jpg"])
}
end
def rebuild_media_from_files(project_id) do
project = Projects.get_project!(project_id)
media_items =
canonical_sidecars =
project
|> Projects.project_data_dir()
|> Path.join("media")
|> list_matching_files("*.meta")
|> Enum.filter(&canonical_sidecar?/1)
|> Enum.filter(&binary_exists_for_sidecar?/1)
|> Enum.map(&upsert_media_from_sidecar(project, &1))
media_items = Enum.map(canonical_sidecars, &upsert_media_from_sidecar(project, &1))
canonical_media_by_binary_path =
Map.new(media_items, fn media ->
{Path.join(Projects.project_data_dir(project), media.file_path), media}
end)
project
|> Projects.project_data_dir()
|> Path.join("media")
|> list_matching_files("*.meta")
|> Enum.filter(&translation_sidecar?/1)
|> Enum.each(&upsert_translation_from_sidecar(project, canonical_media_by_binary_path, &1))
{:ok, media_items}
end
@@ -150,6 +229,7 @@ defmodule BDS.Media do
media
|> Media.changeset(attrs)
|> Repo.insert_or_update!()
|> tap(fn reloaded_media -> ensure_thumbnails(project, reloaded_media) end)
end
defp write_sidecar(project, media) do
@@ -177,6 +257,80 @@ defmodule BDS.Media do
)
end
defp write_translation_sidecar(project, media, translation) do
path = Path.join(Projects.project_data_dir(project), translation_sidecar_path(media, translation.language))
:ok = File.mkdir_p(Path.dirname(path))
atomic_write(
path,
Sidecar.serialize_document([
{:translation_for, media.id},
{:language, translation.language},
{:title, translation.title},
{:alt, translation.alt},
{:caption, translation.caption}
])
)
end
defp upsert_translation_from_sidecar(project, canonical_media_by_binary_path, sidecar_path) do
binary_path = binary_path_for_translation_sidecar(sidecar_path)
case Map.get(canonical_media_by_binary_path, binary_path) do
nil ->
:skip
media ->
{:ok, fields} = sidecar_path |> File.read!() |> Sidecar.parse_document()
now = System.system_time(:second)
language = Map.fetch!(fields, "language")
translation =
Repo.get_by(Translation, translation_for: media.id, language: language) ||
%Translation{id: Ecto.UUID.generate(), created_at: now}
translation
|> Translation.changeset(%{
id: translation.id,
project_id: project.id,
translation_for: media.id,
language: language,
title: Map.get(fields, "title"),
alt: Map.get(fields, "alt"),
caption: Map.get(fields, "caption"),
created_at: translation.created_at || now,
updated_at: now
})
|> Repo.insert_or_update!()
end
end
defp ensure_thumbnails(project, media) do
if image_mime?(media.mime_type) do
source_path = Path.join(Projects.project_data_dir(project), media.file_path)
Enum.each(thumbnail_paths(media), fn {_size, relative_path} ->
destination = Path.join(Projects.project_data_dir(project), relative_path)
:ok = File.mkdir_p(Path.dirname(destination))
case File.read(source_path) do
{:ok, contents} -> :ok = File.write(destination, contents)
{:error, _reason} -> :ok = File.write(destination, "")
end
end)
end
:ok
end
defp delete_thumbnail_files(project_id, media) do
Enum.each(Map.values(thumbnail_paths(media)), fn path ->
delete_file_if_present(project_id, path)
end)
:ok
end
defp media_file_path(file_name, timestamp) do
datetime = DateTime.from_unix!(timestamp)
year = Integer.to_string(datetime.year)
@@ -197,6 +351,8 @@ defmodule BDS.Media do
end
end
defp image_mime?(mime_type), do: String.starts_with?(mime_type || "", "image/")
defp binary_exists_for_sidecar?(sidecar_path) do
sidecar_path
|> String.trim_trailing(".meta")
@@ -213,6 +369,20 @@ defmodule BDS.Media do
end
end
defp canonical_sidecar?(sidecar_path) do
not translation_sidecar?(sidecar_path)
end
defp translation_sidecar?(sidecar_path) do
Regex.match?(~r/\.[a-z]{2}\.meta$/i, sidecar_path)
end
defp binary_path_for_translation_sidecar(sidecar_path) do
Regex.replace(~r/\.[a-z]{2}\.meta$/i, sidecar_path, "")
end
defp translation_sidecar_path(media, language), do: "#{media.file_path}.#{language}.meta"
defp delete_file_if_present(project_id, relative_path) do
project = Projects.get_project!(project_id)
full_path = Path.join(Projects.project_data_dir(project), relative_path)

30
lib/bds/media/translation.ex Normal file
View File

@@ -0,0 +1,30 @@
defmodule BDS.Media.Translation do
@moduledoc false
use Ecto.Schema
import Ecto.Changeset
@primary_key {:id, :string, autogenerate: false}
@foreign_key_type :string
schema "media_translations" do
belongs_to :media, BDS.Media.Media, foreign_key: :translation_for, references: :id, type: :string
field :project_id, :string
field :language, :string
field :title, :string
field :alt, :string
field :caption, :string
field :created_at, :integer
field :updated_at, :integer
end
def changeset(translation, attrs) do
translation
|> cast(attrs, [:id, :project_id, :translation_for, :language, :title, :alt, :caption, :created_at, :updated_at],
empty_values: [nil]
)
|> validate_required([:id, :project_id, :translation_for, :language, :created_at, :updated_at])
|> foreign_key_constraint(:translation_for)
|> unique_constraint(:language, name: :media_translations_translation_language_idx)
end
end

106
test/bds/media_test.exs
View File

@@ -82,28 +82,43 @@ defmodule BDS.MediaTest do
assert {:ok, media} = BDS.Media.import_media(%{project_id: project.id, source_path: source_path})
assert {:ok, _translation} =
BDS.Media.upsert_media_translation(media.id, "de", %{
title: "Titel",
alt: "Alt",
caption: "Beschriftung"
})
thumbnail_paths = BDS.Media.thumbnail_paths(media)
assert {:ok, :deleted} = BDS.Media.delete_media(media.id)
assert Repo.get(BDS.Media.Media, media.id) == nil
assert Repo.all(BDS.Media.Translation) == []
refute File.exists?(Path.join(temp_dir, media.file_path))
refute File.exists?(Path.join(temp_dir, media.sidecar_path))
refute File.exists?(Path.join(temp_dir, media.file_path <> ".de.meta"))
Enum.each(Map.values(thumbnail_paths), fn path ->
refute File.exists?(Path.join(temp_dir, path))
end)
end
test "rebuild_media_from_files recreates media rows from sidecars", %{project: project, temp_dir: temp_dir} do
media_dir = Path.join([temp_dir, "media", "2026", "04"])
File.mkdir_p!(media_dir)
binary_path = Path.join(media_dir, "asset.txt")
binary_path = Path.join(media_dir, "asset.jpg")
sidecar_path = binary_path <> ".meta"
File.write!(binary_path, "hello media")
File.write!(binary_path, "fake-jpeg")
File.write!(
sidecar_path,
[
"id: media-from-file",
"original_name: original.txt",
"mime_type: text/plain",
"size: 11",
"original_name: original.jpg",
"mime_type: image/jpeg",
"size: 9",
"width: 0",
"height: 0",
"title: Recovered",
@@ -120,23 +135,92 @@ defmodule BDS.MediaTest do
|> Enum.join("\n")
)
File.write!(
binary_path <> ".de.meta",
[
"translation_for: media-from-file",
"language: de",
"title: Titel",
"alt: Alt text",
"caption: Bildunterschrift",
""
]
|> Enum.join("\n")
)
assert {:ok, media_items} = BDS.Media.rebuild_media_from_files(project.id)
assert length(media_items) == 1
[media] = media_items
assert media.id == "media-from-file"
assert media.project_id == project.id
assert media.filename == "asset.txt"
assert media.original_name == "original.txt"
assert media.mime_type == "text/plain"
assert media.size == 11
assert media.filename == "asset.jpg"
assert media.original_name == "original.jpg"
assert media.mime_type == "image/jpeg"
assert media.size == 9
assert media.title == "Recovered"
assert media.alt == "Recovered alt"
assert media.caption == "Recovered caption"
assert media.author == "Writer"
assert media.language == "en"
assert media.tags == ["alpha"]
assert media.file_path == "media/2026/04/asset.txt"
assert media.sidecar_path == "media/2026/04/asset.txt.meta"
assert media.file_path == "media/2026/04/asset.jpg"
assert media.sidecar_path == "media/2026/04/asset.jpg.meta"
[translation] = Repo.all(BDS.Media.Translation)
assert translation.translation_for == "media-from-file"
assert translation.language == "de"
assert translation.title == "Titel"
assert translation.alt == "Alt text"
assert translation.caption == "Bildunterschrift"
thumbnail_paths = BDS.Media.thumbnail_paths(media)
Enum.each(Map.values(thumbnail_paths), fn path ->
assert File.exists?(Path.join(temp_dir, path))
end)
end
test "import_media generates the four thumbnail files in bucketed thumbnail paths", %{project: project, temp_dir: temp_dir} do
source_path = Path.join(temp_dir, "sample.jpg")
File.write!(source_path, "fake-jpeg")
assert {:ok, media} = BDS.Media.import_media(%{project_id: project.id, source_path: source_path})
thumbnail_paths = BDS.Media.thumbnail_paths(media)
assert thumbnail_paths.small == "thumbnails/#{String.slice(media.id, 0, 2)}/#{media.id}-small.webp"
assert thumbnail_paths.medium == "thumbnails/#{String.slice(media.id, 0, 2)}/#{media.id}-medium.webp"
assert thumbnail_paths.large == "thumbnails/#{String.slice(media.id, 0, 2)}/#{media.id}-large.webp"
assert thumbnail_paths.ai == "thumbnails/#{String.slice(media.id, 0, 2)}/#{media.id}-ai.jpg"
Enum.each(Map.values(thumbnail_paths), fn path ->
assert File.exists?(Path.join(temp_dir, path))
end)
end
test "upsert_media_translation persists the row and writes a translated sidecar next to the binary", %{project: project, temp_dir: temp_dir} do
source_path = Path.join(temp_dir, "sample.txt")
File.write!(source_path, "hello media")
assert {:ok, media} = BDS.Media.import_media(%{project_id: project.id, source_path: source_path})
assert {:ok, translation} =
BDS.Media.upsert_media_translation(media.id, "de", %{
title: "Titel",
alt: "Alt text",
caption: "Bildunterschrift"
})
assert translation.translation_for == media.id
assert translation.language == "de"
assert translation.title == "Titel"
translated_sidecar_path = Path.join(temp_dir, media.file_path <> ".de.meta")
contents = File.read!(translated_sidecar_path)
assert contents =~ "translation_for: #{media.id}\n"
assert contents =~ "language: de\n"
assert contents =~ "title: Titel\n"
assert contents =~ "alt: Alt text\n"
assert contents =~ "caption: Bildunterschrift\n"
end
end