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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.5.13",
+    "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;
         }
       }
     }