tango-app-api-payment-subscription 3.5.7 → 3.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.5.7",
+    "version": "3.5.8",
     "description": "paymentSubscription",
     "main": "index.js",
     "type": "module",
@@ -29,7 +29,7 @@
         "nodemon": "^3.1.0",
         "puppeteer": "^24.41.0",
         "swagger-ui-express": "^5.0.0",
-        "tango-api-schema": "^2.6.26",
+        "tango-api-schema": "^2.6.27",
         "tango-app-api-middleware": "^3.6.18",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0",

package/scripts/seed-payment-reminders.js

@@ -0,0 +1,82 @@
+// One-shot seeder: creates a paymentreminders config for every ACTIVE client
+// (clients.status === 'active'), with a single static recipient email and the
+// app's default template toggles. Idempotent — re-running upserts the same
+// docs, so existing configs are overwritten with the static email + defaults.
+//
+// Usage (from the API project root):
+//   node scripts/seed-payment-reminders.js
+//   node scripts/seed-payment-reminders.js someone@else.com   # override email
+//   node scripts/seed-payment-reminders.js --dry-run          # report only
+//
+// Reads MONGO connection + env from .env (same as the app).
+
+import dotenv from 'dotenv';
+import mongoose from 'mongoose';
+import model from 'tango-api-schema';
+import { getConnection } from '../config/database/database.js';
+
+dotenv.config();
+
+const args = process.argv.slice( 2 );
+const dryRun = args.includes( '--dry-run' );
+const STATIC_EMAIL = args.find( ( a ) => a.includes( '@' ) ) || 'ayyanarkalusulingam13@gmail.com';
+
+// Mirrors the app's DEFAULTS() in paymentReminder.controller.js.
+const DEFAULT_TEMPLATES = {
+  preDue: { enabled: true, daysBefore: 3 },
+  onDue: { enabled: true },
+  onHold: { enabled: true },
+  suspend: { enabled: true },
+  deactivated: { enabled: false },
+};
+
+async function run() {
+  // Reuse the app's own connection builder (reads mongo_* env config).
+  const { uri, options } = getConnection();
+  await mongoose.connect( uri, options );
+  console.log( `Connected. Static recipient: ${STATIC_EMAIL}${dryRun ? '  (DRY RUN — no writes)' : ''}\n` );
+
+  const clients = await model.clientModel.find(
+      { status: 'active' },
+      { clientId: 1, clientName: 1 },
+  ).lean();
+  console.log( `Active clients found: ${clients.length}\n` );
+
+  const summary = { total: clients.length, upserted: 0, skipped: 0 };
+
+  for ( const c of clients ) {
+    if ( !c.clientId ) {
+      summary.skipped++;
+      console.log( `  - skip (no clientId): ${c.clientName || c._id}` );
+      continue;
+    }
+    if ( dryRun ) {
+      summary.upserted++;
+      console.log( `  • would upsert: ${c.clientName || c.clientId}` );
+      continue;
+    }
+    await model.paymentReminderModel.updateOne(
+        { clientId: c.clientId },
+        {
+          $set: {
+            clientId: c.clientId,
+            reminderEmails: [ STATIC_EMAIL ],
+            templates: DEFAULT_TEMPLATES,
+            updatedBy: 'seed-script',
+          },
+        },
+        { upsert: true },
+    );
+    summary.upserted++;
+    console.log( `  ✓ ${c.clientName || c.clientId}` );
+  }
+
+  console.log( `\nDone. ${summary.upserted} upserted, ${summary.skipped} skipped (of ${summary.total} active).` );
+  await mongoose.disconnect();
+  process.exit( 0 );
+}
+
+run().catch( ( err ) => {
+  console.error( 'Failed:', err?.message || err );
+  process.exit( 1 );
+} );

package/scripts/send-reminder-test-emails.js

