@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc2

package/src/services/processOrder.ts

@@ -0,0 +1,241 @@
+import {
+  Order,
+  OrderDelivery,
+  OrderDeliveryStatus,
+  OrderPayment,
+  OrderPaymentStatus,
+  OrderStatus,
+} from '@unchainedshop/core-orders';
+import { Modules } from '../modules.js';
+import { createEnrollmentFromCheckoutService } from './createEnrollmentFromCheckout.js';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { WarehousingDirector, DeliveryDirector, PaymentDirector } from '../directors/index.js';
+import { fullfillQuotationService } from './fullfillQuotation.js';
+
+const isAutoConfirmationEnabled = async (
+  {
+    orderPayment,
+    orderDelivery,
+  }: {
+    orderPayment: OrderPayment;
+    orderDelivery: OrderDelivery;
+  },
+  modules: Modules,
+) => {
+  if (orderPayment.status !== OrderPaymentStatus.PAID) {
+    const provider = await modules.payment.paymentProviders.findProvider({
+      paymentProviderId: orderPayment.paymentProviderId,
+    });
+    const actions = await PaymentDirector.actions(provider, {}, { modules });
+    if (!actions.isPayLaterAllowed()) return false;
+  }
+
+  if (orderDelivery.status !== OrderDeliveryStatus.DELIVERED) {
+    const deliveryProvider = await modules.delivery.findProvider({
+      deliveryProviderId: orderDelivery.deliveryProviderId,
+    });
+    const director = await DeliveryDirector.actions(deliveryProvider, {}, { modules });
+    if (!director.isAutoReleaseAllowed()) return false;
+  }
+
+  return true;
+};
+
+const findNextStatus = async (
+  status: OrderStatus | null,
+  order: Order,
+  modules: Modules,
+): Promise<OrderStatus | null> => {
+  if (status === null) {
+    return OrderStatus.PENDING;
+  }
+
+  if (status === OrderStatus.FULLFILLED || status === OrderStatus.REJECTED) {
+    // Final!
+    return status;
+  }
+
+  const orderPayment = await modules.orders.payments.findOrderPayment({
+    orderPaymentId: order.paymentId,
+  });
+  if (!orderPayment) return status;
+
+  const orderDelivery = await modules.orders.deliveries.findDelivery({
+    orderDeliveryId: order.deliveryId,
+  });
+  if (!orderDelivery) return status;
+
+  // Ok, we have a payment and a delivery and the correct status,
+  // let's check if we can auto-confirm or auto-fulfill
+  if (status === OrderStatus.PENDING) {
+    if (await isAutoConfirmationEnabled({ orderPayment, orderDelivery }, modules)) {
+      return OrderStatus.CONFIRMED;
+    }
+  }
+  if (status === OrderStatus.CONFIRMED) {
+    const readyForFullfillment =
+      orderDelivery.status === OrderDeliveryStatus.DELIVERED &&
+      orderPayment.status === OrderPaymentStatus.PAID;
+    if (readyForFullfillment) {
+      return OrderStatus.FULLFILLED;
+    }
+  }
+
+  return status;
+};
+
+export async function processOrderService(
+  this: Modules,
+  initialOrder: Order,
+  orderTransactionContext: {
+    paymentContext?: any;
+    deliveryContext?: any;
+    comment?: string;
+    nextStatus?: OrderStatus;
+  },
+) {
+  const {
+    paymentContext,
+    deliveryContext,
+    nextStatus: forceNextStatus,
+    comment,
+  } = orderTransactionContext;
+
+  const orderId = initialOrder._id;
+  let order = initialOrder;
+  let nextStatus = forceNextStatus || (await findNextStatus(initialOrder.status, order, this));
+
+  if (nextStatus === OrderStatus.PENDING) {
+    // auto charge during transition to pending
+    const orderPayment = await this.orders.payments.findOrderPayment({
+      orderPaymentId: order.paymentId,
+    });
+
+    await PaymentDirector.chargeOrderPayment(
+      orderPayment,
+      { userId: order.userId, transactionContext: paymentContext },
+      { modules: this },
+    );
+
+    nextStatus = await findNextStatus(nextStatus, order, this);
+  }
+
+  if (nextStatus === OrderStatus.REJECTED) {
+    // auto cancel during transition to rejected
+    const orderPayment = await this.orders.payments.findOrderPayment({
+      orderPaymentId: order.paymentId,
+    });
+    await PaymentDirector.cancelOrderPayment(
+      orderPayment,
+      { userId: order.userId, transactionContext: paymentContext },
+      { modules: this },
+    );
+  }
+
+  if (nextStatus === OrderStatus.CONFIRMED) {
+    // confirm pre-authorized payments
+    const orderPayment = await this.orders.payments.findOrderPayment({
+      orderPaymentId: order.paymentId,
+    });
+    await PaymentDirector.confirmOrderPayment(
+      orderPayment,
+      { userId: order.userId, transactionContext: paymentContext },
+      { modules: this },
+    );
+    if (order.status !== OrderStatus.CONFIRMED) {
+      // we have to stop here shortly to complete the confirmation
+      // before auto delivery is started, else we have no chance to create
+      // numbers that are needed for delivery
+      order = await this.orders.updateStatus(orderId, {
+        status: OrderStatus.CONFIRMED,
+        info: comment,
+      });
+
+      const orderDelivery = await this.orders.deliveries.findDelivery({
+        orderDeliveryId: order.deliveryId,
+      });
+
+      await DeliveryDirector.sendOrderDelivery(orderDelivery, deliveryContext, { modules: this });
+
+      const orderPositions = await this.orders.positions.findOrderPositions({ orderId });
+      const mappedProductOrderPositions = await Promise.all(
+        orderPositions.map(async (orderPosition) => {
+          const product = await this.products.findProduct({
+            productId: orderPosition.productId,
+          });
+          return {
+            orderPosition,
+            product,
+          };
+        }),
+      );
+      const tokenizedItems = mappedProductOrderPositions.filter(
+        (item) => item.product?.type === ProductTypes.TokenizedProduct,
+      );
+      if (tokenizedItems.length > 0) {
+        // Give virtual warehouse a chance to instantiate new virtual objects
+        const virtualProviders = await this.warehousing.findProviders({
+          type: WarehousingProviderType.VIRTUAL,
+        });
+        // It's very important to do this in a series and not in Promise.all
+        // TODO: Actually, only createTokens should decide on the unique chainTokenId
+        // and the tokens should be created with a distributed Lock to not assign the same id multiple times!
+        for (const { orderPosition, product } of tokenizedItems) {
+          for (const virtualProvider of virtualProviders) {
+            const adapterActions = await WarehousingDirector.actions(
+              virtualProvider,
+              {
+                order,
+                orderPosition,
+                product,
+                quantity: orderPosition.quantity,
+                referenceDate: order.ordered,
+              },
+              { modules: this },
+            );
+            const isActive = await adapterActions.isActive();
+            if (isActive) {
+              const tokens = await adapterActions.tokenize();
+              await this.warehousing.createTokens(tokens);
+            }
+          }
+        }
+      }
+
+      // Enrollments: Generate enrollments for plan products
+      const planItems = mappedProductOrderPositions.filter(
+        (item) => item.product?.type === ProductTypes.PlanProduct && !order.originEnrollmentId,
+      );
+      if (planItems.length > 0) {
+        await createEnrollmentFromCheckoutService.bind(this)(order, {
+          items: planItems,
+          context: {
+            paymentContext,
+            deliveryContext,
+          },
+        });
+      }
+
+      // Quotations: If we came here, the checkout succeeded, so we can fullfill underlying quotations
+      const quotationItems = mappedProductOrderPositions.filter(
+        (item) => item.orderPosition.quotationId,
+      );
+      await Promise.all(
+        quotationItems.map(async ({ orderPosition }) => {
+          const quotation = await this.quotations.findQuotation({
+            quotationId: orderPosition.quotationId,
+          });
+          await fullfillQuotationService.bind(this)(quotation, {
+            orderId,
+            orderPositionId: orderPosition._id,
+          });
+        }),
+      );
+    }
+
+    nextStatus = await findNextStatus(nextStatus, order, this);
+  }
+
+  return this.orders.updateStatus(order._id, { status: nextStatus, info: comment });
+}

