@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc.12

package/src/services/activateEnrollment.ts

@@ -0,0 +1,30 @@
+import { Enrollment, EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { Modules } from '../modules.js';
+import { processEnrollmentService } from './processEnrollment.js';
+
+export async function activateEnrollmentService(this: Modules, enrollment: Enrollment) {
+  if (enrollment.status === EnrollmentStatus.TERMINATED) return enrollment;
+
+  let updatedEnrollment = await this.enrollments.updateStatus(enrollment._id, {
+    status: EnrollmentStatus.ACTIVE,
+    info: 'activated manually',
+  });
+
+  updatedEnrollment = 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: 'status_change',
+      locale: locale.baseName,
+      template: 'ENROLLMENT_STATUS',
+      enrollmentId: updatedEnrollment._id,
+    },
+  });
+
+  return updatedEnrollment;
+}

package/src/services/calculateDiscountTotal.ts

@@ -0,0 +1,71 @@
+import { Order, OrderDiscount } from '@unchainedshop/core-orders';
+import { Modules } from '../modules.js';
+import {
+  OrderPricingRowCategory,
+  OrderPricingSheet,
+  DeliveryPricingRowCategory,
+  DeliveryPricingSheet,
+  ProductPricingRowCategory,
+  ProductPricingSheet,
+  PaymentPricingRowCategory,
+  PaymentPricingSheet,
+} from '../directors/index.js';
+
+export async function calculateDiscountTotalService(
+  this: Modules,
+  order: Order,
+  orderDiscount: OrderDiscount,
+) {
+  const orderDiscountId = orderDiscount._id;
+
+  // Delivery discounts
+  const orderDelivery = await this.orders.deliveries.findDelivery({
+    orderDeliveryId: order.deliveryId,
+  });
+  const orderDeliveryDiscountSum = DeliveryPricingSheet({
+    calculation: orderDelivery.calculation || [],
+    currency: order.currency,
+  }).total({ category: DeliveryPricingRowCategory.Discount, discountId: orderDiscountId });
+
+  // Payment discounts
+  const orderPayment = await this.orders.payments.findOrderPayment({
+    orderPaymentId: order.paymentId,
+  });
+  const orderPaymentDiscountSum = PaymentPricingSheet({
+    calculation: orderPayment.calculation || [],
+    currency: order.currency,
+  }).total({ category: PaymentPricingRowCategory.Discount, discountId: orderDiscountId });
+
+  // Position discounts
+  const orderPositions = await this.orders.positions.findOrderPositions({
+    orderId: order._id,
+  });
+  const orderPositionDiscounts = orderPositions.map((orderPosition) =>
+    ProductPricingSheet({
+      calculation: orderPosition.calculation || [],
+      currency: order.currency,
+      quantity: orderPosition.quantity,
+    }).total({
+      category: ProductPricingRowCategory.Discount,
+      discountId: orderDiscountId,
+    }),
+  );
+
+  // order discounts
+  const orderDiscountSum = OrderPricingSheet({
+    calculation: order.calculation,
+    currency: order.currency,
+  }).total({ category: OrderPricingRowCategory.Discounts, discountId: orderDiscountId });
+
+  const prices = [
+    orderDeliveryDiscountSum.amount,
+    orderPaymentDiscountSum.amount,
+    ...orderPositionDiscounts.map((positionDiscount) => positionDiscount.amount),
+    orderDiscountSum.amount,
+  ];
+  const amount = prices.reduce((oldValue, price) => oldValue + (price || 0), 0);
+  return {
+    amount,
+    currency: order.currency,
+  };
+}

package/src/services/checkoutOrder.ts

@@ -0,0 +1,43 @@
+import { OrderStatus } from '@unchainedshop/core-orders';
+import { Modules } from '../modules.js';
+import { nextUserCartService } from './nextUserCart.js';
+import { validateOrderService } from './validateOrder.js';
+import { processOrderService } from './processOrder.js';
+
+export async function checkoutOrderService(
+  this: Modules,
+  orderId: string,
+  transactionContext: {
+    paymentContext?: any;
+    deliveryContext?: any;
+    comment?: string;
+    nextStatus?: OrderStatus;
+  },
+) {
+  const order = await this.orders.findOrder({ orderId });
+  if (order.status !== null) return order;
+
+  await validateOrderService.bind(this)(order);
+
+  const lock = await this.orders.acquireLock(order._id, 'checkout');
+
+  try {
+    const processedOrder = await processOrderService.bind(this)(order, transactionContext);
+
+    // After checkout, store last checkout information on user
+    await this.users.updateLastBillingAddress(processedOrder.userId, processedOrder.billingAddress);
+    await this.users.updateLastContact(processedOrder.userId, processedOrder.contact);
+
+    // Then eventually build next cart
+    const user = await this.users.findUserById(processedOrder.userId);
+    const locale = this.users.userLocale(user);
+    await nextUserCartService.bind(this)({
+      user,
+      countryCode: locale.region,
+    });
+
+    return processedOrder;
+  } finally {
+    await lock.release();
+  }
+}

