tango-app-api-payment-subscription 3.5.5 → 3.5.7

package/src/controllers/invoice.controller.js

@@ -17,6 +17,7 @@ import { symbolFor } from '../utils/currency.js';
 import { invoiceStatusEnum } from '../dtos/validation.dtos.js';
 import { findOneApplicationDefault } from '../services/applicationDefault.service.js';
 import * as assignedStoreService from '../services/assignedStore.service.js';
+import { getUsdInrRate } from './brandsBilling.controller.js';
 
 // Pulls CSM + Finance head emails (stored under applicationDefault
 // type=invoice, subType=heads) AND the per-client CSMs assigned via
@@ -360,6 +361,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;
@@ -438,145 +536,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' );
@@ -755,65 +718,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' );
@@ -926,68 +834,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 );
@@ -1857,7 +1705,19 @@ export async function clientInvoiceList( req, res ) {
         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' ) {
+      // 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' ) );
       }
@@ -1943,6 +1803,14 @@ export async function clientInvoiceList( req, res ) {
         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 ] },
+        ] },
       },
     },
 
@@ -1953,6 +1821,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' } },
           ],
@@ -1987,11 +1857,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,
@@ -2021,7 +1895,45 @@ export async function clientInvoiceList( req, res ) {
         client.logo = '';
       }
     }
-    res.sendSuccess( { count: count.length, data: invoiceList } );
+
+    // Card totals — computed over the CURRENTLY-FILTERED result set (`count`
+    // holds every invoice matching the active filters, pre-pagination), so the
+    // cards reflect exactly what the filters select. Dollar invoices are
+    // converted to INR at today's rate so all three totals are a single ₹
+    // figure. Outstanding = unpaid remaining (totalAmount - paidAmount);
+    // Overdue = past-due unpaid subset; Pending Payment = approved-but-unpaid.
+    const usdRate = await getUsdInrRate();
+    const now = new Date();
+    const cards = {
+      outstandingAmount: 0, outstandingCount: 0,
+      overdueAmount: 0, overdueCount: 0,
+      pendingPaymentAmount: 0, pendingPaymentCount: 0,
+    };
+    for ( const inv of count ) {
+      if ( inv.paymentStatus === 'paid' ) {
+        continue;
+      }
+      const fx = inv.currency === 'dollar' ? usdRate : 1;
+      const total = Number( inv.totalAmount ) || Number( inv.amount ) || 0;
+      const paid = Number( inv.paidAmount ) || 0;
+      const remaining = Math.max( 0, total - paid ) * fx;
+
+      cards.outstandingAmount += remaining;
+      cards.outstandingCount += 1;
+      if ( inv.dueDate && new Date( inv.dueDate ) < now ) {
+        cards.overdueAmount += remaining;
+        cards.overdueCount += 1;
+      }
+      if ( inv.status === 'approved' ) {
+        cards.pendingPaymentAmount += remaining;
+        cards.pendingPaymentCount += 1;
+      }
+    }
+    cards.outstandingAmount = Math.round( cards.outstandingAmount * 100 ) / 100;
+    cards.overdueAmount = Math.round( cards.overdueAmount * 100 ) / 100;
+    cards.pendingPaymentAmount = Math.round( cards.pendingPaymentAmount * 100 ) / 100;
+
+    res.sendSuccess( { count: count.length, data: invoiceList, cards } );
   } catch ( error ) {
     logger.error( { error: error, function: 'clientInvoiceList' } );
     return res.sendError( error, 500 );

package/src/controllers/paymentReminder.controller.js

@@ -0,0 +1,81 @@
+import * as paymentReminderService from '../services/paymentReminder.service.js';
+import { logger } from 'tango-app-api-middleware';
+
+// Payment reminder config (Billing Settings page). One document per brand
+// (clientId): recipient emails + five toggleable reminder templates. Returns
+// sensible defaults when a brand has no config saved yet.
+const DEFAULTS = () => ( {
+  reminderEmails: [],
+  templates: {
+    preDue: { enabled: true, daysBefore: 3 },
+    onDue: { enabled: true },
+    onHold: { enabled: true },
+    suspend: { enabled: true },
+    deactivated: { enabled: false },
+  },
+} );
+
+export async function getPaymentReminder( req, res ) {
+  try {
+    const clientId = req.params.clientId || req.query.clientId;
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+    const existing = await paymentReminderService.findOne( { clientId } );
+    if ( !existing ) {
+      return res.sendSuccess( { clientId, ...DEFAULTS(), isDefault: true } );
+    }
+    return res.sendSuccess( existing );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getPaymentReminder' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function savePaymentReminder( req, res ) {
+  try {
+    const b = req.body || {};
+    if ( !b.clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+
+    // Normalize recipients: trim, drop blanks, de-dupe.
+    const emails = Array.isArray( b.reminderEmails ) ? b.reminderEmails : [];
+    const reminderEmails = [ ...new Set(
+        emails.map( ( e ) => String( e || '' ).trim() ).filter( Boolean ),
+    ) ];
+
+    const t = b.templates || {};
+    const bool = ( v, d ) => ( typeof v === 'boolean' ? v : d );
+    let daysBefore = Number( t.preDue?.daysBefore );
+    if ( !Number.isFinite( daysBefore ) ) {
+      daysBefore = 3;
+    }
+    daysBefore = Math.min( 365, Math.max( 1, Math.round( daysBefore ) ) );
+
+    const templates = {
+      preDue: { enabled: bool( t.preDue?.enabled, true ), daysBefore },
+      onDue: { enabled: bool( t.onDue?.enabled, true ) },
+      onHold: { enabled: bool( t.onHold?.enabled, true ) },
+      suspend: { enabled: bool( t.suspend?.enabled, true ) },
+      deactivated: { enabled: bool( t.deactivated?.enabled, false ) },
+    };
+
+    await paymentReminderService.upsert(
+        { clientId: b.clientId },
+        {
+          clientId: b.clientId,
+          reminderEmails,
+          templates,
+          updatedBy: req.user?.email || req.user?.userName || '',
+        },
+    );
+
+    const saved = await paymentReminderService.findOne( { clientId: b.clientId } );
+    logger.info?.( { function: 'savePaymentReminder', clientId: b.clientId } );
+    return res.sendSuccess( saved );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'savePaymentReminder' } );
+    return res.sendError( error, 500 );
+  }
+}