Struct WorkOrders 

pub struct WorkOrders { /* private fields */ }

Work Order operations.

Access via commerce.work_orders().

Example

use stateset_embedded::{Commerce, CreateWorkOrder, CreateWorkOrderTask, ProductId};
use rust_decimal_macros::dec;

let commerce = Commerce::new("./store.db")?;

// Create a work order
let wo = commerce.work_orders().create(CreateWorkOrder {
    product_id: ProductId::new(),
    quantity_to_build: dec!(100),
    tasks: Some(vec![
        CreateWorkOrderTask {
            task_name: "Assembly".into(),
            sequence: Some(1),
            estimated_hours: Some(dec!(2)),
            ..Default::default()
        },
    ]),
    ..Default::default()
})?;

// Start the work order
let wo = commerce.work_orders().start(wo.id)?;

// Complete with quantity
let wo = commerce.work_orders().complete(wo.id, dec!(100))?;

Implementations

impl WorkOrders

pub fn create(&self, input: CreateWorkOrder) -> Result<WorkOrder>

Create a new work order.

Example

use stateset_embedded::{Commerce, CreateWorkOrder, ProductId};
use rust_decimal_macros::dec;

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

let wo = commerce.work_orders().create(CreateWorkOrder {
    product_id: ProductId::new(),
    quantity_to_build: dec!(50),
    notes: Some("Rush order".into()),
    ..Default::default()
})?;

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

Get a work order by ID.

pub fn get_by_number( &self, work_order_number: &str, ) -> Result<Option<WorkOrder>>

Get a work order by its work order number.

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

Update a work order.

pub fn list(&self, filter: WorkOrderFilter) -> Result<Vec<WorkOrder>>

List work orders with optional filter.

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

Delete a work order (cancels if not started).

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

Start a work order.

Transitions the work order from Planned to InProgress and records the actual start time.

Example

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

let commerce = Commerce::new(":memory:")?;
let wo_id = Uuid::new_v4(); // Existing work order ID

let wo = commerce.work_orders().start(wo_id)?;
assert_eq!(wo.status.to_string(), "in_progress");

pub fn complete( &self, id: Uuid, quantity_completed: Decimal, ) -> Result<WorkOrder>

Complete a work order with the quantity produced.

If the quantity meets or exceeds the target, the order is marked as Completed. Otherwise, it’s marked as PartiallyCompleted.

Example

use stateset_embedded::Commerce;
use rust_decimal_macros::dec;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;
let wo_id = Uuid::new_v4(); // Existing work order ID

// Complete with full quantity
let wo = commerce.work_orders().complete(wo_id, dec!(100))?;

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

Put a work order on hold.

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

Resume a held work order.

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

Cancel a work order.

pub fn add_task( &self, work_order_id: Uuid, task: CreateWorkOrderTask, ) -> Result<WorkOrderTask>

Add a task to a work order.

Example

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

let commerce = Commerce::new(":memory:")?;
let wo_id = Uuid::new_v4(); // Existing work order ID

let task = commerce.work_orders().add_task(wo_id, CreateWorkOrderTask {
    task_name: "Quality Check".into(),
    sequence: Some(10),
    estimated_hours: Some(dec!(0.5)),
    ..Default::default()
})?;

pub fn update_task( &self, task_id: Uuid, task: UpdateWorkOrderTask, ) -> Result<WorkOrderTask>

Update a task.

pub fn remove_task(&self, task_id: Uuid) -> Result<()>

Remove a task from a work order.

pub fn get_tasks(&self, work_order_id: Uuid) -> Result<Vec<WorkOrderTask>>

Get all tasks for a work order.

pub fn start_task(&self, task_id: Uuid) -> Result<WorkOrderTask>

Start a task.

pub fn complete_task( &self, task_id: Uuid, actual_hours: Option<Decimal>, ) -> Result<WorkOrderTask>

Complete a task with optional actual hours.

pub fn add_material( &self, work_order_id: Uuid, material: AddWorkOrderMaterial, ) -> Result<WorkOrderMaterial>

Add material to a work order.

Example

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

let commerce = Commerce::new(":memory:")?;
let wo_id = Uuid::new_v4(); // Existing work order ID

let material = commerce.work_orders().add_material(wo_id, AddWorkOrderMaterial {
    component_sku: "SCREW-M3".into(),
    component_name: "M3 Screw".into(),
    quantity: dec!(200),
    ..Default::default()
})?;

pub fn consume_material( &self, material_id: Uuid, quantity: Decimal, ) -> Result<WorkOrderMaterial>

Consume material during production.

Records that a certain quantity of material has been used.

pub fn get_materials( &self, work_order_id: Uuid, ) -> Result<Vec<WorkOrderMaterial>>

Get all materials for a work order.

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

Count work orders matching filter.

pub fn for_product(&self, product_id: ProductId) -> Result<Vec<WorkOrder>>

Get work orders for a specific product.

pub fn for_bom(&self, bom_id: Uuid) -> Result<Vec<WorkOrder>>

Get work orders using a specific BOM.

Trait Implementations

impl Debug for WorkOrders

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

Formats the value using the given formatter.