use std::fmt;
use std::ops::{Deref, DerefMut};
use crate::{Column, Executor, Model, Result, Value};
pub struct Tracked<M> {
record: M,
original: Vec<(&'static str, Value)>,
}
impl<M: Model> Tracked<M> {
pub fn new(record: M) -> Self {
let original = record.values();
Self { record, original }
}
pub fn changes(&self) -> Vec<(&'static str, Value, Value)> {
self.record
.values()
.into_iter()
.zip(&self.original)
.filter(|((_, new), (_, old))| new != old)
.map(|((column, new), (_, old))| (column, old.clone(), new))
.collect()
}
pub fn is_dirty(&self) -> bool {
self.record
.values()
.iter()
.zip(&self.original)
.any(|((_, new), (_, old))| new != old)
}
pub fn is_changed(&self, column: Column<M>) -> bool {
self.changes().iter().any(|(c, _, _)| *c == column.name())
}
pub async fn save<'e, E: Executor<'e>>(&mut self, executor: E) -> Result<bool> {
let changed: Vec<Column<M>> = self
.changes()
.into_iter()
.map(|(c, _, _)| Column::new(c))
.collect();
if changed.is_empty() {
return Ok(false);
}
let stored = self.record.save_only(executor, Some(changed)).await?;
*self = Tracked::new(stored);
Ok(true)
}
pub fn mark_clean(&mut self) {
self.original = self.record.values();
}
pub fn into_inner(self) -> M {
self.record
}
}
impl<M> Deref for Tracked<M> {
type Target = M;
fn deref(&self) -> &M {
&self.record
}
}
impl<M> DerefMut for Tracked<M> {
fn deref_mut(&mut self) -> &mut M {
&mut self.record
}
}
impl<M: fmt::Debug> fmt::Debug for Tracked<M> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Tracked").field(&self.record).finish()
}
}