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

chore: and the next god module down

Browse Source
This commit is contained in:
Chili Palmer
2026-05-01 11:48:56 +02:00
parent 96402bb4f3
commit 753f742b99
7 changed files with 910 additions and 721 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
CODESMELL.md
View File

@@ -2,7 +2,7 @@
Living document. Each section lists **status**, then **open work in priority order**, then a brief notes block. Completed work is listed compactly at the bottom (`## Changelog`). Living document. Each section lists **status**, then **open work in priority order**, then a brief notes block. Completed work is listed compactly at the bottom (`## Changelog`).
Last refreshed: 2026-05-01. Last refreshed: 2026-05-02.
--- ---
@@ -14,7 +14,6 @@ Last refreshed: 2026-05-01.
| # | Module | Current lines | Target | Strategy | | # | Module | Current lines | Target | Strategy |
|---|---|---|---|---| |---|---|---|---|---|
| 1 | `BDS.Media` | 993 | ≤ 250 | Extract `Thumbnails` (~140), `Sidecars` (~150), `FileOps` (~180), `Rebuild` (~130), `Linking` (~80). Main keeps CRUD + translation API. |
| 3 | `BDS.Desktop.ShellLive.ImportEditor` | 1436 | ≤ 600 | Extract `ConflictResolution` (~150), `TaxonomyEditing` (~120), `AnalysisState` (~150), `ProgressTracking` (~120). Components stay in main file. | | 3 | `BDS.Desktop.ShellLive.ImportEditor` | 1436 | ≤ 600 | Extract `ConflictResolution` (~150), `TaxonomyEditing` (~120), `AnalysisState` (~150), `ProgressTracking` (~120). Components stay in main file. |
| 4 | `BDS.Rendering` | 838 | ≤ 200 | Extract `TemplateSelection` (~120), `PostRendering` (~180), `ListArchive` (~150), `Metadata` (~140), `LinksAndLanguages` (~100). Main keeps the 3 public renders. | | 4 | `BDS.Rendering` | 838 | ≤ 200 | Extract `TemplateSelection` (~120), `PostRendering` (~180), `ListArchive` (~150), `Metadata` (~140), `LinksAndLanguages` (~100). Main keeps the 3 public renders. |
| 5 | `BDS.Desktop.ShellLive.MenuEditor` | 871 | ≤ 350 | Extract `TreeOps` (~280), `TreePredicates` (~60), `DraftManagement` (~140), `PageCategory` (~120), `State` (~80). | | 5 | `BDS.Desktop.ShellLive.MenuEditor` | 871 | ≤ 350 | Extract `TreeOps` (~280), `TreePredicates` (~60), `DraftManagement` (~140), `PageCategory` (~120), `State` (~80). |
@@ -33,6 +32,7 @@ Last refreshed: 2026-05-01.
- `BDS.Posts` 1781 → 569 (68 %) - `BDS.Posts` 1781 → 569 (68 %)
- `BDS.Desktop.ShellLive` 2607 → 1545 (41 %) - `BDS.Desktop.ShellLive` 2607 → 1545 (41 %)
- `BDS.Maintenance` 810 → 141 (83 %) - `BDS.Maintenance` 810 → 141 (83 %)
- `BDS.Media` 993 → 324 (67 %)
--- ---
@@ -166,6 +166,13 @@ Most tests share the SQLite repo and named GenServers (`BDS.Tasks`, `BDS.Search`
## Changelog ## Changelog
### 2026-05-02
### 2026-05-02
- **God modules**:
- `BDS.Media` 993 → 324 (67 %). Submodules under `lib/bds/media/`: `FileOps` (150, attr/maybe_put/blank_to_nil/atomic_write/delete_file_if_present/list_matching_files/media_file_path/detect_mime/image_dimensions/image_mime?/progress callbacks), `Thumbnails` (165, thumbnail_paths/regenerate_thumbnails/regenerate_missing_thumbnails/ensure_thumbnails/delete_thumbnail_files + private render/write helpers), `Sidecars` (329, write_sidecar/write_translation_sidecar/parse_canonical_sidecar/parse_translation_sidecar/upsert_media_from_sidecar/upsert_translation_from_sidecar + sync/import-orphan public API + translation_sidecar_path/canonical_sidecar?/translation_sidecar?/binary_path_for_translation_sidecar/binary_exists_for_sidecar?), `Linking` (125, list_linked_posts/link_media_to_post/unlink_media_from_post/linked_post_ids), `Rebuilder` (82, rebuild_media_from_files/2). Public API preserved via `defdelegate`; coordinator keeps import_media/update_media/delete_media/upsert_media_translation/delete_media_translation/replace_media_file/list_media_translations and uses `import only:` for shared helpers.
### 2026-05-01 ### 2026-05-01
- **God modules**: - **God modules**:

769
lib/bds/media.ex
View File

@@ -1,18 +1,37 @@
defmodule BDS.Media do defmodule BDS.Media do
@moduledoc false @moduledoc false
import BDS.Media.FileOps,
only: [
attr: 2,
delete_file_if_present: 2,
detect_mime: 1,
image_dimensions: 2,
maybe_put: 3,
media_file_path: 2
]
import BDS.Media.Sidecars,
only: [
translation_sidecar_path: 2,
write_sidecar: 2,
write_translation_sidecar: 3
]
import BDS.Media.Thumbnails,
only: [
delete_thumbnail_files: 2,
ensure_thumbnails: 2
]
import Ecto.Query import Ecto.Query
alias BDS.DocumentFields
alias BDS.Media.Media alias BDS.Media.Media
alias BDS.Media.Translation alias BDS.Media.Translation
alias BDS.Persistence alias BDS.Persistence
alias BDS.Posts.PostMedia
alias BDS.Projects alias BDS.Projects
alias BDS.Rebuild
alias BDS.Repo alias BDS.Repo
alias BDS.Search alias BDS.Search
alias BDS.Sidecar
@typedoc "An attribute map that may use atom or string keys." @typedoc "An attribute map that may use atom or string keys."
@type attrs :: %{optional(atom()) => term(), optional(String.t()) => term()} @type attrs :: %{optional(atom()) => term(), optional(String.t()) => term()}
@@ -20,6 +39,28 @@ defmodule BDS.Media do
@typedoc "Options accepted by long-running rebuild operations." @typedoc "Options accepted by long-running rebuild operations."
@type rebuild_opts :: keyword() @type rebuild_opts :: keyword()
# Public API delegations to submodules
defdelegate thumbnail_paths(media), to: BDS.Media.Thumbnails
defdelegate regenerate_thumbnails(media_id), to: BDS.Media.Thumbnails
defdelegate regenerate_missing_thumbnails(project_id), to: BDS.Media.Thumbnails
defdelegate regenerate_missing_thumbnails(project_id, opts), to: BDS.Media.Thumbnails
defdelegate sync_media_sidecar(media_id), to: BDS.Media.Sidecars
defdelegate sync_media_from_sidecar(media_id), to: BDS.Media.Sidecars
defdelegate sync_media_translation_sidecar(translation_id), to: BDS.Media.Sidecars
defdelegate sync_media_translation_from_sidecar(translation_id), to: BDS.Media.Sidecars
defdelegate import_orphan_media_sidecar(project_id, relative_path), to: BDS.Media.Sidecars
defdelegate import_orphan_media_translation_sidecar(project_id, relative_path),
to: BDS.Media.Sidecars
defdelegate list_linked_posts(media_id), to: BDS.Media.Linking
defdelegate link_media_to_post(media_id, post_id), to: BDS.Media.Linking
defdelegate unlink_media_from_post(media_id, post_id), to: BDS.Media.Linking
defdelegate rebuild_media_from_files(project_id), to: BDS.Media.Rebuilder
defdelegate rebuild_media_from_files(project_id, opts), to: BDS.Media.Rebuilder
@spec import_media(attrs()) :: {:ok, Media.t()} | {:error, Ecto.Changeset.t() | term()} @spec import_media(attrs()) :: {:ok, Media.t()} | {:error, Ecto.Changeset.t() | term()}
def import_media(attrs) do def import_media(attrs) do
project = Projects.get_project!(attr(attrs, :project_id)) project = Projects.get_project!(attr(attrs, :project_id))
@@ -112,129 +153,6 @@ defmodule BDS.Media do
end end
end end
@spec sync_media_sidecar(String.t()) :: :ok | {:error, :not_found | term()}
def sync_media_sidecar(media_id) do
case Repo.get(Media, media_id) do
nil ->
{:error, :not_found}
media ->
project = Projects.get_project!(media.project_id)
:ok = write_sidecar(project, media)
:ok
end
end
@spec sync_media_from_sidecar(String.t()) ::
{:ok, Media.t()} | {:error, :not_found | term()}
def sync_media_from_sidecar(media_id) do
case Repo.get(Media, media_id) do
nil ->
{:error, :not_found}
%Media{} = media ->
project = Projects.get_project!(media.project_id)
sidecar_path = Path.join(Projects.project_data_dir(project), media.sidecar_path)
if File.exists?(sidecar_path) do
{:ok, upsert_media_from_sidecar(project, parse_canonical_sidecar(project, sidecar_path), sync_search: true)}
else
{:error, :not_found}
end
end
end
@spec sync_media_translation_sidecar(String.t()) ::
{:ok, Translation.t()} | {:error, :not_found | term()}
def sync_media_translation_sidecar(translation_id) do
case Repo.get(Translation, translation_id) do
nil ->
{:error, :not_found}
%Translation{} = translation ->
media = Repo.get!(Media, translation.translation_for)
project = Projects.get_project!(media.project_id)
:ok = write_translation_sidecar(project, media, translation)
{:ok, translation}
end
end
@spec sync_media_translation_from_sidecar(String.t()) ::
{:ok, Translation.t()} | {:error, :not_found | term()}
def sync_media_translation_from_sidecar(translation_id) do
case Repo.get(Translation, translation_id) do
nil ->
{:error, :not_found}
%Translation{} = translation ->
media = Repo.get!(Media, translation.translation_for)
project = Projects.get_project!(media.project_id)
sidecar_path = Path.join(Projects.project_data_dir(project), translation_sidecar_path(media, translation.language))
if File.exists?(sidecar_path) do
sidecar = parse_translation_sidecar(sidecar_path)
case upsert_media_translation(media.id, DocumentFields.fetch!(sidecar.fields, "language"), %{
title: DocumentFields.get(sidecar.fields, "title"),
alt: DocumentFields.get(sidecar.fields, "alt"),
caption: DocumentFields.get(sidecar.fields, "caption")
}) do
{:ok, updated_translation} -> {:ok, updated_translation}
error -> error
end
else
{:error, :not_found}
end
end
end
@spec import_orphan_media_sidecar(String.t(), String.t()) ::
{:ok, Media.t()} | {:error, term()}
def import_orphan_media_sidecar(project_id, relative_path) do
project = Projects.get_project!(project_id)
sidecar_path = Path.join(Projects.project_data_dir(project), relative_path)
if File.exists?(sidecar_path) do
{:ok, upsert_media_from_sidecar(project, parse_canonical_sidecar(project, sidecar_path), sync_search: true)}
else
{:error, :not_found}
end
end
@spec import_orphan_media_translation_sidecar(String.t(), String.t()) ::
{:ok, Translation.t()} | {:error, term()}
def import_orphan_media_translation_sidecar(project_id, relative_path) do
project = Projects.get_project!(project_id)
sidecar_path = Path.join(Projects.project_data_dir(project), relative_path)
if File.exists?(sidecar_path) do
sidecar = parse_translation_sidecar(sidecar_path)
case Repo.get(Media, DocumentFields.get(sidecar.fields, "translationFor")) do
nil ->
{:error, :not_found}
media ->
case Repo.get_by(Translation,
translation_for: media.id,
language: DocumentFields.fetch!(sidecar.fields, "language")
) do
nil ->
upsert_media_translation(media.id, DocumentFields.fetch!(sidecar.fields, "language"), %{
title: DocumentFields.get(sidecar.fields, "title"),
alt: DocumentFields.get(sidecar.fields, "alt"),
caption: DocumentFields.get(sidecar.fields, "caption")
})
_translation ->
{:error, :conflict}
end
end
else
{:error, :not_found}
end
end
@spec delete_media(String.t()) :: {:ok, :deleted} | {:error, :not_found} @spec delete_media(String.t()) :: {:ok, :deleted} | {:error, :not_found}
def delete_media(media_id) do def delete_media(media_id) do
case Repo.get(Media, media_id) do case Repo.get(Media, media_id) do
@@ -328,7 +246,11 @@ defmodule BDS.Media do
case Repo.transaction(fn -> Repo.delete!(translation) end) do case Repo.transaction(fn -> Repo.delete!(translation) end) do
{:ok, _deleted} -> {:ok, _deleted} ->
delete_file_if_present(media.project_id, translation_sidecar_path(media, normalized_language)) delete_file_if_present(
media.project_id,
translation_sidecar_path(media, normalized_language)
)
:ok = Search.sync_media(media) :ok = Search.sync_media(media)
:ok = write_sidecar(project, media) :ok = write_sidecar(project, media)
{:ok, true} {:ok, true}
@@ -399,595 +321,4 @@ defmodule BDS.Media do
order_by: [asc: translation.language] order_by: [asc: translation.language]
) )
end end
@spec list_linked_posts(String.t()) :: [%{post_id: String.t(), title: String.t(), sort_order: integer()}]
def list_linked_posts(media_id) when is_binary(media_id) do
Repo.all(
from post in BDS.Posts.Post,
join: pm in PostMedia,
on: pm.post_id == post.id,
where: pm.media_id == ^media_id,
order_by: [asc: pm.sort_order, asc: post.updated_at],
select: %{
post_id: post.id,
title: fragment("COALESCE(?, ?, ?)", post.title, post.slug, post.id),
sort_order: pm.sort_order
}
)
end
@spec link_media_to_post(String.t(), String.t()) ::
{:ok, :linked} | {:error, :not_found | term()}
def link_media_to_post(media_id, post_id) when is_binary(media_id) and is_binary(post_id) do
case {Repo.get(Media, media_id), Repo.get(BDS.Posts.Post, post_id)} do
{nil, _post} ->
{:error, :not_found}
{_media, nil} ->
{:error, :not_found}
{%Media{} = media, %BDS.Posts.Post{} = post} ->
project = Projects.get_project!(media.project_id)
case Repo.transaction(fn ->
if Repo.exists?(from pm in PostMedia, where: pm.post_id == ^post.id and pm.media_id == ^media.id) do
:already_linked
else
sort_order = next_sort_order(media.id)
%PostMedia{}
|> PostMedia.changeset(%{
id: Ecto.UUID.generate(),
project_id: media.project_id,
post_id: post.id,
media_id: media.id,
sort_order: sort_order,
created_at: Persistence.now_ms()
})
|> Repo.insert!()
:linked
end
end) do
{:ok, _result} ->
:ok = write_sidecar(project, media)
{:ok, :linked}
{:error, reason} ->
{:error, reason}
end
end
end
@spec unlink_media_from_post(String.t(), String.t()) ::
{:ok, :unlinked} | {:error, :not_found | term()}
def unlink_media_from_post(media_id, post_id) when is_binary(media_id) and is_binary(post_id) do
case Repo.get(Media, media_id) do
nil ->
{:error, :not_found}
%Media{} = media ->
project = Projects.get_project!(media.project_id)
case Repo.transaction(fn ->
{_count, _} =
Repo.delete_all(
from pm in PostMedia, where: pm.media_id == ^media.id and pm.post_id == ^post_id
)
:ok
end) do
{:ok, :ok} ->
:ok = write_sidecar(project, media)
{:ok, :unlinked}
{:error, reason} ->
{:error, reason}
end
end
end
@spec thumbnail_paths(Media.t()) :: %{required(atom()) => String.t()}
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
@spec regenerate_thumbnails(String.t()) :: {:ok, Media.t()} | {:error, :not_found | term()}
def regenerate_thumbnails(media_id) do
case Repo.get(Media, media_id) do
nil ->
{:error, :not_found}
media ->
project = Projects.get_project!(media.project_id)
:ok = ensure_thumbnails(project, media)
{:ok, media}
end
end
@spec regenerate_missing_thumbnails(String.t(), rebuild_opts()) ::
%{processed: non_neg_integer(), generated: non_neg_integer(), failed: non_neg_integer()}
def regenerate_missing_thumbnails(project_id, opts \\ []) do
project = Projects.get_project!(project_id)
on_progress = progress_callback(opts)
media_items =
Repo.all(
from(media in Media,
where: media.project_id == ^project_id,
order_by: [asc: media.created_at]
)
)
|> Enum.filter(fn media ->
String.starts_with?(media.mime_type || "", "image/") and
not String.contains?(media.mime_type || "", "svg")
end)
total_media = length(media_items)
:ok = report_rebuild_started(on_progress, total_media, "image assets")
media_items
|> Enum.with_index(1)
|> Enum.reduce(%{processed: 0, generated: 0, failed: 0}, fn {media, index}, acc ->
missing_paths =
media
|> thumbnail_paths()
|> Enum.map(fn {_size, relative_path} -> Path.join(Projects.project_data_dir(project), relative_path) end)
|> Enum.reject(&File.exists?/1)
next_acc =
if missing_paths == [] do
%{acc | processed: acc.processed + 1}
else
try do
:ok = ensure_thumbnails(project, media)
%{
processed: acc.processed + 1,
generated: acc.generated + length(missing_paths),
failed: acc.failed
}
rescue
_error ->
%{acc | processed: acc.processed + 1, failed: acc.failed + 1}
end
end
:ok = report_rebuild_progress(on_progress, index, total_media, "image assets")
next_acc
end)
end
@spec rebuild_media_from_files(String.t(), rebuild_opts()) :: {:ok, [Media.t()]}
def rebuild_media_from_files(project_id, opts \\ []) do
project = Projects.get_project!(project_id)
on_progress = progress_callback(opts)
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)
|> Rebuild.parallel_map(&parse_canonical_sidecar(project, &1))
translation_sidecars =
project
|> Projects.project_data_dir()
|> Path.join("media")
|> list_matching_files("*.meta")
|> Enum.filter(&translation_sidecar?/1)
|> Rebuild.parallel_map(&parse_translation_sidecar(&1))
total_files = length(canonical_sidecars) + length(translation_sidecars)
:ok = report_rebuild_started(on_progress, total_files, "media files")
media_items =
canonical_sidecars
|> Enum.with_index(1)
|> Enum.map(fn {sidecar, index} ->
media = upsert_media_from_sidecar(project, sidecar, sync_search: false)
:ok = report_rebuild_progress(on_progress, index, total_files, "media files")
media
end)
canonical_media_by_binary_path =
Map.new(media_items, fn media ->
{Path.join(Projects.project_data_dir(project), media.file_path), media}
end)
translation_sidecars
|> Enum.with_index(length(canonical_sidecars) + 1)
|> Enum.each(fn {sidecar, index} ->
upsert_translation_from_sidecar(project, canonical_media_by_binary_path, sidecar, sync_search: false)
:ok = report_rebuild_progress(on_progress, index, total_files, "media files")
end)
if Keyword.get(opts, :reindex_search, true) do
:ok = report_rebuild_phase(on_progress, 0.99, "Refreshing media search index")
:ok =
Search.reindex_media(project.id,
on_progress: scaled_progress_reporter(on_progress, 0.99, 1.0)
)
end
{:ok, media_items}
end
defp upsert_media_from_sidecar(project, sidecar, opts) do
now = Persistence.now_ms()
attrs = %{
id: DocumentFields.get(sidecar.fields, "id") || Ecto.UUID.generate(),
project_id: project.id,
filename: sidecar.filename,
original_name: DocumentFields.get(sidecar.fields, "originalName") || sidecar.filename,
mime_type: DocumentFields.get(sidecar.fields, "mimeType") || detect_mime(sidecar.filename),
size: DocumentFields.get(sidecar.fields, "size", 0),
width: blank_to_nil(DocumentFields.get(sidecar.fields, "width")),
height: blank_to_nil(DocumentFields.get(sidecar.fields, "height")),
title: DocumentFields.get(sidecar.fields, "title"),
alt: DocumentFields.get(sidecar.fields, "alt"),
caption: DocumentFields.get(sidecar.fields, "caption"),
author: DocumentFields.get(sidecar.fields, "author"),
language: DocumentFields.get(sidecar.fields, "language"),
file_path: sidecar.relative_file_path,
sidecar_path: sidecar.relative_sidecar_path,
checksum: nil,
tags: DocumentFields.get(sidecar.fields, "tags", []),
created_at: DocumentFields.get(sidecar.fields, "createdAt", now),
updated_at: DocumentFields.get(sidecar.fields, "updatedAt", now)
}
media =
Repo.get(Media, attrs.id) ||
Repo.get_by(Media, project_id: project.id, file_path: sidecar.relative_file_path) || %Media{}
media =
media
|> Media.changeset(attrs)
|> Repo.insert_or_update!()
if Keyword.get(opts, :sync_search, true) do
:ok = Search.sync_media(media)
end
media
end
defp write_sidecar(project, media) do
path = Path.join(Projects.project_data_dir(project), media.sidecar_path)
:ok = File.mkdir_p(Path.dirname(path))
atomic_write(
path,
Sidecar.serialize_document([
{"id", media.id},
{"originalName", media.original_name},
{"mimeType", media.mime_type},
{"size", media.size},
{"width", media.width},
{"height", media.height},
{"title", media.title},
{"alt", media.alt},
{"caption", media.caption},
{"author", media.author},
{"language", media.language},
{"createdAt", media.created_at},
{"updatedAt", media.updated_at},
{"linkedPostIds", linked_post_ids(media.id)},
{"tags", media.tags || []}
])
)
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([
{"translationFor", 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, opts) do
case Map.get(canonical_media_by_binary_path, sidecar.binary_path) do
nil ->
:skip
media ->
now = Persistence.now_ms()
language = DocumentFields.fetch!(sidecar.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: DocumentFields.get(sidecar.fields, "title"),
alt: DocumentFields.get(sidecar.fields, "alt"),
caption: DocumentFields.get(sidecar.fields, "caption"),
created_at: translation.created_at || now,
updated_at: now
})
|> Repo.insert_or_update!()
if Keyword.get(opts, :sync_search, true) do
:ok = Search.sync_media(media.id)
end
end
end
defp parse_canonical_sidecar(project, sidecar_path) do
{:ok, fields} = sidecar_path |> File.read!() |> Sidecar.parse_document()
relative_sidecar_path = Path.relative_to(sidecar_path, Projects.project_data_dir(project))
relative_file_path = String.trim_trailing(relative_sidecar_path, ".meta")
%{
fields: fields,
relative_sidecar_path: relative_sidecar_path,
relative_file_path: relative_file_path,
filename: Path.basename(relative_file_path)
}
end
defp parse_translation_sidecar(sidecar_path) do
{:ok, fields} = sidecar_path |> File.read!() |> Sidecar.parse_document()
%{
fields: fields,
binary_path: binary_path_for_translation_sidecar(sidecar_path)
}
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)
case Image.open(source_path) do
{:ok, image} ->
image
|> Image.autorotate!()
|> write_all_thumbnails(project, media)
{:error, _reason} ->
:ok
end
end
:ok
end
defp write_all_thumbnails(image, project, media) do
thumbnail_paths(media)
|> Enum.each(fn {size, relative_path} ->
destination = Path.join(Projects.project_data_dir(project), relative_path)
:ok = File.mkdir_p(Path.dirname(destination))
image
|> render_thumbnail(size)
|> write_thumbnail(destination, size)
end)
:ok
end
defp render_thumbnail(image, :small), do: bounded_thumbnail(image, 150, 150)
defp render_thumbnail(image, :medium), do: bounded_thumbnail(image, 400, 400)
defp render_thumbnail(image, :large), do: bounded_thumbnail(image, 800, 800)
defp render_thumbnail(image, :ai) do
image
|> Image.thumbnail!("448x448", fit: :contain, resize: :both, autorotate: false)
|> Image.embed!(448, 448, x: :center, y: :center, background_color: :black)
end
defp bounded_thumbnail(image, width, height) do
Image.thumbnail!(image, "#{width}x#{height}", fit: :contain, resize: :down, autorotate: false)
end
defp write_thumbnail(image, destination, :ai) do
flattened = Image.flatten!(image, background_color: :black)
Image.write!(flattened, destination, quality: 85, strip_metadata: true)
:ok
end
defp write_thumbnail(image, destination, _size) do
Image.write!(image, destination, quality: 80, strip_metadata: true)
: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 = Persistence.from_unix_ms!(timestamp)
year = Integer.to_string(datetime.year)
month = datetime.month |> Integer.to_string() |> String.pad_leading(2, "0")
Path.join(["media", year, month, file_name])
end
defp detect_mime(file_name) do
case String.downcase(Path.extname(file_name)) do
".txt" -> "text/plain"
".md" -> "text/markdown"
".jpg" -> "image/jpeg"
".jpeg" -> "image/jpeg"
".png" -> "image/png"
".gif" -> "image/gif"
".webp" -> "image/webp"
".tif" -> "image/tiff"
".tiff" -> "image/tiff"
".bmp" -> "image/bmp"
".heic" -> "image/heic"
".heif" -> "image/heif"
_ -> "application/octet-stream"
end
end
defp image_dimensions(source_path, mime_type) do
if image_mime?(mime_type) do
case Image.open(source_path) do
{:ok, image} -> {Image.width(image), Image.height(image)}
{:error, _reason} -> {nil, nil}
end
else
{nil, nil}
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")
|> File.exists?()
end
defp list_matching_files(dir, pattern) do
if File.dir?(dir) do
Path.join([dir, "**", pattern])
|> Path.wildcard()
|> Enum.sort()
else
[]
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)
case File.rm(full_path) do
:ok -> :ok
{:error, :enoent} -> :ok
{:error, reason} -> {:error, reason}
end
end
defp atomic_write(path, contents) do
Persistence.atomic_write(path, contents)
end
defp linked_post_ids(media_id) do
Repo.all(
from pm in PostMedia,
where: pm.media_id == ^media_id,
order_by: [asc: pm.sort_order, asc: pm.post_id],
select: pm.post_id
)
end
defp next_sort_order(media_id) do
case Repo.one(
from pm in PostMedia,
where: pm.media_id == ^media_id,
select: max(pm.sort_order)
) do
value when is_integer(value) -> value + 1
_other -> 0
end
end
defp blank_to_nil(nil), do: nil
defp blank_to_nil(""), do: nil
defp blank_to_nil(value), do: value
defp maybe_put(map, _key, nil), do: map
defp maybe_put(map, key, value), do: Map.put(map, key, value)
defp attr(attrs, key) do
cond do
Map.has_key?(attrs, key) -> Map.get(attrs, key)
Map.has_key?(attrs, Atom.to_string(key)) -> Map.get(attrs, Atom.to_string(key))
true -> nil
end
end
defp progress_callback(opts) do
case Keyword.get(opts, :on_progress) do
callback when is_function(callback, 2) -> callback
_other -> nil
end
end
defp scaled_progress_reporter(nil, _start_value, _end_value), do: nil
defp scaled_progress_reporter(report, start_value, end_value) when is_function(report, 2) do
fn value, message ->
scaled_value = start_value + (end_value - start_value) * value
report.(scaled_value, message)
end
end
defp report_rebuild_started(nil, _total, _label), do: :ok
defp report_rebuild_started(callback, 0, label) do
callback.(1.0, "No #{label} found")
:ok
end
defp report_rebuild_started(callback, total, label) do
callback.(0.05, "Rebuilding #{label} (0/#{total})")
:ok
end
defp report_rebuild_progress(nil, _current, _total, _label), do: :ok
defp report_rebuild_progress(_callback, _current, 0, _label), do: :ok
defp report_rebuild_progress(callback, current, total, label) do
callback.(0.05 + 0.95 * (current / total), "Rebuilding #{label} (#{current}/#{total})")
:ok
end
defp report_rebuild_phase(nil, _progress, _message), do: :ok
defp report_rebuild_phase(callback, progress, message) do
callback.(progress, message)
:ok
end
end end

