@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc10

package/src/services/index.ts

@@ -0,0 +1,168 @@
+import { Modules } from '../modules.js';
+import { migrateUserDataService } from './migrateUserData.js';
+import { updateUserAvatarAfterUploadService } from './updateUserAvatarAfterUpload.js';
+import { linkFileService } from './linkFileService.js';
+import { createSignedURLService } from './createSignedURL.js';
+import { uploadFileFromURLService } from './uploadFileFromURL.js';
+import { uploadFileFromStreamService } from './uploadFileFromStream.js';
+import { removeFilesService } from './removeFiles.js';
+import { createDownloadStreamService } from './createDownloadStream.js';
+import { migrateBookmarksService } from './migrateBookmarks.js';
+import { migrateOrderCartsService } from './migrateOrderCart.js';
+import { nextUserCartService } from './nextUserCart.js';
+import { removeProductService } from './removeProduct.js';
+import { initCartProvidersService } from './initCartProviders.js';
+import { updateCalculationService } from './updateCalculation.js';
+import { supportedDeliveryProvidersService } from './supportedDeliveryProviders.js';
+import { deleteUserService } from './deleteUser.js';
+import { supportedPaymentProvidersService } from './supportedPaymentProviders.js';
+import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
+import { createEnrollmentFromCheckoutService } from './createEnrollmentFromCheckout.js';
+import { searchAssortmentsService } from './searchAssortments.js';
+import { searchProductsService } from './searchProducts.js';
+import { calculateDiscountTotalService } from './calculateDiscountTotal.js';
+import { registerPaymentCredentialsService } from './registerPaymentCredentials.js';
+import { processOrderService } from './processOrder.js';
+import { checkoutOrderService } from './checkoutOrder.js';
+import { confirmOrderService } from './confirmOrder.js';
+import { rejectOrderService } from './rejectOrder.js';
+import { discountedEntitiesService } from './discountedEntities.js';
+import { createManualOrderDiscountService } from './createManualOrderDiscount.js';
+import { initializeEnrollmentService } from './initializeEnrollment.js';
+import { activateEnrollmentService } from './activateEnrollment.js';
+import { terminateEnrollmentService } from './terminateEnrollment.js';
+import { invalidateFilterCacheService } from './invalidateFilterCache.js';
+import { fullfillQuotationService } from './fullfillQuotation.js';
+import { processQuotationService } from './processQuotation.js';
+import { proposeQuotationService } from './proposeQuotation.js';
+import { rejectQuotationService } from './rejectQuotation.js';
+import { verifyQuotationService } from './verifyQuotation.js';
+import { loadFiltersService } from './loadFilters.js';
+import { loadFilterOptionsService } from './loadFilterOptions.js';
+import { ercMetadataService } from './ercMetadata.js';
+import { simulateProductPricingService } from './simulateProductPricing.js';
+import { simulateProductDispatchingService } from './simulateProductDispatching.js';
+import { simulateProductInventoryService } from './simulateProductInventory.js';
+import { findOrInitCartService } from './findOrInitCart.js';
+
+// TODO: Auto-Inject Unchained API as last parameter
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
+
+function bindMethodsToModules(modules: Modules) {
+  return {
+    get(target, prop, receiver) {
+      const value = target[prop];
+      if (value instanceof Function) {
+        return value.bind(modules);
+      } else if (value instanceof Object) {
+        return new Proxy(value, bindMethodsToModules(modules));
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+  };
+}
+
+export interface ServiceInterface {
+  (this: Modules, ...args: any[]): any;
+}
+
+export type Bound<T extends ServiceInterface> = OmitThisParameter<T>;
+
+export default function initServices(
+  modules: Modules,
+  customServices: Record<string, ServiceInterface> = {},
+) {
+  const services = {
+    bookmarks: {
+      migrateBookmarks: migrateBookmarksService as Bound<typeof migrateBookmarksService>,
+    },
+    files: {
+      linkFile: linkFileService as Bound<typeof linkFileService>,
+      createSignedURL: createSignedURLService as Bound<typeof createSignedURLService>,
+      uploadFileFromURL: uploadFileFromURLService as Bound<typeof uploadFileFromURLService>,
+      uploadFileFromStream: uploadFileFromStreamService as Bound<typeof uploadFileFromStreamService>,
+      removeFiles: removeFilesService as Bound<typeof removeFilesService>,
+      createDownloadStream: createDownloadStreamService as Bound<typeof createDownloadStreamService>,
+    },
+    orders: {
+      registerPaymentCredentials: registerPaymentCredentialsService as Bound<
+        typeof registerPaymentCredentialsService
+      >,
+      calculateDiscountTotal: calculateDiscountTotalService as Bound<
+        typeof calculateDiscountTotalService
+      >,
+      migrateOrderCarts: migrateOrderCartsService as Bound<typeof migrateOrderCartsService>,
+      nextUserCart: nextUserCartService as Bound<typeof nextUserCartService>,
+      findOrInitCart: findOrInitCartService as Bound<typeof findOrInitCartService>,
+      initCartProviders: initCartProvidersService as Bound<typeof initCartProvidersService>,
+      updateCalculation: updateCalculationService as Bound<typeof updateCalculationService>,
+      supportedDeliveryProviders: supportedDeliveryProvidersService as Bound<
+        typeof supportedDeliveryProvidersService
+      >,
+      supportedPaymentProviders: supportedPaymentProvidersService as Bound<
+        typeof supportedPaymentProvidersService
+      >,
+      supportedWarehousingProviders: supportedWarehousingProvidersService as Bound<
+        typeof supportedWarehousingProvidersService
+      >,
+      processOrder: processOrderService as Bound<typeof processOrderService>,
+      checkoutOrder: checkoutOrderService as Bound<typeof checkoutOrderService>,
+      confirmOrder: confirmOrderService as Bound<typeof confirmOrderService>,
+      rejectOrder: rejectOrderService as Bound<typeof rejectOrderService>,
+      discountedEntities: discountedEntitiesService as Bound<typeof discountedEntitiesService>,
+      createManualOrderDiscount: createManualOrderDiscountService as Bound<
+        typeof createManualOrderDiscountService
+      >,
+    },
+    products: {
+      simulateProductPricing: simulateProductPricingService as Bound<
+        typeof simulateProductPricingService
+      >,
+      simulateProductDispatching: simulateProductDispatchingService as Bound<
+        typeof simulateProductDispatchingService
+      >,
+      simulateProductInventory: simulateProductInventoryService as Bound<
+        typeof simulateProductInventoryService
+      >,
+      removeProduct: removeProductService as Bound<typeof removeProductService>,
+    },
+    users: {
+      migrateUserData: migrateUserDataService as Bound<typeof migrateUserDataService>,
+      updateUserAvatarAfterUpload: updateUserAvatarAfterUploadService as Bound<
+        typeof updateUserAvatarAfterUploadService
+      >,
+      deleteUser: deleteUserService as Bound<typeof deleteUserService>,
+    },
+    enrollments: {
+      createEnrollmentFromCheckout: createEnrollmentFromCheckoutService as Bound<
+        typeof createEnrollmentFromCheckoutService
+      >,
+      processEnrollment: processOrderService as Bound<typeof processOrderService>,
+      initializeEnrollment: initializeEnrollmentService as Bound<typeof initializeEnrollmentService>,
+      activateEnrollment: activateEnrollmentService as Bound<typeof activateEnrollmentService>,
+      terminateEnrollment: terminateEnrollmentService as Bound<typeof terminateEnrollmentService>,
+    },
+    quotations: {
+      fullfillQuotation: fullfillQuotationService as Bound<typeof fullfillQuotationService>,
+      processQuotation: processQuotationService as Bound<typeof processQuotationService>,
+      proposeQuotation: proposeQuotationService as Bound<typeof proposeQuotationService>,
+      rejectQuotation: rejectQuotationService as Bound<typeof rejectQuotationService>,
+      verifyQuotation: verifyQuotationService as Bound<typeof verifyQuotationService>,
+    },
+    filters: {
+      searchAssortments: searchAssortmentsService as Bound<typeof searchAssortmentsService>,
+      searchProducts: searchProductsService as Bound<typeof searchProductsService>,
+      invalidateFilterCache: invalidateFilterCacheService as Bound<typeof invalidateFilterCacheService>,
+      loadFilters: loadFiltersService as Bound<typeof loadFiltersService>,
+      loadFilterOptions: loadFilterOptionsService as Bound<typeof loadFilterOptionsService>,
+    },
+    warehousing: {
+      ercMetadata: ercMetadataService as Bound<typeof ercMetadataService>,
+    },
+  };
+
+  // This Proxy Binds all services to the Modules Object
+  return new Proxy<typeof services>({ ...services, ...customServices }, bindMethodsToModules(modules));
+}
+
+export type Services = ReturnType<typeof initServices>;

package/src/services/initCartProviders.ts

@@ -0,0 +1,86 @@
+import { Order } from '@unchainedshop/core-orders';
+import { deliverySettings } from '@unchainedshop/core-delivery';
+import { paymentSettings } from '@unchainedshop/core-payment';
+import { supportedDeliveryProvidersService } from './supportedDeliveryProviders.js';
+import { supportedPaymentProvidersService } from './supportedPaymentProviders.js';
+import { Modules } from '../modules.js';
+
+export async function initCartProvidersService(this: Modules, order: Order) {
+  let updatedOrder = order;
+
+  // Init delivery provider
+  const supportedDeliveryProviders = await supportedDeliveryProvidersService.bind(this)({
+    order: updatedOrder,
+  });
+
+  const orderDelivery = await this.orders.deliveries.findDelivery({
+    orderDeliveryId: updatedOrder.deliveryId,
+  });
+  const deliveryProviderId = orderDelivery?.deliveryProviderId;
+
+  const isAlreadyInitializedWithSupportedDeliveryProvider = supportedDeliveryProviders?.some(
+    (provider) => {
+      return provider._id === deliveryProviderId;
+    },
+  );
+
+  if (supportedDeliveryProviders?.length > 0 && !isAlreadyInitializedWithSupportedDeliveryProvider) {
+    const defaultOrderDeliveryProvider = await deliverySettings.determineDefaultProvider(
+      {
+        providers: supportedDeliveryProviders,
+        order: updatedOrder,
+      },
+      { modules: this },
+    );
+    if (defaultOrderDeliveryProvider) {
+      updatedOrder = await this.orders.setDeliveryProvider(
+        updatedOrder._id,
+        defaultOrderDeliveryProvider._id,
+      );
+    }
+  }
+
+  // Init payment provider
+  const supportedPaymentProviders = await supportedPaymentProvidersService.bind(this)({
+    order: updatedOrder,
+  });
+
+  const orderPayment = await this.orders.payments.findOrderPayment({
+    orderPaymentId: updatedOrder.paymentId,
+  });
+  const paymentProviderId = orderPayment?.paymentProviderId;
+
+  const isAlreadyInitializedWithSupportedPaymentProvider = supportedPaymentProviders?.some(
+    (provider) => {
+      return provider._id === paymentProviderId;
+    },
+  );
+
+  if (supportedPaymentProviders?.length > 0 && !isAlreadyInitializedWithSupportedPaymentProvider) {
+    const paymentCredentials = await this.payment.paymentCredentials.findPaymentCredentials(
+      { userId: updatedOrder.userId, isPreferred: true },
+      {
+        sort: {
+          created: -1,
+        },
+      },
+    );
+
+    const defaultOrderPaymentProvider = await paymentSettings.determineDefaultProvider(
+      {
+        providers: supportedPaymentProviders,
+        order: updatedOrder,
+        paymentCredentials,
+      },
+      { modules: this },
+    );
+
+    if (defaultOrderPaymentProvider) {
+      updatedOrder = await this.orders.setPaymentProvider(
+        updatedOrder._id,
+        defaultOrderPaymentProvider._id,
+      );
+    }
+  }
+  return updatedOrder;
+}

package/src/services/initializeEnrollment.ts

@@ -0,0 +1,38 @@
+import { Enrollment } from '@unchainedshop/core-enrollments';
+import { EnrollmentDirector } from '../core-index.js';
+import { processEnrollmentService } from './processEnrollment.js';
+import { Modules } from '../modules.js';
+
+export async function initializeEnrollmentService(
+  this: Modules,
+  enrollment: Enrollment,
+  params: { orderIdForFirstPeriod?: string; reason: string },
+) {
+  const director = await EnrollmentDirector.actions({ enrollment }, { modules: this });
+  const period = await director.nextPeriod();
+
+  let updatedEnrollment = enrollment;
+  if (period && (params.orderIdForFirstPeriod || period.isTrial)) {
+    updatedEnrollment = await this.enrollments.addEnrollmentPeriod(enrollment._id, {
+      ...period,
+      orderId: params.orderIdForFirstPeriod,
+    });
+  }
+
+  const processedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
+  const user = await this.users.findUserById(enrollment.userId);
+  const locale = this.users.userLocale(user);
+
+  await this.worker.addWork({
+    type: 'MESSAGE',
+    retries: 0,
+    input: {
+      reason: params.reason || 'status_change',
+      locale: locale.baseName,
+      template: 'ENROLLMENT_STATUS',
+      enrollmentId: processedEnrollment._id,
+    },
+  });
+
+  return processedEnrollment;
+}

package/src/services/invalidateFilterCache.ts

@@ -0,0 +1,16 @@
+import { Modules } from '../modules.js';
+import { FilterDirector } from '../core-index.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core');
+
+export async function invalidateFilterCacheService(this: Modules) {
+  logger.debug('Filters: Start invalidating filter caches');
+
+  const filters = await this.filters.findFilters({ includeInactive: true });
+
+  await filters.reduce(async (lastPromise, filter) => {
+    await lastPromise;
+    return FilterDirector.invalidateProductIdCache(filter, { modules: this });
+  }, Promise.resolve(undefined));
+}

package/src/services/linkFileService.ts

@@ -0,0 +1,22 @@
+import { FileDirector } from '@unchainedshop/file-upload';
+import { Modules } from '../modules.js';
+
+export async function linkFileService(
+  this: Modules,
+  { fileId, size, type }: { fileId: string; size: number; type?: string },
+) {
+  const file = await this.files.findFile({ fileId });
+  if (file?.expires) {
+    await this.files.update(file._id, {
+      size: size || file.size,
+      type: type || file.type,
+      expires: null,
+    });
+    const callback = FileDirector.getFileUploadCallback(file.path);
+    if (callback) {
+      await callback(file, { modules: this });
+    }
+    return this.files.findFile({ fileId });
+  }
+  return file;
+}

package/src/services/loadFilterOptions.ts

@@ -0,0 +1,49 @@
+import { FilterType, Filter, SearchQuery } from '@unchainedshop/core-filters';
+import { Modules } from '../modules.js';
+import { FilterDirector, parseQueryArray } from '../directors/FilterDirector.js';
+
+export async function loadFilterOptionsService(
+  this: Modules,
+  filter: Filter,
+  params: {
+    searchQuery: SearchQuery;
+    forceLiveCollection: boolean;
+    productIdSet: Set<string>;
+  },
+) {
+  const { forceLiveCollection, productIdSet, searchQuery } = params;
+
+  const filterQueryParsed = parseQueryArray(searchQuery?.filterQuery);
+  const values = filterQueryParsed[filter.key];
+
+  const allOptions = (filter.type === FilterType.SWITCH && ['true', 'false']) || filter.options || [];
+  const mappedOptions = await Promise.all(
+    allOptions.map(async (value) => {
+      const filterOptionProductIds = await FilterDirector.filterProductIds(
+        filter,
+        {
+          values: [value],
+          forceLiveCollection,
+        },
+        { modules: this },
+      );
+      const filteredProductIdSet = productIdSet.intersection(new Set(filterOptionProductIds));
+
+      const normalizedValues = values && this.filters.parse(filter, values, [value]);
+      const isSelected = normalizedValues && normalizedValues.indexOf(value) !== -1;
+
+      if (!filteredProductIdSet.size && !isSelected) {
+        return null;
+      }
+
+      return {
+        filteredProductIdSet,
+        searchQuery,
+        value,
+        filter,
+        isSelected,
+      };
+    }),
+  );
+  return mappedOptions.filter(Boolean);
+}

package/src/services/loadFilters.ts

@@ -0,0 +1,52 @@
+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,
+  { productIds, forceLiveCollection }: { productIds: Array<string>; forceLiveCollection: boolean },
+) {
+  const filterActions = await FilterDirector.actions({ searchQuery }, { modules: this });
+  const filterSelector = await filterActions.transformFilterSelector(defaultFilterSelector(searchQuery));
+
+  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,
+            allProductIds: productIds,
+            otherFilters: sortedFilters,
+          },
+          { modules: this },
+        );
+
+      return {
+        forceLiveCollection,
+        searchQuery,
+        filter,
+        examinedProductIdSet,
+        filteredByOtherFiltersSet,
+        filteredByThisFilterSet,
+      };
+    }),
+  );
+}

