tango-app-api-payment-subscription 3.5.4 → 3.5.6

package/src/controllers/invoice.controller.js

@@ -208,7 +208,14 @@ export async function createInvoice( req, res ) {
       let amount = products.reduce( ( sum, product ) => sum + product.amount, 0 );
       let taxList = [];
       let totalAmount = 0;
-      if ( group.gst && group.gst.slice( 0, 2 ) == '33' ) {
+      // International billing groups: skip tax calculation entirely. The
+      // tax array stays empty so the PDF won't render a tax line and
+      // totalAmount equals subtotal. Default 'domestic' preserves the
+      // existing GST/IGST/CGST/SGST behavior for legacy records that have
+      // no taxCalculationType set yet.
+      if ( group.taxCalculationType === 'international' ) {
+        totalAmount = Math.round( amount );
+      } else if ( group.gst && group.gst.slice( 0, 2 ) == '33' ) {
         let taxAmount = ( amount * 18 ) / 100;
         totalAmount = Math.round( amount + taxAmount );
         taxList.push(
@@ -353,6 +360,103 @@ function getCurrentFinancialYear() {
 }
 
 
+// ---------------------------------------------------------------------------
+// Shared annexure builder. Anchored to the invoice's BILLING month and
+// mirroring invoice generation's billing-type rules: perZone / perCamera
+// products multiply by the store's zone / camera count (see standardPrice).
+// Returns the per-store rows plus the grand total shown at the end.
+// ---------------------------------------------------------------------------
+async function buildAnnexureRows( invoiceInfo, getgroup ) {
+  const billingMonth = invoiceInfo.billingDate ? dayjs( invoiceInfo.billingDate ) : dayjs();
+  const billingMonthEnd = new Date( billingMonth.endOf( 'month' ).toISOString() );
+  const monthDays = billingMonth.daysInMonth();
+  const invoiceCurrency = symbolFor( invoiceInfo.currency );
+
+  const annexClient = await clientService.findOne( { clientId: invoiceInfo.clientId }, { 'planDetails.product': 1 } );
+  const billingTypeMap = {};
+  ( annexClient?.planDetails?.product || [] ).forEach( ( p ) => {
+    billingTypeMap[p.productName] = p.billingType || 'perStore';
+  } );
+
+  const rows = await dailyPricingService.aggregate( [
+    { $match: { clientId: invoiceInfo.clientId, dateISO: { $lte: billingMonthEnd } } },
+    { $sort: { dateISO: -1 } },
+    { $limit: 1 },
+    { $project: { stores: { $filter: { input: '$stores', as: 'item', cond: { $in: [ '$$item.storeId', getgroup?.stores ?? [] ] } } } } },
+    { $unwind: { path: '$stores', preserveNullAndEmptyArrays: false } },
+    { $unwind: { path: '$stores.products', preserveNullAndEmptyArrays: false } },
+    { $project: {
+      productName: '$stores.products.productName',
+      storeId: '$stores.storeId',
+      storeName: '$stores.storeName',
+      edgefirstFileDate: { $ifNull: [ '$stores.edgefirstFileDate', '$stores.processfirstFileDate' ] },
+      workingdays: '$stores.products.workingdays',
+      zoneCount: { $ifNull: [ '$stores.zoneCount', 0 ] },
+      trafficCameraCount: { $ifNull: [ '$stores.trafficCameraCount', 0 ] },
+      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 } },
+  ] );
+
+  const data = rows.map( ( s ) => {
+    const billingType = billingTypeMap[s.productName] || 'perStore';
+    // Same units rule as invoice generation: perZone / perCamera multiply by
+    // the store's zone / camera count; anything else stays per-store.
+    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;
+      }
+    } else if ( s.productName === 'tangoTraffic' ) {
+      if ( billingType === 'perCamera' && s.trafficCameraCount > 0 ) {
+        units = s.trafficCameraCount;
+      }
+    }
+    const price = Number( s.standard?.negotiatePrice ) || 0;
+    const runningCost = s.workingdays >= monthDays ?
+      Math.round( price * units * 100 ) / 100 :
+      Math.round( ( price / monthDays ) * s.workingdays * units * 100 ) / 100;
+    return {
+      productName: s.productName ? s.productName.charAt( 0 ).toUpperCase() + s.productName.slice( 1 ) : '',
+      currencyType: invoiceCurrency,
+      workingdays: s.workingdays,
+      storeName: s.storeName,
+      storeId: s.storeId,
+      edgefirstFileDate: s.edgefirstFileDate ? dayjs( s.edgefirstFileDate ).format( 'YYYY-MM-DD' ) : '',
+      period: s.workingdays < monthDays ? 'prorate' : 'fullmonth',
+      billingType,
+      // Human label for the unit-price column: what one unit means.
+      unitBasis: billingType === 'perCamera' ? 'Per Camera' : billingType === 'perZone' ? 'Per Zone' : 'Per Store',
+      units,
+      standardPrice: price,
+      runningCost,
+    };
+  } );
+
+  const totalAmount = Math.round( data.reduce( ( a, x ) => a + ( x.runningCost || 0 ), 0 ) * 100 ) / 100;
+  const totalFormatted = totalAmount.toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } );
+  return { data, totalAmount, totalFormatted };
+}
+
 export async function invoiceDownload( req, res ) {
   try {
     let invoiceData;
@@ -369,7 +473,7 @@ export async function invoiceDownload( req, res ) {
         let [ firstWord, secondWord ] = item.productName.replace( /([a-z])([A-Z])/g, '$1 $2' ).split( ' ' );
         firstWord = firstWord.charAt( 0 ).toUpperCase() + firstWord.slice( 1 );
         item.productName = firstWord + ' ' + secondWord;
-        item.price = Math.round( item.price ).toLocaleString( 'en-IN' );
+        item.price = item.price .toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } );
         item.amount = item.amount.toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } );
         item.currency = invoiceCurrency;
       } );
