tango-app-api-payment-subscription 3.5.14 → 3.5.16

package/package.json

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

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';
@@ -580,6 +582,11 @@ export async function brandInvoiceList( req, res ) {
     let summary = {
       totalInvoices: allInvoices.length,
       totalInvoiced: allInvoices.reduce( ( sum, inv ) => sum + ( inv.totalAmount || 0 ), 0 ),
+      // Footer totals over the FULL filtered set (not just the current page):
+      // stores, amount excl. GST and amount incl. GST.
+      totalStores: allInvoices.reduce( ( sum, inv ) => sum + ( inv.stores || 0 ), 0 ),
+      totalAmountExclGst: allInvoices.reduce( ( sum, inv ) => sum + ( inv.amount || 0 ), 0 ),
+      totalAmountInclGst: allInvoices.reduce( ( sum, inv ) => sum + ( inv.totalAmount || 0 ), 0 ),
       pendingApproval: allInvoices.filter( ( inv ) => [ 'pendingCsm', 'pendingFinance', 'pendingApproval' ].includes( inv.status ) ).length,
       pendingPayment: allInvoices.filter( ( inv ) => inv.paymentStatus === 'unpaid' && inv.status === 'approved' ).length,
       paid: allInvoices.filter( ( inv ) => inv.paymentStatus === 'paid' ).length,
@@ -889,6 +896,32 @@ export async function latestDailyPricing( req, res ) {
       } },
     ] );
 
+    // Newly onboarded stores = stores whose FIRST FILE date falls in the current
+    // calendar month. Counted over the FULL store list (record.stores), not the
+    // status/search-filtered view, so the card reflects all new onboardings.
+    // First-file date is edgefirstFileDate, with processfirstFileDate as the
+    // fallback (same rule the annexure uses); some legacy rows store it as a
+    // string, so coerce defensively.
+    const monthStart = dayjs().startOf( 'month' );
+    const monthEnd = dayjs().endOf( 'month' );
+    const newlyOnboardedStoreList = ( record.stores || [] )
+        .map( ( s ) => {
+          const raw = s.edgefirstFileDate || s.processfirstFileDate;
+          const ff = raw ? dayjs( raw ) : null;
+          return { store: s, ff };
+        } )
+        .filter( ( x ) => x.ff && x.ff.isValid() &&
+          x.ff.isAfter( monthStart.subtract( 1, 'millisecond' ) ) &&
+          x.ff.isBefore( monthEnd.add( 1, 'millisecond' ) ) )
+        .map( ( x ) => ( {
+          storeId: x.store.storeId,
+          storeName: x.store.storeName,
+          status: x.store.status,
+          firstFileDate: x.ff.format( 'YYYY-MM-DD' ),
+        } ) )
+        .sort( ( a, b ) => a.firstFileDate.localeCompare( b.firstFileDate ) );
+    const newlyOnboardedStores = newlyOnboardedStoreList.length;
+
     let data = {
       clientId: record.clientId,
       brandName: record.brandName,
@@ -899,6 +932,8 @@ export async function latestDailyPricing( req, res ) {
       status: record.status,
       proRate: record.proRate,
       count,
+      newlyOnboardedStores,
+      newlyOnboardedStoreList,
       data: storeList,
       monthlyBillingSummary,
     };
@@ -1694,6 +1729,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' );
@@ -1753,6 +1793,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
@@ -1767,7 +1855,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
@@ -1984,11 +2072,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,
@@ -2048,3 +2146,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)
@@ -266,6 +286,58 @@ export async function createInvoice( req, res ) {
         products = expanded;
       }
 
