use iced::Task;
use knotra_vcs::VcsAdapter;
use crate::{
message::{BackgroundMessage, Message},
state::{
AppState, OperationLeaseId, OperationOwner, freezer::FreezerPhase, sync::SyncPhase,
topology::TopologyPhase,
},
};
pub(super) fn find_project(
state: &AppState,
id: &knotra_vcs::ProjectId,
) -> Option<knotra_vcs::Project> {
state
.workspace
.as_ref()
.and_then(|ws| ws.projects.iter().find(|p| &p.id == id).cloned())
}
pub(super) fn acquire_operation(
state: &mut AppState,
owner: OperationOwner,
) -> Option<OperationLeaseId> {
let lease = state.operation_interlock.try_acquire(owner);
if lease.is_none() {
state.status_bar = Some(state.t("plain.activity.busy").to_owned());
}
lease
}
pub(super) fn refresh_workspace_task(state: &AppState) -> Task<Message> {
let workspace = match &state.workspace {
Some(ws) => ws.clone(),
None => return Task::none(),
};
let max = state.config.max_concurrent_reads;
Task::perform(
async move { VcsAdapter::read_workspace_status(&workspace, max).await },
|s| Message::Background(BackgroundMessage::WorkspaceStatusRefreshed(s)),
)
}
pub(super) fn scan_topology_task(state: &mut AppState) -> Task<Message> {
let projects: Vec<_> = state
.workspace
.as_ref()
.map(|ws| ws.projects.clone())
.unwrap_or_default();
state.topology.phase = TopologyPhase::Scanning;
Task::perform(
async move { VcsAdapter::scan_topology(&projects).await },
|graph| Message::Background(BackgroundMessage::TopologyScanned(graph)),
)
}
pub(super) fn cancel_freezer_validation(state: &mut AppState) {
if let FreezerPhase::Validating { lease_id } = state.freezer.phase {
state.operation_interlock.release_if_matches(lease_id);
state.freezer.phase = FreezerPhase::Idle;
}
}
pub(super) fn clear_sync_retry_context(state: &mut AppState) {
invalidate_retry_preparation(state);
state.sync.retry_exclusions.clear();
}
pub(super) fn invalidate_retry_preparation(state: &mut AppState) {
if let Some(preparation) = state.sync.retry_preparation.take() {
state
.operation_interlock
.release_if_matches(preparation.lease_id);
if matches!(state.sync.phase, SyncPhase::RetryPreparing) {
state.sync.phase = SyncPhase::Idle;
}
}
}