150
lib/bds/media/file_ops.ex Normal file
View File

@@ -0,0 +1,150 @@
defmodule BDS.Media.FileOps do
@moduledoc false
alias BDS.Persistence
alias BDS.Projects
@typedoc "An attribute map that may use atom or string keys."
@type attrs :: %{optional(atom()) => term(), optional(String.t()) => term()}
@spec attr(attrs(), atom()) :: term()
def attr(attrs, key) do
cond do
Map.has_key?(attrs, key) -> Map.get(attrs, key)
Map.has_key?(attrs, Atom.to_string(key)) -> Map.get(attrs, Atom.to_string(key))
true -> nil
end
end
@spec maybe_put(map(), atom(), term()) :: map()
def maybe_put(map, _key, nil), do: map
def maybe_put(map, key, value), do: Map.put(map, key, value)
@spec blank_to_nil(term()) :: term()
def blank_to_nil(nil), do: nil
def blank_to_nil(""), do: nil
def blank_to_nil(value), do: value
@spec atomic_write(Path.t(), iodata()) :: :ok | {:error, term()}
def atomic_write(path, contents), do: Persistence.atomic_write(path, contents)
@spec delete_file_if_present(String.t(), Path.t()) :: :ok | {:error, term()}
def 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)
case File.rm(full_path) do
:ok -> :ok
{:error, :enoent} -> :ok
{:error, reason} -> {:error, reason}
end
end
@spec list_matching_files(Path.t(), String.t()) :: [Path.t()]
def list_matching_files(dir, pattern) do
if File.dir?(dir) do
Path.join([dir, "**", pattern])
|> Path.wildcard()
|> Enum.sort()
else
[]
end
end
@spec media_file_path(String.t(), integer()) :: Path.t()
def media_file_path(file_name, timestamp) do
datetime = Persistence.from_unix_ms!(timestamp)
year = Integer.to_string(datetime.year)
month = datetime.month |> Integer.to_string() |> String.pad_leading(2, "0")
Path.join(["media", year, month, file_name])
end
@spec detect_mime(String.t()) :: String.t()
def detect_mime(file_name) do
case String.downcase(Path.extname(file_name)) do
".txt" -> "text/plain"
".md" -> "text/markdown"
".jpg" -> "image/jpeg"
".jpeg" -> "image/jpeg"
".png" -> "image/png"
".gif" -> "image/gif"
".webp" -> "image/webp"
".tif" -> "image/tiff"
".tiff" -> "image/tiff"
".bmp" -> "image/bmp"
".heic" -> "image/heic"
".heif" -> "image/heif"
_ -> "application/octet-stream"
end
end
@spec image_dimensions(Path.t(), String.t() | nil) ::
{non_neg_integer() | nil, non_neg_integer() | nil}
def image_dimensions(source_path, mime_type) do
if image_mime?(mime_type) do
case Image.open(source_path) do
{:ok, image} -> {Image.width(image), Image.height(image)}
{:error, _reason} -> {nil, nil}
end
else
{nil, nil}
end
end
@spec image_mime?(String.t() | nil) :: boolean()
def image_mime?(mime_type), do: String.starts_with?(mime_type || "", "image/")
@spec progress_callback(keyword()) :: (float(), String.t() -> any()) | nil
def progress_callback(opts) do
case Keyword.get(opts, :on_progress) do
callback when is_function(callback, 2) -> callback
_other -> nil
end
end
@spec scaled_progress_reporter((float(), String.t() -> any()) | nil, float(), float()) ::
(float(), String.t() -> any()) | nil
def scaled_progress_reporter(nil, _start_value, _end_value), do: nil
def scaled_progress_reporter(report, start_value, end_value) when is_function(report, 2) do
fn value, message ->
scaled_value = start_value + (end_value - start_value) * value
report.(scaled_value, message)
end
end
@spec report_rebuild_started((float(), String.t() -> any()) | nil, non_neg_integer(), String.t()) :: :ok
def report_rebuild_started(nil, _total, _label), do: :ok
def report_rebuild_started(callback, 0, label) do
callback.(1.0, "No #{label} found")
:ok
end
def report_rebuild_started(callback, total, label) do
callback.(0.05, "Rebuilding #{label} (0/#{total})")
:ok
end
@spec report_rebuild_progress(
(float(), String.t() -> any()) | nil,
non_neg_integer(),
non_neg_integer(),
String.t()
) :: :ok
def report_rebuild_progress(nil, _current, _total, _label), do: :ok
def report_rebuild_progress(_callback, _current, 0, _label), do: :ok
def report_rebuild_progress(callback, current, total, label) do
callback.(0.05 + 0.95 * (current / total), "Rebuilding #{label} (#{current}/#{total})")
:ok
end
@spec report_rebuild_phase((float(), String.t() -> any()) | nil, float(), String.t()) :: :ok
def report_rebuild_phase(nil, _progress, _message), do: :ok
def report_rebuild_phase(callback, progress, message) do
callback.(progress, message)
:ok
end
end