package/src/services/confirmOrder.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 confirmOrderService(
+  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.CONFIRMED,
+    });
+  } finally {
+    await lock.release();
+  }
+}

package/src/services/createDownloadStream.ts

@@ -0,0 +1,16 @@
+import { getFileAdapter } from '@unchainedshop/core-files';
+import { Modules } from '../modules.js';
+
+export async function createDownloadStreamService(
+  this: Modules,
+  {
+    fileId,
+  }: {
+    fileId: string;
+  },
+) {
+  const fileAdapter = getFileAdapter();
+  const file = await this.files.findFile({ fileId });
+  const stream = fileAdapter.createDownloadStream(file, { modules: this });
+  return stream;
+}

package/src/services/createEnrollmentFromCheckout.ts

@@ -0,0 +1,66 @@
+import { Order, OrderPosition } from '@unchainedshop/core-orders';
+import { Product } from '@unchainedshop/core-products';
+import { Enrollment } from '@unchainedshop/core-enrollments';
+import { Modules } from '../modules.js';
+import { EnrollmentDirector } from '../directors/index.js';
+import { initializeEnrollmentService } from './initializeEnrollment.js';
+
+export async function createEnrollmentFromCheckoutService(
+  this: Modules,
+  order: Order,
+  {
+    items,
+    context,
+  }: {
+    items: Array<{
+      orderPosition: OrderPosition;
+      product: Product;
+    }>;
+    context: {
+      paymentContext?: any;
+      deliveryContext?: any;
+    };
+  },
+): Promise<Array<Enrollment>> {
+  const orderId = order._id;
+
+  const payment = await this.orders.payments.findOrderPayment({
+    orderPaymentId: order.paymentId,
+  });
+  const delivery = await this.orders.deliveries.findDelivery({
+    orderDeliveryId: order.deliveryId,
+  });
+
+  const template = {
+    billingAddress: order.billingAddress,
+    contact: order.contact,
+    countryCode: order.countryCode,
+    currencyCode: order.currency,
+    delivery: {
+      deliveryProviderId: delivery.deliveryProviderId,
+      context: delivery.context,
+    },
+    orderIdForFirstPeriod: orderId,
+    payment: {
+      paymentProviderId: payment.paymentProviderId,
+      context: payment.context,
+    },
+    userId: order.userId,
+    meta: order.context,
+    ...context,
+  };
+
+  return Promise.all(
+    items.map(async (item) => {
+      const enrollmentData = await EnrollmentDirector.transformOrderItemToEnrollment(item, template, {
+        modules: this,
+      });
+
+      const enrollment = await this.enrollments.create(enrollmentData);
+      return await initializeEnrollmentService.bind(this)(enrollment, {
+        orderIdForFirstPeriod: enrollment.orderIdForFirstPeriod,
+        reason: 'new_enrollment',
+      });
+    }),
+  );
+}

package/src/services/createManualOrderDiscount.ts

