248 lines
8.4 KiB
Elixir
248 lines
8.4 KiB
Elixir
defmodule BDS.Maintenance do
|
|
@moduledoc false
|
|
|
|
import BDS.Maintenance.Progress,
|
|
only: [
|
|
progress_callback: 1,
|
|
report_metadata_diff_phase: 4,
|
|
report_metadata_diff_complete: 1,
|
|
report_started: 3,
|
|
report_progress: 4
|
|
]
|
|
|
|
import BDS.Maintenance.Repair,
|
|
only: [
|
|
normalize_entity_type: 1,
|
|
normalize_repair_direction: 1,
|
|
repair_metadata_diff_item: 3,
|
|
repair_embedding_batch: 5,
|
|
import_metadata_diff_orphan: 2
|
|
]
|
|
|
|
import BDS.Maintenance.DiffReports,
|
|
only: [
|
|
project_metadata_diff_reports: 1,
|
|
post_diff_reports: 2,
|
|
post_translation_diff_reports: 2,
|
|
media_diff_reports: 2,
|
|
media_translation_diff_reports: 2,
|
|
script_diff_reports: 2,
|
|
template_diff_reports: 2
|
|
]
|
|
|
|
import BDS.Maintenance.FileScan, only: [orphan_reports: 2]
|
|
|
|
alias BDS.Embeddings
|
|
alias BDS.Projects
|
|
|
|
def repair_metadata_diff(project_id, direction, items, opts \\ [])
|
|
|
|
def repair_metadata_diff(project_id, direction, items, opts)
|
|
when is_binary(project_id) and is_list(items) do
|
|
on_progress = progress_callback(opts)
|
|
total = length(items)
|
|
:ok = report_started(on_progress, total, "Repairing metadata differences")
|
|
|
|
normalized_direction = normalize_repair_direction(direction)
|
|
|
|
result =
|
|
case repair_embedding_batch(project_id, normalized_direction, items, on_progress, total) do
|
|
{:ok, batch_result} ->
|
|
batch_result
|
|
|
|
:unsupported ->
|
|
items
|
|
|> Enum.with_index(1)
|
|
|> Enum.reduce(%{repaired: 0, failed: 0}, fn {item, index}, acc ->
|
|
next_acc =
|
|
case repair_metadata_diff_item(project_id, normalized_direction, item) do
|
|
:ok -> %{acc | repaired: acc.repaired + 1}
|
|
{:ok, _value} -> %{acc | repaired: acc.repaired + 1}
|
|
_error -> %{acc | failed: acc.failed + 1}
|
|
end
|
|
|
|
:ok = report_progress(on_progress, index, total, "Repairing metadata differences")
|
|
next_acc
|
|
end)
|
|
end
|
|
|
|
{:ok, result}
|
|
end
|
|
|
|
def import_metadata_diff_orphans(project_id, orphans, opts \\ [])
|
|
|
|
def import_metadata_diff_orphans(project_id, orphans, opts)
|
|
when is_binary(project_id) and is_list(orphans) do
|
|
on_progress = progress_callback(opts)
|
|
total = length(orphans)
|
|
:ok = report_started(on_progress, total, "Importing orphan files")
|
|
|
|
result =
|
|
orphans
|
|
|> Enum.with_index(1)
|
|
|> Enum.reduce(%{imported: 0, failed: 0}, fn {orphan, index}, acc ->
|
|
next_acc =
|
|
case import_metadata_diff_orphan(project_id, orphan) do
|
|
{:ok, _value} -> %{acc | imported: acc.imported + 1}
|
|
_error -> %{acc | failed: acc.failed + 1}
|
|
end
|
|
|
|
:ok = report_progress(on_progress, index, total, "Importing orphan files")
|
|
next_acc
|
|
end)
|
|
|
|
{:ok, result}
|
|
end
|
|
|
|
def rebuild_from_filesystem(project_id, entity_type, opts \\ []) do
|
|
case normalize_entity_type(entity_type) do
|
|
:post -> BDS.Posts.rebuild_posts_from_files(project_id, opts)
|
|
:media -> BDS.Media.rebuild_media_from_files(project_id, opts)
|
|
:script -> BDS.Scripts.rebuild_scripts_from_files(project_id, opts)
|
|
:template -> BDS.Templates.rebuild_templates_from_files(project_id, opts)
|
|
:embedding -> Embeddings.rebuild_project(project_id, opts)
|
|
:unsupported -> {:error, :unsupported_entity_type}
|
|
end
|
|
end
|
|
|
|
def metadata_diff(project_id, opts \\ [])
|
|
|
|
def metadata_diff(project_id, opts) when is_binary(project_id) and is_list(opts) do
|
|
project = Projects.get_project!(project_id)
|
|
on_progress = progress_callback(opts)
|
|
|
|
phases = [
|
|
{"Comparing project metadata", fn -> project_metadata_diff_reports(project_id) end},
|
|
{"Comparing post metadata", fn -> post_diff_reports(project_id, project) end},
|
|
{"Comparing post translations",
|
|
fn -> post_translation_diff_reports(project_id, project) end},
|
|
{"Comparing media metadata", fn -> media_diff_reports(project_id, project) end},
|
|
{"Comparing media translations",
|
|
fn -> media_translation_diff_reports(project_id, project) end},
|
|
{"Comparing script metadata", fn -> script_diff_reports(project_id, project) end},
|
|
{"Comparing template metadata", fn -> template_diff_reports(project_id, project) end},
|
|
{"Comparing embeddings", fn -> Embeddings.diff_reports(project_id) end}
|
|
]
|
|
|
|
total_phases = length(phases) + 1
|
|
|
|
diff_reports =
|
|
phases
|
|
|> Enum.with_index(1)
|
|
|> Enum.flat_map(fn {{label, fun}, index} ->
|
|
:ok = report_metadata_diff_phase(on_progress, index, total_phases, label)
|
|
fun.()
|
|
end)
|
|
|
|
:ok =
|
|
report_metadata_diff_phase(on_progress, total_phases, total_phases, "Scanning orphan files")
|
|
|
|
orphan_reports = orphan_reports(project_id, project)
|
|
:ok = report_metadata_diff_complete(on_progress)
|
|
|
|
{:ok, %{diff_reports: diff_reports, orphan_reports: orphan_reports}}
|
|
end
|
|
|
|
@doc """
|
|
The canonical full-rebuild sequence, shared by the GUI "Rebuild Database"
|
|
command and the CLI `rebuild` command so the two can never drift. Each step
|
|
is `%{name: String.t(), work: (report -> result)}` where `report` is a
|
|
2-arity progress callback and a `{:error, message}` result marks failure.
|
|
"""
|
|
def full_rebuild_steps(project_id) when is_binary(project_id) do
|
|
[
|
|
%{
|
|
name: "Rebuild Posts From Files",
|
|
work: fn report ->
|
|
{:ok, posts} =
|
|
rebuild_from_filesystem(project_id, "post",
|
|
on_progress: report,
|
|
rebuild_embeddings: false
|
|
)
|
|
|
|
report.(1.0, "Post rebuild complete")
|
|
%{project_id: project_id, counts: %{posts: length(posts)}}
|
|
end
|
|
},
|
|
%{
|
|
name: "Rebuild Media From Files",
|
|
work: fn report ->
|
|
{:ok, media} = rebuild_from_filesystem(project_id, "media", on_progress: report)
|
|
report.(1.0, "Media rebuild complete")
|
|
%{project_id: project_id, counts: %{media: length(media)}}
|
|
end
|
|
},
|
|
%{
|
|
name: "Rebuild Scripts From Files",
|
|
work: fn report ->
|
|
{:ok, scripts} = rebuild_from_filesystem(project_id, "script", on_progress: report)
|
|
report.(1.0, "Script rebuild complete")
|
|
%{project_id: project_id, counts: %{scripts: length(scripts)}}
|
|
end
|
|
},
|
|
%{
|
|
name: "Rebuild Templates From Files",
|
|
work: fn report ->
|
|
{:ok, templates} = rebuild_from_filesystem(project_id, "template", on_progress: report)
|
|
report.(1.0, "Template rebuild complete")
|
|
%{project_id: project_id, counts: %{templates: length(templates)}}
|
|
end
|
|
},
|
|
%{
|
|
name: "Rebuild Post Links",
|
|
work: fn report ->
|
|
:ok = BDS.Posts.rebuild_post_links(project_id, on_progress: report)
|
|
report.(1.0, "Post links rebuilt")
|
|
%{project_id: project_id}
|
|
end
|
|
},
|
|
%{
|
|
name: "Regenerate Missing Thumbnails",
|
|
work: fn report ->
|
|
result = BDS.Media.regenerate_missing_thumbnails(project_id, on_progress: report)
|
|
report.(1.0, "Missing thumbnails regenerated")
|
|
Map.put(result, :project_id, project_id)
|
|
end
|
|
},
|
|
%{
|
|
name: "Rebuild Embedding Index",
|
|
work: fn report -> rebuild_embedding_index(project_id, on_progress: report) end
|
|
}
|
|
]
|
|
end
|
|
|
|
@doc """
|
|
Rebuilds the embedding index for the project, mapping backend failures to a
|
|
user-facing message (`{:error, message}`).
|
|
"""
|
|
def rebuild_embedding_index(project_id, opts \\ []) when is_binary(project_id) do
|
|
on_progress = progress_callback(opts)
|
|
|
|
case Embeddings.rebuild_project(project_id, on_progress: on_progress) do
|
|
{:ok, rebuilt_post_ids} ->
|
|
on_progress.(1.0, "Embedding index rebuilt")
|
|
|
|
%{
|
|
project_id: project_id,
|
|
rebuilt_post_ids: rebuilt_post_ids,
|
|
rebuilt_count: length(rebuilt_post_ids)
|
|
}
|
|
|
|
{:error, reason} ->
|
|
{:error, embedding_error_message(reason)}
|
|
end
|
|
end
|
|
|
|
defp embedding_error_message(reason) do
|
|
detail =
|
|
case reason do
|
|
message when is_binary(message) -> message
|
|
{:embedding_backend_unavailable, _inner} -> "the embedding service did not start"
|
|
other -> inspect(other)
|
|
end
|
|
|
|
"Could not build the embedding index: #{detail}. The model is downloaded on first use, " <>
|
|
"so check your internet connection — or turn off semantic similarity in Settings."
|
|
end
|
|
end
|