125
lib/bds/media/linking.ex Normal file
View File

@@ -0,0 +1,125 @@
defmodule BDS.Media.Linking do
@moduledoc false
import Ecto.Query
alias BDS.Media.Media
alias BDS.Media.Sidecars
alias BDS.Persistence
alias BDS.Posts.PostMedia
alias BDS.Projects
alias BDS.Repo
@spec list_linked_posts(String.t()) ::
[%{post_id: String.t(), title: String.t(), sort_order: integer()}]
def list_linked_posts(media_id) when is_binary(media_id) do
Repo.all(
from post in BDS.Posts.Post,
join: pm in PostMedia,
on: pm.post_id == post.id,
where: pm.media_id == ^media_id,
order_by: [asc: pm.sort_order, asc: post.updated_at],
select: %{
post_id: post.id,
title: fragment("COALESCE(?, ?, ?)", post.title, post.slug, post.id),
sort_order: pm.sort_order
}
)
end
@spec link_media_to_post(String.t(), String.t()) ::
{:ok, :linked} | {:error, :not_found | term()}
def link_media_to_post(media_id, post_id) when is_binary(media_id) and is_binary(post_id) do
case {Repo.get(Media, media_id), Repo.get(BDS.Posts.Post, post_id)} do
{nil, _post} ->
{:error, :not_found}
{_media, nil} ->
{:error, :not_found}
{%Media{} = media, %BDS.Posts.Post{} = post} ->
project = Projects.get_project!(media.project_id)
case Repo.transaction(fn ->
if Repo.exists?(
from pm in PostMedia,
where: pm.post_id == ^post.id and pm.media_id == ^media.id
) do
:already_linked
else
sort_order = next_sort_order(media.id)
%PostMedia{}
|> PostMedia.changeset(%{
id: Ecto.UUID.generate(),
project_id: media.project_id,
post_id: post.id,
media_id: media.id,
sort_order: sort_order,
created_at: Persistence.now_ms()
})
|> Repo.insert!()
:linked
end
end) do
{:ok, _result} ->
:ok = Sidecars.write_sidecar(project, media)
{:ok, :linked}
{:error, reason} ->
{:error, reason}
end
end
end
@spec unlink_media_from_post(String.t(), String.t()) ::
{:ok, :unlinked} | {:error, :not_found | term()}
def unlink_media_from_post(media_id, post_id) when is_binary(media_id) and is_binary(post_id) do
case Repo.get(Media, media_id) do
nil ->
{:error, :not_found}
%Media{} = media ->
project = Projects.get_project!(media.project_id)
case Repo.transaction(fn ->
{_count, _} =
Repo.delete_all(
from pm in PostMedia,
where: pm.media_id == ^media.id and pm.post_id == ^post_id
)
:ok
end) do
{:ok, :ok} ->
:ok = Sidecars.write_sidecar(project, media)
{:ok, :unlinked}
{:error, reason} ->
{:error, reason}
end
end
end
@spec linked_post_ids(String.t()) :: [String.t()]
def linked_post_ids(media_id) do
Repo.all(
from pm in PostMedia,
where: pm.media_id == ^media_id,
order_by: [asc: pm.sort_order, asc: pm.post_id],
select: pm.post_id
)
end
defp next_sort_order(media_id) do
case Repo.one(
from pm in PostMedia,
where: pm.media_id == ^media_id,
select: max(pm.sort_order)
) do
value when is_integer(value) -> value + 1
_other -> 0
end
end
end

