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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.5.8",
+    "version": "3.5.10",
     "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.27",
+        "tango-api-schema": "^2.6.29",
         "tango-app-api-middleware": "^3.6.18",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0",

package/src/controllers/bankTransaction.controller.js

@@ -467,69 +467,118 @@ export async function resolveBankTransaction( req, res ) {
     }
 
     // ---- reconcile ----
-    const invoiceId = req.body?.invoiceId;
-    if ( !invoiceId ) {
-      return res.sendError( 'invoiceId is required to reconcile', 400 );
-    }
-    const invoice = await invoiceService.findOne( { _id: invoiceId } );
-    if ( !invoice ) {
-      return res.sendError( 'Invoice not found', 404 );
+    // Accept either a single invoiceId (legacy) or a list of invoiceIds. One
+    // payment can settle multiple invoices: the amount auto-fills them in the
+    // order given, each settled fully until the money runs out.
+    const invoiceIds = Array.isArray( req.body?.invoiceIds ) && req.body.invoiceIds.length ?
+      req.body.invoiceIds.map( String ) :
+      ( req.body?.invoiceId ? [ String( req.body.invoiceId ) ] : [] );
+    if ( !invoiceIds.length ) {
+      return res.sendError( 'invoiceIds is required to reconcile', 400 );
     }
 
-    const prevPaid = Number( invoice.paidAmount ) || 0;
-    const totalAmount = Number( invoice.totalAmount ) || 0;
-    const outstanding = round2( totalAmount - prevPaid );
-    const diff = round2( txn.amount - outstanding );
-
-    let note;
-    let newStatus;
-    if ( Math.abs( diff ) <= AMOUNT_TOLERANCE ) {
-      newStatus = 'paid';
-      note = `Manually reconciled to ${invoice.invoice} — invoice marked Paid`;
-    } else if ( diff < 0 ) {
-      newStatus = 'partial';
-      note = `Partial — ${round2( -diff )} balance remains on ${invoice.invoice}`;
-    } else {
-      newStatus = 'paid';
-      note = `Overpayment — ${invoice.invoice} settled, ${round2( diff )} excess to follow up`;
+    // EDIT case: this transaction was ALREADY reconciled, so its amount was
+    // previously applied to one or more invoices. Reverse each prior allocation
+    // first so re-reconciling never double-counts. Prefer the recorded
+    // per-invoice allocations; fall back to the single invoiceId for older rows.
+    if ( txn.status === 'reconciled' ) {
+      const priorAllocations = ( Array.isArray( txn.appliedInvoices ) && txn.appliedInvoices.length ) ?
+        txn.appliedInvoices :
+        ( txn.invoiceId ? [ { invoiceId: txn.invoiceId, amount: txn.amount } ] : [] );
+      for ( const alloc of priorAllocations ) {
+        const prevInvoice = await invoiceService.findOne( { _id: alloc.invoiceId } );
+        if ( !prevInvoice ) {
+          continue;
+        }
+        const revertedPaid = round2( Math.max( 0, ( Number( prevInvoice.paidAmount ) || 0 ) - ( Number( alloc.amount ) || 0 ) ) );
+        const prevTotal = Number( prevInvoice.totalAmount ) || 0;
+        const revertedStatus = revertedPaid <= AMOUNT_TOLERANCE ? 'unpaid' :
+          ( round2( prevTotal - revertedPaid ) > AMOUNT_TOLERANCE ? 'partial' : 'paid' );
+        await invoiceService.invoiceUpdateOne(
+            { _id: prevInvoice._id },
+            {
+              $set: { paymentStatus: revertedStatus, paidAmount: revertedPaid },
+              $pull: { paymentHistory: { reference: txn.refNo || undefined, method: 'bank-statement' } },
+            },
+        );
+      }
     }
-    const newPaid = round2( prevPaid + txn.amount );
-
-    await invoiceService.invoiceUpdateOne(
-        { _id: invoice._id },
-        {
-          $set: {
-            paymentStatus: newStatus,
-            paidAmount: newPaid,
-            ...( newStatus === 'paid' ? { paidDate: new Date() } : {} ),
-          },
-          $push: {
-            paymentHistory: {
-              amount: txn.amount,
-              date: txn.valueDate || new Date(),
-              method: 'bank-statement',
-              reference: txn.refNo || undefined,
-              notes: `Manually reconciled from "${txn.fileName || 'statement'}"`,
-              recordedBy: req.user?.email || req.user?.userName || 'bank-reconciliation',
-              recordedAt: new Date(),
+
+    // Apply the payment across the selected invoices in order (auto-fill).
+    let remaining = round2( txn.amount );
+    const appliedInvoices = [];
+    const settledLabels = [];
+    let firstInvoice = null;
+    for ( const id of invoiceIds ) {
+      const invoice = await invoiceService.findOne( { _id: id } );
+      if ( !invoice ) {
+        continue;
+      }
+      if ( !firstInvoice ) {
+        firstInvoice = invoice;
+      }
+      const prevPaid = Number( invoice.paidAmount ) || 0;
+      const totalAmount = Number( invoice.totalAmount ) || 0;
+      const outstanding = round2( Math.max( 0, totalAmount - prevPaid ) );
+      const applied = round2( Math.max( 0, Math.min( remaining, outstanding ) ) );
+      if ( applied <= 0 && outstanding > 0 ) {
+        // No money left for this invoice — record it as selected but unfunded.
+        continue;
+      }
+      remaining = round2( remaining - applied );
+      const newPaid = round2( prevPaid + applied );
+      const fullySettled = round2( totalAmount - newPaid ) <= AMOUNT_TOLERANCE;
+      await invoiceService.invoiceUpdateOne(
+          { _id: invoice._id },
+          {
+            $set: {
+              paymentStatus: fullySettled ? 'paid' : 'partial',
+              paidAmount: newPaid,
+              ...( fullySettled ? { paidDate: new Date() } : {} ),
+            },
+            $push: {
+              paymentHistory: {
+                amount: applied,
+                date: txn.valueDate || new Date(),
+                method: 'bank-statement',
+                reference: txn.refNo || undefined,
+                notes: `Manually reconciled from "${txn.fileName || 'statement'}"`,
+                recordedBy: req.user?.email || req.user?.userName || 'bank-reconciliation',
+                recordedAt: new Date(),
+              },
             },
           },
-        },
-    );
+      );
+      appliedInvoices.push( { invoiceId: String( invoice._id ), invoice: invoice.invoice, amount: applied } );
+      settledLabels.push( `${invoice.invoice} (${fullySettled ? 'Paid' : 'Partial'})` );
+    }
+
+    if ( !appliedInvoices.length ) {
+      return res.sendError( 'None of the selected invoices could be reconciled.', 400 );
+    }
+
+    const pending = round2( remaining );
+    let note = appliedInvoices.length > 1 ?
+      `Reconciled across ${appliedInvoices.length} invoices: ${settledLabels.join( ', ' )}` :
+      `Manually reconciled to ${settledLabels[0]}`;
+    if ( pending > AMOUNT_TOLERANCE ) {
+      note += ` — ₹${pending} excess to follow up`;
+    }
 
-    // Brand name for the table's Brand Name column.
-    const client = await clientService.findOne( { clientId: invoice.clientId }, { clientName: 1 } );
+    // Brand name for the table's Brand Name column (from the first invoice).
+    const client = await clientService.findOne( { clientId: firstInvoice.clientId }, { clientName: 1 } );
     await bankTransactionService.updateOne( { _id: txnId }, { $set: {
       status: 'reconciled',
       contacted: false,
-      invoice: invoice.invoice,
-      invoiceId: String( invoice._id ),
-      identifiedClientId: String( invoice.clientId ?? '' ),
-      identifiedClientName: client?.clientName || invoice.companyName || '',
+      invoice: appliedInvoices.map( ( a ) => a.invoice ).join( ', ' ),
+      invoiceId: appliedInvoices[0].invoiceId,
+      appliedInvoices,
+      identifiedClientId: String( firstInvoice.clientId ?? '' ),
+      identifiedClientName: client?.clientName || firstInvoice.companyName || '',
       resultNote: note,
     } } );
 
-    return res.sendSuccess( { status: 'reconciled', note, invoice: invoice.invoice } );
+    return res.sendSuccess( { status: 'reconciled', note, invoices: appliedInvoices.map( ( a ) => a.invoice ), pending } );
   } catch ( error ) {
     logger.error( { error: error, function: 'resolveBankTransaction' } );
     return res.sendError( error, 500 );

package/src/controllers/brandsBilling.controller.js

@@ -30,11 +30,36 @@ export async function brandsBillingList( req, res ) {
     }
 
     if ( req.body.paymentStatus && req.body.paymentStatus.length > 0 ) {
-      query.push( {
-        $match: {
-          'planDetails.paymentStatus': { $in: req.body.paymentStatus },
-        },
-      } );
+      // Filter by the SAME derived buckets the pills use (see payBucketExpr),
+      // so a selected pill returns exactly the rows it counts:
+      //   trial     -> paymentStatus == 'trial'
+      //   free      -> paymentStatus == 'free'
+      //   paid      -> paymentStatus in {paid,unbilled,due} AND no trial product
+      //   trialPaid -> paymentStatus in {paid,unbilled,due} AND has a trial product
+      // 'trialPaid' is a derived bucket — there is no stored 'trialPaid'
+      // status — which is why a plain $in match returned no data.
+      const buckets = req.body.paymentStatus;
+      const paidLike = [ 'paid', 'unbilled', 'due' ];
+      const hasTrialProduct = { $gt: [ { $size: { $filter: {
+        input: { $ifNull: [ '$planDetails.product', [] ] },
+        as: 'p',
+        cond: { $eq: [ '$$p.status', 'trial' ] },
+      } } }, 0 ] };
+      const ors = [];
+      for ( const b of buckets ) {
+        if ( b === 'trial' || b === 'free' ) {
+          ors.push( { $eq: [ '$planDetails.paymentStatus', b ] } );
+        } else if ( b === 'paid' ) {
+          ors.push( { $and: [ { $in: [ '$planDetails.paymentStatus', paidLike ] }, { $not: hasTrialProduct } ] } );
+        } else if ( b === 'trialPaid' ) {
+          ors.push( { $and: [ { $in: [ '$planDetails.paymentStatus', paidLike ] }, hasTrialProduct ] } );
+        } else {
+          ors.push( { $eq: [ '$planDetails.paymentStatus', b ] } );
+        }
+      }
+      if ( ors.length ) {
+        query.push( { $match: { $expr: ors.length === 1 ? ors[0] : { $or: ors } } } );
+      }
     }
 
     query.push(
@@ -173,6 +198,21 @@ export async function brandsBillingList( req, res ) {
             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 ] },
+              ],
+            },
           },
         },
         {
@@ -184,10 +224,25 @@ export async function brandsBillingList( req, res ) {
             totalStores: 1,
             billingStores: 1,
             productsAdded: 1,
+            billingConfigured: 1,
             dueInr: 1,
             dueUsd: 1,
             status: 1,
-            paymentStatus: '$planDetails.paymentStatus',
+            // Display mapping for the Payment Status column: an 'unbilled' or
+            // 'due' plan is shown as 'paid'; any other status is shown as-is.
+            paymentStatus: {
+              $cond: {
+                if: { $eq: [ '$planDetails.paymentStatus', 'unbilled' ] },
+                then: 'paid',
+                else: {
+                  $cond: {
+                    if: { $eq: [ '$planDetails.paymentStatus', 'due' ] },
+                    then: 'paid',
+                    else: '$planDetails.paymentStatus',
+                  },
+                },
+              },
+            },
             nextBillingDate: 1,
             currencyType: '$paymentInvoice.currencyType',
           },
@@ -249,9 +304,11 @@ export async function brandsBillingList( req, res ) {
             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' },
-              { case: { $eq: [ '$$ps', 'unbilled' ] }, then: 'unbilled' },
+              // 'unbilled' and 'due' are treated as PAID (same mapping as the
+              // Payment Status column). A paid/unbilled/due plan that still has
+              // a product on trial is bucketed as trialPaid.
+              { case: { $and: [ { $in: [ '$$ps', [ 'paid', 'unbilled', 'due' ] ] }, '$$hasTrialProduct' ] }, then: 'trialPaid' },
+              { case: { $in: [ '$$ps', [ 'paid', 'unbilled', 'due' ] ] }, then: 'paid' },
             ],
             default: 'other',
           },
