forked from Furumi/furumi-tui
Add a share toggle to the Podcasts tab
Shift+F in the podcasts context shares the selected or opened podcast through PodcastStore::set_shared (a synced decision) or makes it private again. A feed URL that looks private is confirmed first in a dialog that lists the warnings in Russian. The reconciler runs after share and unsubscribe actions, received podcast operations, feed refreshes, overlay restarts and periodically; the list and side panel show the shared and published state and publication errors. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
8c90035fa2
commit
8f4e58d8af
14 files changed
+943
-8
No files matched your search
+6
-1
@@ -75,6 +75,9 @@ pub enum Action {
|
||||
UnsubscribePodcast,
|
||||
/// Podcasts: play the selected (or playing) episode from the beginning.
|
||||
RestartEpisode,
|
||||
/// Podcasts: turn "share in the federation" on or off for the selected
|
||||
/// or opened podcast (asks first when its feed URL looks private).
|
||||
TogglePodcastShare,
|
||||
}
|
||||
|
||||
/// Help-window sections, in display order.
|
||||
@@ -168,7 +171,8 @@ impl Action {
|
||||
| Action::CycleEpisodeFilter
|
||||
| Action::ToggleEpisodePlayed
|
||||
| Action::UnsubscribePodcast
|
||||
| Action::RestartEpisode => Category::Podcasts,
|
||||
| Action::RestartEpisode
|
||||
| Action::TogglePodcastShare => Category::Podcasts,
|
||||
Action::OpenSearch | Action::OpenCommandLine => Category::Search,
|
||||
Action::ToggleHelp | Action::Quit => Category::System,
|
||||
}
|
||||
@@ -257,6 +261,7 @@ impl Action {
|
||||
Action::ToggleEpisodePlayed => "Mark played / unplayed".into(),
|
||||
Action::UnsubscribePodcast => "Unsubscribe (keeps progress)".into(),
|
||||
Action::RestartEpisode => "Play episode from the start".into(),
|
||||
Action::TogglePodcastShare => "Share podcast in the federation on/off".into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -268,4 +268,19 @@ pub enum AppEvent {
|
||||
PodcastRefreshTick,
|
||||
/// Feeds due for a background refresh.
|
||||
PodcastsDue(Result<Vec<(music_dht::podcast::PodcastId, music_dht::podcast::FeedUrl)>, String>),
|
||||
/// What sharing a podcast would publish (`Effect::PodcastPrepareShare`).
|
||||
PodcastSharePrepared {
|
||||
podcast_id: music_dht::podcast::PodcastId,
|
||||
title: String,
|
||||
result: Result<crate::podcasts::publication::ShareCheck, String>,
|
||||
},
|
||||
/// The share decision was written (`Effect::PodcastSetShared`).
|
||||
PodcastShareSet {
|
||||
podcast_id: music_dht::podcast::PodcastId,
|
||||
title: String,
|
||||
shared: bool,
|
||||
result: Result<(), String>,
|
||||
},
|
||||
/// The publication reconciler finished a pass.
|
||||
PodcastPublication(crate::podcasts::publication::PublicationReport),
|
||||
}
|
||||
+8
-2
@@ -1734,7 +1734,10 @@ fn perform_effect(state: &mut AppState, runtime: &mut Runtime, effect: Effect) {
|
||||
| Effect::PodcastSubscribe(_)
|
||||
| Effect::PodcastRefresh { .. }
|
||||
| Effect::PodcastUnsubscribe { .. }
|
||||
| Effect::PodcastSetPlayed { .. } => {}
|
||||
| Effect::PodcastSetPlayed { .. }
|
||||
| Effect::PodcastPrepareShare { .. }
|
||||
| Effect::PodcastSetShared { .. }
|
||||
| Effect::PodcastPublicationSync => {}
|
||||
Effect::LoadListenHistory => {
|
||||
let library = Arc::clone(&runtime.library);
|
||||
let devices = Arc::clone(&runtime.devices);
|
||||
@@ -3531,7 +3534,10 @@ fn handle_app_event(state: &mut AppState, runtime: &mut Runtime, event: AppEvent
|
||||
| AppEvent::PodcastEpisodeStarted { .. }
|
||||
| AppEvent::PodcastEpisodeFailed { .. }
|
||||
| AppEvent::PodcastRefreshTick
|
||||
| AppEvent::PodcastsDue(_) => {}
|
||||
| AppEvent::PodcastsDue(_)
|
||||
| AppEvent::PodcastSharePrepared { .. }
|
||||
| AppEvent::PodcastShareSet { .. }
|
||||
| AppEvent::PodcastPublication(_) => {}
|
||||
AppEvent::StatusVisualizationReady(ready) => {
|
||||
runtime.status_visualizer.busy = false;
|
||||
state.status_visualizer.apply(ready);
|
||||
|
||||
+144
-2
@@ -19,6 +19,7 @@ use crate::podcasts::playback::{self, StartAt};
|
||||
use crate::podcasts::progress::{
|
||||
CHECKPOINT_INTERVAL, ProgressCommand, ProgressEvent, ProgressWriter,
|
||||
};
|
||||
use crate::podcasts::publication::{self, Reconciler, ShareConfirmations};
|
||||
use crate::podcasts::refresh::{self, Services};
|
||||
use crate::podcasts::stream::{CancelToken, StreamEnd, StreamProbe};
|
||||
|
||||
@@ -39,6 +40,8 @@ pub struct PodcastRuntime {
|
||||
/// Writes progress in order on its own thread; `None` if it could not
|
||||
/// start (episodes then play without saving progress).
|
||||
progress: Option<ProgressWriter>,
|
||||
/// Publishes shared podcasts to public discovery and revokes the rest.
|
||||
publication: Reconciler,
|
||||
}
|
||||
|
||||
/// The episode this device is playing (or starting), as the progress
|
||||
@@ -124,6 +127,32 @@ fn spawn_scheduler(tx: tokio::sync::mpsc::UnboundedSender<AppEvent>) {
|
||||
});
|
||||
}
|
||||
|
||||
/// Starts the publication reconciler. Without a store every own public
|
||||
/// card is revoked (see `publication::reconcile`).
|
||||
fn spawn_publication(
|
||||
runtime: &Runtime,
|
||||
store: Option<Arc<PodcastStore>>,
|
||||
confirmations: Arc<ShareConfirmations>,
|
||||
) -> Reconciler {
|
||||
let tx = runtime.event_tx.clone();
|
||||
publication::spawn(
|
||||
runtime.federation.podcast_dht(),
|
||||
store,
|
||||
confirmations,
|
||||
move |report| {
|
||||
let _ = tx.send(AppEvent::PodcastPublication(report));
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/// Asks the publication reconciler for a pass (share decisions, feed
|
||||
/// metadata or subscriptions changed).
|
||||
fn wake_publication(runtime: &Runtime) {
|
||||
if let Some(podcasts) = &runtime.podcasts {
|
||||
podcasts.publication.wake();
|
||||
}
|
||||
}
|
||||
|
||||
fn services(runtime: &Runtime) -> Option<Services> {
|
||||
runtime
|
||||
.podcasts
|
||||
@@ -143,6 +172,11 @@ pub fn perform(state: &mut AppState, runtime: &mut Runtime, effect: Effect) -> O
|
||||
if matches!(effect, Effect::PodcastSubscribe(_)) {
|
||||
state.podcasts.subscribing = false;
|
||||
}
|
||||
if let Effect::PodcastPrepareShare { podcast_id, .. }
|
||||
| Effect::PodcastSetShared { podcast_id, .. } = &effect
|
||||
{
|
||||
state.podcasts.share_busy.remove(podcast_id);
|
||||
}
|
||||
state.status_message = Some("podcasts are unavailable (see the Podcasts tab)".into());
|
||||
return None;
|
||||
}
|
||||
@@ -213,6 +247,13 @@ pub fn perform(state: &mut AppState, runtime: &mut Runtime, effect: Effect) -> O
|
||||
.log
|
||||
.record(&mut |stamps| store.unsubscribe(stamps, &id))
|
||||
.map_err(err_string);
|
||||
// Unsubscribing also revoked the share decision: sharing
|
||||
// after subscribing again asks again.
|
||||
if result.is_ok()
|
||||
&& let Err(err) = services.confirmations.forget(&podcast_id)
|
||||
{
|
||||
tracing::warn!("podcast share confirmation not removed: {err:#}");
|
||||
}
|
||||
let _ = tx.send(AppEvent::PodcastUnsubscribed {
|
||||
podcast_id,
|
||||
title,
|
||||
@@ -235,11 +276,63 @@ pub fn perform(state: &mut AppState, runtime: &mut Runtime, effect: Effect) -> O
|
||||
}
|
||||
}
|
||||
}
|
||||
Effect::PodcastPrepareShare { podcast_id, title } => {
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let result =
|
||||
publication::check_share(&services.store, &services.confirmations, &podcast_id)
|
||||
.map_err(err_string);
|
||||
let _ = tx.send(AppEvent::PodcastSharePrepared {
|
||||
podcast_id,
|
||||
title,
|
||||
result,
|
||||
});
|
||||
});
|
||||
}
|
||||
Effect::PodcastSetShared {
|
||||
podcast_id,
|
||||
title,
|
||||
shared,
|
||||
confirm,
|
||||
} => {
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let result =
|
||||
set_shared(&services, &podcast_id, shared, confirm).map_err(err_string);
|
||||
let _ = tx.send(AppEvent::PodcastShareSet {
|
||||
podcast_id,
|
||||
title,
|
||||
shared,
|
||||
result,
|
||||
});
|
||||
});
|
||||
}
|
||||
Effect::PodcastPublicationSync => wake_publication(runtime),
|
||||
other => return Some(other),
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Writes a share decision. The local confirmation is recorded before the
|
||||
/// synced decision, so the reconciler pass the decision triggers already
|
||||
/// sees it; turning sharing off forgets it. Blocking.
|
||||
fn set_shared(
|
||||
services: &Services,
|
||||
podcast_id: &music_dht::podcast::PodcastId,
|
||||
shared: bool,
|
||||
confirm: Option<publication::ConfirmedUrls>,
|
||||
) -> anyhow::Result<()> {
|
||||
if let Some(urls) = confirm {
|
||||
services.confirmations.confirm(podcast_id, urls)?;
|
||||
}
|
||||
let store = Arc::clone(&services.store);
|
||||
services
|
||||
.log
|
||||
.record(&mut |stamps| store.set_shared(stamps, podcast_id, shared))?;
|
||||
if !shared {
|
||||
services.confirmations.forget(podcast_id)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn is_podcast_effect(effect: &Effect) -> bool {
|
||||
matches!(
|
||||
effect,
|
||||
@@ -250,6 +343,9 @@ fn is_podcast_effect(effect: &Effect) -> bool {
|
||||
| Effect::PodcastRefresh { .. }
|
||||
| Effect::PodcastUnsubscribe { .. }
|
||||
| Effect::PodcastSetPlayed { .. }
|
||||
| Effect::PodcastPrepareShare { .. }
|
||||
| Effect::PodcastSetShared { .. }
|
||||
| Effect::PodcastPublicationSync
|
||||
)
|
||||
}
|
||||
|
||||
@@ -274,6 +370,11 @@ pub fn handle_event(
|
||||
) -> Option<AppEvent> {
|
||||
let effects: Vec<Effect> = match event {
|
||||
AppEvent::PodcastStoreOpened(result) => {
|
||||
if result.is_err() {
|
||||
// This device can no longer tell what is shared: revoke its
|
||||
// own public cards (fail-safe for privacy).
|
||||
let _ = spawn_publication(runtime, None, Arc::new(ShareConfirmations::in_memory()));
|
||||
}
|
||||
let result = result.map(|services| {
|
||||
let tx = runtime.event_tx.clone();
|
||||
let progress = ProgressWriter::spawn(services.clone(), move |event| {
|
||||
@@ -291,10 +392,16 @@ pub fn handle_event(
|
||||
tracing::warn!("podcast sync: {err:#}");
|
||||
}
|
||||
});
|
||||
let publication = spawn_publication(
|
||||
runtime,
|
||||
Some(Arc::clone(&services.store)),
|
||||
Arc::clone(&services.confirmations),
|
||||
);
|
||||
runtime.podcasts = Some(PodcastRuntime {
|
||||
services,
|
||||
refresh_slots: Arc::new(tokio::sync::Semaphore::new(MAX_CONCURRENT_REFRESHES)),
|
||||
progress,
|
||||
publication,
|
||||
});
|
||||
spawn_scheduler(runtime.event_tx.clone());
|
||||
});
|
||||
@@ -323,17 +430,52 @@ pub fn handle_event(
|
||||
podcast_id,
|
||||
result,
|
||||
manual,
|
||||
} => podcasts::refreshed(state, podcast_id, result, manual),
|
||||
} => {
|
||||
// The card of a shared podcast follows its feed metadata.
|
||||
if result.is_ok() {
|
||||
wake_publication(runtime);
|
||||
}
|
||||
podcasts::refreshed(state, podcast_id, result, manual)
|
||||
}
|
||||
AppEvent::PodcastUnsubscribed {
|
||||
podcast_id,
|
||||
title,
|
||||
result,
|
||||
} => podcasts::unsubscribed(state, podcast_id, title, result)
|
||||
} => {
|
||||
// Unsubscribing revokes this device's card.
|
||||
wake_publication(runtime);
|
||||
podcasts::unsubscribed(state, podcast_id, title, result)
|
||||
.into_iter()
|
||||
.collect()
|
||||
}
|
||||
AppEvent::PodcastSharePrepared {
|
||||
podcast_id,
|
||||
title,
|
||||
result,
|
||||
} => podcasts::share_prepared(state, podcast_id, title, result)
|
||||
.into_iter()
|
||||
.collect(),
|
||||
AppEvent::PodcastShareSet {
|
||||
podcast_id,
|
||||
title,
|
||||
shared,
|
||||
result,
|
||||
} => {
|
||||
wake_publication(runtime);
|
||||
podcasts::share_set(state, podcast_id, title, shared, result)
|
||||
.into_iter()
|
||||
.collect()
|
||||
}
|
||||
AppEvent::PodcastPublication(report) => {
|
||||
podcasts::publication_reported(state, report);
|
||||
Vec::new()
|
||||
}
|
||||
AppEvent::PodcastProgress(event) => progress_event(state, runtime, event),
|
||||
AppEvent::PodcastsSynced { progress, changed } => {
|
||||
if changed {
|
||||
// Share or subscription decisions of another device: publish
|
||||
// or revoke this device's own cards accordingly.
|
||||
wake_publication(runtime);
|
||||
// A subscription that came from another device has no
|
||||
// episodes here until its feed is fetched: check now.
|
||||
let _ = runtime.event_tx.send(AppEvent::PodcastRefreshTick);
|
||||
|
||||
@@ -124,6 +124,13 @@ pub fn handle_key(state: &mut AppState, runtime: &mut Runtime, key: KeyEvent) {
|
||||
KeyCode::Esc | KeyCode::Char('n') | KeyCode::Char('q') => {}
|
||||
_ => state.popup = Some(Popup::ConfirmPodcastUnsubscribe { podcast_id, title }),
|
||||
},
|
||||
popup @ Popup::ConfirmPodcastShare { .. } => {
|
||||
if let Some(effect) =
|
||||
crate::app::update::podcasts::share_confirmation_key(state, popup, key.code)
|
||||
{
|
||||
super::perform_effect(state, runtime, effect);
|
||||
}
|
||||
}
|
||||
Popup::SimilarityPrivacyConsent { enable_federation } => match key.code {
|
||||
KeyCode::Enter | KeyCode::Char('y') => {
|
||||
state.similarity.settings.federation_consent = true;
|
||||
|
||||
@@ -768,6 +768,18 @@ pub enum Popup {
|
||||
podcast_id: music_dht::podcast::PodcastId,
|
||||
title: String,
|
||||
},
|
||||
/// Sharing a podcast whose feed URL looks private: the user confirms
|
||||
/// publishing exactly `urls`. Enter/y publishes, Esc/n cancels; when the
|
||||
/// podcast is already shared (publication held back on this device),
|
||||
/// `x` turns sharing off.
|
||||
ConfirmPodcastShare {
|
||||
podcast_id: music_dht::podcast::PodcastId,
|
||||
title: String,
|
||||
urls: crate::podcasts::publication::ConfirmedUrls,
|
||||
/// Russian descriptions of the privacy warnings.
|
||||
warnings: Vec<String>,
|
||||
already_shared: bool,
|
||||
},
|
||||
/// Enabling network similarity reveals an embedding query to peers.
|
||||
SimilarityPrivacyConsent { enable_federation: bool },
|
||||
/// Derived data is safe to recreate but potentially expensive.
|
||||
@@ -1796,6 +1808,10 @@ pub struct PodcastsTab {
|
||||
pub pending_select: Option<music_dht::podcast::PodcastId>,
|
||||
/// Last episode request sequence handed out.
|
||||
pub episode_seq: u64,
|
||||
/// This device's public discovery publications (last reconciler pass).
|
||||
pub publication: crate::podcasts::publication::PublicationReport,
|
||||
/// A share check or share decision is being written.
|
||||
pub share_busy: HashSet<music_dht::podcast::PodcastId>,
|
||||
}
|
||||
|
||||
impl PodcastsTab {
|
||||
|
||||
+19
-1
@@ -136,6 +136,23 @@ pub enum Effect {
|
||||
episode_id: music_dht::podcast::EpisodeId,
|
||||
played: bool,
|
||||
},
|
||||
/// Check what sharing a podcast would publish (privacy warnings) before
|
||||
/// turning sharing on or confirming a held-back publication.
|
||||
PodcastPrepareShare {
|
||||
podcast_id: music_dht::podcast::PodcastId,
|
||||
title: String,
|
||||
},
|
||||
/// Turn sharing on or off (synced decision). `confirm` records, on this
|
||||
/// device only, that the user confirmed publishing these feed URLs
|
||||
/// despite privacy warnings.
|
||||
PodcastSetShared {
|
||||
podcast_id: music_dht::podcast::PodcastId,
|
||||
title: String,
|
||||
shared: bool,
|
||||
confirm: Option<crate::podcasts::publication::ConfirmedUrls>,
|
||||
},
|
||||
/// Reconcile this device's public podcast cards now.
|
||||
PodcastPublicationSync,
|
||||
}
|
||||
|
||||
pub fn update(state: &mut AppState, action: Action) -> Option<Effect> {
|
||||
@@ -541,7 +558,8 @@ pub fn update(state: &mut AppState, action: Action) -> Option<Effect> {
|
||||
| Action::CycleEpisodeSort
|
||||
| Action::CycleEpisodeFilter
|
||||
| Action::ToggleEpisodePlayed
|
||||
| Action::UnsubscribePodcast => {
|
||||
| Action::UnsubscribePodcast
|
||||
| Action::TogglePodcastShare => {
|
||||
state.status_message = Some(format!(
|
||||
"open the Podcasts tab ({}) for this command",
|
||||
Tab::Podcasts.index() + 1
|
||||
|
||||
@@ -18,6 +18,7 @@ use crate::app::state::{
|
||||
PODCAST_EPISODE_PAGE, PodcastListRow, PodcastRow, PodcastStoreStatus, Popup, SeasonRow, Tab,
|
||||
};
|
||||
use crate::library::models::TrackItem;
|
||||
use crate::podcasts::publication::{Publication, PublicationReport, ShareCheck, warning_ru};
|
||||
use crate::podcasts::refresh::{RefreshReport, SubscribeReport};
|
||||
|
||||
/// The next page starts loading when the cursor is this close to the end.
|
||||
@@ -59,6 +60,7 @@ pub(super) fn handle(state: &mut AppState, action: &Action) -> Option<Option<Eff
|
||||
Action::CycleEpisodeFilter => cycle_played_filter(state),
|
||||
Action::ToggleEpisodePlayed => toggle_played(state),
|
||||
Action::RestartEpisode => restart_selected(state),
|
||||
Action::TogglePodcastShare => toggle_share(state),
|
||||
_ => return None,
|
||||
};
|
||||
Some(effect)
|
||||
@@ -616,6 +618,222 @@ fn confirm_unsubscribe(state: &mut AppState) {
|
||||
});
|
||||
}
|
||||
|
||||
/// Shift-F: share the selected or opened podcast in the federation, or stop
|
||||
/// sharing it.
|
||||
///
|
||||
/// Turning sharing on first checks the card it would publish
|
||||
/// ([`Effect::PodcastPrepareShare`]); a feed URL that looks private asks for
|
||||
/// confirmation in [`Popup::ConfirmPodcastShare`] ([`share_prepared`]).
|
||||
/// A shared podcast whose publication is held back on this device (the URL
|
||||
/// changed or was shared from another device) asks again instead of turning
|
||||
/// sharing off; the dialog can still turn it off.
|
||||
fn toggle_share(state: &mut AppState) -> Option<Effect> {
|
||||
if !store_ready(state) {
|
||||
return None;
|
||||
}
|
||||
let Some(row) = state.podcasts.current_podcast() else {
|
||||
state.status_message = Some("podcasts: select a podcast to share".into());
|
||||
return None;
|
||||
};
|
||||
let podcast_id = row.id().clone();
|
||||
let title = row.title().to_string();
|
||||
let shared = row.summary.shared;
|
||||
if state.podcasts.share_busy.contains(&podcast_id) {
|
||||
state.status_message = Some("podcasts: still saving the share setting".into());
|
||||
return None;
|
||||
}
|
||||
let held = matches!(
|
||||
state.podcasts.publication.podcasts.get(&podcast_id),
|
||||
Some(Publication::HeldBack(_))
|
||||
);
|
||||
state.podcasts.share_busy.insert(podcast_id.clone());
|
||||
if shared && !held {
|
||||
state.status_message = Some(format!(
|
||||
"podcasts: stopping sharing {}…",
|
||||
display_title(&title)
|
||||
));
|
||||
return Some(Effect::PodcastSetShared {
|
||||
podcast_id,
|
||||
title,
|
||||
shared: false,
|
||||
confirm: None,
|
||||
});
|
||||
}
|
||||
Some(Effect::PodcastPrepareShare { podcast_id, title })
|
||||
}
|
||||
|
||||
/// The card check of [`toggle_share`] arrived: share right away, or ask
|
||||
/// about the privacy warnings first.
|
||||
pub fn share_prepared(
|
||||
state: &mut AppState,
|
||||
podcast_id: PodcastId,
|
||||
title: String,
|
||||
result: Result<ShareCheck, String>,
|
||||
) -> Option<Effect> {
|
||||
let check = match result {
|
||||
Ok(check) => check,
|
||||
Err(err) => {
|
||||
state.podcasts.share_busy.remove(&podcast_id);
|
||||
state.status_message = Some(format!("podcasts: cannot share: {err}"));
|
||||
return None;
|
||||
}
|
||||
};
|
||||
let already_shared = state
|
||||
.podcasts
|
||||
.podcast(&podcast_id)
|
||||
.is_some_and(|row| row.summary.shared);
|
||||
if check.needs_confirmation() || (already_shared && !check.warnings.is_empty()) {
|
||||
// Wait for the user; nothing is written until they confirm.
|
||||
state.podcasts.share_busy.remove(&podcast_id);
|
||||
state.popup = Some(Popup::ConfirmPodcastShare {
|
||||
podcast_id,
|
||||
title,
|
||||
urls: check.urls,
|
||||
warnings: check.warnings.iter().map(warning_ru).collect(),
|
||||
already_shared,
|
||||
});
|
||||
return None;
|
||||
}
|
||||
if already_shared {
|
||||
// Held back without warnings any more: the next pass publishes it.
|
||||
state.podcasts.share_busy.remove(&podcast_id);
|
||||
state.status_message = Some(format!(
|
||||
"podcasts: {} is shared; publishing…",
|
||||
display_title(&title)
|
||||
));
|
||||
return Some(Effect::PodcastPublicationSync);
|
||||
}
|
||||
state.status_message = Some(format!("podcasts: sharing {}…", display_title(&title)));
|
||||
Some(Effect::PodcastSetShared {
|
||||
podcast_id,
|
||||
title,
|
||||
shared: true,
|
||||
// Already confirmed earlier for exactly these URLs (or no warning).
|
||||
confirm: None,
|
||||
})
|
||||
}
|
||||
|
||||
/// A key in [`Popup::ConfirmPodcastShare`]: Enter/y publishes exactly the
|
||||
/// URLs shown (and remembers that confirmation on this device), `x` stops
|
||||
/// sharing a podcast that is already shared, Esc/n/q cancels (nothing is
|
||||
/// written). Other keys keep the dialog open.
|
||||
pub fn share_confirmation_key(
|
||||
state: &mut AppState,
|
||||
popup: Popup,
|
||||
code: crossterm::event::KeyCode,
|
||||
) -> Option<Effect> {
|
||||
use crossterm::event::KeyCode;
|
||||
let Popup::ConfirmPodcastShare {
|
||||
podcast_id,
|
||||
title,
|
||||
urls,
|
||||
warnings,
|
||||
already_shared,
|
||||
} = popup
|
||||
else {
|
||||
state.popup = Some(popup);
|
||||
return None;
|
||||
};
|
||||
match code {
|
||||
KeyCode::Enter | KeyCode::Char('y') => {
|
||||
state.podcasts.share_busy.insert(podcast_id.clone());
|
||||
state.status_message = Some(format!("podcasts: sharing {}…", display_title(&title)));
|
||||
Some(Effect::PodcastSetShared {
|
||||
podcast_id,
|
||||
title,
|
||||
shared: true,
|
||||
confirm: Some(urls),
|
||||
})
|
||||
}
|
||||
KeyCode::Char('x') if already_shared => {
|
||||
state.podcasts.share_busy.insert(podcast_id.clone());
|
||||
state.status_message = Some(format!(
|
||||
"podcasts: stopping sharing {}…",
|
||||
display_title(&title)
|
||||
));
|
||||
Some(Effect::PodcastSetShared {
|
||||
podcast_id,
|
||||
title,
|
||||
shared: false,
|
||||
confirm: None,
|
||||
})
|
||||
}
|
||||
KeyCode::Esc | KeyCode::Char('n') | KeyCode::Char('q') => {
|
||||
state.status_message = Some(if already_shared {
|
||||
"podcasts: not published from this device until you confirm".into()
|
||||
} else {
|
||||
"podcasts: the podcast stays private".into()
|
||||
});
|
||||
None
|
||||
}
|
||||
_ => {
|
||||
state.popup = Some(Popup::ConfirmPodcastShare {
|
||||
podcast_id,
|
||||
title,
|
||||
urls,
|
||||
warnings,
|
||||
already_shared,
|
||||
});
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The share decision was written; the reconciler publishes or revokes.
|
||||
pub fn share_set(
|
||||
state: &mut AppState,
|
||||
podcast_id: PodcastId,
|
||||
title: String,
|
||||
shared: bool,
|
||||
result: Result<(), String>,
|
||||
) -> Option<Effect> {
|
||||
state.podcasts.share_busy.remove(&podcast_id);
|
||||
let title = display_title(&title);
|
||||
match result {
|
||||
Ok(()) if shared => {
|
||||
state.status_message = Some(format!(
|
||||
"podcasts: {title} is shared in the federation (publishing from this device)"
|
||||
));
|
||||
Some(Effect::PodcastsReload)
|
||||
}
|
||||
Ok(()) => {
|
||||
state.podcasts.publication.podcasts.remove(&podcast_id);
|
||||
state.status_message = Some(format!(
|
||||
"podcasts: {title} is private again; the public card is being revoked"
|
||||
));
|
||||
Some(Effect::PodcastsReload)
|
||||
}
|
||||
Err(err) => {
|
||||
state.status_message = Some(format!("podcasts: cannot change sharing: {err}"));
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A publication reconciler pass finished. Errors go to the status bar
|
||||
/// when they are new (the log has them too).
|
||||
pub fn publication_reported(state: &mut AppState, report: PublicationReport) {
|
||||
let previous = std::mem::replace(&mut state.podcasts.publication, report);
|
||||
let report = &state.podcasts.publication;
|
||||
if let Some(error) = &report.error
|
||||
&& previous.error.as_ref() != Some(error)
|
||||
{
|
||||
state.status_message = Some(format!("podcasts: public discovery: {error}"));
|
||||
}
|
||||
for (podcast_id, publication) in &report.podcasts {
|
||||
if let Publication::Failed(error) = publication
|
||||
&& previous.podcasts.get(podcast_id) != Some(publication)
|
||||
{
|
||||
let title = state
|
||||
.podcasts
|
||||
.podcast(podcast_id)
|
||||
.map(|row| display_title(row.title()))
|
||||
.unwrap_or_else(|| "a shared podcast".to_string());
|
||||
state.status_message = Some(format!("podcasts: cannot publish {title}: {error}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn refresh_targets(state: &mut AppState, rows: Vec<&PodcastRow>) -> Vec<(PodcastId, FeedUrl)> {
|
||||
rows.into_iter()
|
||||
.filter(|row| !state.podcasts.refreshing.contains(row.id()))
|
||||
|
||||
@@ -1834,6 +1834,311 @@ mod podcast_tab {
|
||||
Some(Effect::PodcastLoadEpisodes { .. })
|
||||
));
|
||||
}
|
||||
|
||||
// --- Sharing in the federation (MR-T3) ---
|
||||
|
||||
use crate::podcasts::publication::{
|
||||
ConfirmedUrls, Discovery, Publication, PublicationReport, ShareCheck,
|
||||
};
|
||||
use crossterm::event::KeyCode;
|
||||
|
||||
fn urls() -> ConfirmedUrls {
|
||||
ConfirmedUrls {
|
||||
feed_url: FeedUrl::parse("https://example.test/feed.xml").unwrap(),
|
||||
id_feed_url: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn check(warnings: bool, confirmed: bool) -> ShareCheck {
|
||||
ShareCheck {
|
||||
urls: urls(),
|
||||
warnings: if warnings {
|
||||
vec![
|
||||
music_dht::podcast_dht::FeedUrlPrivacyWarning::SecretQueryParameter {
|
||||
name: "token".into(),
|
||||
},
|
||||
]
|
||||
} else {
|
||||
Vec::new()
|
||||
},
|
||||
confirmed,
|
||||
}
|
||||
}
|
||||
|
||||
fn set_shared(shared: bool, confirm: Option<ConfirmedUrls>) -> Option<Effect> {
|
||||
Some(Effect::PodcastSetShared {
|
||||
podcast_id: podcast_id(),
|
||||
title: "Show".into(),
|
||||
shared,
|
||||
confirm,
|
||||
})
|
||||
}
|
||||
|
||||
fn shared_row() -> crate::app::state::PodcastRow {
|
||||
let mut row = fx::row("Show", 0, 1, 0);
|
||||
row.summary.shared = true;
|
||||
row
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sharing_a_podcast_checks_its_card_first_and_shares_without_warnings() {
|
||||
let mut state = ready(vec![fx::row("Show", 0, 1, 0)]);
|
||||
assert_eq!(
|
||||
update(&mut state, Action::TogglePodcastShare),
|
||||
Some(Effect::PodcastPrepareShare {
|
||||
podcast_id: podcast_id(),
|
||||
title: "Show".into(),
|
||||
})
|
||||
);
|
||||
// A second press while the check runs does nothing.
|
||||
assert_eq!(update(&mut state, Action::TogglePodcastShare), None);
|
||||
let effect = podcasts::share_prepared(
|
||||
&mut state,
|
||||
podcast_id(),
|
||||
"Show".into(),
|
||||
Ok(check(false, false)),
|
||||
);
|
||||
assert_eq!(effect, set_shared(true, None));
|
||||
assert!(state.popup.is_none());
|
||||
// Also inside the opened podcast.
|
||||
let mut state = ready(vec![fx::row("Show", 0, 1, 0)]);
|
||||
let (seq, _) = episode_request(update(&mut state, Action::Select));
|
||||
podcasts::episodes_loaded(&mut state, seq, 0, Ok(page(1)));
|
||||
assert!(matches!(
|
||||
update(&mut state, Action::TogglePodcastShare),
|
||||
Some(Effect::PodcastPrepareShare { .. })
|
||||
));
|
||||
// Already confirmed for exactly these URLs: no dialog.
|
||||
let effect = podcasts::share_prepared(
|
||||
&mut state,
|
||||
podcast_id(),
|
||||
"Show".into(),
|
||||
Ok(check(true, true)),
|
||||
);
|
||||
assert_eq!(effect, set_shared(true, None));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_private_looking_feed_url_is_shared_only_after_confirmation() {
|
||||
let mut state = ready(vec![fx::row("Show", 0, 1, 0)]);
|
||||
update(&mut state, Action::TogglePodcastShare);
|
||||
let effect = podcasts::share_prepared(
|
||||
&mut state,
|
||||
podcast_id(),
|
||||
"Show".into(),
|
||||
Ok(check(true, false)),
|
||||
);
|
||||
assert_eq!(effect, None, "nothing is written before the user confirms");
|
||||
let Some(Popup::ConfirmPodcastShare {
|
||||
warnings,
|
||||
already_shared,
|
||||
urls: shown,
|
||||
..
|
||||
}) = &state.popup
|
||||
else {
|
||||
panic!("expected the share confirmation, got {:?}", state.popup);
|
||||
};
|
||||
assert_eq!(
|
||||
warnings,
|
||||
&vec!["в адресе ленты есть параметр «token», похожий на ключ доступа".to_string()]
|
||||
);
|
||||
assert!(!already_shared);
|
||||
assert_eq!(shown, &urls());
|
||||
assert!(state.podcasts.share_busy.is_empty());
|
||||
|
||||
// Esc keeps the podcast private; other keys keep the dialog.
|
||||
let popup = state.popup.take().unwrap();
|
||||
assert_eq!(
|
||||
podcasts::share_confirmation_key(&mut state, popup, KeyCode::Char('j')),
|
||||
None
|
||||
);
|
||||
assert!(state.popup.is_some());
|
||||
let popup = state.popup.take().unwrap();
|
||||
assert_eq!(
|
||||
podcasts::share_confirmation_key(&mut state, popup, KeyCode::Char('x')),
|
||||
None
|
||||
);
|
||||
assert!(state.popup.is_some(), "x only stops an existing share");
|
||||
let popup = state.popup.take().unwrap();
|
||||
assert_eq!(
|
||||
podcasts::share_confirmation_key(&mut state, popup, KeyCode::Esc),
|
||||
None
|
||||
);
|
||||
assert!(state.popup.is_none());
|
||||
assert!(
|
||||
state
|
||||
.status_message
|
||||
.as_deref()
|
||||
.is_some_and(|m| m.contains("stays private"))
|
||||
);
|
||||
|
||||
// Enter confirms exactly the URLs shown.
|
||||
update(&mut state, Action::TogglePodcastShare);
|
||||
podcasts::share_prepared(
|
||||
&mut state,
|
||||
podcast_id(),
|
||||
"Show".into(),
|
||||
Ok(check(true, false)),
|
||||
);
|
||||
let popup = state.popup.take().unwrap();
|
||||
assert_eq!(
|
||||
podcasts::share_confirmation_key(&mut state, popup, KeyCode::Enter),
|
||||
set_shared(true, Some(urls()))
|
||||
);
|
||||
assert!(state.podcasts.share_busy.contains(&podcast_id()));
|
||||
assert_eq!(
|
||||
podcasts::share_set(&mut state, podcast_id(), "Show".into(), true, Ok(())),
|
||||
Some(Effect::PodcastsReload)
|
||||
);
|
||||
assert!(state.podcasts.share_busy.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stopping_sharing_needs_no_dialog_and_a_held_publication_asks_again() {
|
||||
let mut state = ready(vec![shared_row()]);
|
||||
assert_eq!(
|
||||
update(&mut state, Action::TogglePodcastShare),
|
||||
set_shared(false, None)
|
||||
);
|
||||
state
|
||||
.podcasts
|
||||
.publication
|
||||
.podcasts
|
||||
.insert(podcast_id(), Publication::Published);
|
||||
let effect = podcasts::share_set(&mut state, podcast_id(), "Show".into(), false, Ok(()));
|
||||
assert_eq!(effect, Some(Effect::PodcastsReload));
|
||||
assert!(state.podcasts.publication.podcasts.is_empty());
|
||||
assert!(
|
||||
state
|
||||
.status_message
|
||||
.as_deref()
|
||||
.is_some_and(|m| m.contains("private again"))
|
||||
);
|
||||
|
||||
// Shared (for example from another device) but held back here: the
|
||||
// key asks for this device's confirmation instead of unsharing.
|
||||
let mut state = ready(vec![shared_row()]);
|
||||
state.podcasts.publication.podcasts.insert(
|
||||
podcast_id(),
|
||||
Publication::HeldBack(check(true, false).warnings),
|
||||
);
|
||||
assert!(matches!(
|
||||
update(&mut state, Action::TogglePodcastShare),
|
||||
Some(Effect::PodcastPrepareShare { .. })
|
||||
));
|
||||
podcasts::share_prepared(
|
||||
&mut state,
|
||||
podcast_id(),
|
||||
"Show".into(),
|
||||
Ok(check(true, false)),
|
||||
);
|
||||
assert!(matches!(
|
||||
&state.popup,
|
||||
Some(Popup::ConfirmPodcastShare {
|
||||
already_shared: true,
|
||||
..
|
||||
})
|
||||
));
|
||||
let popup = state.popup.take().unwrap();
|
||||
assert_eq!(
|
||||
podcasts::share_confirmation_key(&mut state, popup, KeyCode::Char('x')),
|
||||
set_shared(false, None)
|
||||
);
|
||||
// Or confirms it (sharing is already on; the confirmation is new).
|
||||
state.podcasts.share_busy.clear();
|
||||
podcasts::share_prepared(
|
||||
&mut state,
|
||||
podcast_id(),
|
||||
"Show".into(),
|
||||
Ok(check(true, false)),
|
||||
);
|
||||
let popup = state.popup.take().unwrap();
|
||||
assert_eq!(
|
||||
podcasts::share_confirmation_key(&mut state, popup, KeyCode::Char('y')),
|
||||
set_shared(true, Some(urls()))
|
||||
);
|
||||
// Held without warnings any more: just reconcile again.
|
||||
state.podcasts.share_busy.clear();
|
||||
assert_eq!(
|
||||
podcasts::share_prepared(
|
||||
&mut state,
|
||||
podcast_id(),
|
||||
"Show".into(),
|
||||
Ok(check(false, false))
|
||||
),
|
||||
Some(Effect::PodcastPublicationSync)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn share_errors_and_publication_failures_are_shown() {
|
||||
let mut state = ready(vec![fx::row("Show", 0, 1, 0)]);
|
||||
update(&mut state, Action::TogglePodcastShare);
|
||||
assert_eq!(
|
||||
podcasts::share_prepared(&mut state, podcast_id(), "Show".into(), Err("boom".into())),
|
||||
None
|
||||
);
|
||||
assert!(state.podcasts.share_busy.is_empty());
|
||||
assert!(
|
||||
state
|
||||
.status_message
|
||||
.as_deref()
|
||||
.is_some_and(|m| m.contains("cannot share: boom"))
|
||||
);
|
||||
assert_eq!(
|
||||
podcasts::share_set(
|
||||
&mut state,
|
||||
podcast_id(),
|
||||
"Show".into(),
|
||||
true,
|
||||
Err("db".into())
|
||||
),
|
||||
None
|
||||
);
|
||||
assert!(
|
||||
state
|
||||
.status_message
|
||||
.as_deref()
|
||||
.is_some_and(|m| m.contains("cannot change sharing: db"))
|
||||
);
|
||||
|
||||
state.status_message = None;
|
||||
let mut report = PublicationReport {
|
||||
discovery: Discovery::Running { peers: 3 },
|
||||
..PublicationReport::default()
|
||||
};
|
||||
report
|
||||
.podcasts
|
||||
.insert(podcast_id(), Publication::Failed("signing failed".into()));
|
||||
podcasts::publication_reported(&mut state, report.clone());
|
||||
assert!(
|
||||
state
|
||||
.status_message
|
||||
.as_deref()
|
||||
.is_some_and(|m| m.contains("cannot publish \"Show\": signing failed"))
|
||||
);
|
||||
// The same failure again is not repeated in the status bar.
|
||||
state.status_message = None;
|
||||
podcasts::publication_reported(&mut state, report);
|
||||
assert_eq!(state.status_message, None);
|
||||
assert_eq!(
|
||||
state.podcasts.publication.discovery,
|
||||
Discovery::Running { peers: 3 }
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn share_actions_outside_the_tab_only_explain() {
|
||||
let mut state = fx::ready_state(vec![fx::row("Show", 0, 1, 0)]);
|
||||
state.active_tab = Tab::Global;
|
||||
assert_eq!(update(&mut state, Action::TogglePodcastShare), None);
|
||||
assert!(state.podcasts.share_busy.is_empty());
|
||||
let mut opening = AppState {
|
||||
active_tab: Tab::Podcasts,
|
||||
..AppState::default()
|
||||
};
|
||||
assert_eq!(update(&mut opening, Action::TogglePodcastShare), None);
|
||||
}
|
||||
}
|
||||
|
||||
/// Podcast episodes in the shared queue: identity by episode id (never the
|
||||
|
||||
@@ -319,3 +319,8 @@ context = "podcasts"
|
||||
key_sequence = "b"
|
||||
command = "RestartEpisode"
|
||||
context = "podcasts"
|
||||
|
||||
[[keymaps]]
|
||||
key_sequence = "shift-f"
|
||||
command = "TogglePodcastShare"
|
||||
context = "podcasts"
|
||||
@@ -904,6 +904,7 @@ mod tests {
|
||||
(key!(m), Action::ToggleEpisodePlayed),
|
||||
(shift('U'), Action::UnsubscribePodcast),
|
||||
(key!(b), Action::RestartEpisode),
|
||||
(shift('F'), Action::TogglePodcastShare),
|
||||
];
|
||||
for (key, action) in cases {
|
||||
assert_eq!(
|
||||
|
||||
@@ -181,6 +181,74 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn podcast_share_state_is_shown_in_the_list_and_details() {
|
||||
use crate::podcasts::publication::{Discovery, Publication};
|
||||
let mut state =
|
||||
podcast_fixtures::ready_state(vec![podcast_fixtures::row("Test Show", 0, 3, 0)]);
|
||||
state.podcasts.selected = crate::app::state::PODCAST_ACTION_ROWS;
|
||||
let screen = render(&state, 110, 30);
|
||||
assert!(screen.contains("private (not shared"), "{screen}");
|
||||
assert!(!screen.contains("shared · 3 ep"), "{screen}");
|
||||
|
||||
let mut row = podcast_fixtures::row("Test Show", 0, 3, 0);
|
||||
row.summary.shared = true;
|
||||
let mut state = podcast_fixtures::ready_state(vec![row]);
|
||||
state.podcasts.selected = crate::app::state::PODCAST_ACTION_ROWS;
|
||||
state.podcasts.publication.discovery = Discovery::Running { peers: 2 };
|
||||
state
|
||||
.podcasts
|
||||
.publication
|
||||
.podcasts
|
||||
.insert(podcast_fixtures::podcast_id(), Publication::Published);
|
||||
let screen = render(&state, 110, 30);
|
||||
assert!(screen.contains("shared · 3 ep"), "{screen}");
|
||||
assert!(screen.contains("shared · published from"), "{screen}");
|
||||
|
||||
state.podcasts.publication.podcasts.insert(
|
||||
podcast_fixtures::podcast_id(),
|
||||
Publication::HeldBack(Vec::new()),
|
||||
);
|
||||
let screen = render(&state, 110, 30);
|
||||
assert!(screen.contains("held back"), "{screen}");
|
||||
|
||||
state.podcasts.publication.discovery = Discovery::Off("federation is off".into());
|
||||
let screen = render(&state, 110, 30);
|
||||
assert!(screen.contains("not published:"), "{screen}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn podcast_share_confirmation_lists_the_warnings_in_russian() {
|
||||
let mut state =
|
||||
podcast_fixtures::ready_state(vec![podcast_fixtures::row("Test Show", 0, 1, 0)]);
|
||||
state.popup = Some(crate::app::state::Popup::ConfirmPodcastShare {
|
||||
podcast_id: podcast_fixtures::podcast_id(),
|
||||
title: "Test Show".into(),
|
||||
urls: crate::podcasts::publication::ConfirmedUrls {
|
||||
feed_url: music_dht::podcast::FeedUrl::parse(
|
||||
"https://example.test/feed.xml?token=abc",
|
||||
)
|
||||
.unwrap(),
|
||||
id_feed_url: None,
|
||||
},
|
||||
warnings: vec!["в адресе ленты есть параметр «token», похожий на ключ доступа".into()],
|
||||
already_shared: false,
|
||||
});
|
||||
let screen = render(&state, 100, 30);
|
||||
assert!(
|
||||
screen.contains("Поделиться подкастом «Test Show»"),
|
||||
"{screen}"
|
||||
);
|
||||
assert!(screen.contains("Адрес похож на личный"), "{screen}");
|
||||
assert!(screen.contains("параметр «token»"), "{screen}");
|
||||
assert!(screen.contains("feed.xml?token=abc"), "{screen}");
|
||||
assert!(
|
||||
screen.contains("enter/y опубликовать · esc/n отмена"),
|
||||
"{screen}"
|
||||
);
|
||||
assert!(!screen.contains("x не делиться"), "{screen}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn podcast_seasons_and_episodes_render_progress() {
|
||||
use music_dht::podcast::ProgressStatus;
|
||||
|
||||
+43
-2
@@ -17,6 +17,7 @@ use crate::app::state::{
|
||||
PodcastStoreStatus, SeasonRow,
|
||||
};
|
||||
use crate::app::update::podcasts::{played_label, sort_label};
|
||||
use crate::podcasts::publication::{Discovery, Publication};
|
||||
|
||||
/// Width below which the side panel with the cover is dropped.
|
||||
const SIDE_PANEL_MIN_TOTAL_WIDTH: u16 = 80;
|
||||
@@ -219,7 +220,7 @@ fn list_row(state: &AppState, row: PodcastListRow, width: u16) -> (Line<'static>
|
||||
Span::raw(" ")
|
||||
};
|
||||
let summary = &podcast.summary;
|
||||
let meta = if summary.unplayed_count > 0 {
|
||||
let mut meta = if summary.unplayed_count > 0 {
|
||||
format!(
|
||||
"{} unplayed · {} ep",
|
||||
summary.unplayed_count, summary.episode_count
|
||||
@@ -227,6 +228,9 @@ fn list_row(state: &AppState, row: PodcastListRow, width: u16) -> (Line<'static>
|
||||
} else {
|
||||
format!("{} ep", summary.episode_count)
|
||||
};
|
||||
if summary.shared {
|
||||
meta = format!("shared · {meta}");
|
||||
}
|
||||
let title_width = usize::from(width).saturating_sub(2 + meta.width() + 2);
|
||||
let left = Line::from(vec![
|
||||
marker,
|
||||
@@ -293,7 +297,7 @@ fn draw_side_panel(frame: &mut Frame, area: Rect, state: &AppState, podcast: Opt
|
||||
counts.push_str(&format!(" · {} seasons", summary.season_count));
|
||||
}
|
||||
lines.push(Line::styled(counts, theme::dim()));
|
||||
lines.push(Line::styled("private", theme::dim()));
|
||||
lines.push(share_status_line(state, podcast));
|
||||
lines.push(fetch_status_line(state, podcast));
|
||||
if let Some(description) = &summary.meta.description {
|
||||
lines.push(Line::raw(""));
|
||||
@@ -302,6 +306,43 @@ fn draw_side_panel(frame: &mut Frame, area: Rect, state: &AppState, podcast: Opt
|
||||
frame.render_widget(Paragraph::new(lines).wrap(Wrap { trim: true }), text_area);
|
||||
}
|
||||
|
||||
/// Public discovery state of one podcast: private, or shared and whether
|
||||
/// this device publishes its card.
|
||||
pub(crate) fn share_status_line(state: &AppState, podcast: &PodcastRow) -> Line<'static> {
|
||||
let tab = &state.podcasts;
|
||||
if tab.share_busy.contains(podcast.id()) {
|
||||
return loading_line(state, "saving the share setting…");
|
||||
}
|
||||
if !podcast.summary.shared {
|
||||
return Line::styled("private (not shared in the federation)", theme::dim());
|
||||
}
|
||||
let report = &tab.publication;
|
||||
let (text, style) = match (&report.discovery, report.podcasts.get(podcast.id())) {
|
||||
(Discovery::Off(reason), _) => (format!("shared · not published: {reason}"), theme::dim()),
|
||||
(_, Some(Publication::HeldBack(_))) => (
|
||||
"shared · held back on this device: the feed URL looks private, \
|
||||
press Shift+F to confirm"
|
||||
.to_string(),
|
||||
Style::new().fg(Color::Yellow),
|
||||
),
|
||||
(_, Some(Publication::Failed(error))) => {
|
||||
(format!("shared · not published: {error}"), error_style())
|
||||
}
|
||||
(Discovery::Running { peers: 0 }, Some(Publication::Published)) => (
|
||||
"shared · published from this device (no discovery peers yet)".to_string(),
|
||||
theme::accent_for(state),
|
||||
),
|
||||
(_, Some(Publication::Published)) => (
|
||||
"shared · published from this device".to_string(),
|
||||
theme::accent_for(state),
|
||||
),
|
||||
(Discovery::Starting, _) | (_, Some(Publication::Pending) | None) => {
|
||||
return loading_line(state, "shared · publishing…");
|
||||
}
|
||||
};
|
||||
Line::styled(text, style)
|
||||
}
|
||||
|
||||
/// Refresh status of one podcast: checking, the last error, or when it was
|
||||
/// last checked.
|
||||
fn fetch_status_line(state: &AppState, podcast: &PodcastRow) -> Line<'static> {
|
||||
|
||||
@@ -28,6 +28,13 @@ pub fn draw(frame: &mut Frame, state: &AppState) {
|
||||
Some(Popup::ConfirmPodcastUnsubscribe { title, .. }) => {
|
||||
draw_confirm_podcast_unsubscribe(frame, state, title)
|
||||
}
|
||||
Some(Popup::ConfirmPodcastShare {
|
||||
title,
|
||||
urls,
|
||||
warnings,
|
||||
already_shared,
|
||||
..
|
||||
}) => draw_confirm_podcast_share(frame, state, title, urls, warnings, *already_shared),
|
||||
Some(Popup::SimilarityPrivacyConsent { .. }) => {
|
||||
draw_similarity_privacy_consent(frame, state)
|
||||
}
|
||||
@@ -1318,6 +1325,87 @@ fn draw_confirm_podcast_unsubscribe(frame: &mut Frame, state: &AppState, title:
|
||||
);
|
||||
}
|
||||
|
||||
/// Sharing a podcast whose feed URL looks private. In Russian: the warning
|
||||
/// is about the user's own secret, so it must not be missed.
|
||||
fn draw_confirm_podcast_share(
|
||||
frame: &mut Frame,
|
||||
state: &AppState,
|
||||
title: &str,
|
||||
urls: &crate::podcasts::publication::ConfirmedUrls,
|
||||
warnings: &[String],
|
||||
already_shared: bool,
|
||||
) {
|
||||
let width = 78.min(frame.area().width.saturating_sub(4)).max(30);
|
||||
let mut lines = vec![
|
||||
Line::styled(
|
||||
format!("Поделиться подкастом «{title}» в федерации?"),
|
||||
ratatui::style::Style::new().add_modifier(ratatui::style::Modifier::BOLD),
|
||||
),
|
||||
Line::raw(""),
|
||||
Line::raw(
|
||||
"Карточка с адресом RSS-ленты станет видна всем участникам федерации, \
|
||||
и любой из них сможет читать ленту по этому адресу.",
|
||||
),
|
||||
Line::raw(""),
|
||||
Line::styled(
|
||||
"Адрес похож на личный:",
|
||||
ratatui::style::Style::new().fg(ratatui::style::Color::Yellow),
|
||||
),
|
||||
];
|
||||
lines.extend(warnings.iter().map(|warning| {
|
||||
Line::styled(
|
||||
format!("• {warning}"),
|
||||
ratatui::style::Style::new().fg(ratatui::style::Color::Yellow),
|
||||
)
|
||||
}));
|
||||
lines.push(Line::raw(""));
|
||||
lines.push(Line::styled(
|
||||
format!("Лента: {}", urls.feed_url.as_str()),
|
||||
theme::dim(),
|
||||
));
|
||||
if let Some(origin) = &urls.id_feed_url {
|
||||
lines.push(Line::styled(
|
||||
format!("Исходный адрес: {}", origin.as_str()),
|
||||
theme::dim(),
|
||||
));
|
||||
}
|
||||
lines.push(Line::raw(""));
|
||||
lines.push(Line::styled(
|
||||
"Публикацию можно отозвать, но копии, которые уже получили другие, \
|
||||
отозвать нельзя. Подтверждение хранится только на этом устройстве.",
|
||||
theme::dim(),
|
||||
));
|
||||
let footer = if already_shared {
|
||||
"enter/y опубликовать · x не делиться · esc/n отмена"
|
||||
} else {
|
||||
"enter/y опубликовать · esc/n отмена"
|
||||
};
|
||||
let inner_width = width.saturating_sub(2).max(1);
|
||||
let body_height = lines
|
||||
.iter()
|
||||
.map(|line| {
|
||||
let text_width = line.width().max(1) as u16;
|
||||
text_width.div_ceil(inner_width)
|
||||
})
|
||||
.sum::<u16>();
|
||||
let height = (body_height + 4).min(frame.area().height.saturating_sub(2));
|
||||
let area = centered(frame.area(), width, height);
|
||||
let block = Block::bordered()
|
||||
.title(" Поделиться в федерации ")
|
||||
.title_style(theme::header_for(state))
|
||||
.border_style(theme::strong_border_for(state));
|
||||
let inner = block.inner(area);
|
||||
frame.render_widget(Clear, area);
|
||||
frame.render_widget(block, area);
|
||||
let [body, footer_area] =
|
||||
Layout::vertical([Constraint::Min(1), Constraint::Length(1)]).areas(inner);
|
||||
frame.render_widget(Paragraph::new(lines).wrap(Wrap { trim: false }), body);
|
||||
frame.render_widget(
|
||||
Paragraph::new(Line::styled(footer, theme::dim())).alignment(Alignment::Center),
|
||||
footer_area,
|
||||
);
|
||||
}
|
||||
|
||||
fn draw_log_detail(frame: &mut Frame, state: &AppState, entry: &crate::config::logging::LogEntry) {
|
||||
let width = 90.min(frame.area().width.saturating_sub(4)).max(40);
|
||||
let height = 18.min(frame.area().height.saturating_sub(2)).max(7);
|
||||
|
||||
Reference in new issue
Block a user