Promotions

import { LanguageCode, PromotionCondition } from '@vendure/core';

export const minimumOrderAmount = new PromotionCondition({
  /** A unique identifier for the condition */
  code: 'minimum_order_amount',

  /**
   * A human-readable description. Values defined in the
   * `args` object can be interpolated using the curly-braces syntax.
   */
  description: [
    { languageCode: LanguageCode.en, value: 'If order total is greater than { amount }' },
  ],

  /**
   * Arguments which can be specified when configuring the condition
   * in the Admin UI. The values of these args are then available during
   * the execution of the `check` function.
   */
  args: {
   amount: {
     type: 'int',
     // The optional `ui` object allows you to customize
     // how this arg is rendered in the Admin UI.
     ui: { component: 'currency-form-input' },
   },
    taxInclusive: { type: 'boolean' },
  },

  /**
   * This is the business logic of the condition. It is a function that
   * must resolve to a boolean value indicating whether the condition has
   * been satisfied.
   */
  check(ctx, order, args) {
    if (args.taxInclusive) {
      return order.subTotalWithTax >= args.amount;
    } else {
      return order.subTotal >= args.amount;
    }
  },
});

import { defaultPromotionConditions, VendureConfig } from '@vendure/core';
import { minimumOrderAmount } from './minimum-order-amount';

export const config: VendureConfig = {
  // ...
  promotionOptions: {
    promotionConditions: [
      ...defaultPromotionConditions,
      minimumOrderAmount,
    ],
  }
}

import { LanguageCode, PromotionOrderAction } from '@vendure/core';

export const orderPercentageDiscount = new PromotionOrderAction({
  // See the custom condition example above for explanations
  // of code, description & args fields.
  code: 'order_percentage_discount',
  description: [{ languageCode: LanguageCode.en, value: 'Discount order by { discount }%' }],
  args: {
    discount: {
      type: 'int',
      ui: {
        component: 'number-form-input',
        suffix: '%',
      },
    },
  },

  /**
   * This is the function that defines the actual amount to be discounted.
   * It should return a negative number representing the discount in
   * pennies/cents etc. Rounding to an integer is handled automatically.
   */
  execute(ctx, order, args) {
      return -order.subTotal * (args.discount / 100);
  },
});

import { defaultPromotionActions, VendureConfig } from '@vendure/core';
import { orderPercentageDiscount } from './order-percentage-discount';

export const config: VendureConfig = {
  // ...
  promotionOptions: {
    promotionActions: [
      ...defaultPromotionActions,
      orderPercentageDiscount,
    ],
  }
}

import {
  ID, idsAreEqual, isGraphQlErrorResult, LanguageCode,
  Logger, OrderLine, OrderService, PromotionItemAction, VendurePlugin,
} from '@vendure/core';
import { createHash } from 'crypto';

let orderService: OrderService;
export const freeGiftAction = new PromotionItemAction({
  code: 'free_gift',
  description: [{ languageCode: LanguageCode.en, value: 'Add free gifts to the order' }],
  args: {
    productVariantIds: {
      type: 'ID',
      list: true,
      ui: { component: 'product-selector-form-input' },
      label: [{ languageCode: LanguageCode.en, value: 'Gift product variants' }],
    },
  },
  init(injector) {
    orderService = injector.get(OrderService);
  },
  execute(ctx, orderItem, orderLine, args) {
    // This part is responsible for ensuring the variants marked as 
    // "free gifts" have their price reduced to zero.  
    if (lineContainsIds(args.productVariantIds, orderLine)) {
      const unitPrice = orderLine.productVariant.listPriceIncludesTax
        ? orderLine.unitPriceWithTax
        : orderLine.unitPrice;
      return -unitPrice;
    }
    return 0;
  },
  // The onActivate function is part of the side effect API, and
  // allows us to perform some action whenever a Promotion becomes active
  // due to it's conditions & constraints being satisfied.  
  async onActivate(ctx, order, args, promotion) {
    for (const id of args.productVariantIds) {
      if (
        !order.lines.find(
          (line) =>
            idsAreEqual(line.productVariant.id, id) &&
            line.customFields.freeGiftDescription == null,
        )
      ) {
        // The order does not yet contain this free gift, so add it
        const result = await orderService.addItemToOrder(ctx, order.id, id, 1, {
          freeGiftPromotionId: promotion.id.toString(),
        });
        if (isGraphQlErrorResult(result)) {
          Logger.error(`Free gift action error for variantId "${id}": ${result.message}`);
        }
      }
    }
  },
  // The onDeactivate function is the other part of the side effect API and is called 
  // when an active Promotion becomes no longer active. It should reverse any 
  // side effect performed by the onActivate function.
  async onDeactivate(ctx, order, args, promotion) {
    const linesWithFreeGift = order.lines.filter(
      (line) => line.customFields.freeGiftPromotionId === promotion.id.toString(),
    );
    for (const line of linesWithFreeGift) {
      await orderService.removeItemFromOrder(ctx, order.id, line.id);
    }
  },
});

function lineContainsIds(ids: ID[], line: OrderLine): boolean {
  return !!ids.find((id) => idsAreEqual(id, line.productVariant.id));
}

@VendurePlugin({
  configuration: config => {
    config.promotionOptions.promotionActions.push(freeGiftAction);
    config.customFields.OrderItem.push(
    {
      name: 'freeGiftPromotionId',
      type: 'string',
      public: true,
      readonly: true,
      nullable: true,
    })
  }
})
export class FreeGiftPromotionPlugin {}

export const buy1Get1FreeAction = new PromotionItemAction({
  code: 'buy_1_get_1_free',
  description: [{
    languageCode: LanguageCode.en,
    value: 'Buy 1, get 1 free',
  }],
  args: {},
  conditions: [buyXGetYFreeCondition],
  execute(ctx, orderItem, orderLine, args, state) {
      const freeItemIds = state.buy_x_get_y_free.freeItemIds;
      if (idsContainsItem(freeItemIds, orderItem)) {
          const unitPrice = ctx.channel.pricesIncludeTax ? orderLine.unitPriceWithTax : orderLine.unitPrice;
          return -unitPrice;
      }
      return 0;
  },
});

export const buyXGetYFreeCondition = new PromotionCondition({
  code: 'buy_x_get_y_free',
  description: [{
    languageCode: LanguageCode.en,
    value: 'Buy { amountX } of { variantIdsX } products, get { amountY } of { variantIdsY } products free',
  }],
  args: {
    // omitted for brevity
  },
  async check(ctx, order, args) {
    // logic omitted for brevity
    if (freeItemIds.length === 0) {
      return false;
    }  
    return { freeItemIds };
  },
});