@unchainedshop/core-orders 1.1.3

package/src/director/OrderPricingAdapter.ts

@@ -0,0 +1,41 @@
+import {
+  IOrderPricingSheet,
+  OrderPricingAdapterContext,
+  OrderPricingCalculation,
+} from '@unchainedshop/types/orders.pricing';
+import { IPricingAdapter } from '@unchainedshop/types/pricing';
+import { BasePricingAdapter } from '@unchainedshop/utils';
+import { OrderPricingSheet } from './OrderPricingSheet';
+
+const basePricingAdapter = BasePricingAdapter<OrderPricingAdapterContext, OrderPricingCalculation>();
+
+export const OrderPricingAdapter: IPricingAdapter<
+  OrderPricingAdapterContext,
+  OrderPricingCalculation,
+  IOrderPricingSheet
+> = {
+  ...basePricingAdapter,
+
+  isActivatedFor: () => {
+    return false;
+  },
+
+  actions: (params) => {
+    const { context } = params;
+    const { currency } = context;
+    const baseActions = basePricingAdapter.actions(params);
+    const resultSheet = OrderPricingSheet({ currency });
+
+    return {
+      ...baseActions,
+      calculate: async () => {
+        const resultRaw = resultSheet.getRawPricingSheet();
+        resultRaw.forEach(({ amount, category }) =>
+          basePricingAdapter.log(`Order Pricing Calculation -> ${category} ${amount}`),
+        );
+        return resultRaw;
+      },
+      resultSheet: () => resultSheet,
+    };
+  },
+};

package/src/director/OrderPricingDirector.ts

@@ -0,0 +1,68 @@
+import {
+  IOrderPricingAdapter,
+  IOrderPricingDirector,
+  OrderPricingAdapterContext,
+  OrderPricingCalculation,
+  OrderPricingContext,
+} from '@unchainedshop/types/orders.pricing';
+import { BasePricingDirector } from '@unchainedshop/utils';
+import { OrderPricingSheet } from './OrderPricingSheet';
+
+const baseDirector = BasePricingDirector<
+  OrderPricingContext,
+  OrderPricingAdapterContext,
+  OrderPricingCalculation,
+  IOrderPricingAdapter
+>('OrderPricingDirector');
+
+export const OrderPricingDirector: IOrderPricingDirector = {
+  ...baseDirector,
+
+  buildPricingContext: async ({ order, ...context }, requestContext) => {
+    const { modules } = requestContext;
+    const user = await modules.users.findUserById(order.userId);
+
+    const orderDelivery = await modules.orders.deliveries.findDelivery({
+      orderDeliveryId: order.deliveryId,
+    });
+
+    const orderPayment = await modules.orders.payments.findOrderPayment({
+      orderPaymentId: order.paymentId,
+    });
+
+    const orderPositions = await modules.orders.positions.findOrderPositions({
+      orderId: order._id,
+    });
+
+    const discounts = await modules.orders.discounts.findOrderDiscounts({
+      orderId: order._id,
+    });
+
+    return {
+      country: order.countryCode,
+      currency: order.currency,
+      ...context,
+      ...requestContext,
+      discounts,
+      order,
+      orderDelivery,
+      orderPayment,
+      orderPositions,
+      user,
+    };
+  },
+
+  async actions(pricingContext, requestContext) {
+    const actions = await baseDirector.actions(pricingContext, requestContext, this.buildPricingContext);
+    return {
+      ...actions,
+      calculationSheet() {
+        const context = actions.getContext();
+        return OrderPricingSheet({
+          calculation: actions.getCalculation(),
+          currency: context.currency,
+        });
+      },
+    };
+  },
+};

package/src/director/OrderPricingSheet.ts

