@pvh-afl/graphql 1.0.23 → 1.0.24

package/dist/order-tracking/order-tracking.service.d.ts

@@ -1,35 +1,57 @@
-import { IntegrationFactory, ConfigService } from '@pvh-afl/core';
+import { ConfigService } from '@pvh-afl/core';
 import { OrderTrackingInput, OrderTrackingResult } from './order-tracking.types';
 /**
  * Order Tracking Service
  *
- * Combines data from Omuni OMS and Shopify Admin API for unified tracking.
+ * Fetches comprehensive order tracking data from Shopify Admin API.
  */
 export declare class OrderTrackingService {
-    private readonly integrationFactory;
     private readonly configService;
-    private readonly SHOPIFY_API_VERSION;
-    constructor(integrationFactory: IntegrationFactory, configService: ConfigService);
+    constructor(configService: ConfigService);
     /**
-     * Get unified order tracking information from Omuni and Shopify.
+     * Get complete order tracking information from Shopify.
      */
     getOrderTracking(brand: string, input: OrderTrackingInput): Promise<OrderTrackingResult>;
     /**
-     * Fetch order tracking data from Omuni OMS.
+     * Fetch complete order details from Shopify Admin API.
      */
-    private fetchFromOmuni;
+    private fetchFromShopify;
     /**
-     * Fetch order details and fulfillment events from Shopify Admin API.
+     * Get tracking URL from fulfillment.
      */
-    private fetchFromShopify;
+    private getTrackingUrl;
     /**
      * Map Shopify order to OrderDetails type.
      */
     private mapOrderDetails;
+    /**
+     * Map line items from Shopify order.
+     */
+    private mapLineItems;
+    /**
+     * Map cancellation info if order was cancelled.
+     */
+    private mapCancellation;
+    /**
+     * Map returns from Shopify order.
+     */
+    private mapReturns;
+    /**
+     * Map refunds from Shopify order.
+     */
+    private mapRefunds;
     /**
      * Build tracking timeline from Shopify fulfillment events.
      */
     private buildTrackingTimeline;
+    /**
+     * Map Shopify money to OrderMoney type.
+     */
+    private mapMoney;
+    /**
+     * Map Shopify address to OrderAddress type.
+     */
+    private mapAddress;
     /**
      * Format payment gateway names to readable format.
      */

package/dist/order-tracking/order-tracking.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"order-tracking.service.d.ts","sourceRoot":"","sources":["../../src/order-tracking/order-tracking.service.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAGlB,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EAIpB,MAAM,wBAAwB,CAAC;AAwDhC;;;;GAIG;AACH,qBACa,oBAAoB;IAI7B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa;IAJhC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAa;gBAG9B,kBAAkB,EAAE,kBAAkB,EACtC,aAAa,EAAE,aAAa;IAG/C;;OAEG;IACG,gBAAgB,CACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,mBAAmB,CAAC;IAqB/B;;OAEG;YACW,cAAc;IA2D5B;;OAEG;YACW,gBAAgB;IAqH9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAmCvB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAyF7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA6B3B;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAiB9B"}
+{"version":3,"file":"order-tracking.service.d.ts","sourceRoot":"","sources":["../../src/order-tracking/order-tracking.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAU,MAAM,eAAe,CAAC;AACtD,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EAWpB,MAAM,wBAAwB,CAAC;AAiJhC;;;;GAIG;AACH,qBACa,oBAAoB;IACnB,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,aAAa;IAEzD;;OAEG;IACG,gBAAgB,CACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,mBAAmB,CAAC;IAkB/B;;OAEG;YACW,gBAAgB;IAoK9B;;OAEG;IACH,OAAO,CAAC,cAAc;IAKtB;;OAEG;IACH,OAAO,CAAC,eAAe;IAiEvB;;OAEG;IACH,OAAO,CAAC,YAAY;IAsBpB;;OAEG;IACH,OAAO,CAAC,eAAe;IA4BvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAyBlB;;OAEG;IACH,OAAO,CAAC,UAAU;IAalB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAwF7B;;OAEG;IACH,OAAO,CAAC,QAAQ;IAOhB;;OAEG;IACH,OAAO,CAAC,UAAU;IAiBlB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA4B3B;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAiB9B"}

package/dist/order-tracking/order-tracking.service.js

@@ -4,93 +4,43 @@ exports.OrderTrackingService = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const core_1 = require("@pvh-afl/core");
+// Cancellation window in minutes
+const CANCELLATION_WINDOW_MINUTES = 30;
 /**
  * Order Tracking Service
  *
- * Combines data from Omuni OMS and Shopify Admin API for unified tracking.
+ * Fetches comprehensive order tracking data from Shopify Admin API.
  */
 let OrderTrackingService = class OrderTrackingService {
-    integrationFactory;
     configService;
-    SHOPIFY_API_VERSION = '2024-01';
-    constructor(integrationFactory, configService) {
-        this.integrationFactory = integrationFactory;
+    constructor(configService) {
         this.configService = configService;
     }
     /**
-     * Get unified order tracking information from Omuni and Shopify.
+     * Get complete order tracking information from Shopify.
      */
     async getOrderTracking(brand, input) {
-        // Fetch from both sources in parallel
-        const [omuniData, shopifyData] = await Promise.all([
-            this.fetchFromOmuni(brand, input),
-            this.fetchFromShopify(brand, input.orderId),
-        ]);
-        // Combine responses
-        return {
-            // Omuni data
-            showLoginOTP: omuniData?.showLoginOTP ?? false,
-            statusTrackingUrl: omuniData?.statusTrackingUrl,
-            logisticsTrackingUrl: omuniData?.logisticsTrackingUrl,
-            itemStatuses: omuniData?.itemStatuses,
-            // Shopify data
-            orderDetails: shopifyData?.orderDetails,
-            trackingTimeline: shopifyData?.trackingTimeline,
-        };
-    }
-    /**
-     * Fetch order tracking data from Omuni OMS.
-     */
-    async fetchFromOmuni(brand, input) {
-        const omsService = this.integrationFactory.get(brand, 'oms');
-        if (!omsService) {
-            core_1.logger.warn('OMS integration not configured, skipping Omuni tracking', { brand });
-            return null;
-        }
-        const request = {
-            entityType: input.entityType ?? 'SHOPIFY',
-            marketPlaceOrderId: input.orderId,
-            showItemStatus: input.showItemStatus !== false ? 'YES' : 'NO',
-        };
-        try {
-            const response = await omsService.trackOrder(request);
-            if (!response.success || !response.data) {
-                core_1.logger.warn('Omuni tracking request failed', {
-                    brand,
-                    orderId: input.orderId,
-                    error: response.error,
-                });
-                return null;
-            }
-            const data = response.data.data;
-            const itemStatuses = data.itemStatus?.map((item) => ({
-                itemId: item.itemId,
-                marketPlaceItemId: item.marketPlaceItemId,
-                status: item.itemStatus,
-            }));
+        const result = await this.fetchFromShopify(brand, input.orderId);
+        if (!result) {
             return {
-                showLoginOTP: data.showLoginOTP ?? false,
-                statusTrackingUrl: data.statusTrackingUrl,
-                logisticsTrackingUrl: data.logisticsTrackingUrl,
-                itemStatuses,
+                trackingUrl: undefined,
+                orderDetails: undefined,
+                trackingTimeline: undefined,
+                lineItems: undefined,
+                cancellation: undefined,
+                returns: undefined,
+                refunds: undefined,
             };
         }
-        catch (error) {
-            core_1.logger.error('Omuni tracking fetch failed', {
-                brand,
-                orderId: input.orderId,
-                error: error instanceof Error ? error.message : 'Unknown',
-            });
-            return null;
-        }
+        return result;
     }
     /**
-     * Fetch order details and fulfillment events from Shopify Admin API.
+     * Fetch complete order details from Shopify Admin API.
      */
     async fetchFromShopify(brand, orderId) {
         const adminConfig = this.getShopifyAdminConfig(brand);
         if (!adminConfig) {
-            core_1.logger.warn('Shopify Admin API not configured, skipping Shopify data', { brand });
+            core_1.logger.warn('Shopify Admin API not configured', { brand });
             return null;
         }
         // Build query filter - support both order name (#1001) and order ID
@@ -105,36 +55,80 @@ let OrderTrackingService = class OrderTrackingService {
               id
               name
               createdAt
+              updatedAt
+              processedAt
               displayFinancialStatus
               displayFulfillmentStatus
               cancelledAt
+              cancelReason
               closedAt
+              confirmed
               paymentGatewayNames
+              channelInformation {
+                app { title }
+                channelDefinition { channelName }
+              }
+              subtotalPriceSet { shopMoney { amount currencyCode } }
+              totalShippingPriceSet { shopMoney { amount currencyCode } }
+              totalTaxSet { shopMoney { amount currencyCode } }
+              totalPriceSet { shopMoney { amount currencyCode } }
+              billingAddress {
+                name firstName lastName
+                address1 address2
+                city province provinceCode
+                country countryCode zip phone
+              }
+              shippingAddress {
+                name firstName lastName
+                address1 address2
+                city province provinceCode
+                country countryCode zip phone
+              }
               shippingLines(first: 5) {
+                edges {
+                  node { title code }
+                }
+              }
+              lineItems(first: 50) {
                 edges {
                   node {
-                    title
-                    code
+                    id name sku quantity variantTitle fulfillmentStatus
+                    originalUnitPriceSet { shopMoney { amount currencyCode } }
+                    originalTotalSet { shopMoney { amount currencyCode } }
+                    image { url }
+                    variant {
+                      selectedOptions { name value }
+                    }
                   }
                 }
               }
               fulfillments {
-                status
-                createdAt
-                deliveredAt
-                estimatedDeliveryAt
-                trackingInfo {
-                  number
-                  company
-                  url
-                }
-                events(first: 20) {
+                id status displayStatus
+                createdAt updatedAt deliveredAt inTransitAt estimatedDeliveryAt
+                trackingInfo { number company url }
+                events(first: 30) {
                   edges {
-                    node {
-                      status
-                      happenedAt
-                      city
-                      province
+                    node { status happenedAt city province message }
+                  }
+                }
+              }
+              refunds {
+                id createdAt note
+                totalRefundedSet { shopMoney { amount currencyCode } }
+              }
+              returns(first: 10) {
+                edges {
+                  node {
+                    id status createdAt
+                    returnLineItems(first: 20) {
+                      edges {
+                        node {
+                          id quantity returnReason
+                          fulfillmentLineItem {
+                            lineItem { name image { url } }
+                          }
+                        }
+                      }
                     }
                   }
                 }
@@ -176,8 +170,13 @@ let OrderTrackingService = class OrderTrackingService {
             }
             const order = orderEdge.node;
             return {
+                trackingUrl: this.getTrackingUrl(order),
                 orderDetails: this.mapOrderDetails(order),
                 trackingTimeline: this.buildTrackingTimeline(order),
+                lineItems: this.mapLineItems(order),
+                cancellation: this.mapCancellation(order),
+                returns: this.mapReturns(order),
+                refunds: this.mapRefunds(order),
             };
         }
         catch (error) {
@@ -189,6 +188,13 @@ let OrderTrackingService = class OrderTrackingService {
             return null;
         }
     }
+    /**
+     * Get tracking URL from fulfillment.
+     */
+    getTrackingUrl(order) {
+        const fulfillment = order.fulfillments?.[0];
+        return fulfillment?.trackingInfo?.[0]?.url;
+    }
     /**
      * Map Shopify order to OrderDetails type.
      */
@@ -202,7 +208,7 @@ let OrderTrackingService = class OrderTrackingService {
             orderStatus = 'cancelled';
         }
         else if (order.displayFulfillmentStatus === 'FULFILLED') {
-            orderStatus = 'fulfilled';
+            orderStatus = fulfillment?.deliveredAt ? 'delivered' : 'fulfilled';
         }
         else if (order.displayFulfillmentStatus === 'PARTIALLY_FULFILLED') {
             orderStatus = 'partially_fulfilled';
@@ -210,22 +216,141 @@ let OrderTrackingService = class OrderTrackingService {
         else if (order.displayFulfillmentStatus === 'IN_PROGRESS') {
             orderStatus = 'processing';
         }
-        // Format payment method
-        const paymentMethod = this.formatPaymentMethod(order.paymentGatewayNames);
+        else if (order.confirmed) {
+            orderStatus = 'confirmed';
+        }
+        // Check if order can be cancelled
+        const orderAgeMinutes = (Date.now() - new Date(order.createdAt).getTime()) / (1000 * 60);
+        const canCancel = !order.cancelledAt &&
+            order.displayFulfillmentStatus === 'UNFULFILLED' &&
+            orderAgeMinutes <= CANCELLATION_WINDOW_MINUTES;
+        let cancellationMessage;
+        if (!canCancel && !order.cancelledAt) {
+            if (order.displayFulfillmentStatus !== 'UNFULFILLED') {
+                cancellationMessage = 'We have already started the shipping process.';
+            }
+            else {
+                cancellationMessage = `Unfortunately, the approximate ${CANCELLATION_WINDOW_MINUTES} minute window for cancelling this order has passed.`;
+            }
+        }
+        // Get channel name
+        const channelName = order.channelInformation?.channelDefinition?.channelName ||
+            order.channelInformation?.app?.title ||
+            'Online Store';
         return {
             orderId: order.id,
             orderName: order.name,
             orderStatus,
             fulfillmentStatus: order.displayFulfillmentStatus?.toLowerCase(),
+            financialStatus: order.displayFinancialStatus?.toLowerCase(),
+            channelName,
             shippingMethod: shippingLine?.title,
-            paymentMethod,
+            paymentMethod: this.formatPaymentMethod(order.paymentGatewayNames),
             trackingNumber: trackingInfo?.number,
             carrierName: trackingInfo?.company,
+            trackingUrl: trackingInfo?.url,
             createdAt: order.createdAt,
-            expectedDeliveryAt: fulfillment?.estimatedDeliveryAt,
+            estimatedDeliveryAt: fulfillment?.estimatedDeliveryAt,
             deliveredAt: fulfillment?.deliveredAt,
+            subtotal: this.mapMoney(order.subtotalPriceSet.shopMoney),
+            shippingCost: this.mapMoney(order.totalShippingPriceSet.shopMoney),
+            totalTax: this.mapMoney(order.totalTaxSet.shopMoney),
+            totalAmount: this.mapMoney(order.totalPriceSet.shopMoney),
+            billingAddress: order.billingAddress ? this.mapAddress(order.billingAddress) : undefined,
+            shippingAddress: order.shippingAddress ? this.mapAddress(order.shippingAddress) : undefined,
+            canCancel,
+            cancellationMessage,
         };
     }
+    /**
+     * Map line items from Shopify order.
+     */
+    mapLineItems(order) {
+        return order.lineItems.edges.map(({ node }) => {
+            const variantOptions = node.variant?.selectedOptions?.map(opt => ({
+                name: opt.name,
+                value: opt.value,
+            })) || [];
+            return {
+                id: node.id,
+                name: node.name,
+                sku: node.sku,
+                quantity: node.quantity,
+                unitPrice: this.mapMoney(node.originalUnitPriceSet.shopMoney),
+                totalPrice: this.mapMoney(node.originalTotalSet.shopMoney),
+                imageUrl: node.image?.url,
+                variantTitle: node.variantTitle,
+                variantOptions,
+                fulfillmentStatus: node.fulfillmentStatus?.toLowerCase(),
+            };
+        });
+    }
+    /**
+     * Map cancellation info if order was cancelled.
+     */
+    mapCancellation(order) {
+        if (!order.cancelledAt) {
+            return undefined;
+        }
+        // Map cancel reason to human readable text
+        const reasonMap = {
+            CUSTOMER: 'Customer requested cancellation',
+            FRAUD: 'Suspected fraudulent order',
+            INVENTORY: 'Items out of stock',
+            DECLINED: 'Payment declined',
+            OTHER: 'Other reason',
+        };
+        const refund = order.refunds?.[0];
+        return {
+            cancelledAt: order.cancelledAt,
+            reason: order.cancelReason ? reasonMap[order.cancelReason] || order.cancelReason : undefined,
+            refund: refund ? {
+                id: refund.id,
+                createdAt: refund.createdAt,
+                totalRefunded: this.mapMoney(refund.totalRefundedSet.shopMoney),
+                note: refund.note,
+            } : undefined,
+        };
+    }
+    /**
+     * Map returns from Shopify order.
+     */
+    mapReturns(order) {
+        const returns = order.returns?.edges;
+        if (!returns || returns.length === 0) {
+            return undefined;
+        }
+        return returns.map(({ node }) => {
+            const items = node.returnLineItems.edges.map(({ node: rli }) => ({
+                id: rli.id,
+                name: rli.fulfillmentLineItem.lineItem.name,
+                quantity: rli.quantity,
+                imageUrl: rli.fulfillmentLineItem.lineItem.image?.url,
+                returnReason: rli.returnReason,
+            }));
+            return {
+                id: node.id,
+                status: node.status,
+                createdAt: node.createdAt,
+                itemCount: items.length,
+                items,
+            };
+        });
+    }
+    /**
+     * Map refunds from Shopify order.
+     */
+    mapRefunds(order) {
+        if (!order.refunds || order.refunds.length === 0) {
+            return undefined;
+        }
+        return order.refunds.map(refund => ({
+            id: refund.id,
+            createdAt: refund.createdAt,
+            totalRefunded: this.mapMoney(refund.totalRefundedSet.shopMoney),
+            note: refund.note,
+        }));
+    }
     /**
      * Build tracking timeline from Shopify fulfillment events.
      */
@@ -233,7 +358,7 @@ let OrderTrackingService = class OrderTrackingService {
         const timeline = [];
         // Define the standard tracking stages
         const stages = [
-            { status: 'ordered', label: 'Ordered' },
+            { status: 'ordered', label: 'Order placed' },
             { status: 'confirmed', label: 'Confirmed' },
             { status: 'in_transit', label: 'Shipped' },
             { status: 'out_for_delivery', label: 'Out for Delivery' },
@@ -249,66 +374,99 @@ let OrderTrackingService = class OrderTrackingService {
         // Map events by status (use latest event for each status)
         const eventsByStatus = new Map();
         for (const event of allEvents) {
-            const normalizedStatus = event.status.toLowerCase().replace(/_/g, '_');
+            const normalizedStatus = event.status.toLowerCase();
             const existing = eventsByStatus.get(normalizedStatus);
             if (!existing || new Date(event.happenedAt) > new Date(existing.happenedAt)) {
                 eventsByStatus.set(normalizedStatus, event);
             }
         }
-        // Always add "Ordered" as first event (from order creation)
-        const orderedEvent = {
-            status: 'ordered',
-            label: 'Ordered',
-            happenedAt: order.createdAt,
-            isCompleted: true,
-            isCurrent: false,
-        };
-        timeline.push(orderedEvent);
-        // Determine current status
-        let currentStatusIndex = 0; // Default to "ordered"
+        // Determine current status index
+        let currentStatusIndex = 0;
         const fulfillment = order.fulfillments?.[0];
-        if (fulfillment) {
-            const fulfillmentStatus = fulfillment.status?.toLowerCase();
-            if (fulfillmentStatus === 'delivered' || fulfillment.deliveredAt) {
-                currentStatusIndex = 4; // delivered
+        if (order.cancelledAt) {
+            currentStatusIndex = -1; // Cancelled
+        }
+        else if (fulfillment) {
+            if (fulfillment.deliveredAt || eventsByStatus.has('delivered')) {
+                currentStatusIndex = 4;
             }
             else if (eventsByStatus.has('out_for_delivery')) {
                 currentStatusIndex = 3;
             }
-            else if (eventsByStatus.has('in_transit') || fulfillmentStatus === 'in_transit') {
+            else if (fulfillment.inTransitAt || eventsByStatus.has('in_transit')) {
                 currentStatusIndex = 2;
             }
             else if (eventsByStatus.has('confirmed') || fulfillment.createdAt) {
                 currentStatusIndex = 1;
             }
         }
-        // Build remaining timeline stages
-        for (let i = 1; i < stages.length; i++) {
+        else if (order.confirmed) {
+            currentStatusIndex = 0;
+        }
+        // Build timeline
+        for (let i = 0; i < stages.length; i++) {
             const stage = stages[i];
             const event = eventsByStatus.get(stage.status);
-            // For "confirmed" stage, use fulfillment creation if no explicit event
-            let happenedAt = event?.happenedAt;
-            if (stage.status === 'confirmed' && !happenedAt && fulfillment?.createdAt) {
-                happenedAt = fulfillment.createdAt;
+            let happenedAt;
+            // Determine timestamp for each stage
+            if (stage.status === 'ordered') {
+                happenedAt = order.createdAt;
+            }
+            else if (stage.status === 'confirmed') {
+                happenedAt = event?.happenedAt || fulfillment?.createdAt;
+            }
+            else if (stage.status === 'in_transit') {
+                happenedAt = event?.happenedAt || fulfillment?.inTransitAt;
             }
-            // For "delivered" stage, use deliveredAt if available
-            if (stage.status === 'delivered' && !happenedAt && fulfillment?.deliveredAt) {
-                happenedAt = fulfillment.deliveredAt;
+            else if (stage.status === 'out_for_delivery') {
+                happenedAt = event?.happenedAt;
             }
-            const isCompleted = i <= currentStatusIndex;
+            else if (stage.status === 'delivered') {
+                happenedAt = event?.happenedAt || fulfillment?.deliveredAt;
+            }
+            const isCompleted = currentStatusIndex >= 0 && i <= currentStatusIndex;
             const isCurrent = i === currentStatusIndex;
             timeline.push({
                 status: stage.status,
                 label: stage.label,
-                happenedAt: happenedAt,
+                happenedAt,
                 city: event?.city,
                 province: event?.province,
+                message: event?.message,
                 isCompleted,
                 isCurrent,
             });
         }
         return timeline;
     }
+    /**
+     * Map Shopify money to OrderMoney type.
+     */
+    mapMoney(money) {
+        return {
+            amount: money.amount,
+            currencyCode: money.currencyCode,
+        };
+    }
+    /**
+     * Map Shopify address to OrderAddress type.
+     */
+    mapAddress(addr) {
+        return {
+            name: addr.name,
+            firstName: addr.firstName,
+            lastName: addr.lastName,
+            address1: addr.address1,
+            address2: addr.address2,
+            city: addr.city,
+            province: addr.province,
+            provinceCode: addr.provinceCode,
+            country: addr.country,
+            countryCode: addr.countryCode,
+            zip: addr.zip,
+            phone: addr.phone,
+        };
+    }
     /**
      * Format payment gateway names to readable format.
      */
@@ -316,7 +474,6 @@ let OrderTrackingService = class OrderTrackingService {
         if (!gatewayNames || gatewayNames.length === 0) {
             return 'Unknown';
         }
-        // Common payment gateway mappings
         const gatewayMap = {
             'cash_on_delivery': 'COD',
             'cod': 'COD',
@@ -328,12 +485,15 @@ let OrderTrackingService = class OrderTrackingService {
             'phonepe': 'PhonePe',
             'upi': 'UPI',
             'gokwik': 'GoKwik',
+            'ideal': 'iDEAL',
         };
         const gateway = gatewayNames[0].toLowerCase();
-        // Check for UPI in gateway name
-        if (gateway.includes('upi')) {
+        if (gateway.includes('upi'))
             return 'UPI';
-        }
+        if (gateway.includes('ideal'))
+            return 'iDEAL';
+        if (gateway.includes('credit') || gateway.includes('card'))
+            return 'Credit Card';
         return gatewayMap[gateway] || this.capitalizeFirst(gatewayNames[0].replace(/_/g, ' '));
     }
     /**
@@ -365,7 +525,6 @@ let OrderTrackingService = class OrderTrackingService {
 exports.OrderTrackingService = OrderTrackingService;
 exports.OrderTrackingService = OrderTrackingService = tslib_1.__decorate([
     (0, common_1.Injectable)(),
-    tslib_1.__metadata("design:paramtypes", [core_1.IntegrationFactory,
-        core_1.ConfigService])
+    tslib_1.__metadata("design:paramtypes", [core_1.ConfigService])
 ], OrderTrackingService);
 //# sourceMappingURL=order-tracking.service.js.map