@unchainedshop/core 4.3.5 → 4.4.0

package/src/services/loadFilters.ts

@@ -1,60 +0,0 @@
-import { SearchQuery, defaultFilterSelector } from '@unchainedshop/core-filters';
-import { Modules } from '../modules.js';
-import { FilterDirector } from '../directors/FilterDirector.js';
-
-export async function loadFiltersService(
-  this: Modules,
-  searchQuery: SearchQuery,
-  options: {
-    productIds: string[];
-    forceLiveCollection?: boolean;
-    locale?: Intl.Locale;
-    userId?: string;
-  },
-) {
-  const filterActions = await FilterDirector.actions({ searchQuery }, { modules: this });
-  const filterSelector = await filterActions.transformFilterSelector(
-    defaultFilterSelector(searchQuery),
-    options,
-  );
-
-  if (!filterSelector) return [];
-
-  const otherFilters = await this.filters.findFilters({
-    ...filterSelector,
-    limit: 0,
-    includeInactive: true,
-  });
-
-  const extractedFilterIds = (filterSelector?._id as any)?.$in || [];
-  const sortedFilters = otherFilters.toSorted((left, right) => {
-    const leftIndex = extractedFilterIds.indexOf(left._id);
-    const rightIndex = extractedFilterIds.indexOf(right._id);
-    return leftIndex - rightIndex;
-  });
-
-  return Promise.all(
-    sortedFilters.map(async (filter) => {
-      const { examinedProductIdSet, filteredByOtherFiltersSet, filteredByThisFilterSet } =
-        await FilterDirector.filterFacets(
-          filter,
-          {
-            searchQuery,
-            forceLiveCollection: !!options.forceLiveCollection,
-            allProductIds: options.productIds,
-            otherFilters: sortedFilters,
-          },
-          { modules: this },
-        );
-
-      return {
-        forceLiveCollection: !!options.forceLiveCollection,
-        searchQuery,
-        filter,
-        examinedProductIdSet,
-        filteredByOtherFiltersSet,
-        filteredByThisFilterSet,
-      };
-    }),
-  );
-}

package/src/services/migrateBookmarks.ts

@@ -1,39 +0,0 @@
-import { Modules } from '../modules.js';
-
-const hashBookmark = (bookmark) => {
-  return `${bookmark.productId}:${bookmark.userId}:${JSON.stringify(bookmark.meta || {})}`;
-};
-
-export async function migrateBookmarksService(
-  this: Modules,
-  {
-    fromUserId,
-    toUserId,
-    shouldMerge,
-  }: {
-    fromUserId: string;
-    toUserId: string;
-    shouldMerge: boolean;
-    countryCode: string;
-  },
-) {
-  const fromBookmarks = await this.bookmarks.findBookmarks({ userId: fromUserId });
-  if (!fromBookmarks) {
-    // No bookmarks no copy needed
-    return;
-  }
-  if (!shouldMerge) {
-    await this.bookmarks.deleteByUserId(toUserId);
-    await this.bookmarks.replaceUserId(fromUserId, toUserId);
-  } else {
-    const toBookmarks = await this.bookmarks.findBookmarks({ userId: toUserId });
-    const toBookmarkHashes = toBookmarks.map(hashBookmark);
-    const newBookmarkIds = fromBookmarks
-      .filter((fromBookmark) => {
-        const hash = hashBookmark(fromBookmark);
-        return !toBookmarkHashes.includes(hash);
-      })
-      .map((bookmark) => bookmark._id);
-    await this.bookmarks.replaceUserId(fromUserId, toUserId, newBookmarkIds);
-  }
-}

package/src/services/migrateOrderCart.ts

