Struct SqliteFulfillmentRepository 

pub struct SqliteFulfillmentRepository { /* private fields */ }

Available on crate feature sqlite only.

SQLite fulfillment repository

Implementations

impl SqliteFulfillmentRepository

pub const fn new(pool: Pool<SqliteConnectionManager>) -> Self

Trait Implementations

impl Debug for SqliteFulfillmentRepository

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

Formats the value using the given formatter.

impl FulfillmentRepository for SqliteFulfillmentRepository

fn create_wave(&self, input: CreateWave) -> Result<Wave>

Create a wave from orders

fn get_wave(&self, id: FulfillmentId) -> Result<Option<Wave>>

Get wave by ID

fn get_wave_by_number(&self, number: &str) -> Result<Option<Wave>>

Get wave by number

fn list_waves(&self, filter: WaveFilter) -> Result<Vec<Wave>>

List waves with filter

fn release_wave(&self, id: FulfillmentId) -> Result<Wave>

Release wave for picking

fn complete_wave(&self, id: FulfillmentId) -> Result<Wave>

Complete a wave

fn cancel_wave(&self, id: FulfillmentId) -> Result<Wave>

Cancel a wave

fn get_wave_orders(&self, wave_id: FulfillmentId) -> Result<Vec<OrderId>>

Get orders in a wave

fn count_waves(&self, filter: WaveFilter) -> Result<u64>

Count waves

fn create_pick(&self, input: CreatePickTask) -> Result<PickTask>

Create a pick task

fn get_pick(&self, id: Uuid) -> Result<Option<PickTask>>

Get pick task by ID

fn list_picks(&self, filter: PickTaskFilter) -> Result<Vec<PickTask>>

List pick tasks with filter

fn assign_pick(&self, id: Uuid, assigned_to: &str) -> Result<PickTask>

Assign pick to user

fn start_pick(&self, id: Uuid) -> Result<PickTask>

Start a pick

fn complete_pick(&self, input: CompletePick) -> Result<PickTask>

Complete a pick

fn report_short( &self, id: Uuid, short_qty: Decimal, reason: &str, ) -> Result<PickTask>

Report short pick

fn cancel_pick(&self, id: Uuid) -> Result<PickTask>

Cancel a pick

fn get_picks_for_order(&self, order_id: OrderId) -> Result<Vec<PickTask>>

Get picks for order

fn get_picks_for_wave(&self, wave_id: FulfillmentId) -> Result<Vec<PickTask>>

Get picks for wave

fn count_picks(&self, filter: PickTaskFilter) -> Result<u64>

Count picks

fn create_pack(&self, input: CreatePackTask) -> Result<PackTask>

Create a pack task

fn get_pack(&self, id: Uuid) -> Result<Option<PackTask>>

Get pack task by ID

fn list_packs(&self, filter: PackTaskFilter) -> Result<Vec<PackTask>>

List pack tasks with filter

fn assign_pack(&self, id: Uuid, assigned_to: &str) -> Result<PackTask>

Assign pack to user

fn start_pack(&self, id: Uuid) -> Result<PackTask>

Start packing

fn complete_pack(&self, id: Uuid) -> Result<PackTask>

Complete packing

fn add_carton(&self, input: AddCarton) -> Result<Carton>

Add carton to pack task

fn add_carton_item(&self, input: AddCartonItem) -> Result<CartonItem>

Add item to carton

fn get_cartons(&self, pack_task_id: Uuid) -> Result<Vec<Carton>>

Get cartons for pack task

fn get_carton_items(&self, carton_id: Uuid) -> Result<Vec<CartonItem>>

Get items in carton

fn mark_label_printed(&self, carton_id: Uuid) -> Result<Carton>

Mark carton label printed

fn cancel_pack(&self, id: Uuid) -> Result<PackTask>

Cancel pack task

fn count_packs(&self, filter: PackTaskFilter) -> Result<u64>

Count packs

fn create_ship(&self, input: CreateShipTask) -> Result<ShipTask>

Create a ship task

fn get_ship(&self, id: Uuid) -> Result<Option<ShipTask>>

Get ship task by ID

fn list_ships(&self, filter: ShipTaskFilter) -> Result<Vec<ShipTask>>

List ship tasks with filter

fn assign_ship(&self, id: Uuid, assigned_to: &str) -> Result<ShipTask>

Assign ship to user

fn print_label(&self, id: Uuid, label_url: &str) -> Result<ShipTask>

Print shipping label

fn complete_ship(&self, input: CompleteShip) -> Result<ShipTask>

Complete shipping

fn cancel_ship(&self, id: Uuid) -> Result<ShipTask>

Cancel ship task

fn count_ships(&self, filter: ShipTaskFilter) -> Result<u64>

Count ships

fn create_picks_for_order( &self, order_id: OrderId, warehouse_id: i32, ) -> Result<Vec<PickTask>>

Create picks for an order

fn is_order_ready_to_pack(&self, order_id: OrderId) -> Result<bool>

Check if order is ready to pack

fn is_order_ready_to_ship(&self, order_id: OrderId) -> Result<bool>

Check if order is ready to ship

fn create_waves_batch( &self, inputs: Vec<CreateWave>, ) -> Result<BatchResult<Wave>>

Create multiple waves

fn get_picks_batch(&self, ids: Vec<Uuid>) -> Result<Vec<PickTask>>

Get multiple picks by ID