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

package/package.json

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

@@ -5,8 +5,10 @@ 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 * as cameraService from '../services/camera.service.js';
+import * as planogramService from '../services/planogram.service.js';
 import dayjs from 'dayjs';
-import { logger, checkFileExist, signedUrl, download, insertOpenSearchData } from 'tango-app-api-middleware';
+import { logger, checkFileExist, signedUrl, download, insertOpenSearchData, getOpenSearchData } from 'tango-app-api-middleware';
 import * as XLSX from 'xlsx';
 import ExcelJS from 'exceljs';
 import { bulkUpdateBillingGroupRowSchema } from '../dtos/validation.dtos.js';
@@ -586,16 +588,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 +725,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 +857,7 @@ export async function latestDailyPricing( req, res ) {
         ...( store._doc || store ),
         invoiceAmount: Math.round( invoiceAmount * 100 ) / 100,
         invoiceBreakdown,
-        invoiceCurrency: bpCurrency,
+        invoiceCurrency: invoiceCurrency,
       };
     } );
 
@@ -1667,6 +1696,11 @@ export async function getUsdInrRate() {
 export async function billingSummary( req, res ) {
   try {
     const now = dayjs();
+    const nowDate = now.toDate();
+    // Today's USD->INR rate. Hoisted here (cached) so both the aging buckets and
+    // the revenue columns convert dollar invoices consistently.
+    const usdRate = await getUsdInrRate();
+    const usdRateForAging = usdRate;
     const months = [];
     for ( let i = 4; i >= 0; i-- ) {
       const m = now.subtract( i, 'month' );
@@ -1726,6 +1760,54 @@ export async function billingSummary( req, res ) {
     } );
     const clientById = new Map( clients.map( ( c ) => [ String( c.clientId ), c ] ) );
 
+    // AR aging — outstanding balance per client, bucketed by days past the
+    // invoice DUE DATE. Scope: APPROVED invoices that are not fully paid
+    // (paymentStatus unpaid/partial). Amount per invoice = balance due
+    // (totalAmount - paidAmount). Dollar invoices are converted to INR at
+    // today's rate so the buckets are comparable across currencies (matching the
+    // revenue columns). This intentionally spans ALL time, not the 5-month
+    // window, because overdue balances can be older than the revenue window.
+    const agingRows = await invoiceService.aggregate( [
+      { $match: {
+        status: 'approved',
+        paymentStatus: { $in: [ 'unpaid', 'partial', 'due' ] },
+      } },
+      { $addFields: {
+        dueDateD: { $cond: [
+          { $eq: [ { $type: '$dueDate' }, 'date' ] },
+          '$dueDate',
+          { $convert: { input: '$dueDate', to: 'date', onError: null, onNull: null } },
+        ] },
+        balance: { $subtract: [
+          { $ifNull: [ '$totalAmount', 0 ] },
+          { $ifNull: [ '$paidAmount', 0 ] },
+        ] },
+        isDollar: { $eq: [ '$currency', 'dollar' ] },
+      } },
+      // Only invoices with a positive balance still owed.
+      { $match: { balance: { $gt: 0 } } },
+      { $addFields: {
+        // Days past due. Missing/invalid dueDate -> treat as 0 days overdue so
+        // the amount still shows in the youngest bucket rather than vanishing.
+        daysPastDue: { $cond: [
+          { $eq: [ '$dueDateD', null ] },
+          0,
+          { $dateDiff: { startDate: '$dueDateD', endDate: nowDate, unit: 'day' } },
+        ] },
+      } },
+      { $group: {
+        _id: '$clientId',
+        // Bucket the BALANCE (INR-normalized) by age. < 30, 30-60, > 60.
+        b0to30: { $sum: { $cond: [ { $lt: [ '$daysPastDue', 30 ] },
+          { $cond: [ '$isDollar', { $multiply: [ '$balance', usdRateForAging ] }, '$balance' ] }, 0 ] } },
+        b30to60: { $sum: { $cond: [ { $and: [ { $gte: [ '$daysPastDue', 30 ] }, { $lte: [ '$daysPastDue', 60 ] } ] },
+          { $cond: [ '$isDollar', { $multiply: [ '$balance', usdRateForAging ] }, '$balance' ] }, 0 ] } },
+        bOver60: { $sum: { $cond: [ { $gt: [ '$daysPastDue', 60 ] },
+          { $cond: [ '$isDollar', { $multiply: [ '$balance', usdRateForAging ] }, '$balance' ] }, 0 ] } },
+      } },
+    ] );
+    const agingByClient = new Map( agingRows.map( ( a ) => [ String( a._id ), a ] ) );
+
     // 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
@@ -1740,7 +1822,7 @@ export async function billingSummary( req, res ) {
 
     // Per-client CSM (userAssignedStore, tangoUserType 'csm'); display the
     // email's local part since the collection carries no display name.
-    const usdRate = await getUsdInrRate();
+    // usdRate already fetched at the top of the function.
 
     // Current month's store count comes from dailyPricing — counted the same
     // way as Brands & Billing's "Billing Stores": distinct ACTIVE stores that
@@ -1957,11 +2039,21 @@ export async function billingSummary( req, res ) {
       // a client has no billing-group registered name.
       const regNames = regNamesByClient.get( r.clientId ) || [];
       const registeredEntity = regNames[0] || r.registeredEntity || '';
+      // AR aging buckets (INR-normalized). Rounded; outstanding = sum of buckets.
+      const ag = agingByClient.get( r.clientId );
+      const aging0to30 = ag ? Math.round( ag.b0to30 || 0 ) : 0;
+      const aging30to60 = ag ? Math.round( ag.b30to60 || 0 ) : 0;
+      const agingOver60 = ag ? Math.round( ag.bOver60 || 0 ) : 0;
+      const outstanding = aging0to30 + aging30to60 + agingOver60;
       return {
         clientId: r.clientId,
         clientName: r.clientName || registeredEntity || r.clientId,
         registeredEntity,
         registeredEntities: regNames.length ? regNames : ( r.registeredEntity ? [ r.registeredEntity ] : [] ),
+        outstanding,
+        aging0to30,
+        aging30to60,
+        agingOver60,
         status: r.status,
         products: r.products,
         csm: r.csm,
@@ -2021,3 +2113,127 @@ export async function billingSummary( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+
+// ---------------------------------------------------------------------------
+// Additional Products table (Billing Breakdown). These are extra, non-standard
+// products billed per store for a SPECIFIC client only. Currently scoped to
+// clientId '11'; for any other client this returns an empty list so the table
+// simply doesn't render.
+//
+// Both products and their unit prices are hardcoded here by design (they're not
+// in the basepricing catalog). Quantity = distinct store count from each
+// product's own source collection:
+//   - Eyetest   -> cameras collection (eye-test streams with a QR code)
+//   - Planogram -> planograms collection (distinct storeName)
+// Total = Quantity * unit price (INR).
+// ---------------------------------------------------------------------------
+const ADDITIONAL_PRODUCTS_CLIENT_ID = '11';
+// Agreed INR unit prices for client 11.
+const ADDITIONAL_PRODUCT_PRICES = {
+  eyetest: 450,
+  planogram: 770,
+  aiManager: 500,
+};
+// OpenSearch index holding extra billed products (VMS, Run AI, etc.). Each
+// record is a daily snapshot carrying its own quantity + price per product.
+const BILLING_DETAILS_INDEX = ( () => {
+  try {
+    return JSON.parse( process.env.OPENSEARCH || '{}' ).billingDetails || 'billing_details';
+  } catch ( e ) {
+    return 'billing_details';
+  }
+} )();
+
+// Compute the additional-products list for a client. Returns [] for any client
+// that has none (currently only clientId 11). Shared by the Billing Breakdown
+// table (additionalProducts controller) AND invoice generation, so both stay in
+// sync. Each entry: { productName, quantity, price, total }.
+export async function getAdditionalProducts( clientId ) {
+  clientId = String( clientId ?? '' );
+  if ( clientId !== ADDITIONAL_PRODUCTS_CLIENT_ID ) {
+    return [];
+  }
+
+  // Eyetest: distinct stores in the cameras collection that have an eye-test
+  // stream with a QR code.
+  const eyetestRows = await cameraService.aggregate( [
+    { $match: { $and: [
+      { clientId: clientId },
+      { isEyeTestStream: true },
+      { qrCode: { $exists: true } },
+    ] } },
+    { $group: { _id: '$storeId' } },
+    { $count: 'stores' },
+  ] );
+  const eyetestQty = eyetestRows?.[0]?.stores || 0;
+
+  // Planogram: distinct storeName in the planograms collection.
+  const planogramRows = await planogramService.aggregate( [
+    { $match: { clientId: clientId } },
+    { $group: { _id: null, storecount: { $addToSet: '$storeName' } } },
+    { $project: { count: { $size: '$storecount' } } },
+  ] );
+  const planogramQty = planogramRows?.[0]?.count || 0;
+
+  // AI Manager: same count as tangoTraffic running stores — distinct stores in
+  // the latest daily-pricing doc whose tangoTraffic product ran more than one
+  // working day (a single-day appearance is transient and not billed).
+  const aiManagerRows = await dailyPriceService.aggregate( [
+    { $match: { clientId: clientId } },
+    { $sort: { dateISO: -1 } },
+    { $limit: 1 },
+    { $unwind: '$stores' },
+    { $unwind: '$stores.products' },
+    { $match: { 'stores.products.productName': 'tangoTraffic', 'stores.products.workingdays': { $gt: 1 } } },
+    { $group: { _id: '$stores.storeId' } },
+    { $count: 'stores' },
+  ] );
+  const aiManagerQty = aiManagerRows?.[0]?.stores || 0;
+
+  const build = ( productName, quantity, price ) => ( {
+    productName,
+    quantity,
+    price,
+    total: Math.round( quantity * price * 100 ) / 100,
+  } );
+
+  const products = [
+    build( 'Eyetest', eyetestQty, ADDITIONAL_PRODUCT_PRICES.eyetest ),
+    build( 'Planogram', planogramQty, ADDITIONAL_PRODUCT_PRICES.planogram ),
+    build( 'AI Manager', aiManagerQty, ADDITIONAL_PRODUCT_PRICES.aiManager ),
+  ];
+
+  // Extra products from the billing_details OpenSearch index — the LATEST daily
+  // snapshot for this client. quantity/price are stored as strings, so coerce
+  // them. If OpenSearch is unreachable we just skip these rows rather than
+  // failing the whole list.
+  try {
+    const osRes = await getOpenSearchData( BILLING_DETAILS_INDEX, {
+      size: 1,
+      query: { term: { 'client_id': clientId } },
+      sort: [ { date_string: { order: 'desc' } } ],
+    } );
+    const hits = osRes?.body?.hits?.hits || osRes?.hits?.hits || [];
+    const osProducts = hits[0]?._source?.products || [];
+    for ( const p of osProducts ) {
+      const quantity = Number( p.quantity ) || 0;
+      const price = Number( p.price ) || 0;
+      products.push( build( p.productName, quantity, price ) );
+    }
+  } catch ( osError ) {
+    logger.error( { error: osError, function: 'getAdditionalProducts:openSearch' } );
+  }
+
+  return products;
+}
+
+export async function additionalProducts( req, res ) {
+  try {
+    const clientId = String( req.query?.clientId ?? req.body?.clientId ?? '' );
+    const products = await getAdditionalProducts( clientId );
+    return res.sendSuccess( { currency: 'inr', products } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'additionalProducts' } );
+    return res.sendError( error, 500 );
+  }
+}

package/src/controllers/invoice.controller.js

@@ -18,7 +18,7 @@ import { invoiceStatusEnum } from '../dtos/validation.dtos.js';
 import { findOneApplicationDefault } from '../services/applicationDefault.service.js';
 import * as assignedStoreService from '../services/assignedStore.service.js';
 import * as bankTransactionService from '../services/bankTransaction.service.js';
-import { getUsdInrRate } from './brandsBilling.controller.js';
+import { getUsdInrRate, getAdditionalProducts } from './brandsBilling.controller.js';
 
 // Pulls CSM + Finance head emails (stored under applicationDefault
 // type=invoice, subType=heads) AND the per-client CSMs assigned via
@@ -241,6 +241,26 @@ export async function createInvoice( req, res ) {
         products = await stepPrice( group, getClient );
       }
 
+      // Additional products (e.g. Lenskart / clientId 11: Eyetest, Planogram,
+      // AI Manager + the OpenSearch billing_details rows). Each is a single
+      // full-month line item (quantity x price), appended on top of the normal
+      // store-based product lines. Added BEFORE the multi-month expansion below
+      // so they repeat per month and are included in the taxable subtotal, just
+      // like the standard products. Returns [] for any client without extras.
+      const extraProducts = await getAdditionalProducts( group.clientId );
+      for ( const ep of extraProducts ) {
+        products.push( {
+          productName: ep.productName,
+          period: 'fullmonth',
+          storeCount: ep.quantity,
+          amount: ep.total,
+          price: ep.price,
+          description: ep.productName,
+          HsnNumber: '998314',
+          month: baseDate.format( 'MMM YYYY' ),
+        } );
+      }
+
       // Billing horizon in months. Advance and normal cycle are independent —
       // only one drives the span per generation:
       //   advanceInvoice ON  -> advancePeriod (advance future billing)
@@ -324,7 +344,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,17 +468,62 @@ 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 annexClient = await clientService.findOne( { clientId: invoiceInfo.clientId }, { 'planDetails.product': 1, 'priceType': 1 } );
   const billingTypeMap = {};
   ( annexClient?.planDetails?.product || [] ).forEach( ( p ) => {
     billingTypeMap[p.productName] = p.billingType || 'perStore';
   } );
 
+  // Pricing for this client. For STEP clients the price depends on the store's
+  // position within the product (tier ranges), so we can't join a single price
+  // per store in the aggregation — that join is what caused every store to
+  // appear once per tier (e.g. the same store listed at $45 and again at $40).
+  // Instead we pull the tiers here and assign each store a single tier price
+  // below, in JS, by its 1-based index within the product.
+  const pricingDoc = await basepricingService.findOne( { clientId: invoiceInfo.clientId }, { standard: 1, step: 1 } );
+  const isStep = annexClient?.priceType === 'step';
+  const tiersByProduct = {};
+  ( ( isStep ? pricingDoc?.step : pricingDoc?.standard ) || [] ).forEach( ( p ) => {
+    if ( !tiersByProduct[p.productName] ) {
+      tiersByProduct[p.productName] = [];
+    }
+    tiersByProduct[p.productName].push( p );
+  } );
+  // Step tiers must be ordered by their range start so index lookups are correct.
+  Object.keys( tiersByProduct ).forEach( ( name ) => {
+    tiersByProduct[name].sort( ( a, b ) => {
+      const aStart = parseInt( String( a.storeRange || '0' ).split( '-' )[0], 10 ) || 0;
+      const bStart = parseInt( String( b.storeRange || '0' ).split( '-' )[0], 10 ) || 0;
+      return aStart - bStart;
+    } );
+  } );
+
+  // Resolve the per-store price. Standard: first (only) tier's price. Step: the
+  // tier whose range contains this store's 1-based position within the product.
+  const priceForStore = ( productName, positionInProduct ) => {
+    const tiers = tiersByProduct[productName] || [];
+    if ( !tiers.length ) {
+      return 0;
+    }
+    if ( !isStep ) {
+      return Number( tiers[0].negotiatePrice ) || 0;
+    }
+    for ( const tier of tiers ) {
+      const [ min, max ] = String( tier.storeRange || '' ).split( '-' ).map( Number );
+      if ( positionInProduct >= min && positionInProduct <= max ) {
+        return Number( tier.negotiatePrice ) || 0;
+      }
+    }
+    // Beyond the last defined tier: fall back to the last tier's price.
+    return Number( tiers[tiers.length - 1].negotiatePrice ) || 0;
+  };
+
   const rows = await dailyPricingService.aggregate( [
     { $match: { clientId: invoiceInfo.clientId, dateISO: { $lte: billingMonthEnd } } },
     { $sort: { dateISO: -1 } },
@@ -469,25 +542,12 @@ async function buildAnnexureRows( invoiceInfo, getgroup ) {
       zoneCameraCount: { $ifNull: [ '$stores.zoneCameraCount', 0 ] },
     } },
     { $match: { workingdays: { $gt: 0 } } },
-    { $sort: { productName: 1, workingdays: -1 } },
-    { $lookup: {
-      from: 'basepricings',
-      let: { clientId: invoiceInfo.clientId },
-      pipeline: [
-        { $match: { $expr: { $eq: [ '$clientId', '$$clientId' ] } } },
-        { $project: { standard: 1 } },
-      ],
-      as: 'basepricing',
-    } },
-    { $unwind: { path: '$basepricing', preserveNullAndEmptyArrays: true } },
-    { $project: {
-      productName: 1, workingdays: 1, storeName: 1, storeId: 1, edgefirstFileDate: 1,
-      zoneCount: 1, trafficCameraCount: 1, zoneCameraCount: 1,
-      standard: { $filter: { input: '$basepricing.standard', as: 'standard', cond: { $eq: [ '$$standard.productName', '$productName' ] } } },
-    } },
-    { $unwind: { path: '$standard', preserveNullAndEmptyArrays: true } },
+    // Deterministic ordering so step-tier assignment is stable run to run.
+    { $sort: { productName: 1, storeId: 1 } },
   ] );
 
+  // Track each store's 1-based position within its product to pick the step tier.
+  const productPosition = {};
   const data = rows.map( ( s ) => {
     const billingType = billingTypeMap[s.productName] || 'perStore';
     // Same units rule as invoice generation: perZone / perCamera multiply by
@@ -504,9 +564,11 @@ 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;
+    productPosition[s.productName] = ( productPosition[s.productName] || 0 ) + 1;
+    // negotiatePrice is already in the invoice currency — use it verbatim,
+    // matching invoice generation. For step clients the tier is chosen by the
+    // store's position within the product.
+    const price = priceForStore( s.productName, productPosition[s.productName] );
     const runningCost = s.workingdays >= monthDays ?
       Math.round( price * units * 100 ) / 100 :
       Math.round( ( price / monthDays ) * s.workingdays * units * 100 ) / 100;
@@ -1684,7 +1746,13 @@ async function stepPrice( group, getClient ) {
 
   let stepPriceRecord = await basepricingService.findOne( { clientId: group.clientId } );
   let data = products;
-  let pricing = stepPriceRecord.step;
+  // Tiers must be ordered by range start for the cumulative step assignment in
+  // processArray to walk them low-to-high.
+  let pricing = ( stepPriceRecord.step || [] ).slice().sort( ( a, b ) => {
+    const aStart = parseInt( String( a.storeRange || '0' ).split( '-' )[0], 10 ) || 0;
+    const bStart = parseInt( String( b.storeRange || '0' ).split( '-' )[0], 10 ) || 0;
+    return aStart - bStart;
+  } );
 
   const applyPricing = ( data, pricing ) => {
     let totalcount = 0;
@@ -1713,26 +1781,54 @@ async function stepPrice( group, getClient ) {
   function processArray( array1, array2 ) {
     let updatedArray = [];
 
-    let firstPriceAssigned = false;
+    // Step tiers apply CUMULATIVELY across every working-days bucket of a
+    // product, not per bucket. Track how many stores of each product have
+    // already been priced so each bucket continues where the previous one left
+    // off. (Previously the tier counter reset for every bucket, so e.g. the 9
+    // prorated stores — really stores 75-83, in the $40 tier — were each priced
+    // from tier 1 at $45, producing extra/wrong-priced line items.)
+    const assignedByProduct = {};
+
     for ( let item of array1 ) {
       let remainingStores = item.storeCount;
+      let assigned = assignedByProduct[item.productName] || 0;
 
       for ( let range of array2 ) {
-        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,
-          } );
-          remainingStores -= applicableStores;
-          firstPriceAssigned = true;
+        const [ min, max ] = range.storeRange.split( '-' ).map( Number );
+        if ( remainingStores <= 0 ) {
+          break;
         }
+        // How many of this tier's slots are still free given everything already
+        // assigned to this product across previous buckets.
+        const tierCapacityLeft = max - Math.max( min - 1, assigned );
+        if ( tierCapacityLeft <= 0 ) {
+          continue;
+        }
+        const applicableStores = Math.min( remainingStores, tierCapacityLeft );
+        updatedArray.push( {
+          productName: item.productName,
+          workingdays: item.workingdays,
+          storeCount: applicableStores,
+          // Each tier is charged at its own range's negotiated price.
+          price: range.negotiatePrice,
+        } );
+        remainingStores -= applicableStores;
+        assigned += applicableStores;
       }
+
+      // Any stores beyond the last defined tier are charged at the last tier.
+      if ( remainingStores > 0 && array2.length ) {
+        updatedArray.push( {
+          productName: item.productName,
+          workingdays: item.workingdays,
+          storeCount: remainingStores,
+          price: array2[array2.length - 1].negotiatePrice,
+        } );
+        assigned += remainingStores;
+        remainingStores = 0;
+      }
+
+      assignedByProduct[item.productName] = assigned;
     }
     return updatedArray;
   }
@@ -1741,9 +1837,16 @@ async function stepPrice( group, getClient ) {
   console.log( '++++++++++++', resultarray );
   const result = applyPricing( resultarray, pricing );
   console.log( '***********', result );
+  // Group by product + period + PRICE TIER so each step tier is its own line
+  // item, and all stores within a tier+period collapse into a single line:
+  //   - full-month stores of a tier  -> one line (sum cost, sum count)
+  //   - prorated stores of a tier     -> one averaged line (sum cost, sum count)
+  // Keying on price (not storeCount) is what merges the leftover prorated stores
+  // — which span several working-days buckets — into one $40 line instead of one
+  // line per working-days value.
   const groupedData = result.reduce( ( acc, item ) => {
     const { productName, period, runningCost } = item;
-    const key = `${productName}_${period}_${item.storeCount}`;
+    const key = `${productName}_${period}_${item.price}`;
     if ( !acc[key] ) {
       acc[key] = {
         productName,
@@ -1752,14 +1855,8 @@ async function stepPrice( group, getClient ) {
         count: 0,
       };
     }
-    if ( period === 'proRate' ) {
-      acc[key].totalRunningCost += parseFloat( runningCost );
-      acc[key].count += item.storeCount;
-    } else {
-      acc[key].totalRunningCost = parseFloat( runningCost );
-      acc[key].count = item.storeCount;
-    }
-
+    acc[key].totalRunningCost += parseFloat( runningCost );
+    acc[key].count += item.storeCount;
     return acc;
   }, {} );
   console.log( groupedData );

package/src/routes/brandsBilling.routes.js

@@ -1,6 +1,6 @@
 
 import express from 'express';
-import { brandsBillingList, brandInvoiceList, latestDailyPricing, brandBillingGroups, updateDailyPricingWorkingDays, updateDailyPricingStoreField, getClientBillingInfo, bulkDownloadBillingGroups, bulkUpdateBillingGroups, billingSummary } from '../controllers/brandsBilling.controller.js';
+import { brandsBillingList, brandInvoiceList, latestDailyPricing, brandBillingGroups, updateDailyPricingWorkingDays, updateDailyPricingStoreField, getClientBillingInfo, bulkDownloadBillingGroups, bulkUpdateBillingGroups, billingSummary, additionalProducts } from '../controllers/brandsBilling.controller.js';
 import { isAllowedSessionHandler, accessVerification } from 'tango-app-api-middleware';
 
 export const brandsBillingRouter = express.Router();
@@ -16,3 +16,4 @@ brandsBillingRouter.get( '/bulk-download-billing-groups', isAllowedSessionHandle
 brandsBillingRouter.post( '/bulk-update-billing-groups', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ], access: [ { featureName: 'TangoAdmin', name: 'invoiceApproval', permissions: [ 'isEdit' ] } ] } ), bulkUpdateBillingGroups );
 brandsBillingRouter.post( '/billingSummary', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ], access: [ { featureName: 'TangoAdmin', name: 'invoiceApproval', permissions: [] } ] } ), billingSummary );
 brandsBillingRouter.get( '/billingSummary', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ], access: [ { featureName: 'TangoAdmin', name: 'invoiceApproval', permissions: [] } ] } ), billingSummary );
+brandsBillingRouter.get( '/additionalProducts', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ], access: [ { featureName: 'TangoAdmin', name: 'invoiceApproval', permissions: [] } ] } ), additionalProducts );

package/src/services/planogram.service.js

@@ -0,0 +1,13 @@
+import model from 'tango-api-schema';
+
+export const aggregate = ( query = {} ) => {
+  return model.planogramModel.aggregate( query );
+};
+
+export const find = ( query = {}, record = {} ) => {
+  return model.planogramModel.find( query, record );
+};
+
+export const findOne = ( query = {}, record = {} ) => {
+  return model.planogramModel.findOne( query, record );
+};