1782 lines
57 KiB
Elixir
1782 lines
57 KiB
Elixir
defmodule BDS.Posts do
|
|
@moduledoc false
|
|
|
|
import Ecto.Query
|
|
|
|
alias BDS.DocumentFields
|
|
alias BDS.Frontmatter
|
|
alias BDS.Embeddings
|
|
alias BDS.AI
|
|
alias BDS.Media
|
|
alias BDS.Metadata
|
|
alias BDS.Persistence
|
|
alias BDS.PostLinks
|
|
alias BDS.Posts.Link
|
|
alias BDS.Posts.Post
|
|
alias BDS.Posts.PostMedia
|
|
alias BDS.Posts.Translation
|
|
alias BDS.Projects
|
|
alias BDS.Rebuild
|
|
alias BDS.Repo
|
|
alias BDS.Search
|
|
alias BDS.Slug
|
|
alias BDS.Tasks
|
|
|
|
@typedoc "An attribute map that may use atom or string keys."
|
|
@type attrs :: %{optional(atom()) => term(), optional(String.t()) => term()}
|
|
|
|
@typedoc "Options accepted by long-running rebuild operations."
|
|
@type rebuild_opts :: keyword()
|
|
|
|
@typedoc "Aggregate counts returned by `dashboard_stats/1`."
|
|
@type dashboard_stats :: %{
|
|
total_posts: non_neg_integer(),
|
|
draft_count: non_neg_integer(),
|
|
published_count: non_neg_integer(),
|
|
archived_count: non_neg_integer()
|
|
}
|
|
|
|
@typedoc "Per-month post count entry returned by `post_counts_by_year_month/1`."
|
|
@type month_count :: %{year: integer(), month: integer(), count: non_neg_integer()}
|
|
|
|
@typedoc "Translation validation report returned by `validate_translations/2`."
|
|
@type translation_validation_report :: %{
|
|
checked_database_row_count: non_neg_integer(),
|
|
checked_filesystem_file_count: non_neg_integer(),
|
|
invalid_database_rows: [map()],
|
|
invalid_filesystem_files: [map()],
|
|
missing: [map()],
|
|
orphan_files: [map()],
|
|
do_not_translate_posts: [map()]
|
|
}
|
|
|
|
@spec create_post(attrs()) :: {:ok, Post.t()} | {:error, Ecto.Changeset.t()}
|
|
def create_post(attrs) do
|
|
now = Persistence.now_ms()
|
|
project_id = attr(attrs, :project_id)
|
|
title = normalize_title(attr(attrs, :title))
|
|
base_slug = title |> default_slug_source() |> Slug.slugify()
|
|
|
|
%Post{}
|
|
|> Post.changeset(%{
|
|
id: Ecto.UUID.generate(),
|
|
project_id: project_id,
|
|
title: title,
|
|
slug: unique_slug(project_id, base_slug),
|
|
excerpt: attr(attrs, :excerpt),
|
|
content: attr(attrs, :content),
|
|
status: :draft,
|
|
author: attr(attrs, :author),
|
|
created_at: now,
|
|
updated_at: now,
|
|
published_at: nil,
|
|
file_path: "",
|
|
checksum: attr(attrs, :checksum),
|
|
tags: attr(attrs, :tags) || [],
|
|
categories: attr(attrs, :categories) || [],
|
|
template_slug: attr(attrs, :template_slug),
|
|
language: attr(attrs, :language),
|
|
do_not_translate: attr(attrs, :do_not_translate) || false,
|
|
published_title: nil,
|
|
published_content: nil,
|
|
published_tags: nil,
|
|
published_categories: nil,
|
|
published_excerpt: nil
|
|
})
|
|
|> Repo.insert()
|
|
|> case do
|
|
{:ok, post} ->
|
|
:ok = Embeddings.sync_post(post)
|
|
:ok = Search.sync_post(post)
|
|
:ok = maybe_schedule_auto_translations(post)
|
|
{:ok, post}
|
|
|
|
error ->
|
|
error
|
|
end
|
|
end
|
|
|
|
@spec update_post(String.t(), attrs()) ::
|
|
{:ok, Post.t()} | {:error, :not_found | Ecto.Changeset.t()}
|
|
def update_post(post_id, attrs) do
|
|
case Repo.get(Post, post_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
post ->
|
|
with :ok <- validate_slug_change(post, attrs) do
|
|
now = Persistence.now_ms()
|
|
|
|
updates =
|
|
attrs
|
|
|> normalize_updates(post)
|
|
|> Map.put(:updated_at, now)
|
|
|> maybe_reopen_published_post(post)
|
|
|
|
post
|
|
|> Post.changeset(updates)
|
|
|> Repo.update()
|
|
|> case do
|
|
{:ok, updated_post} ->
|
|
if post.status == :published and updated_post.status == :published and
|
|
Map.get(updates, :template_slug) != nil and
|
|
updated_post.template_slug != post.template_slug do
|
|
:ok = rewrite_published_post(updated_post.id)
|
|
end
|
|
|
|
:ok = Embeddings.sync_post(updated_post)
|
|
:ok = PostLinks.sync_post_links(updated_post)
|
|
:ok = Search.sync_post(updated_post)
|
|
:ok = maybe_schedule_auto_translations(updated_post)
|
|
{:ok, updated_post}
|
|
|
|
error ->
|
|
error
|
|
end
|
|
else
|
|
{:error, changeset} -> {:error, changeset}
|
|
end
|
|
end
|
|
end
|
|
|
|
@spec publish_post(String.t()) ::
|
|
{:ok, Post.t()} | {:error, :not_found | Ecto.Changeset.t()}
|
|
def publish_post(post_id) do
|
|
case Repo.get(Post, post_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Post{} = post ->
|
|
project = Projects.get_project!(post.project_id)
|
|
published_at = post.published_at || Persistence.now_ms()
|
|
relative_path = build_post_relative_path(post.slug, post.created_at)
|
|
full_path = Path.join(Projects.project_data_dir(project), relative_path)
|
|
updated_at = Persistence.now_ms()
|
|
body = publishable_post_body(post, full_path, project)
|
|
|
|
:ok =
|
|
Persistence.atomic_write(
|
|
full_path,
|
|
serialize_post_file(%{post | updated_at: updated_at, content: body}, published_at)
|
|
)
|
|
|
|
post
|
|
|> Post.changeset(%{
|
|
status: :published,
|
|
published_at: published_at,
|
|
file_path: relative_path,
|
|
content: nil,
|
|
updated_at: updated_at
|
|
})
|
|
|> Repo.update()
|
|
|> case do
|
|
{:ok, updated_post} ->
|
|
:ok = Embeddings.sync_post(updated_post)
|
|
:ok = publish_post_translations(updated_post)
|
|
:ok = PostLinks.sync_post_links(updated_post)
|
|
:ok = Search.sync_post(updated_post)
|
|
{:ok, updated_post}
|
|
|
|
error ->
|
|
error
|
|
end
|
|
end
|
|
end
|
|
|
|
@spec rebuild_posts_from_files(String.t(), rebuild_opts()) :: {:ok, [Post.t()]}
|
|
def rebuild_posts_from_files(project_id, opts \\ []) do
|
|
project = Projects.get_project!(project_id)
|
|
on_progress = progress_callback(opts)
|
|
|
|
rebuild_files =
|
|
project
|
|
|> Projects.project_data_dir()
|
|
|> Path.join("posts")
|
|
|> list_matching_files("*.md")
|
|
|> Rebuild.parallel_map(&parse_rebuild_file(project, &1))
|
|
|
|
total_files = length(rebuild_files)
|
|
:ok = report_rebuild_started(on_progress, total_files, "post files")
|
|
|
|
{translation_files, post_files} = Enum.split_with(rebuild_files, &translation_rebuild_file?/1)
|
|
|
|
posts =
|
|
post_files
|
|
|> Enum.with_index(1)
|
|
|> Enum.map(fn {file, index} ->
|
|
post = upsert_post_from_rebuild_file(project_id, file, sync_search: false, sync_embeddings: false)
|
|
:ok = report_rebuild_progress(on_progress, index, total_files, "post files")
|
|
post
|
|
end)
|
|
|
|
translation_files
|
|
|> Enum.with_index(length(post_files) + 1)
|
|
|> Enum.each(fn {file, index} ->
|
|
upsert_post_translation_from_rebuild_file(project_id, file, sync_search: false)
|
|
:ok = report_rebuild_progress(on_progress, index, total_files, "post files")
|
|
end)
|
|
|
|
if Keyword.get(opts, :reindex_search, true) do
|
|
:ok = report_rebuild_phase(on_progress, 0.97, "Refreshing post search index")
|
|
:ok =
|
|
Search.reindex_posts(project_id,
|
|
on_progress: scaled_progress_reporter(on_progress, 0.97, 0.99)
|
|
)
|
|
end
|
|
|
|
if Keyword.get(opts, :rebuild_embeddings, true) do
|
|
:ok = report_rebuild_phase(on_progress, 0.99, "Refreshing post embeddings")
|
|
{:ok, _rebuilt_post_ids} =
|
|
Embeddings.rebuild_project(project_id,
|
|
on_progress: scaled_progress_reporter(on_progress, 0.99, 1.0)
|
|
)
|
|
end
|
|
|
|
{:ok, posts}
|
|
end
|
|
|
|
@spec discard_post_changes(String.t()) ::
|
|
{:ok, Post.t()} | {:error, :not_found}
|
|
def discard_post_changes(post_id) do
|
|
case Repo.get(Post, post_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Post{file_path: file_path} when file_path in [nil, ""] ->
|
|
{:error, :not_found}
|
|
|
|
%Post{} = post ->
|
|
project = Projects.get_project!(post.project_id)
|
|
full_path = Path.join(Projects.project_data_dir(project), post.file_path)
|
|
|
|
if File.exists?(full_path) do
|
|
restored_post = upsert_post_from_file(post.project_id, project, full_path)
|
|
:ok = PostLinks.sync_post_links(restored_post)
|
|
{:ok, restored_post}
|
|
else
|
|
{:error, :not_found}
|
|
end
|
|
end
|
|
end
|
|
|
|
@spec editor_body(Post.t() | Translation.t() | term()) :: String.t()
|
|
def editor_body(%Post{content: content}) when is_binary(content), do: content
|
|
|
|
def editor_body(%Post{project_id: project_id, file_path: file_path})
|
|
when is_binary(file_path) and file_path != "" do
|
|
project_id
|
|
|> Projects.get_project!()
|
|
|> Projects.project_data_dir()
|
|
|> Path.join(file_path)
|
|
|> read_markdown_body()
|
|
end
|
|
|
|
def editor_body(%Translation{content: content}) when is_binary(content), do: content
|
|
|
|
def editor_body(%Translation{project_id: project_id, file_path: file_path})
|
|
when is_binary(file_path) and file_path != "" do
|
|
project_id
|
|
|> Projects.get_project!()
|
|
|> Projects.project_data_dir()
|
|
|> Path.join(file_path)
|
|
|> read_markdown_body()
|
|
end
|
|
|
|
def editor_body(_record), do: ""
|
|
|
|
@spec sync_post_from_file(String.t()) :: {:ok, Post.t()} | {:error, :not_found}
|
|
def sync_post_from_file(post_id) do
|
|
case Repo.get(Post, post_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Post{file_path: file_path} when file_path in [nil, ""] ->
|
|
{:error, :not_found}
|
|
|
|
%Post{} = post ->
|
|
project = Projects.get_project!(post.project_id)
|
|
full_path = Path.join(Projects.project_data_dir(project), post.file_path)
|
|
|
|
if File.exists?(full_path) do
|
|
repaired_post = upsert_post_from_file(post.project_id, project, full_path)
|
|
:ok = PostLinks.sync_post_links(repaired_post)
|
|
{:ok, repaired_post}
|
|
else
|
|
{:error, :not_found}
|
|
end
|
|
end
|
|
end
|
|
|
|
@spec sync_post_translation_from_file(String.t()) ::
|
|
{:ok, Translation.t()} | {:error, :not_found}
|
|
def sync_post_translation_from_file(translation_id) do
|
|
case Repo.get(Translation, translation_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Translation{file_path: file_path} when file_path in [nil, ""] ->
|
|
{:error, :not_found}
|
|
|
|
%Translation{} = translation ->
|
|
project = Projects.get_project!(translation.project_id)
|
|
full_path = Path.join(Projects.project_data_dir(project), translation.file_path)
|
|
|
|
if File.exists?(full_path) do
|
|
rebuild_file = parse_rebuild_file(project, full_path)
|
|
{:ok, upsert_post_translation_from_rebuild_file(translation.project_id, rebuild_file, sync_search: true)}
|
|
else
|
|
{:error, :not_found}
|
|
end
|
|
end
|
|
end
|
|
|
|
@spec rewrite_published_post_translation(String.t()) ::
|
|
{:ok, Translation.t()} | {:error, :not_found}
|
|
def rewrite_published_post_translation(translation_id) do
|
|
case Repo.get(Translation, translation_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Translation{file_path: file_path, status: status} = translation
|
|
when file_path not in [nil, ""] and status == :published ->
|
|
post = Repo.get!(Post, translation.translation_for)
|
|
:ok = publish_translation(post, translation)
|
|
{:ok, Repo.get!(Translation, translation_id)}
|
|
|
|
%Translation{} ->
|
|
{:error, :not_found}
|
|
end
|
|
end
|
|
|
|
@spec import_orphan_post_file(String.t(), String.t()) ::
|
|
{:ok, Post.t()} | {:error, :not_found | :unsupported_file}
|
|
def import_orphan_post_file(project_id, relative_path) do
|
|
project = Projects.get_project!(project_id)
|
|
full_path = Path.join(Projects.project_data_dir(project), relative_path)
|
|
|
|
if File.exists?(full_path) do
|
|
rebuild_file = parse_rebuild_file(project, full_path)
|
|
|
|
if translation_rebuild_file?(rebuild_file) do
|
|
{:error, :unsupported_file}
|
|
else
|
|
fields =
|
|
rebuild_file.fields
|
|
|> Map.put("id", unique_post_id(Map.get(rebuild_file.fields, "id")))
|
|
|> Map.put("slug", unique_slug_for_import(project_id, Map.fetch!(rebuild_file.fields, "slug")))
|
|
|
|
{:ok, upsert_post_from_rebuild_file(project_id, %{rebuild_file | fields: fields})}
|
|
end
|
|
else
|
|
{:error, :not_found}
|
|
end
|
|
end
|
|
|
|
@spec import_orphan_post_translation_file(String.t(), String.t()) ::
|
|
{:ok, Translation.t()} | {:error, :not_found | :unsupported_file | :conflict}
|
|
def import_orphan_post_translation_file(project_id, relative_path) do
|
|
project = Projects.get_project!(project_id)
|
|
full_path = Path.join(Projects.project_data_dir(project), relative_path)
|
|
|
|
if File.exists?(full_path) do
|
|
rebuild_file = parse_rebuild_file(project, full_path)
|
|
|
|
if translation_rebuild_file?(rebuild_file) do
|
|
source_post_id = Map.fetch!(rebuild_file.fields, "translationFor")
|
|
language = normalize_language(Map.fetch!(rebuild_file.fields, "language"))
|
|
|
|
case Repo.get(Post, source_post_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Post{} = post ->
|
|
if normalize_language(post.language) == language or
|
|
Repo.get_by(Translation, translation_for: source_post_id, language: language) do
|
|
{:error, :conflict}
|
|
else
|
|
fields = Map.put(rebuild_file.fields, "id", Ecto.UUID.generate())
|
|
{:ok, upsert_post_translation_from_rebuild_file(project_id, %{rebuild_file | fields: fields}, sync_search: true)}
|
|
end
|
|
end
|
|
else
|
|
{:error, :unsupported_file}
|
|
end
|
|
else
|
|
{:error, :not_found}
|
|
end
|
|
end
|
|
|
|
@spec delete_post(String.t()) :: {:ok, :deleted} | {:error, :not_found}
|
|
def delete_post(post_id) do
|
|
case Repo.get(Post, post_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Post{} = post ->
|
|
linked_media_ids = linked_media_ids(post.id)
|
|
delete_post_file(post)
|
|
:ok = Embeddings.remove_post(post.id)
|
|
:ok = PostLinks.delete_post_links(post.id)
|
|
Repo.delete!(post)
|
|
Enum.each(linked_media_ids, &sync_deleted_post_media_sidecar/1)
|
|
:ok = Search.delete_post(post.id)
|
|
{:ok, :deleted}
|
|
end
|
|
end
|
|
|
|
@spec archive_post(String.t()) ::
|
|
{:ok, Post.t()} | {:error, :not_found | Ecto.Changeset.t()}
|
|
def archive_post(post_id) do
|
|
case Repo.get(Post, post_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Post{status: status} = post when status in [:draft, :published] ->
|
|
post
|
|
|> Post.changeset(%{status: :archived, updated_at: Persistence.now_ms()})
|
|
|> Repo.update()
|
|
|> case do
|
|
{:ok, updated_post} ->
|
|
:ok = Search.sync_post(updated_post)
|
|
{:ok, updated_post}
|
|
|
|
error ->
|
|
error
|
|
end
|
|
|
|
%Post{} = post ->
|
|
{:error,
|
|
post
|
|
|> Post.changeset(%{})
|
|
|> Ecto.Changeset.add_error(:status, "cannot archive archived post")}
|
|
end
|
|
end
|
|
|
|
@spec get_post!(String.t()) :: Post.t()
|
|
def get_post!(post_id), do: Repo.get!(Post, post_id)
|
|
|
|
@spec get_post_translation!(String.t()) :: Translation.t()
|
|
def get_post_translation!(translation_id), do: Repo.get!(Translation, translation_id)
|
|
|
|
@spec publish_post_translation(String.t(), String.t() | atom()) ::
|
|
{:ok, Translation.t()} | {:error, :not_found | term()}
|
|
def publish_post_translation(post_id, language) do
|
|
normalized_language = language |> to_string() |> String.trim() |> String.downcase()
|
|
|
|
case Repo.get_by(Translation, translation_for: post_id, language: normalized_language) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Translation{} ->
|
|
with {:ok, _post} <- publish_post(post_id),
|
|
%Translation{} = translation <- Repo.get_by(Translation, translation_for: post_id, language: normalized_language) do
|
|
{:ok, translation}
|
|
else
|
|
nil -> {:error, :not_found}
|
|
error -> error
|
|
end
|
|
end
|
|
end
|
|
|
|
@spec slug_available(String.t(), String.t(), String.t() | nil) :: boolean()
|
|
def slug_available(project_id, slug, exclude_post_id \\ nil) do
|
|
normalized_slug = slug |> to_string() |> String.trim()
|
|
|
|
query =
|
|
from(post in Post,
|
|
where: post.project_id == ^project_id and post.slug == ^normalized_slug,
|
|
select: post.id,
|
|
limit: 1
|
|
)
|
|
|
|
case Repo.one(query) do
|
|
nil -> true
|
|
^exclude_post_id -> true
|
|
_other -> false
|
|
end
|
|
end
|
|
|
|
@spec unique_slug_for_title(String.t(), String.t(), String.t() | nil) :: String.t()
|
|
def unique_slug_for_title(project_id, title, exclude_post_id \\ nil) do
|
|
base_slug = title |> default_slug_source() |> Slug.slugify()
|
|
|
|
if slug_available(project_id, base_slug, exclude_post_id) do
|
|
base_slug
|
|
else
|
|
Stream.iterate(2, &(&1 + 1))
|
|
|> Enum.find_value(fn counter ->
|
|
candidate = "#{base_slug}-#{counter}"
|
|
if slug_available(project_id, candidate, exclude_post_id), do: candidate, else: nil
|
|
end)
|
|
end
|
|
end
|
|
|
|
@spec dashboard_stats(String.t()) :: dashboard_stats()
|
|
def dashboard_stats(project_id) do
|
|
Repo.all(
|
|
from(post in Post,
|
|
where: post.project_id == ^project_id,
|
|
select: post.status
|
|
)
|
|
)
|
|
|> Enum.reduce(
|
|
%{total_posts: 0, draft_count: 0, published_count: 0, archived_count: 0},
|
|
fn status, acc ->
|
|
acc
|
|
|> Map.update!(:total_posts, &(&1 + 1))
|
|
|> case do
|
|
counts when status == :draft -> Map.update!(counts, :draft_count, &(&1 + 1))
|
|
counts when status == :published -> Map.update!(counts, :published_count, &(&1 + 1))
|
|
counts when status == :archived -> Map.update!(counts, :archived_count, &(&1 + 1))
|
|
counts -> counts
|
|
end
|
|
end
|
|
)
|
|
end
|
|
|
|
@spec post_counts_by_year_month(String.t()) :: [month_count()]
|
|
def post_counts_by_year_month(project_id) do
|
|
Repo.all(
|
|
from(post in Post,
|
|
where: post.project_id == ^project_id,
|
|
select: post.created_at
|
|
)
|
|
)
|
|
|> Enum.reduce(%{}, fn created_at, acc ->
|
|
datetime = DateTime.from_unix!(created_at, :millisecond)
|
|
key = {datetime.year, datetime.month}
|
|
Map.update(acc, key, 1, &(&1 + 1))
|
|
end)
|
|
|> Enum.map(fn {{year, month}, count} -> %{year: year, month: month, count: count} end)
|
|
|> Enum.sort_by(fn %{year: year, month: month} -> {-year, -month} end)
|
|
end
|
|
|
|
@spec rebuild_post_links(String.t(), rebuild_opts()) :: :ok
|
|
def rebuild_post_links(project_id, opts \\ []) do
|
|
post_ids = Repo.all(from(post in Post, where: post.project_id == ^project_id, select: post.id))
|
|
on_progress = progress_callback(opts)
|
|
|
|
Repo.delete_all(
|
|
from(link in Link,
|
|
where: link.source_post_id in ^post_ids or link.target_post_id in ^post_ids
|
|
)
|
|
)
|
|
|
|
posts = Repo.all(from(post in Post, where: post.project_id == ^project_id, order_by: [asc: post.created_at]))
|
|
total_posts = length(posts)
|
|
:ok = report_rebuild_started(on_progress, total_posts, "post links")
|
|
|
|
posts
|
|
|> Enum.with_index(1)
|
|
|> Enum.each(fn {post, index} ->
|
|
PostLinks.sync_post_links(post)
|
|
:ok = report_rebuild_progress(on_progress, index, total_posts, "post links")
|
|
end)
|
|
|
|
:ok
|
|
end
|
|
|
|
@spec list_post_translations(String.t()) :: {:ok, [Translation.t()]}
|
|
def list_post_translations(post_id) do
|
|
{:ok,
|
|
Repo.all(
|
|
from translation in Translation,
|
|
where: translation.translation_for == ^post_id,
|
|
order_by: [asc: translation.language]
|
|
)}
|
|
end
|
|
|
|
@spec upsert_post_translation(String.t(), String.t() | atom(), attrs()) ::
|
|
{:ok, Translation.t()} | {:error, :not_found | Ecto.Changeset.t()}
|
|
def upsert_post_translation(post_id, language, attrs) do
|
|
case Repo.get(Post, post_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Post{do_not_translate: true} = post ->
|
|
{:error,
|
|
post
|
|
|> Post.changeset(%{})
|
|
|> Ecto.Changeset.add_error(
|
|
:do_not_translate,
|
|
"cannot add translations when do_not_translate is true"
|
|
)}
|
|
|
|
%Post{} = post ->
|
|
now = Persistence.now_ms()
|
|
normalized_language = normalize_language(language)
|
|
|
|
translation =
|
|
Repo.get_by(Translation, translation_for: post.id, language: normalized_language) ||
|
|
%Translation{}
|
|
|
|
updates =
|
|
normalize_translation_updates(post, translation, normalized_language, attrs, now)
|
|
|
|
translation
|
|
|> Translation.changeset(updates)
|
|
|> Repo.insert_or_update()
|
|
|> case do
|
|
{:ok, saved_translation} ->
|
|
{:ok, _post} = maybe_reopen_source_post_for_manual_translation(post, attrs)
|
|
:ok = Search.sync_post(post.id)
|
|
{:ok, saved_translation}
|
|
|
|
error ->
|
|
error
|
|
end
|
|
end
|
|
end
|
|
|
|
@spec delete_post_translation(String.t()) :: {:ok, :deleted} | {:error, :not_found}
|
|
def delete_post_translation(translation_id) do
|
|
case Repo.get(Translation, translation_id) do
|
|
nil ->
|
|
{:error, :not_found}
|
|
|
|
%Translation{} = translation ->
|
|
:ok = delete_translation_file(translation)
|
|
Repo.delete!(translation)
|
|
:ok = Search.sync_post(translation.translation_for)
|
|
{:ok, :deleted}
|
|
end
|
|
end
|
|
|
|
@spec validate_translations(String.t(), rebuild_opts()) :: {:ok, translation_validation_report()}
|
|
def validate_translations(project_id, opts \\ []) do
|
|
project = Projects.get_project!(project_id)
|
|
{:ok, metadata} = Metadata.get_project_metadata(project_id)
|
|
on_progress = progress_callback(opts)
|
|
|
|
source_posts =
|
|
Repo.all(
|
|
from post in Post,
|
|
where: post.project_id == ^project_id,
|
|
order_by: [asc: post.created_at, asc: post.slug]
|
|
)
|
|
|
|
source_post_map = Map.new(source_posts, &{&1.id, &1})
|
|
|
|
translation_rows =
|
|
Repo.all(
|
|
from translation in Translation,
|
|
where: translation.project_id == ^project_id,
|
|
order_by: [asc: translation.translation_for, asc: translation.language, asc: translation.id]
|
|
)
|
|
|
|
project_data_dir = Projects.project_data_dir(project)
|
|
|
|
markdown_files =
|
|
project_data_dir
|
|
|> Path.join("posts")
|
|
|> list_markdown_files_recursive()
|
|
|
|
total_items = length(translation_rows) + length(markdown_files)
|
|
:ok = report_rebuild_started(on_progress, total_items, "translations")
|
|
|
|
invalid_database_rows =
|
|
translation_rows
|
|
|> Enum.with_index(1)
|
|
|> Enum.flat_map(fn {translation, index} ->
|
|
:ok = report_rebuild_progress(on_progress, index, total_items, "translations")
|
|
|
|
case invalid_database_translation_issue(translation, source_post_map, metadata) do
|
|
nil -> []
|
|
issue -> [issue]
|
|
end
|
|
end)
|
|
|> Enum.sort_by(&translation_validation_issue_sort_key/1)
|
|
|
|
{checked_filesystem_file_count, invalid_filesystem_files} =
|
|
markdown_files
|
|
|> Enum.with_index(length(translation_rows) + 1)
|
|
|> Enum.reduce({0, []}, fn {file_path, index}, {count, issues} ->
|
|
:ok = report_rebuild_progress(on_progress, index, total_items, "translations")
|
|
|
|
case invalid_filesystem_translation_issue(file_path, source_post_map, metadata) do
|
|
{:ok, nil} ->
|
|
{count + 1, issues}
|
|
|
|
{:ok, issue} ->
|
|
{count + 1, [issue | issues]}
|
|
|
|
:skip ->
|
|
{count, issues}
|
|
end
|
|
end)
|
|
|
|
missing = legacy_missing_translation_entries(source_posts, translation_rows, metadata)
|
|
orphan_files = legacy_orphan_translation_files(invalid_filesystem_files, project_data_dir)
|
|
do_not_translate_posts = legacy_do_not_translate_posts(source_posts)
|
|
|
|
{:ok,
|
|
%{
|
|
checked_database_row_count: length(translation_rows),
|
|
checked_filesystem_file_count: checked_filesystem_file_count,
|
|
invalid_database_rows: invalid_database_rows,
|
|
invalid_filesystem_files: Enum.reverse(invalid_filesystem_files) |> Enum.sort_by(&translation_validation_issue_sort_key/1),
|
|
missing: missing,
|
|
orphan_files: orphan_files,
|
|
do_not_translate_posts: do_not_translate_posts
|
|
}}
|
|
end
|
|
|
|
@spec fix_invalid_translations(map()) ::
|
|
{:ok,
|
|
%{
|
|
deleted_database_rows: non_neg_integer(),
|
|
deleted_files: non_neg_integer(),
|
|
flushed_translations: non_neg_integer()
|
|
}}
|
|
def fix_invalid_translations(report) when is_map(report) do
|
|
normalized_report = normalize_translation_validation_report(report)
|
|
|
|
{deleted_database_rows, flushed_translations, synced_post_ids} =
|
|
Enum.reduce(normalized_report.invalid_database_rows, {0, 0, MapSet.new()}, fn issue, {deleted, flushed, synced_ids} ->
|
|
case fix_invalid_database_translation(issue) do
|
|
{:deleted, post_id} ->
|
|
{deleted + 1, flushed, maybe_put_synced_post(synced_ids, post_id)}
|
|
|
|
{:flushed, post_id} ->
|
|
{deleted, flushed + 1, maybe_put_synced_post(synced_ids, post_id)}
|
|
|
|
:noop ->
|
|
{deleted, flushed, synced_ids}
|
|
end
|
|
end)
|
|
|
|
deleted_files =
|
|
Enum.reduce(normalized_report.invalid_filesystem_files, 0, fn issue, count ->
|
|
if delete_translation_validation_file(issue.file_path) do
|
|
count + 1
|
|
else
|
|
count
|
|
end
|
|
end)
|
|
|
|
Enum.each(synced_post_ids, &Search.sync_post/1)
|
|
|
|
{:ok,
|
|
%{
|
|
deleted_database_rows: deleted_database_rows,
|
|
deleted_files: deleted_files,
|
|
flushed_translations: flushed_translations
|
|
}}
|
|
end
|
|
|
|
@spec rewrite_published_post(String.t()) :: :ok
|
|
def rewrite_published_post(post_id) do
|
|
post = Repo.get!(Post, post_id)
|
|
|
|
if post.status == :published and post.file_path not in [nil, ""] do
|
|
project = Projects.get_project!(post.project_id)
|
|
full_path = Path.join(Projects.project_data_dir(project), post.file_path)
|
|
body = published_post_body(post, full_path)
|
|
:ok =
|
|
Persistence.atomic_write(
|
|
full_path,
|
|
serialize_post_file(
|
|
%{post | content: body},
|
|
post.published_at || Persistence.now_ms()
|
|
)
|
|
)
|
|
end
|
|
|
|
:ok
|
|
end
|
|
|
|
defp normalize_updates(attrs, _post) do
|
|
%{}
|
|
|> maybe_put(:title, normalize_optional_title(attr(attrs, :title), attrs))
|
|
|> maybe_put(:slug, attr(attrs, :slug))
|
|
|> maybe_put(:excerpt, attr(attrs, :excerpt))
|
|
|> maybe_put(:content, attr(attrs, :content))
|
|
|> maybe_put(:status, attr(attrs, :status))
|
|
|> maybe_put(:author, attr(attrs, :author))
|
|
|> maybe_put(:published_at, attr(attrs, :published_at))
|
|
|> maybe_put(:file_path, attr(attrs, :file_path))
|
|
|> maybe_put(:checksum, attr(attrs, :checksum))
|
|
|> maybe_put(:tags, attr(attrs, :tags))
|
|
|> maybe_put(:categories, attr(attrs, :categories))
|
|
|> maybe_put(:template_slug, attr(attrs, :template_slug))
|
|
|> maybe_put(:language, attr(attrs, :language))
|
|
|> maybe_put(:do_not_translate, attr(attrs, :do_not_translate))
|
|
|> maybe_put(:published_title, attr(attrs, :published_title))
|
|
|> maybe_put(:published_content, attr(attrs, :published_content))
|
|
|> maybe_put(:published_tags, attr(attrs, :published_tags))
|
|
|> maybe_put(:published_categories, attr(attrs, :published_categories))
|
|
|> maybe_put(:published_excerpt, attr(attrs, :published_excerpt))
|
|
end
|
|
|
|
defp validate_slug_change(%Post{published_at: published_at} = post, attrs)
|
|
when not is_nil(published_at) do
|
|
case attr(attrs, :slug) do
|
|
nil ->
|
|
:ok
|
|
|
|
slug when slug == post.slug ->
|
|
:ok
|
|
|
|
_slug ->
|
|
{:error,
|
|
post
|
|
|> Post.changeset(%{})
|
|
|> Ecto.Changeset.add_error(:slug, "cannot change slug after first publish")}
|
|
end
|
|
end
|
|
|
|
defp validate_slug_change(_post, _attrs), do: :ok
|
|
|
|
defp maybe_reopen_published_post(updates, %Post{status: :published} = post) do
|
|
if published_content_change?(updates, post) do
|
|
Map.put(updates, :status, :draft)
|
|
else
|
|
updates
|
|
end
|
|
end
|
|
|
|
defp maybe_reopen_published_post(updates, _post), do: updates
|
|
|
|
defp published_content_change?(updates, post) do
|
|
Enum.any?(
|
|
[
|
|
:title,
|
|
:excerpt,
|
|
:content,
|
|
:author,
|
|
:language,
|
|
:tags,
|
|
:categories,
|
|
:do_not_translate
|
|
],
|
|
fn field ->
|
|
case Map.fetch(updates, field) do
|
|
{:ok, value} -> value != Map.get(post, field)
|
|
:error -> false
|
|
end
|
|
end
|
|
)
|
|
end
|
|
|
|
defp unique_slug(project_id, base_slug) do
|
|
normalized = if base_slug == "", do: "untitled", else: base_slug
|
|
|
|
if slug_available?(project_id, normalized) do
|
|
normalized
|
|
else
|
|
find_unique_slug(project_id, normalized, 2)
|
|
end
|
|
end
|
|
|
|
defp find_unique_slug(project_id, base_slug, suffix) do
|
|
candidate = "#{base_slug}-#{suffix}"
|
|
|
|
if slug_available?(project_id, candidate) do
|
|
candidate
|
|
else
|
|
find_unique_slug(project_id, base_slug, suffix + 1)
|
|
end
|
|
end
|
|
|
|
defp slug_available?(project_id, slug) do
|
|
not Repo.exists?(
|
|
from post in Post, where: post.project_id == ^project_id and post.slug == ^slug
|
|
)
|
|
end
|
|
|
|
defp maybe_put(map, _key, nil), do: map
|
|
defp maybe_put(map, key, value), do: Map.put(map, key, value)
|
|
|
|
defp unique_slug_for_import(project_id, slug) do
|
|
normalized = default_slug_source(slug) |> Slug.slugify()
|
|
|
|
if slug_available?(project_id, normalized) do
|
|
normalized
|
|
else
|
|
find_unique_slug(project_id, normalized, 2)
|
|
end
|
|
end
|
|
|
|
defp unique_post_id(nil), do: Ecto.UUID.generate()
|
|
|
|
defp unique_post_id(id) do
|
|
if Repo.get(Post, id) || Repo.get(Translation, id) do
|
|
Ecto.UUID.generate()
|
|
else
|
|
id
|
|
end
|
|
end
|
|
|
|
defp normalize_title(nil), do: ""
|
|
defp normalize_title(title), do: title
|
|
|
|
defp normalize_optional_title(_title, attrs) do
|
|
if has_attr?(attrs, :title), do: normalize_title(attr(attrs, :title)), else: nil
|
|
end
|
|
|
|
defp default_slug_source(""), do: "untitled"
|
|
defp default_slug_source(title), do: title
|
|
|
|
defp build_post_relative_path(slug, created_at) do
|
|
datetime = Persistence.from_unix_ms!(created_at)
|
|
year = Integer.to_string(datetime.year)
|
|
month = datetime.month |> Integer.to_string() |> String.pad_leading(2, "0")
|
|
Path.join(["posts", year, month, "#{slug}.md"])
|
|
end
|
|
|
|
defp publishable_post_body(%Post{content: content}, _full_path, _project)
|
|
when is_binary(content), do: content
|
|
|
|
defp publishable_post_body(%Post{file_path: file_path} = post, full_path, project) do
|
|
source_path =
|
|
if file_path in [nil, ""] do
|
|
full_path
|
|
else
|
|
Path.join(Projects.project_data_dir(project), file_path)
|
|
end
|
|
|
|
published_post_body(post, source_path)
|
|
end
|
|
|
|
defp serialize_post_file(post, published_at) do
|
|
Frontmatter.serialize_document(
|
|
[
|
|
{"id", post.id},
|
|
{"title", post.title},
|
|
{"slug", post.slug},
|
|
{"excerpt", post.excerpt},
|
|
{"status", :published},
|
|
{"author", post.author},
|
|
{"language", post.language},
|
|
{"doNotTranslate", post.do_not_translate},
|
|
{"templateSlug", post.template_slug},
|
|
{"createdAt", post.created_at},
|
|
{"updatedAt", post.updated_at},
|
|
{"publishedAt", published_at},
|
|
{"tags", post.tags || []},
|
|
{"categories", post.categories || []}
|
|
],
|
|
post.content
|
|
)
|
|
end
|
|
|
|
defp published_post_body(%Post{content: content}, _full_path) when is_binary(content),
|
|
do: content
|
|
|
|
defp published_post_body(_post, full_path), do: read_markdown_body(full_path)
|
|
|
|
defp read_markdown_body(path) do
|
|
case File.read(path) do
|
|
{:ok, contents} ->
|
|
case String.split(contents, "\n---\n", parts: 2) do
|
|
[_frontmatter, body] -> String.trim_trailing(body, "\n")
|
|
_parts -> ""
|
|
end
|
|
|
|
{:error, _reason} ->
|
|
""
|
|
end
|
|
end
|
|
|
|
defp upsert_post_from_file(project_id, project, path) do
|
|
rebuild_file = parse_rebuild_file(project, path)
|
|
upsert_post_from_rebuild_file(project_id, rebuild_file)
|
|
end
|
|
|
|
defp upsert_post_from_rebuild_file(project_id, rebuild_file, opts \\ []) do
|
|
fields = rebuild_file.fields
|
|
now = Persistence.now_ms()
|
|
|
|
attrs = %{
|
|
id: DocumentFields.get(fields, "id") || Ecto.UUID.generate(),
|
|
project_id: project_id,
|
|
title: DocumentFields.get(fields, "title") || "",
|
|
slug: DocumentFields.fetch!(fields, "slug"),
|
|
excerpt: Map.get(fields, "excerpt"),
|
|
content: nil,
|
|
status: parse_post_status(DocumentFields.get(fields, "status", "published")),
|
|
author: Map.get(fields, "author"),
|
|
created_at: DocumentFields.get(fields, "createdAt", now),
|
|
updated_at: DocumentFields.get(fields, "updatedAt", now),
|
|
published_at: DocumentFields.get(fields, "publishedAt"),
|
|
file_path: rebuild_file.relative_path,
|
|
checksum: nil,
|
|
tags: Map.get(fields, "tags", []),
|
|
categories: Map.get(fields, "categories", []),
|
|
template_slug: DocumentFields.get(fields, "templateSlug"),
|
|
language: Map.get(fields, "language"),
|
|
do_not_translate: DocumentFields.get(fields, "doNotTranslate", false),
|
|
published_title: nil,
|
|
published_content: nil,
|
|
published_tags: nil,
|
|
published_categories: nil,
|
|
published_excerpt: nil
|
|
}
|
|
|
|
post =
|
|
Repo.get(Post, attrs.id) ||
|
|
Repo.get_by(Post, project_id: project_id, file_path: rebuild_file.relative_path) ||
|
|
Repo.get_by(Post, project_id: project_id, slug: attrs.slug) || %Post{}
|
|
|
|
post =
|
|
post
|
|
|> Post.changeset(attrs)
|
|
|> Repo.insert_or_update!()
|
|
|
|
if Keyword.get(opts, :sync_search, true) do
|
|
:ok = Search.sync_post(post)
|
|
end
|
|
|
|
if Keyword.get(opts, :sync_embeddings, true) do
|
|
:ok = Embeddings.sync_post(post)
|
|
end
|
|
|
|
post
|
|
end
|
|
|
|
defp upsert_post_translation_from_rebuild_file(project_id, rebuild_file, opts) do
|
|
fields = rebuild_file.fields
|
|
source_post_id = DocumentFields.fetch!(fields, "translationFor")
|
|
source_post = Repo.get_by!(Post, project_id: project_id, id: source_post_id)
|
|
now = Persistence.now_ms()
|
|
language = normalize_language(DocumentFields.fetch!(fields, "language"))
|
|
|
|
translation =
|
|
Repo.get_by(Translation, translation_for: source_post_id, language: language) || %Translation{}
|
|
|
|
attrs = %{
|
|
id: DocumentFields.get(fields, "id") || Ecto.UUID.generate(),
|
|
project_id: project_id,
|
|
translation_for: source_post_id,
|
|
language: language,
|
|
title: DocumentFields.get(fields, "title") || "",
|
|
excerpt: Map.get(fields, "excerpt"),
|
|
content: nil,
|
|
status: parse_translation_status(DocumentFields.get(fields, "status", "published")),
|
|
created_at: DocumentFields.get(fields, "createdAt", source_post.created_at || now),
|
|
updated_at: DocumentFields.get(fields, "updatedAt", source_post.updated_at || source_post.created_at || now),
|
|
published_at: DocumentFields.get(fields, "publishedAt", source_post.published_at),
|
|
file_path: rebuild_file.relative_path,
|
|
checksum: nil
|
|
}
|
|
|
|
translation
|
|
|> Translation.changeset(attrs)
|
|
|> Repo.insert_or_update!()
|
|
|> tap(fn _translation ->
|
|
if Keyword.get(opts, :sync_search, true) do
|
|
:ok = Search.sync_post(source_post_id)
|
|
end
|
|
end)
|
|
end
|
|
|
|
defp parse_post_status(status) when is_atom(status), do: status
|
|
defp parse_post_status(status), do: String.to_existing_atom(status)
|
|
|
|
defp parse_translation_status(status) when is_atom(status), do: status
|
|
defp parse_translation_status(status), do: String.to_existing_atom(status)
|
|
|
|
defp parse_rebuild_file(project, path) do
|
|
contents = File.read!(path)
|
|
{:ok, %{fields: fields}} = Frontmatter.parse_document(contents)
|
|
|
|
%{
|
|
path: path,
|
|
relative_path: Path.relative_to(path, Projects.project_data_dir(project)),
|
|
fields: fields
|
|
}
|
|
end
|
|
|
|
defp translation_rebuild_file?(%{fields: fields}) do
|
|
DocumentFields.has_key?(fields, "translationFor") and not DocumentFields.has_key?(fields, "slug")
|
|
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 delete_post_file(%Post{project_id: _project_id, file_path: file_path})
|
|
when file_path in [nil, ""], do: :ok
|
|
|
|
defp delete_post_file(%Post{} = post) do
|
|
project = Projects.get_project!(post.project_id)
|
|
full_path = Path.join(Projects.project_data_dir(project), post.file_path)
|
|
|
|
case File.rm(full_path) do
|
|
:ok -> :ok
|
|
{:error, :enoent} -> :ok
|
|
{:error, reason} -> {:error, reason}
|
|
end
|
|
end
|
|
|
|
defp normalize_translation_updates(post, %Translation{} = translation, language, attrs, now) do
|
|
requested_status =
|
|
case attr(attrs, :status) do
|
|
nil -> nil
|
|
status -> parse_translation_status(status)
|
|
end
|
|
|
|
updates =
|
|
%{}
|
|
|> maybe_put(:title, attr(attrs, :title))
|
|
|> maybe_put(:excerpt, attr(attrs, :excerpt))
|
|
|> maybe_put(:content, attr(attrs, :content))
|
|
|
|
reopened? =
|
|
translation.status == :published and translation_content_change?(translation, updates)
|
|
|
|
status = if(reopened?, do: :draft, else: requested_status || translation.status || :draft)
|
|
|
|
%{
|
|
id: translation.id || Ecto.UUID.generate(),
|
|
project_id: post.project_id,
|
|
translation_for: post.id,
|
|
language: language,
|
|
title: Map.get(updates, :title, translation.title),
|
|
excerpt: Map.get(updates, :excerpt, translation.excerpt),
|
|
content: Map.get(updates, :content, translation.content),
|
|
status: status,
|
|
created_at: translation.created_at || now,
|
|
updated_at: now,
|
|
published_at: translation.published_at || if(status == :published, do: now, else: nil),
|
|
file_path: translation.file_path || "",
|
|
checksum: translation.checksum
|
|
}
|
|
end
|
|
|
|
defp translation_content_change?(translation, updates) do
|
|
Enum.any?([:title, :excerpt, :content], fn field ->
|
|
case Map.fetch(updates, field) do
|
|
{:ok, value} -> value != Map.get(translation, field)
|
|
:error -> false
|
|
end
|
|
end)
|
|
end
|
|
|
|
defp publish_post_translations(%Post{} = post) do
|
|
Repo.all(from translation in Translation, where: translation.translation_for == ^post.id)
|
|
|> Enum.each(fn translation ->
|
|
if translation.status == :draft do
|
|
publish_translation(post, translation)
|
|
end
|
|
end)
|
|
|
|
:ok
|
|
end
|
|
|
|
defp publish_translation(%Post{} = post, %Translation{} = translation) do
|
|
project = Projects.get_project!(post.project_id)
|
|
published_at = translation.published_at || Persistence.now_ms()
|
|
relative_path = build_translation_relative_path(post, translation.language)
|
|
full_path = Path.join(Projects.project_data_dir(project), relative_path)
|
|
updated_at = Persistence.now_ms()
|
|
body = publishable_translation_body(translation, full_path)
|
|
|
|
:ok =
|
|
Persistence.atomic_write(
|
|
full_path,
|
|
serialize_translation_file(
|
|
%{translation | updated_at: updated_at, content: body},
|
|
published_at
|
|
)
|
|
)
|
|
|
|
translation
|
|
|> Translation.changeset(%{
|
|
status: :published,
|
|
published_at: published_at,
|
|
file_path: relative_path,
|
|
content: nil,
|
|
updated_at: updated_at
|
|
})
|
|
|> Repo.update!()
|
|
|
|
:ok
|
|
end
|
|
|
|
defp build_translation_relative_path(post, language) do
|
|
datetime = Persistence.from_unix_ms!(post.created_at)
|
|
year = Integer.to_string(datetime.year)
|
|
month = datetime.month |> Integer.to_string() |> String.pad_leading(2, "0")
|
|
Path.join(["posts", year, month, "#{post.slug}.#{language}.md"])
|
|
end
|
|
|
|
defp serialize_translation_file(translation, published_at) do
|
|
Frontmatter.serialize_document(
|
|
[
|
|
{"id", translation.id},
|
|
{"translationFor", translation.translation_for},
|
|
{"language", translation.language},
|
|
{"title", translation.title},
|
|
{"excerpt", translation.excerpt},
|
|
{"status", :published},
|
|
{"createdAt", translation.created_at},
|
|
{"updatedAt", translation.updated_at},
|
|
{"publishedAt", published_at}
|
|
],
|
|
translation.content
|
|
)
|
|
end
|
|
|
|
defp publishable_translation_body(%Translation{content: content}, _full_path)
|
|
when is_binary(content), do: content
|
|
|
|
defp publishable_translation_body(_translation, full_path) do
|
|
case File.read(full_path) do
|
|
{:ok, contents} ->
|
|
case String.split(contents, "\n---\n", parts: 2) do
|
|
[_frontmatter, body] -> String.trim_trailing(body, "\n")
|
|
_parts -> ""
|
|
end
|
|
|
|
{:error, _reason} ->
|
|
""
|
|
end
|
|
end
|
|
|
|
defp delete_translation_file(%Translation{project_id: _project_id, file_path: file_path})
|
|
when file_path in [nil, ""], do: :ok
|
|
|
|
defp delete_translation_file(%Translation{} = translation) do
|
|
project = Projects.get_project!(translation.project_id)
|
|
full_path = Path.join(Projects.project_data_dir(project), translation.file_path)
|
|
|
|
case File.rm(full_path) do
|
|
:ok -> :ok
|
|
{:error, :enoent} -> :ok
|
|
{:error, reason} -> {:error, reason}
|
|
end
|
|
end
|
|
|
|
defp maybe_reopen_source_post_for_manual_translation(%Post{} = post, attrs) do
|
|
if attr(attrs, :auto_generated) == true or post.status != :published or post.file_path in [nil, ""] do
|
|
{:ok, post}
|
|
else
|
|
project = Projects.get_project!(post.project_id)
|
|
full_path = Path.join(Projects.project_data_dir(project), post.file_path)
|
|
restored_content = published_post_body(post, full_path)
|
|
|
|
post
|
|
|> Post.changeset(%{
|
|
status: :draft,
|
|
content: restored_content,
|
|
updated_at: Persistence.now_ms()
|
|
})
|
|
|> Repo.update()
|
|
end
|
|
end
|
|
|
|
defp maybe_schedule_auto_translations(%Post{do_not_translate: true}), do: :ok
|
|
|
|
defp maybe_schedule_auto_translations(%Post{} = post) do
|
|
with true <- auto_translation_configured?(),
|
|
{:ok, metadata} <- Metadata.get_project_metadata(post.project_id) do
|
|
post
|
|
|> missing_auto_translation_languages(metadata)
|
|
|> Enum.each(&queue_post_auto_translation(post, &1))
|
|
else
|
|
_other -> :ok
|
|
end
|
|
|
|
:ok
|
|
end
|
|
|
|
defp missing_auto_translation_languages(%Post{} = post, metadata) do
|
|
source_language = normalize_language(post.language || metadata.main_language)
|
|
|
|
configured_languages =
|
|
([metadata.main_language] ++ (metadata.blog_languages || []))
|
|
|> Enum.map(&normalize_language/1)
|
|
|> Enum.reject(&(&1 in [nil, ""]))
|
|
|> Enum.uniq()
|
|
|
|
existing_languages =
|
|
Repo.all(
|
|
from translation in Translation,
|
|
where: translation.translation_for == ^post.id,
|
|
select: translation.language
|
|
)
|
|
|
|
configured_languages
|
|
|> Enum.reject(&(&1 == source_language or &1 in existing_languages))
|
|
end
|
|
|
|
defp queue_post_auto_translation(%Post{} = post, language) do
|
|
_ =
|
|
Tasks.submit_task(
|
|
"Auto-translate Post to #{language}",
|
|
fn report ->
|
|
report.(0.05, "Translating post to #{language}")
|
|
|
|
with {:ok, translation} <- AI.translate_post(post.id, language, auto_translation_ai_opts()),
|
|
{:ok, saved_translation} <-
|
|
upsert_post_translation(post.id, language, %{
|
|
title: translation.title,
|
|
excerpt: translation.excerpt,
|
|
content: translation.content,
|
|
auto_generated: true
|
|
}) do
|
|
report.(0.85, "Post translation saved")
|
|
:ok = queue_media_translation_cascade(post, language)
|
|
report.(1.0, "Post translation complete")
|
|
%{post_id: post.id, translation_id: saved_translation.id, language: language}
|
|
else
|
|
{:error, reason} -> {:error, reason}
|
|
end
|
|
end,
|
|
auto_translation_task_attrs(post)
|
|
)
|
|
|
|
:ok
|
|
end
|
|
|
|
defp queue_media_translation_cascade(%Post{} = post, language) do
|
|
linked_media_ids(post.id)
|
|
|> Enum.each(fn media_id ->
|
|
if media_translation_needed?(media_id, language) do
|
|
queue_media_translation(post, media_id, language)
|
|
end
|
|
end)
|
|
|
|
:ok
|
|
end
|
|
|
|
defp queue_media_translation(%Post{} = post, media_id, language) do
|
|
_ =
|
|
Tasks.submit_task(
|
|
"Auto-translate Media to #{language}",
|
|
fn report ->
|
|
report.(0.05, "Translating media to #{language}")
|
|
|
|
with {:ok, translation} <- AI.translate_media(media_id, language, auto_translation_ai_opts()),
|
|
{:ok, saved_translation} <-
|
|
Media.upsert_media_translation(media_id, language, %{
|
|
title: translation.title,
|
|
alt: translation.alt,
|
|
caption: translation.caption
|
|
}) do
|
|
report.(1.0, "Media translation complete")
|
|
%{media_id: media_id, translation_id: saved_translation.id, language: language}
|
|
else
|
|
{:error, reason} -> {:error, reason}
|
|
end
|
|
end,
|
|
auto_translation_task_attrs(post)
|
|
)
|
|
|
|
:ok
|
|
end
|
|
|
|
defp media_translation_needed?(media_id, language) do
|
|
case Repo.get(Media.Media, media_id) do
|
|
%Media.Media{language: source_language} when source_language not in [nil, ""] and source_language != language ->
|
|
not Repo.exists?(
|
|
from translation in Media.Translation,
|
|
where: translation.translation_for == ^media_id and translation.language == ^language
|
|
)
|
|
|
|
_other ->
|
|
false
|
|
end
|
|
end
|
|
|
|
defp auto_translation_task_attrs(%Post{} = post) do
|
|
%{
|
|
group_id: post.project_id,
|
|
group_name: "AI"
|
|
}
|
|
end
|
|
|
|
defp auto_translation_ai_opts do
|
|
Application.get_env(:bds, :posts, [])
|
|
|> Keyword.get(:auto_translation_ai_opts, [])
|
|
end
|
|
|
|
defp auto_translation_configured? do
|
|
mode = if AI.airplane_mode?(), do: :airplane, else: :online
|
|
|
|
case AI.get_endpoint(mode) do
|
|
{:ok, %{url: url, model: model} = endpoint}
|
|
when is_binary(url) and url != "" and is_binary(model) and model != "" ->
|
|
mode == :airplane or present?(Map.get(endpoint, :api_key))
|
|
|
|
_other ->
|
|
false
|
|
end
|
|
end
|
|
|
|
defp linked_media_ids(post_id) do
|
|
Repo.all(
|
|
from pm in PostMedia,
|
|
where: pm.post_id == ^post_id,
|
|
order_by: [asc: pm.sort_order, asc: pm.media_id],
|
|
select: pm.media_id
|
|
)
|
|
end
|
|
|
|
defp sync_deleted_post_media_sidecar(media_id) do
|
|
case Media.sync_media_sidecar(media_id) do
|
|
:ok -> :ok
|
|
{:error, :not_found} -> :ok
|
|
end
|
|
end
|
|
|
|
defp present?(value) when is_binary(value), do: String.trim(value) != ""
|
|
defp present?(value), do: not is_nil(value)
|
|
|
|
defp list_markdown_files_recursive(dir) do
|
|
["*.md", "*.markdown", "*.mdx"]
|
|
|> Enum.flat_map(&list_matching_files(dir, &1))
|
|
|> Enum.uniq()
|
|
|> Enum.sort()
|
|
end
|
|
|
|
defp invalid_database_translation_issue(%Translation{} = translation, source_post_map, metadata) do
|
|
source_post = Map.get(source_post_map, translation.translation_for)
|
|
normalized_language = normalize_language(translation.language)
|
|
|
|
cond do
|
|
is_nil(source_post) ->
|
|
translation_validation_issue(%{
|
|
issue: "missing-source-post",
|
|
translation_id: translation.id,
|
|
translation_for: translation.translation_for,
|
|
translation_language: normalized_language,
|
|
title: translation.title,
|
|
file_path: blank_to_nil(translation.file_path)
|
|
})
|
|
|
|
canonical_translation_language?(source_post, normalized_language, metadata) ->
|
|
translation_validation_issue(%{
|
|
issue: "same-language-as-canonical",
|
|
translation_id: translation.id,
|
|
translation_for: translation.translation_for,
|
|
canonical_language: canonical_translation_language(source_post, metadata),
|
|
translation_language: normalized_language,
|
|
title: translation.title,
|
|
file_path: blank_to_nil(translation.file_path)
|
|
})
|
|
|
|
source_post.do_not_translate ->
|
|
translation_validation_issue(%{
|
|
issue: "do-not-translate-has-translations",
|
|
translation_id: translation.id,
|
|
translation_for: translation.translation_for,
|
|
translation_language: normalized_language,
|
|
title: translation.title,
|
|
file_path: blank_to_nil(translation.file_path)
|
|
})
|
|
|
|
translation.status == :published and present?(translation.content) ->
|
|
translation_validation_issue(%{
|
|
issue: "content-in-database",
|
|
translation_id: translation.id,
|
|
translation_for: translation.translation_for,
|
|
translation_language: normalized_language,
|
|
title: translation.title,
|
|
file_path: blank_to_nil(translation.file_path)
|
|
})
|
|
|
|
true ->
|
|
nil
|
|
end
|
|
end
|
|
|
|
defp invalid_filesystem_translation_issue(file_path, source_post_map, metadata) do
|
|
with {:ok, contents} <- File.read(file_path),
|
|
{:ok, %{fields: fields}} <- Frontmatter.parse_document(contents),
|
|
true <- translation_rebuild_file?(%{fields: fields}) do
|
|
translation_for = DocumentFields.get(fields, "translationFor")
|
|
source_post = Map.get(source_post_map, translation_for)
|
|
normalized_language = normalize_language(DocumentFields.get(fields, "language"))
|
|
title = DocumentFields.get(fields, "title")
|
|
|
|
issue =
|
|
cond do
|
|
is_nil(source_post) ->
|
|
translation_validation_issue(%{
|
|
issue: "missing-source-post",
|
|
translation_for: translation_for,
|
|
translation_language: normalized_language,
|
|
title: title,
|
|
file_path: file_path
|
|
})
|
|
|
|
canonical_translation_language?(source_post, normalized_language, metadata) ->
|
|
translation_validation_issue(%{
|
|
issue: "same-language-as-canonical",
|
|
translation_for: translation_for,
|
|
canonical_language: canonical_translation_language(source_post, metadata),
|
|
translation_language: normalized_language,
|
|
title: title,
|
|
file_path: file_path
|
|
})
|
|
|
|
source_post.do_not_translate ->
|
|
translation_validation_issue(%{
|
|
issue: "do-not-translate-has-translations",
|
|
translation_for: translation_for,
|
|
translation_language: normalized_language,
|
|
title: title,
|
|
file_path: file_path
|
|
})
|
|
|
|
true ->
|
|
nil
|
|
end
|
|
|
|
{:ok, issue}
|
|
else
|
|
false -> :skip
|
|
_other -> :skip
|
|
end
|
|
end
|
|
|
|
defp normalize_translation_validation_report(report) do
|
|
%{
|
|
checked_database_row_count: map_value(report, :checked_database_row_count, 0),
|
|
checked_filesystem_file_count: map_value(report, :checked_filesystem_file_count, 0),
|
|
invalid_database_rows:
|
|
report
|
|
|> map_value(:invalid_database_rows, [])
|
|
|> Enum.map(&normalize_translation_validation_issue/1),
|
|
invalid_filesystem_files:
|
|
report
|
|
|> map_value(:invalid_filesystem_files, [])
|
|
|> Enum.map(&normalize_translation_validation_issue/1)
|
|
}
|
|
end
|
|
|
|
defp legacy_missing_translation_entries(source_posts, translation_rows, metadata) do
|
|
configured_languages =
|
|
([Map.get(metadata, :main_language)] ++ Map.get(metadata, :blog_languages, []))
|
|
|> Enum.map(&normalize_language/1)
|
|
|> Enum.reject(&(&1 in [nil, ""]))
|
|
|> Enum.uniq()
|
|
|
|
existing_languages_by_post =
|
|
Enum.reduce(translation_rows, %{}, fn translation, acc ->
|
|
Map.update(
|
|
acc,
|
|
translation.translation_for,
|
|
MapSet.new([normalize_language(translation.language)]),
|
|
&MapSet.put(&1, normalize_language(translation.language))
|
|
)
|
|
end)
|
|
|
|
source_posts
|
|
|> Enum.filter(&(&1.status == :published and not &1.do_not_translate))
|
|
|> Enum.flat_map(fn post ->
|
|
canonical_language = canonical_translation_language(post, metadata)
|
|
existing_languages = Map.get(existing_languages_by_post, post.id, MapSet.new())
|
|
|
|
configured_languages
|
|
|> Enum.reject(&(&1 == canonical_language or MapSet.member?(existing_languages, &1)))
|
|
|> Enum.map(&%{post_id: post.id, language: &1})
|
|
end)
|
|
|> Enum.sort_by(&{&1.post_id, &1.language})
|
|
end
|
|
|
|
defp legacy_orphan_translation_files(invalid_filesystem_files, project_data_dir) do
|
|
invalid_filesystem_files
|
|
|> Enum.filter(&(Map.get(&1, :issue) == "missing-source-post"))
|
|
|> Enum.map(fn issue ->
|
|
issue
|
|
|> Map.get(:file_path)
|
|
|> relative_project_data_path(project_data_dir)
|
|
end)
|
|
|> Enum.reject(&is_nil/1)
|
|
|> Enum.sort()
|
|
end
|
|
|
|
defp legacy_do_not_translate_posts(source_posts) do
|
|
source_posts
|
|
|> Enum.filter(&(&1.status == :published and &1.do_not_translate))
|
|
|> Enum.map(& &1.id)
|
|
|> Enum.sort()
|
|
end
|
|
|
|
defp normalize_translation_validation_issue(issue) when is_map(issue) do
|
|
%{
|
|
issue: map_value(issue, :issue),
|
|
translation_id: blank_to_nil(map_value(issue, :translation_id)),
|
|
translation_for: map_value(issue, :translation_for),
|
|
canonical_language: blank_to_nil(map_value(issue, :canonical_language)),
|
|
translation_language: map_value(issue, :translation_language),
|
|
title: blank_to_nil(map_value(issue, :title)),
|
|
file_path: blank_to_nil(map_value(issue, :file_path))
|
|
}
|
|
end
|
|
|
|
defp fix_invalid_database_translation(%{issue: "content-in-database", translation_id: translation_id})
|
|
when is_binary(translation_id) do
|
|
case Repo.get(Translation, translation_id) do
|
|
%Translation{} = translation ->
|
|
case Repo.get(Post, translation.translation_for) do
|
|
%Post{} = post ->
|
|
:ok = publish_translation(post, translation)
|
|
{:flushed, translation.translation_for}
|
|
|
|
nil ->
|
|
:noop
|
|
end
|
|
|
|
nil ->
|
|
:noop
|
|
end
|
|
end
|
|
|
|
defp fix_invalid_database_translation(%{translation_id: translation_id, translation_for: translation_for})
|
|
when is_binary(translation_id) do
|
|
case Repo.get(Translation, translation_id) do
|
|
%Translation{} = translation ->
|
|
Repo.delete!(translation)
|
|
{:deleted, translation_for}
|
|
|
|
nil ->
|
|
:noop
|
|
end
|
|
end
|
|
|
|
defp fix_invalid_database_translation(_issue), do: :noop
|
|
|
|
defp delete_translation_validation_file(file_path) when file_path in [nil, ""], do: false
|
|
|
|
defp delete_translation_validation_file(file_path) do
|
|
case File.rm(file_path) do
|
|
:ok -> true
|
|
{:error, :enoent} -> false
|
|
{:error, _reason} -> false
|
|
end
|
|
end
|
|
|
|
defp translation_validation_issue(attrs) do
|
|
%{
|
|
issue: Map.get(attrs, :issue),
|
|
translation_id: Map.get(attrs, :translation_id),
|
|
translation_for: Map.get(attrs, :translation_for),
|
|
canonical_language: Map.get(attrs, :canonical_language),
|
|
translation_language: Map.get(attrs, :translation_language),
|
|
title: Map.get(attrs, :title),
|
|
file_path: Map.get(attrs, :file_path)
|
|
}
|
|
end
|
|
|
|
defp translation_validation_issue_sort_key(issue) do
|
|
[Map.get(issue, :translation_for), Map.get(issue, :translation_id), Map.get(issue, :file_path)]
|
|
|> Enum.map(&to_string(&1 || ""))
|
|
|> Enum.join(":")
|
|
end
|
|
|
|
defp canonical_translation_language(source_post, metadata) do
|
|
language = normalize_language(source_post.language)
|
|
|
|
if language == "" do
|
|
normalize_language(Map.get(metadata, :main_language))
|
|
else
|
|
language
|
|
end
|
|
end
|
|
|
|
defp canonical_translation_language?(source_post, language, metadata) do
|
|
canonical_language = canonical_translation_language(source_post, metadata)
|
|
canonical_language != "" and canonical_language == normalize_language(language)
|
|
end
|
|
|
|
defp map_value(map, key, default \\ nil) when is_map(map) do
|
|
Map.get(map, key, Map.get(map, Atom.to_string(key), default))
|
|
end
|
|
|
|
defp blank_to_nil(value) when is_binary(value) do
|
|
case String.trim(value) do
|
|
"" -> nil
|
|
trimmed -> trimmed
|
|
end
|
|
end
|
|
|
|
defp blank_to_nil(value), do: value
|
|
|
|
defp relative_project_data_path(nil, _project_data_dir), do: nil
|
|
|
|
defp relative_project_data_path(file_path, project_data_dir) do
|
|
case Path.relative_to(file_path, project_data_dir) do
|
|
relative_path when relative_path == file_path -> file_path
|
|
relative_path -> relative_path
|
|
end
|
|
end
|
|
|
|
defp maybe_put_synced_post(set, post_id) when is_binary(post_id) and post_id != "", do: MapSet.put(set, post_id)
|
|
defp maybe_put_synced_post(set, _post_id), do: set
|
|
|
|
defp normalize_language(nil), do: ""
|
|
|
|
defp normalize_language(language) do
|
|
language
|
|
|> to_string()
|
|
|> String.downcase()
|
|
|> String.split("-", parts: 2)
|
|
|> hd()
|
|
end
|
|
|
|
defp has_attr?(attrs, key) do
|
|
Map.has_key?(attrs, key) or Map.has_key?(attrs, Atom.to_string(key))
|
|
end
|
|
|
|
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
|