@solution25/n8n-nodes-shopware 1.4.0

package/dist/nodes/Shopware/v1/actions/order/create.operation.js

@@ -0,0 +1,861 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.description = void 0;
+exports.execute = execute;
+const n8n_workflow_1 = require("n8n-workflow");
+const transport_1 = require("../../transport");
+const fields_1 = require("./fields");
+const utils_1 = require("../../helpers/utils");
+const properties = [
+    {
+        displayName: 'Order Number',
+        name: 'orderNumber',
+        type: 'string',
+        default: '',
+        placeholder: 'e.g. ON752834790',
+        description: 'Optional order identifier',
+    },
+    {
+        displayName: 'Date and Time',
+        name: 'dateAndTime',
+        type: 'dateTime',
+        required: true,
+        default: '',
+        description: 'Optional order date and time',
+    },
+    {
+        displayName: 'Currency',
+        name: 'currency',
+        type: 'options',
+        required: true,
+        typeOptions: {
+            loadOptionsMethod: 'getOrderCurrencies',
+        },
+        default: '',
+        description: 'Choose the order currency from the list',
+    },
+    {
+        displayName: 'State',
+        name: 'state',
+        type: 'options',
+        required: true,
+        typeOptions: {
+            loadOptionsMethod: 'getOrderStates',
+        },
+        default: '',
+        description: 'Choose the order state from the list',
+    },
+    {
+        displayName: 'Guest Order',
+        name: 'guestOrder',
+        type: 'boolean',
+        default: false,
+        description: 'Whether the order is a guest order',
+    },
+    {
+        displayName: 'Guest',
+        name: 'guestUi',
+        placeholder: 'Add Guest Details',
+        type: 'fixedCollection',
+        default: {},
+        typeOptions: {
+            multipleValues: false,
+        },
+        displayOptions: {
+            show: {
+                guestOrder: [true],
+            },
+        },
+        description: 'Add guest order details',
+        options: [
+            {
+                name: 'guestValues',
+                displayName: 'Guest Details',
+                values: [
+                    {
+                        displayName: 'First Name',
+                        name: 'firstName',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        description: 'Guest customer first name',
+                    },
+                    {
+                        displayName: 'Last Name',
+                        name: 'lastName',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        description: 'Guest customer last name',
+                    },
+                    {
+                        displayName: 'Email',
+                        name: 'email',
+                        type: 'string',
+                        placeholder: 'name@email.com',
+                        required: true,
+                        default: '',
+                        description: 'Guest customer email',
+                    },
+                    {
+                        displayName: 'Salutation',
+                        name: 'salutation',
+                        type: 'options',
+                        typeOptions: {
+                            loadOptionsMethod: 'getSalutations',
+                        },
+                        required: true,
+                        default: '',
+                        description: 'Guest customer salutation',
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Billing Address',
+        name: 'billingAddressUi',
+        placeholder: 'Add Billing Address',
+        type: 'fixedCollection',
+        default: {},
+        typeOptions: {
+            multipleValues: false,
+        },
+        displayOptions: {
+            show: {
+                guestOrder: [true],
+            },
+        },
+        description: 'Add guest billing address',
+        options: [
+            {
+                name: 'billingAddressValues',
+                displayName: 'Billing Address',
+                values: [
+                    {
+                        displayName: 'Country',
+                        name: 'country',
+                        type: 'options',
+                        typeOptions: {
+                            loadOptionsMethod: 'getCountries',
+                        },
+                        required: true,
+                        default: '',
+                        description: 'Country of the billing address',
+                    },
+                    {
+                        displayName: 'First Name',
+                        name: 'firstName',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        description: 'Customer first name',
+                    },
+                    {
+                        displayName: 'Last Name',
+                        name: 'lastName',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        description: 'Customer last name',
+                    },
+                    {
+                        displayName: 'City',
+                        name: 'city',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        description: 'Billing address city',
+                    },
+                    {
+                        displayName: 'Street',
+                        name: 'street',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        description: 'Billing address street',
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Shipping Address',
+        name: 'shippingAddressUi',
+        placeholder: 'Add Shipping Address',
+        type: 'fixedCollection',
+        default: {},
+        typeOptions: {
+            multipleValues: false,
+        },
+        displayOptions: {
+            show: {
+                guestOrder: [true],
+            },
+        },
+        description: 'Add guest shipping address',
+        options: [
+            {
+                name: 'shippingAddressValues',
+                displayName: 'Shipping Address',
+                values: [
+                    {
+                        displayName: 'Country',
+                        name: 'country',
+                        type: 'options',
+                        typeOptions: {
+                            loadOptionsMethod: 'getCountries',
+                        },
+                        required: true,
+                        default: '',
+                        description: 'Country of the shipping address',
+                    },
+                    {
+                        displayName: 'First Name',
+                        name: 'firstName',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        description: 'Customer first name',
+                    },
+                    {
+                        displayName: 'Last Name',
+                        name: 'lastName',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        description: 'Customer last name',
+                    },
+                    {
+                        displayName: 'City',
+                        name: 'city',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        description: 'Shipping address city',
+                    },
+                    {
+                        displayName: 'Street',
+                        name: 'street',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        description: 'Shipping address street',
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Sales Channel',
+        name: 'salesChannel',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getSalesChannels',
+        },
+        displayOptions: {
+            show: {
+                guestOrder: [true],
+            },
+        },
+        default: '',
+        description: 'Select sales channel for the guest order',
+    },
+    {
+        displayName: 'Customer Number',
+        name: 'customerNumber',
+        type: 'string',
+        displayOptions: {
+            show: {
+                guestOrder: [false],
+            },
+        },
+        default: '',
+        placeholder: 'e.g. C10001',
+        description: 'Number of the order customer',
+    },
+    {
+        displayName: 'Line Items',
+        name: 'lineItems',
+        placeholder: 'Add Line Item',
+        type: 'fixedCollection',
+        typeOptions: {
+            multipleValues: true,
+        },
+        description: 'Order line items',
+        default: {},
+        options: [
+            {
+                name: 'lineItem',
+                displayName: 'Line Item',
+                values: [
+                    {
+                        displayName: 'Product Number',
+                        name: 'productNumber',
+                        type: 'string',
+                        required: true,
+                        default: '',
+                        placeholder: 'e.g. P10001',
+                        description: 'Line item product number',
+                    },
+                    {
+                        displayName: 'Quantity',
+                        name: 'quantity',
+                        type: 'number',
+                        typeOptions: {
+                            maxValue: 999000000,
+                            minValue: 0,
+                        },
+                        required: true,
+                        default: 1,
+                        placeholder: 'e.g. 5',
+                        description: 'Line item quantity',
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Transactions',
+        name: 'transactions',
+        placeholder: 'Add Transaction',
+        type: 'fixedCollection',
+        typeOptions: {
+            multipleValues: true,
+        },
+        description: 'Order transactions',
+        default: {},
+        options: [
+            {
+                name: 'transaction',
+                displayName: 'Transaction',
+                values: [
+                    {
+                        displayName: 'Payment Method',
+                        name: 'paymentMethod',
+                        type: 'options',
+                        typeOptions: {
+                            loadOptionsMethod: 'getPaymentMethods',
+                        },
+                        required: true,
+                        default: '',
+                        description: 'Transaction payment method',
+                    },
+                    {
+                        displayName: 'State',
+                        name: 'state',
+                        type: 'options',
+                        typeOptions: {
+                            loadOptionsMethod: 'getTransactionStates',
+                        },
+                        required: true,
+                        default: '',
+                        description: 'State of the transaction (e.g. Paid)',
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Deliveries',
+        name: 'deliveries',
+        placeholder: 'Add Delivery',
+        type: 'fixedCollection',
+        typeOptions: {
+            multipleValues: true,
+        },
+        description: 'Order deliveries',
+        default: {},
+        options: [
+            {
+                name: 'delivery',
+                displayName: 'Delivery',
+                values: [
+                    {
+                        displayName: 'Shipping Method',
+                        name: 'shippingMethod',
+                        type: 'options',
+                        typeOptions: {
+                            loadOptionsMethod: 'getShippingMethods',
+                        },
+                        required: true,
+                        default: '',
+                        description: 'Delivery shipping method',
+                    },
+                    {
+                        displayName: 'State',
+                        name: 'state',
+                        type: 'options',
+                        typeOptions: {
+                            loadOptionsMethod: 'getDeliveryStates',
+                        },
+                        required: true,
+                        default: '',
+                        description: 'State of the delivery (e.g. Shipped)',
+                    },
+                    {
+                        displayName: 'Use Customer Shipping Address',
+                        name: 'customerShippingAddress',
+                        type: 'boolean',
+                        default: true,
+                        description: 'Whether to use the customer shipping address',
+                    },
+                    {
+                        displayName: 'Address',
+                        name: 'addressUi',
+                        placeholder: 'Add Address',
+                        type: 'fixedCollection',
+                        default: {},
+                        typeOptions: {
+                            multipleValues: false,
+                        },
+                        displayOptions: {
+                            show: {
+                                customerShippingAddress: [false],
+                            },
+                        },
+                        description: 'Add delivery shipping address',
+                        options: [
+                            {
+                                name: 'addressValues',
+                                displayName: 'Address',
+                                values: [
+                                    {
+                                        displayName: 'Country',
+                                        name: 'country',
+                                        type: 'options',
+                                        typeOptions: {
+                                            loadOptionsMethod: 'getCountries',
+                                        },
+                                        required: true,
+                                        default: '',
+                                        description: 'Country of the shippng address',
+                                    },
+                                    {
+                                        displayName: 'First Name',
+                                        name: 'firstName',
+                                        type: 'string',
+                                        required: true,
+                                        default: '',
+                                        description: 'Customer first name',
+                                    },
+                                    {
+                                        displayName: 'Last Name',
+                                        name: 'lastName',
+                                        type: 'string',
+                                        required: true,
+                                        default: '',
+                                        description: 'Customer last name',
+                                    },
+                                    {
+                                        displayName: 'City',
+                                        name: 'city',
+                                        type: 'string',
+                                        required: true,
+                                        default: '',
+                                        description: 'Shipping address city',
+                                    },
+                                    {
+                                        displayName: 'Street',
+                                        name: 'street',
+                                        type: 'string',
+                                        required: true,
+                                        default: '',
+                                        description: 'Shipping address street',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    },
+];
+const displayOptions = {
+    show: {
+        resource: ['order'],
+        operation: ['create'],
+    },
+};
+exports.description = (0, n8n_workflow_1.updateDisplayOptions)(displayOptions, properties);
+async function execute(items) {
+    const returnData = [];
+    for (let i = 0; i < items.length; i++) {
+        try {
+            const orderId = (0, utils_1.uuidv7)();
+            const customerData = {};
+            const globalDefaults = {};
+            let orderCustomer;
+            const customerNumber = !this.getNodeParameter('guestOrder', i)
+                ? this.getNodeParameter('customerNumber', i)
+                : null;
+            if (customerNumber) {
+                const customer = await utils_1.getCustomerByNumber.call(this, customerNumber, i);
+                globalDefaults.languageId = customer.languageId;
+                globalDefaults.salesChannelId = customer.salesChannelId;
+                customerData.firstName = customer.firstName;
+                customerData.lastName = customer.lastName;
+                customerData.email = customer.email;
+                customerData.salutationId = customer.salutationId;
+                customerData.billingAddress = customer.billingAddress;
+                customerData.shippingAddress = customer.shippingAddress;
+                orderCustomer = {
+                    firstName: customer.firstName,
+                    lastName: customer.lastName,
+                    email: customer.email,
+                    salutationId: customer.salutationId,
+                    customerId: customer.id,
+                    customerNumber,
+                };
+            }
+            else {
+                const guest = this.getNodeParameter('guestUi', i)
+                    .guestValues;
+                const guestBillingAddress = this.getNodeParameter('billingAddressUi', i).billingAddressValues;
+                const guestShippingAddress = this.getNodeParameter('shippingAddressUi', i).shippingAddressValues;
+                globalDefaults.languageId = await utils_1.getDefaultLanguageId.call(this);
+                globalDefaults.salesChannelId = this.getNodeParameter('salesChannel', i);
+                customerData.firstName = guest.firstName;
+                customerData.lastName = guest.lastName;
+                customerData.email = guest.email;
+                customerData.salutationId = guest.salutation;
+                customerData.billingAddress = {
+                    id: (0, utils_1.uuidv7)(),
+                    countryId: guestBillingAddress.country,
+                    firstName: guestBillingAddress.firstName,
+                    lastName: guestBillingAddress.lastName,
+                    city: guestBillingAddress.city,
+                    street: guestBillingAddress.street,
+                };
+                customerData.shippingAddress = {
+                    id: (0, utils_1.uuidv7)(),
+                    countryId: guestShippingAddress.country,
+                    firstName: guestShippingAddress.firstName,
+                    lastName: guestShippingAddress.lastName,
+                    city: guestShippingAddress.city,
+                    street: guestShippingAddress.street,
+                };
+                orderCustomer = {
+                    firstName: guest.firstName,
+                    lastName: guest.lastName,
+                    email: guest.email,
+                    salutationId: guest.salutation,
+                    customerNumber: 'guest-' + (0, n8n_workflow_1.randomString)(6),
+                };
+            }
+            const currencyData = this.getNodeParameter('currency', i).split('-');
+            const nodeLineItems = this.getNodeParameter('lineItems', i).lineItem;
+            if (!nodeLineItems || nodeLineItems.length === 0) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Missing order line items', {
+                    description: 'At least one line item must be provided',
+                    itemIndex: i,
+                });
+            }
+            const lineItems = await Promise.all(nodeLineItems.map(async (lineItem) => {
+                const { identifier, productId, label, states, unitPrice, taxRate } = await utils_1.getLineItemData.call(this, lineItem.productNumber, currencyData[0], i);
+                const quantity = lineItem.quantity;
+                const totalPrice = unitPrice * quantity;
+                const tax = totalPrice * (taxRate / 100);
+                const taxPrice = totalPrice + tax;
+                const price = {
+                    unitPrice,
+                    totalPrice,
+                    quantity,
+                    calculatedTaxes: [
+                        {
+                            tax,
+                            taxRate,
+                            price: taxPrice,
+                        },
+                    ],
+                    taxRules: [
+                        {
+                            taxRate,
+                            percentage: 100,
+                        },
+                    ],
+                };
+                return {
+                    identifier,
+                    productId,
+                    quantity,
+                    label,
+                    states,
+                    price,
+                };
+            }));
+            const defaultTaxRate = await utils_1.getDefaultTaxRate.call(this);
+            const totalPrice = lineItems.reduce((acc, item) => acc + item.price.totalPrice, 0);
+            const orderTax = totalPrice * (defaultTaxRate / 100);
+            const taxPrice = totalPrice + orderTax;
+            const quantity = lineItems.reduce((acc, item) => acc + item.quantity, 0);
+            const price = {
+                netPrice: totalPrice,
+                totalPrice: taxPrice,
+                calculatedTaxes: [
+                    {
+                        tax: orderTax,
+                        taxRate: defaultTaxRate,
+                        price: taxPrice,
+                    },
+                ],
+                taxRules: [
+                    {
+                        taxRate: defaultTaxRate,
+                        percentage: 100,
+                    },
+                ],
+                positionPrice: totalPrice,
+                rawTotal: totalPrice,
+                taxStatus: 'gross',
+            };
+            let transactions = [];
+            const nodeTransactions = this.getNodeParameter('transactions', i).transaction;
+            if (nodeTransactions && nodeTransactions.length > 0) {
+                transactions = nodeTransactions.map((transaction) => {
+                    const amount = {
+                        unitPrice: totalPrice,
+                        totalPrice: taxPrice,
+                        quantity,
+                        calculatedTaxes: [
+                            {
+                                tax: orderTax,
+                                taxRate: defaultTaxRate,
+                                price: taxPrice,
+                            },
+                        ],
+                        taxRules: [
+                            {
+                                taxRate: defaultTaxRate,
+                                percentage: 100,
+                            },
+                        ],
+                    };
+                    return {
+                        paymentMethodId: transaction.paymentMethod,
+                        stateId: transaction.state,
+                        amount,
+                    };
+                });
+            }
+            const addresses = [
+                {
+                    id: customerData.shippingAddress.id,
+                    countryId: customerData.shippingAddress.countryId,
+                    firstName: customerData.shippingAddress.firstName,
+                    lastName: customerData.shippingAddress.lastName,
+                    city: customerData.shippingAddress.city,
+                    street: customerData.shippingAddress.street,
+                },
+            ];
+            let deliveries = [];
+            const nodeDeliveries = this.getNodeParameter('deliveries', i).delivery;
+            if (nodeDeliveries && nodeDeliveries.length > 0) {
+                deliveries = await Promise.all(nodeDeliveries.map(async (delivery) => {
+                    let shippingOrderAddressId;
+                    if (delivery.customerShippingAddress) {
+                        shippingOrderAddressId = addresses[0].id;
+                    }
+                    else {
+                        const address = delivery.addressUi.addressValues;
+                        if (!address) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Missing shipping address', {
+                                description: 'A shipping address must be provided for the selected delivery if not using the customer one',
+                                itemIndex: i,
+                            });
+                        }
+                        for (const key in address) {
+                            if (address[key] === '') {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Missing required value for shipping address', {
+                                    description: `Shipping address ${key} must be a valid value.`,
+                                    itemIndex: i,
+                                });
+                            }
+                        }
+                        shippingOrderAddressId = (0, utils_1.uuidv7)();
+                        addresses.push({
+                            id: shippingOrderAddressId,
+                            countryId: address.country,
+                            firstName: address.firstName,
+                            lastName: address.lastName,
+                            city: address.city,
+                            street: address.street,
+                        });
+                    }
+                    const { ['unitPrice']: shippingPrice, ['taxRate']: shippingTaxRate } = await utils_1.getShippingMethodData.call(this, delivery.shippingMethod, currencyData[0]);
+                    const deliveryTime = await utils_1.getShippingDeliveryTime.call(this, delivery.shippingMethod);
+                    const shippingTax = shippingPrice * (shippingTaxRate / 100);
+                    const shippingTaxPrice = shippingPrice + shippingTax;
+                    const shippingCosts = {
+                        unitPrice: shippingPrice,
+                        totalPrice: shippingPrice,
+                        quantity: 1,
+                        calculatedTaxes: [
+                            {
+                                tax: shippingTax,
+                                taxRate: shippingTaxRate,
+                                price: shippingTaxPrice,
+                            },
+                        ],
+                        taxRules: [
+                            {
+                                taxRate: shippingTaxRate,
+                                percentage: 100,
+                            },
+                        ],
+                    };
+                    const shippingDateEarliest = new Date();
+                    const shippingDateLatest = new Date();
+                    switch (deliveryTime.unit) {
+                        case 'hour':
+                            shippingDateEarliest.setHours(shippingDateEarliest.getHours() + deliveryTime.min);
+                            shippingDateLatest.setHours(shippingDateLatest.getHours() + deliveryTime.max);
+                            break;
+                        case 'day':
+                            shippingDateEarliest.setDate(shippingDateEarliest.getDate() + deliveryTime.min);
+                            shippingDateLatest.setDate(shippingDateLatest.getDate() + deliveryTime.max);
+                            break;
+                        case 'week':
+                            shippingDateEarliest.setDate(shippingDateEarliest.getDate() + deliveryTime.min * 7);
+                            shippingDateLatest.setDate(shippingDateLatest.getDate() + deliveryTime.max * 7);
+                            break;
+                    }
+                    return {
+                        shippingOrderAddressId,
+                        shippingMethodId: delivery.shippingMethod,
+                        stateId: delivery.state,
+                        shippingDateEarliest,
+                        shippingDateLatest,
+                        shippingCosts,
+                    };
+                }));
+            }
+            let shippingCosts;
+            if (deliveries.length === 0) {
+                const defaultShippingMethod = await utils_1.getDefaultShippingMethod.call(this);
+                const { ['unitPrice']: shippingPrice, ['taxRate']: shippingTaxRate } = await utils_1.getShippingMethodData.call(this, defaultShippingMethod, currencyData[0]);
+                const shippingTax = shippingPrice * (shippingTaxRate / 100);
+                const shippingTaxPrice = shippingPrice + shippingTax;
+                shippingCosts = {
+                    unitPrice: shippingPrice,
+                    totalPrice: shippingPrice,
+                    quantity: 1,
+                    calculatedTaxes: [
+                        {
+                            tax: shippingTax,
+                            taxRate: shippingTaxRate,
+                            price: shippingTaxPrice,
+                        },
+                    ],
+                    taxRules: [
+                        {
+                            taxRate: shippingTaxRate,
+                            percentage: 100,
+                        },
+                    ],
+                };
+            }
+            else {
+                const deliveriesUnitPrice = deliveries.reduce((acc, delivery) => acc + delivery.shippingCosts.unitPrice, 0);
+                const deliveriesTax = deliveries.reduce((acc, delivery) => acc + delivery.shippingCosts.calculatedTaxes[0].tax, 0);
+                const deliveriesTaxRate = deliveries[0].shippingCosts.taxRules[0].taxRate;
+                const deliveriesTaxPrice = deliveriesUnitPrice + deliveriesTax;
+                shippingCosts = {
+                    unitPrice: deliveriesUnitPrice,
+                    totalPrice: deliveriesUnitPrice,
+                    quantity: 1,
+                    calculatedTaxes: [
+                        {
+                            tax: deliveriesTax,
+                            taxRate: deliveriesTaxRate,
+                            price: deliveriesTaxPrice,
+                        },
+                    ],
+                    taxRules: [
+                        {
+                            taxRate: deliveriesTaxRate,
+                            percentage: 100,
+                        },
+                    ],
+                };
+            }
+            const parsedItemRounding = JSON.parse(currencyData[3]);
+            const itemRounding = {
+                decimals: parsedItemRounding.decimals,
+                interval: parsedItemRounding.interval,
+                roundForNet: parsedItemRounding.roundForNet,
+            };
+            const parsedTotalRounding = JSON.parse(currencyData[4]);
+            const totalRounding = {
+                decimals: parsedTotalRounding.decimals,
+                interval: parsedTotalRounding.interval,
+                roundForNet: parsedTotalRounding.roundForNet,
+            };
+            const serializedBillingAddress = {
+                id: customerData.billingAddress.id,
+                countryId: customerData.billingAddress.countryId,
+                firstName: customerData.billingAddress.firstName,
+                lastName: customerData.billingAddress.lastName,
+                city: customerData.billingAddress.city,
+                street: customerData.billingAddress.street,
+            };
+            const createBody = {
+                id: orderId,
+                currencyId: currencyData[0],
+                languageId: globalDefaults.languageId,
+                salesChannelId: globalDefaults.salesChannelId,
+                billingAddressId: customerData.billingAddress.id,
+                orderNumber: this.getNodeParameter('orderNumber', i),
+                orderDateTime: this.getNodeParameter('dateAndTime', i),
+                stateId: this.getNodeParameter('state', i),
+                currencyFactor: parseInt(currencyData[2]),
+                itemRounding,
+                totalRounding,
+                orderCustomer,
+                billingAddress: serializedBillingAddress,
+                lineItems,
+                price,
+                shippingCosts,
+                transactions,
+                deliveries,
+                addresses,
+            };
+            const searchBody = {
+                fields: fields_1.orderFields,
+                includes: {
+                    order: fields_1.orderFields,
+                },
+                filter: [{ type: 'equals', field: 'id', value: orderId }],
+            };
+            for (const key in createBody) {
+                const typedKey = key;
+                if (Array.isArray(createBody[typedKey]) &&
+                    createBody[typedKey].length === 0) {
+                    delete createBody[typedKey];
+                }
+                else if (createBody[typedKey] === '') {
+                    delete createBody[typedKey];
+                }
+            }
+            await transport_1.apiRequest.call(this, 'POST', `/order`, createBody);
+            const response = await transport_1.apiRequest.call(this, 'POST', `/search/order`, searchBody);
+            const executionData = this.helpers.constructExecutionMetaData((0, utils_1.wrapData)(response.data), {
+                itemData: { item: i },
+            });
+            returnData.push(...executionData);
+        }
+        catch (error) {
+            if (this.continueOnFail()) {
+                returnData.push({ json: { error: error.message } });
+                continue;
+            }
+            if (error instanceof n8n_workflow_1.NodeOperationError) {
+                throw error;
+            }
+            throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
+        }
+    }
+    return returnData;
+}
+//# sourceMappingURL=create.operation.js.map