+      // One-time onboarding fee: stores in THIS billing group whose first file
+      // date falls in the invoice's billing month, charged a flat
+      // oneTimeFeePerStore (from the client's basepricing). Added AFTER the
+      // multi-month expansion so it's billed ONCE per invoice (not per month).
+      // It's a normal line item, so it lands in the taxable subtotal below.
+      try {
+        const oneTimeBp = await basepricingService.findOne(
+            { clientId: group.clientId },
+            { oneTimeFeePerStore: 1 },
+        );
+        const oneTimeFeePerStore = Number( oneTimeBp?.oneTimeFeePerStore ) || 0;
+        if ( oneTimeFeePerStore > 0 && Array.isArray( group.stores ) && group.stores.length ) {
+          const monthStart = new Date( baseDate.startOf( 'month' ).toISOString() );
+          const monthEnd = new Date( baseDate.endOf( 'month' ).toISOString() );
+          // Distinct group stores whose first file date is within the billing
+          // month. First file = edgefirstFileDate, fallback processfirstFileDate.
+          const newStoreAgg = await dailyPricingService.aggregate( [
+            { $match: { clientId: group.clientId } },
+            { $sort: { dateISO: -1 } },
+            { $limit: 1 },
+            { $project: { stores: { $filter: {
+              input: '$stores', as: 'item', cond: { $in: [ '$$item.storeId', group.stores ] },
+            } } } },
+            { $unwind: '$stores' },
+            { $addFields: { ff: {
+              $convert: {
+                input: { $ifNull: [ '$stores.edgefirstFileDate', '$stores.processfirstFileDate' ] },
+                to: 'date', onError: null, onNull: null,
+              },
+            } } },
+            { $match: { ff: { $ne: null, $gte: monthStart, $lte: monthEnd } } },
+            { $group: { _id: '$stores.storeId' } },
+            { $count: 'newStores' },
+          ] );
+          const newStoreCount = newStoreAgg?.[0]?.newStores || 0;
+          if ( newStoreCount > 0 ) {
+            products.push( {
+              productName: 'oneTimeFee',
+              period: 'fullmonth',
+              storeCount: newStoreCount,
+              amount: Math.round( newStoreCount * oneTimeFeePerStore * 100 ) / 100,
+              price: oneTimeFeePerStore,
+              description: `One-Time Fee - ${newStoreCount} stores`,
+              HsnNumber: '998314',
+              month: baseDate.format( 'MMM YYYY' ),
+            } );
+          }
+        }
+      } catch ( oneTimeErr ) {
+        logger.error( { error: oneTimeErr, function: 'createInvoice.oneTimeFee', clientId: group.clientId } );
+      }
+
       let amount = products.reduce( ( sum, product ) => sum + product.amount, 0 );
       let taxList = [];
       let totalAmount = 0;
@@ -454,12 +526,56 @@ async function buildAnnexureRows( invoiceInfo, getgroup ) {
   // 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 } },
@@ -478,25 +594,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
@@ -513,9 +616,11 @@ async function buildAnnexureRows( invoiceInfo, getgroup ) {
         units = s.trafficCameraCount;
       }
     }
+    productPosition[s.productName] = ( productPosition[s.productName] || 0 ) + 1;
     // negotiatePrice is already in the invoice currency — use it verbatim,
-    // matching invoice generation.
-    const price = Number( s.standard?.negotiatePrice ) || 0;
+    // 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;
@@ -1428,134 +1533,40 @@ async function stepPrice( group, getClient ) {
       billingTypeMap[p.productName] = p.billingType || 'perStore';
     } );
   }