@@ -431,145 +535,10 @@ export async function invoiceDownload( req, res ) {
           }
         } );
       }
-      const currentMonthDays = dayjs().daysInMonth();
-
       if ( getgroup?.attachAnnexure ) {
-        let annuxureData = await dailyPricingService.aggregate( [
-          {
-            $match: {
-              clientId: invoiceInfo.clientId,
-            },
-          },
-          {
-            $sort: { dateISO: -1 },
-          },
-          { $limit: 1 },
-          {
-            $project: {
-              stores: {
-                $filter: {
-                  input: '$stores',
-                  as: 'item',
-                  cond: { $in: [ '$$item.storeId', getgroup?.stores ] },
-                },
-              },
-            },
-          },
-          {
-            $unwind: {
-              path: '$stores',
-              preserveNullAndEmptyArrays: false,
-            },
-          },
-          {
-            $unwind: {
-              path: '$stores.products',
-              preserveNullAndEmptyArrays: false,
-            },
-          },
-          {
-            $project: {
-              productName: '$stores.products.productName',
-              storeId: '$stores.storeId',
-              storeName: '$stores.storeName',
-              edgefirstFileDate: '$stores.edgefirstFileDate',
-              workingdays: '$stores.products.workingdays',
-              currencyType: { $literal: invoiceCurrency },
-            },
-          },
-          {
-            $sort: {
-              productName: 1,
-              workingdays: -1,
-            },
-          },
-          {
-            $match: { workingdays: { $gt: 0 } },
-          },
-
-          {
-            $lookup: {
-              from: 'basepricings',
-              let: { clientId: invoiceInfo.clientId },
-              pipeline: [
-                {
-                  $match: {
-                    $expr: {
-                      $eq: [ '$clientId', '$$clientId' ],
-                    },
-                  },
-                },
-                {
-                  $project: {
-                    standard: 1,
-                    step: 1,
-                  },
-                },
-              ],
-              as: 'basepricing',
-            },
-          },
-          {
-            $unwind: { path: '$basepricing', preserveNullAndEmptyArrays: true },
-          },
-          {
-            $project: {
-              productName: 1,
-              workingdays: 1,
-              storeName: 1,
-              currencyType: 1,
-              edgefirstFileDate: { $ifNull: [ '$edgefirstFileDate', '$processfirstFileDate' ] },
-              storeId: 1,
-              standard: {
-                $filter: {
-                  input: '$basepricing.standard',
-                  as: 'standard',
-                  cond: { $eq: [ '$$standard.productName', '$productName' ] },
-                },
-              },
-              step: '$basepricing.step',
-            },
-          },
-          {
-            $unwind: { path: '$standard', preserveNullAndEmptyArrays: true },
-          },
-          {
-            $project: {
-              productName: {
-                $concat: [
-                  { $toUpper: { $substr: [ '$productName', 0, 1 ] } }, // Uppercase first letter
-                  { $substr: [ '$productName', 1, { $strLenCP: '$productName' } ] }, // Rest of the string
-                ],
-              },
-              currencyType: 1,
-              workingdays: 1,
-              storeName: 1,
-              edgefirstFileDate: { $dateToString: { format: '%Y-%m-%d', date: '$edgefirstFileDate' } },
-              storeId: 1,
-              period: {
-                $cond: {
-                  if: { $lt: [ '$workingdays', currentMonthDays ] },
-                  then: 'prorate',
-                  else: 'fullmonth',
-                },
-              },
-              standardPrice: '$standard.negotiatePrice',
-              runningCost: {
-                $round: [
-                  {
-                    $multiply: [
-                      { $divide: [ '$standard.negotiatePrice', currentMonthDays ] },
-                      '$workingdays',
-                    ],
-                  },
-                  2,
-                ],
-              },
-            },
-          },
-        ],
-        );
+        const { data: annuxureData, totalFormatted } = await buildAnnexureRows( invoiceInfo, getgroup );
         invoiceData.annuxureData = annuxureData;
+        invoiceData.annuxureTotal = totalFormatted;
       }
 
       const templateHtml = fs.readFileSync( path.resolve( path.dirname( '' ) ) + '/src/hbs/invoicePdf.hbs', 'utf8' );
@@ -748,65 +717,10 @@ async function buildInvoicePdfBuffer( invoiceId ) {
     } );
   }
 