@@ -0,0 +1,138 @@
+import { BasePricingSheet } from '@unchainedshop/utils';
+import {
+  OrderPricingCalculation,
+  OrderPricingRowCategory,
+  IOrderPricingSheet,
+} from '@unchainedshop/types/orders.pricing';
+import { IBasePricingSheet, PricingSheetParams } from '@unchainedshop/types/pricing';
+
+export const OrderPricingSheet = (
+  params: PricingSheetParams<OrderPricingCalculation>,
+): IOrderPricingSheet => {
+  const basePricingSheet: IBasePricingSheet<OrderPricingCalculation> = BasePricingSheet(params);
+
+  const pricingSheet: IOrderPricingSheet = {
+    ...basePricingSheet,
+
+    addItems({ amount, meta }) {
+      basePricingSheet.calculation.push({
+        category: OrderPricingRowCategory.Items,
+        amount,
+        meta,
+      });
+    },
+
+    addDiscount({ amount, discountId, meta }: { amount: number; discountId: string; meta?: any }) {
+      basePricingSheet.calculation.push({
+        category: OrderPricingRowCategory.Discounts,
+        amount,
+        discountId,
+        meta,
+      });
+    },
+
+    addTax({ amount, meta }) {
+      basePricingSheet.calculation.push({
+        category: OrderPricingRowCategory.Taxes,
+        amount,
+        meta,
+      });
+    },
+
+    addDelivery({ amount, meta }) {
+      basePricingSheet.calculation.push({
+        category: OrderPricingRowCategory.Delivery,
+        amount,
+        meta,
+      });
+    },
+
+    addPayment({ amount, meta }) {
+      basePricingSheet.calculation.push({
+        category: OrderPricingRowCategory.Payment,
+        amount,
+        meta,
+      });
+    },
+
+    gross() {
+      // tax is included 2 times, this is only true for Order Pricing!
+      return basePricingSheet.sum() - pricingSheet.taxSum();
+    },
+
+    taxSum() {
+      return basePricingSheet.sum({
+        category: OrderPricingRowCategory.Taxes,
+      });
+    },
+
+    itemsSum() {
+      return basePricingSheet.sum({
+        category: OrderPricingRowCategory.Items,
+      });
+    },
+
+    discountSum(discountId) {
+      return basePricingSheet.sum({
+        category: OrderPricingRowCategory.Discounts,
+        discountId,
+      });
+    },
+
+    discountPrices(explicitDiscountId) {
+      const discountIds = pricingSheet
+        .getDiscountRows(explicitDiscountId)
+        .map(({ discountId }) => discountId);
+
+      return [...new Set(discountIds)]
+        .map((discountId) => {
+          const amount = basePricingSheet.sum({
+            category: OrderPricingRowCategory.Discounts,
+            discountId,
+          });
+          if (!amount) {
+            return null;
+          }
+          return {
+            discountId,
+            amount: Math.round(amount),
+            currency: basePricingSheet.currency,
+          };
+        })
+        .filter(Boolean);
+    },
+
+    getDiscountRows(discountId) {
+      return basePricingSheet.filterBy({
+        category: OrderPricingRowCategory.Discounts,
+        discountId,
+      });
+    },
+
+    getItemsRows() {
+      return basePricingSheet.filterBy({
+        category: OrderPricingRowCategory.Items,
+      });
+    },
+
+    getTaxRows() {
+      return basePricingSheet.filterBy({
+        category: OrderPricingRowCategory.Taxes,
+      });
+    },
+
+    getDeliveryRows() {
+      return basePricingSheet.filterBy({
+        category: OrderPricingRowCategory.Delivery,
+      });
+    },
+
+    getPaymentRows() {
+      return basePricingSheet.filterBy({
+        category: OrderPricingRowCategory.Payment,
+      });
+    },
+  };
+
+  return pricingSheet;
+};

package/src/module/configureOrderDeliveriesModule.ts

