Struct Promotions 

pub struct Promotions { /* private fields */ }

Promotions and discounts management interface.

Implementations

impl Promotions

pub fn create(&self, input: CreatePromotion) -> Result<Promotion>

Create a new promotion.

Example

use stateset_embedded::{Commerce, CreatePromotion, PromotionType};
use rust_decimal_macros::dec;

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

// Create a percentage off promotion
let promo = commerce.promotions().create(CreatePromotion {
    name: "20% Off Everything".into(),
    promotion_type: PromotionType::PercentageOff,
    percentage_off: Some(dec!(0.20)),
    ..Default::default()
})?;

pub fn get(&self, id: PromotionId) -> Result<Option<Promotion>>

Get a promotion by ID.

pub fn get_by_code(&self, code: &str) -> Result<Option<Promotion>>

Get a promotion by its internal code.

pub fn list(&self, filter: PromotionFilter) -> Result<Vec<Promotion>>

List promotions with optional filtering.

Example

use stateset_embedded::{Commerce, PromotionFilter, PromotionStatus};

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

// List active promotions
let promos = commerce.promotions().list(PromotionFilter {
    is_active: Some(true),
    ..Default::default()
})?;

pub fn update( &self, id: PromotionId, input: UpdatePromotion, ) -> Result<Promotion>

Update a promotion.

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

Delete a promotion.

pub fn activate(&self, id: PromotionId) -> Result<Promotion>

Activate a promotion (make it available for use).

Example

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

let commerce = Commerce::new(":memory:")?;
commerce.promotions().activate(Uuid::new_v4())?;

pub fn deactivate(&self, id: PromotionId) -> Result<Promotion>

Deactivate (pause) a promotion.

pub fn create_coupon(&self, input: CreateCouponCode) -> Result<CouponCode>

Create a coupon code for a promotion.

Example

use stateset_embedded::{Commerce, CreateCouponCode};
use uuid::Uuid;

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

let coupon = commerce.promotions().create_coupon(CreateCouponCode {
    promotion_id: Uuid::new_v4(),
    code: "SUMMER25".into(),
    usage_limit: Some(100),
    ..Default::default()
})?;

pub fn get_coupon(&self, id: Uuid) -> Result<Option<CouponCode>>

Get a coupon by ID.

pub fn get_coupon_by_code(&self, code: &str) -> Result<Option<CouponCode>>

Get a coupon by its code (the code customers enter).

pub fn list_coupons(&self, filter: CouponFilter) -> Result<Vec<CouponCode>>

List coupons with optional filtering.

pub fn validate_coupon(&self, code: &str) -> Result<Option<CouponCode>>

Validate a coupon code (check if it’s valid and can be used).

Example

use stateset_embedded::Commerce;

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

match commerce.promotions().validate_coupon("SUMMER25")? {
    Some(coupon) => println!("Valid coupon for promotion: {:?}", coupon.promotion_id),
    None => println!("Invalid or expired coupon"),
}

pub fn apply( &self, request: ApplyPromotionsRequest, ) -> Result<ApplyPromotionsResult>

Apply promotions to a request (cart or order).

This is the main entry point for promotion calculation. It:

1. Finds all applicable automatic promotions
2. Validates any coupon codes provided
3. Checks all promotion conditions
4. Calculates discounts respecting stacking rules
5. Returns detailed breakdown of applied discounts

Example

use stateset_embedded::{Commerce, ApplyPromotionsRequest, PromotionLineItem};
use rust_decimal_macros::dec;

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

let result = commerce.promotions().apply(ApplyPromotionsRequest {
    subtotal: dec!(150.00),
    shipping_amount: dec!(10.00),
    coupon_codes: vec!["SUMMER25".into()],
    line_items: vec![PromotionLineItem {
        id: "item-1".into(),
        quantity: 2,
        unit_price: dec!(75.00),
        line_total: dec!(150.00),
        ..Default::default()
    }],
    ..Default::default()
})?;

println!("Total discount: ${}", result.total_discount);
println!("Final total: ${}", result.grand_total);

pub fn record_usage( &self, promotion_id: PromotionId, coupon_id: Option<Uuid>, customer_id: Option<CustomerId>, order_id: Option<OrderId>, cart_id: Option<CartId>, discount_amount: Decimal, currency: &str, ) -> Result<PromotionUsage>

Record promotion usage (called after order completion).

This increments usage counts and creates an audit trail.

pub fn get_active(&self) -> Result<Vec<Promotion>>

Get all active promotions.

pub fn is_valid(&self, id: PromotionId) -> Result<bool>

Check if a promotion is currently valid.

pub fn add_condition( &self, promotion_id: PromotionId, condition: CreatePromotionCondition, ) -> Result<Promotion>

Add a condition to an existing promotion.

Trait Implementations

impl Debug for Promotions

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

Formats the value using the given formatter.