tango-app-api-payment-subscription 3.5.12 → 3.5.14

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(node --check src/controllers/paymentSubscription.controllers.js)",
+      "Bash(npx eslint *)",
+      "Bash(echo \"---eslint-exit:$?---\")"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.5.12",
+    "version": "3.5.14",
     "description": "paymentSubscription",
     "main": "index.js",
     "type": "module",

package/scripts/create-billing-groups-by-country.js

@@ -0,0 +1,201 @@
+// One-shot script: creates billing groups by store country for specific
+// clients. For each target client it reads every store, groups storeIds by
+// `storeProfile.country`, and creates one billing group per distinct country
+// holding all the storeIds in that country.
+//
+// Scope: ONLY clientIds 387 and 193 (override with --clients=a,b).
+//
+// Idempotency / existing groups: if a billing group with the same
+// (clientId, groupName=<country>) already exists, its `stores` array is
+// OVERWRITTEN to match the current country membership (not duplicated).
+//
+// One store, one group: a store placed in a country group is pulled out of the
+// primary "Default Group" so it lives in exactly one billing group (mirrors
+// createBillingGroup).
+//
+// Stores with a missing/empty country are NOT grouped — they remain in the
+// primary "Default Group". Any legacy fallback group named UNKNOWN_GROUP_NAME
+// (from an earlier version of this script) is deleted; its stores already live
+// in the Default Group, so nothing is lost.
+//
+// Connection: reuses the app's own getConnection() (config/database) so it
+// connects exactly like the server does — reading mongo_username /
+// mongo_password from .env plus host/name/authSource from config/env/env.js.
+// Override with MONGO_URI if you want to point it elsewhere.
+//
+// Run modes:
+//   DRY RUN (default) — prints what it WOULD create/update, writes nothing:
+//     node scripts/create-billing-groups-by-country.js
+//   APPLY — actually writes:
+//     node scripts/create-billing-groups-by-country.js --apply
+//
+// Other flags:
+//   --clients=387,193   override the target client list
+
+import mongoose from 'mongoose';
+import 'dotenv/config';
+import { getConnection } from '../config/database/database.js';
+
+const DEFAULT_CLIENTS = [ '387', '193' ];
+
+// Fallback billing group for stores that have no storeProfile.country.
+const UNKNOWN_GROUP_NAME = 'Unknown';
+
+function parseArgs( argv ) {
+  const apply = argv.includes( '--apply' ) || process.env.APPLY === 'true';
+  let clients = DEFAULT_CLIENTS;
+  const clientsArg = argv.find( ( a ) => a.startsWith( '--clients=' ) );
+  if ( clientsArg ) {
+    clients = clientsArg.slice( '--clients='.length ).split( ',' ).map( ( c ) => c.trim() ).filter( Boolean );
+  }
+  return { apply, clients };
+}
+
+async function run() {
+  const { apply, clients } = parseArgs( process.argv.slice( 2 ) );
+
+  console.log( `Target clients: ${clients.join( ', ' )}` );
+  console.log( `Mode: ${apply ? 'APPLY (writing to DB)' : 'DRY RUN (no writes)'}` );
+  console.log( '' );
+
+  // Prefer an explicit MONGO_URI override; otherwise build the connection the
+  // same way the app does via getConnection().
+  if ( process.env.MONGO_URI ) {
+    await mongoose.connect( process.env.MONGO_URI );
+  } else {
+    const { uri, options } = getConnection();
+    await mongoose.connect( uri, options );
+  }
+
+  // strict:false so we don't pin to a specific tango-api-schema version.
+  const Store = mongoose.model(
+      '_cbgStore',
+      new mongoose.Schema( {}, { strict: false } ),
+      'stores',
+  );
+  const Billing = mongoose.model(
+      '_cbgBilling',
+      new mongoose.Schema( {}, { strict: false } ),
+      'billings',
+  );
+
+  let totalGroupsCreated = 0;
+  let totalGroupsUpdated = 0;
+  let totalPulledFromPrimary = 0;
+  let totalUnknownGroupsDeleted = 0;
+  const noCountryStores = [];
+
+  for ( const clientId of clients ) {
+    const stores = await Store.find(
+        { clientId: clientId },
+        { 'storeId': 1, 'storeName': 1, 'storeProfile.country': 1 },
+    ).lean();
+
+    console.log( `=== Client ${clientId}: ${stores.length} store(s) ===` );
+
+    if ( !stores.length ) {
+      console.log( '  No stores found. Skipping.\n' );
+      continue;
+    }
+
+    // Group storeIds by country. Stores with no country are NOT grouped — they
+    // remain in the primary "Default Group".
+    const byCountry = new Map();
+    for ( const s of stores ) {
+      const country = ( s.storeProfile?.country || '' ).trim();
+      if ( !country ) {
+        noCountryStores.push( { clientId, storeId: s.storeId, storeName: s.storeName } );
+        continue;
+      }
+      if ( !byCountry.has( country ) ) {
+        byCountry.set( country, [] );
+      }
+      byCountry.get( country ).push( s.storeId );
+    }
+
+    // Tidy up the legacy fallback group: country-less stores belong in the
+    // primary group, so any previously-created "Unknown" group is removed.
+    // (Its stores are also in the primary group, so nothing is lost.)
+    const unknownGroup = await Billing.findOne( { clientId: clientId, groupName: UNKNOWN_GROUP_NAME } );
+    if ( unknownGroup ) {
+      console.log( `  [DELETE] legacy "${UNKNOWN_GROUP_NAME}" group (_id ${unknownGroup._id}) — country-less stores stay in Default Group` );
+      if ( apply ) {
+        await Billing.deleteOne( { _id: unknownGroup._id } );
+      }
+      totalUnknownGroupsDeleted++;
+    }
+
+    if ( !byCountry.size ) {
+      console.log( '  No stores with a country value. Nothing to group.\n' );
+      continue;
+    }
+
+    for ( const [ country, storeIds ] of byCountry ) {
+      const existing = await Billing.findOne( { clientId: clientId, groupName: country } );
+
+      if ( existing ) {
+        console.log( `  [UPDATE] group "${country}" exists (_id ${existing._id}) → set ${storeIds.length} store(s)` );
+        if ( apply ) {
+          await Billing.updateOne(
+              { _id: existing._id },
+              { $set: { stores: storeIds } },
+          );
+        }
+        totalGroupsUpdated++;
+      } else {
+        console.log( `  [CREATE] group "${country}" with ${storeIds.length} store(s)` );
+        if ( apply ) {
+          await Billing.create( {
+            clientId: clientId,
+            groupName: country,
+            groupTag: 'store',
+            country: country,
+            stores: storeIds,
+          } );
+        }
+        totalGroupsCreated++;
+      }
+
+      // A store lives in exactly one group: once it's in a country group, pull
+      // it out of the primary "Default Group" (mirrors createBillingGroup).
+      if ( apply ) {
+        const pullRes = await Billing.updateOne(
+            { clientId: clientId, isPrimary: true },
+            { $pull: { stores: { $in: storeIds } } },
+        );
+        if ( pullRes.modifiedCount ) {
+          totalPulledFromPrimary += storeIds.length;
+        }
+      } else {
+        totalPulledFromPrimary += storeIds.length;
+      }
+    }
+    console.log( `  → pulled country-matched stores out of primary "Default Group"` );
+    console.log( '' );
+  }
+
+  console.log( '--- Summary ---' );
+  console.log( `Groups created: ${totalGroupsCreated}` );
+  console.log( `Groups updated: ${totalGroupsUpdated}` );
+  console.log( `Legacy "${UNKNOWN_GROUP_NAME}" groups deleted: ${totalUnknownGroupsDeleted}` );
+  console.log( `Store memberships pulled from primary group: ${totalPulledFromPrimary}` );
+  if ( noCountryStores.length ) {
+    console.log( `Stores with no country (left in "Default Group"): ${noCountryStores.length}` );
+    noCountryStores.slice( 0, 50 ).forEach( ( s ) =>
+      console.log( `  - client ${s.clientId} | ${s.storeId} | ${s.storeName || ''}` ),
+    );
+    if ( noCountryStores.length > 50 ) {
+      console.log( `  ...and ${noCountryStores.length - 50} more` );
+    }
+  }
+  if ( !apply ) {
+    console.log( '\nDRY RUN complete. No data was written. Re-run with --apply to write.' );
+  }
+
+  await mongoose.disconnect();
+}
+
+run().catch( ( err ) => {
+  console.error( err );
+  process.exit( 1 );
+} );