@@ -0,0 +1,70 @@
+// One-shot tester: renders all 5 payment-reminder templates with sample
+// invoice data and emails each one to a single recipient, so you can see
+// exactly what every reminder stage looks like. Uses the real SES setup
+// (reads AWS_CONFIG / SES from .env, same as the app).
+//
+// Usage (from the API project root):
+//   node scripts/send-reminder-test-emails.js
+//   node scripts/send-reminder-test-emails.js someone@else.com
+//
+// The recipient defaults to the address below; pass an arg to override.
+
+import dotenv from 'dotenv';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import Handlebars from '../src/utils/validations/helper/handlebar.helper.js';
+import { sendEmailWithSES } from 'tango-app-api-middleware';
+
+dotenv.config();
+
+const TO = process.argv[2] || 'ayyanarkalusulingam13@gmail.com';
+
+const __dirname = path.dirname( fileURLToPath( import.meta.url ) );
+const HBS_DIR = path.resolve( __dirname, '../src/hbs' );
+Handlebars.registerPartial(
+    'invoiceSummaryTable',
+    fs.readFileSync( `${HBS_DIR}/partials/invoiceSummaryTable.hbs`, 'utf8' ),
+);
+
+// Sample data — a representative client with two unpaid invoices.
+const data = {
+  clientName: 'Cashify',
+  companyName: 'Team Tango',
+  dueDate: '17 Jun 2026',
+  totalDue: '₹ 2,70,106.00',
+  logo: `${JSON.parse( process.env.URL ).apiDomain}/logo.png`,
+  invoices: [
+    { invoiceNumber: 'INV-26-27-00210', invoiceDate: '02 Jun 2026', dueDate: '17 Jun 2026', amountDue: '₹ 1,42,947.00' },
+    { invoiceNumber: 'INV-26-27-00205', invoiceDate: '02 May 2026', dueDate: '17 May 2026', amountDue: '₹ 1,27,159.00' },
+  ],
+};
+
+const STAGES = [
+  { file: 'reminderBeforeDue.hbs', subject: `[TEST] Payment reminder — due on ${data.dueDate}` },
+  { file: 'reminderOnDue.hbs', subject: `[TEST] Payment due today — ${data.totalDue} outstanding` },
+  { file: 'reminderOnHold.hbs', subject: '[TEST] Action needed: payment overdue — your account is on hold' },
+  { file: 'reminderSuspended.hbs', subject: '[TEST] Important: account suspended — payment 30+ days overdue' },
+  { file: 'reminderDeactivated.hbs', subject: '[TEST] Final notice: account deactivated — payment 60+ days overdue' },
+];
+
+async function run() {
+  const SES = JSON.parse( process.env.SES );
+  const fromEmail = SES.accountsEmail || SES.adminEmail;
+  console.log( `Sending ${STAGES.length} reminder emails to ${TO} (from ${fromEmail})\n` );
+
+  for ( const stage of STAGES ) {
+    const tpl = Handlebars.compile( fs.readFileSync( `${HBS_DIR}/${stage.file}`, 'utf8' ) );
+    const html = tpl( data );
+    try {
+      await sendEmailWithSES( TO, stage.subject, html, '', fromEmail );
+      console.log( `  ✓ sent: ${stage.file}` );
+    } catch ( err ) {
+      console.error( `  ✗ failed: ${stage.file} —`, err?.message || err );
+    }
+  }
+  console.log( '\nDone.' );
+  process.exit( 0 );
+}
+
+run();

package/src/controllers/brandsBilling.controller.js

