use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; use uuid::Uuid; #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)] #[serde(rename_all = "camelCase")] pub struct Pending { pub update_id: u64, pub meta: M, pub enqueued_at: DateTime, pub index_uuid: Uuid, } impl Pending { pub fn new(meta: M, update_id: u64, index_uuid: Uuid) -> Self { Self { enqueued_at: Utc::now(), meta, update_id, index_uuid, } } pub fn processing(self) -> Processing { Processing { from: self, started_processing_at: Utc::now(), } } pub fn abort(self) -> Aborted { Aborted { from: self, aborted_at: Utc::now(), } } pub fn meta(&self) -> &M { &self.meta } pub fn id(&self) -> u64 { self.update_id } } #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)] #[serde(rename_all = "camelCase")] pub struct Processed { pub success: N, pub processed_at: DateTime, #[serde(flatten)] pub from: Processing, } impl Processed { pub fn id(&self) -> u64 { self.from.id() } } #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)] #[serde(rename_all = "camelCase")] pub struct Processing { #[serde(flatten)] pub from: Pending, pub started_processing_at: DateTime, } impl Processing { pub fn id(&self) -> u64 { self.from.id() } pub fn meta(&self) -> &M { self.from.meta() } pub fn index_uuid(&self) -> &Uuid { &self.from.index_uuid } pub fn process(self, meta: N) -> Processed { Processed { success: meta, from: self, processed_at: Utc::now(), } } pub fn fail(self, error: E) -> Failed { Failed { from: self, error, failed_at: Utc::now(), } } } #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)] #[serde(rename_all = "camelCase")] pub struct Aborted { #[serde(flatten)] from: Pending, aborted_at: DateTime, } impl Aborted { pub fn id(&self) -> u64 { self.from.id() } } #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)] #[serde(rename_all = "camelCase")] pub struct Failed { #[serde(flatten)] from: Processing, error: E, failed_at: DateTime, } impl Failed { pub fn id(&self) -> u64 { self.from.id() } } #[derive(Debug, PartialEq, Eq, Hash, Serialize)] #[serde(tag = "status", rename_all = "camelCase")] pub enum UpdateStatus { Processing(Processing), Pending(Pending), Processed(Processed), Aborted(Aborted), Failed(Failed), } impl UpdateStatus { pub fn id(&self) -> u64 { match self { UpdateStatus::Processing(u) => u.id(), UpdateStatus::Pending(u) => u.id(), UpdateStatus::Processed(u) => u.id(), UpdateStatus::Aborted(u) => u.id(), UpdateStatus::Failed(u) => u.id(), } } pub fn processed(&self) -> Option<&Processed> { match self { UpdateStatus::Processed(p) => Some(p), _ => None, } } } impl From> for UpdateStatus { fn from(other: Pending) -> Self { Self::Pending(other) } } impl From> for UpdateStatus { fn from(other: Aborted) -> Self { Self::Aborted(other) } } impl From> for UpdateStatus { fn from(other: Processed) -> Self { Self::Processed(other) } } impl From> for UpdateStatus { fn from(other: Processing) -> Self { Self::Processing(other) } } impl From> for UpdateStatus { fn from(other: Failed) -> Self { Self::Failed(other) } }