163 lines
6.3 KiB
Rust
163 lines
6.3 KiB
Rust
use engine::mock_db::create_mock_db;
|
|
use engine::{create_heromodels_engine, eval_file};
|
|
use heromodels::models::flow::{Flow, FlowStep, SignatureRequirement};
|
|
use heromodels_core::Model;
|
|
use rhai::Scope;
|
|
use std::path::Path;
|
|
|
|
mod mock;
|
|
use mock::seed_flow_data;
|
|
|
|
fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
println!("Flow Rhai Example");
|
|
println!("=================");
|
|
|
|
// Create a mock database
|
|
let db = create_mock_db();
|
|
|
|
// Seed the database with initial data
|
|
seed_flow_data(db.clone());
|
|
|
|
// Create the Rhai engine with all modules registered
|
|
let engine = create_heromodels_engine(db.clone());
|
|
|
|
// Get the path to the script
|
|
let script_path = Path::new(file!())
|
|
.parent()
|
|
.unwrap()
|
|
.join("flow_script.rhai");
|
|
|
|
println!("\nRunning script: {}", script_path.display());
|
|
println!("---------------------");
|
|
|
|
// Run the script
|
|
match eval_file(&engine, &script_path.to_string_lossy()) {
|
|
Ok(result) => {
|
|
if !result.is_unit() {
|
|
println!("\nScript returned: {:?}", result);
|
|
}
|
|
println!("\nScript executed successfully!");
|
|
}
|
|
Err(err) => {
|
|
eprintln!("\nError running script: {}", err);
|
|
return Err(Box::new(std::io::Error::new(
|
|
std::io::ErrorKind::Other,
|
|
err.to_string(),
|
|
)));
|
|
}
|
|
}
|
|
|
|
// Demonstrate direct Rust interaction with the Rhai-exposed flow functionality
|
|
println!("\nDirect Rust interaction with Rhai-exposed flow functionality");
|
|
println!("----------------------------------------------------------");
|
|
|
|
// Create a new scope
|
|
let mut scope = Scope::new();
|
|
|
|
// Create a new flow using the Rhai function
|
|
let result = engine.eval::<Flow>("new_flow(0, \"Direct Rust Flow\")");
|
|
match result {
|
|
Ok(mut flow) => {
|
|
println!(
|
|
"Created flow from Rust: {} (ID: {})",
|
|
flow.name,
|
|
flow.get_id()
|
|
);
|
|
|
|
// Set flow status using the builder pattern
|
|
flow = flow.status("active".to_string());
|
|
println!("Set flow status to: {}", flow.status);
|
|
|
|
// Create a new flow step using the Rhai function
|
|
let result = engine.eval::<FlowStep>("new_flow_step(0, 1)");
|
|
|
|
match result {
|
|
Ok(mut step) => {
|
|
println!(
|
|
"Created flow step from Rust: Step Order {} (ID: {})",
|
|
step.step_order,
|
|
step.get_id()
|
|
);
|
|
|
|
// Set step description
|
|
step = step.description("Direct Rust Step".to_string());
|
|
println!(
|
|
"Set step description to: {}",
|
|
step.description
|
|
.clone()
|
|
.unwrap_or_else(|| "None".to_string())
|
|
);
|
|
|
|
// Create a signature requirement using the Rhai function
|
|
let result = engine.eval::<SignatureRequirement>(
|
|
"new_signature_requirement(0, 1, \"Direct Rust Signer\", \"Please sign this document\")"
|
|
);
|
|
|
|
match result {
|
|
Ok(req) => {
|
|
println!(
|
|
"Created signature requirement from Rust: Public Key {} (ID: {})",
|
|
req.public_key,
|
|
req.get_id()
|
|
);
|
|
|
|
// Add the step to the flow using the builder pattern
|
|
flow = flow.add_step(step);
|
|
println!(
|
|
"Added step to flow. Flow now has {} steps",
|
|
flow.steps.len()
|
|
);
|
|
|
|
// Save the flow to the database using the Rhai function
|
|
let save_flow_script = "fn save_it(f) { return db::save_flow(f); }";
|
|
let save_flow_ast = engine.compile(save_flow_script).unwrap();
|
|
let result = engine.call_fn::<Flow>(
|
|
&mut scope,
|
|
&save_flow_ast,
|
|
"save_it",
|
|
(flow,),
|
|
);
|
|
match result {
|
|
Ok(saved_flow) => {
|
|
println!(
|
|
"Saved flow to database with ID: {}",
|
|
saved_flow.get_id()
|
|
);
|
|
}
|
|
Err(err) => eprintln!("Error saving flow: {}", err),
|
|
}
|
|
|
|
// Save the signature requirement to the database using the Rhai function
|
|
let save_req_script =
|
|
"fn save_it(r) { return db::save_signature_requirement(r); }";
|
|
let save_req_ast = engine.compile(save_req_script).unwrap();
|
|
let result = engine.call_fn::<SignatureRequirement>(
|
|
&mut scope,
|
|
&save_req_ast,
|
|
"save_it",
|
|
(req,),
|
|
);
|
|
match result {
|
|
Ok(saved_req) => {
|
|
println!(
|
|
"Saved signature requirement to database with ID: {}",
|
|
saved_req.get_id()
|
|
);
|
|
}
|
|
Err(err) => {
|
|
eprintln!("Error saving signature requirement: {}", err)
|
|
}
|
|
}
|
|
}
|
|
Err(err) => eprintln!("Error creating signature requirement: {}", err),
|
|
}
|
|
}
|
|
Err(err) => eprintln!("Error creating flow step: {}", err),
|
|
}
|
|
}
|
|
Err(err) => eprintln!("Error creating flow: {}", err),
|
|
}
|
|
|
|
Ok(())
|
|
}
|