@unchainedshop/core 5.0.0-alpha.10 → 5.0.0-alpha.11

package/lib/services/calculateDiscountTotal.js

@@ -1,44 +1,52 @@
 import { OrderPricingRowCategory, OrderPricingSheet, DeliveryPricingRowCategory, DeliveryPricingSheet, ProductPricingRowCategory, ProductPricingSheet, PaymentPricingRowCategory, PaymentPricingSheet, } from "../directors/index.js";
-export async function calculateDiscountTotalService(order, orderDiscount) {
-    const orderDiscountId = orderDiscount._id;
+export async function calculateDiscountTotalService(order, orderDiscount, { useNetPrice = false } = {}) {
+    const discountId = orderDiscount._id;
     const orderDelivery = await this.orders.deliveries.findDelivery({
         orderDeliveryId: order.deliveryId,
     });
-    const orderDeliveryDiscountSum = DeliveryPricingSheet({
-        calculation: orderDelivery?.calculation || [],
-        currencyCode: order.currencyCode,
-    }).total({ category: DeliveryPricingRowCategory.Discount, discountId: orderDiscountId });
     const orderPayment = await this.orders.payments.findOrderPayment({
         orderPaymentId: order.paymentId,
     });
-    const orderPaymentDiscountSum = PaymentPricingSheet({
-        calculation: orderPayment?.calculation || [],
-        currencyCode: order.currencyCode,
-    }).total({ category: PaymentPricingRowCategory.Discount, discountId: orderDiscountId });
     const orderPositions = await this.orders.positions.findOrderPositions({
         orderId: order._id,
     });
-    const orderPositionDiscounts = orderPositions.map((orderPosition) => ProductPricingSheet({
-        calculation: orderPosition.calculation || [],
-        currencyCode: order.currencyCode,
-        quantity: orderPosition.quantity,
-    }).total({
-        category: ProductPricingRowCategory.Discount,
-        discountId: orderDiscountId,
-    }));
-    const orderDiscountSum = OrderPricingSheet({
-        calculation: order.calculation,
-        currencyCode: order.currencyCode,
-    }).total({ category: OrderPricingRowCategory.Discounts, discountId: orderDiscountId });
-    const prices = [
-        orderDeliveryDiscountSum.amount,
-        orderPaymentDiscountSum.amount,
-        ...orderPositionDiscounts.map((positionDiscount) => positionDiscount.amount),
-        orderDiscountSum.amount,
+    const discountedSheets = [
+        {
+            category: DeliveryPricingRowCategory.Discount,
+            sheet: DeliveryPricingSheet({
+                calculation: orderDelivery?.calculation || [],
+                currencyCode: order.currencyCode,
+            }),
+        },
+        {
+            category: PaymentPricingRowCategory.Discount,
+            sheet: PaymentPricingSheet({
+                calculation: orderPayment?.calculation || [],
+                currencyCode: order.currencyCode,
+            }),
+        },
+        ...orderPositions.map((orderPosition) => ({
+            category: ProductPricingRowCategory.Discount,
+            sheet: ProductPricingSheet({
+                calculation: orderPosition.calculation || [],
+                currencyCode: order.currencyCode,
+                quantity: orderPosition.quantity,
+            }),
+        })),
+        {
+            category: OrderPricingRowCategory.Discounts,
+            sheet: OrderPricingSheet({
+                calculation: order.calculation,
+                currencyCode: order.currencyCode,
+            }),
+        },
     ];
-    const amount = prices.reduce((oldValue, price) => oldValue + (price || 0), 0);
+    const amount = discountedSheets.reduce((sum, { category, sheet }) => sum + (sheet.total({ category, discountId, useNetPrice }).amount || 0), 0);
+    const taxAmount = discountedSheets.reduce((sum, { category, sheet }) => sum + sheet.taxSum({ baseCategory: category, discountId }), 0);
     return {
         amount,
         currencyCode: order.currencyCode,
+        isTaxable: taxAmount !== 0,
+        isNetPrice: useNetPrice,
     };
 }

package/lib/services/checkoutOrder.js

@@ -3,6 +3,7 @@ import { nextUserCartService } from "./nextUserCart.js";
 import { validateOrderService } from "./validateOrder.js";
 import { processOrderService } from "./processOrder.js";
 import { reserveOrderDiscountsForCheckout } from "./reserveOrderDiscountsForCheckout.js";
+import { reserveOrderQuotationsForCheckout } from "./reserveOrderQuotationsForCheckout.js";
 export async function checkoutOrderService(orderId, transactionContext) {
     const order = await this.orders.findOrder({ orderId });
     if (!order)
@@ -12,7 +13,9 @@ export async function checkoutOrderService(orderId, transactionContext) {
     await validateOrderService.bind(this)(order);
     const lock = await this.orders.acquireLock(order._id, 'checkout');
     let discounts;
+    let quotations;
     try {
+        quotations = await reserveOrderQuotationsForCheckout.call(this, order);
         discounts = await reserveOrderDiscountsForCheckout.call(this, order);
         const processedOrder = await processOrderService.bind(this)(order, transactionContext);
         if (processedOrder.billingAddress) {
@@ -31,6 +34,7 @@ export async function checkoutOrderService(orderId, transactionContext) {
     }
     finally {
         await discounts?.release();
+        await quotations?.release();
         await lock.release();
     }
 }

package/lib/services/index.d.ts

@@ -31,6 +31,8 @@ import { rejectOrderService } from './rejectOrder.ts';
 import { discountedEntitiesService } from './discountedEntities.ts';
 import { createManualOrderDiscountService } from './createManualOrderDiscount.ts';
 import { initializeEnrollmentService } from './initializeEnrollment.ts';
+import { suspendEnrollmentService } from './suspendEnrollment.ts';
+import { updateEnrollmentPlanService } from './updateEnrollmentPlan.ts';
 import { activateEnrollmentService } from './activateEnrollment.ts';
 import { terminateEnrollmentService } from './terminateEnrollment.ts';
 import { invalidateFilterCacheService } from './invalidateFilterCache.ts';
@@ -48,6 +50,8 @@ import { createFilterOptionService } from './createFilterOption.ts';
 import { removeFilterOptionService } from './removeFilterOption.ts';
 import { removeCartDiscountService } from './removeCartDiscount.ts';
 import { addMultipleCartProductsService } from './addMultipleCartProducts.ts';
+import { addCartQuotationService } from './addCartQuotation.ts';
+import { updateCartItemService } from './updateCartItem.ts';
 import { ercMetadataService } from './ercMetadata.ts';
 import { simulateProductPricingService } from './simulateProductPricing.ts';
 import { simulateProductDispatchingService } from './simulateProductDispatching.ts';
@@ -105,6 +109,8 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         resolveOrderItemDispatches: Bound<typeof resolveOrderItemDispatchesService>;
         removeCartDiscount: Bound<typeof removeCartDiscountService>;
         addMultipleCartProducts: Bound<typeof addMultipleCartProductsService>;
+        addCartQuotation: Bound<typeof addCartQuotationService>;
+        updateCartItem: Bound<typeof updateCartItemService>;
     };
     products: {
         simulateProductPricing: Bound<typeof simulateProductPricingService>;
@@ -131,6 +137,8 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         initializeEnrollment: Bound<typeof initializeEnrollmentService>;
         activateEnrollment: Bound<typeof activateEnrollmentService>;
         terminateEnrollment: Bound<typeof terminateEnrollmentService>;
+        suspendEnrollment: Bound<typeof suspendEnrollmentService>;
+        updateEnrollmentPlan: Bound<typeof updateEnrollmentPlanService>;
     };
     quotations: {
         fulfillQuotation: Bound<typeof fulfillQuotationService>;

package/lib/services/index.js

@@ -30,6 +30,8 @@ import { rejectOrderService } from "./rejectOrder.js";
 import { discountedEntitiesService } from "./discountedEntities.js";
 import { createManualOrderDiscountService } from "./createManualOrderDiscount.js";
 import { initializeEnrollmentService } from "./initializeEnrollment.js";
+import { suspendEnrollmentService } from "./suspendEnrollment.js";
+import { updateEnrollmentPlanService } from "./updateEnrollmentPlan.js";
 import { activateEnrollmentService } from "./activateEnrollment.js";
 import { terminateEnrollmentService } from "./terminateEnrollment.js";
 import { invalidateFilterCacheService } from "./invalidateFilterCache.js";
@@ -47,6 +49,8 @@ import { createFilterOptionService } from "./createFilterOption.js";
 import { removeFilterOptionService } from "./removeFilterOption.js";
 import { removeCartDiscountService } from "./removeCartDiscount.js";
 import { addMultipleCartProductsService } from "./addMultipleCartProducts.js";
+import { addCartQuotationService } from "./addCartQuotation.js";
+import { updateCartItemService } from "./updateCartItem.js";
 import { ercMetadataService } from "./ercMetadata.js";
 import { simulateProductPricingService } from "./simulateProductPricing.js";
 import { simulateProductDispatchingService } from "./simulateProductDispatching.js";
@@ -116,6 +120,8 @@ export default function initServices(modules, customServices = {}) {
             resolveOrderItemDispatches: resolveOrderItemDispatchesService,
             removeCartDiscount: removeCartDiscountService,
             addMultipleCartProducts: addMultipleCartProductsService,
+            addCartQuotation: addCartQuotationService,
+            updateCartItem: updateCartItemService,
         },
         products: {
             simulateProductPricing: simulateProductPricingService,
@@ -142,6 +148,8 @@ export default function initServices(modules, customServices = {}) {
             initializeEnrollment: initializeEnrollmentService,
             activateEnrollment: activateEnrollmentService,
             terminateEnrollment: terminateEnrollmentService,
+            suspendEnrollment: suspendEnrollmentService,
+            updateEnrollmentPlan: updateEnrollmentPlanService,
         },
         quotations: {
             fulfillQuotation: fulfillQuotationService,

package/lib/services/initializeEnrollment.d.ts

@@ -1,4 +1,4 @@
-import type { Enrollment } from '@unchainedshop/core-enrollments';
+import { type Enrollment } from '@unchainedshop/core-enrollments';
 import type { Modules } from '../modules.ts';
 export declare function initializeEnrollmentService(this: Modules, enrollment: Enrollment, params: {
     orderIdForFirstPeriod?: string;

package/lib/services/initializeEnrollment.js

@@ -1,3 +1,4 @@
+import { addToDate } from '@unchainedshop/core-enrollments';
 import { EnrollmentDirector } from "../core-index.js";
 import { processEnrollmentService } from "./processEnrollment.js";
 import { addMessageService } from "./addMessage.js";
@@ -14,6 +15,16 @@ export async function initializeEnrollmentService(enrollment, params) {
             orderId: params.orderIdForFirstPeriod,
         }));
     }
+    const { minimumCommitmentPeriods, billingInterval, billingIntervalCount } = product?.plan || {};
+    if (minimumCommitmentPeriods && billingInterval) {
+        const contractStartDate = updatedEnrollment.periods.find(({ isTrial }) => !isTrial)?.start || new Date();
+        updatedEnrollment = (await this.enrollments.updateCommitment(enrollment._id, {
+            contractStartDate,
+            minimumCommitmentEnd: addToDate(contractStartDate, {
+                [billingInterval.toLowerCase()]: (billingIntervalCount || 1) * minimumCommitmentPeriods,
+            }),
+        }));
+    }
     const processedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
     const user = await this.users.findUserById(enrollment.userId);
     const locale = this.users.userLocale(user);

package/lib/services/migrateOrderCart.js

@@ -12,10 +12,10 @@ export async function migrateOrderCartsService({ fromUserId, toUserId, shouldMer
         return toCart;
     }
     if (!toCart || !shouldMerge) {
-        this.orders.setCartOwner({ orderId: fromCart._id, userId: toUserId });
+        await this.orders.setCartOwner({ orderId: fromCart._id, userId: toUserId });
         return updateCalculationService.bind(this)(fromCart._id);
     }
-    this.orders.moveCartPositions({ fromOrderId: fromCart._id, toOrderId: toCart._id });
+    await this.orders.moveCartPositions({ fromOrderId: fromCart._id, toOrderId: toCart._id });
     if (fromCart.billingAddress && !toCart.billingAddress) {
         await this.orders.updateBillingAddress(toCart._id, fromCart.billingAddress);
     }

package/lib/services/migrateUserData.js

@@ -4,6 +4,9 @@ import { migrateOrderCartsService } from "./migrateOrderCart.js";
 export async function migrateUserDataService(userIdBeforeLogin, userId) {
     const user = await this.users.findUserById(userId);
     const userBeforeLogin = await this.users.findUserById(userIdBeforeLogin);
+    if (userBeforeLogin?.guest) {
+        await this.quotations.replaceUserIdOfOpenQuotations(userIdBeforeLogin, userId);
+    }
     await migrateOrderCartsService.bind(this)({
         fromUserId: userIdBeforeLogin,
         toUserId: userId,

package/lib/services/processEnrollment.js

@@ -3,6 +3,12 @@ import { EnrollmentDirector } from "../core-index.js";
 import { createServiceError } from "../errors.js";
 const findNextStatus = async (enrollment, modules) => {
     let status = enrollment.status;
+    if (modules.enrollments.isExpired(enrollment, {}))
+        return EnrollmentStatus.TERMINATED;
+    if (status === EnrollmentStatus.SUSPENDED) {
+        const resumeDue = enrollment.resumeAt && new Date(enrollment.resumeAt).getTime() <= Date.now();
+        return resumeDue ? EnrollmentStatus.ACTIVE : status;
+    }
     const product = await modules.products.findProduct({
         productId: enrollment.productId,
     });
@@ -19,9 +25,6 @@ const findNextStatus = async (enrollment, modules) => {
             status = EnrollmentStatus.PAUSED;
         }
     }
-    else if (modules.enrollments.isExpired(enrollment, {})) {
-        status = EnrollmentStatus.TERMINATED;
-    }
     return status;
 };
 export async function processEnrollmentService(enrollment) {

package/lib/services/processOrder.js

@@ -7,14 +7,14 @@ import { fulfillQuotationService } from "./fulfillQuotation.js";
 import { createLogger } from '@unchainedshop/logger';
 import { createServiceError } from "../errors.js";
 const logger = createLogger('unchained:core:processOrder');
-const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modules) => {
+const isAutoConfirmationEnabled = async ({ order, orderPayment, orderDelivery, }, modules) => {
     if (orderPayment.status !== OrderPaymentStatus.PAID) {
         const paymentProvider = await modules.payment.paymentProviders.findProvider({
             paymentProviderId: orderPayment.paymentProviderId,
         });
         if (!paymentProvider)
             throw createServiceError('PaymentProviderNotFoundError', `Payment provider not found: ${orderPayment.paymentProviderId}`);
-        const actions = await PaymentDirector.actions(paymentProvider, {}, { modules });
+        const actions = await PaymentDirector.actions(paymentProvider, { order, orderPayment, userId: order.userId }, { modules });
         if (!actions.isPayLaterAllowed())
             return false;
     }
@@ -24,7 +24,7 @@ const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modul
         });
         if (!deliveryProvider)
             throw createServiceError('DeliveryProviderNotFoundError', `Delivery provider not found: ${orderDelivery.deliveryProviderId}`);
-        const director = await DeliveryDirector.actions(deliveryProvider, {}, { modules });
+        const director = await DeliveryDirector.actions(deliveryProvider, { order, orderDelivery }, { modules });
         if (!director.isAutoReleaseAllowed())
             return false;
     }
@@ -50,7 +50,7 @@ const findNextStatus = async (status, order, modules) => {
     if (!orderDelivery)
         return status;
     if (status === OrderStatus.PENDING) {
-        if (await isAutoConfirmationEnabled({ orderPayment, orderDelivery }, modules)) {
+        if (await isAutoConfirmationEnabled({ order, orderPayment, orderDelivery }, modules)) {
             return OrderStatus.CONFIRMED;
         }
     }

package/lib/services/reserveOrderQuotationsForCheckout.d.ts

@@ -0,0 +1,8 @@
+import { type Order } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+export declare function isQuotationReserved(this: Modules, quotationId: string, { exceptOrderId }?: {
+    exceptOrderId?: string;
+}): Promise<boolean>;
+export declare function reserveOrderQuotationsForCheckout(this: Modules, order: Order): Promise<{
+    release: () => Promise<void>;
+}>;

package/lib/services/reserveOrderQuotationsForCheckout.js

@@ -0,0 +1,49 @@
+import { OrderStatus } from '@unchainedshop/core-orders';
+import { createServiceError } from "../errors.js";
+const RESERVATION_LOCK_TTL = 60000;
+export async function isQuotationReserved(quotationId, { exceptOrderId } = {}) {
+    const orderIds = (await this.orders.positions.findOrderPositions({ quotationId }))
+        .map(({ orderId }) => orderId)
+        .filter((orderId) => orderId !== exceptOrderId);
+    if (!orderIds.length)
+        return false;
+    const count = await this.orders.count({
+        orderIds,
+        status: [OrderStatus.PENDING, OrderStatus.CONFIRMED, OrderStatus.FULFILLED],
+    });
+    return count > 0;
+}
+export async function reserveOrderQuotationsForCheckout(order) {
+    const locks = [];
+    const release = async () => {
+        await Promise.all(locks.map((lock) => lock.release()));
+    };
+    try {
+        const positions = await this.orders.positions.findOrderPositions({ orderId: order._id });
+        const quotationIds = [
+            ...new Set(positions.map(({ quotationId }) => quotationId).filter(Boolean)),
+        ].sort();
+        for (const quotationId of quotationIds) {
+            try {
+                locks.push(await this.orders.acquireLock(quotationId, 'quotation', RESERVATION_LOCK_TTL));
+            }
+            catch (error) {
+                if (!error?.message?.startsWith('Could not acquire lock'))
+                    throw error;
+                throw createServiceError('QuotationInvalidError', 'Quotation is being ordered by another order');
+            }
+            const quotation = await this.quotations.findQuotation({ quotationId });
+            if (!quotation || !this.quotations.isProposalValid(quotation)) {
+                throw createServiceError('QuotationInvalidError', 'Quotation expired, fulfilled or not valid for this order, please request a new offer');
+            }
+            if (await isQuotationReserved.call(this, quotationId, { exceptOrderId: order._id })) {
+                throw createServiceError('QuotationInvalidError', 'Quotation is reserved by another order');
+            }
+        }
+        return { release };
+    }
+    catch (error) {
+        await release();
+        throw error;
+    }
+}

package/lib/services/simulateConfigurablePriceRange.js

@@ -22,7 +22,7 @@ export async function simulateConfigurablePriceRangeService({ product, currencyC
         return {
             ...unitPrice,
             isNetPrice: useNetPrice,
-            isTaxable: pricing.taxSum() > 0,
+            isTaxable: pricing.taxSum() !== 0,
             currencyCode: pricing.currencyCode,
         };
     }))).filter(Boolean);

package/lib/services/simulateDeliveryPricing.js

@@ -17,7 +17,7 @@ export async function simulateDeliveryPricingService(pricingContext, options = {
         amount: orderPrice.amount,
         currencyCode: orderPrice.currencyCode,
         countryCode: pricingContext.countryCode,
-        isTaxable: pricing.taxSum() > 0,
+        isTaxable: pricing.taxSum() !== 0,
         isNetPrice: options.useNetPrice || false,
     };
 }

package/lib/services/simulatePaymentPricing.js

@@ -17,7 +17,7 @@ export async function simulatePaymentPricingService(pricingContext, options = {}
         amount: orderPrice.amount,
         currencyCode: orderPrice.currencyCode,
         countryCode: pricingContext.countryCode,
-        isTaxable: pricing.taxSum() > 0,
+        isTaxable: pricing.taxSum() !== 0,
         isNetPrice: options.useNetPrice || false,
     };
 }

package/lib/services/suspendEnrollment.d.ts

@@ -0,0 +1,5 @@
+import { type Enrollment } from '@unchainedshop/core-enrollments';
+import type { Modules } from '../modules.ts';
+export declare function suspendEnrollmentService(this: Modules, enrollment: Enrollment, { resumeAt }?: {
+    resumeAt?: Date;
+}): Promise<Enrollment>;

package/lib/services/suspendEnrollment.js

@@ -0,0 +1,21 @@
+import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { addMessageService } from "./addMessage.js";
+export async function suspendEnrollmentService(enrollment, { resumeAt } = {}) {
+    if (enrollment.status === EnrollmentStatus.TERMINATED)
+        return enrollment;
+    let updatedEnrollment = (await this.enrollments.updateStatus(enrollment._id, {
+        status: EnrollmentStatus.SUSPENDED,
+        info: 'suspended manually',
+    }));
+    if (resumeAt) {
+        updatedEnrollment = (await this.enrollments.updateResumeAt(enrollment._id, resumeAt));
+    }
+    const user = await this.users.findUserById(enrollment.userId);
+    const locale = this.users.userLocale(user);
+    await addMessageService.bind(this)('ENROLLMENT_STATUS', {
+        reason: 'status_change',
+        locale: locale.baseName,
+        enrollmentId: updatedEnrollment._id,
+    });
+    return updatedEnrollment;
+}

package/lib/services/terminateEnrollment.d.ts

@@ -1,2 +1,6 @@
-import { type Enrollment } from '@unchainedshop/core-enrollments';
-export declare function terminateEnrollmentService(enrollment: Enrollment): Promise<any>;
+import { type Enrollment, type EnrollmentTerminationReason } from '@unchainedshop/core-enrollments';
+import type { Modules } from '../modules.ts';
+export declare function terminateEnrollmentService(this: Modules, enrollment: Enrollment, { reason, comment }?: {
+    reason?: EnrollmentTerminationReason;
+    comment?: string;
+}): Promise<Enrollment>;

package/lib/services/terminateEnrollment.js

@@ -1,14 +1,34 @@
-import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { EnrollmentStatus, } from '@unchainedshop/core-enrollments';
 import { processEnrollmentService } from "./processEnrollment.js";
 import { addMessageService } from "./addMessage.js";
-export async function terminateEnrollmentService(enrollment) {
+import { EnrollmentDirector } from "../core-index.js";
+import { createServiceError } from "../errors.js";
+export async function terminateEnrollmentService(enrollment, { reason, comment } = {}) {
     if (enrollment.status === EnrollmentStatus.TERMINATED)
         return enrollment;
-    let updatedEnrollment = await this.enrollments.updateStatus(enrollment._id, {
-        status: EnrollmentStatus.TERMINATED,
-        info: 'terminated manually',
-    });
-    updatedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
+    const product = await this.products.findProduct({ productId: enrollment.productId });
+    if (!product)
+        throw createServiceError('ProductNotFoundError', 'Product not found for enrollment');
+    const director = await EnrollmentDirector.actions({ enrollment, product }, { modules: this });
+    const terminationDate = await director.terminationDate({ referenceDate: new Date() });
+    if (!terminationDate) {
+        throw createServiceError('EnrollmentTerminationNotAllowedError', 'Enrollment termination is not allowed at this time');
+    }
+    const expires = new Date(Math.min(Math.max(terminationDate.getTime(), enrollment.minimumCommitmentEnd?.getTime() ?? 0), enrollment.expires?.getTime() ?? Infinity));
+    if (reason || comment) {
+        await this.enrollments.updateCancellation(enrollment._id, { reason, comment });
+    }
+    let updatedEnrollment;
+    if (expires.getTime() > Date.now()) {
+        updatedEnrollment = (await this.enrollments.updateExpiry(enrollment._id, expires));
+    }
+    else {
+        updatedEnrollment = (await this.enrollments.updateStatus(enrollment._id, {
+            status: EnrollmentStatus.TERMINATED,
+            info: 'terminated manually',
+        }));
+        updatedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
+    }
     const user = await this.users.findUserById(enrollment.userId);
     const locale = this.users.userLocale(user);
     await addMessageService.bind(this)('ENROLLMENT_STATUS', {

package/lib/services/updateCartItem.d.ts

@@ -1,11 +1,11 @@
-import { type OrderPosition } from '@unchainedshop/core-orders';
+import { type Order, type OrderPosition } from '@unchainedshop/core-orders';
 import type { Modules } from '../modules.ts';
-export interface UpdateCartItemParams {
-    itemId: string;
-    quantity?: number;
+export declare function updateCartItemService(this: Modules, { order, item, quantity, configuration, }: {
+    order: Order;
+    item: OrderPosition;
+    quantity?: number | null;
     configuration?: {
         key: string;
         value: string;
-    }[];
-}
-export declare function updateCartItemService(this: Modules, params: UpdateCartItemParams, context: any): Promise<OrderPosition>;
+    }[] | null;
+}, unchainedAPI?: Record<string, any>): Promise<OrderPosition | null>;

package/lib/services/updateCartItem.js

@@ -1,37 +1,40 @@
 import { ordersSettings } from '@unchainedshop/core-orders';
-import { updateCalculationService } from "./updateCalculation.js";
-import { OrderItemNotFoundError, OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, ProductNotFoundError, } from "../errors/index.js";
-export async function updateCartItemService(params, context) {
-    const { itemId, configuration, quantity = 1 } = params;
-    const item = await this.orders.positions.findOrderPosition({ itemId });
-    if (!item) {
-        throw new OrderItemNotFoundError({ orderItemId: itemId });
-    }
-    const order = await this.orders.findOrder({ orderId: item.orderId });
-    if (!order) {
-        throw new OrderNotFoundError({ orderId: item.orderId });
-    }
-    if (!this.orders.isCart(order)) {
-        throw new OrderWrongStatusError({ status: order.status });
-    }
+import { QuotationDirector } from "../directors/QuotationDirector.js";
+import { createServiceError } from "../errors.js";
+export async function updateCartItemService({ order, item, quantity, configuration, }, unchainedAPI = {}) {
+    const context = { ...unchainedAPI, modules: this };
     const product = await this.products.findProduct({ productId: item.productId });
     if (!product) {
-        throw new ProductNotFoundError({ productId: item.productId });
+        throw createServiceError('ProductNotFoundError', `Product not found: ${item.productId}`);
     }
-    if (quantity !== null && quantity < 1) {
-        throw new OrderQuantityTooLowError({ quantity });
+    let itemQuantity = quantity === undefined ? 1 : quantity;
+    let itemConfiguration = configuration;
+    if (item.quotationId) {
+        const quotation = await this.quotations.findQuotation({ quotationId: item.quotationId });
+        if (!quotation) {
+            throw createServiceError('QuotationNotFoundError', `Quotation not found: ${item.quotationId}`);
+        }
+        const director = await QuotationDirector.actions({ quotation }, context);
+        const requestedQuantity = quantity || item.quantity;
+        const quotationConfiguration = await director.transformItemConfiguration({
+            quantity: requestedQuantity,
+            configuration: configuration || item.configuration || [],
+        });
+        if (!quotationConfiguration) {
+            throw createServiceError('QuotationItemConfigurationError', `Quotation ${quotation._id} does not take quantity ${requestedQuantity}`);
+        }
+        itemQuantity = quotationConfiguration.quantity || requestedQuantity;
+        itemConfiguration = quotationConfiguration.configuration;
     }
     await ordersSettings.validateOrderPosition({
         order,
         product,
-        configuration,
-        quantityDiff: quantity - item.quantity,
+        configuration: itemConfiguration,
+        quantityDiff: itemQuantity - item.quantity,
     }, context);
-    await this.orders.positions.updateProductItem({
+    return this.orders.positions.updateProductItem({
         orderPositionId: item._id,
-        quantity: quantity || null,
-        configuration: configuration || null,
+        quantity: itemQuantity || null,
+        configuration: itemConfiguration || null,
     });
-    await updateCalculationService.bind(this)(order._id);
-    return (await this.orders.positions.findOrderPosition({ itemId: item._id }));
 }

package/lib/services/updateEnrollmentPlan.d.ts

@@ -0,0 +1,5 @@
+import type { Enrollment, EnrollmentPlan } from '@unchainedshop/core-enrollments';
+import type { Modules } from '../modules.ts';
+export declare function updateEnrollmentPlanService(this: Modules, enrollment: Enrollment, { plan }: {
+    plan: EnrollmentPlan;
+}): Promise<Enrollment>;

package/lib/services/updateEnrollmentPlan.js

@@ -0,0 +1,26 @@
+import { emit } from '@unchainedshop/events';
+import { EnrollmentDirector } from "../core-index.js";
+import { processEnrollmentService } from "./processEnrollment.js";
+import { addMessageService } from "./addMessage.js";
+import { createServiceError } from "../errors.js";
+export async function updateEnrollmentPlanService(enrollment, { plan }) {
+    const product = await this.products.findProduct({ productId: enrollment.productId });
+    if (!product)
+        throw createServiceError('ProductNotFoundError', 'Product not found for enrollment');
+    const director = await EnrollmentDirector.actions({ enrollment, product }, { modules: this });
+    const newPlan = await director.transformPlanToNewPlan({ plan });
+    if (!newPlan) {
+        throw createServiceError('EnrollmentPlanChangeNotSupportedError', 'Plan change is not supported for this enrollment');
+    }
+    let updatedEnrollment = (await this.enrollments.updatePlan(enrollment._id, newPlan));
+    updatedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
+    await emit('ENROLLMENT_PLAN_CHANGE', { enrollment: updatedEnrollment });
+    const user = await this.users.findUserById(enrollment.userId);
+    const locale = this.users.userLocale(user);
+    await addMessageService.bind(this)('ENROLLMENT_STATUS', {
+        reason: 'plan_change',
+        locale: locale.baseName,
+        enrollmentId: updatedEnrollment._id,
+    });
+    return updatedEnrollment;
+}

package/lib/services/validateOrder.js

@@ -29,8 +29,13 @@ export async function validateOrderService(order) {
             (await this.quotations.findQuotation({
                 quotationId: orderPosition.quotationId,
             }));
-        if (quotation && !this.quotations.isProposalValid(quotation)) {
-            throw createServiceError('QuotationInvalidError', 'Quotation expired or fulfilled, please request a new offer');
+        if (quotation &&
+            !this.quotations.isProposalValidFor(quotation, {
+                userId: order.userId,
+                productId: orderPosition.productId,
+                currencyCode: order.currencyCode,
+            })) {
+            throw createServiceError('QuotationInvalidError', 'Quotation expired, fulfilled or not valid for this order, please request a new offer');
         }
     }
 }