private_event_sourcing/
event_history.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
use hdk::prelude::*;
use private_event_sourcing_integrity::{EntryTypes, EventHistory, UnitEntryTypes};

use crate::{
    acknowledgements::query_acknowledgement_entries, awaiting_dependencies::query_awaiting_deps,
    events_sent_to_recipients::query_events_sent_to_recipients_entries,
    query_private_event_entries, utils::create_relaxed,
};

pub fn query_event_histories() -> ExternResult<Vec<EventHistory>> {
    let filter = ChainQueryFilter::new()
        .entry_type(UnitEntryTypes::EventHistory.try_into()?)
        .include_entries(true)
        .action_type(ActionType::Create);
    let records = query(filter)?;
    let event_histories = records
        .into_iter()
        .map(|r| {
            let Some(entry) = r.entry().as_option().clone() else {
                return Err(wasm_error!("PrivateEvents record contained no entry."));
            };
            let entry = EventHistory::try_from(entry)?;
            Ok(entry)
        })
        .collect::<ExternResult<Vec<EventHistory>>>()?;

    Ok(event_histories)
}

#[hdk_extern]
pub fn export_event_history() -> ExternResult<EventHistory> {
    let acknowledgements = query_acknowledgement_entries(())?;
    let awaiting_deps = query_awaiting_deps()?;
    let events_sent_to_recipients = query_events_sent_to_recipients_entries(())?;
    let events = query_private_event_entries(())?;

    Ok(EventHistory {
        awaiting_deps,
        events,
        events_sent_to_recipients,
        acknowledgements,
    })
}

pub fn import_event_history(history: EventHistory) -> ExternResult<()> {
    // TODO: what to do about validation?

    create_relaxed(EntryTypes::EventHistory(history))?;

    Ok(())
}