@unchainedshop/core-orders 1.1.3

package/plugins/order-delivery.ts

@@ -0,0 +1,45 @@
+import { IOrderPricingAdapter } from '@unchainedshop/types/orders.pricing';
+import { OrderPricingDirector, OrderPricingAdapter } from 'meteor/unchained:core-orders';
+
+const OrderDelivery: IOrderPricingAdapter = {
+  ...OrderPricingAdapter,
+
+  key: 'shop.unchained.pricing.order-delivery',
+  version: '1.0',
+  label: 'Add Delivery Fees to Order',
+  orderIndex: 10,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = OrderPricingAdapter.actions(params);
+    const { order, orderDelivery, modules } = params.context;
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        // just add tax + net price to order pricing
+        if (!orderDelivery) return null;
+        const pricing = modules.orders.deliveries.pricingSheet(
+          orderDelivery,
+          order.currency,
+          params.context,
+        );
+        const tax = pricing.taxSum();
+        const shipping = pricing.gross();
+
+        pricingAdapter.resultSheet().addDelivery({ amount: shipping });
+        if (tax !== 0) {
+          pricingAdapter.resultSheet().addTax({ amount: tax });
+        }
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+OrderPricingDirector.registerAdapter(OrderDelivery);

package/plugins/order-discount.ts

@@ -0,0 +1,158 @@
+import { IOrderPricingAdapter, OrderPricingRowCategory } from '@unchainedshop/types/orders.pricing';
+import { OrderPricingDirector, OrderPricingAdapter } from 'meteor/unchained:core-orders';
+
+const resolveRatioAndTaxDivisorForPricingSheet = (pricing, total) => {
+  if (total === 0 || !pricing) {
+    return {
+      ratio: 1,
+      taxDivisor: 1,
+    };
+  }
+  const tax = pricing.taxSum();
+  const gross = pricing.gross();
+  if (gross - tax === 0) {
+    return {
+      ratio: 0,
+      taxDivisor: 0,
+    };
+  }
+  return {
+    ratio: gross / total,
+    taxDivisor: gross / (gross - tax),
+  };
+};
+
+const resolveAmountAndTax = ({ ratio, taxDivisor }, amount) => {
+  const shareAmount = Number.isFinite(ratio) ? amount * ratio : 0;
+  const shareTaxAmount =
+    Number.isFinite(taxDivisor) && taxDivisor !== 0 ? shareAmount - shareAmount / taxDivisor : 0;
+  return [shareAmount, shareTaxAmount];
+};
+
+const applyDiscountToMultipleShares = (shares, amount) => {
+  return shares.reduce(
+    ([currentDiscountAmount, currentTaxAmount], share) => {
+      const [shareAmount, shareTaxAmount] = resolveAmountAndTax(share, amount);
+      return [currentDiscountAmount + shareAmount, currentTaxAmount + shareTaxAmount];
+    },
+    [0, 0],
+  );
+};
+
+const calculateAmountToSplit = (configuration, amount) => {
+  const deductionAmount = configuration.rate ? amount * configuration.rate : configuration.fixedRate;
+
+  const leftInDiscount = Math.max(0, deductionAmount - (configuration.alreadyDeductedForDiscount || 0));
+  const leftToDeduct = Math.min(configuration.amountLeft, leftInDiscount);
+  return Math.max(0, leftToDeduct);
+};
+
+const OrderDiscount: IOrderPricingAdapter = {
+  ...OrderPricingAdapter,
+
+  key: 'shop.unchained.pricing.order-discount',
+  version: '1.0',
+  label: 'Apply Discounts on Total Order Value',
+  orderIndex: 90,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = OrderPricingAdapter.actions(params);
+    const { order, orderDelivery, orderPositions, orderPayment, modules } = params.context;
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        // discounts need to provide a *fixedRate*
+        // if you want to add percentual discounts,
+        // add it to the order item calculation
+        const totalAmountOfItems = params.calculationSheet.sum({
+          category: OrderPricingRowCategory.Items,
+        });
+        const totalAmountOfPaymentAndDelivery =
+          params.calculationSheet.sum({
+            category: OrderPricingRowCategory.Payment,
+          }) +
+          params.calculationSheet.sum({
+            category: OrderPricingRowCategory.Delivery,
+          });
+
+        const itemShares = orderPositions.map((orderPosition) =>
+          resolveRatioAndTaxDivisorForPricingSheet(
+            modules.orders.positions.pricingSheet(orderPosition, order.currency, params.context),
+            totalAmountOfItems,
+          ),
+        );
+
+        const deliveryShare = resolveRatioAndTaxDivisorForPricingSheet(
+          orderDelivery &&
+            modules.orders.deliveries.pricingSheet(orderDelivery, order.currency, params.context),
+          totalAmountOfPaymentAndDelivery,
+        );
+        const paymentShare = resolveRatioAndTaxDivisorForPricingSheet(
+          orderPayment &&
+            modules.orders.payments.pricingSheet(orderPayment, order.currency, params.context),
+          totalAmountOfPaymentAndDelivery,
+        );
+
+        let amountLeft = totalAmountOfPaymentAndDelivery + totalAmountOfItems;
+
+        params.discounts.forEach(({ configuration, discountId }) => {
+          // First, we deduce the discount from the items
+          let alreadyDeductedForDiscount = 0;
+          const [itemsDiscountAmount, itemsTaxAmount] = applyDiscountToMultipleShares(
+            itemShares,
+            calculateAmountToSplit(
+              { ...configuration, amountLeft, alreadyDeductedForDiscount },
+              totalAmountOfItems,
+            ),
+          );
+          amountLeft -= itemsDiscountAmount;
+          alreadyDeductedForDiscount += itemsDiscountAmount;
+
+          // After the items, we deduct the remaining discount from payment & delivery fees
+          const [deliveryAndPaymentDiscountAmount, deliveryAndPaymentTaxAmount] =
+            applyDiscountToMultipleShares(
+              [deliveryShare, paymentShare],
+              calculateAmountToSplit(
+                { ...configuration, amountLeft, alreadyDeductedForDiscount },
+                totalAmountOfPaymentAndDelivery,
+              ),
+            );
+          amountLeft -= deliveryAndPaymentDiscountAmount;
+          alreadyDeductedForDiscount += itemsDiscountAmount;
+
+          const discountAmount = itemsDiscountAmount + deliveryAndPaymentDiscountAmount;
+          const taxAmount = itemsTaxAmount + deliveryAndPaymentTaxAmount;
+
+          if (discountAmount) {
+            pricingAdapter.resultSheet().addDiscount({
+              amount: discountAmount * -1,
+              discountId,
+              meta: {
+                adapter: OrderDiscount.key,
+              },
+            });
+            if (taxAmount !== 0) {
+              pricingAdapter.resultSheet().addTax({
+                amount: taxAmount * -1,
+                meta: {
+                  discountId,
+                  adapter: OrderDiscount.key,
+                },
+              });
+            }
+          }
+        });
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+OrderPricingDirector.registerAdapter(OrderDiscount);

package/plugins/order-items-discount.ts

@@ -0,0 +1,116 @@
+import { IOrderPricingAdapter, OrderPricingRowCategory } from '@unchainedshop/types/orders.pricing';
+import { OrderPricingDirector, OrderPricingAdapter } from 'meteor/unchained:core-orders';
+
+const resolveRatioAndTaxDivisorForPricingSheet = (pricing, total) => {
+  if (total === 0 || !pricing) {
+    return {
+      ratio: 1,
+      taxDivisor: 1,
+    };
+  }
+  const tax = pricing.taxSum();
+  const gross = pricing.gross();
+  return {
+    ratio: gross / total,
+    taxDivisor: gross / (gross - tax),
+  };
+};
+
+const resolveAmountAndTax = ({ ratio, taxDivisor }, amount) => {
+  const shareAmount = Number.isFinite(ratio) ? amount * ratio : 0;
+  const shareTaxAmount = Number.isFinite(taxDivisor) ? shareAmount - shareAmount / taxDivisor : 0;
+  return [shareAmount, shareTaxAmount];
+};
+
+const applyDiscountToMultipleShares = (shares, amount) => {
+  return shares.reduce(
+    ([currentDiscountAmount, currentTaxAmount], share) => {
+      const [shareAmount, shareTaxAmount] = resolveAmountAndTax(share, amount);
+      return [currentDiscountAmount + shareAmount, currentTaxAmount + shareTaxAmount];
+    },
+    [0, 0],
+  );
+};
+
+const calculateAmountToSplit = (configuration, amount) => {
+  const deductionAmount = configuration.rate
+    ? amount * configuration.rate
+    : Math.min(configuration.fixedRate, amount);
+
+  return Math.max(0, deductionAmount - (configuration.alreadyDeducted || 0));
+};
+
+const OrderItemsDiscount: IOrderPricingAdapter = {
+  ...OrderPricingAdapter,
+
+  key: 'shop.unchained.pricing.order-items-discount',
+  version: '1.0',
+  label: 'Apply Discounts on Total Value Of Goods',
+  orderIndex: 89,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = OrderPricingAdapter.actions(params);
+    const { order, orderPositions, modules } = params.context;
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        // discounts need to provide a *fixedRate*
+        // if you want to add percentual discounts,
+        // add it to the order item calculation
+
+        const totalAmountOfItems = params.calculationSheet.sum({
+          category: OrderPricingRowCategory.Items,
+        });
+
+        const itemShares = orderPositions.map((orderPosition) =>
+          resolveRatioAndTaxDivisorForPricingSheet(
+            modules.orders.positions.pricingSheet(orderPosition, order.currency, params.context),
+            totalAmountOfItems,
+          ),
+        );
+
+        let alreadyDeducted = 0;
+
+        params.discounts.forEach(({ configuration, discountId }) => {
+          // First, we deduce the discount from the items
+          const [itemsDiscountAmount, itemsTaxAmount] = applyDiscountToMultipleShares(
+            itemShares,
+            calculateAmountToSplit({ ...configuration, alreadyDeducted }, totalAmountOfItems),
+          );
+          alreadyDeducted = +itemsDiscountAmount;
+
+          const discountAmount = itemsDiscountAmount;
+          const taxAmount = itemsTaxAmount;
+          if (discountAmount) {
+            pricingAdapter.resultSheet().addDiscount({
+              amount: discountAmount * -1,
+              discountId,
+              meta: {
+                adapter: OrderItemsDiscount.key,
+              },
+            });
+            if (taxAmount !== 0) {
+              pricingAdapter.resultSheet().addTax({
+                amount: taxAmount * -1,
+                meta: {
+                  discountId,
+                  adapter: OrderItemsDiscount.key,
+                },
+              });
+            }
+          }
+        });
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+OrderPricingDirector.registerAdapter(OrderItemsDiscount);

package/plugins/order-items.ts

@@ -0,0 +1,61 @@
+import { IOrderPricingAdapter } from '@unchainedshop/types/orders.pricing';
+import { OrderPricingDirector, OrderPricingAdapter } from 'meteor/unchained:core-orders';
+
+const OrderItems: IOrderPricingAdapter = {
+  ...OrderPricingAdapter,
+
+  key: 'shop.unchained.pricing.order-items',
+  version: '1.0',
+  label: 'Add Total Value Of Goods to Order',
+  orderIndex: 0,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = OrderPricingAdapter.actions(params);
+    const { order, orderPositions, modules } = params.context;
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        // just sum up all products items prices, taxes & fees
+        const totalAndTaxesOfAllItems = orderPositions.reduce(
+          (current, orderPosition) => {
+            const pricing = modules.orders.positions.pricingSheet(
+              orderPosition,
+              order.currency,
+              params.context,
+            );
+            const tax = pricing.taxSum();
+            const items = pricing.gross();
+            return {
+              taxes: current.taxes + tax,
+              items: current.items + items,
+            };
+          },
+          {
+            taxes: 0,
+            items: 0,
+          },
+        );
+
+        pricingAdapter.resultSheet().addItems({
+          amount: totalAndTaxesOfAllItems.items,
+        });
+
+        if (totalAndTaxesOfAllItems.taxes !== 0) {
+          pricingAdapter.resultSheet().addTax({
+            amount: totalAndTaxesOfAllItems.taxes,
+          });
+        }
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+OrderPricingDirector.registerAdapter(OrderItems);

package/plugins/order-payment.ts

@@ -0,0 +1,46 @@
+import { IOrderPricingAdapter } from '@unchainedshop/types/orders.pricing';
+import { OrderPricingDirector, OrderPricingAdapter } from 'meteor/unchained:core-orders';
+
+const OrderPayment: IOrderPricingAdapter = {
+  ...OrderPricingAdapter,
+
+  key: 'shop.unchained.pricing.order-payment',
+  version: '1.0',
+  label: 'Add Payment Fees to Order',
+  orderIndex: 20,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = OrderPricingAdapter.actions(params);
+    const { order, orderPayment, modules } = params.context;
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        // just add tax + net price to order pricing
+        if (!orderPayment) return null;
+
+        const pricing = modules.orders.payments.pricingSheet(
+          orderPayment,
+          order.currency,
+          params.context,
+        );
+        const tax = pricing.taxSum();
+        const paymentFees = pricing.gross();
+
+        pricingAdapter.resultSheet().addPayment({ amount: paymentFees });
+        if (tax !== 0) {
+          pricingAdapter.resultSheet().addTax({ amount: tax });
+        }
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+OrderPricingDirector.registerAdapter(OrderPayment);

package/src/db/OrderDeliveriesCollection.ts

@@ -0,0 +1,12 @@
+import { Db } from '@unchainedshop/types/common';
+import { OrderDelivery } from '@unchainedshop/types/orders.deliveries';
+import { buildDbIndexes } from '@unchainedshop/utils';
+
+export const OrderDeliveriesCollection = async (db: Db) => {
+  const OrderDeliveries = db.collection<OrderDelivery>('order_deliveries');
+
+  // Order Indexes
+  await buildDbIndexes<OrderDelivery>(OrderDeliveries, [{ index: { orderId: 1 } }]);
+
+  return OrderDeliveries;
+};

package/src/db/OrderDeliveriesSchema.js

@@ -0,0 +1,24 @@
+import { Schemas } from '@unchainedshop/utils';
+import SimpleSchema from 'simpl-schema';
+
+const calculationFields = {
+  calculation: Array,
+  'calculation.$': {
+    type: Object,
+    blackbox: true,
+  },
+};
+
+export const OrderDeliveriesSchema = new SimpleSchema(
+  {
+    delivered: Date,
+    deliveryProviderId: String,
+    orderId: String,
+    status: String,
+    ...calculationFields,
+    ...Schemas.contextFields,
+    ...Schemas.logFields,
+    ...Schemas.timestampFields,
+  },
+  { requiredByDefault: false },
+);

package/src/db/OrderDiscountTrigger.ts

@@ -0,0 +1,4 @@
+export enum OrderDiscountTrigger {
+  USER = 'USER',
+  SYSTEM = 'SYSTEM',
+}

package/src/db/OrderDiscountsCollection.ts

@@ -0,0 +1,15 @@
+import { Db } from '@unchainedshop/types/common';
+import { OrderDiscount } from '@unchainedshop/types/orders.discounts';
+import { buildDbIndexes } from '@unchainedshop/utils';
+
+export const OrderDiscountsCollection = async (db: Db) => {
+  const OrderDiscounts = db.collection<OrderDiscount>('order_discounts');
+
+  // Order Indexes
+  await buildDbIndexes<OrderDiscount>(OrderDiscounts, [
+    { index: { orderId: 1 } },
+    { index: { trigger: 1 } },
+  ]);
+
+  return OrderDiscounts;
+};

package/src/db/OrderDiscountsSchema.js

@@ -0,0 +1,15 @@
+import { Schemas } from '@unchainedshop/utils';
+import SimpleSchema from 'simpl-schema';
+
+export const OrderDiscountsSchema = new SimpleSchema(
+  {
+    orderId: String,
+    code: String,
+    trigger: { type: String, required: true },
+    discountKey: { type: String, required: true },
+    reservation: { type: Object, blackbox: true },
+    ...Schemas.contextFields,
+    ...Schemas.timestampFields,
+  },
+  { requiredByDefault: false },
+);

package/src/db/OrderPaymentsCollection.ts

@@ -0,0 +1,12 @@
+import { Db } from '@unchainedshop/types/common';
+import { OrderPayment } from '@unchainedshop/types/orders.payments';
+import { buildDbIndexes } from '@unchainedshop/utils';
+
+export const OrderPaymentsCollection = async (db: Db) => {
+  const OrderPayments = db.collection<OrderPayment>('order_payments');
+
+  // Order Indexes
+  await buildDbIndexes<OrderPayment>(OrderPayments, [{ index: { orderId: 1 } }]);
+
+  return OrderPayments;
+};

package/src/db/OrderPaymentsSchema.js

@@ -0,0 +1,24 @@
+import { Schemas } from '@unchainedshop/utils';
+import SimpleSchema from 'simpl-schema';
+
+const calculationFields = {
+  calculation: Array,
+  'calculation.$': {
+    type: Object,
+    blackbox: true,
+  },
+};
+
+export const OrderPaymentsSchema = new SimpleSchema(
+  {
+    orderId: String,
+    paymentProviderId: String,
+    paid: Date,
+    status: String,
+    ...calculationFields,
+    ...Schemas.contextFields,
+    ...Schemas.logFields,
+    ...Schemas.timestampFields,
+  },
+  { requiredByDefault: false },
+);

package/src/db/OrderPositionsCollection.ts

@@ -0,0 +1,15 @@
+import { Db } from '@unchainedshop/types/common';
+import { OrderPosition } from '@unchainedshop/types/orders.positions';
+import { buildDbIndexes } from '@unchainedshop/utils';
+
+export const OrderPositionsCollection = async (db: Db) => {
+  const OrderPositions = db.collection<OrderPosition>('order_positions');
+
+  // Order Indexes
+  await buildDbIndexes<OrderPosition>(OrderPositions, [
+    { index: { productId: 1 } },
+    { index: { orderId: 1 } },
+  ]);
+
+  return OrderPositions;
+};

package/src/db/OrderPositionsSchema.js

@@ -0,0 +1,41 @@
+import { Schemas } from '@unchainedshop/utils';
+import SimpleSchema from 'simpl-schema';
+
+const calculationFields = {
+  calculation: Array,
+  'calculation.$': {
+    type: Object,
+    blackbox: true,
+  },
+  scheduling: Array,
+  'scheduling.$': {
+    type: Object,
+    blackbox: true,
+  },
+};
+
+export const OrderPositionsSchema = new SimpleSchema(
+  {
+    productId: String,
+    orderId: String,
+    originalProductId: { type: String },
+    quotationId: { type: String },
+    quantity: Number,
+    configuration: Array,
+    'configuration.$': {
+      type: Object,
+      required: true,
+    },
+    'configuration.$.key': {
+      type: String,
+      required: true,
+    },
+    'configuration.$.value': {
+      type: String,
+    },
+    ...calculationFields,
+    ...Schemas.contextFields,
+    ...Schemas.timestampFields,
+  },
+  { requiredByDefault: false },
+);

package/src/db/OrdersCollection.ts

@@ -0,0 +1,37 @@
+import { Db } from '@unchainedshop/types/common';
+import { buildDbIndexes } from '@unchainedshop/utils';
+import { Order } from '@unchainedshop/types/orders';
+
+export const OrdersCollection = async (db: Db) => {
+  const Orders = db.collection<Order>('orders');
+
+  // Order Indexes
+  await buildDbIndexes<Order>(Orders, [
+    { index: { userId: 1 } },
+    { index: { status: 1 } },
+    { index: { orderNumber: 1 } },
+    {
+      index: {
+        _id: 'text',
+        userId: 'text',
+        orderNumber: 'text',
+        status: 'text',
+        'contact.emailAddress': 'text',
+        'contact.telNumber': 'text',
+      } as any,
+      options: {
+        weights: {
+          _id: 8,
+          userId: 3,
+          orderNumber: 6,
+          'contact.telNumber': 5,
+          'contact.emailAddress': 4,
+          status: 1,
+        },
+        name: 'order_fulltext_search',
+      },
+    },
+  ]);
+
+  return Orders;
+};

package/src/db/OrdersSchema.js

@@ -0,0 +1,34 @@
+import { Schemas } from '@unchainedshop/utils';
+import SimpleSchema from 'simpl-schema';
+
+const calculationFields = {
+  calculation: Array,
+  'calculation.$': {
+    type: Object,
+    blackbox: true,
+  },
+};
+
+export const OrdersSchema = new SimpleSchema(
+  {
+    billingAddress: Schemas.Address,
+    confirmed: Date,
+    rejected: Date,
+    contact: Schemas.Contact,
+    countryCode: String,
+    currency: String,
+    deliveryId: String,
+    fullfilled: Date,
+    ordered: Date,
+    orderNumber: String,
+    originEnrollmentId: String,
+    paymentId: String,
+    status: String,
+    userId: String,
+    ...calculationFields,
+    ...Schemas.contextFields,
+    ...Schemas.logFields,
+    ...Schemas.timestampFields,
+  },
+  { requiredByDefault: false },
+);

package/src/director/OrderDiscountAdapter.ts

@@ -0,0 +1,5 @@
+import { IDiscountAdapter } from '@unchainedshop/types/discount';
+import { BaseDiscountAdapter } from '@unchainedshop/utils';
+
+export const OrderDiscountAdapter: Omit<IDiscountAdapter, 'key' | 'label' | 'version'> =
+  BaseDiscountAdapter;

package/src/director/OrderDiscountDirector.ts

@@ -0,0 +1,4 @@
+import { IDiscountDirector } from '@unchainedshop/types/discount';
+import { BaseDiscountDirector } from '@unchainedshop/utils';
+
+export const OrderDiscountDirector: IDiscountDirector = BaseDiscountDirector('OrderDiscountDirector');