package/src/services/processQuotation.ts

@@ -0,0 +1,75 @@
+import { Quotation, QuotationStatus } from '@unchainedshop/core-quotations';
+import { Modules } from '../modules.js';
+import { QuotationDirector } from '../core-index.js';
+
+const findNextStatus = async (quotation: Quotation, modules: Modules): Promise<QuotationStatus> => {
+  let status = quotation.status as QuotationStatus;
+  const director = await QuotationDirector.actions({ quotation }, { modules });
+
+  if (status === QuotationStatus.REQUESTED) {
+    if (!(await director.isManualRequestVerificationRequired())) {
+      status = QuotationStatus.PROCESSING;
+    }
+  }
+  if (status === QuotationStatus.PROCESSING) {
+    if (!(await director.isManualProposalRequired())) {
+      status = QuotationStatus.PROPOSED;
+    }
+  }
+  return status;
+};
+
+export async function processQuotationService(
+  this: Modules,
+  initialQuotation: Quotation,
+  params: { quotationContext?: any },
+) {
+  const quotationId = initialQuotation._id;
+  let quotation = initialQuotation;
+  let nextStatus = await findNextStatus(quotation, this);
+  const director = await QuotationDirector.actions({ quotation }, { modules: this });
+
+  if (quotation.status === QuotationStatus.REQUESTED && nextStatus !== QuotationStatus.REQUESTED) {
+    await director.submitRequest(params.quotationContext);
+  }
+
+  quotation = await this.quotations.findQuotation({ quotationId });
+  nextStatus = await findNextStatus(quotation, this);
+  if (nextStatus !== QuotationStatus.PROCESSING) {
+    await director.verifyRequest(params.quotationContext);
+  }
+
+  quotation = await this.quotations.findQuotation({ quotationId });
+  nextStatus = await findNextStatus(quotation, this);
+  if (nextStatus === QuotationStatus.REJECTED) {
+    await director.rejectRequest(params.quotationContext);
+  }
+
+  quotation = await this.quotations.findQuotation({ quotationId });
+  nextStatus = await findNextStatus(quotation, this);
+  if (nextStatus === QuotationStatus.PROPOSED) {
+    const proposal = await director.quote();
+    quotation = await this.quotations.updateProposal(quotation._id, proposal);
+    nextStatus = await findNextStatus(quotation, this);
+  }
+
+  const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
+    status: nextStatus,
+    info: 'quotation processed',
+  });
+
+  const user = await this.users.findUserById(updatedQuotation.userId);
+  const locale = this.users.userLocale(user);
+
+  await this.worker.addWork({
+    type: 'MESSAGE',
+    retries: 0,
+    input: {
+      locale,
+      template: 'QUOTATION_STATUS',
+      quotationId: updatedQuotation._id,
+    },
+  });
+
+  return updatedQuotation;
+}

