@shushed/helpers 0.0.202 → 0.0.203-bug-erp-770-20251208155429

package/dist/cjs/src-public/bcOrder.js

@@ -14,6 +14,9 @@ const GBP = "GBP";
 function toMinorUnits(amount) {
     if (typeof amount !== "number" || !isFinite(amount))
         return 0;
+    if (Math.abs(amount) > Number.MAX_SAFE_INTEGER / 100) {
+        return Math.round(Number((amount * 100).toPrecision(15)));
+    }
     return Math.round(amount * 100);
 }
 function money(value) {
@@ -99,28 +102,45 @@ function buildLineGrouping(payload) {
 }
 function transformMasterOrder(payload) {
     const erp_order_id = payload.no || payload.system_id || "";
-    const sale0 = (payload.sales || [])[0];
-    const invoice0 = (payload.invoices || [])[0];
+    const sale0 = Array.isArray(payload.sales) && payload.sales.length > 0 ? payload.sales[0] : undefined;
+    const invoice0 = Array.isArray(payload.invoices) && payload.invoices.length > 0 ? payload.invoices[0] : undefined;
+    const normalizeDateForSort = (dateStr) => {
+        if (!dateStr || typeof dateStr !== 'string')
+            return '';
+        if (dateStr.includes('T'))
+            return dateStr;
+        if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr))
+            return `${dateStr}T00:00:00Z`;
+        try {
+            const date = new Date(dateStr);
+            if (!isNaN(date.getTime()))
+                return date.toISOString();
+        }
+        catch {
+        }
+        return dateStr;
+    };
     const ordered_at_candidates = [];
     if (sale0?.system_created_at)
-        ordered_at_candidates.push(sale0.system_created_at);
+        ordered_at_candidates.push(normalizeDateForSort(String(sale0.system_created_at)));
     if (Array.isArray(payload.invoices) && payload.invoices.length > 0) {
-        const invDates = payload.invoices.map((i) => i.system_created_at).filter(Boolean);
+        const invDates = payload.invoices
+            .map((i) => i.system_created_at)
+            .filter(Boolean)
+            .map((d) => normalizeDateForSort(String(d)));
         ordered_at_candidates.push(...invDates);
     }
     if (payload.ordered_at)
-        ordered_at_candidates.push(String(payload.ordered_at));
+        ordered_at_candidates.push(normalizeDateForSort(String(payload.ordered_at)));
     if (payload.created_at)