-  const currentMonthDays = dayjs().daysInMonth();
-
   if ( getgroup?.attachAnnexure ) {
-    let annuxureData = await dailyPricingService.aggregate( [
-      { $match: { clientId: invoiceInfo.clientId } },
-      { $sort: { dateISO: -1 } },
-      { $limit: 1 },
-      { $project: { stores: { $filter: { input: '$stores', as: 'item', cond: { $in: [ '$$item.storeId', getgroup?.stores ] } } } } },
-      { $unwind: { path: '$stores', preserveNullAndEmptyArrays: false } },
-      { $unwind: { path: '$stores.products', preserveNullAndEmptyArrays: false } },
-      { $project: {
-        productName: '$stores.products.productName',
-        storeId: '$stores.storeId',
-        storeName: '$stores.storeName',
-        edgefirstFileDate: '$stores.edgefirstFileDate',
-        workingdays: '$stores.products.workingdays',
-        currencyType: { $literal: invoiceCurrency },
-      } },
-      { $sort: { productName: 1, workingdays: -1 } },
-      { $match: { workingdays: { $gt: 0 } } },
-      { $lookup: {
-        from: 'basepricings',
-        let: { clientId: invoiceInfo.clientId },
-        pipeline: [
-          { $match: { $expr: { $eq: [ '$clientId', '$$clientId' ] } } },
-          { $project: { standard: 1, step: 1 } },
-        ],
-        as: 'basepricing',
-      } },
-      { $unwind: { path: '$basepricing', preserveNullAndEmptyArrays: true } },
-      { $project: {
-        productName: 1,
-        workingdays: 1,
-        storeName: 1,
-        currencyType: 1,
-        edgefirstFileDate: { $ifNull: [ '$edgefirstFileDate', '$processfirstFileDate' ] },
-        storeId: 1,
-        standard: { $filter: { input: '$basepricing.standard', as: 'standard', cond: { $eq: [ '$$standard.productName', '$productName' ] } } },
-        step: '$basepricing.step',
-      } },
-      { $unwind: { path: '$standard', preserveNullAndEmptyArrays: true } },
-      { $project: {
-        productName: {
-          $concat: [
-            { $toUpper: { $substr: [ '$productName', 0, 1 ] } },
-            { $substr: [ '$productName', 1, { $strLenCP: '$productName' } ] },
-          ],
-        },
-        currencyType: 1,
-        workingdays: 1,
-        storeName: 1,
-        edgefirstFileDate: { $dateToString: { format: '%Y-%m-%d', date: '$edgefirstFileDate' } },
-        storeId: 1,
-        period: { $cond: { if: { $lt: [ '$workingdays', currentMonthDays ] }, then: 'prorate', else: 'fullmonth' } },
-        standardPrice: '$standard.negotiatePrice',
-        runningCost: { $round: [ { $multiply: [ { $divide: [ '$standard.negotiatePrice', currentMonthDays ] }, '$workingdays' ] }, 2 ] },
-      } },
-    ] );
+    const { data: annuxureData, totalFormatted } = await buildAnnexureRows( invoiceInfo, getgroup );
     invoiceData.annuxureData = annuxureData;
+    invoiceData.annuxureTotal = totalFormatted;
   }
 
   const templateHtml = fs.readFileSync( path.resolve( path.dirname( '' ) ) + '/src/hbs/invoicePdf.hbs', 'utf8' );
@@ -919,68 +833,8 @@ export async function invoiceAnnexure( req, res ) {
       return res.sendSuccess( { data: [] } );
     }
 