package/src/controllers/brandsBilling.controller.js

@@ -586,16 +586,34 @@ export async function brandInvoiceList( req, res ) {
     };
 
     if ( req.body.export ) {
+      // Mirror the on-screen table exactly: same columns (excl. GST and incl.
+      // GST as separate amounts), same currency symbol, and the same status
+      // text the table renders via getInvoiceStatus().
+      const currencySymbols = {
+        inr: '₹', dollar: '$', singaporedollar: 'S$', euro: '€', aed: 'AED',
+      };
+      const statusFor = ( inv ) => {
+        if ( inv.status === 'pendingCsm' ) return 'Pending CSM';
+        if ( inv.status === 'pendingFinance' ) return 'Pending Finance';
+        if ( inv.status === 'pendingApproval' ) return 'Pending Approval';
+        if ( inv.status === 'pending' ) return 'Pending Approval';
+        if ( inv.paymentStatus === 'partial' ) return 'Partial';
+        if ( inv.paymentStatus === 'unpaid' ) return 'Pending Payment';
+        if ( inv.paymentStatus === 'paid' ) return 'Paid';
+        return inv.status;
+      };
       const exportdata = [];
       allInvoices.forEach( ( element ) => {
+        const symbol = currencySymbols[element.currency] || '$';
         exportdata.push( {
           'Invoice #': element.invoice,
           'Billing Group': element.groupName,
           'Period': dayjs( element.billingDate ).format( 'MMM YYYY' ),
           'Generated': dayjs( element.billingDate ).format( 'DD MMM YYYY' ),
           'No of Stores': element.stores,
-          'Amount': element.totalAmount,
-          'Status': [ 'pendingCsm', 'pendingFinance', 'pendingApproval' ].includes( element.status ) ? 'Pending Approval' : element.paymentStatus === 'unpaid' ? 'Pending Payment' : 'Paid',
+          'Amount (excl. GST)': `${symbol}${Number( element.amount || 0 ).toFixed( 2 )}`,
+          'Amount (incl. GST)': `${symbol}${Number( element.totalAmount || 0 ).toFixed( 2 )}`,
+          'Status': statusFor( element ),
         } );
       } );
       await download( exportdata, res );
@@ -705,18 +723,27 @@ export async function latestDailyPricing( req, res ) {
       logger.error( { error: bpErr, function: 'latestDailyPricing.basePrice', clientId: req.body.clientId } );
     }
     // Billing type per product (perStore / perZone / perCamera) from the client
-    // plan — drives whether the amount multiplies by camera/zone count.
+    // plan — drives whether the amount multiplies by camera/zone count. The
+    // same client doc supplies the invoice-amount currency below.
     const billingTypeByProduct = {};
+    // Invoice Amount currency comes from the client's paymentInvoice.currencyType
+    // (normalised to 'dollar' / 'inr' like the rest of this file). Falls back to
+    // the base-pricing currency only when the client has no currencyType set.
+    let invoiceCurrency = bpCurrency;
     try {
       const planClient = await clientService.findOne(
           { clientId: req.body.clientId },
-          { 'planDetails.product.productName': 1, 'planDetails.product.billingType': 1 },
+          { 'planDetails.product.productName': 1, 'planDetails.product.billingType': 1, 'paymentInvoice.currencyType': 1 },
       );
       for ( const p of ( planClient?.planDetails?.product || [] ) ) {
         if ( p.productName ) {
           billingTypeByProduct[p.productName] = p.billingType || 'perStore';
         }
       }
+      const clientCurrency = planClient?.paymentInvoice?.currencyType;
+      if ( clientCurrency ) {
+        invoiceCurrency = clientCurrency === 'dollar' ? 'dollar' : 'inr';
+      }
     } catch ( btErr ) {
       logger.error( { error: btErr, function: 'latestDailyPricing.billingType', clientId: req.body.clientId } );
     }
@@ -828,7 +855,7 @@ export async function latestDailyPricing( req, res ) {
         ...( store._doc || store ),
         invoiceAmount: Math.round( invoiceAmount * 100 ) / 100,
         invoiceBreakdown,
-        invoiceCurrency: bpCurrency,
+        invoiceCurrency: invoiceCurrency,
       };
     } );
 

