Struct Lots 

pub struct Lots { /* private fields */ }

Lot/Batch tracking management interface.

Implementations

impl Lots

pub fn create(&self, input: CreateLot) -> Result<Lot>

Create a new lot.

Example

use stateset_embedded::{Commerce, CreateLot};
use chrono::{Utc, Duration};
use rust_decimal_macros::dec;

let commerce = Commerce::new(":memory:")?;

let lot = commerce.lots().create(CreateLot {
    lot_number: Some("BATCH-001".into()),
    sku: "PROD-001".into(),
    quantity_produced: dec!(500),
    production_date: Some(Utc::now()),
    expiration_date: Some(Utc::now() + Duration::days(180)),
    ..Default::default()
})?;

pub fn get(&self, id: Uuid) -> Result<Option<Lot>>

Get a lot by ID.

pub fn get_by_number(&self, lot_number: &str) -> Result<Option<Lot>>

Get a lot by lot number.

pub fn list(&self, filter: LotFilter) -> Result<Vec<Lot>>

List lots with optional filtering.

Example

use stateset_embedded::{Commerce, LotFilter, LotStatus};

let commerce = Commerce::new(":memory:")?;

// Get all active lots for a SKU
let lots = commerce.lots().list(LotFilter {
    sku: Some("PROD-001".into()),
    status: Some(LotStatus::Active),
    ..Default::default()
})?;

pub fn update(&self, id: Uuid, input: UpdateLot) -> Result<Lot>

Update a lot.

pub fn delete(&self, id: Uuid) -> Result<()>

Delete a lot (only if unused).

pub fn quarantine(&self, id: Uuid, reason: &str) -> Result<Lot>

Quarantine a lot (prevent usage).

Example

use stateset_embedded::Commerce;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

commerce.lots().quarantine(Uuid::new_v4(), "Quality issue detected")?;

pub fn release_quarantine(&self, id: Uuid) -> Result<Lot>

Release a lot from quarantine.

pub fn adjust(&self, input: AdjustLot) -> Result<LotTransaction>

Adjust lot quantity (positive or negative).

Example

use stateset_embedded::{Commerce, AdjustLot};
use rust_decimal_macros::dec;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

// Remove 10 units due to damage
commerce.lots().adjust(AdjustLot {
    lot_id: Uuid::new_v4(),
    quantity: dec!(-10),
    reason: "Damaged in storage".into(),
    performed_by: Some("warehouse_user".into()),
    ..Default::default()
})?;

pub fn consume(&self, input: ConsumeLot) -> Result<LotTransaction>

Consume quantity from a lot.

Example

use stateset_embedded::{Commerce, ConsumeLot};
use rust_decimal_macros::dec;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

commerce.lots().consume(ConsumeLot {
    lot_id: Uuid::new_v4(),
    quantity: dec!(25),
    reference_type: "work_order".into(),
    reference_id: Uuid::new_v4(),
    ..Default::default()
})?;

pub fn reserve(&self, input: ReserveLot) -> Result<Uuid>

Reserve quantity in a lot.

Returns the reservation ID which can be used to release or confirm the reservation.

pub fn release_reservation(&self, reservation_id: Uuid) -> Result<()>

Release a reservation (cancel it without consuming).

pub fn confirm_reservation( &self, reservation_id: Uuid, ) -> Result<LotTransaction>

Confirm a reservation (convert to actual consumption).

pub fn transfer(&self, input: TransferLot) -> Result<LotTransaction>

Transfer lot to a different location.

pub fn split(&self, input: SplitLot) -> Result<Lot>

Split a lot into two.

Example

use stateset_embedded::{Commerce, SplitLot};
use rust_decimal_macros::dec;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

// Split 100 units into a new lot
let new_lot = commerce.lots().split(SplitLot {
    source_lot_id: Uuid::new_v4(),
    new_lot_number: Some("LOT-2025-001B".into()),
    quantity: dec!(100),
    reason: Some("Customer allocation".into()),
    ..Default::default()
})?;

pub fn merge(&self, input: MergeLots) -> Result<Lot>

Merge multiple lots into one.

pub fn add_certificate( &self, input: AddLotCertificate, ) -> Result<LotCertificate>

Add a certificate to a lot.

Example

use stateset_embedded::{Commerce, AddLotCertificate, CertificateType};
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

commerce.lots().add_certificate(AddLotCertificate {
    lot_id: Uuid::new_v4(),
    certificate_type: CertificateType::Coa,
    document_url: Some("https://storage.example.com/certs/coa-123.pdf".into()),
    issued_by: Some("Quality Lab Inc.".into()),
    ..Default::default()
})?;

pub fn get_certificates(&self, lot_id: Uuid) -> Result<Vec<LotCertificate>>

Get certificates for a lot.

pub fn delete_certificate(&self, certificate_id: Uuid) -> Result<()>

Remove a certificate from a lot.

pub fn get_locations(&self, lot_id: Uuid) -> Result<Vec<LotLocation>>

Get lot quantities by location.

pub fn get_quantity_at_location( &self, lot_id: Uuid, location_id: i32, ) -> Result<Option<Decimal>>

Get quantity at a specific location.

pub fn get_transactions( &self, lot_id: Uuid, limit: u32, ) -> Result<Vec<LotTransaction>>

Get transaction history for a lot.

Example

use stateset_embedded::Commerce;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

let transactions = commerce.lots().get_transactions(
    Uuid::new_v4(),
    100,  // limit
)?;

for tx in transactions {
    println!("{:?}: {} units", tx.transaction_type, tx.quantity);
}

pub fn trace(&self, lot_id: Uuid) -> Result<TraceabilityResult>

Get full bidirectional traceability (upstream and downstream).

Example

use stateset_embedded::Commerce;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

let trace = commerce.lots().trace(Uuid::new_v4())?;

println!("Upstream sources: {} nodes", trace.upstream.len());
println!("Downstream destinations: {} nodes", trace.downstream.len());

pub fn get_expiring_lots(&self, days: i32) -> Result<Vec<Lot>>

Get lots expiring within a number of days.

pub fn get_expired_lots(&self) -> Result<Vec<Lot>>

Get already expired lots.

pub fn get_available_lots_for_sku(&self, sku: &str) -> Result<Vec<Lot>>

Get lots with available quantity for a SKU.

Returns lots ordered by production date (FIFO).

pub fn count(&self, filter: LotFilter) -> Result<u64>

Count lots matching filter.

pub fn create_batch(&self, inputs: Vec<CreateLot>) -> Result<BatchResult<Lot>>

Create multiple lots at once.

pub fn get_batch(&self, ids: Vec<Uuid>) -> Result<Vec<Lot>>

Get multiple lots by ID.

pub fn get_active_lots(&self, sku: &str) -> Result<Vec<Lot>>

Get all active lots for a SKU.

pub fn get_quarantined(&self) -> Result<Vec<Lot>>

Get all quarantined lots.

Trait Implementations

impl Debug for Lots

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

Formats the value using the given formatter.