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

package/src/controllers/brandsBilling.controller.js

@@ -3,6 +3,8 @@ import * as invoiceService from '../services/invoice.service.js';
 import * as billingService from '../services/billing.service.js';
 import * as dailyPriceService from '../services/dailyPrice.service.js';
 import * as storeService from '../services/store.service.js';
+import * as assignedStoreService from '../services/assignedStore.service.js';
+import * as basePriceService from '../services/basePrice.service.js';
 import dayjs from 'dayjs';
 import { logger, checkFileExist, signedUrl, download, insertOpenSearchData } from 'tango-app-api-middleware';
 import * as XLSX from 'xlsx';
@@ -162,19 +164,93 @@ export async function brandsBillingList( req, res ) {
 
     let allData = await clientService.aggregate( query );
 
-    if ( allData.length == 0 ) {
-      return res.sendError( 'No data', 204 );
-    }
+    // 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
+    // show even when the default Active tab has zero rows. trialPaid is the
+    // derived "paid plan with at least one product still on trial" bucket.
+    // Bucket every client into ONE mutually-exclusive payment bucket so the
+    // pills (Paid / Trial / Paid-Trial / Free) sum to their lifecycle tab
+    // total. trialPaid = paid plan that still has a product on trial; such a
+    // client is trialPaid, NOT also paid.
+    const payBucketExpr = {
+      $let: {
+        vars: {
+          ps: '$planDetails.paymentStatus',
+          hasTrialProduct: { $gt: [ { $size: { $filter: {
+            input: { $ifNull: [ '$planDetails.product', [] ] },
+            as: 'p',
+            cond: { $eq: [ '$$p.status', 'trial' ] },
+          } } }, 0 ] },
+        },
+        in: {
+          $switch: {
+            branches: [
+              { case: { $eq: [ '$$ps', 'trial' ] }, then: 'trial' },
+              { case: { $eq: [ '$$ps', 'free' ] }, then: 'free' },
+              { case: { $and: [ { $eq: [ '$$ps', 'paid' ] }, '$$hasTrialProduct' ] }, then: 'trialPaid' },
+              { case: { $eq: [ '$$ps', 'paid' ] }, then: 'paid' },
+            ],
+            default: 'other',
+          },
+        },
+      },
+    };
+    const matrixAgg = await clientService.aggregate( [
+      { $project: { status: 1, payBucket: payBucketExpr } },
+      { $group: { _id: { status: '$status', pay: '$payBucket' }, count: { $sum: 1 } } },
+    ] );
+
+    // Lifecycle totals + a status×payment matrix. Counts are over the FULL
+    // population (no filter) so the overview cards and pills stay stable
+    // 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 paymentByStatus = {};
+    let totalBrands = 0;
+    matrixAgg.forEach( ( row ) => {
+      const st = row._id.status || 'active';
+      const pay = row._id.pay;
+      const n = row.count || 0;
+      totalBrands += n;
+      if ( lifecycle[st] != null ) {
+        lifecycle[st] += n;
+      }
+      if ( payTotals[pay] != null ) {
+        payTotals[pay] += n;
+      }
+      if ( !paymentByStatus[st] ) {
+        paymentByStatus[st] = { trial: 0, paid: 0, free: 0, trialPaid: 0 };
+      }
+      if ( paymentByStatus[st][pay] != null ) {
+        paymentByStatus[st][pay] += n;
+      }
+    } );
 
     let summary = {
-      totalBrands: allData.length,
-      active: allData.filter( ( c ) => c.status === 'active' ).length,
-      trial: allData.filter( ( c ) => c.paymentStatus === 'trial' ).length,
-      paid: allData.filter( ( c ) => c.paymentStatus === 'paid' ).length,
+      totalBrands,
+      active: lifecycle.active,
+      hold: lifecycle.hold,
+      suspended: lifecycle.suspended,
+      deactive: lifecycle.deactive,
+      trial: payTotals.trial,
+      paid: payTotals.paid,
+      free: payTotals.free,
+      trialPaid: payTotals.trialPaid,
+      paymentByStatus,
+      // Money/store totals stay tied to the filtered view so they match the
+      // rows on screen.
       totalBillDue: allData.reduce( ( sum, c ) => sum + ( c.billAmountDue || 0 ), 0 ),
       storesUnderBilling: allData.reduce( ( sum, c ) => sum + ( c.billingStores || 0 ), 0 ),
     };
 
+    if ( allData.length == 0 ) {
+      // Still return the population summary so the overview cards populate even
+      // when the current lifecycle tab is empty.
+      return res.sendSuccess( { summary, count: 0, data: [] } );
+    }
+
     if ( req.body.export ) {
       const exportdata = [];
       allData.forEach( ( element ) => {
@@ -524,6 +600,36 @@ export async function latestDailyPricing( req, res ) {
       storeList = stores.slice( skip, skip + Number( req.body.limit ) );
     }
 
+    // Monthly Billing Summary — one row per month of the brand's invoice
+    // history (stores billed + invoice amount), newest first. The UI tags the
+    // current/last-generated rows and computes month-over-month deltas.
+    // billingDate is a Date on most rows but a string on some legacy ones, so
+    // coerce before extracting year/month.
+    const monthlyBillingSummary = await invoiceService.aggregate( [
+      { $match: { clientId: req.body.clientId } },
+      { $addFields: { billingDateD: { $cond: [
+        { $eq: [ { $type: '$billingDate' }, 'date' ] },
+        '$billingDate',
+        { $toDate: '$billingDate' },
+      ] } } },
+      { $match: { billingDateD: { $ne: null } } },
+      { $group: {
+        _id: { year: { $year: '$billingDateD' }, month: { $month: '$billingDateD' } },
+        storesBilled: { $sum: { $ifNull: [ '$stores', 0 ] } },
+        invoiceAmount: { $sum: { $ifNull: [ '$totalAmount', 0 ] } },
+        currency: { $last: { $ifNull: [ '$currency', 'inr' ] } },
+      } },
+      { $sort: { '_id.year': -1, '_id.month': -1 } },
+      { $project: {
+        _id: 0,
+        year: '$_id.year',
+        month: '$_id.month',
+        storesBilled: 1,
+        invoiceAmount: { $round: [ '$invoiceAmount', 2 ] },
+        currency: 1,
+      } },
+    ] );
+
     let data = {
       clientId: record.clientId,
       brandName: record.brandName,
@@ -535,6 +641,7 @@ export async function latestDailyPricing( req, res ) {
       proRate: record.proRate,
       count,
       data: storeList,
+      monthlyBillingSummary,
     };
 
     res.sendSuccess( data );
@@ -1290,3 +1397,332 @@ export async function bulkUpdateBillingGroups( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+
+// ---------------------------------------------------------------------------
+// Billing Summary (landing tab): one row per client — monthly store counts,
+// revenue, price-per-store and installation fee all from the invoice
+// collection (the billed `stores` count per invoice), products + status from
+// clients, CSM from userAssignedStore. Window: last 5 calendar months
+// including the current. Filtering/sorting happen client-side (the dataset
+// is one row per client).
+// ---------------------------------------------------------------------------
+// Today's USD->INR rate for dollar-priced clients. Live rate (cached 6h)
+// with an env override (USD_INR_RATE) and a last-known/static fallback so
+// the summary never fails because a rate API is down.
+let usdRateCache = { rate: null, at: 0 };
+export async function getUsdInrRate() {
+  const override = Number( process.env.USD_INR_RATE );
+  if ( override > 0 ) {
+    return override;
+  }
+  if ( usdRateCache.rate && ( Date.now() - usdRateCache.at ) < 6 * 60 * 60 * 1000 ) {
+    return usdRateCache.rate;
+  }
+  try {
+    const resp = await fetch( 'https://open.er-api.com/v6/latest/USD', { signal: AbortSignal.timeout( 4000 ) } );
+    const body = await resp.json();
+    const rate = Number( body?.rates?.INR );
+    if ( rate > 0 ) {
+      usdRateCache = { rate, at: Date.now() };
+      return rate;
+    }
+  } catch ( err ) {
+    logger.error( { error: err, function: 'getUsdInrRate' } );
+  }
+  return usdRateCache.rate || 83.33;
+}
+
+export async function billingSummary( req, res ) {
+  try {
+    const now = dayjs();
+    const months = [];
+    for ( let i = 4; i >= 0; i-- ) {
+      const m = now.subtract( i, 'month' );
+      months.push( { key: m.format( 'YYYY-MM' ), label: m.format( 'MMM-YY' ) } );
+    }
+    const windowStart = new Date( now.subtract( 4, 'month' ).startOf( 'month' ).toISOString() );
+
+    // Revenue (excl. GST), billed stores and installation fees per client per
+    // month. billingDate is a string on some legacy rows — coerce first.
+    const invoices = await invoiceService.aggregate( [
+      { $addFields: { billingDateD: { $cond: [
+        { $eq: [ { $type: '$billingDate' }, 'date' ] },
+        '$billingDate',
+        { $toDate: '$billingDate' },
+      ] } } },
+      { $match: { billingDateD: { $gte: windowStart } } },
+      { $project: {
+        clientId: 1,
+        companyName: 1,
+        amount: { $ifNull: [ '$amount', 0 ] },
+        stores: { $ifNull: [ '$stores', 0 ] },
+        isDollar: { $eq: [ '$currency', 'dollar' ] },
+        ym: { $dateToString: { format: '%Y-%m', date: '$billingDateD' } },
+        installation: { $sum: { $map: {
+          input: { $filter: {
+            input: { $ifNull: [ '$products', [] ] },
+            cond: { $eq: [ '$$this.productName', 'installationFee' ] },
+          } },
+          in: { $ifNull: [ '$$this.amount', 0 ] },
+        } } },
+      } },
+      // Dollar invoices are summed separately so they can be converted to
+      // INR at today's rate when the months are merged below.
+      { $group: {
+        _id: { c: '$clientId', ym: '$ym' },
+        revenueInr: { $sum: { $cond: [ '$isDollar', 0, '$amount' ] } },
+        revenueUsd: { $sum: { $cond: [ '$isDollar', '$amount', 0 ] } },
+        stores: { $sum: '$stores' },
+        installationInr: { $sum: { $cond: [ '$isDollar', 0, '$installation' ] } },
+        installationUsd: { $sum: { $cond: [ '$isDollar', '$installation', 0 ] } },
+        companyName: { $last: '$companyName' },
+      } },
+    ] );
+
+    const clients = await clientService.find( {}, {
+      'clientId': 1,
+      'clientName': 1,
+      'planDetails.product.productName': 1,
+      'planDetails.product.status': 1,
+      'paymentInvoice.currencyType': 1,
+    } );
+    const clientById = new Map( clients.map( ( c ) => [ String( c.clientId ), c ] ) );
+
+    // Per-client CSM (userAssignedStore, tangoUserType 'csm'); display the
+    // 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.
+    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' } } },
+    ] );
+    const curStoresByClient = new Map( latestDp.map( ( d ) => [ String( d._id ), d.stores || 0 ] ) );
+
+    // Negotiated price per store from the basepricing collection — standard
+    // rows sum across products; step rows are resolved by store-count range.
+    const pricingDocs = await basePriceService.find(
+        { clientId: { $exists: true, $nin: [ '', null ] } },
+        { clientId: 1, standard: 1, step: 1 },
+    );
+    const pricingByClient = new Map( pricingDocs.map( ( d ) => [ String( d.clientId ), d ] ) );
+    const rangeContains = ( rangeStr, count ) => {
+      const s = String( rangeStr || '' );
+      const between = s.match( /(\d+)\s*-\s*(\d+)/ );
+      if ( between ) {
+        return count >= Number( between[1] ) && count <= Number( between[2] );
+      }
+      const plus = s.match( /(\d+)\s*\+/ );
+      if ( plus ) {
+        return count >= Number( plus[1] );
+      }
+      return false;
+    };
+
+    const csms = await assignedStoreService.find( { tangoUserType: 'csm' }, { clientId: 1, userEmail: 1 } );
+    const csmByClient = new Map();
+    for ( const a of csms ) {
+      const key = String( a.clientId ?? '' );
+      const name = String( a.userEmail || '' ).split( '@' )[0];
+      if ( !name ) {
+        continue;
+      }
+      const pretty = name.charAt( 0 ).toUpperCase() + name.slice( 1 );
+      if ( !csmByClient.has( key ) ) {
+        csmByClient.set( key, new Set() );
+      }
+      csmByClient.get( key ).add( pretty );
+    }
+
+    // Merge — a client appears when it has billed invoices in the window.
+    const rows = new Map();
+    const rowOf = ( clientId ) => {
+      const key = String( clientId ?? '' );
+      if ( !rows.has( key ) ) {
+        const c = clientById.get( key );
+        const products = ( c?.planDetails?.product || [] );
+        rows.set( key, {
+          clientId: key,
+          clientName: c?.clientName || '',
+          registeredEntity: '',
+          status: products.length && products.every( ( p ) => p.status === 'trial' ) ? 'Trial' : 'Paid',
+          products: [ ...new Set( products.map( ( p ) => String( p.productName || '' )
+              .replace( /^tango/i, '' ).replace( /^./, ( ch ) => ch.toUpperCase() ) ).filter( Boolean ) ) ],
+          // Price/Store only counts products the client actually subscribes
+          // to (status 'live') — trials are excluded.
+          liveProductSet: new Set( products.filter( ( p ) => p.status === 'live' )
+              .map( ( p ) => String( p.productName || '' ).toLowerCase() ) ),
+          currency: c?.paymentInvoice?.currencyType === 'dollar' ? 'dollar' : 'inr',
+          csm: [ ...( csmByClient.get( key ) || [] ) ].join( ', ' ),
+          revenueMonths: {},
+          billedStoresMonths: {},
+          installationFee: 0,
+        } );
+      }
+      return rows.get( key );
+    };
+
+    for ( const inv of invoices ) {
+      const r = rowOf( inv._id.c );
+      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;
+      if ( inv.companyName ) {
+        r.registeredEntity = inv.companyName;
+      }
+    }
+
+    const curKey = months[4].key;
+    const prevKey = months[3].key;
+    const data = [ ...rows.values() ].map( ( r ) => {
+      const revPrev = r.revenueMonths[prevKey] ?? null;
+      // Price per store from the basepricing collection (negotiated price,
+      // base price fallback). Step pricing picks the row whose store-count
+      // range covers the latest billed store count. Clients without a
+      // basepricing doc fall back to revenue / stores so the column never
+      // lies silently.
+      let latestStores = curStoresByClient.get( r.clientId ) ?? null;
+      if ( latestStores == null ) {
+        for ( let i = months.length - 1; i >= 0; i-- ) {
+          if ( r.billedStoresMonths[months[i].key] ) {
+            latestStores = r.billedStoresMonths[months[i].key];
+            break;
+          }
+        }
+      }
+      let pricePerStore = null;
+      const pdoc = pricingByClient.get( r.clientId );
+      // Price/Store counts only subscribed products — and never the one-time
+      // installationFee line, which isn't a per-store recurring price.
+      const isLive = ( name ) => {
+        const n = String( name || '' ).toLowerCase();
+        return n !== 'installationfee' && r.liveProductSet.has( n );
+      };
+      if ( pdoc?.standard?.length ) {
+        const liveRows = pdoc.standard.filter( ( p ) => isLive( p.productName ) );
+        pricePerStore = liveRows.length ?
+          liveRows.reduce( ( a, p ) => a + ( Number( p.negotiatePrice ) || Number( p.basePrice ) || 0 ), 0 ) :
+          null;
+      } else if ( pdoc?.step?.length ) {
+        const byProduct = new Map();
+        for ( const p of pdoc.step ) {
+          if ( !isLive( p.productName ) ) {
+            continue;
+          }
+          const key = p.productName || '';
+          if ( !byProduct.has( key ) ) {
+            byProduct.set( key, [] );
+          }
+          byProduct.get( key ).push( p );
+        }
+        let sum = 0;
+        for ( const list of byProduct.values() ) {
+          const hit = ( latestStores != null && list.find( ( x ) => rangeContains( x.storeRange, latestStores ) ) ) || list[0];
+          sum += Number( hit?.negotiatePrice ) || Number( hit?.basePrice ) || 0;
+        }
+        pricePerStore = sum || null;
+      }
+      if ( pricePerStore == null ) {
+        for ( let i = months.length - 1; i >= 0; i-- ) {
+          const k = months[i].key;
+          if ( r.revenueMonths[k] && r.billedStoresMonths[k] ) {
+            // revenueMonths is INR — divide back for dollar clients so the
+            // fallback price stays in their native currency.
+            pricePerStore = r.revenueMonths[k] / r.billedStoresMonths[k] / ( r.currency === 'dollar' ? usdRate : 1 );
+            break;
+          }
+        }
+      }
+      pricePerStore = pricePerStore == null ? null : Math.round( pricePerStore );
+      // Current month's revenue: the invoice amount once generated; until
+      // then an estimate of live store count x price per store.
+      let revCur = r.revenueMonths[curKey] ?? null;
+      let revCurEstimated = false;
+      if ( revCur == null ) {
+        const curStores = curStoresByClient.get( r.clientId );
+        if ( curStores && pricePerStore != null ) {
+          // Dollar clients carry a USD per-store price — convert the
+          // projection to INR at today's rate.
+          revCur = curStores * pricePerStore * ( r.currency === 'dollar' ? usdRate : 1 );
+          revCurEstimated = true;
+        }
+      }
+      let variance = null;
+      if ( revCur != null && revPrev != null && revPrev > 0 ) {
+        variance = Math.round( ( revCur - revPrev ) / revPrev * 100 );
+      } else if ( revCur == null && revPrev != null ) {
+        variance = -100;
+      }
+      // All revenue figures are already INR (dollar invoices converted at
+      // aggregation time; the estimate converted above). Price/Store stays
+      // in native USD for dollar clients.
+      revCur = revCur == null ? null : Math.round( revCur );
+      const revPrevOut = revPrev == null ? null : Math.round( revPrev );
+      const installationOut = r.installationFee ? Math.round( r.installationFee ) : null;
+      return {
+        clientId: r.clientId,
+        clientName: r.clientName || r.registeredEntity || r.clientId,
+        registeredEntity: r.registeredEntity,
+        status: r.status,
+        products: r.products,
+        csm: r.csm,
+        currency: r.currency,
+        stores: months.map( ( m, i ) => i === months.length - 1 ?
+          ( curStoresByClient.get( r.clientId ) ?? r.billedStoresMonths[m.key] ?? null ) :
+          ( r.billedStoresMonths[m.key] ?? null ) ),
+        pricePerStore,
+        revPrev: revPrevOut,
+        revCur,
+        revCurEstimated,
+        variance,
+        installationFee: installationOut,
+      };
+    } ).sort( ( a, b ) => ( b.revCur || 0 ) - ( a.revCur || 0 ) );
+
+    // Server-side filters (GET query or POST body). CSM / Product / Variance /
+    // search narrow the per-client rows after they're computed, since those
+    // fields are derived during the merge above.
+    const f = { ...( req.query || {} ), ...( req.body || {} ) };
+    const csm = f.csm && f.csm !== 'All' ? String( f.csm ) : '';
+    const product = f.product && f.product !== 'All' ? String( f.product ) : '';
+    const variance = f.variance && f.variance !== 'All' ? String( f.variance ) : '';
+    const search = f.search ? String( f.search ).toLowerCase().trim() : '';
+
+    let filtered = data;
+    if ( csm ) {
+      filtered = filtered.filter( ( r ) => ( r.csm || '' ).split( ', ' ).includes( csm ) );
+    }
+    if ( product ) {
+      filtered = filtered.filter( ( r ) => ( r.products || [] ).includes( product ) );
+    }
+    if ( variance === 'growth' ) {
+      filtered = filtered.filter( ( r ) => r.variance > 0 );
+    } else if ( variance === 'decline' ) {
+      filtered = filtered.filter( ( r ) => r.variance < 0 );
+    } else if ( variance === 'flat' ) {
+      filtered = filtered.filter( ( r ) => r.variance === 0 );
+    }
+    if ( search ) {
+      filtered = filtered.filter( ( r ) =>
+        ( r.clientName || '' ).toLowerCase().includes( search ) ||
+        ( r.registeredEntity || '' ).toLowerCase().includes( search ) ||
+        String( r.clientId || '' ).includes( search ),
+      );
+    }
+
+    // Distinct option lists for the filter popover are derived from the FULL
+    // result set (not the filtered slice) so the dropdowns don't shrink as
+    // filters are applied.
+    const csmOptions = [ ...new Set( data.flatMap( ( r ) => String( r.csm || '' ).split( ', ' ).filter( Boolean ) ) ) ].sort();
+    const productOptions = [ ...new Set( data.flatMap( ( r ) => r.products || [] ) ) ].sort();
+
+    return res.sendSuccess( { months, data: filtered, total: data.length, csmOptions, productOptions, usdRate } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'billingSummary' } );
+    return res.sendError( error, 500 );
+  }
+}