paymnet methods cards new table

src/seeders/data/payment-methods.data.ts

@@ -1,4 +1,5 @@
 import { PaymentMethodEnum, PaymentGatewayEnum } from '../../modules/payments/interface/payment';
+import { PaymentMethodCardDto } from '../../modules/payments/dto/payment-method-card.dto';
 
 export interface PaymentMethodData {
   method: PaymentMethodEnum;
@@ -6,12 +7,7 @@ export interface PaymentMethodData {
   enabled: boolean;
   order: number;
   gateway: PaymentGatewayEnum | null;
-  cardNumber?: string;
-  cardNumber2?: string;
-  cardNumber3?: string;
-  cardOwner?: string;
-  cardOwner2?: string;
-  cardOwner3?: string;
+  cards?: PaymentMethodCardDto[];
   merchantId?: string;
 }
 
@@ -44,7 +40,11 @@ export const paymentMethodsData: PaymentMethodData[] = [
     enabled: true,
     order: 4,
     gateway: null,
-    cardNumber: '6037991234567890',
-    cardOwner: 'صاحب کارت',
+    cards: [
+      {
+        cardNumber: '6037991234567890',
+        owner: 'صاحب کارت',
+      },
+    ],
   },
 ];

src/seeders/payment-methods.seeder.ts

@@ -1,18 +1,41 @@
 import type { EntityManager } from '@mikro-orm/core';
 import { PaymentMethod } from '../modules/payments/entities/payment-method.entity';
+import { PaymentMethodCard } from '../modules/payments/entities/payment-method-card.entity';
 import type { Restaurant } from '../modules/restaurants/entities/restaurant.entity';
 import { paymentMethodsData } from './data/payment-methods.data';
 
+function cardsMatch(
+  existing: PaymentMethodCard[],
+  expected: { cardNumber: string; owner: string }[] | undefined,
+): boolean {
+  if (!expected?.length) {
+    return existing.length === 0;
+  }
+
+  if (existing.length !== expected.length) {
+    return false;
+  }
+
+  return expected.every((card, index) => {
+    const current = existing[index];
+    return current.cardNumber === card.cardNumber && current.owner === card.owner;
+  });
+}
+
 export class PaymentMethodsSeeder {
   async run(em: EntityManager, restaurants: Restaurant[]): Promise<void> {
     for (const restaurant of restaurants) {
       if (!restaurant) continue;
 
       for (const methodData of paymentMethodsData) {
-        const existing = await em.findOne(PaymentMethod, {
-          restaurant: { id: restaurant.id },
-          method: methodData.method,
-        });
+        const existing = await em.findOne(
+          PaymentMethod,
+          {
+            restaurant: { id: restaurant.id },
+            method: methodData.method,
+          },
+          { populate: ['cards'] },
+        );
 
         if (!existing) {
           const paymentMethod = em.create(PaymentMethod, {
@@ -22,27 +45,27 @@ export class PaymentMethodsSeeder {
             enabled: methodData.enabled,
             order: methodData.order,
             gateway: methodData.gateway,
-            cardNumber: methodData.cardNumber,
-            cardNumber2: methodData.cardNumber2,
-            cardNumber3: methodData.cardNumber3,
-            cardOwner: methodData.cardOwner,
-            cardOwner2: methodData.cardOwner2,
-            cardOwner3: methodData.cardOwner3,
             merchantId: methodData.merchantId,
           });
+
+          for (const card of methodData.cards ?? []) {
+            paymentMethod.cards.add(
+              em.create(PaymentMethodCard, {
+                paymentMethod,
+                cardNumber: card.cardNumber,
+                owner: card.owner,
+              }),
+            );
+          }
+
           em.persist(paymentMethod);
         } else {
-          // Update existing payment method if needed
+          const existingCards = existing.cards.getItems();
           if (
             existing.description !== methodData.description ||
             existing.enabled !== methodData.enabled ||
             existing.order !== methodData.order ||
-            existing.cardNumber !== methodData.cardNumber ||
-            existing.cardNumber2 !== methodData.cardNumber2 ||
-            existing.cardNumber3 !== methodData.cardNumber3 ||
-            existing.cardOwner !== methodData.cardOwner ||
-            existing.cardOwner2 !== methodData.cardOwner2 ||
-            existing.cardOwner3 !== methodData.cardOwner3
+            !cardsMatch(existingCards, methodData.cards)
           ) {
             existing.description = methodData.description;
             existing.enabled = methodData.enabled;
@@ -50,27 +73,21 @@ export class PaymentMethodsSeeder {
             if (methodData.gateway !== undefined) {
               existing.gateway = methodData.gateway;
             }
-            if (methodData.cardNumber !== undefined) {
-              existing.cardNumber = methodData.cardNumber;
-            }
-            if (methodData.cardNumber2 !== undefined) {
-              existing.cardNumber2 = methodData.cardNumber2;
-            }
-            if (methodData.cardNumber3 !== undefined) {
-              existing.cardNumber3 = methodData.cardNumber3;
-            }
-            if (methodData.cardOwner !== undefined) {
-              existing.cardOwner = methodData.cardOwner;
-            }
-            if (methodData.cardOwner2 !== undefined) {
-              existing.cardOwner2 = methodData.cardOwner2;
-            }
-            if (methodData.cardOwner3 !== undefined) {
-              existing.cardOwner3 = methodData.cardOwner3;
-            }
             if (methodData.merchantId !== undefined) {
               existing.merchantId = methodData.merchantId;
             }
+            if (methodData.cards !== undefined) {
+              existing.cards.removeAll();
+              for (const card of methodData.cards) {
+                existing.cards.add(
+                  em.create(PaymentMethodCard, {
+                    paymentMethod: existing,
+                    cardNumber: card.cardNumber,
+                    owner: card.owner,
+                  }),
+                );
+              }
+            }
             em.persist(existing);
           }
         }