82
lib/bds/media/rebuilder.ex Normal file
View File

@@ -0,0 +1,82 @@
defmodule BDS.Media.Rebuilder do
@moduledoc false
import BDS.Media.FileOps,
only: [
list_matching_files: 2,
progress_callback: 1,
report_rebuild_phase: 3,
report_rebuild_progress: 4,
report_rebuild_started: 3,
scaled_progress_reporter: 3
]
alias BDS.Media.Media
alias BDS.Media.Sidecars
alias BDS.Projects
alias BDS.Rebuild
alias BDS.Search
@type rebuild_opts :: keyword()
@spec rebuild_media_from_files(String.t(), rebuild_opts()) :: {:ok, [Media.t()]}
def rebuild_media_from_files(project_id, opts \\ []) do
project = Projects.get_project!(project_id)
on_progress = progress_callback(opts)
canonical_sidecars =
project
|> Projects.project_data_dir()
|> Path.join("media")
|> list_matching_files("*.meta")
|> Enum.filter(&Sidecars.canonical_sidecar?/1)
|> Enum.filter(&Sidecars.binary_exists_for_sidecar?/1)
|> Rebuild.parallel_map(&Sidecars.parse_canonical_sidecar(project, &1))
translation_sidecars =
project
|> Projects.project_data_dir()
|> Path.join("media")
|> list_matching_files("*.meta")
|> Enum.filter(&Sidecars.translation_sidecar?/1)
|> Rebuild.parallel_map(&Sidecars.parse_translation_sidecar(&1))
total_files = length(canonical_sidecars) + length(translation_sidecars)
:ok = report_rebuild_started(on_progress, total_files, "media files")
media_items =
canonical_sidecars
|> Enum.with_index(1)
|> Enum.map(fn {sidecar, index} ->
media = Sidecars.upsert_media_from_sidecar(project, sidecar, sync_search: false)
:ok = report_rebuild_progress(on_progress, index, total_files, "media files")
media
end)
canonical_media_by_binary_path =
Map.new(media_items, fn media ->
{Path.join(Projects.project_data_dir(project), media.file_path), media}
end)
translation_sidecars
|> Enum.with_index(length(canonical_sidecars) + 1)
|> Enum.each(fn {sidecar, index} ->
Sidecars.upsert_translation_from_sidecar(project, canonical_media_by_binary_path, sidecar,
sync_search: false
)
:ok = report_rebuild_progress(on_progress, index, total_files, "media files")
end)
if Keyword.get(opts, :reindex_search, true) do
:ok = report_rebuild_phase(on_progress, 0.99, "Refreshing media search index")
:ok =
Search.reindex_media(project.id,
on_progress: scaled_progress_reporter(on_progress, 0.99, 1.0)
)
end
{:ok, media_items}
end
end

