Struct DomainRecordDraft 

pub struct DomainRecordDraft {
    pub reference: DomainRecordRef,
    pub payload: Value,
    pub references: Vec<DomainReference>,
}

Fields

reference: DomainRecordRef

payload: Value

references: Vec<DomainReference>

Implementations

impl DomainRecordDraft

pub fn new(reference: DomainRecordRef, payload: Value) -> DomainRecordDraft

pub fn from_typed<T>( reference: TypedDomainRecordRef<T>, payload: &<T as DomainRecordType>::Payload, ) -> Result<DomainRecordDraft, CanwuError>

where T: DomainRecordType, <T as DomainRecordType>::Payload: Serialize,

Examples found in repository

examples/governance_transition.rs (lines 266-280)

fn publish_order(
    view: &SimulationView<'_>,
    context: &BoundaryContext,
) -> Result<BoundaryProposal, CanwuError> {
    let Some(order_id) = owned_order_ingress(view, context, CENTRAL_PLUGIN, ISSUE_INGRESS)? else {
        return Ok(BoundaryProposal::default());
    };
    if order_id != ORDER_ID {
        return Err(CanwuError::new(
            ErrorCode::InvalidBoundary,
            "the issue ingress names an unexpected relief order",
        ));
    }
    if view.typed_domain_record(&order_reference())?.is_some() {
        return Err(CanwuError::new(
            ErrorCode::InvalidBoundary,
            "the relief order already exists; duplicate issue ingress is invalid",
        ));
    }
    let treasury_hash = action_hash(600)?;
    let county_hash = action_hash(600)?;
    let manifest = DomainRecordDraft::from_typed(
        order_reference(),
        &ReliefOrder {
            order_id: ORDER_ID.to_owned(),
            issued_by: CENTRAL_PLUGIN.to_owned(),
            treasury_system: "prepare-treasury".to_owned(),
            treasury_version: 1,
            treasury_disposition: "committed".to_owned(),
            treasury_hash,
            county_system: "prepare-county".to_owned(),
            county_version: 1,
            county_disposition: "committed".to_owned(),
            county_hash,
        },
    )?;
    Ok(BoundaryProposal {
        directives: vec![
            BoundaryDirective::MutateRecord {
                mutation: DomainRecordMutation::Create { record: manifest },
                summary: "Publish the central relief order manifest".to_owned(),
            },
            BoundaryDirective::SchedulePluginIngress {
                target_plugin: TREASURY_PLUGIN.to_owned(),
                after: SimDuration::ZERO,
                packet_type: EXECUTE_INGRESS.to_owned(),
                priority: 0,
                payload: json!({"order_id": ORDER_ID}),
                affected: Vec::new(),
            },
            BoundaryDirective::SchedulePluginIngress {
                target_plugin: COUNTY_PLUGIN.to_owned(),
                after: SimDuration::ZERO,
                packet_type: EXECUTE_INGRESS.to_owned(),
                priority: 0,
                payload: json!({"order_id": ORDER_ID}),
                affected: Vec::new(),
            },
        ],
        ..BoundaryProposal::default()
    })
}

fn prepare_treasury(
    view: &SimulationView<'_>,
    context: &BoundaryContext,
) -> Result<BoundaryProposal, CanwuError> {
    prepare_owner(
        view,
        context,
        TREASURY_PLUGIN,
        "prepare-treasury",
        treasury_reference(),
        &action_payload(600),
    )
}

fn prepare_county(
    view: &SimulationView<'_>,
    context: &BoundaryContext,
) -> Result<BoundaryProposal, CanwuError> {
    prepare_owner(
        view,
        context,
        COUNTY_PLUGIN,
        "prepare-county",
        county_reference(),
        &action_payload(600),
    )
}

fn prepare_owner<T: DomainRecordType<Payload = ReliefAction>>(
    view: &SimulationView<'_>,
    context: &BoundaryContext,
    plugin: &str,
    system: &str,
    reference: TypedDomainRecordRef<T>,
    payload: &ReliefAction,
) -> Result<BoundaryProposal, CanwuError> {
    let Some(order_id) = owned_order_ingress(view, context, plugin, EXECUTE_INGRESS)? else {
        return Ok(BoundaryProposal::default());
    };
    if order_id != ORDER_ID {
        return Err(CanwuError::new(
            ErrorCode::InvalidBoundary,
            format!("{plugin} received an ingress for the wrong order"),
        ));
    }
    let order = order_payload(view)?;
    let hash = action_hash(payload.grain_units)?;
    validate_order(&order, system, plugin, &hash)?;
    let record = DomainRecordDraft::from_typed(reference, payload)?;
    Ok(BoundaryProposal {
        directives: vec![BoundaryDirective::MutateRecord {
            mutation: DomainRecordMutation::Create { record },
            summary: format!("{plugin} prepares its guarded relief disposition"),
        }],
        ..BoundaryProposal::default()
    })
}

Trait Implementations

impl Clone for DomainRecordDraft

fn clone(&self) -> DomainRecordDraft

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DomainRecordDraft

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DomainRecordDraft

fn deserialize<__D>( __deserializer: __D, ) -> Result<DomainRecordDraft, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DomainRecordDraft

fn eq(&self, other: &DomainRecordDraft) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for DomainRecordDraft

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DomainRecordDraft