Struct BiTemporal 

pub struct BiTemporal<T> {
    pub data: T,
    pub version_id: Uuid,
    pub valid_from: NaiveDateTime,
    pub valid_to: Option<NaiveDateTime>,
    pub recorded_at: DateTime<Utc>,
    pub superseded_at: Option<DateTime<Utc>>,
    pub recorded_by: String,
    pub change_reason: Option<String>,
    pub previous_version_id: Option<Uuid>,
    pub change_type: TemporalChangeType,
}

Bi-temporal wrapper for any auditable entity.

Provides two temporal dimensions:

• Business time: When the fact was/is true in the real world
• System time: When the fact was recorded in the system

Example

use datasynth_core::models::BiTemporal;

// A journal entry that was valid from Jan 1 to Jan 15
// but was recorded on Jan 5 and corrected on Jan 16
let entry = BiTemporal::new(journal_entry)
    .with_valid_time(jan_1, Some(jan_15))
    .with_recorded_by("user001")
    .with_change_reason("Initial posting");

Fields

data: T

The wrapped data

version_id: Uuid

Unique version ID for this temporal record

valid_from: NaiveDateTime

When this fact became true in the business world

valid_to: Option<NaiveDateTime>

When this fact stopped being true (None = still current)

recorded_at: DateTime<Utc>

When this record was created in the system

superseded_at: Option<DateTime<Utc>>

When this record was superseded by a newer version (None = current version)

recorded_by: String

User/system that recorded this version

change_reason: Option<String>

Reason for change (for corrections/adjustments)

previous_version_id: Option<Uuid>

Previous version ID (for version chain)

change_type: TemporalChangeType

Change type classification

Implementations

impl<T> BiTemporal<T>

pub fn new(data: T) -> Self

Create a new bi-temporal record with current timestamps.

pub fn with_valid_time( self, from: NaiveDateTime, to: Option<NaiveDateTime>, ) -> Self

Set the valid time range.

pub fn valid_from(self, from: NaiveDateTime) -> Self

Set valid_from only.

pub fn valid_to(self, to: NaiveDateTime) -> Self

Set valid_to only.

pub fn with_recorded_at(self, recorded_at: DateTime<Utc>) -> Self

Set the recorded_at timestamp.

pub fn with_recorded_by(self, recorded_by: &str) -> Self

Set who recorded this version.

pub fn with_change_reason(self, reason: &str) -> Self

Set the change reason.

pub fn with_change_type(self, change_type: TemporalChangeType) -> Self

Set the change type.

pub fn with_previous_version(self, previous_id: Uuid) -> Self

Link to a previous version.

pub fn is_currently_valid(&self) -> bool

Check if this record is currently valid (business time).

pub fn is_current_version(&self) -> bool

Check if this is the current version (system time).

pub fn was_valid_at(&self, at: NaiveDateTime) -> bool

Check if this record was valid at a specific business time.

pub fn was_current_at(&self, at: DateTime<Utc>) -> bool

Check if this version was the current version at a specific system time.

pub fn supersede(&mut self, superseded_at: DateTime<Utc>)

Supersede this record with a new version.

pub fn correct(&self, new_data: T, corrected_by: &str, reason: &str) -> Self

where T: Clone,

Create a correction of this record.

pub fn reverse(&self, reversed_by: &str, reason: &str) -> Self

where T: Clone,

Create a reversal of this record.

pub fn inner(&self) -> &T

Get a reference to the underlying data.

pub fn inner_mut(&mut self) -> &mut T

Get a mutable reference to the underlying data.

pub fn into_inner(self) -> T

Consume and return the underlying data.

Trait Implementations

impl<T: Clone> Clone for BiTemporal<T>

fn clone(&self) -> BiTemporal<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for BiTemporal<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for BiTemporal<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for BiTemporal<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.