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

feat: more work on M4

Browse Source
This commit is contained in:
Chili Palmer
2026-04-10 16:19:01 +02:00
parent 3ca80b00d0
commit ab3fae08ba
13 changed files with 1380 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

650
crates/bds-ui/src/app.rs
View File

@@ -4,6 +4,7 @@ use std::sync::Arc;
use chrono::Datelike;
use iced::{Element, Subscription, Task};
use serde_json::json;
use bds_core::db::Database;
use bds_core::engine::task::{TaskId, TaskManager, TaskStatus};
@@ -118,6 +119,8 @@ pub enum Message {
ShowModal(modal::ModalState),
DismissModal,
ConfirmModal(modal::ConfirmAction),
ToggleAiSuggestionField(usize, bool),
ApplyAiSuggestions(modal::AiEntityTarget, Vec<modal::AiSuggestionField>),
// Blog actions (dispatched to engine)
RebuildDatabase,
@@ -217,6 +220,11 @@ enum PersistedMediaState {
Translation,
}
struct PreviewSession {
project_id: String,
handle: engine::preview::PreviewServerHandle,
}
fn persist_media_editor_state_impl(
db: &Database,
data_dir: &Path,
@@ -1162,6 +1170,9 @@ pub struct BdsApp {
// Modal
active_modal: Option<modal::ModalState>,
// Local preview
preview_session: Option<PreviewSession>,
// Editor states (keyed by entity id)
post_editors: HashMap<String, PostEditorState>,
media_editors: HashMap<String, MediaEditorState>,
@@ -1288,6 +1299,7 @@ impl BdsApp {
theme_badge: String::from("pico"),
toasts: Vec::new(),
active_modal: None,
preview_session: None,
post_editors: HashMap::new(),
media_editors: HashMap::new(),
template_editors: HashMap::new(),
@@ -1342,6 +1354,7 @@ impl BdsApp {
theme_badge: String::from("pico"),
toasts: Vec::new(),
active_modal: None,
preview_session: None,
post_editors: HashMap::new(),
media_editors: HashMap::new(),
template_editors: HashMap::new(),
@@ -1512,6 +1525,7 @@ impl BdsApp {
match engine::project::set_active_project(db.conn(), &project_id) {
Ok(()) => {
self.active_project = self.projects.iter().find(|p| p.id == project_id).cloned();
self.preview_session = None;
self.data_dir = self
.active_project
.as_ref()
@@ -1562,6 +1576,7 @@ impl BdsApp {
let _ = engine::project::set_active_project(db.conn(), &project.id);
self.projects = engine::project::list_projects(db.conn()).unwrap_or_default();
self.active_project = Some(project.clone());
self.preview_session = None;
self.data_dir = project.data_path.as_ref().map(PathBuf::from);
let msg = tw(self.ui_locale, "projectSelector.toast.created", &[("name", &project.name)]);
self.notify(ToastLevel::Success, &msg);
@@ -2042,11 +2057,30 @@ impl BdsApp {
}
}
}
Message::ToggleAiSuggestionField(index, accepted) => {
if let Some(modal::ModalState::AISuggestions { fields, .. }) = self.active_modal.as_mut() {
if let Some(field) = fields.get_mut(index) {
if !field.locked {
field.accepted = accepted;
}
}
}
Task::none()
}
Message::ApplyAiSuggestions(target, fields) => {
self.active_modal = None;
self.apply_ai_suggestions(target, &fields)
}
// ── Editor view messages ──
Message::PostEditor(msg) => {
enum DeferredPostAction {
None,
Analyze(String),
AnalyzeTaxonomy(String),
DetectLanguage(String),
OpenTranslate(String),
TranslateTo { post_id: String, target_language: String },
Save(String),
Publish(String),
Duplicate(String),
@@ -2076,6 +2110,21 @@ impl BdsApp {
if let Some(tab_id) = self.active_tab.clone() {
if let Some(state) = self.post_editors.get_mut(&tab_id) {
match msg {
PostEditorMsg::AnalyzeWithAi => {
deferred = DeferredPostAction::Analyze(tab_id.clone());
}
PostEditorMsg::AnalyzeTaxonomy => {
deferred = DeferredPostAction::AnalyzeTaxonomy(tab_id.clone());
}
PostEditorMsg::DetectLanguage => {
deferred = DeferredPostAction::DetectLanguage(tab_id.clone());
}
PostEditorMsg::Translate => {
deferred = DeferredPostAction::OpenTranslate(tab_id.clone());
}
PostEditorMsg::TranslateTo(target_language) => {
deferred = DeferredPostAction::TranslateTo { post_id: tab_id.clone(), target_language };
}
PostEditorMsg::TitleChanged(s) => { state.title = s; state.mark_dirty(); }
PostEditorMsg::SlugChanged(s) => { state.slug = s; state.mark_dirty(); }
PostEditorMsg::ExcerptChanged(s) => { state.excerpt = s; state.mark_dirty(); }
@@ -2216,6 +2265,13 @@ impl BdsApp {
match deferred {
DeferredPostAction::None => Task::none(),
DeferredPostAction::Analyze(tab_id) => self.run_post_ai_analysis(&tab_id),
DeferredPostAction::AnalyzeTaxonomy(tab_id) => self.run_post_taxonomy_analysis(&tab_id),
DeferredPostAction::DetectLanguage(tab_id) => self.detect_post_language(&tab_id),
DeferredPostAction::OpenTranslate(tab_id) => self.open_post_translation_modal(&tab_id),
DeferredPostAction::TranslateTo { post_id, target_language } => {
self.translate_post_to(&post_id, &target_language)
}
DeferredPostAction::Save(tab_id) => self.save_post_editor(&tab_id),
DeferredPostAction::Publish(tab_id) => self.publish_post_editor(&tab_id),
DeferredPostAction::Duplicate(tab_id) => self.duplicate_post_editor(&tab_id),
@@ -2331,6 +2387,10 @@ impl BdsApp {
Message::MediaEditor(msg) => {
enum DeferredMediaAction {
None,
Analyze(String),
DetectLanguage(String),
OpenTranslate(String),
TranslateTo { media_id: String, target_language: String },
LinkPost { media_id: String, post_id: String },
OpenLinkedPost(String),
UnlinkPost { media_id: String, post_id: String },
@@ -2343,6 +2403,18 @@ impl BdsApp {
if let Some(tab_id) = self.active_tab.clone() {
if let Some(state) = self.media_editors.get_mut(&tab_id) {
match msg {
MediaEditorMsg::AnalyzeWithAi => {
deferred = DeferredMediaAction::Analyze(tab_id.clone());
}
MediaEditorMsg::DetectLanguage => {
deferred = DeferredMediaAction::DetectLanguage(tab_id.clone());
}
MediaEditorMsg::TranslateMetadata => {
deferred = DeferredMediaAction::OpenTranslate(tab_id.clone());
}
MediaEditorMsg::TranslateTo(target_language) => {
deferred = DeferredMediaAction::TranslateTo { media_id: tab_id.clone(), target_language };
}
MediaEditorMsg::TitleChanged(s) => { state.title = s; state.is_dirty = true; }
MediaEditorMsg::AltChanged(s) => { state.alt = s; state.is_dirty = true; }
MediaEditorMsg::CaptionChanged(s) => { state.caption = s; state.is_dirty = true; }
@@ -2403,6 +2475,12 @@ impl BdsApp {
}
match deferred {
DeferredMediaAction::None => Task::none(),
DeferredMediaAction::Analyze(media_id) => self.run_media_ai_analysis(&media_id),
DeferredMediaAction::DetectLanguage(media_id) => self.detect_media_language(&media_id),
DeferredMediaAction::OpenTranslate(media_id) => self.open_media_translation_modal(&media_id),
DeferredMediaAction::TranslateTo { media_id, target_language } => {
self.translate_media_to(&media_id, &target_language)
}
DeferredMediaAction::LinkPost { media_id, post_id } => self.link_media_to_post(&media_id, &post_id),
DeferredMediaAction::OpenLinkedPost(post_id) => {
let title = self
@@ -2704,7 +2782,7 @@ impl BdsApp {
t(self.ui_locale, "dialog.imageFilter"),
),
MenuAction::Save => Task::none(), // Disabled in M2
MenuAction::OpenInBrowser => Task::none(),
MenuAction::OpenInBrowser => self.preview_active_post(),
MenuAction::OpenDataFolder => {
if let Some(ref dir) = self.data_dir {
let _ = open::that(dir);
@@ -2733,7 +2811,7 @@ impl BdsApp {
}
// Blog
MenuAction::PublishSelected => Task::none(), // Disabled in M2
MenuAction::PreviewPost => Task::none(), // Disabled in M2
MenuAction::PreviewPost => self.preview_active_post(),
MenuAction::EditMenu => {
self.open_singleton_tab(TabType::MenuEditor, "tabBar.menuEditor");
Task::none()
@@ -3603,13 +3681,17 @@ impl BdsApp {
/// offline toggle) so that menu items reflect what's actually possible.
fn sync_menu_state(&self) {
let has_project = self.active_project.is_some();
let has_tab = self.active_tab.is_some();
let active_tab_type = self.active_tab.as_ref().and_then(|id| {
self.tabs.iter().find(|t| t.id == *id).map(|t| &t.tab_type)
});
let has_tab = active_tab_type.is_some();
let has_post_tab = active_tab_type == Some(&TabType::Post);
// File group: need active project for most, need open tab for Save
self.menu_registry.set_enabled(MenuAction::NewPost, has_project);
self.menu_registry.set_enabled(MenuAction::ImportMedia, has_project);
self.menu_registry.set_enabled(MenuAction::Save, has_tab);
self.menu_registry.set_enabled(MenuAction::OpenInBrowser, has_tab);
self.menu_registry.set_enabled(MenuAction::OpenInBrowser, has_project && has_post_tab);
self.menu_registry.set_enabled(MenuAction::OpenDataFolder, has_project);
// Edit: Find/Replace need an open tab
@@ -3618,7 +3700,7 @@ impl BdsApp {
// Blog group: need active project
self.menu_registry.set_enabled(MenuAction::PublishSelected, has_project && has_tab);
self.menu_registry.set_enabled(MenuAction::PreviewPost, has_project && has_tab);
self.menu_registry.set_enabled(MenuAction::PreviewPost, has_project && has_post_tab);
self.menu_registry.set_enabled(MenuAction::EditMenu, has_project);
self.menu_registry.set_enabled(MenuAction::RebuildDatabase, has_project);
self.menu_registry.set_enabled(MenuAction::ReindexText, has_project);
@@ -5575,4 +5657,562 @@ impl BdsApp {
api_key,
})
}
fn preview_active_post(&mut self) -> Task<Message> {
let Some(active_id) = self.active_tab.clone() else {
return Task::none();
};
if !self
.tabs
.iter()
.any(|tab| tab.id == active_id && tab.tab_type == TabType::Post)
{
return Task::none();
}
if let Err(error) = self.persist_post_editor_state(&active_id) {
self.notify(ToastLevel::Error, &error);
return Task::none();
}
let Some(project) = self.active_project.as_ref() else {
self.notify(ToastLevel::Error, &t(self.ui_locale, "engine.generateSiteNoProject"));
return Task::none();
};
let Some(data_dir) = self.data_dir.clone() else {
self.notify(ToastLevel::Error, &t(self.ui_locale, "engine.previewDataDirUnavailable"));
return Task::none();
};
let should_restart = self
.preview_session
.as_ref()
.map(|session| session.project_id != project.id)
.unwrap_or(true);
if should_restart {
self.preview_session = None;
match engine::preview::start_preview_server(
self.db_path.clone(),
data_dir,
project.id.clone(),
) {
Ok(handle) => {
self.preview_session = Some(PreviewSession {
project_id: project.id.clone(),
handle,
});
}
Err(engine::EngineError::Conflict(_)) if self.preview_session.is_none() => {
self.notify(ToastLevel::Error, &t(self.ui_locale, "engine.previewPortInUse"));
return Task::none();
}
Err(error) => {
self.notify(ToastLevel::Error, &error.to_string());
return Task::none();
}
}
}
if let Some(session) = &self.preview_session {
let _ = &session.handle;
}
let language = self
.post_editors
.get(&active_id)
.map(|editor| editor.active_language.clone())
.filter(|language| !language.is_empty())
.unwrap_or_else(|| self.content_language.clone());
let url = format!(
"http://{}:{}/__draft/{}?language={}",
engine::preview::PREVIEW_HOST,
engine::preview::PREVIEW_PORT,
active_id,
language
);
if let Err(error) = open::that(&url) {
self.notify(ToastLevel::Error, &error.to_string());
}
Task::none()
}
fn run_post_ai_analysis(&mut self, post_id: &str) -> Task<Message> {
let Some(db) = &self.db else {
self.notify(ToastLevel::Error, "database unavailable");
return Task::none();
};
let Some(state) = self.post_editors.get(post_id).cloned() else {
return Task::none();
};
let request = ai::OneShotRequest {
operation: ai::OneShotOperation::AnalyzePost,
content: json!({
"title": state.title,
"excerpt": state.excerpt,
"content": content_sample(&state.content, 2000),
}),
};
match ai::run_one_shot(db.conn(), self.offline_mode, &request) {
Ok(ai::OneShotResponse::PostAnalysis(result)) => {
self.active_modal = Some(modal::ModalState::AISuggestions {
target: modal::AiEntityTarget::Post(post_id.to_string()),
fields: vec![
modal::AiSuggestionField {
key: "title".to_string(),
label: t(self.ui_locale, "editor.title"),
current_value: state.title,
suggested_value: result.title,
accepted: true,
locked: false,
},
modal::AiSuggestionField {
key: "excerpt".to_string(),
label: t(self.ui_locale, "editor.excerpt"),
current_value: state.excerpt,
suggested_value: result.excerpt,
accepted: true,
locked: false,
},
modal::AiSuggestionField {
key: "slug".to_string(),
label: t(self.ui_locale, "editor.slug"),
current_value: state.slug,
suggested_value: result.slug,
accepted: state.published_at.is_none(),
locked: state.published_at.is_some(),
},
],
});
}
Ok(_) => {}
Err(error) => self.notify(ToastLevel::Error, &error.to_string()),
}
Task::none()
}
fn run_post_taxonomy_analysis(&mut self, post_id: &str) -> Task<Message> {
let Some(db) = &self.db else {
self.notify(ToastLevel::Error, "database unavailable");
return Task::none();
};
let Some(state) = self.post_editors.get(post_id).cloned() else {
return Task::none();
};
let request = ai::OneShotRequest {
operation: ai::OneShotOperation::AnalyzeTaxonomy,
content: json!({
"title": state.title,
"excerpt": state.excerpt,
"content": content_sample(&state.content, 2000),
"tags": state.tags,
"categories": state.categories,
}),
};
match ai::run_one_shot(db.conn(), self.offline_mode, &request) {
Ok(ai::OneShotResponse::Taxonomy(result)) => {
self.active_modal = Some(modal::ModalState::AISuggestions {
target: modal::AiEntityTarget::Post(post_id.to_string()),
fields: vec![
modal::AiSuggestionField {
key: "tags".to_string(),
label: t(self.ui_locale, "sidebar.filter.tags"),
current_value: state.tags.join(", "),
suggested_value: result.tags.join(", "),
accepted: true,
locked: false,
},
modal::AiSuggestionField {
key: "categories".to_string(),
label: t(self.ui_locale, "sidebar.filter.categories"),
current_value: state.categories.join(", "),
suggested_value: result.categories.join(", "),
accepted: true,
locked: false,
},
],
});
}
Ok(_) => {}
Err(error) => self.notify(ToastLevel::Error, &error.to_string()),
}
Task::none()
}
fn detect_post_language(&mut self, post_id: &str) -> Task<Message> {
let Some(db) = &self.db else {
self.notify(ToastLevel::Error, "database unavailable");
return Task::none();
};
let Some(state) = self.post_editors.get(post_id).cloned() else {
return Task::none();
};
let request = ai::OneShotRequest {
operation: ai::OneShotOperation::DetectLanguage,
content: json!({
"text": format!("{}\n\n{}\n\n{}", state.title, state.excerpt, content_sample(&state.content, 2000)),
}),
};
match ai::run_one_shot(db.conn(), self.offline_mode, &request) {
Ok(ai::OneShotResponse::LanguageDetection(result)) => {
if let Some(editor) = self.post_editors.get_mut(post_id) {
editor.language = result.language_code;
editor.mark_dirty();
}
if let Err(error) = self.persist_post_editor_state(post_id) {
self.notify(ToastLevel::Error, &error);
} else {
self.notify(ToastLevel::Success, &t(self.ui_locale, "editor.saved"));
}
}
Ok(_) => {}
Err(error) => self.notify(ToastLevel::Error, &error.to_string()),
}
Task::none()
}
fn open_post_translation_modal(&mut self, post_id: &str) -> Task<Message> {
let Some(state) = self.post_editors.get(post_id) else {
return Task::none();
};
let targets = self
.blog_languages
.iter()
.filter(|language| **language != state.active_language)
.map(|language| modal::LanguageTarget {
code: language.clone(),
name: language_label(self.ui_locale, language),
flag_emoji: bds_core::i18n::normalize_language(language).flag_emoji().to_string(),
has_existing_translation: state.translation_drafts.contains_key(language),
existing_status: state.translation_drafts.get(language).map(|draft| match draft.status {
PostStatus::Draft => "draft".to_string(),
PostStatus::Published => "published".to_string(),
PostStatus::Archived => "archived".to_string(),
}),
})
.collect::<Vec<_>>();
self.active_modal = Some(modal::ModalState::LanguagePicker {
target: modal::AiEntityTarget::Post(post_id.to_string()),
source_language: state.active_language.clone(),
available_targets: targets,
});
Task::none()
}
fn translate_post_to(&mut self, post_id: &str, target_language: &str) -> Task<Message> {
self.active_modal = None;
let Some(db) = &self.db else {
self.notify(ToastLevel::Error, "database unavailable");
return Task::none();
};
let Some(data_dir) = &self.data_dir else {
self.notify(ToastLevel::Error, "project data directory unavailable");
return Task::none();
};
let Some(state) = self.post_editors.get(post_id).cloned() else {
return Task::none();
};
if state.active_language == state.canonical_language && state.status == PostStatus::Published {
match engine::post::update_post(
db.conn(),
data_dir,
post_id,
Some(&state.title),
None,
Some(Some(state.excerpt.as_str())),
Some(&state.content),
Some(state.tags.clone()),
Some(state.categories.clone()),
Some(Some(state.author.as_str())),
Some(Some(state.language.as_str())),
Some(Some(state.template_slug.as_str())),
Some(state.do_not_translate),
) {
Ok(updated) => {
if let Some(editor) = self.post_editors.get_mut(post_id) {
editor.status = updated.status;
}
}
Err(error) => {
self.notify(ToastLevel::Error, &error.to_string());
return Task::none();
}
}
}
let request = ai::OneShotRequest {
operation: ai::OneShotOperation::TranslatePost { target_language: target_language.to_string() },
content: json!({
"title": state.title,
"excerpt": state.excerpt,
"content": state.content,
}),
};
match ai::run_one_shot(db.conn(), self.offline_mode, &request) {
Ok(ai::OneShotResponse::Translation(result)) => {
if let Some(editor) = self.post_editors.get_mut(post_id) {
editor.switch_language(target_language);
editor.title = result.title.clone();
editor.excerpt = result.excerpt.clone();
editor.content = result.content.clone();
editor.editor_buffer = std::cell::RefCell::new(bds_editor::EditorBuffer::new(&result.content));
editor.mark_dirty();
}
if let Err(error) = self.persist_post_editor_state(post_id) {
self.notify(ToastLevel::Error, &error);
} else {
self.notify(ToastLevel::Success, &t(self.ui_locale, "editor.saved"));
}
}
Ok(_) => {}
Err(error) => self.notify(ToastLevel::Error, &error.to_string()),
}
Task::none()
}
fn run_media_ai_analysis(&mut self, media_id: &str) -> Task<Message> {
let Some(db) = &self.db else {
self.notify(ToastLevel::Error, "database unavailable");
return Task::none();
};
let Some(state) = self.media_editors.get(media_id).cloned() else {
return Task::none();
};
let request = ai::OneShotRequest {
operation: ai::OneShotOperation::AnalyzeImage,
content: json!({
"title": state.title,
"alt": state.alt,
"caption": state.caption,
"filename": state.original_name,
"mime_type": state.mime_type,
}),
};
match ai::run_one_shot(db.conn(), self.offline_mode, &request) {
Ok(ai::OneShotResponse::ImageAnalysis(result)) => {
self.active_modal = Some(modal::ModalState::AISuggestions {
target: modal::AiEntityTarget::Media(media_id.to_string()),
fields: vec![
modal::AiSuggestionField {
key: "title".to_string(),
label: t(self.ui_locale, "editor.title"),
current_value: state.title,
suggested_value: result.title,
accepted: true,
locked: false,
},
modal::AiSuggestionField {
key: "alt".to_string(),
label: t(self.ui_locale, "editor.alt"),
current_value: state.alt,
suggested_value: result.alt,
accepted: true,
locked: false,
},
modal::AiSuggestionField {
key: "caption".to_string(),
label: t(self.ui_locale, "editor.caption"),
current_value: state.caption,
suggested_value: result.caption,
accepted: true,
locked: false,
},
],
});
}
Ok(_) => {}
Err(error) => self.notify(ToastLevel::Error, &error.to_string()),
}
Task::none()
}
fn detect_media_language(&mut self, media_id: &str) -> Task<Message> {
let Some(db) = &self.db else {
self.notify(ToastLevel::Error, "database unavailable");
return Task::none();
};
let Some(state) = self.media_editors.get(media_id).cloned() else {
return Task::none();
};
let request = ai::OneShotRequest {
operation: ai::OneShotOperation::DetectLanguage,
content: json!({
"text": format!("{}\n{}\n{}", state.title, state.alt, state.caption),
}),
};
match ai::run_one_shot(db.conn(), self.offline_mode, &request) {
Ok(ai::OneShotResponse::LanguageDetection(result)) => {
if let Some(editor) = self.media_editors.get_mut(media_id) {
editor.language = result.language_code;
editor.is_dirty = true;
}
if let Err(error) = self.persist_media_editor_state(media_id) {
self.notify(ToastLevel::Error, &error);
} else {
self.notify(ToastLevel::Success, &t(self.ui_locale, "editor.saved"));
}
}
Ok(_) => {}
Err(error) => self.notify(ToastLevel::Error, &error.to_string()),
}
Task::none()
}
fn open_media_translation_modal(&mut self, media_id: &str) -> Task<Message> {
let Some(state) = self.media_editors.get(media_id) else {
return Task::none();
};
let targets = self
.blog_languages
.iter()
.filter(|language| **language != state.active_language)
.map(|language| modal::LanguageTarget {
code: language.clone(),
name: language_label(self.ui_locale, language),
flag_emoji: bds_core::i18n::normalize_language(language).flag_emoji().to_string(),
has_existing_translation: state.translation_drafts.contains_key(language),
existing_status: state.translation_drafts.get(language).map(|_| "draft".to_string()),
})
.collect::<Vec<_>>();
self.active_modal = Some(modal::ModalState::LanguagePicker {
target: modal::AiEntityTarget::Media(media_id.to_string()),
source_language: state.active_language.clone(),
available_targets: targets,
});
Task::none()
}
fn translate_media_to(&mut self, media_id: &str, target_language: &str) -> Task<Message> {
self.active_modal = None;
let Some(db) = &self.db else {
self.notify(ToastLevel::Error, "database unavailable");
return Task::none();
};
let Some(state) = self.media_editors.get(media_id).cloned() else {
return Task::none();
};
let source_language = if state.language.is_empty() {
match ai::run_one_shot(
db.conn(),
self.offline_mode,
&ai::OneShotRequest {
operation: ai::OneShotOperation::DetectLanguage,
content: json!({ "text": format!("{}\n{}\n{}", state.title, state.alt, state.caption) }),
},
) {
Ok(ai::OneShotResponse::LanguageDetection(result)) => result.language_code,
Ok(_) => String::new(),
Err(error) => {
self.notify(ToastLevel::Error, &error.to_string());
return Task::none();
}
}
} else {
state.language.clone()
};
if let Some(editor) = self.media_editors.get_mut(media_id) {
if editor.language.is_empty() {
editor.language = source_language;
}
}
let request = ai::OneShotRequest {
operation: ai::OneShotOperation::TranslateMedia { target_language: target_language.to_string() },
content: json!({
"title": state.title,
"alt": state.alt,
"caption": state.caption,
}),
};
match ai::run_one_shot(db.conn(), self.offline_mode, &request) {
Ok(ai::OneShotResponse::MediaTranslation(result)) => {
if let Some(editor) = self.media_editors.get_mut(media_id) {
editor.switch_language(target_language);
editor.title = result.title.clone();
editor.alt = result.alt.clone();
editor.caption = result.caption.clone();
editor.is_dirty = true;
}
if let Err(error) = self.persist_media_editor_state(media_id) {
self.notify(ToastLevel::Error, &error);
} else {
self.notify(ToastLevel::Success, &t(self.ui_locale, "editor.saved"));
}
}
Ok(_) => {}
Err(error) => self.notify(ToastLevel::Error, &error.to_string()),
}
Task::none()
}
fn apply_ai_suggestions(
&mut self,
target: modal::AiEntityTarget,
fields: &[modal::AiSuggestionField],
) -> Task<Message> {
match target {
modal::AiEntityTarget::Post(post_id) => {
if let Some(editor) = self.post_editors.get_mut(&post_id) {
for field in fields.iter().filter(|field| field.accepted && !field.locked) {
match field.key.as_str() {
"title" => editor.title = field.suggested_value.clone(),
"excerpt" => editor.excerpt = field.suggested_value.clone(),
"slug" => editor.slug = field.suggested_value.clone(),
"tags" => {
editor.tags = split_csv_values(&field.suggested_value);
editor.tags_input.clear();
}
"categories" => {
editor.categories = split_csv_values(&field.suggested_value);
editor.categories_input.clear();
}
_ => {}
}
}
editor.mark_dirty();
}
if let Err(error) = self.persist_post_editor_state(&post_id) {
self.notify(ToastLevel::Error, &error);
} else {
self.notify(ToastLevel::Success, &t(self.ui_locale, "editor.saved"));
}
}
modal::AiEntityTarget::Media(media_id) => {
if let Some(editor) = self.media_editors.get_mut(&media_id) {
for field in fields.iter().filter(|field| field.accepted && !field.locked) {
match field.key.as_str() {
"title" => editor.title = field.suggested_value.clone(),
"alt" => editor.alt = field.suggested_value.clone(),
"caption" => editor.caption = field.suggested_value.clone(),
_ => {}
}
}
editor.is_dirty = true;
}
if let Err(error) = self.persist_media_editor_state(&media_id) {
self.notify(ToastLevel::Error, &error);
} else {
self.notify(ToastLevel::Success, &t(self.ui_locale, "editor.saved"));
}
}
}
Task::none()
}
}
fn content_sample(content: &str, max_len: usize) -> String {
content.chars().take(max_len).collect()
}
fn split_csv_values(value: &str) -> Vec<String> {
value
.split(',')
.map(str::trim)
.filter(|item| !item.is_empty())
.map(|item| item.to_string())
.collect()
}
fn language_label(locale: UiLocale, code: &str) -> String {
let key = format!("language.{code}");
let value = t(locale, &key);
if value == key { code.to_string() } else { value }
}

20
crates/bds-ui/src/views/media_editor.rs
View File

@@ -197,6 +197,10 @@ impl MediaEditorState {
/// Media editor messages.
#[derive(Debug, Clone)]
pub enum MediaEditorMsg {
AnalyzeWithAi,
DetectLanguage,
TranslateMetadata,
TranslateTo(String),
TitleChanged(String),
AltChanged(String),
CaptionChanged(String),
@@ -224,6 +228,22 @@ pub fn view<'a>(
text(state.original_name.clone()).size(18).into(),
],
vec![
if state.mime_type.starts_with("image/") {
button(text(t(locale, "editor.aiAnalyze")).size(13))
.on_press(Message::MediaEditor(MediaEditorMsg::AnalyzeWithAi))
.padding([6, 16])
.into()
} else {
Space::new(0, 0).into()
},
button(text(t(locale, "editor.detectLanguage")).size(13))
.on_press(Message::MediaEditor(MediaEditorMsg::DetectLanguage))
.padding([6, 16])
.into(),
button(text(t(locale, "editor.translate")).size(13))
.on_press(Message::MediaEditor(MediaEditorMsg::TranslateMetadata))
.padding([6, 16])
.into(),
button(text(t(locale, "common.save")).size(13))
.on_press(Message::MediaEditor(MediaEditorMsg::Save))
.style(inputs::primary_button)

149
crates/bds-ui/src/views/modal.rs
View File

@@ -1,7 +1,7 @@
use std::path::Path;
use iced::widget::text::Shaping;
use iced::widget::{button, column, container, image, row, text, text_input, Space};
use iced::widget::{button, checkbox, column, container, image, row, scrollable, text, text_input, Space};
use iced::{Alignment, Background, Border, Color, Element, Length, Theme};
use bds_core::i18n::UiLocale;
@@ -20,6 +20,31 @@ pub struct InsertLinkResult {
pub canonical_url: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AiEntityTarget {
Post(String),
Media(String),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AiSuggestionField {
pub key: String,
pub label: String,
pub current_value: String,
pub suggested_value: String,
pub accepted: bool,
pub locked: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LanguageTarget {
pub code: String,
pub name: String,
pub flag_emoji: String,
pub has_existing_translation: bool,
pub existing_status: Option<String>,
}
/// Active modal state. Only one modal at a time.
#[derive(Debug, Clone)]
pub enum ModalState {
@@ -60,6 +85,15 @@ pub enum ModalState {
media_list: Vec<bds_core::model::Media>,
selected_index: Option<usize>,
},
AISuggestions {
target: AiEntityTarget,
fields: Vec<AiSuggestionField>,
},
LanguagePicker {
target: AiEntityTarget,
source_language: String,
available_targets: Vec<LanguageTarget>,
},
}
#[derive(Debug, Clone, Copy, PartialEq)]
@@ -874,6 +908,119 @@ pub fn view(state: ModalState, locale: UiLocale, data_dir: Option<&Path>) -> Ele
.style(modal_box_style)
.into()
}
ModalState::AISuggestions { target, fields } => {
let title = text(t(locale, "modal.aiSuggestions.title"))
.size(16)
.shaping(Shaping::Advanced)
.color(Color::WHITE);
let rows = fields.iter().enumerate().map(|(index, field)| {
let toggle = checkbox(field.label.clone(), field.accepted)
.on_toggle_maybe((!field.locked)
.then_some(move |value| Message::ToggleAiSuggestionField(index, value)))
.size(16)
.text_size(13);
container(column![
toggle,
row![
container(text(field.current_value.clone()).size(12).color(Color::from_rgb(0.58, 0.58, 0.64))).width(Length::FillPortion(1)),
text("→").size(14).color(Color::from_rgb(0.62, 0.66, 0.74)),
container(text(field.suggested_value.clone()).size(12).color(Color::WHITE)).width(Length::FillPortion(1)),
]
.spacing(10)
.align_y(Alignment::Center),
]
.spacing(8))
.padding(10)
.style(|_: &Theme| container::Style {
background: Some(Background::Color(Color::from_rgb(0.18, 0.20, 0.25))),
border: Border {
color: Color::from_rgb(0.30, 0.30, 0.35),
width: 1.0,
radius: 6.0.into(),
},
..container::Style::default()
})
.into()
}).collect::<Vec<Element<'static, Message>>>();
let buttons = row![
button(text(t(locale, "common.cancel")).size(13))
.on_press(Message::DismissModal)
.padding([6, 16])
.style(cancel_button_style),
Space::with_width(Length::Fill),
button(text(t(locale, "modal.aiSuggestions.applySelected")).size(13))
.on_press(Message::ApplyAiSuggestions(target, fields))
.padding([6, 16])
.style(confirm_button_style),
];
let content = column![
title,
Space::with_height(12.0),
scrollable(column(rows).spacing(8)).height(Length::Fixed(320.0)),
Space::with_height(16.0),
buttons,
]
.spacing(4);
container(content.padding(20))
.width(Length::Fixed(640.0))
.style(modal_box_style)
.into()
}
ModalState::LanguagePicker { target, source_language, available_targets } => {
let title = text(t(locale, "modal.languagePicker.title"))
.size(16)
.shaping(Shaping::Advanced)
.color(Color::WHITE);
let subtitle = text(format!("{}: {}", t(locale, "editor.language"), source_language))
.size(12)
.shaping(Shaping::Advanced)
.color(Color::from_rgb(0.60, 0.60, 0.68));
let rows = if available_targets.is_empty() {
vec![text(t(locale, "common.noResults")).size(12).into()]
} else {
available_targets.into_iter().map(|language| {
let message = match &target {
AiEntityTarget::Post(_) => Message::PostEditor(PostEditorMsg::TranslateTo(language.code.clone())),
AiEntityTarget::Media(_) => Message::MediaEditor(crate::views::media_editor::MediaEditorMsg::TranslateTo(language.code.clone())),
};
let status = language.existing_status.clone().unwrap_or_default();
button(row![
text(format!("{} {}", language.flag_emoji, language.name)).size(13).color(Color::WHITE),
Space::with_width(Length::Fill),
text(status).size(11).color(Color::from_rgb(0.60, 0.60, 0.68)),
].align_y(Alignment::Center))
.on_press(message)
.padding([8, 12])
.style(cancel_button_style)
.into()
}).collect::<Vec<Element<'static, Message>>>()
};
let content = column![
title,
subtitle,
Space::with_height(12.0),
column(rows).spacing(6),
Space::with_height(16.0),
button(text(t(locale, "common.cancel")).size(13))
.on_press(Message::DismissModal)
.padding([6, 16])
.style(cancel_button_style),
]
.spacing(4);
container(content.padding(20))
.width(Length::Fixed(420.0))
.style(modal_box_style)
.into()
}
};
// Center the modal in a full-screen backdrop

23
crates/bds-ui/src/views/post_editor.rs
View File

@@ -322,6 +322,11 @@ impl PostEditorState {
/// Post editor messages.
#[derive(Debug, Clone)]
pub enum PostEditorMsg {
AnalyzeWithAi,
AnalyzeTaxonomy,
DetectLanguage,
Translate,
TranslateTo(String),
TitleChanged(String),
SlugChanged(String),
ExcerptChanged(String),
@@ -389,6 +394,18 @@ pub fn view<'a>(
.into()],
vec![
status_badge(&state.status),
button(text(t(locale, "editor.aiAnalyze")).size(13).shaping(Shaping::Advanced))
.on_press(Message::PostEditor(PostEditorMsg::AnalyzeWithAi))
.padding([6, 16])
.into(),
button(text(t(locale, "editor.suggestTaxonomy")).size(13).shaping(Shaping::Advanced))
.on_press(Message::PostEditor(PostEditorMsg::AnalyzeTaxonomy))
.padding([6, 16])
.into(),
button(text(t(locale, "editor.translate")).size(13).shaping(Shaping::Advanced))
.on_press(Message::PostEditor(PostEditorMsg::Translate))
.padding([6, 16])
.into(),
button(
text(t(locale, "common.save"))
.size(13)
@@ -523,6 +540,9 @@ pub fn view<'a>(
Some(&state.language),
|lang| Message::PostEditor(PostEditorMsg::LanguageChanged(lang)),
);
let detect_language = button(text(t(locale, "editor.detectLanguage")).size(12).shaping(Shaping::Advanced))
.on_press(Message::PostEditor(PostEditorMsg::DetectLanguage))
.padding([6, 12]);
let template_input = inputs::labeled_input(
&t(locale, "editor.templateSlug"),
"",
@@ -534,7 +554,8 @@ pub fn view<'a>(
state.do_not_translate,
|b| Message::PostEditor(PostEditorMsg::ToggleDoNotTranslate(b)),
);
let meta_row2 = row![author_input, language_input, template_input, dnt]
let language_block = column![language_input, detect_language].spacing(6);
let meta_row2 = row![author_input, language_block, template_input, dnt]
.spacing(16)
.width(Length::Fill);