package/src/services/proposeQuotation.ts

@@ -0,0 +1,18 @@
+import { Quotation, QuotationStatus } from '@unchainedshop/core-quotations';
+import { Modules } from '../modules.js';
+import { processQuotationService } from './processQuotation.js';
+
+export async function proposeQuotationService(
+  this: Modules,
+  quotation: Quotation,
+  { quotationContext }: { quotationContext?: any },
+) {
+  if (quotation.status !== QuotationStatus.PROCESSING) return quotation;
+
+  const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
+    status: QuotationStatus.PROPOSED,
+    info: 'proposed manually',
+  });
+
+  return processQuotationService.bind(this)(updatedQuotation, { quotationContext });
+}

package/src/services/registerPaymentCredentials.ts

@@ -0,0 +1,30 @@
+import { PaymentCredentials } from '@unchainedshop/core-payment';
+import { PaymentContext } from '../directors/PaymentAdapter.js';
+import { PaymentDirector } from '../directors/PaymentDirector.js';
+import { Modules } from '../modules.js';
+
+export async function registerPaymentCredentialsService(
+  this: Modules,
+  paymentProviderId: string,
+  paymentContext: PaymentContext,
+): Promise<PaymentCredentials> {
+  const paymentProvider = await this.payment.paymentProviders.findProvider({
+    paymentProviderId,
+  });
+  const actions = await PaymentDirector.actions(paymentProvider, paymentContext, { modules: this });
+  const registration = await actions.register();
+
+  if (!registration) return null;
+
+  const paymentCredentialsId = await this.payment.paymentCredentials.upsertCredentials({
+    userId: paymentContext.userId,
+    paymentProviderId,
+    ...registration,
+  });
+
+  return this.payment.paymentCredentials.findPaymentCredential({
+    paymentCredentialsId,
+    userId: paymentContext.userId,
+    paymentProviderId,
+  });
+}

