@unchainedshop/core-orders 1.1.3

package/src/module/configureOrdersModule-transformations.ts

@@ -0,0 +1,145 @@
+import { Collection, FindOptions, Query } from '@unchainedshop/types/common';
+import { Order, OrderTransformations } from '@unchainedshop/types/orders';
+import { OrderPricingSheet } from '../director/OrderPricingSheet';
+
+export const configureOrderModuleTransformations = ({
+  Orders,
+}: {
+  Orders: Collection<Order>;
+}): OrderTransformations => {
+  return {
+    discounted: async (order, orderDiscount, requestContext) => {
+      const { modules } = requestContext;
+
+      // Delivery discounts
+      const orderDelivery = await modules.orders.deliveries.findDelivery({
+        orderDeliveryId: order.deliveryId,
+      });
+      const orderDeliveryDiscounts = modules.orders.deliveries.discounts(
+        orderDelivery,
+        { order, orderDiscount },
+        requestContext,
+      );
+
+      // Payment discounts
+      const orderPayment = await modules.orders.payments.findOrderPayment({
+        orderPaymentId: order.paymentId,
+      });
+      const orderPaymentDiscounts = modules.orders.payments.discounts(
+        orderPayment,
+        { order, orderDiscount },
+        requestContext,
+      );
+
+      // Position discounts
+      const orderPositions = await modules.orders.positions.findOrderPositions({
+        orderId: order._id,
+      });
+      const orderPositionDiscounts = orderPositions.flatMap((orderPosition) =>
+        modules.orders.positions.discounts(orderPosition, { order, orderDiscount }, requestContext),
+      );
+
+      // order discounts
+      const pricingSheet = OrderPricingSheet({
+        calculation: order.calculation,
+        currency: order.currency,
+      });
+
+      const orderDiscounts = pricingSheet
+        .discountPrices(orderDiscount._id)
+        .map((discount) => ({ order, ...discount }));
+
+      // All discounts
+      const discounted = [
+        ...orderPaymentDiscounts,
+        ...orderDeliveryDiscounts,
+        ...orderPositionDiscounts,
+        ...orderDiscounts,
+      ].filter(Boolean);
+
+      return discounted;
+    },
+
+    discountTotal: async (order, orderDiscount, requestContext) => {
+      const { modules } = requestContext;
+      const orderDiscountId = orderDiscount._id;
+
+      // Delivery discounts
+      const orderDelivery = await modules.orders.deliveries.findDelivery({
+        orderDeliveryId: order.deliveryId,
+      });
+      const orderDeliveryDiscountSum =
+        orderDelivery &&
+        modules.orders.deliveries
+          .pricingSheet(orderDelivery, order.currency, requestContext)
+          .discountSum(orderDiscountId);
+
+      // Payment discounts
+      const orderPayment = await modules.orders.payments.findOrderPayment({
+        orderPaymentId: order.paymentId,
+      });
+      const orderPaymentDiscountSum =
+        orderPayment &&
+        modules.orders.payments
+          .pricingSheet(orderPayment, order.currency, requestContext)
+          .discountSum(orderDiscountId);
+
+      // Position discounts
+      const orderPositions = await modules.orders.positions.findOrderPositions({
+        orderId: order._id,
+      });
+      const orderPositionDiscounts = orderPositions.map((orderPosition) =>
+        modules.orders.positions
+          .pricingSheet(orderPosition, order.currency, requestContext)
+          .discountSum(orderDiscountId),
+      );
+
+      // order discounts
+      const orderDiscountSum = OrderPricingSheet({
+        calculation: order.calculation,
+        currency: order.currency,
+      }).discountSum(orderDiscountId);
+
+      const prices = [
+        orderDeliveryDiscountSum,
+        orderPaymentDiscountSum,
+        ...orderPositionDiscounts,
+        orderDiscountSum,
+      ];
+      const amount = prices.reduce((oldValue, price) => oldValue + (price || 0), 0);
+      return {
+        amount,
+        currency: order.currency,
+      };
+    },
+
+    isCart: (order) => {
+      return order.status === null;
+    },
+    cart: async ({ orderNumber, countryContext }, user) => {
+      const selector: Query = {
+        countryCode: countryContext || user.lastLogin.countryContext,
+        status: { $eq: null },
+        userId: user._id,
+      };
+
+      if (orderNumber) {
+        selector.orderNumber = orderNumber;
+      }
+
+      const options: FindOptions = {
+        sort: {
+          updated: -1,
+        },
+      };
+      return Orders.findOne(selector, options);
+    },
+
+    pricingSheet: (order) => {
+      return OrderPricingSheet({
+        calculation: order.calculation,
+        currency: order.currency,
+      });
+    },
+  };
+};