@@ -0,0 +1,56 @@
+import { Order, OrderDiscount } from '@unchainedshop/core-orders';
+import { OrderDiscountDirector } from '../directors/OrderDiscountDirector.js';
+import { Modules } from '../modules.js';
+
+export async function createManualOrderDiscountService(
+  this: Modules,
+  { order, code }: { code: string; order: Order },
+): Promise<OrderDiscount> {
+  // Use an already existing discount if available!
+  const spareDiscount = await this.orders.discounts.findSpareDiscount({ code });
+  if (spareDiscount) {
+    const Adapter = OrderDiscountDirector.getAdapter(spareDiscount.discountKey);
+    if (!Adapter) return null;
+
+    const actions = await Adapter.actions({
+      context: { order, orderDiscount: spareDiscount, code, modules: this },
+    });
+    const reservation = await actions.reserve({
+      code,
+    });
+
+    return this.orders.discounts.update(spareDiscount._id, { orderId: order._id, reservation });
+  }
+
+  const director = await OrderDiscountDirector.actions({ order, code }, { modules: this });
+  const Adapter = await director.resolveDiscountAdapterFromStaticCode({
+    code,
+  });
+
+  if (!Adapter) return null;
+
+  const newDiscount = await this.orders.discounts.create({
+    orderId: order._id,
+    code,
+    discountKey: Adapter.key,
+  });
+
+  const adapter = await Adapter.actions({
+    context: { order, orderDiscount: newDiscount, code: newDiscount.code, modules: this },
+  });
+
+  try {
+    const reservation = await adapter.reserve({
+      code: newDiscount.code,
+    });
+    const reservedDiscount = this.orders.discounts.update(newDiscount._id, {
+      orderId: newDiscount.orderId,
+      reservation,
+    });
+    return reservedDiscount;
+  } catch (error) {
+    await adapter.release();
+    await this.orders.discounts.delete(newDiscount._id);
+    throw error;
+  }
+}

package/src/services/createSignedURL.ts

@@ -0,0 +1,20 @@
+import { getFileFromFileData, getFileAdapter, SignedFileUpload } from '@unchainedshop/core-files';
+import { Modules } from '../modules.js';
+
+export async function createSignedURLService(
+  this: Modules,
+  { directoryName, fileName, meta }: { directoryName: string; fileName: string; meta?: any },
+) {
+  const fileUploadAdapter = getFileAdapter();
+  const preparedFileData = await fileUploadAdapter.createSignedURL(directoryName, fileName, {
+    modules: this,
+  });
+  const fileData = getFileFromFileData(preparedFileData, meta);
+  const fileId = await this.files.create(fileData);
+  const file = await this.files.findFile({ fileId });
+
+  return {
+    ...file,
+    putURL: preparedFileData.putURL as string,
+  } as SignedFileUpload;
+}

package/src/services/deleteUser.ts

@@ -0,0 +1,33 @@
+import { Modules } from '../modules.js';
+
+export async function deleteUserService(this: Modules, { userId }: { userId: string }) {
+  const user = await this.users.markDeleted(userId);
+
+  if (!user) return null;
+
+  await this.bookmarks.deleteByUserId(userId);
+  await this.quotations.deleteRequestedUserQuotations(userId);
+  await this.enrollments.deleteInactiveUserEnrollments(userId);
+
+  const carts = await this.orders.findOrders({ userId, status: null });
+
+  await Array.fromAsync(carts, async (userCart) => {
+    await this.orders.positions.deleteOrderPositions(userCart?._id);
+    await this.orders.payments.deleteOrderPayments(userCart?._id);
+    await this.orders.deliveries.deleteOrderDeliveries(userCart?._id);
+    await this.orders.discounts.deleteOrderDiscounts(userCart?._id);
+    await this.orders.delete(userCart?._id);
+  });
+
+  const ordersCount = await this.orders.count({ userId, includeCarts: true });
+  const quotationsCount = await this.quotations.count({ userId });
+  const reviewsCount = await this.products.reviews.count({ authorId: userId });
+  const enrollmentsCount = await this.enrollments.count({ userId });
+  const tokens = await this.warehousing.findTokensForUser({ userId });
+
+  if (!ordersCount && !reviewsCount && !enrollmentsCount && !quotationsCount && !tokens?.length) {
+    await this.users.deletePermanently({ userId });
+  }
+
+  return user;
+}

package/src/services/discountedEntities.ts