package/src/services/rejectOrder.ts

@@ -0,0 +1,26 @@
+import { Order, OrderStatus } from '@unchainedshop/core-orders';
+import { Modules } from '../modules.js';
+import { processOrderService } from './processOrder.js';
+
+export async function rejectOrderService(
+  this: Modules,
+  order: Order,
+  transactionContext: {
+    paymentContext?: any;
+    deliveryContext?: any;
+    comment?: string;
+    nextStatus?: OrderStatus;
+  },
+) {
+  if (order.status !== OrderStatus.PENDING) return order;
+
+  const lock = await this.orders.acquireLock(order._id, 'confirm-reject', 1500);
+  try {
+    return await processOrderService.bind(this)(order, {
+      ...transactionContext,
+      nextStatus: OrderStatus.REJECTED,
+    });
+  } finally {
+    await lock.release();
+  }
+}

package/src/services/rejectQuotation.ts

@@ -0,0 +1,18 @@
+import { Quotation, QuotationStatus } from '@unchainedshop/core-quotations';
+import { Modules } from '../modules.js';
+import { processQuotationService } from './processQuotation.js';
+
+export async function rejectQuotationService(
+  this: Modules,
+  quotation: Quotation,
+  { quotationContext }: { quotationContext?: any },
+) {
+  if (quotation.status === QuotationStatus.FULLFILLED) return quotation;
+
+  const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
+    status: QuotationStatus.REJECTED,
+    info: 'rejected manually',
+  });
+
+  return processQuotationService.bind(this)(updatedQuotation, { quotationContext });
+}

package/src/services/removeFiles.ts

@@ -0,0 +1,25 @@
+import { getFileAdapter } from '@unchainedshop/core-files';
+import { Modules } from '../modules.js';
+
+export async function removeFilesService(this: Modules, { fileIds }: { fileIds: Array<string> }) {
+  if (fileIds && typeof fileIds !== 'string' && !Array.isArray(fileIds))
+    throw Error('Media id/s to be removed not provided as a string or array');
+
+  const fileUploadAdapter = getFileAdapter();
+
+  const fileObjects = await this.files.findFiles({
+    _id: { $in: fileIds },
+  });
+
+  try {
+    await fileUploadAdapter.removeFiles(fileObjects, { modules: this });
+  } catch (e) {
+    console.warn(e); // eslint-disable-line
+  }
+
+  const fileIdsToDelete = fileObjects.map((f) => f._id).filter(Boolean);
+
+  await this.files.deleteMany(fileIdsToDelete);
+
+  return fileIdsToDelete.length;
+}

package/src/services/removeProduct.ts