package/src/module/configureOrdersModule.ts

@@ -0,0 +1,359 @@
+import { Context } from '@unchainedshop/types/api';
+import { ModuleInput, Update } from '@unchainedshop/types/common';
+import { Order, OrderStatus, OrdersModule, OrdersSettingsOptions } from '@unchainedshop/types/orders';
+import { OrderDelivery } from '@unchainedshop/types/orders.deliveries';
+import { OrderPayment } from '@unchainedshop/types/orders.payments';
+import { OrderPosition } from '@unchainedshop/types/orders.positions';
+import { log } from '@unchainedshop/logger';
+import { generateDbFilterById } from '@unchainedshop/utils';
+import { OrderDeliveriesCollection } from '../db/OrderDeliveriesCollection';
+import { OrderDiscountsCollection } from '../db/OrderDiscountsCollection';
+import { OrderDiscountTrigger } from '../db/OrderDiscountTrigger';
+import { OrderPaymentsCollection } from '../db/OrderPaymentsCollection';
+import { OrderPositionsCollection } from '../db/OrderPositionsCollection';
+import { OrdersCollection } from '../db/OrdersCollection';
+import { OrderDiscountDirector } from '../director/OrderDiscountDirector';
+import { OrderPricingDirector } from '../director/OrderPricingDirector';
+import { ordersSettings } from '../orders-settings';
+import { configureOrderDeliveriesModule } from './configureOrderDeliveriesModule';
+import { configureOrderDiscountsModule } from './configureOrderDiscountsModule';
+import { configureOrderPaymentsModule } from './configureOrderPaymentsModule';
+import { configureOrderPositionsModule } from './configureOrderPositionsModule';
+import { configureOrderModuleMutations } from './configureOrdersModule-mutations';
+import { configureOrderModuleProcessing } from './configureOrdersModule-processing';
+import { configureOrdersModuleQueries } from './configureOrdersModule-queries';
+import { configureOrderModuleTransformations } from './configureOrdersModule-transformations';
+
+export const configureOrdersModule = async ({
+  db,
+  options: orderOptions = {},
+}: ModuleInput<OrdersSettingsOptions>): Promise<OrdersModule> => {
+  ordersSettings.configureSettings(orderOptions);
+
+  const Orders = await OrdersCollection(db);
+  const OrderDeliveries = await OrderDeliveriesCollection(db);
+  const OrderDiscounts = await OrderDiscountsCollection(db);
+  const OrderPayments = await OrderPaymentsCollection(db);
+  const OrderPositions = await OrderPositionsCollection(db);
+
+  const findOrderPositions = async (order: Order) =>
+    OrderPositions.find(
+      {
+        orderId: order._id,
+        quantity: { $gt: 0 },
+      },
+      {},
+    ).toArray();
+
+  const findOrderDelivery = async (order: Order) =>
+    OrderDeliveries.findOne(generateDbFilterById(order.deliveryId), {});
+
+  const findOrderPayment = async (order: Order) =>
+    OrderPayments.findOne(generateDbFilterById(order.paymentId), {});
+
+  const findNewOrderNumber = async (order: Order, index = 0) => {
+    const newHashID = ordersSettings.orderNumberHashFn(order, index);
+    if ((await Orders.countDocuments({ orderNumber: newHashID }, { limit: 1 })) === 0) {
+      return newHashID;
+    }
+    return findNewOrderNumber(order, index + 1);
+  };
+
+  const updateStatus: OrdersModule['updateStatus'] = async (
+    orderId,
+    { status, info },
+    requestContext,
+  ) => {
+    const selector = generateDbFilterById(orderId);
+    const order = await Orders.findOne(selector, {});
+
+    if (order.status === status) return order;
+
+    const date = new Date();
+    const $set: Partial<Order> = {
+      status,
+      updated: new Date(),
+      updatedBy: requestContext.userId,
+    };
+
+    switch (status) {
+      // explicitly use fallthrough here!
+      case OrderStatus.FULLFILLED:
+        if (!order.fullfilled) {
+          $set.fullfilled = date;
+        }
+      case OrderStatus.REJECTED: // eslint-disable-line no-fallthrough
+        if (!order.rejected) {
+          $set.rejected = date;
+        }
+      case OrderStatus.CONFIRMED: // eslint-disable-line no-fallthrough
+        if (!order.confirmed) {
+          $set.confirmed = date;
+        }
+      case OrderStatus.PENDING: // eslint-disable-line no-fallthrough
+        if (!order.ordered) {
+          $set.ordered = date;
+        }
+        if (!order.orderNumber) {
+          // Order Numbers can be set by the user
+          $set.orderNumber = await findNewOrderNumber(order);
+        }
+        break;
+      default:
+        break;
+    }
+
+    const modifier: Update<Order> = {
+      $set,
+      $push: {
+        log: {
+          date,
+          status,
+          info,
+        },
+      },
+    };
+
+    log(`New Status: ${status}`, { orderId });
+
+    await Orders.updateOne(selector, modifier);
+
+    return Orders.findOne(selector, {});
+  };
+
+  const updateDiscounts = async (order: Order, requestContext: Context) => {
+    const { modules } = requestContext;
+
+    // 1. go through existing order-discounts and check if discount still valid,
+    // those who are not valid anymore should get removed
+    const discounts = await modules.orders.discounts.findOrderDiscounts({
+      orderId: order._id,
+    });
+
+    await Promise.all(
+      discounts.map(async (discount) => {
+        const isValid = await modules.orders.discounts.isValid(discount, requestContext);
+
+        if (!isValid) {
+          await modules.orders.discounts.delete(discount._id, requestContext);
+        }
+      }),
+    );
+
+    // 2. run auto-system discount
+    const cleanedDiscounts = await modules.orders.discounts.findOrderDiscounts({
+      orderId: order._id,
+    });
+
+    const currentDiscountKeys = cleanedDiscounts.map(({ discountKey }) => discountKey);
+
+    const director = await OrderDiscountDirector.actions({ order }, requestContext);
+    const systemDiscounts = await director.findSystemDiscounts();
+
+    await Promise.all(
+      systemDiscounts
+        .filter((key) => currentDiscountKeys.indexOf(key) === -1)
+        .map((discountKey) =>
+          modules.orders.discounts.create(
+            {
+              orderId: order._id,
+              discountKey,
+              trigger: OrderDiscountTrigger.SYSTEM,
+            },
+            requestContext.userId,
+          ),
+        ),
+    );
+  };
+
+  const initProviders = async (order: Order, requestContext: Context) => {
+    const { modules } = requestContext;
+
+    let updatedOrder = order;
+
+    // Init delivery provider
+    const supportedDeliveryProviders = await modules.delivery.findSupported(
+      { order: updatedOrder },
+      requestContext,
+    );
+
+    const orderDelivery = await modules.orders.deliveries.findDelivery({
+      orderDeliveryId: updatedOrder.deliveryId,
+    });
+    const deliveryProviderId = orderDelivery?.deliveryProviderId;
+
+    const isAlreadyInitializedWithSupportedDeliveryProvider = supportedDeliveryProviders?.some(
+      (provider) => {
+        return provider._id === deliveryProviderId;
+      },
+    );
+
+    if (supportedDeliveryProviders?.length > 0 && !isAlreadyInitializedWithSupportedDeliveryProvider) {
+      const defaultOrderDeliveryProvider = await modules.delivery.determineDefault(
+        supportedDeliveryProviders,
+        { order: updatedOrder },
+        requestContext,
+      );
+      if (defaultOrderDeliveryProvider) {
+        updatedOrder = await modules.orders.setDeliveryProvider(
+          updatedOrder._id,
+          defaultOrderDeliveryProvider._id,
+          requestContext,
+        );
+      }
+    }
+
+    // Init payment provider
+    const supportedPaymentProviders = await modules.payment.paymentProviders.findSupported(
+      { order: updatedOrder },
+      requestContext,
+    );
+
+    const orderPayment = await modules.orders.payments.findOrderPayment({
+      orderPaymentId: updatedOrder.paymentId,
+    });
+    const paymentProviderId = orderPayment?.paymentProviderId;
+
+    const isAlreadyInitializedWithSupportedPaymentProvider = supportedPaymentProviders?.some(
+      (provider) => {
+        return provider._id === paymentProviderId;
+      },
+    );
+
+    if (supportedPaymentProviders?.length > 0 && !isAlreadyInitializedWithSupportedPaymentProvider) {
+      const paymentCredentials = await modules.payment.paymentCredentials.findPaymentCredentials(
+        { userId: updatedOrder.userId, isPreferred: true },
+        {
+          sort: {
+            created: -1,
+          },
+        },
+      );
+
+      const defaultOrderPaymentProvider = await modules.payment.paymentProviders.determineDefault(
+        supportedPaymentProviders,
+        { order: updatedOrder, paymentCredentials },
+        requestContext,
+      );
+
+      if (defaultOrderPaymentProvider) {
+        updatedOrder = await modules.orders.setPaymentProvider(
+          updatedOrder._id,
+          defaultOrderPaymentProvider._id,
+          requestContext,
+        );
+      }
+    }
+    return updatedOrder;
+  };
+
+  const updateCalculation: OrdersModule['updateCalculation'] = async (orderId, requestContext) => {
+    const { modules } = requestContext;
+
+    const selector = generateDbFilterById(orderId);
+    let order = (await Orders.findOne(selector, {})) as Order;
+
+    // Don't recalculate orders, only carts
+    if (order.status !== null) return order;
+
+    await updateDiscounts(order, requestContext);
+
+    order = await initProviders(order, requestContext);
+
+    let orderPositions = (await findOrderPositions(order)) as OrderPosition[];
+    orderPositions = await Promise.all(
+      orderPositions.map((orderPosition) =>
+        modules.orders.positions.updateCalculation(orderPosition, requestContext),
+      ),
+    );
+
+    let orderDelivery = (await findOrderDelivery(order)) as OrderDelivery;
+    if (orderDelivery) {
+      orderDelivery = await modules.orders.deliveries.updateCalculation(orderDelivery, requestContext);
+    }
+    let orderPayment = (await findOrderPayment(order)) as OrderPayment;
+    if (orderPayment) {
+      orderPayment = await modules.orders.payments.updateCalculation(orderPayment, requestContext);
+    }
+
+    orderPositions = await Promise.all(
+      orderPositions.map((orderPosition) =>
+        modules.orders.positions.updateScheduling(
+          { order, orderDelivery, orderPosition },
+          requestContext,
+        ),
+      ),
+    );
+
+    const pricing = await OrderPricingDirector.actions(
+      { order, orderPositions, orderDelivery, orderPayment },
+      requestContext,
+    );
+
+    const calculation = await pricing.calculate();
+
+    await Orders.updateOne(selector, {
+      $set: {
+        calculation,
+        updated: new Date(),
+        updatedBy: requestContext.userId,
+      },
+    });
+
+    return Orders.findOne(selector, {});
+  };
+
+  const orderQueries = configureOrdersModuleQueries({ Orders });
+  const orderTransformations = configureOrderModuleTransformations({
+    Orders,
+  });
+  const orderProcessing = configureOrderModuleProcessing({
+    Orders,
+    OrderDeliveries,
+    OrderPayments,
+    OrderPositions,
+    updateCalculation,
+    updateStatus,
+  });
+  const orderMutations = configureOrderModuleMutations({
+    Orders,
+    OrderDeliveries,
+    OrderPayments,
+    initProviders,
+    updateCalculation,
+    updateStatus,
+  });
+
+  const orderDiscountsModule = configureOrderDiscountsModule({
+    OrderDiscounts,
+    updateCalculation,
+  });
+
+  const orderPositionsModule = configureOrderPositionsModule({
+    OrderPositions,
+    updateCalculation,
+  });
+
+  const orderPaymentsModule = configureOrderPaymentsModule({
+    OrderPayments,
+    updateCalculation,
+  });
+
+  const orderDeliveriesModule = configureOrderDeliveriesModule({
+    OrderDeliveries,
+    updateCalculation,
+  });
+
+  return {
+    ...orderQueries,
+    ...orderTransformations,
+    ...orderProcessing,
+    ...orderMutations,
+
+    // Subentities
+    deliveries: orderDeliveriesModule,
+    discounts: orderDiscountsModule,
+    positions: orderPositionsModule,
+    payments: orderPaymentsModule,
+  };
+};

