Using a step in another workflow

/// The shop counter's card terminal, faked: it declines a card that expired before this year,
/// and prints what it does once it has answered. Its receipts start with `C`.
struct Terminal {
    this_year: u32,
}

#[async_trait]
impl Payments for Terminal {
    async fn charge(
        &self,
        order: &str,
        card: &str,
        amount: i64,
    ) -> Result<Option<String>, NetworkDown> {
        network().await;
        if expiry(card).is_some_and(|year| year < self.this_year) {
            println!("the counter's terminal declines card {card}: it has expired");
            return Ok(None);
        }
        println!("the counter's terminal charges {amount} for order {order}");
        Ok(Some(format!("C-{order}")))
    }
}

/// The counter's workflow: it looks the order up, and finishes an order already completed.
/// Otherwise it works out what the order costs, then charges it at the counter's terminal and
/// audits the charge. The customer takes the goods away, so nothing is shipped, and a card the
/// terminal declines is handed back rather than repaired.
#[workflow(name = "counter", async_reporters = [Log])]
#[with_step(Lookup, name = "lookup", policies = [AlreadyCompleted])]
#[with_step(Price, name = "price")]
#[with_step(Charge, name = "charge", policies = [Audit])]
struct Counter;

#[workflow]
impl Counter {
    /// Names each journey after its order.
    #[id_generator]
    fn order_number(&self, data: &DataBag) -> Result<String, Error> {
        Ok(data.required("order")?)
    }

    /// The order book, which has the orders completed before today.
    #[provider(key = "order_book")]
    fn ledger(&self) -> Result<Provided<dyn OrderBook>, Error> {
        Ok(provide!(Ledger {
            completed: vec!["A-13"],
        }))
    }

    /// The counter's terminal, as the payment client of the journey.
    #[provider(key = "payments")]
    fn terminal(&self) -> Result<Provided<dyn Payments>, Error> {
        Ok(provide!(Terminal { this_year: 2026 }))
    }
}

/// What the shop knows about an order collected at the counter when its journey starts.
#[derive(InitialData)]
struct CounterOrder {
    order: String,
    price: i64,
    discount: Option<i64>,
    card: String,
    gift_card: bool,
}

// The order, the customer, the price, the discount and the card.
let orders = [
    ("A-17", "Nia", 18, Some(3), "nia-2028"),
    ("A-18", "Omar", 12, None, "omar-2023"),
];
for (order, customer, price, discount, card) in orders {
    println!("{customer}'s order {order}, at the counter:");
    let instance = Counter::builder()
        .reporters_global_metadata("customer", customer.to_owned())
        .initial_data(CounterOrder {
            order: order.to_owned(),
            price,
            discount,
            card: card.to_owned(),
            gift_card: false,
        })
        .create()?;
    follow_up(&journey(instance).await?)?;
}

/// What the counter reads back once the journey has ended.
#[derive(Output)]
struct Collected {
    receipt: Option<String>,
    audit: Option<String>,
}

/// Says how a journey at the counter ended.
fn follow_up(result: &JourneyResult) -> Result<(), Box<dyn std::error::Error>> {
    let data: Collected = result.output()?;
    match &result.status {
        JourneyStatus::Succeeded { .. } => {
            let receipt = data.receipt.as_deref().unwrap_or("none");
            println!("the journey succeeded, with receipt {receipt}");
            println!("audit: {}", data.audit.as_deref().unwrap_or("none"));
        }
        JourneyStatus::Failed {
            failure: Failure::Failure(reason),
            ..
        } => println!("the journey failed: {}, hand the card back", reason.code()),
        _ => println!("the journey ended as {}", result.status.kind()),
    }
    Ok(())
}

/// Runs a journey at the counter with an executor of its own.
async fn journey(instance: Instance<Counter, Asynchronous>) -> Result<JourneyResult, Refusal> {
    local_executor_for!(Counter).run(instance).await
}