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

package/src/controllers/invoice.controller.js

@@ -286,6 +286,61 @@ 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 {
+        // Use the group's basepricing doc when group-wise pricing applies,
+        // else the brand-level doc.
+        const { query: oneTimeQuery } = await resolveBasePricingScope( group, getClient );
+        const oneTimeBp = await basepricingService.findOne(
+            oneTimeQuery,
+            { 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;
@@ -474,7 +529,7 @@ 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, 'priceType': 1 } );
+  const annexClient = await clientService.findOne( { clientId: invoiceInfo.clientId }, { 'planDetails.product': 1, 'priceType': 1, 'billingGroupWisePricing': 1 } );
   const billingTypeMap = {};
   ( annexClient?.planDetails?.product || [] ).forEach( ( p ) => {
     billingTypeMap[p.productName] = p.billingType || 'perStore';
@@ -486,7 +541,18 @@ async function buildAnnexureRows( invoiceInfo, getgroup ) {
   // 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 } );
+  // Group-wise pricing: read the billing group's own doc when enabled and one
+  // exists; otherwise the brand-level doc.
+  let pricingDocQuery = { clientId: invoiceInfo.clientId, groupId: { $exists: false } };
+  if ( annexClient?.billingGroupWisePricing && getgroup?._id ) {
+    const grpDoc = await basepricingService.findOne(
+        { clientId: invoiceInfo.clientId, groupId: String( getgroup._id ) }, { _id: 1 },
+    );
+    if ( grpDoc ) {
+      pricingDocQuery = { clientId: invoiceInfo.clientId, groupId: String( getgroup._id ) };
+    }
+  }
+  const pricingDoc = await basepricingService.findOne( pricingDocQuery, { standard: 1, step: 1 } );
   const isStep = annexClient?.priceType === 'step';
   const tiersByProduct = {};
   ( ( isStep ? pricingDoc?.step : pricingDoc?.standard ) || [] ).forEach( ( p ) => {
@@ -1028,6 +1094,25 @@ function inWords( num ) {
 }
 
 
+// Resolve which basepricing doc applies to a billing group. When the client
+// has billingGroupWisePricing enabled AND a doc exists for this group, returns
+// that group's doc; otherwise falls back to the brand-level doc (groupId unset).
+// Returns { query, groupId } where query is the mongo filter for the chosen doc
+// and groupId is the group id to use in aggregation lookups (or null for brand).
+async function resolveBasePricingScope( group, getClient ) {
+  const brandQuery = { clientId: group.clientId, groupId: { $exists: false } };
+  if ( getClient?.billingGroupWisePricing && group?._id ) {
+    const groupIdStr = String( group._id );
+    const groupDoc = await basepricingService.findOne(
+        { clientId: group.clientId, groupId: groupIdStr }, { _id: 1 },
+    );
+    if ( groupDoc ) {
+      return { query: { clientId: group.clientId, groupId: groupIdStr }, groupId: groupIdStr };
+    }
+  }
+  return { query: brandQuery, groupId: null };
+}
+
 async function standardPrice( group, getClient, baseDate ) {
   console.log( '🚀 ~ standardPrice ~ baseDate:', baseDate.format( 'MMM YYYY' ) );
   const currentMonthDays = dayjs().daysInMonth();
@@ -1036,6 +1121,9 @@ async function standardPrice( group, getClient, baseDate ) {
   // Computed once so the aggregation pipelines can inline a $literal.
   const isFlatPricing = group.proRata === 'flat';
   console.log( '🚀 ~ standardPrice ~ isFlatPricing:', isFlatPricing );
+  // Which basepricing doc applies (group-wise vs brand-level). pricingGroupId is
+  // used in the $lookup pipeline so the join picks the right doc.
+  const { groupId: pricingGroupId } = await resolveBasePricingScope( group, getClient );
   let billingTypeMap = {};
   if ( getClient?.planDetails?.product ) {
     getClient.planDetails.product.forEach( ( p ) => {
@@ -1172,7 +1260,14 @@ async function standardPrice( group, getClient, baseDate ) {
           {
             $match: {
               $expr: {
-                $eq: [ '$clientId', '$$clientId' ],
+                $and: [
+                  { $eq: [ '$clientId', '$$clientId' ] },
+                  // Match the resolved doc: a specific group's doc when group-wise
+                  // pricing applies, else the brand-level doc (no groupId).
+                  pricingGroupId ?
+                    { $eq: [ '$groupId', pricingGroupId ] } :
+                    { $not: [ { $ifNull: [ '$groupId', false ] } ] },
+                ],
               },
             },
           },
@@ -1367,7 +1462,12 @@ async function standardPrice( group, getClient, baseDate ) {
           from: 'basepricings',
           let: { clientId: group.clientId },
           pipeline: [
-            { $match: { $expr: { $eq: [ '$clientId', '$$clientId' ] } } },
+            { $match: { $expr: { $and: [
+              { $eq: [ '$clientId', '$$clientId' ] },
+              pricingGroupId ?
+                { $eq: [ '$groupId', pricingGroupId ] } :
+                { $not: [ { $ifNull: [ '$groupId', false ] } ] },
+            ] } } },
             { $project: { standard: 1 } },
           ],
           as: 'basepricing',
@@ -1475,140 +1575,48 @@ async function stepPrice( group, getClient ) {
   // 'flat' => every store billed for full month.
   // 'prorate' => actual working days. See standardPrice for the same flag.
   const isFlatPricing = group.proRata === 'flat';
+  // Which basepricing doc applies (group-wise vs brand-level).
+  const { query: pricingDocQuery, groupId: pricingGroupId } = await resolveBasePricingScope( group, getClient );
   let billingTypeMap = {};
   if ( getClient?.planDetails?.product ) {
     getClient.planDetails.product.forEach( ( p ) => {
       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 = {};
@@ -1670,7 +1678,12 @@ async function stepPrice( group, getClient ) {
           from: 'basepricings',
           let: { clientId: group.clientId },
           pipeline: [
-            { $match: { $expr: { $eq: [ '$clientId', '$$clientId' ] } } },
+            { $match: { $expr: { $and: [
+              { $eq: [ '$clientId', '$$clientId' ] },
+              pricingGroupId ?
+                { $eq: [ '$groupId', pricingGroupId ] } :
+                { $not: [ { $ifNull: [ '$groupId', false ] } ] },
+            ] } } },
             { $project: { step: 1 } },
           ],
           as: 'basepricing',
@@ -1679,7 +1692,7 @@ async function stepPrice( group, getClient ) {
       { $unwind: { path: '$basepricing', preserveNullAndEmptyArrays: true } },
     ] );
 
-    let stepPriceData = await basepricingService.findOne( { clientId: group.clientId } );
+    let stepPriceData = await basepricingService.findOne( pricingDocQuery );
     let pricingRanges = stepPriceData?.step || [];
     let defaultPrice = pricingRanges.length > 0 ? pricingRanges[0].negotiatePrice : 0;
 
@@ -1721,168 +1734,100 @@ async function stepPrice( group, getClient ) {
     }
   }
 
-  // Filter out eachStore products from aggregated results
-  products = products.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;
-      }
-    }
-    delete product.totalZoneCount;
-    delete product.totalTrafficCameraCount;
-    delete product.totalZoneCameraCount;
-    return product;
-  } );
+  // Drop eachStore products — those are handled by the per-store branch above.
+  perStoreRows = perStoreRows.filter( ( p ) => !eachStoreProductNames.includes( p.productName ) );
 
-  let stepPriceRecord = await basepricingService.findOne( { clientId: group.clientId } );
-  let data = products;
-  // 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 stepPriceRecord = await basepricingService.findOne( pricingDocQuery );
+  // 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;
   } );
-
-  const applyPricing = ( data, pricing ) => {
-    let totalcount = 0;
-    return data.map( ( item ) => {
-      totalcount = totalcount + item.storeCount;
-
-      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 );
+  // 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;
       }
-
-      return {
-        ...item,
-        negotiatePrice: item.price,
-        perstorecost: ( ( item.price / currentMonthDays ) * item.workingdays ).toFixed( 2 ),
-      };
-    } );
+    }
+    // Beyond the last defined tier -> last tier's price.
+    return Number( tiers[tiers.length - 1].negotiatePrice ) || 0;
   };
-  console.log( '---->', data, pricing );
-
-
-  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 ) {
-        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;
+  // 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;
       }
-
-      // 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;
+    } else if ( s.productName === 'tangoTraffic' ) {
+      if ( billingType === 'perCamera' && s.trafficCameraCount > 0 ) {
+        units = s.trafficCameraCount;
       }
-
-      assignedByProduct[item.productName] = assigned;
     }
-    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 );
-  // 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.price}`;
-    if ( !acc[key] ) {
-      acc[key] = {
-        productName,
-        period,
-        totalRunningCost: 0,
-        count: 0,
-      };
-    }
-    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 ];
 }