package/src/orders-index.ts

@@ -0,0 +1,15 @@
+export { configureOrdersModule } from './module/configureOrdersModule';
+export { orderServices } from './service/orderServices';
+
+export { OrderStatus } from '@unchainedshop/types/orders';
+export { OrderDeliveryStatus } from '@unchainedshop/types/orders.deliveries';
+export { OrderPaymentStatus } from '@unchainedshop/types/orders.payments';
+
+export { OrderDiscountAdapter } from './director/OrderDiscountAdapter';
+export { OrderDiscountDirector } from './director/OrderDiscountDirector';
+
+export { OrderPricingAdapter } from './director/OrderPricingAdapter';
+export { OrderPricingDirector } from './director/OrderPricingDirector';
+export { OrderPricingSheet } from './director/OrderPricingSheet';
+
+export { ordersSettings } from './orders-settings';

package/src/orders-settings.ts

@@ -0,0 +1,23 @@
+import { generateRandomHash } from '@unchainedshop/utils';
+
+export const defaultValidateOrderPosition = ({ product }, { modules }) => {
+  if (!modules.products.isActive(product)) {
+    throw new Error('This product is inactive');
+  }
+};
+
+export const ordersSettings = {
+  ensureUserHasCart: null,
+  orderNumberHashFn: null,
+  validateOrderPosition: null,
+
+  configureSettings({
+    ensureUserHasCart = false,
+    orderNumberHashFn = generateRandomHash,
+    validateOrderPosition = defaultValidateOrderPosition,
+  } = {}) {
+    this.ensureUserHasCart = ensureUserHasCart;
+    this.orderNumberHashFn = orderNumberHashFn;
+    this.validateOrderPosition = validateOrderPosition;
+  },
+};