@@ -1,52 +0,0 @@
-import { updateCalculationService } from './updateCalculation.js';
-import { Modules } from '../modules.js';
-
-export async function migrateOrderCartsService(
-  this: Modules,
-  {
-    fromUserId,
-    toUserId,
-    shouldMerge,
-    countryCode,
-  }: {
-    fromUserId: string;
-    toUserId: string;
-    shouldMerge: boolean;
-    countryCode: string;
-  },
-) {
-  const fromCart = await this.orders.cart({
-    countryCode,
-    userId: fromUserId,
-  });
-  const toCart = await this.orders.cart({
-    countryCode,
-    userId: toUserId,
-  });
-
-  if (!fromCart) {
-    // No cart, don't copy
-    return toCart;
-  }
-
-  if (!toCart || !shouldMerge) {
-    // No destination cart, move whole cart
-    this.orders.setCartOwner({ orderId: fromCart._id, userId: toUserId });
-    return updateCalculationService.bind(this)(fromCart._id);
-  }
-
-  // Move positions
-  this.orders.moveCartPositions({ fromOrderId: fromCart._id, toOrderId: toCart._id });
-
-  // Move billing address if target order has none
-  if (fromCart.billingAddress && !toCart.billingAddress) {
-    await this.orders.updateBillingAddress(toCart._id, fromCart.billingAddress);
-  }
-
-  // Move contact data if target order has none
-  if (fromCart.contact && !toCart.contact) {
-    await this.orders.updateContact(toCart._id, fromCart.contact);
-  }
-
-  return updateCalculationService.bind(this)(toCart._id);
-}

package/src/services/migrateUserData.ts

@@ -1,22 +0,0 @@
-import { userSettings } from '@unchainedshop/core-users';
-import { migrateBookmarksService } from './migrateBookmarks.js';
-import { migrateOrderCartsService } from './migrateOrderCart.js';
-
-export async function migrateUserDataService(userIdBeforeLogin: string, userId: string) {
-  const user = await this.users.findUserById(userId);
-  const userBeforeLogin = await this.users.findUserById(userIdBeforeLogin);
-
-  await migrateOrderCartsService.bind(this)({
-    fromUserId: userIdBeforeLogin,
-    toUserId: userId,
-    shouldMerge: userSettings.mergeUserCartsOnLogin,
-    countryCode: userBeforeLogin?.lastLogin?.countryCode || user?.lastLogin?.countryCode,
-  });
-
-  await migrateBookmarksService.bind(this)({
-    fromUserId: userIdBeforeLogin,
-    toUserId: userId,
-    shouldMerge: userSettings.mergeUserCartsOnLogin,
-    countryCode: userBeforeLogin?.lastLogin?.countryCode || user?.lastLogin?.countryCode,
-  });
-}

package/src/services/nextUserCart.ts

@@ -1,52 +0,0 @@
-import { resolveBestCurrency } from '@unchainedshop/utils';
-import { User } from '@unchainedshop/core-users';
-import { ordersSettings } from '@unchainedshop/core-orders';
-import { initCartProvidersService } from './initCartProviders.js';
-import { Modules } from '../modules.js';
-
-export async function nextUserCartService(
-  this: Modules,
-  {
-    user,
-    orderNumber,
-    countryCode,
-    forceCartCreation,
-  }: {
-    user: User;
-    orderNumber?: string;
-    countryCode: string;
-    forceCartCreation?: boolean;
-  },
-) {
-  const cart = await this.orders.cart({
-    countryCode,
-    orderNumber,
-    userId: user._id,
-  });
-  if (cart) return cart;
-
-  const shouldCreateNewCart = forceCartCreation || ordersSettings.ensureUserHasCart;
-  if (!shouldCreateNewCart) return null;
-
-  const countryObject = await this.countries.findCountry({ isoCode: countryCode });
-  const currencies = await this.currencies.findCurrencies({ includeInactive: false });
-  const currencyCode = resolveBestCurrency(countryObject?.defaultCurrencyCode || null, currencies);
-
-  const order = await this.orders.create({
-    userId: user._id,
-    orderNumber,
-    currencyCode,
-    countryCode,
-    billingAddress: user.lastBillingAddress || user.profile?.address,
-    contact:
-      user.lastContact ||
-      (!user.guest
-        ? {
-            telNumber: user.profile?.phoneMobile,
-            emailAddress: this.users.primaryEmail(user)?.address,
-          }
-        : {}),
-  });
-
-  return initCartProvidersService.bind(this)(order);
-}

package/src/services/processEnrollment.ts