-        ordered_at_candidates.push(String(payload.created_at));
-    const orderedAtRaw = ordered_at_candidates.length > 0
-        ? ordered_at_candidates.sort()[0]
+        ordered_at_candidates.push(normalizeDateForSort(String(payload.created_at)));
+    const validDates = ordered_at_candidates.filter(d => d.length > 0);
+    const orderedAtRaw = validDates.length > 0
+        ? validDates.sort()[0]
         : new Date().toISOString();
     let ordered_at;
     try {
-        const dateStr = typeof orderedAtRaw === 'string' && orderedAtRaw.includes('T')
-            ? orderedAtRaw
-            : `${orderedAtRaw}T00:00:00Z`;
-        const date = new Date(dateStr);
+        const date = new Date(orderedAtRaw);
         if (isNaN(date.getTime())) {
             ordered_at = new Date().toISOString();
         }
@@ -133,7 +153,7 @@ function transformMasterOrder(payload) {
     }
     const created_by_raw = sale0?.created_by ?? invoice0?.created_by ?? "";
     const system_created_by = created_by_raw === "SITOO" ? "POS" : created_by_raw === "STOREFRONT" ? "ECOMMERCE" : "SYSTEM";
-    const is_gift = Boolean((sale0?.gift_message && String(sale0.gift_message).trim().length > 0) ||
+    const is_gift = Boolean((sale0?.gift_message && String(sale0?.gift_message).trim().length > 0) ||
         (payload.invoices?.some((i) => (i.gift_message || "").trim().length > 0)));
     const invoiceLinesForReturn = payload.invoices?.flatMap((i) => i.invoice_lines || []) || [];
     const salesLinesFallbackForReturn = (sale0?.sale_lines || []);
@@ -376,16 +396,31 @@ function transformMasterOrder(payload) {
         itemsMap[it.sku].push(it);
     });
     const invoicedLineNos = new Set((payload.invoices || []).flatMap((inv) => (inv?.invoice_lines || []).map((l) => Number(l?.order_line_no || -1))));
-    let invoicesNetMinor = toMinorUnits((payload.invoices || []).reduce((acc, inv) => acc + (inv.amount_excl_vat || 0), 0));
-    let invoicesGrossMinor = toMinorUnits((payload.invoices || []).reduce((acc, inv) => acc + (inv.amount_incl_vat || 0), 0));
+    const isDeliveryItem = (line) => {
+        const desc = String(line?.description || '').trim().toLowerCase();
+        return desc === 'delivery';
+    };
+    let invoicesNetMinor = 0;
+    let invoicesGrossMinor = 0;
+    (payload.invoices || []).forEach((inv) => {
+        (inv.invoice_lines || []).forEach((line) => {
+            if (!isDeliveryItem(line)) {
+                invoicesNetMinor += toMinorUnits(Number(line?.amount || line?.amount_excl_vat || 0));
+                invoicesGrossMinor += toMinorUnits(Number(line?.amount_including_vat || line?.amount_incl_vat || 0));
+            }
+        });
+    });
+    if (invoicesGrossMinor === 0 && (payload.invoices || []).length > 0) {
+        invoicesNetMinor = toMinorUnits((payload.invoices || []).reduce((acc, inv) => acc + (inv.amount_excl_vat || 0), 0));
+        invoicesGrossMinor = toMinorUnits((payload.invoices || []).reduce((acc, inv) => acc + (inv.amount_incl_vat || 0), 0));
+    }
     if (invoicesGrossMinor === 0 && invoicedLineNos.size > 0 && sale0?.sale_lines) {
-        const invoicedSaleLines = (sale0.sale_lines || []).filter((l) => {
-            const lineNo = Number(l?.line_no || -1);
-            const itemNo = String(l?.item_no || l?.no || '').toUpperCase();
-            if (itemNo === 'X DELCHR')
+        const invoicedSaleLines = (sale0?.sale_lines || []).filter((l) => {
+            if (isDeliveryItem(l))
                 return false;
             if (String(l?.type || '').toLowerCase() !== 'item')
                 return false;
+            const lineNo = Number(l?.line_no || -1);
             return invoicedLineNos.has(lineNo);
         });
         invoicesNetMinor = toMinorUnits(invoicedSaleLines.reduce((acc, l) => acc + (Number(l?.amount || 0)), 0));
@@ -393,7 +428,26 @@ function transformMasterOrder(payload) {
     }
     let nonInvSalesNetMinor = 0;
     let nonInvSalesGrossMinor = 0;
-    if (sale0 && (sale0.amount_excl_vat || sale0.amount_incl_vat)) {
+    if (sale0?.sale_lines && sale0.sale_lines.length > 0) {
+        const allSaleLines = (sale0.sale_lines || []).filter((l) => {
+            if (isDeliveryItem(l))
+                return false;
+            if (String(l?.type || '').toLowerCase() !== 'item')
+                return false;
+            return true;
+        });
+        const totalSaleNetMinor = toMinorUnits(allSaleLines.reduce((acc, l) => acc + (Number(l?.amount || 0)), 0));
+        const totalSaleGrossMinor = toMinorUnits(allSaleLines.reduce((acc, l) => acc + (Number(l?.amount_including_vat || 0)), 0));
+        if (invoicesGrossMinor > 0) {
+            nonInvSalesNetMinor = Math.max(0, totalSaleNetMinor - invoicesNetMinor);
+            nonInvSalesGrossMinor = Math.max(0, totalSaleGrossMinor - invoicesGrossMinor);
+        }
+        else {
+            nonInvSalesNetMinor = totalSaleNetMinor;
+            nonInvSalesGrossMinor = totalSaleGrossMinor;
+        }
+    }
+    else if (sale0 && (sale0.amount_excl_vat || sale0.amount_incl_vat)) {
         const saleNetMinor = toMinorUnits(sale0.amount_excl_vat || 0);
         const saleGrossMinor = toMinorUnits(sale0.amount_incl_vat || 0);
         if (invoicesGrossMinor > 0) {
@@ -407,12 +461,11 @@ function transformMasterOrder(payload) {
     }
     else {
         const nonInvoicedSales = (sale0?.sale_lines || []).filter((l) => {
-            const lineNo = Number(l?.line_no || -1);
-            const itemNo = String(l?.item_no || l?.no || '').toUpperCase();
-            if (itemNo === 'X DELCHR')
+            if (isDeliveryItem(l))
                 return false;
             if (String(l?.type || '').toLowerCase() !== 'item')
                 return false;
+            const lineNo = Number(l?.line_no || -1);
             return !invoicedLineNos.has(lineNo);
         });
         nonInvSalesNetMinor = toMinorUnits(nonInvoicedSales.reduce((acc, l) => acc + (Number(l?.amount || 0)), 0));
@@ -557,21 +610,27 @@ function transformMasterOrder(payload) {
             const typeStr = String(l?.type || "").toLowerCase();
             const isItemish = typeStr.includes('item') || looksProduct;
             const isRefund = itemNo.toUpperCase() === 'REFUND';
-            const isDelivery = itemNo.toUpperCase() === 'X DELCHR';
-            if ((l?.quantity || 0) > 0 && isItemish && !isRefund && !isDelivery) {
+            if ((l?.quantity || 0) > 0 && isItemish && !isRefund && !isDeliveryItem(l)) {
                 hasQualifying = true;
                 return s + (l?.amount_including_vat || 0);
             }
             return s;
         }, 0);
-        const add = sum > 0 ? sum : (hasQualifying ? (cm?.amount_incl_vat || 0) : 0);
-        return acc + add;
+        if (!hasQualifying)
+            return acc;
+        if (cm?.amount_incl_vat != null && cm.amount_incl_vat > 0) {
+            return acc + cm.amount_incl_vat;
+        }
+        return acc + sum;
     }, 0);
     const merchReturnGrossFromReturnSales = (payload.sales || []).reduce((acc, sale) => {
         const docTypeRaw = String(sale?.document_type || sale?.documentType || "");
         const isReturnOrder = docTypeRaw.toLowerCase().includes('return');
         if (!isReturnOrder)
             return acc;
+        if (sale?.amount_incl_vat != null && sale.amount_incl_vat > 0) {
+            return acc + sale.amount_incl_vat;
+        }
         const lines = sale?.sale_lines || [];
         let hasQualifying = false;
         const sum = lines.reduce((s, l) => {
@@ -581,15 +640,13 @@ function transformMasterOrder(payload) {
             const typeStr = String(l?.type || "").toLowerCase();
             const isItemish = typeStr.includes('item') || looksProduct;
             const isRefund = itemNo.toUpperCase() === 'REFUND';
-            const isDelivery = itemNo.toUpperCase() === 'X DELCHR';
-            if ((l?.quantity || 0) > 0 && isItemish && !isRefund && !isDelivery) {
+            if ((l?.quantity || 0) > 0 && isItemish && !isRefund && !isDeliveryItem(l)) {
                 hasQualifying = true;
                 return s + (l?.amount_including_vat || 0);
             }
             return s;
         }, 0);
-        const add = sum > 0 ? sum : (hasQualifying ? (sale?.amount_incl_vat || sale?.amount_including_vat || 0) : 0);
-        return acc + add;
+        return acc + (sum > 0 ? sum : (hasQualifying ? (sale?.amount_incl_vat || sale?.amount_including_vat || 0) : 0));
     }, 0);
     const merchReturnGross = merchReturnGrossFromCreditMemos + merchReturnGrossFromReturnSales;
     const hasMerchReturn = merchReturnGross > 0;
@@ -647,12 +704,12 @@ function transformMasterOrder(payload) {
             return acc + (s.amount_incl_vat || 0);
         }
         const lineAmounts = (s.shipment_lines || []).reduce((lineAcc, l) => {
-            const itemNo = String(l?.item_no || l?.no || "").toUpperCase();
-            if (itemNo === 'X DELCHR')
+            if (isDeliveryItem(l))
                 return lineAcc;
             const orderLineNo = Number(l?.order_line_no || -1);
             let sourceLine = orderLineNo > 0 ? sourceLineMap.get(orderLineNo) : null;
             if (!sourceLine) {
+                const itemNo = String(l?.item_no || l?.no || "").toUpperCase();
                 const variant = String(l?.variant_code || "");
                 const sku = variant ? `${itemNo}-${variant}` : itemNo;
                 sourceLine = sourceLineBySku.get(sku);
@@ -686,85 +743,358 @@ function transformMasterOrder(payload) {
     const shipping_from = invoice0 || sale0 || null;
     const mapPaymentMethod = (code, card) => {
         const c = String(code || '').toUpperCase();
-        if (/(GVOUCHER|VOUCHER|GIFT|EGIFT)/.test(c) || String(card?.service_type || '').toUpperCase().includes('VOUCHER'))
+        const processorId = String(card?.processor_id || '').toUpperCase();
+        const giftCertId = String(card?.gift_certificate_id || '').trim();
+        const cardType = String(card?.type || '').trim().toLowerCase();
+        if (giftCertId.length > 0)
             return 'GIFT-CARD';
-        if (c.includes('ADYEN') && !card?.card_number)
-            return 'APPLE-PAY';
-        if (c.includes('APPLE') || String(card?.service_type || '').toUpperCase().includes('APPLE'))
+        if (cardType === 'gift certificate')
+            return 'GIFT-CARD';
+        if (processorId.includes('GIFT_CERTIFICATE') || processorId.includes('GIFT-CERTIFICATE'))
+            return 'GIFT-CARD';
+        if (/(GVOUCHER|VOUCHER|GIFT|EGIFT)/.test(c))
+            return 'GIFT-CARD';
+        if (c.includes('APPLE'))
             return 'APPLE-PAY';
-        if (card?.transaction_id || card?.card_number)
+        if ((c.includes('PAYPAL') || processorId === 'PAYPAL') && giftCertId.length === 0) {
+            return 'PAYPAL';
+        }
+        if (c.includes('MOTO'))
+            return 'MOTO';
+        if (c.includes('ADYEN') && cardType === 'credit card' && giftCertId.length === 0) {
+            return 'CREDIT-CARD';
+        }
+        const serviceType = String(card?.service_type || '').toUpperCase();
+        if (serviceType.includes('VOUCHER') && giftCertId.length === 0 && processorId !== 'PAYPAL') {
+            return 'GIFT-CARD';
+        }
+        if (card?.card_number)
             return 'CREDIT-CARD';
         return 'OTHER';
     };
-    const journeyFromCreatedBy = (createdBy) => {
-        const v = String(createdBy || '').toUpperCase();
-        if (v === 'SITOO')
-            return 'POS';
-        if (v === 'STOREFRONT')
-            return 'CHECKOUT';
-        if (v === 'CENTRA')
-            return 'CHECKOUT';
-        return 'SYSTEM';
-    };
     const cardPays = (payload.card_payments || []).map((c) => ({
         created_at: c.created_at,
-        amount: c.amount,
-        type: 'Payment',
+        amount: c.mount || c.amount,
+        type: c.type || 'Payment',
         payment_method_code: String(c.service_type || ''),
         transaction_id: c.transaction_id,
         card_number: c.card_number,
         psp_reference: c.psp_reference,
+        gift_certificate_id: c.gift_certificate_id,
+        service_type: c.service_type,
+        processor_id: c.processor_id,
         created_by: invoice0?.created_by || sale0?.created_by,
+        source: 'card_payment',
+        order_no: c.order_no,
+        captured: c.captured,
     }));
     const normalPays = (payload.payments || []).map((p) => ({
         created_at: p.created_at,
         amount: p.amount,
         type: p.type,
         payment_method_code: p.payment_method_code,
-        transaction_id: p.ledger_entry_no ? String(p.ledger_entry_no) : undefined,
+        transaction_id: p.transaction_id,
         card_number: undefined,
         psp_reference: p.psp_reference,
+        payment_gateway_token: p.payment_gateway_token,
+        payment_number: p.payment_number,
+        payment_refund_number: p.payment_refund_number,
+        original_payment_refund_id: p.original_payment_refund_id,
         created_by: p.created_by || invoice0?.created_by || sale0?.created_by,
+        source: 'payment',
+        order_no: p.master_order_no,
+        ledger_entry_no: p.ledger_entry_no,
     }));
     const flat = [...cardPays, ...normalPays];
     const groupsMap = new Map();
-    flat.forEach((p, idx) => {
+    flat.forEach((p) => {
+        try {
+            const isRefund = String(p.type || '').toLowerCase() === 'refund';
+            const logicalType = isRefund ? 'REFUND' : 'CHARGE';
+            let keyBase;
+            const unifiedId = p.transaction_id || p.payment_gateway_token;
+            if (unifiedId) {
+                keyBase = unifiedId;
+            }
+            else if (p.payment_number) {
+                keyBase = `PN:${p.payment_number}`;
+            }
+            else if (!isRefund) {
+                const paymentType = String(p.type || '').toUpperCase();
+                const amount = Number(p.amount || 0);
+                const paymentMethod = String(p.payment_method_code || '').toUpperCase().trim();
+                const orderNo = p.order_no || erp_order_id;
+                if (paymentType === 'CAPTURE' || paymentType === 'AUTHORISATION') {
+                    keyBase = `CHARGE-${orderNo}-${amount}-${paymentMethod}`;
+                }
+                else if (p.gift_certificate_id) {
+                    keyBase = `GIFT:${p.gift_certificate_id}`;
+                }
+                else {
+                    const orderNo = p.order_no || erp_order_id;
+                    const paymentMethod = String(p.payment_method_code || '').toUpperCase().trim();
+                    keyBase = `${orderNo}-${amount}-${paymentMethod}`;
+                }
+            }
+            else {
+                if (p.payment_refund_number) {
+                    keyBase = `PRN:${p.payment_refund_number}`;
+                }
+                else {
+                    const orderNo = p.order_no || erp_order_id;
+                    const amount = Number(p.amount || 0);
+                    const paymentMethod = String(p.payment_method_code || '').toUpperCase().trim();
+                    keyBase = `${orderNo}-${amount}-${paymentMethod}`;
+                }
+            }
+            const key = `${logicalType}:${keyBase}`;
+            const g = groupsMap.get(key) || { entries: [], type: logicalType, key };
+            g.entries.push(p);
+            groupsMap.set(key, g);
+        }
+        catch (error) {
+            console.error(`Error processing payment entry:`, {
+                error: error instanceof Error ? error.message : String(error),
+                payment_type: p?.type,
+                amount: p?.amount,
+                order_no: p?.order_no || erp_order_id,
+                transaction_id: p?.transaction_id,
+                payment_gateway_token: p?.payment_gateway_token,
+            });
+        }
+    });
+    const allPaymentEntriesByOrder = new Map();
+    flat.forEach(p => {
+        const orderNo = p.order_no || erp_order_id;
+        const amount = Number(p.amount || 0);
+        const key = `${orderNo}-${amount}`;
+        if (!allPaymentEntriesByOrder.has(key)) {
+            allPaymentEntriesByOrder.set(key, []);
+        }
+        allPaymentEntriesByOrder.get(key).push(p);
+    });
+    const cardPaymentsByToken = new Map();
+    cardPays.forEach(cp => {
+        if (cp.transaction_id) {
+            cardPaymentsByToken.set(cp.transaction_id, cp);
+        }
+    });
+    const paymentsByOriginalRefundId = new Map();
+    const paymentsByPaymentNumber = new Map();
+    const paymentsByPaymentRefundNumber = new Map();
+    normalPays.forEach(p => {
         const isRefund = String(p.type || '').toLowerCase() === 'refund';
-        const logicalType = isRefund ? 'REFUND' : 'CHARGE';
-        const keyBase = p.transaction_id || `${erp_order_id}-${logicalType}-${idx + 1}`;
-        const key = `${logicalType}:${keyBase}`;
-        const g = groupsMap.get(key) || { entries: [], type: logicalType, key };
-        g.entries.push(p);
-        groupsMap.set(key, g);
+        if (!isRefund) {
+            if (p.original_payment_refund_id) {
+                paymentsByOriginalRefundId.set(p.original_payment_refund_id, p);
+            }
+            if (p.payment_number) {
+                paymentsByPaymentNumber.set(p.payment_number, p);
+            }
+            if (p.payment_refund_number) {
+                paymentsByPaymentRefundNumber.set(p.payment_refund_number, p);
+            }
+        }
     });
-    const payments = Array.from(groupsMap.values()).map((g, i) => {
+    const payments = Array.from(groupsMap.values()).map((g) => {
+        const sortedEntries = [...g.entries].sort((a, b) => {
+            if (a.source === 'card_payment' && b.source !== 'card_payment')
+                return -1;
+            if (b.source === 'card_payment' && a.source !== 'card_payment')
+                return 1;
+            if (a.source === 'payment' && b.source === 'payment') {
+                const aType = String(a.type || '').toUpperCase();
+                const bType = String(b.type || '').toUpperCase();
+                if (aType === 'AUTHORISATION' && bType !== 'AUTHORISATION')
+                    return -1;
+                if (bType === 'AUTHORISATION' && aType !== 'AUTHORISATION')
+                    return 1;
+                if (aType === 'CAPTURE' && bType !== 'CAPTURE' && bType !== 'AUTHORISATION')
+                    return -1;
+                if (bType === 'CAPTURE' && aType !== 'CAPTURE' && aType !== 'AUTHORISATION')
+                    return 1;
+            }
+            return 0;
+        });
         const created_at = g.entries
             .map(e => e.created_at)
             .filter(Boolean)
             .map(d => new Date(d).toISOString())
             .sort()[0] || ordered_at;
-        const amount = Math.max(...g.entries.map(e => Number(e.amount || 0)), 0);
-        const any = g.entries[0] || {};
-        const pm = mapPaymentMethod(any.payment_method_code, any);
-        const transaction_id = (any.transaction_id) || `${erp_order_id}-PAY-${i + 1}`;
-        const psp_reference = any.psp_reference || transaction_id;
-        const created_by = 'CUSTOMER';
-        const journey_label = journeyFromCreatedBy(invoice0?.created_by || sale0?.created_by);
+        const amountInclVat = Math.max(...g.entries.map(e => Number(e.amount || 0)), 0);
+        const amount = money(amountInclVat);
+        const primary = sortedEntries[0] || {};
+        const paymentEntryForMethod = sortedEntries.find(e => e.source === 'payment' && e.payment_method_code);
+        const paymentMethodCode = paymentEntryForMethod?.payment_method_code || primary.payment_method_code;
+        let cardPaymentEntryForMethod = sortedEntries.find(e => e.source === 'card_payment');
+        const groupCardData = {
+            card_number: cardPaymentEntryForMethod?.card_number || sortedEntries.find(e => e.card_number)?.card_number,
+            transaction_id: cardPaymentEntryForMethod?.transaction_id || sortedEntries.find(e => e.transaction_id)?.transaction_id,
+            service_type: cardPaymentEntryForMethod?.service_type || sortedEntries.find(e => e.service_type)?.service_type,
+            processor_id: cardPaymentEntryForMethod?.processor_id || sortedEntries.find(e => e.processor_id)?.processor_id,
+            gift_certificate_id: cardPaymentEntryForMethod?.gift_certificate_id || sortedEntries.find(e => e.gift_certificate_id)?.gift_certificate_id,
+            type: cardPaymentEntryForMethod?.type || sortedEntries.find(e => e.type && e.source === 'card_payment')?.type,
+        };
+        let pm;
+        if (cardPaymentEntryForMethod?.type && String(cardPaymentEntryForMethod.type).trim().toLowerCase() === 'apple pay') {
+            pm = 'APPLE-PAY';
+        }
+        else {
+            pm = mapPaymentMethod(paymentMethodCode, groupCardData);
+        }
+        let cardPaymentEntryForTransaction = sortedEntries.find(e => e.source === 'card_payment' && e.transaction_id);
+        if (!cardPaymentEntryForTransaction && primary.payment_gateway_token) {
+            cardPaymentEntryForTransaction = cardPaymentsByToken.get(primary.payment_gateway_token);
+        }
+        if (!cardPaymentEntryForTransaction && g.type === 'REFUND') {
+            let originalPayment;
+            const refundEntryWithPaymentNumber = sortedEntries.find(e => e.payment_number && String(e.payment_number).trim().length > 0);
+            if (refundEntryWithPaymentNumber?.payment_number) {
+                originalPayment = paymentsByPaymentNumber.get(refundEntryWithPaymentNumber.payment_number);
+            }
+            if (!originalPayment) {
+                const refundEntryWithOriginalId = sortedEntries.find(e => e.original_payment_refund_id);
+                if (refundEntryWithOriginalId?.original_payment_refund_id) {
+                    originalPayment = Array.from(normalPays).find(p => p.ledger_entry_no === refundEntryWithOriginalId.original_payment_refund_id &&
+                        String(p.type || '').toLowerCase() !== 'refund');
+                }
+            }
+            if (!originalPayment) {
+                const refundEntryWithRefundNumber = sortedEntries.find(e => e.payment_refund_number && String(e.payment_refund_number).trim().length > 0);
+                if (refundEntryWithRefundNumber?.payment_refund_number) {
+                    originalPayment = paymentsByPaymentRefundNumber.get(refundEntryWithRefundNumber.payment_refund_number);
+                }
+            }
+            if (originalPayment?.payment_gateway_token) {
+                cardPaymentEntryForTransaction = cardPaymentsByToken.get(originalPayment.payment_gateway_token);
+                if (!cardPaymentEntryForMethod && cardPaymentEntryForTransaction) {
+                    cardPaymentEntryForMethod = cardPaymentEntryForTransaction;
+                    if (cardPaymentEntryForMethod?.type && String(cardPaymentEntryForMethod.type).trim().toLowerCase() === 'apple pay') {
+                        pm = 'APPLE-PAY';
+                    }
+                    else {
+                        const refundCardData = {
+                            card_number: cardPaymentEntryForMethod?.card_number,
+                            transaction_id: cardPaymentEntryForMethod?.transaction_id,
+                            service_type: cardPaymentEntryForMethod?.service_type,
+                            processor_id: cardPaymentEntryForMethod?.processor_id,
+                            gift_certificate_id: cardPaymentEntryForMethod?.gift_certificate_id,
+                            type: cardPaymentEntryForMethod?.type,
+                        };
+                        pm = mapPaymentMethod(paymentMethodCode, refundCardData);
+                    }
+                }
+            }
+        }
+        let transaction_id = null;
+        if (g.type === 'REFUND' && !cardPaymentEntryForTransaction && !primary.transaction_id && !primary.payment_gateway_token) {
+            let originalPaymentForTransaction;
+            const refundEntryWithPaymentNumber = sortedEntries.find(e => e.payment_number && String(e.payment_number).trim().length > 0);
+            if (refundEntryWithPaymentNumber?.payment_number) {
+                originalPaymentForTransaction = paymentsByPaymentNumber.get(refundEntryWithPaymentNumber.payment_number);
+            }
+            if (!originalPaymentForTransaction && primary.original_payment_refund_id) {
+                originalPaymentForTransaction = Array.from(normalPays).find(p => p.ledger_entry_no === primary.original_payment_refund_id &&
+                    String(p.type || '').toLowerCase() !== 'refund');
+            }
+            if (!originalPaymentForTransaction && primary.payment_refund_number) {
+                const refundEntryWithRefundNumber = sortedEntries.find(e => e.payment_refund_number && String(e.payment_refund_number).trim().length > 0);
+                if (refundEntryWithRefundNumber?.payment_refund_number) {
+                    originalPaymentForTransaction = paymentsByPaymentRefundNumber.get(refundEntryWithRefundNumber.payment_refund_number);
+                }
+            }
+            if (originalPaymentForTransaction?.payment_gateway_token) {
+                const originalCardPayment = cardPaymentsByToken.get(originalPaymentForTransaction.payment_gateway_token);
+                transaction_id = originalCardPayment?.transaction_id || null;
+            }
+        }
+        else {
+            transaction_id = cardPaymentEntryForTransaction?.transaction_id || primary.transaction_id || null;
+        }
+        const psp_reference = transaction_id;
+        const paymentCreatedByRaw = invoice0?.created_by || primary.created_by || sale0?.created_by || "";
+        const paymentCreatedByUpper = String(paymentCreatedByRaw).toUpperCase();
+        const isEmail = typeof paymentCreatedByRaw === 'string' && paymentCreatedByRaw.includes('@');
+        const validEnumValues = ['CUSTOMER', 'SYSTEM', 'CENTRA', 'SITOO', 'STOREFRONT', 'MOTO'];
+        const isValidEnum = validEnumValues.includes(paymentCreatedByUpper);
+        const created_by = isEmail
+            ? paymentCreatedByRaw
+            : isValidEnum
+                ? paymentCreatedByUpper
+                : 'MOTO';
+        const journey_label = null;
+        let card_number = sortedEntries.find(e => e.source === 'card_payment' && e.card_number)?.card_number
+            || primary.card_number
+            || null;
+        if (!card_number && g.type === 'REFUND' && cardPaymentEntryForTransaction) {
+            card_number = cardPaymentEntryForTransaction.card_number || null;
+        }
+        let cardPaymentForBrand = sortedEntries.find(e => e.source === 'card_payment' && e.service_type);
+        if (!cardPaymentForBrand && g.type === 'REFUND' && cardPaymentEntryForTransaction) {
+            cardPaymentForBrand = cardPaymentEntryForTransaction;
+        }
+        const card_brand = cardPaymentForBrand?.service_type
+            ? String(cardPaymentForBrand.service_type).trim() || null
+            : null;
+        let status = 'CAPTURED';
+        const isVoucher = pm === 'GIFT-CARD' ||
+            sortedEntries.some(e => e.gift_certificate_id) ||
+            sortedEntries.some(e => /(GVOUCHER|VOUCHER|GIFT|EGIFT)/.test(String(e.payment_method_code || '').toUpperCase())) ||
+            sortedEntries.some(e => String(e.service_type || '').toUpperCase().includes('VOUCHER'));
+        const cardPaymentEntry = sortedEntries.find(e => e.source === 'card_payment');
+        if (isVoucher) {
+            let paymentEntry = g.entries.find(e => e.source === 'payment' &&
+                (String(e.type || '').toUpperCase() === 'PAYMENT' || String(e.type || '').toUpperCase() === 'CAPTURE'));
+            let paymentType = paymentEntry ? String(paymentEntry.type || '').toUpperCase() : '';
+            if (!paymentEntry && g.entries.length > 0) {
+                const firstEntry = g.entries[0];
+                const orderNo = firstEntry.order_no || erp_order_id;
+                const amount = Number(firstEntry.amount || 0);
+                const lookupKey = `${orderNo}-${amount}`;
+                const relatedEntries = allPaymentEntriesByOrder.get(lookupKey) || [];
+                paymentEntry = relatedEntries.find(e => e.source === 'payment' &&
+                    (String(e.type || '').toUpperCase() === 'PAYMENT' || String(e.type || '').toUpperCase() === 'CAPTURE'));
+                paymentType = paymentEntry ? String(paymentEntry.type || '').toUpperCase() : '';
+            }
+            if (paymentType === 'PAYMENT' || paymentType === 'CAPTURE') {
+                status = 'CAPTURED';
+            }
+            else {
+                status = 'FAILED';
+            }
+        }
+        else {
+            if (cardPaymentEntry?.captured === true) {
+                status = 'CAPTURED';
+            }
+            else if (cardPaymentEntry?.captured === false) {
+                status = 'FAILED';
+            }
+            else {
+                const paymentType = String(primary.type || '').toUpperCase();
+                if (paymentType === 'CAPTURE' || paymentType === 'PAYMENT') {
+                    status = 'CAPTURED';
+                }
+                else {
+                    status = 'CAPTURED';
+                }
+            }
+        }
         return {
             type: g.type,
             created_at,
             payment_method: pm,
             transaction_id,
-            card_number: any.card_number || null,
+            card_number,
             card_holder: null,
             card_token: null,
             expiration_month: null,
             expiration_year: null,
             journey_label,
             psp_reference,
-            card_brand: null,
-            status: 'CAPTURED',
-            amount: money(amount),
+            card_brand,
+            status,
+            amount,
             created_by,
         };
     });
@@ -917,8 +1247,10 @@ function transformMasterOrder(payload) {
         return_total,
         net_total,
         shipping_method,
-        payments,
     };
+    if (payments.length > 0) {
+        result.payments = payments;
+    }
     if (shipmentsWithItems.length > 0) {
         result.shipments = shipmentsWithItems;
     }