package/src/controllers/invoice.controller.js

@@ -324,7 +324,15 @@ export async function createInvoice( req, res ) {
               $filter: {
                 input: '$stores',
                 as: 'item',
-                cond: { $and: [ { $gt: [ '$$item.daysDifference', 0 ] }, { $in: [ '$$item.storeId', group.stores ] } ] },
+                // A store is "running" if it has working days for ANY product.
+                // Edge products (tangoZone/tangoTraffic) use daysDifference;
+                // tangoTrax uses daysDifferenceTrax. A trax-only store has
+                // daysDifference = 0 but daysDifferenceTrax > 0 — counting only
+                // daysDifference would wrongly drop it and report stores: 0.
+                cond: { $and: [
+                  { $or: [ { $gt: [ '$$item.daysDifference', 0 ] }, { $gt: [ '$$item.daysDifferenceTrax', 0 ] } ] },
+                  { $in: [ '$$item.storeId', group.stores ] },
+                ] },
               },
             },
           },
@@ -440,10 +448,11 @@ async function buildAnnexureRows( invoiceInfo, getgroup ) {
   const billingMonthEnd = new Date( billingMonth.endOf( 'month' ).toISOString() );
   const monthDays = billingMonth.daysInMonth();
   const invoiceCurrency = symbolFor( invoiceInfo.currency );
-  // basepricing negotiatePrice is stored in INR. For non-INR invoices the
-  // annexure must convert it to the invoice currency, otherwise the INR number
-  // is shown verbatim under a $ symbol (e.g. ₹1650 rendered as "$1,650").
-  const annexFx = invoiceInfo.currency === 'dollar' ? ( await getUsdInrRate() ) : 1;
+  // basepricing negotiatePrice is stored in the client's own billing currency
+  // (INR for INR clients, the foreign currency for dollar/AED clients). Invoice
+  // generation uses negotiatePrice verbatim (no FX), so the annexure must too —
+  // converting here would make the annexure unit price disagree with the actual
+  // billed amount (e.g. a $45 negotiated price wrongly shown as $0.48).
 
   const annexClient = await clientService.findOne( { clientId: invoiceInfo.clientId }, { 'planDetails.product': 1 } );
   const billingTypeMap = {};
@@ -504,9 +513,9 @@ async function buildAnnexureRows( invoiceInfo, getgroup ) {
         units = s.trafficCameraCount;
       }
     }