package/src/service/createUserCartService.ts

@@ -0,0 +1,38 @@
+import { CreateUserCartService } from '@unchainedshop/types/orders';
+
+export const createUserCartService: CreateUserCartService = async (
+  { user, orderNumber, countryCode },
+  requestContext,
+) => {
+  const { countryContext, modules, services } = requestContext;
+
+  const normalizedCountryCode = countryCode || countryContext;
+
+  const currency = await services.countries.resolveDefaultCurrencyCode(
+    {
+      isoCode: normalizedCountryCode,
+    },
+    requestContext,
+  );
+
+  const order = await modules.orders.create(
+    {
+      orderNumber,
+      currency,
+      countryCode: normalizedCountryCode,
+      billingAddress: user.lastBillingAddress || user.profile?.address,
+      contact:
+        user.lastContact ||
+        (!user.guest
+          ? {
+              telNumber: user.profile?.phoneMobile,
+              emailAddress: modules.users.primaryEmail(user)?.address,
+            }
+          : {}),
+    },
+    user._id,
+  );
+
+  await modules.orders.initProviders(order, requestContext);
+  return order;
+};

package/src/service/migrateOrderCartService.ts

@@ -0,0 +1,22 @@
+import { MigrateOrderCartsService } from '@unchainedshop/types/orders';
+
+export const migrateOrderCartsService: MigrateOrderCartsService = async (
+  { fromUser, toUser, shouldMerge },
+  requestContext,
+) => {
+  const fromCart = await requestContext.modules.orders.cart(
+    { countryContext: requestContext.countryContext },
+    fromUser,
+  );
+  const toCart = await requestContext.modules.orders.cart(
+    { countryContext: requestContext.countryContext },
+    toUser,
+  );
+
+  if (!fromCart) {
+    // No cart, don't copy
+    return toCart;
+  }
+
+  return requestContext.modules.orders.migrateCart({ fromCart, shouldMerge, toCart }, requestContext);
+};