329
lib/bds/media/sidecars.ex Normal file
View File

@@ -0,0 +1,329 @@
defmodule BDS.Media.Sidecars do
@moduledoc false
import BDS.Media.FileOps,
only: [
atomic_write: 2,
blank_to_nil: 1,
detect_mime: 1
]
alias BDS.DocumentFields
alias BDS.Media.Linking
alias BDS.Media.Media
alias BDS.Media.Translation
alias BDS.Persistence
alias BDS.Projects
alias BDS.Repo
alias BDS.Search
alias BDS.Sidecar
@spec write_sidecar(BDS.Projects.Project.t(), Media.t()) :: :ok
def write_sidecar(project, media) do
path = Path.join(Projects.project_data_dir(project), media.sidecar_path)
:ok = File.mkdir_p(Path.dirname(path))
atomic_write(
path,
Sidecar.serialize_document([
{"id", media.id},
{"originalName", media.original_name},
{"mimeType", media.mime_type},
{"size", media.size},
{"width", media.width},
{"height", media.height},
{"title", media.title},
{"alt", media.alt},
{"caption", media.caption},
{"author", media.author},
{"language", media.language},
{"createdAt", media.created_at},
{"updatedAt", media.updated_at},
{"linkedPostIds", Linking.linked_post_ids(media.id)},
{"tags", media.tags || []}
])
)
end
@spec write_translation_sidecar(BDS.Projects.Project.t(), Media.t(), Translation.t()) :: :ok
def 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([
{"translationFor", media.id},
{"language", translation.language},
{"title", translation.title},
{"alt", translation.alt},
{"caption", translation.caption}
])
)
end
@spec parse_canonical_sidecar(BDS.Projects.Project.t(), Path.t()) :: map()
def parse_canonical_sidecar(project, sidecar_path) do
{:ok, fields} = sidecar_path |> File.read!() |> Sidecar.parse_document()
relative_sidecar_path = Path.relative_to(sidecar_path, Projects.project_data_dir(project))
relative_file_path = String.trim_trailing(relative_sidecar_path, ".meta")
%{
fields: fields,
relative_sidecar_path: relative_sidecar_path,
relative_file_path: relative_file_path,
filename: Path.basename(relative_file_path)
}
end
@spec parse_translation_sidecar(Path.t()) :: map()
def parse_translation_sidecar(sidecar_path) do
{:ok, fields} = sidecar_path |> File.read!() |> Sidecar.parse_document()
%{
fields: fields,
binary_path: binary_path_for_translation_sidecar(sidecar_path)
}
end
@spec upsert_media_from_sidecar(BDS.Projects.Project.t(), map(), keyword()) :: Media.t()
def upsert_media_from_sidecar(project, sidecar, opts) do
now = Persistence.now_ms()
attrs = %{
id: DocumentFields.get(sidecar.fields, "id") || Ecto.UUID.generate(),
project_id: project.id,
filename: sidecar.filename,
original_name: DocumentFields.get(sidecar.fields, "originalName") || sidecar.filename,
mime_type: DocumentFields.get(sidecar.fields, "mimeType") || detect_mime(sidecar.filename),
size: DocumentFields.get(sidecar.fields, "size", 0),
width: blank_to_nil(DocumentFields.get(sidecar.fields, "width")),
height: blank_to_nil(DocumentFields.get(sidecar.fields, "height")),
title: DocumentFields.get(sidecar.fields, "title"),
alt: DocumentFields.get(sidecar.fields, "alt"),
caption: DocumentFields.get(sidecar.fields, "caption"),
author: DocumentFields.get(sidecar.fields, "author"),
language: DocumentFields.get(sidecar.fields, "language"),
file_path: sidecar.relative_file_path,
sidecar_path: sidecar.relative_sidecar_path,
checksum: nil,
tags: DocumentFields.get(sidecar.fields, "tags", []),
created_at: DocumentFields.get(sidecar.fields, "createdAt", now),
updated_at: DocumentFields.get(sidecar.fields, "updatedAt", now)
}
media =
Repo.get(Media, attrs.id) ||
Repo.get_by(Media, project_id: project.id, file_path: sidecar.relative_file_path) ||
%Media{}
media =
media
|> Media.changeset(attrs)
|> Repo.insert_or_update!()
if Keyword.get(opts, :sync_search, true) do
:ok = Search.sync_media(media)
end
media
end
@spec upsert_translation_from_sidecar(BDS.Projects.Project.t(), %{required(Path.t()) => Media.t()}, map(), keyword()) ::
Translation.t() | :skip | :ok
def upsert_translation_from_sidecar(project, canonical_media_by_binary_path, sidecar, opts) do
case Map.get(canonical_media_by_binary_path, sidecar.binary_path) do
nil ->
:skip
media ->
now = Persistence.now_ms()
language = DocumentFields.fetch!(sidecar.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: DocumentFields.get(sidecar.fields, "title"),
alt: DocumentFields.get(sidecar.fields, "alt"),
caption: DocumentFields.get(sidecar.fields, "caption"),
created_at: translation.created_at || now,
updated_at: now
})
|> Repo.insert_or_update!()
if Keyword.get(opts, :sync_search, true) do
:ok = Search.sync_media(media.id)
end
end
end
@spec sync_media_sidecar(String.t()) :: :ok | {:error, :not_found | term()}
def sync_media_sidecar(media_id) do
case Repo.get(Media, media_id) do
nil ->
{:error, :not_found}
media ->
project = Projects.get_project!(media.project_id)
:ok = write_sidecar(project, media)
:ok
end
end
@spec sync_media_from_sidecar(String.t()) :: {:ok, Media.t()} | {:error, :not_found | term()}
def sync_media_from_sidecar(media_id) do
case Repo.get(Media, media_id) do
nil ->
{:error, :not_found}
%Media{} = media ->
project = Projects.get_project!(media.project_id)
sidecar_path = Path.join(Projects.project_data_dir(project), media.sidecar_path)
if File.exists?(sidecar_path) do
{:ok, upsert_media_from_sidecar(project, parse_canonical_sidecar(project, sidecar_path), sync_search: true)}
else
{:error, :not_found}
end
end
end
@spec sync_media_translation_sidecar(String.t()) ::
{:ok, Translation.t()} | {:error, :not_found | term()}
def sync_media_translation_sidecar(translation_id) do
case Repo.get(Translation, translation_id) do
nil ->
{:error, :not_found}
%Translation{} = translation ->
media = Repo.get!(Media, translation.translation_for)
project = Projects.get_project!(media.project_id)
:ok = write_translation_sidecar(project, media, translation)
{:ok, translation}
end
end
@spec sync_media_translation_from_sidecar(String.t()) ::
{:ok, Translation.t()} | {:error, :not_found | term()}
def sync_media_translation_from_sidecar(translation_id) do
case Repo.get(Translation, translation_id) do
nil ->
{:error, :not_found}
%Translation{} = translation ->
media = Repo.get!(Media, translation.translation_for)
project = Projects.get_project!(media.project_id)
sidecar_path =
Path.join(
Projects.project_data_dir(project),
translation_sidecar_path(media, translation.language)
)
if File.exists?(sidecar_path) do
sidecar = parse_translation_sidecar(sidecar_path)
case BDS.Media.upsert_media_translation(
media.id,
DocumentFields.fetch!(sidecar.fields, "language"),
%{
title: DocumentFields.get(sidecar.fields, "title"),
alt: DocumentFields.get(sidecar.fields, "alt"),
caption: DocumentFields.get(sidecar.fields, "caption")
}
) do
{:ok, updated_translation} -> {:ok, updated_translation}
error -> error
end
else
{:error, :not_found}
end
end
end
@spec import_orphan_media_sidecar(String.t(), String.t()) ::
{:ok, Media.t()} | {:error, term()}
def import_orphan_media_sidecar(project_id, relative_path) do
project = Projects.get_project!(project_id)
sidecar_path = Path.join(Projects.project_data_dir(project), relative_path)
if File.exists?(sidecar_path) do
{:ok, upsert_media_from_sidecar(project, parse_canonical_sidecar(project, sidecar_path), sync_search: true)}
else
{:error, :not_found}
end
end
@spec import_orphan_media_translation_sidecar(String.t(), String.t()) ::
{:ok, Translation.t()} | {:error, term()}
def import_orphan_media_translation_sidecar(project_id, relative_path) do
project = Projects.get_project!(project_id)
sidecar_path = Path.join(Projects.project_data_dir(project), relative_path)
if File.exists?(sidecar_path) do
sidecar = parse_translation_sidecar(sidecar_path)
case Repo.get(Media, DocumentFields.get(sidecar.fields, "translationFor")) do
nil ->
{:error, :not_found}
media ->
case Repo.get_by(Translation,
translation_for: media.id,
language: DocumentFields.fetch!(sidecar.fields, "language")
) do
nil ->
BDS.Media.upsert_media_translation(
media.id,
DocumentFields.fetch!(sidecar.fields, "language"),
%{
title: DocumentFields.get(sidecar.fields, "title"),
alt: DocumentFields.get(sidecar.fields, "alt"),
caption: DocumentFields.get(sidecar.fields, "caption")
}
)
_translation ->
{:error, :conflict}
end
end
else
{:error, :not_found}
end
end
@spec translation_sidecar_path(Media.t(), String.t()) :: String.t()
def translation_sidecar_path(media, language), do: "#{media.file_path}.#{language}.meta"
@spec canonical_sidecar?(Path.t()) :: boolean()
def canonical_sidecar?(sidecar_path), do: not translation_sidecar?(sidecar_path)
@spec translation_sidecar?(Path.t()) :: boolean()
def translation_sidecar?(sidecar_path) do
Regex.match?(~r/\.[a-z]{2}\.meta$/i, sidecar_path)
end
@spec binary_path_for_translation_sidecar(Path.t()) :: Path.t()
def binary_path_for_translation_sidecar(sidecar_path) do
Regex.replace(~r/\.[a-z]{2}\.meta$/i, sidecar_path, "")
end
@spec binary_exists_for_sidecar?(Path.t()) :: boolean()
def binary_exists_for_sidecar?(sidecar_path) do
sidecar_path
|> String.trim_trailing(".meta")
|> File.exists?()
end
end

