@unchainedshop/core-orders 1.1.3

package/src/module/configureOrderPositionsModule.ts

@@ -0,0 +1,329 @@
+import { Collection, Filter, ModuleMutations, Query } from '@unchainedshop/types/common';
+import { OrdersModule } from '@unchainedshop/types/orders';
+import { OrderPosition, OrderPositionsModule } from '@unchainedshop/types/orders.positions';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { log } from '@unchainedshop/logger';
+import { generateDbFilterById, generateDbMutations, generateDbObjectId } from '@unchainedshop/utils';
+import { OrderPositionsSchema } from '../db/OrderPositionsSchema';
+import { ordersSettings } from '../orders-settings';
+
+const ORDER_POSITION_EVENTS: string[] = [
+  'ORDER_UPDATE_CART_ITEM',
+  'ORDER_REMOVE_CART_ITEM',
+  'ORDER_EMPTY_CART',
+  'ORDER_ADD_PRODUCT',
+];
+
+const buildFindByIdSelector = (orderPositionId: string, orderId?: string) =>
+  generateDbFilterById(orderPositionId, orderId ? { orderId } : undefined) as Filter<OrderPosition>;
+
+export const configureOrderPositionsModule = ({
+  OrderPositions,
+  updateCalculation,
+}: {
+  OrderPositions: Collection<OrderPosition>;
+  updateCalculation: OrdersModule['updateCalculation'];
+}): OrderPositionsModule => {
+  registerEvents(ORDER_POSITION_EVENTS);
+
+  const mutations = generateDbMutations<OrderPosition>(OrderPositions, OrderPositionsSchema, {
+    permanentlyDeleteByDefault: true,
+    hasCreateOnly: false,
+  }) as ModuleMutations<OrderPosition>;
+
+  return {
+    // Queries
+    findOrderPosition: async ({ itemId }, options) => {
+      return OrderPositions.findOne(buildFindByIdSelector(itemId), options);
+    },
+
+    findOrderPositions: async ({ orderId }) => {
+      const positions = OrderPositions.find({ orderId, quantity: { $gt: 0 } });
+      return positions.toArray();
+    },
+
+    // Transformations
+    discounts: (orderPosition, { order, orderDiscount }, requestContext) => {
+      const pricingSheet = requestContext.modules.orders.positions.pricingSheet(
+        orderPosition,
+        order.currency,
+        requestContext,
+      );
+
+      return pricingSheet.discountPrices(orderDiscount._id).map((discount) => ({
+        item: orderPosition,
+        ...discount,
+      }));
+    },
+
+    pricingSheet: (orderPosition, currency, { modules }) => {
+      return modules.products.pricingSheet({
+        calculation: orderPosition.calculation,
+        currency,
+        quantity: orderPosition.quantity,
+      });
+    },
+
+    // Mutations
+
+    create: async (
+      { configuration, context, quantity, quotationId },
+      { order, product, originalProduct },
+      requestContext,
+    ) => {
+      const orderId = order._id;
+      const productId = product._id;
+      const originalProductId = originalProduct ? originalProduct._id : undefined;
+
+      log(
+        `Create ${quantity}x Position with Product ${productId} ${quotationId ? ` (${quotationId})` : ''
+        }`,
+        { orderId, productId, originalProductId, userId: requestContext.userId },
+      );
+
+      const positionId = await mutations.create(
+        {
+          orderId,
+          productId,
+          originalProductId,
+          quotationId,
+          quantity,
+          configuration,
+          context,
+          calculation: [],
+          scheduling: [],
+        },
+        requestContext.userId,
+      );
+
+      await updateCalculation(orderId, requestContext);
+
+      return OrderPositions.findOne(buildFindByIdSelector(positionId));
+    },
+
+    delete: async (orderPositionId, requestContext) => {
+      const selector = buildFindByIdSelector(orderPositionId);
+      const orderPosition = await OrderPositions.findOne(selector, {});
+
+      log(`Remove Position ${orderPositionId}`, {
+        orderId: orderPosition.orderId,
+      });
+
+      await OrderPositions.deleteOne(selector);
+
+      await updateCalculation(orderPosition.orderId, requestContext);
+
+      emit('ORDER_REMOVE_CART_ITEM', {
+        orderPosition,
+      });
+
+      return orderPosition;
+    },
+
+    removePositions: async ({ orderId }, requestContext) => {
+      log('Remove Positions', { orderId });
+
+      const result = await OrderPositions.deleteMany({ orderId });
+
+      await updateCalculation(orderId, requestContext);
+
+      emit('ORDER_EMPTY_CART', { orderId, count: result.deletedCount });
+
+      return result.deletedCount;
+    },
+
+    updateProductItem: async (
+      { quantity, configuration },
+      { order, product, orderPosition },
+      requestContext,
+    ) => {
+      const selector = buildFindByIdSelector(orderPosition._id, order._id);
+      const modifier: any = {
+        $set: {
+          updated: new Date(),
+          updatedBy: requestContext.userId,
+        },
+      };
+
+      if (quantity !== null && quantity !== orderPosition.quantity) {
+        modifier.$set.quantity = quantity;
+      }
+
+      if (configuration !== null) {
+        const resolvedProduct = await requestContext.modules.products.resolveOrderableProduct(
+          product,
+          { configuration },
+          requestContext,
+        );
+        modifier.$set.productId = resolvedProduct._id;
+        modifier.$set.configuration = configuration;
+      }
+
+      await ordersSettings.validateOrderPosition(
+        {
+          order,
+          product,
+          configuration,
+          quantityDiff: quantity - orderPosition.quantity,
+        },
+        requestContext,
+      );
+
+      await OrderPositions.updateOne(selector, modifier);
+
+      await updateCalculation(order._id, requestContext);
+
+      const updatedOrderPosition = await OrderPositions.findOne(selector, {});
+
+      emit('ORDER_UPDATE_CART_ITEM', {
+        orderPosition: updatedOrderPosition,
+      });
+
+      return updatedOrderPosition;
+    },
+
+    updateScheduling: async ({ order, orderDelivery, orderPosition }, requestContext) => {
+      const { modules } = requestContext;
+      // scheduling (store in db for auditing)
+      const product = await modules.products.findProduct({
+        productId: orderPosition.productId,
+      });
+      const deliveryProvider =
+        orderDelivery &&
+        (await modules.delivery.findProvider({
+          deliveryProviderId: orderDelivery.deliveryProviderId,
+        }));
+      const { countryCode, userId } = order;
+
+      const scheduling = await Promise.all(
+        (
+          await modules.warehousing.findSupported(
+            {
+              product,
+              deliveryProvider,
+            },
+            requestContext,
+          )
+        ).map(async (warehousingProvider) => {
+          const context = {
+            warehousingProvider,
+            deliveryProvider,
+            product,
+            item: orderPosition,
+            delivery: deliveryProvider,
+            order,
+            userId,
+            country: countryCode,
+            referenceDate: order.ordered,
+            quantity: orderPosition.quantity,
+          };
+          const dispatch = await requestContext.modules.warehousing.estimatedDispatch(
+            warehousingProvider,
+            context,
+            requestContext,
+          );
+
+          return {
+            warehousingProviderId: warehousingProvider._id,
+            ...dispatch,
+          };
+        }),
+      );
+
+      await OrderPositions.updateOne(generateDbFilterById(orderPosition._id), {
+        $set: { scheduling },
+      });
+
+      return OrderPositions.findOne(generateDbFilterById(orderPosition._id), {});
+    },
+
+    updateCalculation: async (orderPosition, requestContext) => {
+      log(`OrderPosition ${orderPosition._id} -> Update Calculation`, {
+        orderId: orderPosition.orderId,
+      });
+
+      const calculation = await requestContext.modules.products.calculate(
+        { item: orderPosition },
+        requestContext,
+      );
+      const selector = buildFindByIdSelector(orderPosition._id);
+
+      await OrderPositions.updateOne(selector, {
+        $set: { calculation },
+      });
+
+      return OrderPositions.findOne(selector, {});
+    },
+
+    addProductItem: async (orderPosition: OrderPosition, { order, product }, requestContext) => {
+      const { modules } = requestContext;
+      const { configuration, orderId: positionOrderId, quantity, ...scope } = orderPosition;
+      const orderId = order._id || positionOrderId;
+
+      // Resolve product
+      const resolvedProduct = await modules.products.resolveOrderableProduct(
+        product,
+        { configuration },
+        requestContext,
+      );
+
+      // Validate add to cart mutation
+      await ordersSettings.validateOrderPosition(
+        {
+          order,
+          product,
+          configuration,
+          quantityDiff: quantity,
+        },
+        requestContext,
+      );
+
+      // Search for existing position
+      const selector: Query = {
+        orderId,
+        productId: resolvedProduct._id,
+        originalProductId: product._id,
+        configuration: configuration || { $exists: false },
+        ...scope,
+      };
+
+      const { upsertedId } = await OrderPositions.updateOne(
+        selector,
+        {
+          $set: {
+            updated: new Date(),
+            updatedBy: requestContext.userId,
+          },
+          $inc: { quantity },
+          $setOnInsert: {
+            _id: generateDbObjectId(),
+            created: new Date(),
+            createdBy: requestContext.userId,
+            calculation: [],
+            scheduling: [],
+            orderId,
+            productId: resolvedProduct._id,
+            originalProductId: product._id,
+            configuration,
+            ...scope,
+          },
+        },
+        { upsert: true },
+      );
+
+      await updateCalculation(orderId, requestContext);
+
+      const upsertedOrderPosition = await OrderPositions.findOne(
+        upsertedId
+          ? {
+            _id: upsertedId,
+          }
+          : selector,
+      );
+
+      emit('ORDER_ADD_PRODUCT', { orderPosition: upsertedOrderPosition });
+
+      return upsertedOrderPosition;
+    },
+  };
+};