-    // Convert the INR negotiatePrice into the invoice currency (annexFx = 1 for
-    // INR invoices, = USD→INR rate for dollar invoices, so divide).
-    const price = ( Number( s.standard?.negotiatePrice ) || 0 ) / annexFx;
+    // negotiatePrice is already in the invoice currency — use it verbatim,
+    // matching invoice generation.
+    const price = Number( s.standard?.negotiatePrice ) || 0;
     const runningCost = s.workingdays >= monthDays ?
       Math.round( price * units * 100 ) / 100 :
       Math.round( ( price / monthDays ) * s.workingdays * units * 100 ) / 100;
@@ -1713,7 +1722,6 @@ async function stepPrice( group, getClient ) {
   function processArray( array1, array2 ) {
     let updatedArray = [];
 
-    let firstPriceAssigned = false;
     for ( let item of array1 ) {
       let remainingStores = item.storeCount;
 
@@ -1721,16 +1729,17 @@ async function stepPrice( group, getClient ) {
         let [ min, max ] = range.storeRange.split( '-' ).map( Number );
 
         if ( remainingStores > 0 ) {
-          console.log( firstPriceAssigned );
           let applicableStores = Math.min( remainingStores, max - min + 1 );
           updatedArray.push( {
             productName: item.productName,
             workingdays: item.workingdays,
             storeCount: applicableStores,
-            price: firstPriceAssigned ? 1100 : range.negotiatePrice,
+            // Each tier is charged at its own range's negotiated price. (Was a
+            // hardcoded 1100 for every tier after the first — a placeholder
+            // that ignored the actual step price of the next range.)
+            price: range.negotiatePrice,
           } );
           remainingStores -= applicableStores;
-          firstPriceAssigned = true;
         }
       }
     }

package/src/controllers/paymentSubscription.controllers.js

@@ -3325,13 +3325,201 @@ export const dailyPricingInsertOld = async ( req, res ) => {
   }
 };
 
+// Computes the daily-pricing entry for a single store. Pure per-store work
+// (independent DB reads + calculation) so stores can run concurrently.
+// storeIndex is the store's original position in getStore — required for the
+// step-pricing storeRange check, so it must be preserved when parallelizing.
+const processStoreDailyPricing = async ( store, storeIndex, getClient, getBaseprice, date ) => {
+  let productList = [];
+  let query = [
+    {
+      $match: {
+        clientId: getClient.clientId,
+      },
+    },
+    { $unwind: '$stores' },
+    {
+      $match: {
+        'stores.storeId': store.storeId,
+      },
+    },
+    {
+      $project: {
+        'stores.daysDifference': 1,
+        'stores.daysDifferenceTrax': 1,
+        'dateString': 1,
+      },
+    },
+    {
+      $sort: {
+        _id: -1,
+      },
+    },
+    { $limit: 1 },
+  ];
+  let dailyData = await dailyPriceService.aggregate( query );
+  let cameraDetails = await cameraService.find( { storeId: store.storeId, clientId: getClient.clientId, isActivated: true, isUp: true }, { streamName: 1, productModule: 1 } );
+  // console.log( '🚀 ~ dailyPricingInsert ~ cameraDetails:', cameraDetails );
+
+  let trafficCameraCount = cameraDetails.filter( ( cam ) =>
+    ( cam.productModule || [] ).some( ( mod ) =>
+      ( mod.productName === 'tangoTraffic' || mod.productName === 'tangoTracking' ) && mod.checked === true,
+    ),
+  ).length;
+
+  let zoneCameraCount = cameraDetails.filter( ( cam ) =>
+    ( cam.productModule || [] ).some( ( mod ) =>
+      mod.productName === 'tangoZone' && mod.checked === true,
+    ),
+  ).length;
+
+  let zoneCameraStreamNames = cameraDetails.filter( ( cam ) =>
+    ( cam.productModule || [] ).some( ( mod ) =>
+      mod.productName === 'tangoZone' && mod.checked === true,
+    ),
+  ).map( ( cam ) => cam.streamName );
+  let allcameraname = cameraDetails?.map( ( cam ) => cam?.streamName );
+  console.log( '🚀 ~ dailyPricingInsert ~ zoneCameraStreamNames:', zoneCameraStreamNames );
+  let taggingDetails = await taggingService.find( { storeId: store.storeId, clientId: getClient.clientId, productName: 'tangoZone', coordinates: { $ne: [] }, streamName: { $in: allcameraname } }, { tagName: 1 } );
+  let zoneCount = taggingDetails.length;
+  let zoneName = taggingDetails.map( ( item ) => item.tagName );
+  let firstDate = dayjs( store?.edge?.firstFileDate ).format( 'YYYY-MM-DD' );
+  let workingdays;
+  let workingdaystrax;
+  const givenDate = dayjs( date );
+  console.log( '🚀 ~ dailyPricingInsert ~ cameraCount:', store.storeId, trafficCameraCount, zoneCameraCount, zoneCount );
+  const isFirstDayOfMonth = givenDate.isSame( dayjs().startOf( 'month' ), 'day' );
+  if ( store?.edge.firstFile ) {
+    if ( firstDate < date && store?.status == 'active' &&
+              dailyData[0]?.dateString != dayjs( date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) ) {
+      if ( dailyData.length && dailyData[0]?.stores?.daysDifference&&!isFirstDayOfMonth ) {
+        workingdays = dailyData[0]?.stores?.daysDifference + 1;
+      } else {
+        workingdays = 1;
+      }
+    } else {
+      if ( dailyData[0]?.stores?.daysDifference&&!isFirstDayOfMonth ) {
+        workingdays = dailyData[0]?.stores?.daysDifference;
+      } else {
+        workingdays = 0;
+      }
+    }
+  }
+  console.log( dailyData[0]?.stores );
+  if ( store?.status == 'active' &&
+            dailyData[0]?.dateString != dayjs( date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) ) {
+    if ( dailyData.length && dailyData[0]?.stores?.daysDifferenceTrax&&!isFirstDayOfMonth ) {
+      workingdaystrax = dailyData[0]?.stores?.daysDifferenceTrax + 1;
+    } else {
+      workingdaystrax = 1;
+    }
+  } else {
+    if ( dailyData[0]?.stores?.daysDifferenceTrax&&!isFirstDayOfMonth ) {
+      workingdaystrax = dailyData[0]?.stores?.daysDifferenceTrax;
+    } else {
+      workingdaystrax = 0;
+    }
+  }
+  let priceDetails = getClient.priceType == 'standard' ? getBaseprice.standard : getBaseprice.step;
+  priceDetails = priceDetails.filter( ( item1 ) =>
+    getClient.planDetails.product.some( ( item2 ) =>
+      item2.productName === item1.productName && item2.status === 'live',
+    ),
+  );
+  for ( let storeProductIndex = 0; storeProductIndex < store.product.length; storeProductIndex++ ) {
+    let productDetails;
+    if ( getClient.priceType == 'standard' ) {
+      productDetails = priceDetails.find( ( item ) => item.productName == store.product[storeProductIndex] );
+    } else {
+      productDetails = priceDetails.find( ( item ) => {
+        let range = item.storeRange.split( '-' );
+        if ( parseInt( range[0] ) <= ( storeIndex + 1 ) && parseInt( range[1] ) >= ( storeIndex + 1 ) ) {
+          return ( item.productName == store.product[storeProductIndex] && parseInt( range[0] ) <= ( storeIndex + 1 ) && parseInt( range[1] ) >= ( storeIndex + 1 ) );
+        }
+      } );
+      if ( !productDetails ) {
+        let stepProductDetails = priceDetails.filter( ( item ) => item.productName == store.product[storeProductIndex] );
+        productDetails = stepProductDetails[stepProductDetails.length - 1];
+      }
+    }
+    if ( productDetails ) {
+      console.log( '-------', workingdays, workingdaystrax, productDetails.productName );
+      let newObject = {
+        productName: productDetails.productName,
+        workingdays: productDetails.productName==='tangoTrax'?workingdaystrax:workingdays,
+      };
+      productList.push( newObject );
+    }
+  }
+  return {
+    storeId: store.storeId,
+    store: store._id,
+    storeName: store.storeName,
+    status: store?.status,
+    firstFile: store?.edge?.firstFile || false,
+    edgefirstFileDate: store?.edge?.firstFileDate || null,
+    date: new Date( date ),
+    daysDifference: workingdays,
+    daysDifferenceTrax: workingdaystrax,
+    products: productList,
+    camera: cameraDetails.map( ( item ) => item.streamName ),
+    trafficCameraCount: trafficCameraCount,
+    zoneCameraCount: zoneCameraCount,
+    zoneCount: zoneCount,
+    zoneName: zoneName,
+  };
+};
+
+// Processes daily pricing for a single client. Self-contained so multiple
+// clients can run concurrently via Promise.all in dailyPricingInsert.
+const processClientDailyPricing = async ( clientId, date ) => {
+  let getClient = await paymentService.findOne( { clientId: clientId } );
+  if ( getClient ) {
+    let getBaseprice = await basePriceService.findOne( { clientId: clientId } );
+    let getStore = await storeService.find( { 'clientId': clientId } );
+    console.log( '==========>', clientId, getStore.length );
+    if ( getStore.length && getBaseprice ) {
+      // Process stores in bounded batches so large clients (200+ stores) run
+      // in parallel without exhausting the DB connection pool. storeIndex is
+      // preserved so step-pricing ranges still resolve correctly.
+      const STORE_BATCH_SIZE = 20;
+      let storeList = [];
+      for ( let i = 0; i < getStore.length; i += STORE_BATCH_SIZE ) {
+        let batch = getStore.slice( i, i + STORE_BATCH_SIZE );
+        let batchResults = await Promise.all(
+            batch.map( ( store, batchIndex ) =>
+              processStoreDailyPricing( store, i + batchIndex, getClient, getBaseprice, date ),
+            ),
+        );
+        storeList.push( ...batchResults );
+      }
+
+      let activestores = storeList.filter( ( store ) => store.status=='active' );
+      console.log( '------', activestores.length );
+      let params = {
+        clientId: clientId,
+        stores: storeList,
+        dateISO: new Date( date ),
+        accountType: getClient?.planDetails?.subscriptionType,
+        status: getClient?.status,
+        activeStores: activestores?.length,
+        brandName: getClient?.clientName,
+        proRate: getClient?.paymentInvoice?.proRate,
+        dateString: dayjs( date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ),
+      };
+      await dailyPriceService.updateOne( { clientId: clientId, dateString: params.dateString }, params, { upsert: true } );
+    } else {
+      // console.log( 'store or base price not found' );
+    }
+  }
+};
+
 export const dailyPricingInsert = async ( req, res ) => {
   try {
     let requestData = req.body;
-    let clientlist;
     let requestClient = [];
     if ( !requestData?.clientId || !requestData?.clientId?.length ) {
-      clientlist = await paymentService.find( { 'status': 'active' } );
+      let clientlist = await paymentService.find( { 'status': 'active' } );
       for ( let client of clientlist ) {
         requestClient.push( client.clientId );
       }
@@ -3342,214 +3530,45 @@ export const dailyPricingInsert = async ( req, res ) => {
     if ( !requestData?.date ) {
       requestData.date = dayjs().format( 'YYYY-MM-DD' );
     }
-    if ( requestData.clientId && requestClient.length > 0 ) {
-      for ( let clientIndex = 0; clientIndex < requestClient.length; clientIndex++ ) {
-        let getClient = await paymentService.findOne( { clientId: requestClient[clientIndex] } );
-        if ( getClient ) {
-          let getBaseprice = await basePriceService.findOne( { clientId: requestClient[clientIndex] } );
-          let getStore = await storeService.find( { 'clientId': requestClient[clientIndex] } );
-          console.log( '==========>', getStore.length );
-          if ( getStore.length ) {
-            let storeList = [];
-            for ( let storeIndex = 0; storeIndex < getStore.length; storeIndex++ ) {
-              let productList = [];
-              if ( getBaseprice ) {
-                // await axios.get( `${JSON.parse( process.env.URL ).oldapidomain}/processedDayData/getDailyData?clientId=${requestClient[clientIndex]}&storeId=${getStore[storeIndex].storeId}&date=${requestData.date}`, { headers: { Authorization: 'Bearer d47433f8-9a33-47c7-ba43-1a0fbac28f66' } } ).then( async ( response ) => {
-                // let processedFileDate = response.data?.data?.firstFileDate || null;
-                let query = [
-                  {
-                    $match: {
-                      clientId: getClient.clientId,
-                    },
-                  },
-                  { $unwind: '$stores' },
-                  {
-                    $match: {
-                      'stores.storeId': getStore[storeIndex].storeId,
-                    },
-                  },
-                  {
-                    $project: {
-                      'stores.daysDifference': 1,
-                      'stores.daysDifferenceTrax': 1,
-                      'dateString': 1,
-                    },
-                  },
-                  {
-                    $sort: {
-                      _id: -1,
-                    },
-                  },
-                  { $limit: 1 },
-                ];
-                let dailyData = await dailyPriceService.aggregate( query );
-                let cameraDetails = await cameraService.find( { storeId: getStore[storeIndex].storeId, clientId: requestClient[clientIndex], isActivated: true, isUp: true }, { streamName: 1, productModule: 1 } );
-                // console.log( '🚀 ~ dailyPricingInsert ~ cameraDetails:', cameraDetails );
-
-                let trafficCameraCount = cameraDetails.filter( ( cam ) =>
-                  ( cam.productModule || [] ).some( ( mod ) =>
-                    ( mod.productName === 'tangoTraffic' || mod.productName === 'tangoTracking' ) && mod.checked === true,
-                  ),
-                ).length;
-
-                let zoneCameraCount = cameraDetails.filter( ( cam ) =>
-                  ( cam.productModule || [] ).some( ( mod ) =>
-                    mod.productName === 'tangoZone' && mod.checked === true,
-                  ),
-                ).length;
-
-                let zoneCameraStreamNames = cameraDetails.filter( ( cam ) =>
-                  ( cam.productModule || [] ).some( ( mod ) =>
-                    mod.productName === 'tangoZone' && mod.checked === true,
-                  ),
-                ).map( ( cam ) => cam.streamName );
-                let allcameraname = cameraDetails?.map( ( cam ) => cam?.streamName );
-                console.log( '🚀 ~ dailyPricingInsert ~ zoneCameraStreamNames:', zoneCameraStreamNames );
-                let taggingDetails = await taggingService.find( { storeId: getStore[storeIndex].storeId, clientId: requestClient[clientIndex], productName: 'tangoZone', coordinates: { $ne: [] }, streamName: { $in: allcameraname } }, { tagName: 1 } );
-                let zoneCount = taggingDetails.length;
-                let zoneName = taggingDetails.map( ( item ) => item.tagName );
-                let firstDate = dayjs( getStore[storeIndex]?.edge?.firstFileDate ).format( 'YYYY-MM-DD' );
-                let workingdays;
-                let workingdaystrax;
-                const givenDate = dayjs( requestData.date );
-                console.log( '🚀 ~ dailyPricingInsert ~ cameraCount:', getStore[storeIndex].storeId, trafficCameraCount, zoneCameraCount, zoneCount );
-                const isFirstDayOfMonth = givenDate.isSame( dayjs().startOf( 'month' ), 'day' );
-                if ( getStore[storeIndex]?.edge.firstFile ) {
-                  if ( firstDate < requestData.date && getStore[storeIndex]?.status == 'active' &&
-                      dailyData[0]?.dateString != dayjs( requestData.date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) ) {
-                    if ( dailyData.length && dailyData[0]?.stores?.daysDifference&&!isFirstDayOfMonth ) {
-                      workingdays = dailyData[0]?.stores?.daysDifference + 1;
-                    } else {
-                      workingdays = 1;
-                    }
-                  } else {
-                    if ( dailyData[0]?.stores?.daysDifference&&!isFirstDayOfMonth ) {
-                      workingdays = dailyData[0]?.stores?.daysDifference;
-                    } else {
-                      workingdays = 0;
-                    }
-                  }
-                }
-                console.log( dailyData[0]?.stores );
-                if ( getStore[storeIndex]?.status == 'active' &&
-                    dailyData[0]?.dateString != dayjs( requestData.date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) ) {
-                  if ( dailyData.length && dailyData[0]?.stores?.daysDifferenceTrax&&!isFirstDayOfMonth ) {
-                    workingdaystrax = dailyData[0]?.stores?.daysDifferenceTrax + 1;
-                  } else {
-                    workingdaystrax = 1;
-                  }
-                } else {
-                  if ( dailyData[0]?.stores?.daysDifferenceTrax&&!isFirstDayOfMonth ) {
-                    workingdaystrax = dailyData[0]?.stores?.daysDifferenceTrax;
-                  } else {
-                    workingdaystrax = 0;
-                  }
-                }
-                let priceDetails = getClient.priceType == 'standard' ? getBaseprice.standard : getBaseprice.step;
-                priceDetails = priceDetails.filter( ( item1 ) =>
-                  getClient.planDetails.product.some( ( item2 ) =>
-                    item2.productName === item1.productName && item2.status === 'live',
-                  ),
-                );
-                for ( let storeProductIndex = 0; storeProductIndex < getStore[storeIndex].product.length; storeProductIndex++ ) {
-                  let productDetails;
-                  if ( getClient.priceType == 'standard' ) {
-                    productDetails = priceDetails.find( ( item ) => item.productName == getStore[storeIndex].product[storeProductIndex] );
-                  } else {
-                    productDetails = priceDetails.find( ( item ) => {
-                      let range = item.storeRange.split( '-' );
-                      if ( parseInt( range[0] ) <= ( storeIndex + 1 ) && parseInt( range[1] ) >= ( storeIndex + 1 ) ) {
-                        return ( item.productName == getStore[storeIndex].product[storeProductIndex] && parseInt( range[0] ) <= ( storeIndex + 1 ) && parseInt( range[1] ) >= ( storeIndex + 1 ) );
-                      }
-                    } );
-                    if ( !productDetails ) {
-                      let stepProductDetails = priceDetails.filter( ( item ) => item.productName == getStore[storeIndex].product[storeProductIndex] );
-                      productDetails = stepProductDetails[stepProductDetails.length - 1];
-                    }
-                  }
-                  if ( productDetails ) {
-                    console.log( '-------', workingdays, workingdaystrax, productDetails.productName );
-                    let newObject = {
-                      productName: productDetails.productName,
-                      workingdays: productDetails.productName==='tangoTrax'?workingdaystrax:workingdays,
-                    };
-                    productList.push( newObject );
-                  }
-                }
-                storeList.push(
-                    {
-                      storeId: getStore[storeIndex].storeId,
-                      store: getStore[storeIndex]._id,
-                      storeName: getStore[storeIndex].storeName,
-                      status: getStore[storeIndex]?.status,
-                      firstFile: getStore[storeIndex]?.edge?.firstFile || false,
-                      edgefirstFileDate: getStore[storeIndex]?.edge?.firstFileDate || null,
-                      date: new Date( requestData.date ),
-                      daysDifference: workingdays,
-                      daysDifferenceTrax: workingdaystrax,
-                      products: productList,
-                      camera: cameraDetails.map( ( item ) => item.streamName ),
-                      trafficCameraCount: trafficCameraCount,
-                      zoneCameraCount: zoneCameraCount,
-                      zoneCount: zoneCount,
-                      zoneName: zoneName,
-                    },
-                );
-                console.log( storeIndex, getStore.length - 1 );
-                if ( storeIndex == getStore.length - 1 ) {
-                  let activestores = storeList.filter( ( store ) => store.status=='active' );
-                  console.log( '------', activestores.length );
-                  let params = {
-                    clientId: requestClient[clientIndex],
-                    stores: storeList,
-                    dateISO: new Date( requestData.date ),
-                    accountType: getClient?.planDetails?.subscriptionType,
-                    status: getClient?.status,
-                    activeStores: activestores?.length,
-                    brandName: getClient?.clientName,
-                    proRate: getClient?.paymentInvoice?.proRate,
-                    dateString: dayjs( requestData.date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ),
-                  };
-                  await dailyPriceService.updateOne( { clientId: requestClient[clientIndex], dateString: params.dateString }, params, { upsert: true } );
-                }
-                // } ).catch( ( error ) => {
-                //   logger.error( { error: error, function: 'old processedDayData' } );
-                // } );
-              } else {
-                // console.log( 'base price not found' );
-              }
-            }
-          } else {
-            // console.log( 'store not found' );
-          }
-        }
-        // console.log( clientIndex, requestClient.length-1 );
-        if ( clientIndex == requestClient.length - 1 ) {
-          // let teamsAlertUrls = process.env.teamsAlertURL ? JSON.parse( process.env.teamsAlertURL ) : '';
-          let totalcount = await dailyPriceService.find( { dateString: dayjs( requestData.date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) } );
-          let teamsMsg = `${totalcount.length} clients data is inserted on ${dayjs( requestData.date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' )}`;
-          console.log( teamsMsg );
-          // if ( teamsAlertUrls.invoiceAlert ) {
-          //   sendTeamsNotification( teamsAlertUrls.invoiceAlert, teamsMsg );
-          // }
 
-          const SES = JSON.parse( process.env.SES );
-          let fromEmail = SES.accountsEmail;
-          console.log( process.env.invoiceAlert );
-          let invoiceEmails = JSON.parse( process.env.invoiceAlert );
-          let mailSubject = `Daily Invoice Alert ${dayjs( requestData.date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' )}`;
-          if ( invoiceEmails ) {
-            const result = await sendEmailWithSES( invoiceEmails?.email, mailSubject, teamsMsg, '', fromEmail, [] );
-            console.log( '🚀 ~ dailyPricingInsert ~ result:', result );
-          }
+    if ( requestClient.length > 0 ) {
+      // Process clients in bounded batches so we run in parallel without
+      // exhausting the DB connection pool with hundreds of concurrent clients.
+      const BATCH_SIZE = 5;
+      for ( let i = 0; i < requestClient.length; i += BATCH_SIZE ) {
+        let batch = requestClient.slice( i, i + BATCH_SIZE );
+        await Promise.all(
+            batch.map( ( clientId ) =>
+              processClientDailyPricing( clientId, requestData.date ).catch( ( error ) => {
+                logger.error( { error: error, function: 'processClientDailyPricing', clientId: clientId } );
+              } ),
+            ),
+        );
+      }
 
-          return res.sendSuccess( 'Price Details Inserted Successfully' );
-        }
+      // let teamsAlertUrls = process.env.teamsAlertURL ? JSON.parse( process.env.teamsAlertURL ) : '';
+      let totalcount = await dailyPriceService.find( { dateString: dayjs( requestData.date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) } );
+      let teamsMsg = `${totalcount.length} clients data is inserted on ${dayjs( requestData.date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' )}`;
+      console.log( teamsMsg );
+      // if ( teamsAlertUrls.invoiceAlert ) {
+      //   sendTeamsNotification( teamsAlertUrls.invoiceAlert, teamsMsg );
+      // }
+
+      const SES = JSON.parse( process.env.SES );
+      let fromEmail = SES.accountsEmail;
+      console.log( process.env.invoiceAlert );
+      let invoiceEmails = JSON.parse( process.env.invoiceAlert );
+      let mailSubject = `Daily Invoice Alert ${dayjs( requestData.date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' )}`;
+      if ( invoiceEmails ) {
+        const result = await sendEmailWithSES( invoiceEmails?.email, mailSubject, teamsMsg, '', fromEmail, [] );
+        console.log( '🚀 ~ dailyPricingInsert ~ result:', result );
       }
-      return res.sendSuccess( 'success' );
+
+      return res.sendSuccess( 'Price Details Inserted Successfully' );
     }
+    return res.sendSuccess( 'success' );
   } catch ( e ) {
-    logger.error( { error: e, function: 'invoiceCreate' } );
+    logger.error( { error: e, function: 'dailyPricingInsert' } );
     return res.sendError( e, 500 );
   }
 };