@@ -1,49 +0,0 @@
-import { Enrollment, EnrollmentStatus } from '@unchainedshop/core-enrollments';
-import { Modules } from '../modules.js';
-import { EnrollmentDirector } from '../core-index.js';
-
-const findNextStatus = async (
-  enrollment: Enrollment,
-  modules: Modules,
-): Promise<EnrollmentStatus | null> => {
-  let status = enrollment.status;
-  const product = await modules.products.findProduct({
-    productId: enrollment.productId,
-  });
-
-  if (!product) throw new Error('Product not found for enrollment');
-
-  const director = await EnrollmentDirector.actions({ enrollment, product }, { modules });
-
-  if (status === EnrollmentStatus.INITIAL || status === EnrollmentStatus.PAUSED) {
-    if (await director.isValidForActivation()) {
-      status = EnrollmentStatus.ACTIVE;
-    }
-  } else if (status === EnrollmentStatus.ACTIVE) {
-    if (await director.isOverdue()) {
-      status = EnrollmentStatus.PAUSED;
-    }
-  } else if (modules.enrollments.isExpired(enrollment, {})) {
-    status = EnrollmentStatus.TERMINATED;
-  }
-
-  return status;
-};
-
-export async function processEnrollmentService(this: Modules, enrollment: Enrollment) {
-  const status = await findNextStatus(enrollment, this);
-
-  if (status === EnrollmentStatus.ACTIVE) {
-    // const nextEnrollment = await reactivateEnrollment(enrollment);
-    // TODO: Reactivate!
-    // status = await findNextStatus(nextEnrollment, unchainedAPI);
-  }
-
-  if (status) {
-    return this.enrollments.updateStatus(enrollment._id, {
-      status,
-      info: 'enrollment processed',
-    }) as Promise<Enrollment>;
-  }
-  return enrollment;
-}

package/src/services/processOrder.ts

@@ -1,243 +0,0 @@
-import {
-  Order,
-  OrderDelivery,
-  OrderDeliveryStatus,
-  OrderPayment,
-  OrderPaymentStatus,
-  OrderPosition,
-  OrderStatus,
-} from '@unchainedshop/core-orders';
-import { Modules } from '../modules.js';
-import { createEnrollmentFromCheckoutService } from './createEnrollmentFromCheckout.js';
-import { Product, 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 paymentProvider = await modules.payment.paymentProviders.findProvider({
-      paymentProviderId: orderPayment.paymentProviderId,
-    });
-    if (!paymentProvider)
-      throw new Error('Payment provider not found: ' + orderPayment.paymentProviderId);
-    const actions = await PaymentDirector.actions(paymentProvider, {}, { modules });
-    if (!actions.isPayLaterAllowed()) return false;
-  }
-
-  if (orderDelivery.status !== OrderDeliveryStatus.DELIVERED) {
-    const deliveryProvider = await modules.delivery.findProvider({
-      deliveryProviderId: orderDelivery.deliveryProviderId,
-    });
-    if (!deliveryProvider)
-      throw new Error('Delivery provider not found: ' + 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 =
-    order.paymentId &&
-    (await modules.orders.payments.findOrderPayment({
-      orderPaymentId: order.paymentId,
-    }));
-  if (!orderPayment) return status;
-
-  const orderDelivery =
-    order.deliveryId &&
-    (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
-    await PaymentDirector.chargeOrderPayment(
-      order,
-      { userId: order.userId, transactionContext: paymentContext },
-      { modules: this },
-    );
-    nextStatus = await findNextStatus(nextStatus, order, this);
-  }
-
-  if (nextStatus === OrderStatus.REJECTED) {
-    // auto cancel during transition to rejected
-    await PaymentDirector.cancelOrderPayment(
-      order,
-      { userId: order.userId, transactionContext: paymentContext },
-      { modules: this },
-    );
-  }
-
-  if (nextStatus === OrderStatus.CONFIRMED) {
-    // confirm pre-authorized payments
-    await PaymentDirector.confirmOrderPayment(
-      order,
-      { 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,
-      })) as Order;
-
-      // TODO: What happens if this THROWS?
-      // Tokenization would be skipped?
-      // Enrollments will not be there?
-      // Quotations would not fulfil?
-      await DeliveryDirector.sendOrderDelivery(order, 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,
-          })) as Product;
-          return {
-            orderPosition,
-            product,
-          };
-        }),
-      );
-      const tokenizedItems = mappedProductOrderPositions.filter(
-        (item) => item.product?.type === ProductTypes.TokenizedProduct,
-      ) as { orderPosition: OrderPosition; product: Product }[];
-
-      if (tokenizedItems.length > 0) {
-        // Give virtual warehouse a chance to instantiate new virtual objects
-        const virtualProviders = (await this.warehousing.allProviders()).filter(
-          ({ type }) => 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 tokenSerialNumber
-        // 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,
-      ) as { orderPosition: OrderPosition & { quotationId: string }; product: Product }[];
-
-      await Promise.all(
-        quotationItems.map(async ({ orderPosition }) => {
-          const quotation = await this.quotations.findQuotation({
-            quotationId: orderPosition.quotationId,
-          });
-          if (!quotation) return; // TODO: What happens then?
-          await fullfillQuotationService.bind(this)(quotation, {
-            orderId,
-            orderPositionId: orderPosition._id,
-          });
-        }),
-      );
-    }
-
-    nextStatus = await findNextStatus(nextStatus, order, this);
-  }
-
-  return (await this.orders.updateStatus(order._id, { status: nextStatus, info: comment })) as Order;
-}