@@ -0,0 +1,81 @@
+import { Order, OrderDiscount } from '@unchainedshop/core-orders';
+import {
+  DeliveryPricingSheet,
+  OrderPricingDiscount,
+  OrderPricingSheet,
+  PaymentPricingSheet,
+  ProductPricingSheet,
+} from '../directors/index.js';
+import { Modules } from '../modules.js';
+
+export async function discountedEntitiesService(
+  this: Modules,
+  order: Order,
+  orderDiscount: OrderDiscount,
+): Promise<Array<OrderPricingDiscount>> {
+  // Delivery discounts
+  const orderDelivery = await this.orders.deliveries.findDelivery({
+    orderDeliveryId: order.deliveryId,
+  });
+
+  const deliveryPricingSheet = DeliveryPricingSheet({
+    calculation: orderDelivery.calculation || [],
+    currency: order.currency,
+  });
+  const orderDeliveryDiscounts = deliveryPricingSheet
+    .discountPrices(orderDiscount._id)
+    .map((discount) => ({
+      delivery: orderDelivery,
+      ...discount,
+    }));
+
+  // Payment discounts
+  const orderPayment = await this.orders.payments.findOrderPayment({
+    orderPaymentId: order.paymentId,
+  });
+  const paymentPricingSheet = PaymentPricingSheet({
+    calculation: orderPayment.calculation || [],
+    currency: order.currency,
+  });
+  const orderPaymentDiscounts = paymentPricingSheet
+    .discountPrices(orderDiscount._id)
+    .map((discount) => ({
+      payment: orderPayment,
+      ...discount,
+    }));
+
+  // Position discounts
+  const orderPositions = await this.orders.positions.findOrderPositions({
+    orderId: order._id,
+  });
+  const orderPositionDiscounts = orderPositions.flatMap((orderPosition) =>
+    ProductPricingSheet({
+      calculation: orderPosition.calculation,
+      currency: order.currency,
+      quantity: orderPosition.quantity,
+    })
+      .discountPrices(orderDiscount._id)
+      .map((discount) => ({
+        item: orderPosition,
+        ...discount,
+      })),
+  );
+
+  // order discounts
+  const orderDiscounts = OrderPricingSheet({
+    calculation: order.calculation || [],
+    currency: order.currency,
+  })
+    .discountPrices(orderDiscount._id)
+    .map((discount) => ({ order, ...discount }));
+
+  // All discounts
+  const discounted = [
+    ...orderPaymentDiscounts,
+    ...orderDeliveryDiscounts,
+    ...orderPositionDiscounts,
+    ...orderDiscounts,
+  ].filter(Boolean);
+
+  return discounted;
+}

package/src/services/ercMetadata.ts

@@ -0,0 +1,33 @@
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { WarehousingDirector } from '../directors/WarehousingDirector.js';
+import { Modules } from '../modules.js';
+
+export async function ercMetadataService(
+  this: Modules,
+  { productId, chainTokenId, locale }: { productId: string; chainTokenId: string; locale: Intl.Locale },
+) {
+  const product = await this.products.findProduct({
+    productId,
+  });
+
+  const [token] = await this.warehousing.findTokens({
+    chainTokenId,
+    contractAddress: product?.tokenization?.contractAddress,
+  });
+
+  const virtualProviders = await this.warehousing.findProviders({
+    type: WarehousingProviderType.VIRTUAL,
+  });
+
+  return await WarehousingDirector.tokenMetadata(
+    virtualProviders,
+    {
+      product,
+      token,
+      locale,
+      quantity: token?.quantity || 1,
+      referenceDate: new Date(),
+    },
+    { modules: this },
+  );
+}

package/src/services/findOrInitCart.ts

@@ -0,0 +1,29 @@
+import { User } from '@unchainedshop/core-users';
+import { Order } from '@unchainedshop/core-orders';
+import { Modules } from '../modules.js';
+import { nextUserCartService } from './nextUserCart.js';
+
+export async function findOrInitCartService(
+  this: Modules,
+  {
+    user,
+    countryCode,
+    orderId,
+  }: {
+    user: User;
+    countryCode: string;
+    orderId?: string;
+  },
+) {
+  if (orderId) {
+    const order = await this.orders.findOrder({ orderId });
+    if (!order) return null;
+    return order;
+  }
+
+  return nextUserCartService.bind(this)({
+    user,
+    countryCode,
+    forceCartCreation: true,
+  }) as Order;
+}

package/src/services/fullfillQuotation.ts

@@ -0,0 +1,14 @@
+import { Quotation, QuotationStatus } from '@unchainedshop/core-quotations';
+import { Modules } from '../modules.js';
+import { processQuotationService } from './processQuotation.js';
+
+export async function fullfillQuotationService(this: Modules, quotation: Quotation, info) {
+  if (quotation.status === QuotationStatus.FULLFILLED) return quotation;
+
+  const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
+    status: QuotationStatus.FULLFILLED,
+    info: JSON.stringify(info),
+  });
+
+  return processQuotationService.bind(this)(updatedQuotation, {});
+}