@vendure/core 1.4.7 → 1.5.2

package/cli/service/services/order.service.js

@@ -0,0 +1,1158 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderService = void 0;
+const common_1 = require("@nestjs/common");
+const generated_types_1 = require("@vendure/common/lib/generated-types");
+const shared_utils_1 = require("@vendure/common/lib/shared-utils");
+const unique_1 = require("@vendure/common/lib/unique");
+const FindOptionsUtils_1 = require("typeorm/find-options/FindOptionsUtils");
+const request_context_cache_service_1 = require("../../cache/request-context-cache.service");
+const error_result_1 = require("../../common/error/error-result");
+const errors_1 = require("../../common/error/errors");
+const generated_graphql_admin_errors_1 = require("../../common/error/generated-graphql-admin-errors");
+const generated_graphql_shop_errors_1 = require("../../common/error/generated-graphql-shop-errors");
+const tax_utils_1 = require("../../common/tax-utils");
+const utils_1 = require("../../common/utils");
+const config_service_1 = require("../../config/config.service");
+const transactional_connection_1 = require("../../connection/transactional-connection");
+const order_item_entity_1 = require("../../entity/order-item/order-item.entity");
+const order_line_entity_1 = require("../../entity/order-line/order-line.entity");
+const order_modification_entity_1 = require("../../entity/order-modification/order-modification.entity");
+const order_entity_1 = require("../../entity/order/order.entity");
+const payment_entity_1 = require("../../entity/payment/payment.entity");
+const product_variant_entity_1 = require("../../entity/product-variant/product-variant.entity");
+const refund_entity_1 = require("../../entity/refund/refund.entity");
+const shipping_line_entity_1 = require("../../entity/shipping-line/shipping-line.entity");
+const surcharge_entity_1 = require("../../entity/surcharge/surcharge.entity");
+const event_bus_1 = require("../../event-bus/event-bus");
+const index_1 = require("../../event-bus/index");
+const index_2 = require("../../event-bus/index");
+const index_3 = require("../../event-bus/index");
+const index_4 = require("../../event-bus/index");
+const index_5 = require("../../event-bus/index");
+const custom_field_relation_service_1 = require("../helpers/custom-field-relation/custom-field-relation.service");
+const list_query_builder_1 = require("../helpers/list-query-builder/list-query-builder");
+const order_calculator_1 = require("../helpers/order-calculator/order-calculator");
+const order_merger_1 = require("../helpers/order-merger/order-merger");
+const order_modifier_1 = require("../helpers/order-modifier/order-modifier");
+const order_state_machine_1 = require("../helpers/order-state-machine/order-state-machine");
+const payment_state_machine_1 = require("../helpers/payment-state-machine/payment-state-machine");
+const refund_state_machine_1 = require("../helpers/refund-state-machine/refund-state-machine");
+const shipping_calculator_1 = require("../helpers/shipping-calculator/shipping-calculator");
+const order_utils_1 = require("../helpers/utils/order-utils");
+const patch_entity_1 = require("../helpers/utils/patch-entity");
+const translate_entity_1 = require("../helpers/utils/translate-entity");
+const channel_service_1 = require("./channel.service");
+const country_service_1 = require("./country.service");
+const customer_service_1 = require("./customer.service");
+const fulfillment_service_1 = require("./fulfillment.service");
+const history_service_1 = require("./history.service");
+const payment_method_service_1 = require("./payment-method.service");
+const payment_service_1 = require("./payment.service");
+const product_variant_service_1 = require("./product-variant.service");
+const promotion_service_1 = require("./promotion.service");
+const stock_movement_service_1 = require("./stock-movement.service");
+let OrderService = class OrderService {
+    constructor(connection, configService, productVariantService, customerService, countryService, orderCalculator, shippingCalculator, orderStateMachine, orderMerger, paymentService, paymentStateMachine, paymentMethodService, fulfillmentService, listQueryBuilder, stockMovementService, refundStateMachine, historyService, promotionService, eventBus, channelService, orderModifier, customFieldRelationService, requestCache) {
+        this.connection = connection;
+        this.configService = configService;
+        this.productVariantService = productVariantService;
+        this.customerService = customerService;
+        this.countryService = countryService;
+        this.orderCalculator = orderCalculator;
+        this.shippingCalculator = shippingCalculator;
+        this.orderStateMachine = orderStateMachine;
+        this.orderMerger = orderMerger;
+        this.paymentService = paymentService;
+        this.paymentStateMachine = paymentStateMachine;
+        this.paymentMethodService = paymentMethodService;
+        this.fulfillmentService = fulfillmentService;
+        this.listQueryBuilder = listQueryBuilder;
+        this.stockMovementService = stockMovementService;
+        this.refundStateMachine = refundStateMachine;
+        this.historyService = historyService;
+        this.promotionService = promotionService;
+        this.eventBus = eventBus;
+        this.channelService = channelService;
+        this.orderModifier = orderModifier;
+        this.customFieldRelationService = customFieldRelationService;
+        this.requestCache = requestCache;
+    }
+    getOrderProcessStates() {
+        return Object.entries(this.orderStateMachine.config.transitions).map(([name, { to }]) => ({
+            name,
+            to,
+        }));
+    }
+    findAll(ctx, options) {
+        return this.listQueryBuilder
+            .build(order_entity_1.Order, options, {
+            ctx,
+            relations: [
+                'lines',
+                'customer',
+                'lines.productVariant',
+                'lines.items',
+                'channels',
+                'shippingLines',
+            ],
+            channelId: ctx.channelId,
+            customPropertyMap: {
+                customerLastName: 'customer.lastName',
+            },
+        })
+            .getManyAndCount()
+            .then(([items, totalItems]) => {
+            return {
+                items,
+                totalItems,
+            };
+        });
+    }
+    async findOne(ctx, orderId) {
+        const qb = this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder('order')
+            .leftJoin('order.channels', 'channel')
+            .leftJoinAndSelect('order.customer', 'customer')
+            .leftJoinAndSelect('order.shippingLines', 'shippingLines')
+            .leftJoinAndSelect('order.surcharges', 'surcharges')
+            .leftJoinAndSelect('customer.user', 'user')
+            .leftJoinAndSelect('order.lines', 'lines')
+            .leftJoinAndSelect('lines.productVariant', 'productVariant')
+            .leftJoinAndSelect('productVariant.taxCategory', 'prodVariantTaxCategory')
+            .leftJoinAndSelect('productVariant.productVariantPrices', 'prices')
+            .leftJoinAndSelect('productVariant.translations', 'translations')
+            .leftJoinAndSelect('lines.featuredAsset', 'featuredAsset')
+            .leftJoinAndSelect('lines.items', 'items')
+            .leftJoinAndSelect('items.fulfillments', 'fulfillments')
+            .leftJoinAndSelect('lines.taxCategory', 'lineTaxCategory')
+            .where('order.id = :orderId', { orderId })
+            .andWhere('channel.id = :channelId', { channelId: ctx.channelId })
+            .addOrderBy('lines.createdAt', 'ASC')
+            .addOrderBy('items.createdAt', 'ASC');
+        FindOptionsUtils_1.FindOptionsUtils.joinEagerRelations(qb, qb.alias, qb.expressionMap.mainAlias.metadata);
+        const order = await qb.getOne();
+        if (order) {
+            for (const line of order.lines) {
+                line.productVariant = translate_entity_1.translateDeep(await this.productVariantService.applyChannelPriceAndTax(line.productVariant, ctx, order), ctx.languageCode);
+            }
+            return order;
+        }
+    }
+    async findOneByCode(ctx, orderCode) {
+        const order = await this.connection.getRepository(ctx, order_entity_1.Order).findOne({
+            relations: ['customer'],
+            where: {
+                code: orderCode,
+            },
+        });
+        return order ? this.findOne(ctx, order.id) : undefined;
+    }
+    async findByCustomerId(ctx, customerId, options) {
+        return this.listQueryBuilder
+            .build(order_entity_1.Order, options, {
+            relations: [
+                'lines',
+                'lines.items',
+                'lines.productVariant',
+                'lines.productVariant.options',
+                'customer',
+                'channels',
+                'shippingLines',
+            ],
+            channelId: ctx.channelId,
+            ctx,
+        })
+            .andWhere('order.customer.id = :customerId', { customerId })
+            .getManyAndCount()
+            .then(([items, totalItems]) => {
+            items.forEach(item => {
+                item.lines.forEach(line => {
+                    line.productVariant = translate_entity_1.translateDeep(line.productVariant, ctx.languageCode, [
+                        'options',
+                    ]);
+                });
+            });
+            return {
+                items,
+                totalItems,
+            };
+        });
+    }
+    getOrderPayments(ctx, orderId) {
+        return this.connection.getRepository(ctx, payment_entity_1.Payment).find({
+            relations: ['refunds'],
+            where: {
+                order: { id: orderId },
+            },
+        });
+    }
+    async getRefundOrderItems(ctx, refundId) {
+        const refund = await this.connection.getEntityOrThrow(ctx, refund_entity_1.Refund, refundId, {
+            relations: ['orderItems'],
+        });
+        return refund.orderItems;
+    }
+    getOrderModifications(ctx, orderId) {
+        return this.connection.getRepository(ctx, order_modification_entity_1.OrderModification).find({
+            where: {
+                order: orderId,
+            },
+            relations: ['orderItems', 'payment', 'refund', 'surcharges'],
+        });
+    }
+    getPaymentRefunds(ctx, paymentId) {
+        return this.connection.getRepository(ctx, refund_entity_1.Refund).find({
+            where: {
+                paymentId,
+            },
+        });
+    }
+    async getActiveOrderForUser(ctx, userId) {
+        const customer = await this.customerService.findOneByUserId(ctx, userId);
+        if (customer) {
+            const activeOrder = await this.connection
+                .getRepository(ctx, order_entity_1.Order)
+                .createQueryBuilder('order')
+                .innerJoinAndSelect('order.channels', 'channel', 'channel.id = :channelId', {
+                channelId: ctx.channelId,
+            })
+                .leftJoinAndSelect('order.customer', 'customer')
+                .leftJoinAndSelect('order.shippingLines', 'shippingLines')
+                .where('order.active = :active', { active: true })
+                .andWhere('order.customer.id = :customerId', { customerId: customer.id })
+                .orderBy('order.createdAt', 'DESC')
+                .getOne();
+            if (activeOrder) {
+                return this.findOne(ctx, activeOrder.id);
+            }
+        }
+    }
+    async create(ctx, userId) {
+        const newOrder = new order_entity_1.Order({
+            code: await this.configService.orderOptions.orderCodeStrategy.generate(ctx),
+            state: this.orderStateMachine.getInitialState(),
+            lines: [],
+            surcharges: [],
+            couponCodes: [],
+            modifications: [],
+            shippingAddress: {},
+            billingAddress: {},
+            subTotal: 0,
+            subTotalWithTax: 0,
+            currencyCode: ctx.channel.currencyCode,
+        });
+        if (userId) {
+            const customer = await this.customerService.findOneByUserId(ctx, userId);
+            if (customer) {
+                newOrder.customer = customer;
+            }
+        }
+        await this.channelService.assignToCurrentChannel(newOrder, ctx);
+        const order = await this.connection.getRepository(ctx, order_entity_1.Order).save(newOrder);
+        this.eventBus.publish(new index_2.OrderEvent(ctx, order, 'created'));
+        const transitionResult = await this.transitionToState(ctx, order.id, 'AddingItems');
+        if (error_result_1.isGraphQlErrorResult(transitionResult)) {
+            throw transitionResult;
+        }
+        return transitionResult;
+    }
+    async updateCustomFields(ctx, orderId, customFields) {
+        let order = await this.getOrderOrThrow(ctx, orderId);
+        order = patch_entity_1.patchEntity(order, { customFields });
+        await this.customFieldRelationService.updateRelations(ctx, order_entity_1.Order, { customFields }, order);
+        const updatedOrder = await this.connection.getRepository(ctx, order_entity_1.Order).save(order);
+        this.eventBus.publish(new index_2.OrderEvent(ctx, updatedOrder, 'updated'));
+        return updatedOrder;
+    }
+    async addItemToOrder(ctx, orderId, productVariantId, quantity, customFields) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const existingOrderLine = await this.orderModifier.getExistingOrderLine(ctx, order, productVariantId, customFields);
+        const validationError = this.assertQuantityIsPositive(quantity) ||
+            this.assertAddingItemsState(order) ||
+            this.assertNotOverOrderItemsLimit(order, quantity) ||
+            this.assertNotOverOrderLineItemsLimit(existingOrderLine, quantity);
+        if (validationError) {
+            return validationError;
+        }
+        const variant = await this.connection.getEntityOrThrow(ctx, product_variant_entity_1.ProductVariant, productVariantId, {
+            relations: ['product'],
+            where: {
+                enabled: true,
+                deletedAt: null,
+            },
+        });
+        if (variant.product.enabled === false) {
+            throw new errors_1.EntityNotFoundError('ProductVariant', productVariantId);
+        }
+        const correctedQuantity = await this.orderModifier.constrainQuantityToSaleable(ctx, variant, quantity, existingOrderLine === null || existingOrderLine === void 0 ? void 0 : existingOrderLine.quantity);
+        if (correctedQuantity === 0) {
+            return new generated_graphql_shop_errors_1.InsufficientStockError(correctedQuantity, order);
+        }
+        const orderLine = await this.orderModifier.getOrCreateOrderLine(ctx, order, productVariantId, customFields);
+        if (correctedQuantity < quantity) {
+            const newQuantity = (existingOrderLine ? existingOrderLine === null || existingOrderLine === void 0 ? void 0 : existingOrderLine.quantity : 0) + correctedQuantity;
+            await this.orderModifier.updateOrderLineQuantity(ctx, orderLine, newQuantity, order);
+        }
+        else {
+            await this.orderModifier.updateOrderLineQuantity(ctx, orderLine, correctedQuantity, order);
+        }
+        const quantityWasAdjustedDown = correctedQuantity < quantity;
+        const updatedOrder = await this.applyPriceAdjustments(ctx, order, [orderLine]);
+        if (quantityWasAdjustedDown) {
+            return new generated_graphql_shop_errors_1.InsufficientStockError(correctedQuantity, updatedOrder);
+        }
+        else {
+            return updatedOrder;
+        }
+    }
+    async adjustOrderLine(ctx, orderId, orderLineId, quantity, customFields) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const orderLine = this.getOrderLineOrThrow(order, orderLineId);
+        const validationError = this.assertAddingItemsState(order) ||
+            this.assertQuantityIsPositive(quantity) ||
+            this.assertNotOverOrderItemsLimit(order, quantity - orderLine.quantity) ||
+            this.assertNotOverOrderLineItemsLimit(orderLine, quantity - orderLine.quantity);
+        if (validationError) {
+            return validationError;
+        }
+        if (customFields != null) {
+            orderLine.customFields = customFields;
+            await this.customFieldRelationService.updateRelations(ctx, order_line_entity_1.OrderLine, { customFields }, orderLine);
+        }
+        const correctedQuantity = await this.orderModifier.constrainQuantityToSaleable(ctx, orderLine.productVariant, quantity);
+        let updatedOrderLines = [orderLine];
+        if (correctedQuantity === 0) {
+            order.lines = order.lines.filter(l => !utils_1.idsAreEqual(l.id, orderLine.id));
+            await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).remove(orderLine);
+            this.eventBus.publish(new index_5.OrderLineEvent(ctx, order, orderLine, 'deleted'));
+            updatedOrderLines = [];
+        }
+        else {
+            await this.orderModifier.updateOrderLineQuantity(ctx, orderLine, correctedQuantity, order);
+        }
+        const quantityWasAdjustedDown = correctedQuantity < quantity;
+        const updatedOrder = await this.applyPriceAdjustments(ctx, order, updatedOrderLines);
+        if (quantityWasAdjustedDown) {
+            return new generated_graphql_shop_errors_1.InsufficientStockError(correctedQuantity, updatedOrder);
+        }
+        else {
+            return updatedOrder;
+        }
+    }
+    async removeItemFromOrder(ctx, orderId, orderLineId) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const validationError = this.assertAddingItemsState(order);
+        if (validationError) {
+            return validationError;
+        }
+        const orderLine = this.getOrderLineOrThrow(order, orderLineId);
+        order.lines = order.lines.filter(line => !utils_1.idsAreEqual(line.id, orderLineId));
+        const updatedOrder = await this.applyPriceAdjustments(ctx, order);
+        await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).remove(orderLine);
+        this.eventBus.publish(new index_5.OrderLineEvent(ctx, order, orderLine, 'deleted'));
+        return updatedOrder;
+    }
+    async removeAllItemsFromOrder(ctx, orderId) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const validationError = this.assertAddingItemsState(order);
+        if (validationError) {
+            return validationError;
+        }
+        await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).remove(order.lines);
+        order.lines = [];
+        const updatedOrder = await this.applyPriceAdjustments(ctx, order);
+        return updatedOrder;
+    }
+    async addSurchargeToOrder(ctx, orderId, surchargeInput) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const surcharge = await this.connection.getRepository(ctx, surcharge_entity_1.Surcharge).save(new surcharge_entity_1.Surcharge(Object.assign({ taxLines: [], sku: '', listPriceIncludesTax: ctx.channel.pricesIncludeTax, order }, surchargeInput)));
+        order.surcharges.push(surcharge);
+        const updatedOrder = await this.applyPriceAdjustments(ctx, order);
+        return updatedOrder;
+    }
+    async removeSurchargeFromOrder(ctx, orderId, surchargeId) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const surcharge = await this.connection.getEntityOrThrow(ctx, surcharge_entity_1.Surcharge, surchargeId);
+        if (order.surcharges.find(s => utils_1.idsAreEqual(s.id, surcharge.id))) {
+            order.surcharges = order.surcharges.filter(s => !utils_1.idsAreEqual(s.id, surchargeId));
+            const updatedOrder = await this.applyPriceAdjustments(ctx, order);
+            await this.connection.getRepository(ctx, surcharge_entity_1.Surcharge).remove(surcharge);
+            return updatedOrder;
+        }
+        else {
+            return order;
+        }
+    }
+    async applyCouponCode(ctx, orderId, couponCode) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        if (order.couponCodes.includes(couponCode)) {
+            return order;
+        }
+        const validationResult = await this.promotionService.validateCouponCode(ctx, couponCode, order.customer && order.customer.id);
+        if (error_result_1.isGraphQlErrorResult(validationResult)) {
+            return validationResult;
+        }
+        order.couponCodes.push(couponCode);
+        await this.historyService.createHistoryEntryForOrder({
+            ctx,
+            orderId: order.id,
+            type: generated_types_1.HistoryEntryType.ORDER_COUPON_APPLIED,
+            data: { couponCode, promotionId: validationResult.id },
+        });
+        this.eventBus.publish(new index_1.CouponCodeEvent(ctx, couponCode, orderId, 'assigned'));
+        return this.applyPriceAdjustments(ctx, order);
+    }
+    async removeCouponCode(ctx, orderId, couponCode) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        if (order.couponCodes.includes(couponCode)) {
+            const affectedOrderItems = order.lines
+                .reduce((items, l) => [...items, ...l.items], [])
+                .filter(i => i.adjustments.filter(a => a.type === generated_types_1.AdjustmentType.DISTRIBUTED_ORDER_PROMOTION)
+                .length);
+            order.couponCodes = order.couponCodes.filter(cc => cc !== couponCode);
+            await this.historyService.createHistoryEntryForOrder({
+                ctx,
+                orderId: order.id,
+                type: generated_types_1.HistoryEntryType.ORDER_COUPON_REMOVED,
+                data: { couponCode },
+            });
+            this.eventBus.publish(new index_1.CouponCodeEvent(ctx, couponCode, orderId, 'removed'));
+            const result = await this.applyPriceAdjustments(ctx, order);
+            await this.connection.getRepository(ctx, order_item_entity_1.OrderItem).save(affectedOrderItems);
+            return result;
+        }
+        else {
+            return order;
+        }
+    }
+    async getOrderPromotions(ctx, orderId) {
+        const order = await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, orderId, {
+            channelId: ctx.channelId,
+            relations: ['promotions'],
+        });
+        return order.promotions || [];
+    }
+    getNextOrderStates(order) {
+        return this.orderStateMachine.getNextStates(order);
+    }
+    async setShippingAddress(ctx, orderId, input) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const country = await this.countryService.findOneByCode(ctx, input.countryCode);
+        order.shippingAddress = Object.assign(Object.assign({}, input), { countryCode: input.countryCode, country: country.name });
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(order);
+        this.requestCache.set(ctx, 'activeTaxZone', undefined);
+        return this.applyPriceAdjustments(ctx, order, order.lines);
+    }
+    async setBillingAddress(ctx, orderId, input) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const country = await this.countryService.findOneByCode(ctx, input.countryCode);
+        order.billingAddress = Object.assign(Object.assign({}, input), { countryCode: input.countryCode, country: country.name });
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(order);
+        this.requestCache.set(ctx, 'activeTaxZone', undefined);
+        return this.applyPriceAdjustments(ctx, order, order.lines);
+    }
+    async getEligibleShippingMethods(ctx, orderId) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const eligibleMethods = await this.shippingCalculator.getEligibleShippingMethods(ctx, order);
+        return eligibleMethods.map(eligible => {
+            const { price, taxRate, priceIncludesTax, metadata } = eligible.result;
+            return {
+                id: eligible.method.id,
+                price: priceIncludesTax ? tax_utils_1.netPriceOf(price, taxRate) : price,
+                priceWithTax: priceIncludesTax ? price : tax_utils_1.grossPriceOf(price, taxRate),
+                description: eligible.method.description,
+                name: eligible.method.name,
+                code: eligible.method.code,
+                metadata,
+                customFields: eligible.method.customFields,
+            };
+        });
+    }
+    async getEligiblePaymentMethods(ctx, orderId) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        return this.paymentMethodService.getEligiblePaymentMethods(ctx, order);
+    }
+    async setShippingMethod(ctx, orderId, shippingMethodId) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const validationError = this.assertAddingItemsState(order);
+        if (validationError) {
+            return validationError;
+        }
+        const shippingMethod = await this.shippingCalculator.getMethodIfEligible(ctx, order, shippingMethodId);
+        if (!shippingMethod) {
+            return new generated_graphql_shop_errors_1.IneligibleShippingMethodError();
+        }
+        let shippingLine = order.shippingLines[0];
+        if (shippingLine) {
+            shippingLine.shippingMethod = shippingMethod;
+        }
+        else {
+            shippingLine = await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(new shipping_line_entity_1.ShippingLine({
+                shippingMethod,
+                order,
+                adjustments: [],
+                listPrice: 0,
+                listPriceIncludesTax: ctx.channel.pricesIncludeTax,
+                taxLines: [],
+            }));
+            order.shippingLines = [shippingLine];
+        }
+        await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(shippingLine);
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
+        await this.applyPriceAdjustments(ctx, order);
+        return this.connection.getRepository(ctx, order_entity_1.Order).save(order);
+    }
+    async transitionToState(ctx, orderId, state) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        order.payments = await this.getOrderPayments(ctx, orderId);
+        const fromState = order.state;
+        try {
+            await this.orderStateMachine.transition(ctx, order, state);
+        }
+        catch (e) {
+            const transitionError = ctx.translate(e.message, { fromState, toState: state });
+            return new generated_graphql_shop_errors_1.OrderStateTransitionError(transitionError, fromState, state);
+        }
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
+        this.eventBus.publish(new index_3.OrderStateTransitionEvent(fromState, state, ctx, order));
+        return order;
+    }
+    async transitionFulfillmentToState(ctx, fulfillmentId, state) {
+        const result = await this.fulfillmentService.transitionToState(ctx, fulfillmentId, state);
+        if (error_result_1.isGraphQlErrorResult(result)) {
+            return result;
+        }
+        const { fulfillment, fromState, toState, orders } = result;
+        if (toState === 'Cancelled') {
+            await this.stockMovementService.createCancellationsForOrderItems(ctx, fulfillment.orderItems);
+            const lines = await this.groupOrderItemsIntoLines(ctx, fulfillment.orderItems);
+            await this.stockMovementService.createAllocationsForOrderLines(ctx, lines);
+        }
+        await Promise.all(orders.map(order => this.handleFulfillmentStateTransitByOrder(ctx, order, fromState, toState)));
+        return fulfillment;
+    }
+    async modifyOrder(ctx, input) {
+        await this.connection.startTransaction(ctx);
+        const order = await this.getOrderOrThrow(ctx, input.orderId);
+        const result = await this.orderModifier.modifyOrder(ctx, input, order);
+        if (input.dryRun) {
+            await this.connection.rollBackTransaction(ctx);
+            return error_result_1.isGraphQlErrorResult(result) ? result : result.order;
+        }
+        if (error_result_1.isGraphQlErrorResult(result)) {
+            await this.connection.rollBackTransaction(ctx);
+            return result;
+        }
+        await this.historyService.createHistoryEntryForOrder({
+            ctx,
+            orderId: input.orderId,
+            type: generated_types_1.HistoryEntryType.ORDER_MODIFIED,
+            data: {
+                modificationId: result.modification.id,
+            },
+        });
+        await this.connection.commitOpenTransaction(ctx);
+        return this.getOrderOrThrow(ctx, input.orderId);
+    }
+    async handleFulfillmentStateTransitByOrder(ctx, order, fromState, toState) {
+        const nextOrderStates = this.getNextOrderStates(order);
+        const transitionOrderIfStateAvailable = (state) => nextOrderStates.includes(state) && this.transitionToState(ctx, order.id, state);
+        if (toState === 'Shipped') {
+            const orderWithFulfillment = await this.getOrderWithFulfillments(ctx, order.id);
+            if (order_utils_1.orderItemsAreShipped(orderWithFulfillment)) {
+                await transitionOrderIfStateAvailable('Shipped');
+            }
+            else {
+                await transitionOrderIfStateAvailable('PartiallyShipped');
+            }
+        }
+        if (toState === 'Delivered') {
+            const orderWithFulfillment = await this.getOrderWithFulfillments(ctx, order.id);
+            if (order_utils_1.orderItemsAreDelivered(orderWithFulfillment)) {
+                await transitionOrderIfStateAvailable('Delivered');
+            }
+            else {
+                await transitionOrderIfStateAvailable('PartiallyDelivered');
+            }
+        }
+    }
+    async transitionPaymentToState(ctx, paymentId, state) {
+        const result = await this.paymentService.transitionToState(ctx, paymentId, state);
+        if (error_result_1.isGraphQlErrorResult(result)) {
+            return result;
+        }
+        const order = await this.findOne(ctx, result.order.id);
+        if (order) {
+            order.payments = await this.getOrderPayments(ctx, order.id);
+            await this.transitionOrderIfTotalIsCovered(ctx, order);
+        }
+        return result;
+    }
+    async addPaymentToOrder(ctx, orderId, input) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        if (order.state !== 'ArrangingPayment') {
+            return new generated_graphql_shop_errors_1.OrderPaymentStateError();
+        }
+        order.payments = await this.getOrderPayments(ctx, order.id);
+        const amountToPay = order.totalWithTax - order_utils_1.totalCoveredByPayments(order);
+        const payment = await this.paymentService.createPayment(ctx, order, amountToPay, input.method, input.metadata);
+        if (error_result_1.isGraphQlErrorResult(payment)) {
+            return payment;
+        }
+        const existingPayments = await this.getOrderPayments(ctx, orderId);
+        order.payments = [...existingPayments, payment];
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
+        if (payment.state === 'Error') {
+            return new generated_graphql_shop_errors_1.PaymentFailedError(payment.errorMessage || '');
+        }
+        if (payment.state === 'Declined') {
+            return new generated_graphql_shop_errors_1.PaymentDeclinedError(payment.errorMessage || '');
+        }
+        return this.transitionOrderIfTotalIsCovered(ctx, order);
+    }
+    async transitionOrderIfTotalIsCovered(ctx, order) {
+        const orderId = order.id;
+        if (order_utils_1.orderTotalIsCovered(order, 'Settled') && order.state !== 'PaymentSettled') {
+            return this.transitionToState(ctx, orderId, 'PaymentSettled');
+        }
+        if (order_utils_1.orderTotalIsCovered(order, ['Authorized', 'Settled']) && order.state !== 'PaymentAuthorized') {
+            return this.transitionToState(ctx, orderId, 'PaymentAuthorized');
+        }
+        return order;
+    }
+    async addManualPaymentToOrder(ctx, input) {
+        const order = await this.getOrderOrThrow(ctx, input.orderId);
+        if (order.state !== 'ArrangingAdditionalPayment' && order.state !== 'ArrangingPayment') {
+            return new generated_graphql_admin_errors_1.ManualPaymentStateError();
+        }
+        const existingPayments = await this.getOrderPayments(ctx, order.id);
+        order.payments = existingPayments;
+        const amount = order.totalWithTax - order_utils_1.totalCoveredByPayments(order);
+        const modifications = await this.getOrderModifications(ctx, order.id);
+        const unsettledModifications = modifications.filter(m => !m.isSettled);
+        if (0 < unsettledModifications.length) {
+            const outstandingModificationsTotal = shared_utils_1.summate(unsettledModifications, 'priceChange');
+            if (outstandingModificationsTotal !== amount) {
+                throw new errors_1.InternalServerError(`The outstanding order amount (${amount}) should equal the unsettled OrderModifications total (${outstandingModificationsTotal})`);
+            }
+        }
+        const payment = await this.paymentService.createManualPayment(ctx, order, amount, input);
+        order.payments.push(payment);
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
+        for (const modification of unsettledModifications) {
+            modification.payment = payment;
+            await this.connection.getRepository(ctx, order_modification_entity_1.OrderModification).save(modification);
+        }
+        return order;
+    }
+    async settlePayment(ctx, paymentId) {
+        const payment = await this.paymentService.settlePayment(ctx, paymentId);
+        if (!error_result_1.isGraphQlErrorResult(payment)) {
+            if (payment.state !== 'Settled') {
+                return new generated_graphql_admin_errors_1.SettlePaymentError(payment.errorMessage || '');
+            }
+            const order = await this.findOne(ctx, payment.order.id);
+            if (order) {
+                order.payments = await this.getOrderPayments(ctx, order.id);
+                const orderTransitionResult = await this.transitionOrderIfTotalIsCovered(ctx, order);
+                if (error_result_1.isGraphQlErrorResult(orderTransitionResult)) {
+                    return orderTransitionResult;
+                }
+            }
+        }
+        return payment;
+    }
+    async createFulfillment(ctx, input) {
+        if (!input.lines || input.lines.length === 0 || shared_utils_1.summate(input.lines, 'quantity') === 0) {
+            return new generated_graphql_admin_errors_1.EmptyOrderLineSelectionError();
+        }
+        const ordersAndItems = await this.getOrdersAndItemsFromLines(ctx, input.lines, i => !i.fulfillment && !i.cancelled);
+        if (!ordersAndItems) {
+            return new generated_graphql_admin_errors_1.ItemsAlreadyFulfilledError();
+        }
+        const stockCheckResult = await this.ensureSufficientStockForFulfillment(ctx, input);
+        if (error_result_1.isGraphQlErrorResult(stockCheckResult)) {
+            return stockCheckResult;
+        }
+        const fulfillment = await this.fulfillmentService.create(ctx, ordersAndItems.orders, ordersAndItems.items, input.handler);
+        if (error_result_1.isGraphQlErrorResult(fulfillment)) {
+            return fulfillment;
+        }
+        await this.stockMovementService.createSalesForOrder(ctx, ordersAndItems.items);
+        for (const order of ordersAndItems.orders) {
+            await this.historyService.createHistoryEntryForOrder({
+                ctx,
+                orderId: order.id,
+                type: generated_types_1.HistoryEntryType.ORDER_FULFILLMENT,
+                data: {
+                    fulfillmentId: fulfillment.id,
+                },
+            });
+        }
+        const result = await this.fulfillmentService.transitionToState(ctx, fulfillment.id, 'Pending');
+        if (error_result_1.isGraphQlErrorResult(result)) {
+            return result;
+        }
+        return result.fulfillment;
+    }
+    async ensureSufficientStockForFulfillment(ctx, input) {
+        const lines = await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).findByIds(input.lines.map(l => l.orderLineId), { relations: ['productVariant'] });
+        for (const line of lines) {
+            const lineInput = input.lines.find(l => utils_1.idsAreEqual(l.orderLineId, line.id));
+            const fulfillableStockLevel = await this.productVariantService.getFulfillableStockLevel(ctx, line.productVariant);
+            if (fulfillableStockLevel < lineInput.quantity) {
+                const productVariant = translate_entity_1.translateDeep(line.productVariant, ctx.languageCode);
+                return new generated_graphql_admin_errors_1.InsufficientStockOnHandError(productVariant.id, productVariant.name, productVariant.stockOnHand);
+            }
+        }
+    }
+    async getOrderFulfillments(ctx, order) {
+        var _a, _b, _c, _d;
+        let lines;
+        if (((_d = (_c = (_b = (_a = order.lines) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.items) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.fulfillments) !== undefined) {
+            lines = order.lines;
+        }
+        else {
+            lines = await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).find({
+                where: {
+                    order: order.id,
+                },
+                relations: ['items', 'items.fulfillments'],
+            });
+        }
+        const items = lines.reduce((acc, l) => [...acc, ...l.items], []);
+        const fulfillments = items.reduce((acc, i) => [...acc, ...(i.fulfillments || [])], []);
+        return unique_1.unique(fulfillments, 'id');
+    }
+    async getOrderSurcharges(ctx, orderId) {
+        const order = await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, orderId, {
+            channelId: ctx.channelId,
+            relations: ['surcharges'],
+        });
+        return order.surcharges || [];
+    }
+    async cancelOrder(ctx, input) {
+        let allOrderItemsCancelled = false;
+        const cancelResult = input.lines != null
+            ? await this.cancelOrderByOrderLines(ctx, input, input.lines)
+            : await this.cancelOrderById(ctx, input);
+        if (error_result_1.isGraphQlErrorResult(cancelResult)) {
+            return cancelResult;
+        }
+        else {
+            allOrderItemsCancelled = cancelResult;
+        }
+        if (allOrderItemsCancelled) {
+            const transitionResult = await this.transitionToState(ctx, input.orderId, 'Cancelled');
+            if (error_result_1.isGraphQlErrorResult(transitionResult)) {
+                return transitionResult;
+            }
+        }
+        return utils_1.assertFound(this.findOne(ctx, input.orderId));
+    }
+    async cancelOrderById(ctx, input) {
+        const order = await this.getOrderOrThrow(ctx, input.orderId);
+        if (order.active) {
+            return true;
+        }
+        else {
+            const lines = order.lines.map(l => ({
+                orderLineId: l.id,
+                quantity: l.quantity,
+            }));
+            return this.cancelOrderByOrderLines(ctx, input, lines);
+        }
+    }
+    async cancelOrderByOrderLines(ctx, input, lines) {
+        if (lines.length === 0 || shared_utils_1.summate(lines, 'quantity') === 0) {
+            return new generated_graphql_admin_errors_1.EmptyOrderLineSelectionError();
+        }
+        const ordersAndItems = await this.getOrdersAndItemsFromLines(ctx, lines, i => !i.cancelled);
+        if (!ordersAndItems) {
+            return new generated_graphql_admin_errors_1.QuantityTooGreatError();
+        }
+        if (1 < ordersAndItems.orders.length) {
+            return new generated_graphql_admin_errors_1.MultipleOrderError();
+        }
+        const { orders, items } = ordersAndItems;
+        const order = orders[0];
+        if (!utils_1.idsAreEqual(order.id, input.orderId)) {
+            return new generated_graphql_admin_errors_1.MultipleOrderError();
+        }
+        if (order.active) {
+            return new generated_graphql_admin_errors_1.CancelActiveOrderError(order.state);
+        }
+        const fullOrder = await this.findOne(ctx, order.id);
+        const soldItems = items.filter(i => !!i.fulfillment);
+        const allocatedItems = items.filter(i => !i.fulfillment);
+        await this.stockMovementService.createCancellationsForOrderItems(ctx, soldItems);
+        await this.stockMovementService.createReleasesForOrderItems(ctx, allocatedItems);
+        items.forEach(i => (i.cancelled = true));
+        await this.connection.getRepository(ctx, order_item_entity_1.OrderItem).save(items, { reload: false });
+        const orderWithItems = await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, order.id, {
+            relations: ['lines', 'lines.items', 'surcharges', 'shippingLines'],
+        });
+        if (input.cancelShipping === true) {
+            for (const shippingLine of orderWithItems.shippingLines) {
+                shippingLine.adjustments.push({
+                    adjustmentSource: 'CANCEL_ORDER',
+                    type: generated_types_1.AdjustmentType.OTHER,
+                    description: 'shipping cancellation',
+                    amount: -shippingLine.discountedPriceWithTax,
+                });
+                this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(shippingLine, { reload: false });
+            }
+        }
+        this.orderCalculator.calculateOrderTotals(orderWithItems);
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(orderWithItems, { reload: false });
+        await this.historyService.createHistoryEntryForOrder({
+            ctx,
+            orderId: order.id,
+            type: generated_types_1.HistoryEntryType.ORDER_CANCELLATION,
+            data: {
+                orderItemIds: items.map(i => i.id),
+                reason: input.reason || undefined,
+                shippingCancelled: !!input.cancelShipping,
+            },
+        });
+        return order_utils_1.orderItemsAreAllCancelled(orderWithItems);
+    }
+    async refundOrder(ctx, input) {
+        if ((!input.lines || input.lines.length === 0 || shared_utils_1.summate(input.lines, 'quantity') === 0) &&
+            input.shipping === 0) {
+            return new generated_graphql_admin_errors_1.NothingToRefundError();
+        }
+        const ordersAndItems = await this.getOrdersAndItemsFromLines(ctx, input.lines, i => { var _a; return ((_a = i.refund) === null || _a === void 0 ? void 0 : _a.state) !== 'Settled'; });
+        if (!ordersAndItems) {
+            return new generated_graphql_admin_errors_1.QuantityTooGreatError();
+        }
+        const { orders, items } = ordersAndItems;
+        if (1 < orders.length) {
+            return new generated_graphql_admin_errors_1.MultipleOrderError();
+        }
+        const payment = await this.connection.getEntityOrThrow(ctx, payment_entity_1.Payment, input.paymentId, {
+            relations: ['order'],
+        });
+        if (orders && orders.length && !utils_1.idsAreEqual(payment.order.id, orders[0].id)) {
+            return new generated_graphql_admin_errors_1.PaymentOrderMismatchError();
+        }
+        const order = payment.order;
+        if (order.state === 'AddingItems' ||
+            order.state === 'ArrangingPayment' ||
+            order.state === 'PaymentAuthorized') {
+            return new generated_graphql_admin_errors_1.RefundOrderStateError(order.state);
+        }
+        const alreadyRefunded = items.find(i => { var _a, _b; return ((_a = i.refund) === null || _a === void 0 ? void 0 : _a.state) === 'Pending' || ((_b = i.refund) === null || _b === void 0 ? void 0 : _b.state) === 'Settled'; });
+        if (alreadyRefunded) {
+            return new generated_graphql_admin_errors_1.AlreadyRefundedError(alreadyRefunded.refundId);
+        }
+        return await this.paymentService.createRefund(ctx, input, order, items, payment);
+    }
+    async settleRefund(ctx, input) {
+        const refund = await this.connection.getEntityOrThrow(ctx, refund_entity_1.Refund, input.id, {
+            relations: ['payment', 'payment.order'],
+        });
+        refund.transactionId = input.transactionId;
+        const fromState = refund.state;
+        const toState = 'Settled';
+        await this.refundStateMachine.transition(ctx, refund.payment.order, refund, toState);
+        await this.connection.getRepository(ctx, refund_entity_1.Refund).save(refund);
+        this.eventBus.publish(new index_4.RefundStateTransitionEvent(fromState, toState, ctx, refund, refund.payment.order));
+        return refund;
+    }
+    async addCustomerToOrder(ctx, orderId, customer) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        order.customer = customer;
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
+        if (order.couponCodes) {
+            let codesRemoved = false;
+            for (const couponCode of order.couponCodes.slice()) {
+                const validationResult = await this.promotionService.validateCouponCode(ctx, couponCode, customer.id);
+                if (error_result_1.isGraphQlErrorResult(validationResult)) {
+                    order.couponCodes = order.couponCodes.filter(c => c !== couponCode);
+                    codesRemoved = true;
+                }
+            }
+            if (codesRemoved) {
+                return this.applyPriceAdjustments(ctx, order);
+            }
+        }
+        return order;
+    }
+    async addNoteToOrder(ctx, input) {
+        const order = await this.getOrderOrThrow(ctx, input.id);
+        await this.historyService.createHistoryEntryForOrder({
+            ctx,
+            orderId: order.id,
+            type: generated_types_1.HistoryEntryType.ORDER_NOTE,
+            data: {
+                note: input.note,
+            },
+        }, input.isPublic);
+        return order;
+    }
+    async updateOrderNote(ctx, input) {
+        var _a;
+        return this.historyService.updateOrderHistoryEntry(ctx, {
+            type: generated_types_1.HistoryEntryType.ORDER_NOTE,
+            data: input.note ? { note: input.note } : undefined,
+            isPublic: (_a = input.isPublic) !== null && _a !== void 0 ? _a : undefined,
+            ctx,
+            entryId: input.noteId,
+        });
+    }
+    async deleteOrderNote(ctx, id) {
+        try {
+            await this.historyService.deleteOrderHistoryEntry(ctx, id);
+            return {
+                result: generated_types_1.DeletionResult.DELETED,
+            };
+        }
+        catch (e) {
+            return {
+                result: generated_types_1.DeletionResult.NOT_DELETED,
+                message: e.message,
+            };
+        }
+    }
+    async mergeOrders(ctx, user, guestOrder, existingOrder) {
+        if (guestOrder && guestOrder.customer) {
+            return existingOrder;
+        }
+        const mergeResult = await this.orderMerger.merge(ctx, guestOrder, existingOrder);
+        const { orderToDelete, linesToInsert, linesToDelete, linesToModify } = mergeResult;
+        let { order } = mergeResult;
+        if (orderToDelete) {
+            for (const shippingLine of orderToDelete.shippingLines) {
+                await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).delete(shippingLine.id);
+            }
+            await this.connection.getRepository(ctx, order_entity_1.Order).delete(orderToDelete.id);
+        }
+        if (order && linesToInsert) {
+            const orderId = order.id;
+            for (const line of linesToInsert) {
+                const result = await this.addItemToOrder(ctx, orderId, line.productVariantId, line.quantity, line.customFields);
+                if (!error_result_1.isGraphQlErrorResult(result)) {
+                    order = result;
+                }
+            }
+        }
+        if (order && linesToModify) {
+            const orderId = order.id;
+            for (const line of linesToModify) {
+                const result = await this.adjustOrderLine(ctx, orderId, line.orderLineId, line.quantity, line.customFields);
+                if (!error_result_1.isGraphQlErrorResult(result)) {
+                    order = result;
+                }
+            }
+        }
+        if (order && linesToDelete) {
+            const orderId = order.id;
+            for (const line of linesToDelete) {
+                const result = await this.removeItemFromOrder(ctx, orderId, line.orderLineId);
+                if (!error_result_1.isGraphQlErrorResult(result)) {
+                    order = result;
+                }
+            }
+        }
+        const customer = await this.customerService.findOneByUserId(ctx, user.id);
+        if (order && customer) {
+            order.customer = customer;
+            await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
+        }
+        return order;
+    }
+    async getOrderOrThrow(ctx, orderId) {
+        const order = await this.findOne(ctx, orderId);
+        if (!order) {
+            throw new errors_1.EntityNotFoundError('Order', orderId);
+        }
+        return order;
+    }
+    getOrderLineOrThrow(order, orderLineId) {
+        const orderLine = order.lines.find(line => utils_1.idsAreEqual(line.id, orderLineId));
+        if (!orderLine) {
+            throw new errors_1.UserInputError(`error.order-does-not-contain-line-with-id`, { id: orderLineId });
+        }
+        return orderLine;
+    }
+    assertQuantityIsPositive(quantity) {
+        if (quantity < 0) {
+            return new generated_graphql_shop_errors_1.NegativeQuantityError();
+        }
+    }
+    assertAddingItemsState(order) {
+        if (order.state !== 'AddingItems') {
+            return new generated_graphql_shop_errors_1.OrderModificationError();
+        }
+    }
+    assertNotOverOrderItemsLimit(order, quantityToAdd) {
+        const currentItemsCount = shared_utils_1.summate(order.lines, 'quantity');
+        const { orderItemsLimit } = this.configService.orderOptions;
+        if (orderItemsLimit < currentItemsCount + quantityToAdd) {
+            return new generated_graphql_shop_errors_1.OrderLimitError(orderItemsLimit);
+        }
+    }
+    assertNotOverOrderLineItemsLimit(orderLine, quantityToAdd) {
+        const currentQuantity = (orderLine === null || orderLine === void 0 ? void 0 : orderLine.quantity) || 0;
+        const { orderLineItemsLimit } = this.configService.orderOptions;
+        if (orderLineItemsLimit < currentQuantity + quantityToAdd) {
+            return new generated_graphql_shop_errors_1.OrderLimitError(orderLineItemsLimit);
+        }
+    }
+    async applyPriceAdjustments(ctx, order, updatedOrderLines) {
+        var _a, _b;
+        if (updatedOrderLines === null || updatedOrderLines === void 0 ? void 0 : updatedOrderLines.length) {
+            const { orderItemPriceCalculationStrategy, changedPriceHandlingStrategy } = this.configService.orderOptions;
+            for (const updatedOrderLine of updatedOrderLines) {
+                const variant = await this.productVariantService.applyChannelPriceAndTax(updatedOrderLine.productVariant, ctx, order);
+                let priceResult = await orderItemPriceCalculationStrategy.calculateUnitPrice(ctx, variant, updatedOrderLine.customFields || {});
+                const initialListPrice = (_b = (_a = updatedOrderLine.items.find(i => i.initialListPrice != null)) === null || _a === void 0 ? void 0 : _a.initialListPrice) !== null && _b !== void 0 ? _b : priceResult.price;
+                if (initialListPrice !== priceResult.price) {
+                    priceResult = await changedPriceHandlingStrategy.handlePriceChange(ctx, priceResult, updatedOrderLine.items);
+                }
+                for (const item of updatedOrderLine.items) {
+                    if (item.initialListPrice == null) {
+                        item.initialListPrice = initialListPrice;
+                    }
+                    item.listPrice = priceResult.price;
+                    item.listPriceIncludesTax = priceResult.priceIncludesTax;
+                }
+            }
+        }
+        const { items: promotions } = await this.promotionService.findAll(ctx, {
+            filter: { enabled: { eq: true } },
+            sort: { priorityScore: 'ASC' },
+        });
+        const updatedItems = await this.orderCalculator.applyPriceAdjustments(ctx, order, promotions, updatedOrderLines !== null && updatedOrderLines !== void 0 ? updatedOrderLines : []);
+        const updateFields = [
+            'initialListPrice',
+            'listPrice',
+            'listPriceIncludesTax',
+            'adjustments',
+            'taxLines',
+        ];
+        await this.connection
+            .getRepository(ctx, order_item_entity_1.OrderItem)
+            .createQueryBuilder()
+            .insert()
+            .into(order_item_entity_1.OrderItem, [...updateFields, 'id', 'lineId'])
+            .values(updatedItems)
+            .orUpdate({
+            conflict_target: ['id'],
+            overwrite: updateFields,
+        })
+            .updateEntity(false)
+            .execute();
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
+        await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(order.shippingLines, { reload: false });
+        return order;
+    }
+    async getOrderWithFulfillments(ctx, orderId) {
+        return await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, orderId, {
+            relations: ['lines', 'lines.items', 'lines.items.fulfillments'],
+        });
+    }
+    async getOrdersAndItemsFromLines(ctx, orderLinesInput, itemMatcher) {
+        const orders = new Map();
+        const items = new Map();
+        const lines = await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).findByIds(orderLinesInput.map(l => l.orderLineId), {
+            relations: ['order', 'items', 'items.fulfillments', 'order.channels', 'items.refund'],
+            order: { id: 'ASC' },
+        });
+        for (const line of lines) {
+            const inputLine = orderLinesInput.find(l => utils_1.idsAreEqual(l.orderLineId, line.id));
+            if (!inputLine) {
+                continue;
+            }
+            const order = line.order;
+            if (!order.channels.some(channel => channel.id === ctx.channelId)) {
+                throw new errors_1.EntityNotFoundError('Order', order.id);
+            }
+            if (!orders.has(order.id)) {
+                orders.set(order.id, order);
+            }
+            const matchingItems = line.items.sort((a, b) => (a.id < b.id ? -1 : 1)).filter(itemMatcher);
+            if (matchingItems.length < inputLine.quantity) {
+                return false;
+            }
+            matchingItems.slice(0, inputLine.quantity).forEach(item => {
+                items.set(item.id, item);
+            });
+        }
+        return {
+            orders: Array.from(orders.values()),
+            items: Array.from(items.values()),
+        };
+    }
+    mergePaymentMetadata(m1, m2) {
+        if (!m2) {
+            return m1;
+        }
+        const merged = Object.assign(Object.assign({}, m1), m2);
+        if (m1.public && m1.public) {
+            merged.public = Object.assign(Object.assign({}, m1.public), m2.public);
+        }
+        return merged;
+    }
+    async groupOrderItemsIntoLines(ctx, orderItems) {
+        const orderLineIdQuantityMap = new Map();
+        for (const item of orderItems) {
+            const quantity = orderLineIdQuantityMap.get(item.lineId);
+            if (quantity == null) {
+                orderLineIdQuantityMap.set(item.lineId, 1);
+            }
+            else {
+                orderLineIdQuantityMap.set(item.lineId, quantity + 1);
+            }
+        }
+        const orderLines = await this.connection
+            .getRepository(ctx, order_line_entity_1.OrderLine)
+            .findByIds([...orderLineIdQuantityMap.keys()], {
+            relations: ['productVariant'],
+        });
+        return orderLines.map(orderLine => ({
+            orderLine,
+            quantity: orderLineIdQuantityMap.get(orderLine.id),
+        }));
+    }
+};
+OrderService = __decorate([
+    common_1.Injectable(),
+    __metadata("design:paramtypes", [transactional_connection_1.TransactionalConnection,
+        config_service_1.ConfigService,
+        product_variant_service_1.ProductVariantService,
+        customer_service_1.CustomerService,
+        country_service_1.CountryService,
+        order_calculator_1.OrderCalculator,
+        shipping_calculator_1.ShippingCalculator,
+        order_state_machine_1.OrderStateMachine,
+        order_merger_1.OrderMerger,
+        payment_service_1.PaymentService,
+        payment_state_machine_1.PaymentStateMachine,
+        payment_method_service_1.PaymentMethodService,
+        fulfillment_service_1.FulfillmentService,
+        list_query_builder_1.ListQueryBuilder,
+        stock_movement_service_1.StockMovementService,
+        refund_state_machine_1.RefundStateMachine,
+        history_service_1.HistoryService,
+        promotion_service_1.PromotionService,
+        event_bus_1.EventBus,
+        channel_service_1.ChannelService,
+        order_modifier_1.OrderModifier,
+        custom_field_relation_service_1.CustomFieldRelationService,
+        request_context_cache_service_1.RequestContextCacheService])
+], OrderService);
+exports.OrderService = OrderService;
+//# sourceMappingURL=order.service.js.map