@@ -15,6 +15,12 @@ export async function brandsBillingList( req, res ) {
   try {
     let query = [];
 
+    // Billing-store count is taken from dailyPricing for the current billing
+    // month: a store counts only if it actually RAN on more than one day in
+    // the month (a store that appears on a single day is transient — e.g. a
+    // late onboard or a one-off reading — and isn't billed for the period).
+    const billingMonthStart = new Date( dayjs().startOf( 'month' ).toISOString() );
+
     if ( req.body.status && req.body.status.length > 0 ) {
       query.push( {
         $match: {
@@ -38,9 +44,15 @@ export async function brandsBillingList( req, res ) {
             let: { clientId: '$clientId' },
             pipeline: [
               {
+                // Count only ACTIVE stores — the 'stores' collection also holds
+                // deactive/suspended docs which inflated the No. of Stores
+                // column and made it inconsistent with Billing Stores.
                 $match: {
                   $expr: {
-                    $eq: [ '$clientId', '$$clientId' ],
+                    $and: [
+                      { $eq: [ '$clientId', '$$clientId' ] },
+                      { $eq: [ '$status', 'active' ] },
+                    ],
                   },
                 },
               },
@@ -66,7 +78,6 @@ export async function brandsBillingList( req, res ) {
               {
                 $group: {
                   _id: null,
-                  billingStores: { $sum: { $size: { $ifNull: [ '$stores', [] ] } } },
                   products: { $addToSet: '$products' },
                   nextBillingDate: { $min: '$nextBillingDate' },
                 },
@@ -75,6 +86,35 @@ export async function brandsBillingList( req, res ) {
             as: 'billingData',
           },
         },
+        {
+          // Billing stores from dailyPricing: distinct active stores that ran
+          // on MORE THAN ONE day in the current billing month. We unwind the
+          // per-day store rows, keep active ones, collect the distinct dates
+          // each store was active, then count only the stores seen on >1 day.
+          $lookup: {
+            from: 'dailypricings',
+            let: { clientId: '$clientId' },
+            pipeline: [
+              {
+                $match: {
+                  $expr: { $eq: [ '$clientId', '$$clientId' ] },
+                  dateISO: { $gte: billingMonthStart },
+                },
+              },
+              { $unwind: { path: '$stores', preserveNullAndEmptyArrays: false } },
+              { $match: { 'stores.status': 'active' } },
+              {
+                $group: {
+                  _id: '$stores.storeId',
+                  days: { $addToSet: { $dateToString: { format: '%Y-%m-%d', date: '$dateISO' } } },
+                },
+              },
+              { $match: { $expr: { $gt: [ { $size: '$days' }, 1 ] } } },
+              { $count: 'billingStores' },
+            ],
+            as: 'dailyBillingData',
+          },
+        },
         {
           $lookup: {
             from: 'invoices',
@@ -91,9 +131,14 @@ export async function brandsBillingList( req, res ) {
                 },
               },
               {
+                // Split unpaid totals by currency so dollar invoices can be
+                // converted to INR after aggregation (the $lookup can't call
+                // getUsdInrRate). Invoice totalAmount is stored in NATIVE
+                // currency, so summing blindly mislabelled USD as INR.
                 $group: {
                   _id: null,
-                  totalDue: { $sum: '$totalAmount' },
+                  dueInr: { $sum: { $cond: [ { $eq: [ '$currency', 'dollar' ] }, 0, '$totalAmount' ] } },
+                  dueUsd: { $sum: { $cond: [ { $eq: [ '$currency', 'dollar' ] }, '$totalAmount', 0 ] } },
                 },
               },
             ],
@@ -106,13 +151,16 @@ export async function brandsBillingList( req, res ) {
         {
           $unwind: { path: '$billingData', preserveNullAndEmptyArrays: true },
         },
+        {
+          $unwind: { path: '$dailyBillingData', preserveNullAndEmptyArrays: true },
+        },
         {
           $unwind: { path: '$invoiceData', preserveNullAndEmptyArrays: true },
         },
         {
           $addFields: {
             totalStores: { $ifNull: [ '$storeData.totalStores', 0 ] },
-            billingStores: { $ifNull: [ '$billingData.billingStores', 0 ] },
+            billingStores: { $ifNull: [ '$dailyBillingData.billingStores', 0 ] },
             productsAdded: {
               $size: {
                 $filter: {
@@ -122,7 +170,8 @@ export async function brandsBillingList( req, res ) {
                 },
               },
             },
-            billAmountDue: { $ifNull: [ '$invoiceData.totalDue', 0 ] },
+            dueInr: { $ifNull: [ '$invoiceData.dueInr', 0 ] },
+            dueUsd: { $ifNull: [ '$invoiceData.dueUsd', 0 ] },
             nextBillingDate: { $ifNull: [ '$billingData.nextBillingDate', null ] },
           },
         },
@@ -135,7 +184,8 @@ export async function brandsBillingList( req, res ) {
             totalStores: 1,
             billingStores: 1,
             productsAdded: 1,
-            billAmountDue: 1,
+            dueInr: 1,
+            dueUsd: 1,
             status: 1,
             paymentStatus: '$planDetails.paymentStatus',
             nextBillingDate: 1,
@@ -164,6 +214,17 @@ export async function brandsBillingList( req, res ) {
 
     let allData = await clientService.aggregate( query );
 
+    // Bill Amount Due in INR: dollar invoice totals converted at today's rate
+    // and added to the INR totals, so the column and the ₹-labelled Total Bill
+    // Due chip are a single, additive currency. (Previously USD was shown as ₹
+    // and the grand total summed INR+USD raw.)
+    const billDueRate = await getUsdInrRate();
+    for ( const c of allData ) {
+      c.billAmountDue = Math.round( ( ( c.dueInr || 0 ) + ( c.dueUsd || 0 ) * billDueRate ) * 100 ) / 100;
+      delete c.dueInr;
+      delete c.dueUsd;
+    }
+
     // Lifecycle + payment counts over the FULL client population (no status /
     // paymentStatus filter), so the overview cards stay stable regardless of
     // which lifecycle tab is selected — and so Hold / Suspended / Deactive
@@ -190,6 +251,7 @@ export async function brandsBillingList( req, res ) {
               { case: { $eq: [ '$$ps', 'free' ] }, then: 'free' },
               { case: { $and: [ { $eq: [ '$$ps', 'paid' ] }, '$$hasTrialProduct' ] }, then: 'trialPaid' },
               { case: { $eq: [ '$$ps', 'paid' ] }, then: 'paid' },
+              { case: { $eq: [ '$$ps', 'unbilled' ] }, then: 'unbilled' },
             ],
             default: 'other',
           },
@@ -206,7 +268,7 @@ export async function brandsBillingList( req, res ) {
     // regardless of the selected tab, and show even when the Active tab is
     // empty.
     const lifecycle = { active: 0, hold: 0, suspended: 0, deactive: 0 };
-    const payTotals = { trial: 0, paid: 0, free: 0, trialPaid: 0 };
+    const payTotals = { trial: 0, paid: 0, free: 0, trialPaid: 0, unbilled: 0 };
     const paymentByStatus = {};
     let totalBrands = 0;
     matrixAgg.forEach( ( row ) => {
@@ -221,7 +283,7 @@ export async function brandsBillingList( req, res ) {
         payTotals[pay] += n;
       }
       if ( !paymentByStatus[st] ) {
-        paymentByStatus[st] = { trial: 0, paid: 0, free: 0, trialPaid: 0 };
+        paymentByStatus[st] = { trial: 0, paid: 0, free: 0, trialPaid: 0, unbilled: 0 };
       }
       if ( paymentByStatus[st][pay] != null ) {
         paymentByStatus[st][pay] += n;
@@ -238,6 +300,7 @@ export async function brandsBillingList( req, res ) {
       paid: payTotals.paid,
       free: payTotals.free,
       trialPaid: payTotals.trialPaid,
+      unbilled: payTotals.unbilled,
       paymentByStatus,
       // Money/store totals stay tied to the filtered view so they match the
       // rows on screen.
@@ -1476,6 +1539,12 @@ export async function billingSummary( req, res ) {
         installationInr: { $sum: { $cond: [ '$isDollar', 0, '$installation' ] } },
         installationUsd: { $sum: { $cond: [ '$isDollar', '$installation', 0 ] } },
         companyName: { $last: '$companyName' },
+        // Track the actual invoice currencies so the row currency reflects how
+        // the client is really billed — not the (sometimes stale)
+        // paymentInvoice.currencyType. e.g. Sundora is flagged 'dollar' but
+        // every invoice is INR.
+        dollarInvoices: { $sum: { $cond: [ '$isDollar', 1, 0 ] } },
+        inrInvoices: { $sum: { $cond: [ '$isDollar', 0, 1 ] } },
       } },
     ] );
 
@@ -1556,11 +1625,15 @@ export async function billingSummary( req, res ) {
           // to (status 'live') — trials are excluded.
           liveProductSet: new Set( products.filter( ( p ) => p.status === 'live' )
               .map( ( p ) => String( p.productName || '' ).toLowerCase() ) ),
+          // Fallback only — overridden below from actual invoice currencies
+          // when the client has invoices.
           currency: c?.paymentInvoice?.currencyType === 'dollar' ? 'dollar' : 'inr',
           csm: [ ...( csmByClient.get( key ) || [] ) ].join( ', ' ),
           revenueMonths: {},
           billedStoresMonths: {},
           installationFee: 0,
+          invDollar: 0,
+          invInr: 0,
         } );
       }
       return rows.get( key );
@@ -1571,11 +1644,37 @@ export async function billingSummary( req, res ) {
       r.revenueMonths[inv._id.ym] = Math.round( ( ( inv.revenueInr || 0 ) + ( inv.revenueUsd || 0 ) * usdRate ) * 100 ) / 100;
       r.billedStoresMonths[inv._id.ym] = inv.stores || 0;
       r.installationFee += ( inv.installationInr || 0 ) + ( inv.installationUsd || 0 ) * usdRate;
+      r.invDollar += ( inv.dollarInvoices || 0 );
+      r.invInr += ( inv.inrInvoices || 0 );
       if ( inv.companyName ) {
         r.registeredEntity = inv.companyName;
       }
     }
 
+    // Resolve each row's currency from its actual invoices: 'dollar' only when
+    // the client has dollar invoices and NO inr invoices; otherwise 'inr'. The
+    // paymentInvoice.currencyType fallback set above stands only for clients
+    // with no invoices in the window.
+    for ( const r of rows.values() ) {
+      if ( r.invDollar > 0 || r.invInr > 0 ) {
+        r.currency = ( r.invDollar > 0 && r.invInr === 0 ) ? 'dollar' : 'inr';
+      }
+      delete r.invDollar;
+      delete r.invInr;
+    }
+
+    // A client may be actively billing yet have no invoice in the 5-month
+    // window (e.g. invoice for the running month not generated yet). Seed a
+    // row for any client that has a current-month store reading in
+    // dailyPricing, so the list reflects every brand under billing — not just
+    // the ones with a recent invoice. (Without this, brands silently vanish
+    // from the summary until their next invoice lands.)
+    for ( const [ clientId ] of curStoresByClient ) {
+      if ( clientById.has( clientId ) ) {
+        rowOf( clientId );
+      }
+    }
+
     const curKey = months[4].key;
     const prevKey = months[3].key;
     const data = [ ...rows.values() ].map( ( r ) => {

package/src/controllers/estimate.controller.js

@@ -191,6 +191,69 @@ export async function createEstimate( req, res ) {
   }
 }
 
+export async function updateEstimate( req, res ) {
+  try {
+    const b = req.body || {};
+    const estimateId = b._id || b.estimateId || req.params.estimateId;
+    if ( !estimateId ) {
+      return res.sendError( 'estimateId is required', 400 );
+    }
+
+    const existing = await estimateService.findOne( { _id: estimateId } );
+    if ( !existing ) {
+      return res.sendError( 'Estimate not found', 404 );
+    }
+    // Accepted estimates are locked — mirrors the delete guard.
+    if ( ( existing._doc || existing ).status === 'accepted' ) {
+      return res.sendError( 'An accepted estimate cannot be edited.', 409 );
+    }
+
+    const amount = Math.round( Number( b.amount ) || 0 );
+    let totalAmount = Math.round( Number( b.totalAmount ) || 0 );
+    if ( !totalAmount && amount ) {
+      totalAmount = Math.round( amount * 1.18 );
+    }
+
+    // Only the editable fields are updated. The estimate number, index,
+    // clientId and createdDate are immutable so the document keeps its
+    // identity and financial-year sequence.
+    const update = {
+      companyName: b.companyName ?? existing.companyName,
+      companyAddress: b.companyAddress ?? existing.companyAddress,
+      PlaceOfSupply: b.PlaceOfSupply ?? existing.PlaceOfSupply,
+      GSTNumber: b.GSTNumber ?? existing.GSTNumber,
+      groupId: b.groupId || existing.groupId,
+      groupName: b.groupName || existing.groupName,
+      stores: Number( b.stores ) || 0,
+      products: Array.isArray( b.products ) ? b.products : existing.products,
+      tax: Array.isArray( b.tax ) ? b.tax : existing.tax,
+      amount,
+      totalAmount,
+      currency: b.currency || existing.currency,
+      notes: b.notes ?? existing.notes,
+      updatedBy: req.user?.email || req.user?.userName || '',
+    };
+    if ( b.validTill ) {
+      update.validTill = new Date( b.validTill );
+    }
+    if ( b.period ) {
+      update.period = b.period;
+    }
+    // Allow a status nudge (e.g. draft → sent) on save, but never to accepted.
+    if ( b.status && [ 'draft', 'sent' ].includes( b.status ) ) {
+      update.status = b.status;
+    }
+
+    await estimateService.updateOne( { _id: estimateId }, { $set: update } );
+    const saved = await estimateService.findOne( { _id: estimateId } );
+    logger.info?.( { function: 'updateEstimate', estimateId } );
+    return res.sendSuccess( saved );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'updateEstimate' } );
+    return res.sendError( error, 500 );
+  }
+}
+
 export async function getEstimate( req, res ) {
   try {
     const estimate = await estimateService.findOne( { _id: req.params.estimateId } );

package/src/controllers/invoice.controller.js

@@ -142,7 +142,8 @@ export async function createInvoice( req, res ) {
         clientId: req.body.clientId,
         groupId: req.body.groupId || undefined,
         groupName: req.body.groupName || '',
-        companyName: req.body.companyName || '',
+        // Company (registered) name is always stored uppercase on invoices.
+        companyName: ( req.body.companyName || '' ).toUpperCase(),
         companyAddress: req.body.companyAddress || '',
         GSTNumber: req.body.GSTNumber || '',
         PlaceOfSupply: req.body.PlaceOfSupply || '',
@@ -285,7 +286,7 @@ export async function createInvoice( req, res ) {
         amount: Math.round( amount ),
         invoiceIndex: req.body.invoiceId ? findInvoice.invoiceIndex : invoiceNo,
         tax: taxList,
-        companyName: group.registeredCompanyName,
+        companyName: ( group.registeredCompanyName || '' ).toUpperCase(),
         companyAddress: address,
         PlaceOfSupply: group.placeOfSupply,
         GSTNumber: group.gst,
@@ -372,6 +373,10 @@ 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;
 
   const annexClient = await clientService.findOne( { clientId: invoiceInfo.clientId }, { 'planDetails.product': 1 } );
   const billingTypeMap = {};
@@ -432,7 +437,9 @@ async function buildAnnexureRows( invoiceInfo, getgroup ) {
         units = s.trafficCameraCount;
       }
     }
-    const price = Number( s.standard?.negotiatePrice ) || 0;
+    // 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;
     const runningCost = s.workingdays >= monthDays ?
       Math.round( price * units * 100 ) / 100 :
       Math.round( ( price / monthDays ) * s.workingdays * units * 100 ) / 100;
@@ -526,6 +533,10 @@ export async function invoiceDownload( req, res ) {
         billingCurrency: virtualAccount?.currency,
         virtualaccountNumber: virtualAccount ? virtualAccount?.accountNumber : '',
         virtualifsc: virtualAccount ? virtualAccount?.ifsc : '',
+        // GST applies only to domestic (INR) invoices. Gate the tax block on the
+        // invoice's OWN currency — not the payment-account currency, which is
+        // null/non-inr for many INR invoices and was dropping the GST rows.
+        gstApplicable: invoiceInfo.currency === 'inr',
       };
 
       if ( invoiceData?.tax?.length ) {
@@ -590,9 +601,20 @@ export async function invoiceDownload( req, res ) {
           // Load configured CSM + Finance heads PLUS the per-client CSMs from
           // userAssignedStore as CC recipients on the invoice mail.
           const ccEmails = await getInvoiceCcEmails( invoiceInfo.clientId );
-          console.log( fromEmail, getgroup.generateInvoiceTo, ccEmails, attachments );
-
-          const result = await sendEmailWithSES( getgroup.generateInvoiceTo, mailSubject, mailbody, attachments, fromEmail, ccEmails.length ? ccEmails : undefined );
+          // De-duplicate recipients so nobody gets the invoice 2-3 times:
+          // unique TO list, and drop from CC anyone already in TO (overlap
+          // between generateInvoiceTo, invoice heads and assigned CSMs was the
+          // cause of duplicate mails).
+          const toEmails = [ ...new Set(
+              ( getgroup.generateInvoiceTo || [] ).map( ( e ) => String( e || '' ).trim() ).filter( Boolean ),
+          ) ];
+          const toSet = new Set( toEmails.map( ( e ) => e.toLowerCase() ) );
+          const dedupedCc = [ ...new Set(
+              ( ccEmails || [] ).map( ( e ) => String( e || '' ).trim() ).filter( Boolean ),
+          ) ].filter( ( e ) => !toSet.has( e.toLowerCase() ) );
+          console.log( fromEmail, toEmails, dedupedCc, attachments );
+
+          const result = await sendEmailWithSES( toEmails, mailSubject, mailbody, attachments, fromEmail, dedupedCc.length ? dedupedCc : undefined );
           console.log( result );
           let logObj = {
             userName: req.user?.userName,
@@ -707,6 +729,8 @@ async function buildInvoicePdfBuffer( invoiceId ) {
     billingCurrency: virtualAccount?.currency,
     virtualaccountNumber: virtualAccount ? virtualAccount?.accountNumber : '',
     virtualifsc: virtualAccount ? virtualAccount?.ifsc : '',
+    // GST applies only to domestic (INR) invoices; gate on the invoice currency.
+    gstApplicable: invoiceInfo.currency === 'inr',
   };
 
   if ( invoiceData?.tax?.length ) {
@@ -1290,8 +1314,12 @@ async function standardPrice( group, getClient, baseDate ) {
     return product;
   } );
 
-  // Combine overallStore and eachStore products
-  return [ ...products, ...eachStoreProducts ];
+  // Combine overallStore and eachStore products. Sort by product name so the
+  // persisted order is deterministic — MongoDB $group output order isn't
+  // guaranteed, which made products "interchange" between the Plans view, the
+  // stored invoice and regenerated invoices / PDF.
+  return [ ...products, ...eachStoreProducts ]
+      .sort( ( a, b ) => String( a.productName || '' ).localeCompare( String( b.productName || '' ) ) );
 }
 
 
@@ -1425,7 +1453,10 @@ async function stepPrice( group, getClient ) {
       },
     },
     {
+      // productName first so order is deterministic across views/PDF, then
+      // workingdays so step rows stay grouped consistently.
       $sort: {
+        productName: 1,
         workingdays: -1,
       },
     },
@@ -1854,6 +1885,24 @@ export async function clientInvoiceList( req, res ) {
     }
 
     if ( req.body.export ) {
+      // Due Status — mirrors the UI cell (getDueStatus) exactly so the column
+      // matches what reviewers see on screen. Paid / no-due-date show a dash;
+      // otherwise it's overdue / due today / due in N days from TODAY at
+      // day-granularity (time-of-day ignored on both ends).
+      const today = dayjs().startOf( 'day' );
+      const dueStatusOf = ( inv ) => {
+        if ( inv.paymentStatus === 'paid' || !inv.dueDate ) {
+          return '—';
+        }
+        const days = dayjs( inv.dueDate ).startOf( 'day' ).diff( today, 'day' );
+        if ( days < 0 ) {
+          return `Overdue by ${-days} day${days === -1 ? '' : 's'}`;
+        }
+        if ( days === 0 ) {
+          return 'Due today';
+        }
+        return `Due in ${days} day${days === 1 ? '' : 's'}`;
+      };
       const exportdata = [];
       count.forEach( ( element ) => {
         exportdata.push( {
@@ -1862,9 +1911,13 @@ export async function clientInvoiceList( req, res ) {
           'Invoice #': element.invoice,
           'Billing date': dayjs( element.billingDate ).format( 'DD MMM, YYYY' ),
           'Due Date': element.dueDate ? dayjs( element.dueDate ).format( 'DD MMM, YYYY' ) : '',
+          'Due Status': dueStatusOf( element ),
           'Group Name': element.groupName,
           'Amount Excl. GST': element.amount,
-          'GST Amount': element.gstAmount,
+          // GST only applies to domestic (INR) invoices. International invoices
+          // (dollar / euro / etc.) are billed without GST — show a dash to
+          // match the on-screen column rather than a misleading 0.
+          'GST Amount': element.currency === 'inr' ? element.gstAmount : '—',
           'Amount Incl. GST': element.totalAmount,
           'Stores': element.stores,
           'Payment Status': element.paymentStatus,
@@ -2468,7 +2521,10 @@ async function transitionInvoiceStatus( req, res, fromStatus, toStatus ) {
       return res.sendError( 'Invoice not found', 404 );
     }
 
-    if ( invoice.status !== fromStatus ) {
+    // Legacy 'pending' invoices are equivalent to the first CSM stage, so the
+    // CSM transition accepts either 'pendingCsm' or 'pending' as the source.
+    const acceptedFrom = fromStatus === 'pendingCsm' ? [ 'pendingCsm', 'pending' ] : [ fromStatus ];
+    if ( !acceptedFrom.includes( invoice.status ) ) {
       return res.sendError(
           `Invoice is currently at status '${invoice.status}', not '${fromStatus}'. Another user may have advanced it.`,
           409,