-    const currentMonthDays = dayjs().daysInMonth();
-    // Annexure must show the same currency as the invoice it accompanies —
-    // see invoiceDownload / buildInvoicePdfBuffer for the same pattern.
-    const invoiceCurrency = symbolFor( invoiceInfo.currency );
-
-    const annexureData = await dailyPricingService.aggregate( [
-      { $match: { clientId: invoiceInfo.clientId } },
-      { $sort: { dateISO: -1 } },
-      { $limit: 1 },
-      { $project: { stores: { $filter: { input: '$stores', as: 'item', cond: { $in: [ '$$item.storeId', getgroup?.stores ?? [] ] } } } } },
-      { $unwind: { path: '$stores', preserveNullAndEmptyArrays: false } },
-      { $unwind: { path: '$stores.products', preserveNullAndEmptyArrays: false } },
-      { $project: {
-        productName: '$stores.products.productName',
-        storeId: '$stores.storeId',
-        storeName: '$stores.storeName',
-        edgefirstFileDate: '$stores.edgefirstFileDate',
-        workingdays: '$stores.products.workingdays',
-        currencyType: { $literal: invoiceCurrency },
-      } },
-      { $sort: { productName: 1, workingdays: -1 } },
-      { $match: { workingdays: { $gt: 0 } } },
-      { $lookup: {
-        from: 'basepricings',
-        let: { clientId: invoiceInfo.clientId },
-        pipeline: [
-          { $match: { $expr: { $eq: [ '$clientId', '$$clientId' ] } } },
-          { $project: { standard: 1, step: 1 } },
-        ],
-        as: 'basepricing',
-      } },
-      { $unwind: { path: '$basepricing', preserveNullAndEmptyArrays: true } },
-      { $project: {
-        productName: 1,
-        workingdays: 1,
-        storeName: 1,
-        currencyType: 1,
-        edgefirstFileDate: { $ifNull: [ '$edgefirstFileDate', '$processfirstFileDate' ] },
-        storeId: 1,
-        standard: { $filter: { input: '$basepricing.standard', as: 'standard', cond: { $eq: [ '$$standard.productName', '$productName' ] } } },
-        step: '$basepricing.step',
-      } },
-      { $unwind: { path: '$standard', preserveNullAndEmptyArrays: true } },
-      { $project: {
-        productName: {
-          $concat: [
-            { $toUpper: { $substr: [ '$productName', 0, 1 ] } },
-            { $substr: [ '$productName', 1, { $strLenCP: '$productName' } ] },
-          ],
-        },
-        currencyType: 1,
-        workingdays: 1,
-        storeName: 1,
-        edgefirstFileDate: { $dateToString: { format: '%Y-%m-%d', date: '$edgefirstFileDate' } },
-        storeId: 1,
-        period: { $cond: { if: { $lt: [ '$workingdays', currentMonthDays ] }, then: 'prorate', else: 'fullmonth' } },
-        standardPrice: '$standard.negotiatePrice',
-        runningCost: { $round: [ { $multiply: [ { $divide: [ '$standard.negotiatePrice', currentMonthDays ] }, '$workingdays' ] }, 2 ] },
-      } },
-    ] );
-
-    return res.sendSuccess( { data: annexureData } );
+    const { data, totalAmount } = await buildAnnexureRows( invoiceInfo, getgroup );
+    return res.sendSuccess( { data, totalAmount } );
   } catch ( error ) {
     logger.error( { error: error, function: 'invoiceAnnexure', invoiceId: req.params.invoiceId } );
     return res.sendError( error, 500 );
@@ -1005,6 +859,11 @@ function inWords( num ) {
 async function standardPrice( group, getClient, baseDate ) {
   console.log( '🚀 ~ standardPrice ~ baseDate:', baseDate.format( 'MMM YYYY' ) );
   const currentMonthDays = dayjs().daysInMonth();
+  // Pricing method: 'flat' => bill every store for the full month
+  // regardless of working days. 'prorate' => bill for actual working days.
+  // Computed once so the aggregation pipelines can inline a $literal.
+  const isFlatPricing = group.proRata === 'flat';
+  console.log( '🚀 ~ standardPrice ~ isFlatPricing:', isFlatPricing );
   let billingTypeMap = {};
   if ( getClient?.planDetails?.product ) {
     getClient.planDetails.product.forEach( ( p ) => {
@@ -1052,6 +911,13 @@ async function standardPrice( group, getClient, baseDate ) {
         storeStatus: '$stores.status',
         zoneCount: { $ifNull: [ '$stores.zoneCount', 0 ] },
         cameraCount: { $ifNull: [ '$stores.cameraCount', 0 ] },
+        // Pull per-store camera splits off the daily-pricing store doc so the
+        // downstream perCamera branch (see below) can multiply price by the
+        // actual camera count. Without these the second $group would $sum
+        // missing fields and totalTraffic/ZoneCameraCount would always be 0
+        // — silently degrading perCamera billing to perStore.
+        trafficCameraCount: { $ifNull: [ '$stores.trafficCameraCount', 0 ] },
+        zoneCameraCount: { $ifNull: [ '$stores.zoneCameraCount', 0 ] },
       },
     },
     {
@@ -1063,23 +929,31 @@ async function standardPrice( group, getClient, baseDate ) {
       $project: {
         productName: 1,
         storeId: 1,
-        prorate: { $literal: group.proRata },
+        // isFlatPricing is the group-level pricing flag, baked into every
+        // doc so the next $project's $cond can read it.
+        isFlatPricing: { $literal: isFlatPricing },
         workingDays: 1,
         storeStatus: 1,
         zoneCount: 1,
         cameraCount: 1,
+        trafficCameraCount: 1,
+        zoneCameraCount: 1,
       },
     },
     {
       $project: {
         productName: 1,
         storeId: 1,
+        // Flat pricing => every store billed for the full month.
+        // Prorate => keep the actual workingDays.
         workingDays: {
-          $cond: { if: { $and: [ { $gte: [ '$workingDays', 15 ] }, { $eq: [ '$storeStatus', 'active' ] }, { $eq: [ '$prorate', 'before15' ] } ] }, then: currentMonthDays, else: '$workingDays' },
+          $cond: { if: '$isFlatPricing', then: currentMonthDays, else: '$workingDays' },
         },
         storeStatus: 1,
         zoneCount: 1,
         cameraCount: 1,
+        trafficCameraCount: 1,
+        zoneCameraCount: 1,
       },
     },
     {
@@ -1091,6 +965,8 @@ async function standardPrice( group, getClient, baseDate ) {
         workingdays: { $first: '$workingDays' },
         zoneCount: { $first: '$zoneCount' },
         cameraCount: { $first: '$cameraCount' },
+        trafficCameraCount: { $first: '$trafficCameraCount' },
+        zoneCameraCount: { $first: '$zoneCameraCount' },
       },
     },
     {
@@ -1294,16 +1170,24 @@ async function standardPrice( group, getClient, baseDate ) {
           storeStatus: '$stores.status',
           zoneCount: { $ifNull: [ '$stores.zoneCount', 0 ] },
           cameraCount: { $ifNull: [ '$stores.cameraCount', 0 ] },
+          // perCamera (eachStore branch) reads these on the per-store record
+          // below; projecting them through is required for the camera-count
+          // multiplier to fire.
+          trafficCameraCount: { $ifNull: [ '$stores.trafficCameraCount', 0 ] },
+          zoneCameraCount: { $ifNull: [ '$stores.zoneCameraCount', 0 ] },
         },
       },
       { $match: { workingDays: { $gt: 0 }, productName: { $in: eachStoreProductNames } } },
       {
         $project: {
           productName: 1, storeId: 1, storeName: 1,
+          // Flat pricing => full month per store. Prorate => actual working
+          // days. Same rule as the overall-store branch above.
           workingDays: {
-            $cond: { if: { $and: [ { $gte: [ '$workingDays', 15 ] }, { $eq: [ '$storeStatus', 'active' ] }, { $eq: [ { $literal: group.proRata }, 'before15' ] } ] }, then: currentMonthDays, else: '$workingDays' },
+            $cond: { if: { $literal: isFlatPricing }, then: currentMonthDays, else: '$workingDays' },
           },
           zoneCount: 1, cameraCount: 1,
+          trafficCameraCount: 1, zoneCameraCount: 1,
         },
       },
       {
@@ -1331,6 +1215,11 @@ async function standardPrice( group, getClient, baseDate ) {
       {
         $project: {
           productName: 1, storeId: 1, storeName: 1, workingDays: 1, zoneCount: 1, cameraCount: 1,
+          // Final whitelist project — must carry trafficCameraCount and
+          // zoneCameraCount through to the JS consumer. Without these the
+          // perCamera branch in the for-loop below sees undefined and falls
+          // back to storeCount=1.
+          trafficCameraCount: 1, zoneCameraCount: 1,
           price: '$matchedStandard.negotiatePrice',
           period: { $cond: { if: { $lt: [ '$workingDays', currentMonthDays ] }, then: 'prorate', else: 'fullmonth' } },
         },
@@ -1339,6 +1228,7 @@ async function standardPrice( group, getClient, baseDate ) {
 
     for ( let store of perStoreData ) {
       let productBillingType = billingTypeMap[store.productName] || 'perStore';
+
       let storeCount = 1;
       if ( store.productName === 'tangoZone' ) {
         if ( productBillingType === 'perZone' && store.zoneCount > 0 ) {
@@ -1406,6 +1296,9 @@ async function standardPrice( group, getClient, baseDate ) {
 
 async function stepPrice( group, getClient ) {
   const currentMonthDays = dayjs().daysInMonth();
+  // 'flat' => every store billed for full month.
+  // 'prorate' => actual working days. See standardPrice for the same flag.
+  const isFlatPricing = group.proRata === 'flat';
   let billingTypeMap = {};
   if ( getClient?.planDetails?.product ) {
     getClient.planDetails.product.forEach( ( p ) => {
@@ -1453,6 +1346,11 @@ async function stepPrice( group, getClient ) {
         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 ] },
       },
     },
     {
@@ -1464,23 +1362,30 @@ async function stepPrice( group, getClient ) {
       $project: {
         productName: 1,
         storeId: 1,
-        prorate: { $literal: group.proRata },
+        // 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: { $and: [ { $gte: [ '$workingDays', 15 ] }, { $eq: [ '$storeStatus', 'active' ] }, { $eq: [ '$prorate', 'before15' ] } ] }, then: currentMonthDays, else: '$workingDays' },
+          $cond: { if: '$isFlatPricing', then: currentMonthDays, else: '$workingDays' },
         },
         storeStatus: 1,
         zoneCount: 1,
         cameraCount: 1,
+        trafficCameraCount: 1,
+        zoneCameraCount: 1,
       },
     }, {
       $group: {
@@ -1491,6 +1396,8 @@ async function stepPrice( group, getClient ) {
         workingdays: { $first: '$workingDays' },
         zoneCount: { $first: '$zoneCount' },
         cameraCount: { $first: '$cameraCount' },
+        trafficCameraCount: { $first: '$trafficCameraCount' },
+        zoneCameraCount: { $first: '$zoneCameraCount' },
       },
     },
     {
@@ -1559,16 +1466,24 @@ async function stepPrice( group, getClient ) {
           storeStatus: '$stores.status',
           zoneCount: { $ifNull: [ '$stores.zoneCount', 0 ] },
           cameraCount: { $ifNull: [ '$stores.cameraCount', 0 ] },
+          // perCamera (eachStore branch) reads these on the per-store record
+          // below; projecting them through is required for the camera-count
+          // multiplier to fire.
+          trafficCameraCount: { $ifNull: [ '$stores.trafficCameraCount', 0 ] },
+          zoneCameraCount: { $ifNull: [ '$stores.zoneCameraCount', 0 ] },
         },
       },
       { $match: { workingDays: { $gt: 0 }, productName: { $in: eachStoreProductNames } } },
       {
         $project: {
           productName: 1, storeId: 1, storeName: 1,
+          // Flat pricing => full month per store. Prorate => actual working
+          // days. Same rule as the overall-store branch above.
           workingDays: {
-            $cond: { if: { $and: [ { $gte: [ '$workingDays', 15 ] }, { $eq: [ '$storeStatus', 'active' ] }, { $eq: [ { $literal: group.proRata }, 'before15' ] } ] }, then: currentMonthDays, else: '$workingDays' },
+            $cond: { if: { $literal: isFlatPricing }, then: currentMonthDays, else: '$workingDays' },
           },
           zoneCount: 1, cameraCount: 1,
+          trafficCameraCount: 1, zoneCameraCount: 1,
         },
       },
       {
@@ -1770,35 +1685,76 @@ export async function clientInvoiceList( req, res ) {
         clientId: { $in: findClients },
       },
     } ];
+
+    // If the user picked an explicit Month or Year, ignore the Duration
+    // filter — otherwise the two ranges conflict (e.g. "current month" +
+    // April would always return zero results). Mirrors brand-invoices.
+    const hasMonthYear = ( req.body.monthFilter && String( req.body.monthFilter ) !== '' ) ||
+      ( req.body.yearFilter && String( req.body.yearFilter ) !== '' );
+
     let filterStartDate = '';
     let filterEndDate = '';
 
-    if ( req.body?.filter && req.body.filter == 'current' ) {
-      filterStartDate = new Date( dayjs().startOf( 'month' ).format( 'YYYY-MM-DD' ) );
-      filterEndDate = new Date( dayjs().endOf( 'month' ).format( 'YYYY-MM-DD' ) );
-    }
-    if ( req.body?.filter && req.body.filter == 'prev' ) {
-      filterStartDate = new Date( dayjs().subtract( 1, 'month' ).startOf( 'month' ).format( 'YYYY-MM-DD' ) );
-      filterEndDate = new Date( dayjs().subtract( 1, 'month' ).endOf( 'month' ).format( 'YYYY-MM-DD' ) );
-    }
-    if ( req.body?.filter && req.body.filter == 'last' ) {
-      filterStartDate = new Date( dayjs().subtract( 12, 'month' ).startOf( 'month' ).format( 'YYYY-MM-DD' ) );
-      filterEndDate = new Date( dayjs().endOf( 'month' ).format( 'YYYY-MM-DD' ) );
-    }
-    console.log( filterStartDate, filterEndDate );
+    if ( !hasMonthYear ) {
+      if ( req.body?.filter && req.body.filter == 'current' ) {
+        filterStartDate = new Date( dayjs().startOf( 'month' ).format( 'YYYY-MM-DD' ) );
+        filterEndDate = new Date( dayjs().endOf( 'month' ).format( 'YYYY-MM-DD' ) );
+      }
+      if ( req.body?.filter && req.body.filter == 'prev' ) {
+        filterStartDate = new Date( dayjs().subtract( 1, 'month' ).startOf( 'month' ).format( 'YYYY-MM-DD' ) );
+        filterEndDate = new Date( dayjs().subtract( 1, 'month' ).endOf( 'month' ).format( 'YYYY-MM-DD' ) );
+      }
+      // Rolling windows. 'last3' = the prototype's "Last 3 Months" (was the
+      // legacy 'last' id, which silently meant 12 months and made every other
+      // filter look broken). 'last' is kept as an alias of 'last3' so older
+      // clients don't break mid-deploy.
+      if ( req.body?.filter && ( req.body.filter == 'last3' || req.body.filter == 'last' ) ) {
+        filterStartDate = new Date( dayjs().subtract( 3, 'month' ).startOf( 'month' ).format( 'YYYY-MM-DD' ) );
+        filterEndDate = new Date( dayjs().endOf( 'month' ).format( 'YYYY-MM-DD' ) );
+      }
+      if ( req.body?.filter && req.body.filter == 'last6' ) {
+        filterStartDate = new Date( dayjs().subtract( 6, 'month' ).startOf( 'month' ).format( 'YYYY-MM-DD' ) );
+        filterEndDate = new Date( dayjs().endOf( 'month' ).format( 'YYYY-MM-DD' ) );
+      }
+      if ( req.body?.filter && req.body.filter == 'last12' ) {
+        filterStartDate = new Date( dayjs().subtract( 12, 'month' ).startOf( 'month' ).format( 'YYYY-MM-DD' ) );
+        filterEndDate = new Date( dayjs().endOf( 'month' ).format( 'YYYY-MM-DD' ) );
+      }
 
-    if ( req.body?.filter ) {
-      query.push(
-          {
-            $match: {
-              $and: [
-                { billingDate: { $gte: filterStartDate } },
-                { billingDate: { $lte: filterEndDate } },
-              ],
-            },
+      if ( req.body?.filter ) {
+        query.push( {
+          $match: {
+            $and: [
+              { billingDate: { $gte: filterStartDate } },
+              { billingDate: { $lte: filterEndDate } },
+            ],
           },
+        } );
+      }
+    }
 
-      );
+    // Month / Year filters (independent of durationFilter). Both 1-based:
+    // monthFilter '1'..'12', yearFilter four-digit string like '2026'.
+    // billingDate may be stored as Date OR string in some legacy rows, so
+    // coerce inside the pipeline before $year/$month.
+    const monthNum = req.body.monthFilter ? parseInt( req.body.monthFilter, 10 ) : null;
+    const yearNum = req.body.yearFilter ? parseInt( req.body.yearFilter, 10 ) : null;
+    if ( ( monthNum && monthNum >= 1 && monthNum <= 12 ) || yearNum ) {
+      const billingDateExpr = {
+        $cond: [
+          { $eq: [ { $type: '$billingDate' }, 'date' ] },
+          '$billingDate',
+          { $toDate: '$billingDate' },
+        ],
+      };
+      const expr = { $and: [] };
+      if ( yearNum ) {
+        expr.$and.push( { $eq: [ { $year: billingDateExpr }, yearNum ] } );
+      }
+      if ( monthNum && monthNum >= 1 && monthNum <= 12 ) {
+        expr.$and.push( { $eq: [ { $month: billingDateExpr }, monthNum ] } );
+      }
+      query.push( { $match: { $expr: expr } } );
     }
 
 
@@ -1835,6 +1791,7 @@ export async function clientInvoiceList( req, res ) {
         clientName: '$clientDetails.clientName',
         logo: '$clientDetails.logo',
         currencyType: '$currency',
+        currency: 1,
         invoice: 1,
         stores: 1,
         amount: 1,
@@ -1842,8 +1799,17 @@ export async function clientInvoiceList( req, res ) {
         groupName: 1,
         status: 1,
         paymentStatus: 1,
+        paidAmount: { $ifNull: [ '$paidAmount', 0 ] },
         clientId: 1,
         billingDate: 1,
+        companyName: 1,
+        dueDate: 1,
+        // GST column shown in the table. Derived rather than stored because
+        // dollar-currency invoices have totalAmount === amount (no GST).
+        gstAmount: { $subtract: [
+          { $ifNull: [ '$totalAmount', 0 ] },
+          { $ifNull: [ '$amount', 0 ] },
+        ] },
       },
     },
 
@@ -1854,6 +1820,8 @@ export async function clientInvoiceList( req, res ) {
           $or: [
             { groupName: { $regex: req.body.searchValue, $options: 'i' } },
             { clientName: { $regex: req.body.searchValue, $options: 'i' } },
+            { companyName: { $regex: req.body.searchValue, $options: 'i' } },
+            { invoice: { $regex: req.body.searchValue, $options: 'i' } },
             { paymentStatus: { $regex: req.body.searchValue, $options: 'i' } },
             { status: { $regex: req.body.searchValue, $options: 'i' } },
           ],
@@ -1888,11 +1856,15 @@ export async function clientInvoiceList( req, res ) {
       const exportdata = [];
       count.forEach( ( element ) => {
         exportdata.push( {
-          'Client Name': element.clientName,
+          'Brand Name': element.clientName,
+          'Registered Name': element.companyName || '',
           'Invoice #': element.invoice,
           'Billing date': dayjs( element.billingDate ).format( 'DD MMM, YYYY' ),
+          'Due Date': element.dueDate ? dayjs( element.dueDate ).format( 'DD MMM, YYYY' ) : '',
           'Group Name': element.groupName,
-          'Amount': element.totalAmount,
+          'Amount Excl. GST': element.amount,
+          'GST Amount': element.gstAmount,
+          'Amount Incl. GST': element.totalAmount,
           'Stores': element.stores,
           'Payment Status': element.paymentStatus,
           'Approval Status': element.status,
@@ -1922,7 +1894,38 @@ export async function clientInvoiceList( req, res ) {
         client.logo = '';
       }
     }
-    res.sendSuccess( { count: count.length, data: invoiceList } );
+
+    // Card totals — computed over the user's full client scope (findClients),
+    // NOT the currently-filtered/paged view, so the cards stay stable as the
+    // user narrows the list with filters. Outstanding is everything unpaid;
+    // Overdue is the past-due subset; Pending Payment is the approved-but-
+    // unpaid subset. "Outstanding amount" uses totalAmount - paidAmount so a
+    // partially-paid invoice contributes only its remaining balance.
+    const now = new Date();
+    const remaining = { $subtract: [
+      { $ifNull: [ '$totalAmount', { $ifNull: [ '$amount', 0 ] } ] },
+      { $ifNull: [ '$paidAmount', 0 ] },
+    ] };
+    const cardsAggregate = await invoiceService.aggregate( [
+      { $match: { clientId: { $in: findClients }, paymentStatus: { $ne: 'paid' } } },
+      { $group: {
+        _id: null,
+        outstandingAmount: { $sum: remaining },
+        outstandingCount: { $sum: 1 },
+        overdueAmount: { $sum: { $cond: [ { $lt: [ '$dueDate', now ] }, remaining, 0 ] } },
+        overdueCount: { $sum: { $cond: [ { $lt: [ '$dueDate', now ] }, 1, 0 ] } },
+        pendingPaymentAmount: { $sum: { $cond: [ { $eq: [ '$status', 'approved' ] }, remaining, 0 ] } },
+        pendingPaymentCount: { $sum: { $cond: [ { $eq: [ '$status', 'approved' ] }, 1, 0 ] } },
+      } },
+    ] );
+    const cards = cardsAggregate[0] || {
+      outstandingAmount: 0, outstandingCount: 0,
+      overdueAmount: 0, overdueCount: 0,
+      pendingPaymentAmount: 0, pendingPaymentCount: 0,
+    };
+    delete cards._id;
+
+    res.sendSuccess( { count: count.length, data: invoiceList, cards } );
   } catch ( error ) {
     logger.error( { error: error, function: 'clientInvoiceList' } );
     return res.sendError( error, 500 );
@@ -2147,6 +2150,105 @@ export async function PaymentStatusChange( req, res ) {
   }
 }
 
+// Record a (full or partial) payment against an invoice. Appends to
+// paymentHistory, increments paidAmount, and recomputes paymentStatus
+// (unpaid → partial → paid). Body: { invoiceId, amount, date, method?,
+// reference?, notes? }. invoiceId is the human-readable invoice number
+// (e.g. INV-26-27-00077), matching the legacy PaymentStatusChange contract.
+export async function recordPayment( req, res ) {
+  try {
+    const { invoiceId, amount, date, method, reference, notes } = req.body;
+    if ( !invoiceId ) {
+      return res.sendError( 'invoiceId is required', 400 );
+    }
+    const amountNum = Number( amount );
+    if ( !Number.isFinite( amountNum ) || amountNum <= 0 ) {
+      return res.sendError( 'amount must be a positive number', 400 );
+    }
+
+    const invoice = await invoiceService.findOne( { invoice: invoiceId } );
+    if ( !invoice ) {
+      return res.sendError( 'Invoice not found', 404 );
+    }
+
+    const previousPaid = Number( invoice.paidAmount ) || 0;
+    const newPaid = Math.round( ( previousPaid + amountNum ) * 100 ) / 100;
+    const totalAmount = Number( invoice.totalAmount ) || 0;
+
+    // Reject overpayment — finance teams want this caught early. They can
+    // record an exact final payment that brings the running total to the
+    // invoice total; anything beyond that is a data-entry error.
+    if ( totalAmount > 0 && newPaid > totalAmount + 0.01 ) {
+      return res.sendError(
+          `Payment exceeds outstanding balance. Outstanding: ${( totalAmount - previousPaid ).toFixed( 2 )}`,
+          400,
+      );
+    }
+
+    let derivedStatus = 'unpaid';
+    if ( newPaid >= totalAmount - 0.01 && totalAmount > 0 ) {
+      derivedStatus = 'paid';
+    } else if ( newPaid > 0 ) {
+      derivedStatus = 'partial';
+    }
+
+    const historyEntry = {
+      amount: amountNum,
+      date: date ? new Date( date ) : new Date(),
+      method: method || undefined,
+      reference: reference || undefined,
+      notes: notes || undefined,
+      recordedBy: req.user?.email || req.user?.userName || undefined,
+      recordedAt: new Date(),
+    };
+
+    const update = {
+      $set: {
+        paidAmount: newPaid,
+        paymentStatus: derivedStatus,
+        ...( derivedStatus === 'paid' ? { paidDate: new Date() } : {} ),
+      },
+      $push: { paymentHistory: historyEntry },
+    };
+
+    // Use invoiceUpdateOne — it passes the raw update object straight to
+    // Mongoose. invoiceService.updateOne (without "invoice" prefix) wraps
+    // its second arg in $set, which would turn our { $set, $push } into
+    // { $set: { $set, $push } } and Mongoose silently drops both as
+    // unknown fields under strict mode. (That's why an earlier version
+    // of this controller responded 200 but didn't actually persist.)
+    const result = await invoiceService.invoiceUpdateOne( { invoice: invoiceId }, update );
+    logger.info?.( { function: 'recordPayment', invoiceId, matched: result?.matchedCount, modified: result?.modifiedCount } );
+
+    try {
+      const logObj = {
+        userName: req.user?.userName,
+        email: req.user?.email,
+        clientId: invoice.clientId,
+        logSubType: 'paymentRecorded',
+        logType: 'invoice',
+        date: new Date(),
+        changes: [ `Payment of ${amountNum} recorded for ${invoiceId}. Status: ${derivedStatus} (${newPaid}/${totalAmount}).` ],
+        eventType: 'update',
+        timestamp: new Date(),
+        showTo: [ 'tango' ],
+      };
+      insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).activityLog, logObj );
+    } catch ( logErr ) {
+      logger.error( { error: logErr, function: 'recordPayment.log' } );
+    }
+
+    return res.sendSuccess( {
+      paidAmount: newPaid,
+      pendingAmount: Math.max( 0, totalAmount - newPaid ),
+      paymentStatus: derivedStatus,
+    } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'recordPayment' } );
+    return res.sendError( error, 500 );
+  }
+}
+
 export async function checkPaymentStatus( req, res ) {
   try {
     let findInvoice = await invoiceService.find( { status: 'approved', paymentStatus: { $ne: 'paid' } } );