@@ -0,0 +1,34 @@
+import { ProductStatus } from '@unchainedshop/core-products';
+import { updateCalculationService } from './updateCalculation.js';
+import { Modules } from '../modules.js';
+
+export async function removeProductService(
+  this: Modules,
+  { productId }: { productId: string },
+): Promise<boolean> {
+  const product = await this.products.findProduct({ productId });
+  switch (product.status) {
+    case ProductStatus.ACTIVE:
+      await this.products.unpublish(product);
+    // falls through
+    case null:
+    case ProductStatus.DRAFT:
+      {
+        await this.bookmarks.deleteByProductId(productId);
+        await this.assortments.products.delete(productId);
+        const orderIdsToRecalculate =
+          await this.orders.positions.removeProductByIdFromAllOpenPositions(productId);
+        await Promise.all(
+          [...new Set(orderIdsToRecalculate)].map(async (orderIdToRecalculate) => {
+            await updateCalculationService.bind(this)(orderIdToRecalculate);
+          }),
+        );
+        await this.products.delete(productId);
+      }
+      break;
+    default:
+      throw new Error(`Invalid status', ${product.status}`);
+  }
+
+  return true;
+}

package/src/services/searchAssortments.ts

@@ -0,0 +1,58 @@
+import { Assortment } from '@unchainedshop/core-assortments';
+import {
+  defaultAssortmentSelector,
+  defaultFilterSelector,
+  defaultSortStage,
+  SearchConfiguration,
+  SearchQuery,
+} from '@unchainedshop/core-filters';
+import { mongodb } from '@unchainedshop/mongodb';
+import { Modules } from '../modules.js';
+import { FilterDirector } from '../directors/index.js';
+export interface SearchAssortmentConfiguration extends SearchConfiguration {
+  assortmentSelector: mongodb.Filter<Assortment>;
+}
+
+export async function searchAssortmentsService(
+  this: Modules,
+  searchQuery: SearchQuery,
+  { forceLiveCollection }: { forceLiveCollection?: boolean },
+) {
+  const filterActions = await FilterDirector.actions({ searchQuery }, { modules: this });
+
+  const filterSelector = await filterActions.transformFilterSelector(defaultFilterSelector(searchQuery));
+  const assortmentSelector = defaultAssortmentSelector(searchQuery);
+  const sortStage = await filterActions.transformSortStage(defaultSortStage(searchQuery));
+
+  const searchConfiguration: SearchAssortmentConfiguration = {
+    searchQuery,
+    filterSelector,
+    assortmentSelector,
+    sortStage,
+    forceLiveCollection,
+  };
+
+  const assortmentIds = await searchQuery.assortmentIds;
+
+  const totalAssortmentIds =
+    (await filterActions.searchAssortments({ assortmentIds }, searchConfiguration)) || [];
+
+  return {
+    searchConfiguration,
+    totalAssortmentIds,
+
+    assortmentsCount: async () =>
+      this.assortments.count({
+        assortmentSelector,
+        assortmentIds: totalAssortmentIds,
+      }),
+    assortments: async ({ offset, limit }) =>
+      this.assortments.search.findFilteredAssortments({
+        limit,
+        offset,
+        assortmentIds: totalAssortmentIds,
+        assortmentSelector,
+        sort: sortStage,
+      }),
+  };
+}

package/src/services/searchProducts.ts