@@ -0,0 +1,240 @@
+import { Collection, Filter, ModuleMutations, Update } from '@unchainedshop/types/common';
+import { OrdersModule } from '@unchainedshop/types/orders';
+import {
+  OrderDeliveriesModule,
+  OrderDelivery,
+  OrderDeliveryStatus,
+} from '@unchainedshop/types/orders.deliveries';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { log } from '@unchainedshop/logger';
+import { generateDbFilterById, generateDbMutations } from '@unchainedshop/utils';
+import { OrderDeliveriesSchema } from '../db/OrderDeliveriesSchema';
+
+const ORDER_DELIVERY_EVENTS: string[] = ['ORDER_DELIVER', 'ORDER_UPDATE_DELIVERY'];
+
+const buildFindByIdSelector = (orderDeliveryId: string) =>
+  generateDbFilterById(orderDeliveryId) as Filter<OrderDelivery>;
+
+export const configureOrderDeliveriesModule = ({
+  OrderDeliveries,
+  updateCalculation,
+}: {
+  OrderDeliveries: Collection<OrderDelivery>;
+  updateCalculation: OrdersModule['updateCalculation'];
+}): OrderDeliveriesModule => {
+  registerEvents(ORDER_DELIVERY_EVENTS);
+
+  const mutations = generateDbMutations<OrderDelivery>(OrderDeliveries, OrderDeliveriesSchema, {
+    permanentlyDeleteByDefault: true,
+    hasCreateOnly: false,
+  }) as ModuleMutations<OrderDelivery>;
+
+  const normalizedStatus: OrderDeliveriesModule['normalizedStatus'] = (orderDelivery) => {
+    return orderDelivery.status === null
+      ? OrderDeliveryStatus.OPEN
+      : (orderDelivery.status as OrderDeliveryStatus);
+  };
+
+  const updateStatus: OrderDeliveriesModule['updateStatus'] = async (
+    orderDeliveryId,
+    { status, info },
+    userId,
+  ) => {
+    log(`OrderDelivery ${orderDeliveryId} -> New Status: ${status}`);
+
+    const date = new Date();
+    const modifier: Update<OrderDelivery> = {
+      $set: { status, updated: new Date(), updatedBy: userId },
+      $push: {
+        log: {
+          date,
+          status,
+          info,
+        },
+      },
+    };
+    if (status === OrderDeliveryStatus.DELIVERED) {
+      modifier.$set.delivered = date;
+    }
+
+    const selector = buildFindByIdSelector(orderDeliveryId);
+    await OrderDeliveries.updateOne(selector, modifier);
+    return OrderDeliveries.findOne(selector, {});
+  };
+
+  return {
+    // Queries
+    findDelivery: async ({ orderDeliveryId }, options) => {
+      return OrderDeliveries.findOne(buildFindByIdSelector(orderDeliveryId), options);
+    },
+
+    // Transformations
+    discounts: (orderDelivery, { order, orderDiscount }, context) => {
+      const { modules } = context;
+      if (!orderDelivery) return [];
+
+      const pricingSheet = modules.orders.deliveries.pricingSheet(
+        orderDelivery,
+        order.currency,
+        context,
+      );
+
+      return pricingSheet.discountPrices(orderDiscount._id).map((discount) => ({
+        delivery: orderDelivery,
+        ...discount,
+      }));
+    },
+
+    isBlockingOrderConfirmation: async (orderDelivery, requestContext) => {
+      const provider = await requestContext.modules.delivery.findProvider({
+        deliveryProviderId: orderDelivery.deliveryProviderId,
+      });
+
+      const isAutoReleaseAllowed = await requestContext.modules.delivery.isAutoReleaseAllowed(
+        provider,
+        requestContext,
+      );
+
+      return !isAutoReleaseAllowed;
+    },
+    isBlockingOrderFullfillment: (orderDelivery) => {
+      if (orderDelivery.status === OrderDeliveryStatus.DELIVERED) return false;
+      return true;
+    },
+
+    normalizedStatus,
+
+    pricingSheet: (orderDelivery, currency, { modules }) => {
+      return modules.delivery.pricingSheet({
+        calculation: orderDelivery.calculation,
+        currency,
+      });
+    },
+
+    // Mutations
+
+    create: async (doc, userId) => {
+      const orderDeliveryId = await mutations.create(
+        { ...doc, context: doc.context || {}, status: null },
+        userId,
+      );
+
+      const orderDelivery = await OrderDeliveries.findOne(buildFindByIdSelector(orderDeliveryId));
+      return orderDelivery;
+    },
+
+    delete: async (orderDeliveryId, userId) => {
+      const deletedCount = await mutations.delete(orderDeliveryId, userId);
+      return deletedCount;
+    },
+
+    markAsDelivered: async (orderDelivery, userId) => {
+      if (normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN) return;
+      const updatedOrderDelivery = await updateStatus(
+        orderDelivery._id,
+        {
+          status: OrderDeliveryStatus.DELIVERED,
+          info: 'mark delivered manually',
+        },
+        userId,
+      );
+      emit('ORDER_DELIVER', { orderDelivery: updatedOrderDelivery });
+    },
+
+    send: async (orderDelivery, { order, deliveryContext }, requestContext) => {
+      if (normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN) return orderDelivery;
+
+      const deliveryProvider = await requestContext.modules.delivery.findProvider({
+        deliveryProviderId: orderDelivery.deliveryProviderId,
+      });
+
+      const deliveryProviderId = deliveryProvider._id;
+
+      const address = orderDelivery.context?.address || order || order.billingAddress || {};
+
+      const arbitraryResponseData = await requestContext.modules.delivery.send(
+        deliveryProviderId,
+        {
+          order,
+          orderDelivery,
+          transactionContext: {
+            ...(deliveryContext || {}),
+            ...(orderDelivery.context || {}),
+            address,
+          },
+        },
+        requestContext,
+      );
+
+      if (arbitraryResponseData) {
+        return updateStatus(
+          orderDelivery._id,
+          {
+            status: OrderDeliveryStatus.DELIVERED,
+            info: JSON.stringify(arbitraryResponseData),
+          },
+          requestContext.userId,
+        );
+      }
+
+      return orderDelivery;
+    },
+
+    updateContext: async (orderDeliveryId, context, requestContext) => {
+      const selector = buildFindByIdSelector(orderDeliveryId);
+      const orderDelivery = await OrderDeliveries.findOne(selector, {});
+      const { orderId } = orderDelivery;
+
+      log(`OrderDelivery ${orderDeliveryId} -> Update Context`, {
+        orderId,
+      });
+
+      const result = await OrderDeliveries.updateOne(selector, {
+        $set: {
+          context: { ...(orderDelivery.context || {}), ...context },
+          updated: new Date(),
+          updatedBy: requestContext.userId,
+        },
+      });
+
+      if (result.modifiedCount) {
+        await updateCalculation(orderId, requestContext);
+        emit('ORDER_UPDATE_DELIVERY', {
+          orderDelivery: {
+            ...orderDelivery,
+            context: { ...(orderDelivery.context || {}), ...context },
+          },
+        });
+        return true;
+      }
+
+      return false;
+    },
+
+    updateStatus,
+
+    updateCalculation: async (orderDelivery, requestContext) => {
+      log(`OrderDelivery ${orderDelivery._id} -> Update Calculation`, {
+        orderId: orderDelivery.orderId,
+      });
+
+      const calculation = await requestContext.modules.delivery.calculate(
+        {
+          item: orderDelivery,
+        },
+        requestContext,
+      );
+
+      const selector = buildFindByIdSelector(orderDelivery._id);
+      await OrderDeliveries.updateOne(selector, {
+        $set: {
+          calculation,
+          updated: new Date(),
+          updatedBy: requestContext.userId,
+        },
+      });
+
+      return OrderDeliveries.findOne(selector);
+    },
+  };
+};