@@ -268,7 +325,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, unbilled: 0 };
+    const payTotals = { trial: 0, paid: 0, free: 0, trialPaid: 0 };
     const paymentByStatus = {};
     let totalBrands = 0;
     matrixAgg.forEach( ( row ) => {
@@ -283,7 +340,7 @@ export async function brandsBillingList( req, res ) {
         payTotals[pay] += n;
       }
       if ( !paymentByStatus[st] ) {
-        paymentByStatus[st] = { trial: 0, paid: 0, free: 0, trialPaid: 0, unbilled: 0 };
+        paymentByStatus[st] = { trial: 0, paid: 0, free: 0, trialPaid: 0 };
       }
       if ( paymentByStatus[st][pay] != null ) {
         paymentByStatus[st][pay] += n;
@@ -300,7 +357,6 @@ 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.
@@ -594,8 +650,14 @@ export async function latestDailyPricing( req, res ) {
     let stores = record.stores || [];
     let count = stores.length;
 
-    if ( req.body.statusFilter && req.body.statusFilter !== '' ) {
-      stores = stores.filter( ( s ) => s.status === req.body.statusFilter );
+    // statusFilter may be an array (multi-select) or a legacy string. An empty
+    // value / empty array means "all statuses".
+    const statusFilterList = Array.isArray( req.body.statusFilter ) ?
+      req.body.statusFilter.filter( Boolean ) :
+      ( req.body.statusFilter ? [ req.body.statusFilter ] : [] );
+    if ( statusFilterList.length ) {
+      const allowed = new Set( statusFilterList );
+      stores = stores.filter( ( s ) => allowed.has( s.status ) );
     }
 
     if ( req.body.searchValue && req.body.searchValue !== '' ) {
@@ -1557,18 +1619,38 @@ export async function billingSummary( req, res ) {
     } );
     const clientById = new Map( clients.map( ( c ) => [ String( c.clientId ), c ] ) );
 
+    // Registered Entity comes from the billings collection (each billing group's
+    // registeredCompanyName). A client can have multiple groups/names, so
+    // collect the distinct list per client — the UI shows the first and reveals
+    // the rest on hover.
+    const billingNameAgg = await billingService.aggregatebilling( [
+      { $match: { registeredCompanyName: { $exists: true, $nin: [ '', null ] } } },
+      { $group: { _id: '$clientId', names: { $addToSet: '$registeredCompanyName' } } },
+    ] );
+    const regNamesByClient = new Map(
+        billingNameAgg.map( ( b ) => [ String( b._id ), ( b.names || [] ).filter( Boolean ) ] ),
+    );
+
     // 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.
+    // 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 ] ) );
 
@@ -1762,10 +1844,17 @@ export async function billingSummary( req, res ) {
       revCur = revCur == null ? null : Math.round( revCur );
       const revPrevOut = revPrev == null ? null : Math.round( revPrev );
       const installationOut = r.installationFee ? Math.round( r.installationFee ) : null;
+      // Registered Entity from the billings collection (distinct group names).
+      // First name shown in the column; the full list is sent so the UI can
+      // reveal the others on hover. Fall back to the invoice company name when
+      // a client has no billing-group registered name.
+      const regNames = regNamesByClient.get( r.clientId ) || [];
+      const registeredEntity = regNames[0] || r.registeredEntity || '';
       return {
         clientId: r.clientId,
-        clientName: r.clientName || r.registeredEntity || r.clientId,
-        registeredEntity: r.registeredEntity,
+        clientName: r.clientName || registeredEntity || r.clientId,
+        registeredEntity,
+        registeredEntities: regNames.length ? regNames : ( r.registeredEntity ? [ r.registeredEntity ] : [] ),
         status: r.status,
         products: r.products,
         csm: r.csm,