Skip to main content

Promotion

Promotion​

@vendure/corepromotion.entity.ts

A Promotion is used to define a set of conditions under which promotions actions (typically discounts) will be applied to an Order.

Each assigned PromotionCondition is checked against the Order, and if they all return true, then each assign PromotionItemAction / PromotionLineAction / PromotionOrderAction / PromotionShippingAction is applied to the Order.

Signature
class Promotion extends AdjustmentSource implements ChannelAware, SoftDeletable, HasCustomFields, Translatable {
    type = AdjustmentType.PROMOTION;
    constructor(input?: DeepPartial<Promotion> & {
            promotionConditions?: Array<PromotionCondition<any>>;
            promotionActions?: Array<PromotionAction<any>>;
        })
    @Column({ type: Date, nullable: true })
    deletedAt: Date | null;
    @Column({ type: Date, nullable: true })
    startsAt: Date | null;
    @Column({ type: Date, nullable: true })
    endsAt: Date | null;
    @Column({ nullable: true })
    couponCode: string;
    @Column({ nullable: true })
    perCustomerUsageLimit: number;
    @Column({ nullable: true })
    usageLimit: number;
    name: LocaleString;
    description: LocaleString;
    @OneToMany(type => PromotionTranslation, translation => translation.base, { eager: true })
    translations: Array<Translation<Promotion>>;
    @Column() enabled: boolean;
    @ManyToMany(type => Channel, channel => channel.promotions)
    @JoinTable()
    channels: Channel[];
    @ManyToMany(type => Order, order => order.promotions)
    orders: Order[];
    @Column(type => CustomPromotionFields)
    customFields: CustomPromotionFields;
    @Column('simple-json') conditions: ConfigurableOperation[];
    @Column('simple-json') actions: ConfigurableOperation[];
    @Column() priorityScore: number;
    apply(ctx: RequestContext, args: ApplyOrderActionArgs | ApplyOrderItemActionArgs | ApplyShippingActionArgs, state?: PromotionState) => Promise<Adjustment | undefined>;
    test(ctx: RequestContext, order: Order) => Promise<PromotionTestResult>;
    activate(ctx: RequestContext, order: Order) => ;
    deactivate(ctx: RequestContext, order: Order) => ;
}

type​

property

constructor​

method
(input?: DeepPartial<Promotion> & { promotionConditions?: Array<PromotionCondition<any>>; promotionActions?: Array<PromotionAction<any>>; }) => Promotion

deletedAt​

property
Date | null

startsAt​

property
Date | null

endsAt​

property
Date | null

couponCode​

property
string

perCustomerUsageLimit​

property
number

usageLimit​

property
number

name​

property
LocaleString

description​

property
LocaleString

translations​

property
Array<Translation<Promotion>>

enabled​

property
boolean

channels​

property
Channel[]

orders​

property
Order[]

customFields​

property
CustomPromotionFields

conditions​

property
ConfigurableOperation[]

actions​

property
ConfigurableOperation[]

priorityScore​

property
number

The PriorityScore is used to determine the sequence in which multiple promotions are tested on a given order. A higher number moves the Promotion towards the end of the sequence.

The score is derived from the sum of the priorityValues of the PromotionConditions and PromotionActions comprising this Promotion.

An example illustrating the need for a priority is this:

Consider 2 Promotions, 1) buy 1 get one free and 2) 10% off when order total is over $50. If Promotion 2 is evaluated prior to Promotion 1, then it can trigger the 10% discount even if the subsequent application of Promotion 1 brings the order total down to way below $50.

apply​

method
(ctx: RequestContext, args: ApplyOrderActionArgs | ApplyOrderItemActionArgs | ApplyShippingActionArgs, state?: PromotionState) => Promise<Adjustment | undefined>

test​

method
(ctx: RequestContext, order: Order) => Promise<PromotionTestResult>

activate​

method
(ctx: RequestContext, order: Order) =>

deactivate​

method
(ctx: RequestContext, order: Order) =>