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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.5.7",
+    "version": "3.5.9",
     "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.28",
         "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,8 +170,24 @@ 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 ] },
+            // Whether billing is SET UP — true when a billing group exists (or
+            // live products are configured). Drives the Setup-Billing vs View
+            // button; must NOT depend on the volatile current-month run count.
+            billingConfigured: {
+              $or: [
+                { $ne: [ '$billingData', null ] },
+                { $gt: [ {
+                  $size: { $filter: {
+                    input: { $ifNull: [ '$planDetails.product', [] ] },
+                    as: 'prod',
+                    cond: { $eq: [ '$$prod.status', 'live' ] },
+                  } },
+                }, 0 ] },
+              ],
+            },
           },
         },
         {
@@ -135,7 +199,9 @@ export async function brandsBillingList( req, res ) {
             totalStores: 1,
             billingStores: 1,
             productsAdded: 1,
-            billAmountDue: 1,
+            billingConfigured: 1,
+            dueInr: 1,
+            dueUsd: 1,
             status: 1,
             paymentStatus: '$planDetails.paymentStatus',
             nextBillingDate: 1,
@@ -164,6 +230,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 +267,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 +284,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 +299,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 +316,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 +1555,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 ] } },
       } },
     ] );
 
@@ -1492,14 +1577,22 @@ export async function billingSummary( req, res ) {
     // email's local part since the collection carries no display name.
     const usdRate = await getUsdInrRate();
 
-    // Current month's store count comes from dailyPricing (latest reading
-    // this month) — invoices for the running month usually don't exist yet.
+    // Current month's store count comes from dailyPricing — counted the same
+    // way as Brands & Billing's "Billing Stores": distinct ACTIVE stores that
+    // RAN on more than one day in the month (a single-day appearance is
+    // transient and isn't billed). Invoices for the running month usually don't
+    // exist yet, so this is the current-month source.
     const curMonthStart = new Date( now.startOf( 'month' ).toISOString() );
     const latestDp = await dailyPriceService.aggregate( [
       { $match: { dateISO: { $gte: curMonthStart } } },
-      { $project: { clientId: 1, activeStores: 1, dateISO: 1 } },
-      { $sort: { dateISO: 1 } },
-      { $group: { _id: '$clientId', stores: { $last: '$activeStores' } } },
+      { $unwind: { path: '$stores', preserveNullAndEmptyArrays: false } },
+      { $match: { 'stores.status': 'active' } },
+      { $group: {
+        _id: { clientId: '$clientId', storeId: '$stores.storeId' },
+        days: { $addToSet: { $dateToString: { format: '%Y-%m-%d', date: '$dateISO' } } },
+      } },
+      { $match: { $expr: { $gt: [ { $size: '$days' }, 1 ] } } },
+      { $group: { _id: '$_id.clientId', stores: { $sum: 1 } } },
     ] );
     const curStoresByClient = new Map( latestDp.map( ( d ) => [ String( d._id ), d.stores || 0 ] ) );
 
@@ -1556,11 +1649,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 +1668,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 ) => {