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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.5.14",
+    "version": "3.5.15",
     "description": "paymentSubscription",
     "main": "index.js",
     "type": "module",

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';
@@ -1694,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' );
@@ -1753,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
@@ -1767,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
@@ -1984,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,
@@ -2048,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)
@@ -454,12 +474,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 +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
@@ -513,9 +564,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;
@@ -1693,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;
@@ -1722,26 +1781,54 @@ async function stepPrice( group, getClient ) {
   function processArray( array1, array2 ) {
     let updatedArray = [];
 
+    // 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 ) {
-          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;
+        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;
   }
@@ -1750,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,
@@ -1761,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 );
+};