package/src/services/migrateBookmarks.ts

@@ -0,0 +1,39 @@
+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;
+    countryContext: 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

@@ -0,0 +1,52 @@
+import { updateCalculationService } from './updateCalculation.js';
+import { Modules } from '../modules.js';
+
+export async function migrateOrderCartsService(
+  this: Modules,
+  {
+    fromUserId,
+    toUserId,
+    shouldMerge,
+    countryContext,
+  }: {
+    fromUserId: string;
+    toUserId: string;
+    shouldMerge: boolean;
+    countryContext: string;
+  },
+) {
+  const fromCart = await this.orders.cart({
+    countryCode: countryContext,
+    userId: fromUserId,
+  });
+  const toCart = await this.orders.cart({
+    countryCode: countryContext,
+    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

@@ -0,0 +1,22 @@
+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,
+    countryContext: userBeforeLogin.lastLogin?.countryCode || user.lastLogin?.countryCode,
+  });
+
+  await migrateBookmarksService.bind(this)({
+    fromUserId: userIdBeforeLogin,
+    toUserId: userId,
+    shouldMerge: userSettings.mergeUserCartsOnLogin,
+    countryContext: userBeforeLogin.lastLogin?.countryCode || user.lastLogin?.countryCode,
+  });
+}

package/src/services/nextUserCart.ts

@@ -0,0 +1,52 @@
+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 currency = resolveBestCurrency(countryObject.defaultCurrencyCode, currencies);
+
+  const order = await this.orders.create({
+    userId: user._id,
+    orderNumber,
+    currency,
+    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

@@ -0,0 +1,37 @@
+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> => {
+  let status = enrollment.status;
+  const director = await EnrollmentDirector.actions({ enrollment }, { 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);
+  }
+
+  return this.enrollments.updateStatus(enrollment._id, {
+    status,
+    info: 'enrollment processed',
+  });
+}