@@ -0,0 +1,73 @@
+import {
+  defaultFilterSelector,
+  defaultProductSelector,
+  defaultSortStage,
+  SearchConfiguration,
+  SearchQuery,
+} from '@unchainedshop/core-filters';
+import { Product } from '@unchainedshop/core-products';
+import { mongodb } from '@unchainedshop/mongodb';
+import { Modules } from '../modules.js';
+import { FilterDirector } from '../directors/index.js';
+export interface SearchProductConfiguration extends SearchConfiguration {
+  productSelector: mongodb.Filter<Product>;
+}
+
+export async function searchProductsService(
+  this: Modules,
+  searchQuery: SearchQuery,
+  { forceLiveCollection }: { forceLiveCollection?: boolean },
+) {
+  const filterActions = await FilterDirector.actions({ searchQuery }, { modules: this });
+
+  const filterSelector = await filterActions.transformFilterSelector(defaultFilterSelector(searchQuery));
+  const productSelector = await filterActions.transformProductSelector(
+    defaultProductSelector(searchQuery, { modules: this }),
+    {},
+  );
+  const sortStage = await filterActions.transformSortStage(defaultSortStage(searchQuery));
+
+  const searchConfiguration: SearchProductConfiguration = {
+    searchQuery,
+    filterSelector,
+    productSelector,
+    sortStage,
+    forceLiveCollection,
+  };
+
+  if (searchQuery.productIds?.length === 0) {
+    // Restricted to an empty array of products
+    // will always lead to an empty result
+    return {
+      searchConfiguration,
+      aggregatedTotalProductIds: [],
+      aggregatedFilteredProductIds: [],
+      totalProductIds: [],
+    };
+  }
+
+  const productIds = await searchQuery.productIds;
+  const totalProductIds =
+    (await filterActions.searchProducts({ productIds }, searchConfiguration)) || [];
+
+  const filteredProductIds = await FilterDirector.productFacetedSearch(
+    totalProductIds,
+    searchConfiguration,
+    { modules: this },
+  );
+
+  const aggregatedTotalProductIds = filterActions.aggregateProductIds({
+    productIds: totalProductIds,
+  });
+
+  const aggregatedFilteredProductIds = filterActions.aggregateProductIds({
+    productIds: filteredProductIds,
+  });
+
+  return {
+    searchConfiguration,
+    totalProductIds,
+    aggregatedTotalProductIds,
+    aggregatedFilteredProductIds,
+  };
+}

package/src/services/supportedDeliveryProviders.ts

@@ -0,0 +1,24 @@
+import { DeliveryProvider, deliverySettings } from '@unchainedshop/core-delivery';
+import { Modules } from '../modules.js';
+import { DeliveryContext, DeliveryDirector } from '../directors/index.js';
+
+export async function supportedDeliveryProvidersService(this: Modules, params: DeliveryContext) {
+  const allProviders = await this.delivery.findProviders({});
+
+  const providers = (
+    await Promise.all(
+      allProviders.map(async (provider: DeliveryProvider) => {
+        const adapter = await DeliveryDirector.actions(provider, params, { modules: this });
+        return adapter.isActive() ? [provider] : [];
+      }),
+    )
+  ).flat();
+
+  return deliverySettings.filterSupportedProviders(
+    {
+      providers,
+      order: params.order,
+    },
+    { modules: this },
+  );
+}

package/src/services/supportedPaymentProviders.ts

@@ -0,0 +1,25 @@
+import { PaymentProvider, paymentSettings } from '@unchainedshop/core-payment';
+import { PaymentDirector } from '../directors/PaymentDirector.js';
+import { PaymentContext } from '../directors/PaymentAdapter.js';
+import { Modules } from '../modules.js';
+
+export async function supportedPaymentProvidersService(this: Modules, params: PaymentContext) {
+  const allProviders = await this.payment.paymentProviders.findProviders({});
+
+  const providers = (
+    await Promise.all(
+      allProviders.map(async (provider: PaymentProvider) => {
+        const adapter = await PaymentDirector.actions(provider, params, { modules: this });
+        return adapter.isActive() ? [provider] : [];
+      }),
+    )
+  ).flat();
+
+  return paymentSettings.filterSupportedProviders(
+    {
+      providers,
+      order: params.order,
+    },
+    { modules: this },
+  );
+}

package/src/services/supportedWarehousingProviders.ts

@@ -0,0 +1,18 @@
+import { WarehousingProvider } from '@unchainedshop/core-warehousing';
+import { WarehousingContext, WarehousingDirector } from '../directors/index.js';
+import { Modules } from '../modules.js';
+
+export async function supportedWarehousingProvidersService(this: Modules, params: WarehousingContext) {
+  const allProviders = await this.warehousing.findProviders({});
+
+  const providers = (
+    await Promise.all(
+      allProviders.map(async (provider: WarehousingProvider) => {
+        const adapter = await WarehousingDirector.actions(provider, params, { modules: this });
+        return adapter.isActive() ? [provider] : [];
+      }),
+    )
+  ).flat();
+
+  return providers;
+}