skid
commented
2 years ago In our case (online supermarket), this is a very common promotion. Here's the ideal implementation:
- The item is automatically added - this is A MUST because customers get confused and ask "where's my gift"
- The item is automatically removed if the condition is no longer met. Otherwise customers don't read their final statement and sometimes pay the full order then ask for refunds.
- Support for BOGO (buy one, get one free) promotions with auto add / remove. This is trickier than it sounds and maybe even impossible to do. The way we do this now is that we list the "free" items as a separate SKU which as a custom field "hidden" flag, which prevents it from being purchased regularly.
Here's how we solve the auto add / remove:
@VendurePlugin({
imports: [PluginCommonModule],
entities: [],
providers: [PromoService],
})
export class PromoPlugin implements OnApplicationBootstrap {
constructor(private orderService: OrderService, private promoService: PromoService) {}
async onApplicationBootstrap() {
const addItemToOrder = this.orderService.addItemToOrder;
const adjustOrderLine = this.orderService.adjustOrderLine;
const removeItemFromOrder = this.orderService.removeItemFromOrder;
// TODO: Prevent adding of hidden items
this.orderService.addItemToOrder = async (...args: Parameters<typeof addItemToOrder>) => {
let order = await addItemToOrder.apply(this.orderService, args);
if (order instanceof Order) {
order = await this.promoService.autoAddPromoItems(args[0], addItemToOrder, adjustOrderLine, order);
}
if (order instanceof Order) {
order.lines = order.lines.sort((a, b) => +a.createdAt - +b.createdAt);
}
return order;
};
// TODO: Prevent adding of hidden items
this.orderService.adjustOrderLine = async (...args: Parameters<typeof adjustOrderLine>) => {
let order = await adjustOrderLine.apply(this.orderService, args);
if (order instanceof Order) {
order = await this.promoService.autoAddPromoItems(args[0], addItemToOrder, adjustOrderLine, order);
}
if (order instanceof Order) {
order.lines = order.lines.sort((a, b) => +a.createdAt - +b.createdAt);
}
return order;
};
this.orderService.removeItemFromOrder = async (...args: Parameters<typeof removeItemFromOrder>) => {
let order = await removeItemFromOrder.apply(this.orderService, args);
if (order instanceof Order) {
order = await this.promoService.autoAddPromoItems(args[0], addItemToOrder, adjustOrderLine, order);
}
if (order instanceof Order) {
order.lines = order.lines.sort((a, b) => +a.createdAt - +b.createdAt);
}
return order;
};
}
}Here's the autoAdd method. As you can see it depends directly on having specific conditions and actions active.
@Injectable()
export class PromoService {
constructor(
private orderService: OrderService,
private promotionService: PromotionService,
private conn: TransactionalConnection,
) {}
async autoAddPromoItems(
ctx: RequestContext,
addItemToOrderFn: typeof this.orderService.addItemToOrder,
adjustOrderLineFn: typeof this.orderService.adjustOrderLine,
order: Order,
) {
const { items: promotions } = await this.promotionService.findAll(ctx, {
filter: { enabled: { eq: true } },
sort: { priorityScore: 'ASC' },
});
// Tracks which variantIds should be added or removed
const updates: { [key: string]: number } = {};
for (const promotion of promotions) {
const condition = promotion.conditions.find(c => c.code === 'buy_x_of_y');
const action = promotion.actions.find(a => a.code === 'get_x_free');
if (!condition || !action) {
// Auto-adding and removing only works for BOGO-type promotions
continue;
}
const { amount, variantIds, autoAdd } = getXFreeArgParser(action.args);
if (!autoAdd) {
// No need to adjust quantities without autoadd
continue;
}
const state = await promotion.test(ctx, order);
if (!state || typeof state !== 'object') {
continue;
}
const appliedDiscounts = state.buy_x_of_y.discounts as number;
const purchasedVaiants = state.buy_x_of_y.variants as { [key: string]: number };
const totalQuantity = appliedDiscounts * amount;
for (const variantId of variantIds) {
const line = order.lines.find(line => line.productVariant.id === variantId);
// For BOGO discounts (buy 1 milk, get 1 milk free) we do not auto add
// It causes a weird interaction where adding 1 beer adds 2.
// We solve this by making another SKU for the same product and make it hidden.
if ((totalQuantity === 0 && !line) || purchasedVaiants[variantId]) {
continue;
}
updates[variantId] = (updates[variantId] || 0) + totalQuantity;
}
}
const variantIds = Object.keys(updates);
const hidden =
variantIds.length === 0
? []
: await this.conn
.getRepository(ctx, Product)
.createQueryBuilder('p')
.select('p.customFieldsHidden', 'h')
.addSelect('pv.id', 'id')
.innerJoin(ProductVariant, 'pv', 'pv.productId = p.id AND pv.id IN (:...variantIds)', { variantIds })
.getRawMany();
for (const variantId of variantIds) {
const line = order.lines.find(line => line.productVariant.id === variantId);
const newQuantity = updates[variantId];
const delta = newQuantity - (line?.quantity || 0);
const autoRemove = !!hidden.find(l => l.id === variantId);
let result: any;
if (line && (delta > 0 || (autoRemove && delta < 0))) {
result = await adjustOrderLineFn.call(this.orderService, ctx, order.id, line.id, newQuantity);
} else if (!line && delta > 0) {
result = await addItemToOrderFn.call(this.orderService, ctx, order.id, variantId, newQuantity);
}
if (result instanceof Order) {
order = result; // Small optimization to prvent another fetch
}
}
return await this.orderService.applyPriceAdjustments(ctx, order);
}
}And here's the implementation of some promotion actions and conditions:
import compact from 'lodash/compact';
import { PromotionCondition, LanguageCode, FacetValueChecker, TransactionalConnection, PromotionItemAction } from '@vendure/core';
let facetValueChecker: FacetValueChecker;
export const buyXofY = new PromotionCondition({
code: 'buy_x_of_y',
description: [
{
languageCode: LanguageCode.en,
value: 'Buy items/value of variants/facets',
},
],
args: {
amount: {
type: 'int',
defaultValue: 0,
required: false,
label: [{ languageCode: LanguageCode.en, value: 'At least this many items (0 to ignore)' }],
},
value: {
type: 'int',
defaultValue: 0,
required: false,
ui: { component: 'currency-form-input' },
label: [{ languageCode: LanguageCode.en, value: 'At least this much in value (0 to ignore)' }],
},
variantIds: {
type: 'ID',
list: true,
required: false,
ui: { component: 'product-selector-form-input' },
label: [{ languageCode: LanguageCode.en, value: 'Specific variants' }],
},
facetIds: {
type: 'ID',
list: true,
required: false,
ui: { component: 'facet-value-form-input' },
label: [{ languageCode: LanguageCode.en, value: 'Facet values' }],
},
},
init(injector) {
facetValueChecker = new FacetValueChecker(injector.get(TransactionalConnection));
},
async check(ctx, order, args) {
if (!order || !order.lines) {
return false;
}
// All order lines that contain
const lines = compact(
await Promise.all(
order.lines.map(async line => {
const hasVariant = args.variantIds.length > 0 && args.variantIds.includes(line.productVariant.id);
const hasFacets = args.facetIds.length > 0 && (await facetValueChecker.hasFacetValues(line, args.facetIds));
return (hasVariant || hasFacets) && line;
}),
),
);
const { quantity, value } = lines.reduce(
(acc, line) => {
acc.value += ctx.channel.pricesIncludeTax ? line.linePriceWithTax : line.linePrice;
acc.quantity += line.quantity;
return acc;
},
{ quantity: 0, value: 0 },
);
const discountsToApplyBasedOnQuantity = args.amount && Math.floor(quantity / args.amount);
const discountsToApplyBasedOnValue = args.value && Math.floor(value / args.value);
return {
triggerQuantity: args.amount || 0,
variants: Object.fromEntries(lines.map(line => [line.productVariant.id, line.quantity])),
discounts: Math.max(discountsToApplyBasedOnQuantity, discountsToApplyBasedOnValue),
};
},
});
export const getXFree = new PromotionItemAction({
code: 'get_x_free',
description: [
{
languageCode: LanguageCode.en,
value: 'Get a number of selected variants for free',
},
],
args: {
amount: {
type: 'int',
defaultValue: 1,
label: [{ languageCode: LanguageCode.en, value: 'Free amount of EACH selected variant' }],
},
autoAdd: {
type: 'boolean',
defaultValue: false,
label: [{ languageCode: LanguageCode.en, value: 'Auto-add to cart' }],
},
autoRemove: {
type: 'boolean',
defaultValue: false,
label: [{ languageCode: LanguageCode.en, value: 'No regular purchase (only select for hidden items)' }],
},
variantIds: {
type: 'ID',
list: true,
ui: { component: 'product-selector-form-input' },
label: [{ languageCode: LanguageCode.en, value: 'Product Variants' }],
},
},
conditions: [buyXofY],
execute(_ctx, item, line, args, state) {
if (!state || !line) {
return 0;
}
const { discounts, variants, triggerQuantity } = state.buy_x_of_y;
let totalDiscountedItems = discounts * args.amount;
if (totalDiscountedItems > 0 && args.variantIds.includes(line.productVariant.id)) {
const itemIndex = line.items.findIndex(i => i.id === item.id);
// Number of already purchased items OF THE SAME variant that is discounted
// This is important for BOGO discount (buy 1 milk, get 1 milk free)
// We don't want to Apply a "GET 1 FREE" discount to the only item in the cart
const purchasedVariants = variants[line.productVariant.id] || 0;
if (purchasedVariants && triggerQuantity) {
// The number of items including the free ones. Eg for "Buy 2 Get 1 free" it's 3.
// This doesn't work with "Buy 3 Get 2 free" entirely, because you need at least 5 items
// but you really should get a discount on "Buy 3 get 1 free".
const discountPackSize = triggerQuantity + args.amount;
totalDiscountedItems = 0;
let quant = line.quantity;
while (true) {
if (quant >= discountPackSize) {
quant -= discountPackSize;
totalDiscountedItems += args.amount;
continue;
}
if (quant > triggerQuantity) {
const diff = quant - triggerQuantity;
quant -= diff;
totalDiscountedItems += diff;
}
break;
}
}
// This method gets called once per OrderItem
// This is how we decide if we've discounted enough items
if (itemIndex < totalDiscountedItems) {
return -item.listPrice;
}
}
return 0;
},
});
michaelbromley
tianyingchun
Is your feature request related to a problem? Please describe. It is quite common to have a promotion that entitles the customer to a free gift. Currently we are able to support making an item free using an PromotionItemAction, but the customer still has to manually add it to the order.
The ideal flow in this case however is that once the condition(s) pass, then Vendure can automatically add the free gift to the order.
To work around this, I have suggested in the past the creation of a custom
addItemToOrdermutation which contains logic to achieve this. However, it would be better to support this common use-case natively.Describe the solution you'd like Perhaps a new kind of PromotionAction which is dedicated to adding items the order. The exact mechanism of how this would actually work is not yet clear.
Currently all promotion actions are processed as part of the
OrderCalculator.applyPriceAdjustments()method. I would not suggest using this same method to add a new item, since this is mixing concerns and also you get this recursive issue where adding a new item during the price calculation can then potentially trigger new promotions, potentially changing prices of those already added etc.It would probably work in a separate stage, so:
Open questions