package/src/service/orderServices.ts

@@ -0,0 +1,8 @@
+import { OrderServices } from '@unchainedshop/types/orders';
+import { migrateOrderCartsService } from './migrateOrderCartService';
+import { createUserCartService } from './createUserCartService';
+
+export const orderServices: OrderServices = {
+  migrateOrderCarts: migrateOrderCartsService,
+  createUserCart: createUserCartService,
+};

package/tests/orders-index.test.ts

@@ -0,0 +1,50 @@
+import { assert } from 'chai';
+import { initDb } from 'meteor/unchained:mongodb';
+import { configureOrdersModule } from 'meteor/unchained:core-orders';
+import { OrdersModule } from '@unchainedshop/types/orders';
+
+describe('Test exports', () => {
+  let module: OrdersModule;
+
+  before(async () => {
+    const db = await initDb();
+    module = await configureOrdersModule({ db }).catch((error) => {
+      console.error(error);
+
+      throw error;
+    });
+  });
+
+  it('Insert order', async () => {
+    let order = await module.create(
+      {
+        billingAddress: {
+          lastName: 'Mustermann',
+          firstName: 'Max',
+          addressLine: 'Teststreet 11',
+          city: 'Zürich',
+          postalCode: '8009',
+          company: 'Unchained Commerce',
+          countryCode: 'CH',
+        },
+        orderNumber: 'Nr-1234123',
+        currency: 'CHF',
+        countryCode: 'CH',
+      },
+      'Test-User-1'
+    );
+
+    assert.ok(order);
+    const orderId = order._id;
+    order = await module.findOrder({ orderId });
+
+    assert.ok(order);
+
+    const deletedCount = await module
+      .delete(orderId, 'Test-User-1')
+      .catch((error) => {
+        return 0;
+      });
+    assert.equal(deletedCount, 1);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["esnext"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,
+    "outDir": "lib",
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "types": ["node"],
+    "baseUrl": ".", // This must be specified if "paths" is.
+    "paths": {
+      "meteor/unchained:*": ["node_modules/@unchainedshop/types/index.d.ts"]
+    }
+  },
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.build.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node", "mocha"]
+  },
+  "include": ["src", "tests", "plugins"]
+}