165
lib/bds/media/thumbnails.ex Normal file
View File

@@ -0,0 +1,165 @@
defmodule BDS.Media.Thumbnails do
@moduledoc false
import BDS.Media.FileOps,
only: [
delete_file_if_present: 2,
image_mime?: 1,
progress_callback: 1,
report_rebuild_progress: 4,
report_rebuild_started: 3
]
import Ecto.Query
alias BDS.Media.Media
alias BDS.Projects
alias BDS.Repo
@type rebuild_opts :: keyword()
@spec thumbnail_paths(Media.t()) :: %{required(atom()) => String.t()}
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
@spec regenerate_thumbnails(String.t()) :: {:ok, Media.t()} | {:error, :not_found | term()}
def regenerate_thumbnails(media_id) do
case Repo.get(Media, media_id) do
nil ->
{:error, :not_found}
media ->
project = Projects.get_project!(media.project_id)
:ok = ensure_thumbnails(project, media)
{:ok, media}
end
end
@spec regenerate_missing_thumbnails(String.t(), rebuild_opts()) ::
%{processed: non_neg_integer(), generated: non_neg_integer(), failed: non_neg_integer()}
def regenerate_missing_thumbnails(project_id, opts \\ []) do
project = Projects.get_project!(project_id)
on_progress = progress_callback(opts)
media_items =
Repo.all(
from(media in Media,
where: media.project_id == ^project_id,
order_by: [asc: media.created_at]
)
)
|> Enum.filter(fn media ->
String.starts_with?(media.mime_type || "", "image/") and
not String.contains?(media.mime_type || "", "svg")
end)
total_media = length(media_items)
:ok = report_rebuild_started(on_progress, total_media, "image assets")
media_items
|> Enum.with_index(1)
|> Enum.reduce(%{processed: 0, generated: 0, failed: 0}, fn {media, index}, acc ->
missing_paths =
media
|> thumbnail_paths()
|> Enum.map(fn {_size, relative_path} -> Path.join(Projects.project_data_dir(project), relative_path) end)
|> Enum.reject(&File.exists?/1)
next_acc =
if missing_paths == [] do
%{acc | processed: acc.processed + 1}
else
try do
:ok = ensure_thumbnails(project, media)
%{
processed: acc.processed + 1,
generated: acc.generated + length(missing_paths),
failed: acc.failed
}
rescue
_error ->
%{acc | processed: acc.processed + 1, failed: acc.failed + 1}
end
end
:ok = report_rebuild_progress(on_progress, index, total_media, "image assets")
next_acc
end)
end
@spec ensure_thumbnails(BDS.Projects.Project.t(), Media.t()) :: :ok
def ensure_thumbnails(project, media) do
if image_mime?(media.mime_type) do
source_path = Path.join(Projects.project_data_dir(project), media.file_path)
case Image.open(source_path) do
{:ok, image} ->
image
|> Image.autorotate!()
|> write_all_thumbnails(project, media)
{:error, _reason} ->
:ok
end
end
:ok
end
@spec delete_thumbnail_files(String.t(), Media.t()) :: :ok
def 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 write_all_thumbnails(image, project, media) do
thumbnail_paths(media)
|> Enum.each(fn {size, relative_path} ->
destination = Path.join(Projects.project_data_dir(project), relative_path)
:ok = File.mkdir_p(Path.dirname(destination))
image
|> render_thumbnail(size)
|> write_thumbnail(destination, size)
end)
:ok
end
defp render_thumbnail(image, :small), do: bounded_thumbnail(image, 150, 150)
defp render_thumbnail(image, :medium), do: bounded_thumbnail(image, 400, 400)
defp render_thumbnail(image, :large), do: bounded_thumbnail(image, 800, 800)
defp render_thumbnail(image, :ai) do
image
|> Image.thumbnail!("448x448", fit: :contain, resize: :both, autorotate: false)
|> Image.embed!(448, 448, x: :center, y: :center, background_color: :black)
end
defp bounded_thumbnail(image, width, height) do
Image.thumbnail!(image, "#{width}x#{height}", fit: :contain, resize: :down, autorotate: false)
end
defp write_thumbnail(image, destination, :ai) do
flattened = Image.flatten!(image, background_color: :black)
Image.write!(flattened, destination, quality: 85, strip_metadata: true)
:ok
end
defp write_thumbnail(image, destination, _size) do
Image.write!(image, destination, quality: 80, strip_metadata: true)
:ok
end
end