package/src/module/configureOrdersModule-mutations.ts

@@ -0,0 +1,230 @@
+import { Collection, ModuleMutations } from '@unchainedshop/types/common';
+import { Order, OrderStatus, OrderMutations, OrdersModule } from '@unchainedshop/types/orders';
+import { OrderDelivery } from '@unchainedshop/types/orders.deliveries';
+import { OrderPayment } from '@unchainedshop/types/orders.payments';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { log, LogLevel } from '@unchainedshop/logger';
+import { generateDbFilterById, generateDbMutations } from '@unchainedshop/utils';
+import { OrdersSchema } from '../db/OrdersSchema';
+
+const ORDER_EVENTS: string[] = [
+  'ORDER_CREATE',
+  'ORDER_REMOVE',
+  'ORDER_SET_DELIVERY_PROVIDER',
+  'ORDER_SET_PAYMENT_PROVIDER',
+  'ORDER_UPDATE',
+];
+
+export const configureOrderModuleMutations = ({
+  Orders,
+  OrderDeliveries,
+  OrderPayments,
+  initProviders,
+  updateStatus,
+  updateCalculation,
+}: {
+  Orders: Collection<Order>;
+  OrderDeliveries: Collection<OrderDelivery>;
+  OrderPayments: Collection<OrderPayment>;
+  initProviders: OrdersModule['initProviders'];
+  updateStatus: OrdersModule['updateStatus'];
+  updateCalculation: OrdersModule['updateCalculation'];
+}): OrderMutations => {
+  registerEvents(ORDER_EVENTS);
+
+  const mutations = generateDbMutations<Order>(Orders, OrdersSchema, {
+    permanentlyDeleteByDefault: true,
+    hasCreateOnly: false,
+  }) as ModuleMutations<Order>;
+
+  return {
+    create: async ({ orderNumber, currency, countryCode, billingAddress, contact }, userId) => {
+      const orderId = await mutations.create(
+        {
+          created: new Date(),
+          createdBy: userId,
+          status: null,
+          billingAddress,
+          contact,
+          userId,
+          currency,
+          countryCode,
+          calculation: [],
+          log: [],
+          orderNumber,
+        },
+        userId,
+      );
+
+      const order = await Orders.findOne(generateDbFilterById(orderId), {});
+
+      emit('ORDER_CREATE', { order });
+      return order;
+    },
+
+    delete: async (orderId, userId) => {
+      const deletedCount = await mutations.delete(orderId, userId);
+      emit('ORDER_REMOVE', { orderId });
+      return deletedCount;
+    },
+
+    initProviders,
+
+    invalidateProviders: async (requestContext, maxAgeDays = 30) => {
+      log('Orders: Start invalidating cart providers', {
+        level: LogLevel.Verbose,
+      });
+
+      const ONE_DAY_IN_MILLISECONDS = 86400000;
+
+      const minValidDate = new Date(new Date().getTime() - maxAgeDays * ONE_DAY_IN_MILLISECONDS);
+
+      const orders = await Orders.find({
+        status: { $eq: null },
+        updated: { $gte: minValidDate },
+      }).toArray();
+
+      await Promise.all(orders.map((order) => initProviders(order, requestContext)));
+    },
+
+    setDeliveryProvider: async (orderId, deliveryProviderId, requestContext) => {
+      const { modules } = requestContext;
+      const delivery = await OrderDeliveries.findOne({
+        orderId,
+        deliveryProviderId,
+      });
+      const deliveryId =
+        delivery?._id ||
+        (
+          await modules.orders.deliveries.create(
+            {
+              calculation: [],
+              deliveryProviderId,
+              log: [],
+              orderId,
+              status: null,
+            },
+            requestContext.userId,
+          )
+        )._id;
+
+      log(`Set Delivery Provider ${deliveryProviderId}`, { orderId });
+
+      const selector = generateDbFilterById(orderId);
+      await Orders.updateOne(selector, {
+        $set: {
+          deliveryId,
+          updated: new Date(),
+          updatedBy: requestContext.userId,
+        },
+      });
+
+      const order = await updateCalculation(orderId, requestContext);
+
+      emit('ORDER_SET_DELIVERY_PROVIDER', {
+        order,
+        deliveryProviderId,
+      });
+
+      return order;
+    },
+
+    setPaymentProvider: async (orderId, paymentProviderId, requestContext) => {
+      const { modules, userId } = requestContext;
+      const payment = await OrderPayments.findOne({
+        orderId,
+        paymentProviderId,
+      });
+
+      const paymentId =
+        payment?._id ||
+        (
+          await modules.orders.payments.create(
+            {
+              calculation: [],
+              paymentProviderId,
+              log: [],
+              orderId,
+              status: null,
+            },
+            userId,
+          )
+        )._id;
+      log(`Set Payment Provider ${paymentProviderId}`, { orderId });
+
+      const selector = generateDbFilterById(orderId);
+      await Orders.updateOne(selector, {
+        $set: { paymentId, updated: new Date(), updatedBy: userId },
+      });
+
+      const order = await updateCalculation(orderId, requestContext);
+
+      emit('ORDER_SET_PAYMENT_PROVIDER', {
+        order,
+        paymentProviderId,
+      });
+
+      return order;
+    },
+
+    updateBillingAddress: async (orderId, billingAddress, requestContext) => {
+      log('Update Invoicing Address', { orderId });
+
+      const selector = generateDbFilterById(orderId);
+      await Orders.updateOne(selector, {
+        $set: {
+          billingAddress,
+          updated: new Date(),
+          updatedBy: requestContext.userId,
+        },
+      });
+
+      const order = await updateCalculation(orderId, requestContext);
+      emit('ORDER_UPDATE', { order, field: 'billing' });
+      return order;
+    },
+
+    updateContact: async (orderId, contact, requestContext) => {
+      log('Update Contact', { orderId });
+
+      const selector = generateDbFilterById(orderId);
+      await Orders.updateOne(selector, {
+        $set: {
+          contact,
+          updated: new Date(),
+          updatedBy: requestContext.userId,
+        },
+      });
+
+      const order = await updateCalculation(orderId, requestContext);
+      emit('ORDER_UPDATE', { order, field: 'contact' });
+      return order;
+    },
+
+    updateContext: async (orderId, context, requestContext) => {
+      log('Update Arbitrary Context', { orderId, context });
+
+      const selector = generateDbFilterById(orderId);
+
+      selector.status = { $in: [null, OrderStatus.PENDING] };
+
+      const result = await Orders.updateOne(selector, {
+        $set: {
+          context,
+          updated: new Date(),
+          updatedBy: requestContext.userId,
+        },
+      });
+
+      if (result.modifiedCount) {
+        const order = await updateCalculation(orderId, requestContext);
+        emit('ORDER_UPDATE', { order, field: 'context' });
+        return true;
+      }
+      return false;
+    },
+
+    updateStatus,
+    updateCalculation,
+  };
+};