-  let products = await dailyPricingService.aggregate( [
-    {
-      $match: {
-        clientId: group.clientId,
-      },
-    },
-    {
-      $sort: { dateISO: -1 },
-    },
+  // PER-STORE rows (not bucketed) so step tiers can be assigned to individual
+  // stores and each store charged tierPrice x its EXACT camera/zone count.
+  let perStoreRows = await dailyPricingService.aggregate( [
+    { $match: { clientId: group.clientId } },
+    { $sort: { dateISO: -1 } },
     { $limit: 1 },
-    {
-      $project: {
-        stores: {
-          $filter: {
-            input: '$stores',
-            as: 'item',
-            cond: { $in: [ '$$item.storeId', group.stores ] },
-          },
-        },
-      },
-    },
-    {
-      $unwind: {
-        path: '$stores',
-        preserveNullAndEmptyArrays: false,
-      },
-    },
-    {
-      $unwind: {
-        path: '$stores.products',
-        preserveNullAndEmptyArrays: false,
-      },
-    },
-    {
-      $project: {
-        productName: '$stores.products.productName',
-        storeId: '$stores.storeId',
-        workingDays: '$stores.products.workingdays',
-        storeStatus: '$stores.status',
-        zoneCount: { $ifNull: [ '$stores.zoneCount', 0 ] },
-        cameraCount: { $ifNull: [ '$stores.cameraCount', 0 ] },
-        // Pull per-store camera splits; same fix as standardPrice — without
-        // these the second $group sums missing fields and the perCamera
-        // branch in the downstream map silently falls back to perStore.
-        trafficCameraCount: { $ifNull: [ '$stores.trafficCameraCount', 0 ] },
-        zoneCameraCount: { $ifNull: [ '$stores.zoneCameraCount', 0 ] },
-      },
-    },
-    {
-      $match: {
-        workingDays: { $gt: 0 },
-      },
-    },
-    {
-      $project: {
-        productName: 1,
-        storeId: 1,
-        // Group-level flag baked into every doc; consumed by the next
-        // $project's $cond.
-        isFlatPricing: { $literal: isFlatPricing },
-        workingDays: 1,
-        storeStatus: 1,
-        zoneCount: 1,
-        cameraCount: 1,
-        trafficCameraCount: 1,
-        zoneCameraCount: 1,
-      },
-    },
-    {
-      $project: {
-        productName: 1,
-        storeId: 1,
-        // Flat => full month per store. Prorate => actual working days.
-        workingDays: {
-          $cond: { if: '$isFlatPricing', then: currentMonthDays, else: '$workingDays' },
-        },
-        storeStatus: 1,
-        zoneCount: 1,
-        cameraCount: 1,
-        trafficCameraCount: 1,
-        zoneCameraCount: 1,
-      },
-    }, {
-      $group: {
-        _id: {
-          productName: '$productName',
-          storeId: '$storeId',
-        },
-        workingdays: { $first: '$workingDays' },
-        zoneCount: { $first: '$zoneCount' },
-        cameraCount: { $first: '$cameraCount' },
-        trafficCameraCount: { $first: '$trafficCameraCount' },
-        zoneCameraCount: { $first: '$zoneCameraCount' },
-      },
-    },
-    {
-      $group: {
-        _id: {
-          productName: '$_id.productName',
-          workingdays: '$workingdays',
-        },
-        storeCount: { $sum: 1 },
-        totalZoneCount: { $sum: '$zoneCount' },
-        totalTrafficCameraCount: { $sum: '$trafficCameraCount' },
-        totalZoneCameraCount: { $sum: '$zoneCameraCount' },
-      },
-    },
-    {
-      $project: {
-        _id: 0,
-        productName: '$_id.productName',
-        workingdays: '$_id.workingdays',
-        storeCount: '$storeCount',
-        totalZoneCount: '$totalZoneCount',
-        totalTrafficCameraCount: '$totalTrafficCameraCount',
-        totalZoneCameraCount: '$totalZoneCameraCount',
-      },
-    },
-    {
-      // productName first so order is deterministic across views/PDF, then
-      // workingdays so step rows stay grouped consistently.
-      $sort: {
-        productName: 1,
-        workingdays: -1,
-      },
-    },
-
-
+    { $project: { stores: { $filter: {
+      input: '$stores', as: 'item', cond: { $in: [ '$$item.storeId', group.stores ] },
+    } } } },
+    { $unwind: { path: '$stores', preserveNullAndEmptyArrays: false } },
+    { $unwind: { path: '$stores.products', preserveNullAndEmptyArrays: false } },
+    { $project: {
+      productName: '$stores.products.productName',
+      storeId: '$stores.storeId',
+      storeName: '$stores.storeName',
+      workingDays: '$stores.products.workingdays',
+      zoneCount: { $ifNull: [ '$stores.zoneCount', 0 ] },
+      trafficCameraCount: { $ifNull: [ '$stores.trafficCameraCount', 0 ] },
+      zoneCameraCount: { $ifNull: [ '$stores.zoneCameraCount', 0 ] },
+    } },
+    { $match: { workingDays: { $gt: 0 } } },
+    // Flat pricing => bill every store for the full month.
+    { $project: {
+      _id: 0,
+      productName: 1,
+      storeId: 1,
+      storeName: 1,
+      workingDays: { $cond: { if: { $literal: isFlatPricing }, then: currentMonthDays, else: '$workingDays' } },
+      zoneCount: 1,
+      trafficCameraCount: 1,
+      zoneCameraCount: 1,
+    } },
+    // Deterministic order so per-store tier assignment is stable run to run.
+    { $sort: { productName: 1, storeId: 1 } },
   ] );
   // Build billingMethod map from group.products
   let billingMethodMap = {};
@@ -1668,133 +1679,100 @@ async function stepPrice( group, getClient ) {
     }
   }
 
-  // Filter out eachStore products from aggregated results
-  products = products.filter( ( p ) => !eachStoreProductNames.includes( p.productName ) );
+  // Drop eachStore products — those are handled by the per-store branch above.
+  perStoreRows = perStoreRows.filter( ( p ) => !eachStoreProductNames.includes( p.productName ) );
 
-  // Adjust storeCount based on billingType for tangoZone and tangoTraffic (overallStore only)
-  products = products.map( ( product ) => {
-    let productBillingType = billingTypeMap[product.productName] || 'perStore';
-    if ( product.productName === 'tangoZone' ) {
-      if ( productBillingType === 'perZone' && product.totalZoneCount > 0 ) {
-        product.storeCount = product.totalZoneCount;
-      } else if ( productBillingType === 'perCamera' && product.totalZoneCameraCount > 0 ) {
-        product.storeCount = product.totalZoneCameraCount;
-      }
-    } else if ( product.productName === 'tangoTraffic' ) {
-      if ( productBillingType === 'perCamera' && product.totalTrafficCameraCount > 0 ) {
-        product.storeCount = product.totalTrafficCameraCount;
+  const stepPriceRecord = await basepricingService.findOne( { clientId: group.clientId } );
+  // Tiers ordered by range start so per-store tier assignment walks low-to-high.
+  const 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;
+  } );
+  // Tiers grouped per product (only one product set here, but keep it general).
+  const tiersByProduct = {};
+  for ( const t of pricing ) {
+    if ( !tiersByProduct[t.productName] ) {
+      tiersByProduct[t.productName] = [];
+    }
+    tiersByProduct[t.productName].push( t );
+  }
+  // Resolve the tier price for a store's 1-based position within its product.
+  const tierPriceForPosition = ( productName, position ) => {
+    const tiers = tiersByProduct[productName] || [];
+    if ( !tiers.length ) {
+      return 0;
+    }
+    for ( const t of tiers ) {
+      const [ min, max ] = String( t.storeRange || '' ).split( '-' ).map( Number );
+      if ( position >= min && position <= max ) {
+        return Number( t.negotiatePrice ) || 0;
       }
     }
-    delete product.totalZoneCount;
-    delete product.totalTrafficCameraCount;
-    delete product.totalZoneCameraCount;
-    return product;
-  } );
-
-  let stepPriceRecord = await basepricingService.findOne( { clientId: group.clientId } );
-  let data = products;
-  let pricing = stepPriceRecord.step;
-
-  const applyPricing = ( data, pricing ) => {
-    let totalcount = 0;
-    return data.map( ( item ) => {
-      totalcount = totalcount + item.storeCount;
+    // Beyond the last defined tier -> last tier's price.
+    return Number( tiers[tiers.length - 1].negotiatePrice ) || 0;
+  };
 
-      console.log( '======>', item );
-      if ( item.workingdays === currentMonthDays ) {
-        item.period = 'fullMonth';
-        item.runningCost = item.storeCount * item.price;
-      } else {
-        item.period = 'proRate';
-        item.runningCost = ( item.storeCount * ( item.price / currentMonthDays ) * item.workingdays ).toFixed( 2 );
+  // EXACT per-store pricing: assign each store a 1-based position within its
+  // product (tier boundary counted in STORES), then charge tierPrice x that
+  // store's EXACT billable units — cameras (perCamera) / zones (perZone) / 1
+  // (perStore) — prorated by working days. Group lines by product + period +
+  // tier price so each tier collapses into a single line item.
+  const productPosition = {};
+  const grouped = {};
+  for ( const s of perStoreRows ) {
+    const billingType = billingTypeMap[s.productName] || 'perStore';
+    let units = 1;
+    if ( s.productName === 'tangoZone' ) {
+      if ( billingType === 'perZone' && s.zoneCount > 0 ) {
+        units = s.zoneCount;
+      } else if ( billingType === 'perCamera' && s.zoneCameraCount > 0 ) {
+        units = s.zoneCameraCount;
       }
-
-      return {
-        ...item,
-        negotiatePrice: item.price,
-        perstorecost: ( ( item.price / currentMonthDays ) * item.workingdays ).toFixed( 2 ),
-      };
-    } );
-  };
-  console.log( '---->', data, pricing );
-
-
-  function processArray( array1, array2 ) {
-    let updatedArray = [];
-
-    for ( let item of array1 ) {
-      let remainingStores = item.storeCount;
-
-      for ( let range of array2 ) {
-        let [ min, max ] = range.storeRange.split( '-' ).map( Number );
-
-        if ( remainingStores > 0 ) {
-          let applicableStores = Math.min( remainingStores, max - min + 1 );
-          updatedArray.push( {
-            productName: item.productName,
-            workingdays: item.workingdays,
-            storeCount: applicableStores,
-            // Each tier is charged at its own range's negotiated price. (Was a
-            // hardcoded 1100 for every tier after the first — a placeholder
-            // that ignored the actual step price of the next range.)
-            price: range.negotiatePrice,
-          } );
-          remainingStores -= applicableStores;
-        }
+    } else if ( s.productName === 'tangoTraffic' ) {
+      if ( billingType === 'perCamera' && s.trafficCameraCount > 0 ) {
+        units = s.trafficCameraCount;
       }
     }
-    return updatedArray;
+    productPosition[s.productName] = ( productPosition[s.productName] || 0 ) + 1;
+    const price = tierPriceForPosition( s.productName, productPosition[s.productName] );
+    const fullMonth = s.workingDays >= currentMonthDays;
+    const amount = fullMonth ?
+      Math.round( units * price * 100 ) / 100 :
+      Math.round( ( units * ( price / currentMonthDays ) * s.workingDays ) * 100 ) / 100;
+    const period = fullMonth ? 'fullMonth' : 'proRate';
+    const key = `${s.productName}_${period}_${price}`;
+    if ( !grouped[key] ) {
+      grouped[key] = { productName: s.productName, period, price, totalAmount: 0, unitCount: 0 };
+    }
+    grouped[key].totalAmount += amount;
+    grouped[key].unitCount += units;
   }
 
-  let resultarray = processArray( data, pricing );
-  console.log( '++++++++++++', resultarray );
-  const result = applyPricing( resultarray, pricing );
-  console.log( '***********', result );
-  const groupedData = result.reduce( ( acc, item ) => {
-    const { productName, period, runningCost } = item;
-    const key = `${productName}_${period}_${item.storeCount}`;
-    if ( !acc[key] ) {
-      acc[key] = {
-        productName,
-        period,
-        totalRunningCost: 0,
-        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;
-    }
-
-    return acc;
-  }, {} );
-  console.log( groupedData );
-  // Calculating average running cost
-  const finalresult = Object.values( groupedData ).map( ( grp ) => {
+  const finalresult = Object.values( grouped ).map( ( grp ) => {
     let description = '';
     if ( grp.productName === 'tangoTraffic' ) {
       description = 'Customer Footfall Analytics';
     } else if ( grp.productName === 'tangoZone' ) {
       description = 'Product category/section analytics';
-    } else {
-      description = '';
     }
+    const amount = Math.round( grp.totalAmount * 100 ) / 100;
     return {
       productName: grp.productName,
       period: grp.period,
-      storeCount: grp.count,
+      // Quantity = billable units (cameras for perCamera, zones for perZone,
+      // stores otherwise). For full-month lines price = tier price; for prorated
+      // lines it's the effective per-unit cost (amount / units).
+      storeCount: Math.round( grp.unitCount * 100 ) / 100,
       description: description,
       HsnNumber: '998314',
-      amount: grp.totalRunningCost,
+      amount: amount,
       month: dayjs().format( 'MMM YYYY' ),
-      price: ( grp.totalRunningCost / grp.count ).toFixed( 2 ),
+      price: grp.unitCount ? ( amount / grp.unitCount ).toFixed( 2 ) : '0.00',
     };
   } );
 
-  // Combine overallStore and eachStore products
+  // Combine overallStore (per-store tiered) and eachStore products.
   return [ ...finalresult, ...eachStoreProducts ];
 }
 

package/src/controllers/paymentSubscription.controllers.js

@@ -1,6 +1,6 @@
 
 /* eslint-disable new-cap */
-import { logger, download, sendEmailWithSES, insertOpenSearchData, getOpenSearchData, updateOpenSearchData, getOpenSearchById } from 'tango-app-api-middleware';
+import { logger, download, sendEmailWithSES, insertOpenSearchData, getOpenSearchData, updateOpenSearchData, getOpenSearchById, fileUpload, customSignedUrl } from 'tango-app-api-middleware';
 import * as paymentService from '../services/clientPayment.services.js';
 import * as basePriceService from '../services/basePrice.service.js';
 import * as storeService from '../services/store.service.js';
@@ -2246,7 +2246,7 @@ export const invoiceList = async ( req, res ) => {
 
 export const priceList = async ( req, res ) => {
   try {
-    let pricingDetails = await basePricingService.findOne( { clientId: { $exists: true }, clientId: req.body.clientId }, { standard: 1, step: 1 } );
+    let pricingDetails = await basePricingService.findOne( { clientId: { $exists: true }, clientId: req.body.clientId }, { standard: 1, step: 1, oneTimeFeePerStore: 1 } );
     if ( !pricingDetails ) {
       return res.sendError( 'no data found', 204 );
     }
@@ -2301,19 +2301,25 @@ export const priceList = async ( req, res ) => {
               product.showImg = true;
               product.showEditDelete = true;
             }
-            product.storeCount = item.storeCount;
+            // Last tier absorbs whatever stores remain after the earlier tiers.
+            // Never let it go negative when the actual store count is smaller
+            // than the defined tier ranges (e.g. 83 stores across 1-50 / 51-100
+            // left the last tier at 83 - 100 = -17).
+            product.storeCount = Math.max( item.storeCount, 0 );
             product.lastIndex = true;
-          } else if ( index == 0 ) {
-            product.storeCount = 100;
-            item.storeCount = item.storeCount - 100;
           } else {
-            product.showImg = true;
-            let rangeArray = product.storeRange.split( '-' );
+            // Non-last tier: use its own range size (end - start + 1), but cap at
+            // the stores still remaining so a tier can't claim more stores than
+            // exist. The first tier previously hardcoded 100, which overcounted
+            // (and pushed the last tier negative) whenever the range wasn't 1-100.
+            product.showImg = index != 0;
+            let rangeArray = String( product.storeRange || '' ).split( '-' );
             let startNumber = parseInt( rangeArray[0] );
             let endNumber = parseInt( rangeArray[1] );
-            let diff = endNumber - startNumber + 1;
-            product.storeCount = diff;
-            item.storeCount = item.storeCount - diff;
+            let diff = ( endNumber - startNumber + 1 ) || 0;
+            let assigned = Math.max( Math.min( diff, item.storeCount ), 0 );
+            product.storeCount = assigned;
+            item.storeCount = item.storeCount - assigned;
           }
         }
         // let discountPrice = product.basePrice * ( product.discountPercentage / 100 );
@@ -2335,6 +2341,7 @@ export const priceList = async ( req, res ) => {
     let finalValue = parseFloat( discountTotalPrice ) + gstAmount;
     let result = {
       product: data,
+      oneTimeFeePerStore: pricingDetails.oneTimeFeePerStore != null ? pricingDetails.oneTimeFeePerStore : null,
       totalActualPrice: originalTotalPrice,
       totalNegotiatePrice: discountTotalPrice.toFixed( 2 ),
       actualPrice: totalProductPrice,
@@ -2484,6 +2491,11 @@ export const pricingListUpdate = async ( req, res ) => {
     } else {
       getPriceInfo.step = req.body.products;
     }
+    // Brand-level one-time fee per store. Only overwrite when the request
+    // actually carries a value so other save paths don't wipe it.
+    if ( req.body.oneTimeFeePerStore != null && req.body.oneTimeFeePerStore !== '' ) {
+      getPriceInfo.oneTimeFeePerStore = Number( req.body.oneTimeFeePerStore ) || 0;
+    }
     getPriceInfo.save().then( async () => {
       let clientDetails = await paymentService.findOne( { clientId: req.body.clientId }, { priceType: 1, paymentInvoice: 1, planDetails: 1 } );
       clientDetails.priceType = req.body.type;
@@ -4130,3 +4142,96 @@ export async function createDefaultbillings( req, res ) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Brand documents (Plans & Subscription > Documents accordion).
+// Upload a single PDF for a client, store it in the assets bucket under
+// <clientId>/documents/, and record { documentName, path } on the client's
+// additionalDocuments array. List returns the docs with signed URLs.
+// ---------------------------------------------------------------------------
+export async function uploadClientDocument( req, res ) {
+  try {
+    const clientId = String( req.body?.clientId || '' );
+    const documentName = String( req.body?.documentName || '' ).trim();
+    const expiryDateRaw = req.body?.expiryDate;
+    const file = req.file; // multer single('file')
+
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+    if ( !documentName ) {
+      return res.sendError( 'documentName is required', 400 );
+    }
+    if ( !file ) {
+      return res.sendError( 'file is required', 400 );
+    }
+    // PDF only.
+    if ( file.mimetype !== 'application/pdf' ) {
+      return res.sendError( 'Only PDF files are allowed', 400 );
+    }
+
+    const client = await paymentService.findOneClient( { clientId }, { clientId: 1 } );
+    if ( !client ) {
+      return res.sendError( 'Client not found', 404 );
+    }
+
+    const bucket = JSON.parse( process.env.BUCKET );
+    // Unique-ish file name so re-uploads with the same display name don't clash.
+    const safeName = documentName.replace( /[^a-zA-Z0-9-_]/g, '_' );
+    const fileName = `${safeName}_${Date.now()}.pdf`;
+    const key = `${clientId}/documents/`;
+
+    await fileUpload( {
+      Bucket: bucket.assets,
+      Key: key,
+      fileName: fileName,
+      ContentType: file.mimetype,
+      body: file.buffer,
+    } );
+
+    const storedPath = `${key}${fileName}`;
+    const expiryDate = expiryDateRaw ? new Date( expiryDateRaw ) : null;
+    await paymentService.pushAdditionalDocument( { clientId }, {
+      documentName: documentName,
+      path: storedPath,
+      expiryDate: ( expiryDate && !isNaN( expiryDate.getTime() ) ) ? expiryDate : null,
+      uploadedAt: new Date(),
+    } );
+
+    return res.sendSuccess( { documentName, path: storedPath, expiryDate } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'uploadClientDocument' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function getClientDocuments( req, res ) {
+  try {
+    const clientId = String( req.query?.clientId || req.params?.clientId || '' );
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+    const client = await paymentService.findOneClient( { clientId }, { additionalDocuments: 1 } );
+    const bucket = JSON.parse( process.env.BUCKET );
+    const docs = await Promise.all( ( client?.additionalDocuments || [] ).map( async ( d ) => {
+      let url = '';
+      try {
+        url = await customSignedUrl( { Bucket: bucket.assets, file_path: d.path }, 8 );
+      } catch ( e ) {
+        url = '';
+      }
+      return {
+        _id: d._id,
+        documentName: d.documentName,
+        path: d.path,
+        expiryDate: d.expiryDate,
+        uploadedAt: d.uploadedAt,
+        url,
+      };
+    } ) );
+    return res.sendSuccess( { documents: docs } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getClientDocuments' } );
+    return res.sendError( error, 500 );
+  }
+}
+

package/src/dtos/validation.dtos.js

@@ -153,6 +153,7 @@ export const validatePriceSchema = joi.object( {
   type: joi.string().optional(),
   clientId: joi.string().required(),
   products: joi.array().optional(),
+  oneTimeFeePerStore: joi.number().optional().allow( null, '' ),
   pricing: joi.array().items( joi.object( {
     productName: joi.string().required(),
     negotiatePrice: joi.number().required(),

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/routes/paymentSubscription.routes.js

@@ -1,11 +1,16 @@
 
 import express from 'express';
+import multer from 'multer';
 import * as paymentController from '../controllers/paymentSubscription.controllers.js';
 import { validate, isAllowedSessionHandler, accessVerification } from 'tango-app-api-middleware';
 import * as validationDtos from '../dtos/validation.dtos.js';
 import { validateClient } from '../utils/validations/client.validation.js';
 export const paymentSubscriptionRouter = express.Router();
 
+// PDF document upload (Plans & Subscription > Documents). In-memory storage,
+// 10MB cap; the controller streams the buffer to the assets S3 bucket.
+const documentUpload = multer( { storage: multer.memoryStorage(), limits: { fileSize: 10 * 1024 * 1024 } } );
+
 paymentSubscriptionRouter.post( '/addBilling', isAllowedSessionHandler, accessVerification( {
   userType: [ 'tango', 'client' ], access: [
     { featureName: 'Global', name: 'Subscription', permissions: [ 'isAdd' ] },
@@ -146,4 +151,8 @@ paymentSubscriptionRouter.put( '/pushNotification/update/:notificationId', isAll
 paymentSubscriptionRouter.post( '/updateRemind/:notificationId', isAllowedSessionHandler, validate( validationDtos.validateId ), paymentController.updateRemind );
 paymentSubscriptionRouter.post( '/createDefaultbillings', paymentController.createDefaultbillings );
 
+// Brand documents (Plans & Subscription > Documents accordion).
+paymentSubscriptionRouter.post( '/client-document/upload', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ], access: [ { featureName: 'Global', name: 'Subscription', permissions: [ 'isEdit' ] } ] } ), documentUpload.single( 'file' ), paymentController.uploadClientDocument );
+paymentSubscriptionRouter.get( '/client-document/list', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ], access: [ { featureName: 'Global', name: 'Subscription', permissions: [] } ] } ), paymentController.getClientDocuments );
+
 

package/src/services/clientPayment.services.js

@@ -16,6 +16,11 @@ export const updateOne = ( query = {}, record = {} ) => {
   return model.clientModel.updateOne( query, { $set: record } );
 };
 
+// Push a document into the client's additionalDocuments array.
+export const pushAdditionalDocument = ( query = {}, document = {} ) => {
+  return model.clientModel.updateOne( query, { $push: { additionalDocuments: document } } );
+};
+
 export const aggregate = ( query = [] ) => {
   return model.clientModel.aggregate( query );
 };

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 );
+};