update grid4 & heroledger models

heromodels/examples/grid4_bid_example.rs

@@ -0,0 +1,199 @@
+use heromodels::db::{Collection, Db};
+use heromodels::models::grid4::{Bid, BidStatus, BillingPeriod};
+use heromodels::models::grid4::bid::bid_index::customer_id;
+use heromodels_core::Model;
+
+// Helper function to print bid details
+fn print_bid_details(bid: &Bid) {
+    println!("\n--- Bid Details ---");
+    println!("ID: {}", bid.get_id());
+    println!("Customer ID: {}", bid.customer_id);
+    println!("Compute Slices: {}", bid.compute_slices_nr);
+    println!("Compute Slice Price: ${:.2}", bid.compute_slice_price);
+    println!("Storage Slices: {}", bid.storage_slices_nr);
+    println!("Storage Slice Price: ${:.2}", bid.storage_slice_price);
+    println!("Status: {:?}", bid.status);
+    println!("Obligation: {}", bid.obligation);
+    println!("Start Date: {}", bid.start_date);
+    println!("End Date: {}", bid.end_date);
+    println!("Billing Period: {:?}", bid.billing_period);
+    println!("Signature User: {}", bid.signature_user);
+    println!("Created At: {}", bid.base_data.created_at);
+    println!("Modified At: {}", bid.base_data.modified_at);
+}
+
+fn main() {
+    // Create a new DB instance in /tmp/grid4_db, and reset before every run
+    let db = heromodels::db::hero::OurDB::new("/tmp/grid4_db", true).expect("Can create DB");
+
+    println!("Grid4 Bid Models - Basic Usage Example");
+    println!("=====================================");
+
+    // Create bids with different configurations
+
+    // Bid 1 - Small compute request
+    let bid1 = Bid::new()
+        .customer_id(101)
+        .compute_slices_nr(4)
+        .compute_slice_price(0.05)
+        .storage_slices_nr(10)
+        .storage_slice_price(0.02)
+        .status(BidStatus::Pending)
+        .obligation(false)
+        .start_date(1640995200) // 2022-01-01
+        .end_date(1672531200)   // 2023-01-01
+        .billing_period(BillingPeriod::Monthly)
+        .signature_user("sig_user_101_abc123".to_string());
+
+    // Bid 2 - Large compute request with obligation
+    let bid2 = Bid::new()
+        .customer_id(102)
+        .compute_slices_nr(16)
+        .compute_slice_price(0.04)
+        .storage_slices_nr(50)
+        .storage_slice_price(0.015)
+        .status(BidStatus::Confirmed)
+        .obligation(true)
+        .start_date(1640995200)
+        .end_date(1704067200)   // 2024-01-01
+        .billing_period(BillingPeriod::Yearly)
+        .signature_user("sig_user_102_def456".to_string());
+
+    // Bid 3 - Storage-heavy request
+    let bid3 = Bid::new()
+        .customer_id(103)
+        .compute_slices_nr(2)
+        .compute_slice_price(0.06)
+        .storage_slices_nr(100)
+        .storage_slice_price(0.01)
+        .status(BidStatus::Assigned)
+        .obligation(true)
+        .start_date(1640995200)
+        .end_date(1672531200)
+        .billing_period(BillingPeriod::Hourly)
+        .signature_user("sig_user_103_ghi789".to_string());
+
+    // Bid 4 - Cancelled bid
+    let bid4 = Bid::new()
+        .customer_id(104)
+        .compute_slices_nr(8)
+        .compute_slice_price(0.055)
+        .storage_slices_nr(25)
+        .storage_slice_price(0.018)
+        .status(BidStatus::Cancelled)
+        .obligation(false)
+        .start_date(1640995200)
+        .end_date(1672531200)
+        .billing_period(BillingPeriod::Monthly)
+        .signature_user("sig_user_104_jkl012".to_string());
+
+    // Save all bids to database and get their assigned IDs and updated models
+    let (bid1_id, db_bid1) = db
+        .collection()
+        .expect("can open bid collection")
+        .set(&bid1)
+        .expect("can set bid");
+    let (bid2_id, db_bid2) = db
+        .collection()
+        .expect("can open bid collection")
+        .set(&bid2)
+        .expect("can set bid");
+    let (bid3_id, db_bid3) = db
+        .collection()
+        .expect("can open bid collection")
+        .set(&bid3)
+        .expect("can set bid");
+    let (bid4_id, db_bid4) = db
+        .collection()
+        .expect("can open bid collection")
+        .set(&bid4)
+        .expect("can set bid");
+
+    println!("Bid 1 assigned ID: {}", bid1_id);
+    println!("Bid 2 assigned ID: {}", bid2_id);
+    println!("Bid 3 assigned ID: {}", bid3_id);
+    println!("Bid 4 assigned ID: {}", bid4_id);
+
+    // Print all bids retrieved from database
+    println!("\n--- Bids Retrieved from Database ---");
+    println!("\n1. Small compute bid:");
+    print_bid_details(&db_bid1);
+
+    println!("\n2. Large compute bid with obligation:");
+    print_bid_details(&db_bid2);
+
+    println!("\n3. Storage-heavy bid:");
+    print_bid_details(&db_bid3);
+
+    println!("\n4. Cancelled bid:");
+    print_bid_details(&db_bid4);
+
+    // Demonstrate different ways to retrieve bids from the database
+    println!("\n--- Retrieving Bids by Different Methods ---");
+    println!("\n1. By Customer ID Index (Customer 102):");
+    
+    let customer_bids = db
+        .collection::<Bid>()
+        .expect("can open bid collection")
+        .get::<customer_id, _>(&102u32)
+        .expect("can load bids by customer");
+
+    assert_eq!(customer_bids.len(), 1);
+    print_bid_details(&customer_bids[0]);
+
+    println!("\n2. Updating Bid Status:");
+    let mut updated_bid = db_bid1.clone();
+    updated_bid.status = BidStatus::Confirmed;
+
+    let (_, confirmed_bid) = db
+        .collection::<Bid>()
+        .expect("can open bid collection")
+        .set(&updated_bid)
+        .expect("can update bid");
+
+    println!("Updated bid status to Confirmed:");
+    print_bid_details(&confirmed_bid);
+
+    // 3. Delete a bid and show the updated results
+    println!("\n3. After Deleting a Bid:");
+    println!("Deleting bid with ID: {}", bid4_id);
+    db.collection::<Bid>()
+        .expect("can open bid collection")
+        .delete_by_id(bid4_id)
+        .expect("can delete existing bid");
+
+    // Show remaining bids
+    let all_bids = db
+        .collection::<Bid>()
+        .expect("can open bid collection")
+        .get_all()
+        .expect("can load all bids");
+
+    println!("Remaining bids count: {}", all_bids.len());
+    assert_eq!(all_bids.len(), 3);
+
+    // Calculate total compute and storage requested
+    println!("\n--- Bid Analytics ---");
+    let total_compute_slices: i32 = all_bids.iter().map(|b| b.compute_slices_nr).sum();
+    let total_storage_slices: i32 = all_bids.iter().map(|b| b.storage_slices_nr).sum();
+    let avg_compute_price: f64 = all_bids.iter().map(|b| b.compute_slice_price).sum::<f64>() / all_bids.len() as f64;
+    let avg_storage_price: f64 = all_bids.iter().map(|b| b.storage_slice_price).sum::<f64>() / all_bids.len() as f64;
+
+    println!("Total Compute Slices Requested: {}", total_compute_slices);
+    println!("Total Storage Slices Requested: {}", total_storage_slices);
+    println!("Average Compute Price: ${:.3}", avg_compute_price);
+    println!("Average Storage Price: ${:.3}", avg_storage_price);
+
+    // Count bids by status
+    let confirmed_count = all_bids.iter().filter(|b| matches!(b.status, BidStatus::Confirmed)).count();
+    let assigned_count = all_bids.iter().filter(|b| matches!(b.status, BidStatus::Assigned)).count();
+    let pending_count = all_bids.iter().filter(|b| matches!(b.status, BidStatus::Pending)).count();
+
+    println!("\nBids by Status:");
+    println!("  Confirmed: {}", confirmed_count);
+    println!("  Assigned: {}", assigned_count);
+    println!("  Pending: {}", pending_count);
+
+    println!("\n--- Model Information ---");
+    println!("Bid DB Prefix: {}", Bid::db_prefix());
+}