package/src/services/processQuotation.ts

@@ -1,71 +0,0 @@
-import { Quotation, QuotationStatus } from '@unchainedshop/core-quotations';
-import { Modules } from '../modules.js';
-import { QuotationDirector } from '../core-index.js';
-import { addMessageService } from './addMessage.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 })) as Quotation;
-  nextStatus = await findNextStatus(quotation, this);
-  if (nextStatus !== QuotationStatus.PROCESSING) {
-    await director.verifyRequest(params.quotationContext);
-  }
-
-  quotation = (await this.quotations.findQuotation({ quotationId })) as Quotation;
-  nextStatus = await findNextStatus(quotation, this);
-  if (nextStatus === QuotationStatus.REJECTED) {
-    await director.rejectRequest(params.quotationContext);
-  }
-
-  quotation = (await this.quotations.findQuotation({ quotationId })) as Quotation;
-  nextStatus = await findNextStatus(quotation, this);
-  if (nextStatus === QuotationStatus.PROPOSED) {
-    const proposal = await director.quote();
-    quotation = (await this.quotations.updateProposal(quotation._id, proposal)) as Quotation;
-    nextStatus = await findNextStatus(quotation, this);
-  }
-
-  const updatedQuotation = (await this.quotations.updateStatus(quotation._id, {
-    status: nextStatus,
-    info: 'quotation processed',
-  })) as Quotation;
-
-  const user = await this.users.findUserById(updatedQuotation.userId);
-  const locale = this.users.userLocale(user);
-
-  await addMessageService.bind(this)('QUOTATION_STATUS', {
-    locale: locale.baseName,
-    quotationId: updatedQuotation._id,
-  });
-
-  return updatedQuotation;
-}

package/src/services/proposeQuotation.ts

@@ -1,18 +0,0 @@
-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',
-  })) as Quotation;
-
-  return processQuotationService.bind(this)(updatedQuotation, { quotationContext });
-}

package/src/services/registerPaymentCredentials.ts

@@ -1,28 +0,0 @@
-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,
-) {
-  const paymentProvider = await this.payment.paymentProviders.findProvider({
-    paymentProviderId,
-  });
-
-  if (!paymentProvider) return null;
-
-  const actions = await PaymentDirector.actions(paymentProvider, paymentContext, { modules: this });
-  const registration = await actions.register();
-
-  if (!registration) return null;
-
-  const paymentCredentials = await this.payment.paymentCredentials.upsertCredentials({
-    userId: paymentContext.userId,
-    paymentProviderId,
-    ...registration,
-  });
-
-  return paymentCredentials;
-}

package/src/services/rejectOrder.ts

@@ -1,26 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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',
-  })) as Quotation;
-
-  return processQuotationService.bind(this)(updatedQuotation, { quotationContext });
-}