orbital_scheduler/shared/
data_source.rs1use std::collections::{HashMap, HashSet};
4use std::future::Future;
5use std::pin::Pin;
6
7use leptos::prelude::{RwSignal, Update, WithUntracked};
8use orbital_date_pickers::DateTimeRange;
9
10use crate::{EventChanges, PlannedEvent, SchedulerError};
11
12#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
14pub struct AbortSignal {
15 aborted: bool,
16}
17
18impl AbortSignal {
19 pub fn is_aborted(self) -> bool {
21 self.aborted
22 }
23
24 pub fn abort(&mut self) {
26 self.aborted = true;
27 }
28}
29
30type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
31
32pub trait SchedulerDataSource: Send + Sync {
34 fn get_events(
35 &self,
36 range: DateTimeRange,
37 signal: AbortSignal,
38 ) -> BoxFuture<'_, Result<Vec<PlannedEvent>, SchedulerError>>;
39
40 fn persist_events(&self, changes: EventChanges) -> BoxFuture<'_, Result<(), SchedulerError>>;
41}
42
43pub enum SchedulerDataSourceMode {
45 Client(Vec<PlannedEvent>),
47 Remote(Box<dyn SchedulerDataSource>),
49}
50
51#[derive(Clone, Default)]
53pub struct LazyFetchCoordinator {
54 generation: u32,
55}
56
57impl LazyFetchCoordinator {
58 pub fn begin(&mut self) -> u32 {
60 self.generation = self.generation.wrapping_add(1);
61 self.generation
62 }
63
64 pub fn is_current(&self, gen: u32) -> bool {
66 self.generation == gen
67 }
68}
69
70pub fn coordinator_begin(coordinator: RwSignal<LazyFetchCoordinator>) -> u32 {
72 let mut generation = 0;
73 coordinator.update(|c| {
74 generation = c.begin();
75 });
76 generation
77}
78
79pub fn coordinator_is_current(
81 coordinator: RwSignal<LazyFetchCoordinator>,
82 generation: u32,
83) -> bool {
84 coordinator.with_untracked(|c| c.is_current(generation))
85}
86
87pub fn diff_event_changes(before: &[PlannedEvent], after: &[PlannedEvent]) -> EventChanges {
89 let before_map: HashMap<&str, &PlannedEvent> =
90 before.iter().map(|e| (e.id.as_str(), e)).collect();
91 let after_map: HashMap<&str, &PlannedEvent> =
92 after.iter().map(|e| (e.id.as_str(), e)).collect();
93
94 let before_ids: HashSet<&str> = before_map.keys().copied().collect();
95 let after_ids: HashSet<&str> = after_map.keys().copied().collect();
96
97 let added = after
98 .iter()
99 .filter(|e| !before_ids.contains(e.id.as_str()))
100 .cloned()
101 .collect();
102
103 let updated = after
104 .iter()
105 .filter(|e| before_map.get(e.id.as_str()).is_some_and(|prev| prev != e))
106 .cloned()
107 .collect();
108
109 let removed = before_ids
110 .difference(&after_ids)
111 .map(|id| (*id).to_string())
112 .collect();
113
114 EventChanges {
115 added,
116 updated,
117 removed,
118 }
119}
120
121#[cfg(test)]
122mod tests {
123 use super::*;
124 use orbital_base_components::{DatetimeTimezone, OrbitalDateTime, TryFromUnixSeconds};
125
126 fn event(id: &str, title: &str) -> PlannedEvent {
127 let start = OrbitalDateTime::try_from_unix_seconds(1_735_689_600, DatetimeTimezone::Utc)
128 .expect("valid");
129 let end = start.apply_hms(10, 0, 0).expect("valid end");
130 PlannedEvent::new(id, title, start, end)
131 }
132
133 #[test]
134 fn coordinator_increments_generation() {
135 let mut coord = LazyFetchCoordinator::default();
136 let g1 = coord.begin();
137 let g2 = coord.begin();
138 assert_ne!(g1, g2);
139 assert!(coord.is_current(g2));
140 assert!(!coord.is_current(g1));
141 }
142
143 #[test]
144 fn diff_detects_added_updated_removed() {
145 let mut evt1 = event("evt-1", "One");
146 let evt2 = event("evt-2", "Two");
147 let before = vec![evt1.clone(), evt2.clone()];
148
149 evt1.title = "One updated".into();
150 let evt3 = event("evt-3", "Three");
151 let after = vec![evt1.clone(), evt3.clone()];
152 let evt3_added = evt3;
153
154 let changes = diff_event_changes(&before, &after);
155 assert_eq!(changes.added, vec![evt3_added]);
156 assert_eq!(changes.updated, vec![evt1]);
157 assert_eq!(changes.removed, vec!["evt-2".to_string()]);
158 }
159}