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

package/src/controllers/invoice.controller.js

@@ -360,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;
@@ -438,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' );
@@ -755,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' );
@@ -926,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 );
@@ -1857,7 +1704,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 +1802,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 +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' } },
           ],
@@ -1987,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,
@@ -2021,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 );

package/src/controllers/paymentSubscription.controllers.js

@@ -102,6 +102,15 @@ export const clientBillingSubscriptionInfo = async ( req, res, next ) => {
     let storeCount = await storeService.count( { clientId: clientInfo[0].clientId, status: 'active' } );
     let tangoProductsList = await basePricingService.findOne( { clientId: { $exists: false } }, { basePricing: 1 } );
     let tangoProducts = tangoProductsList.basePricing.map( ( item ) => item.productName );
+    // Client-specific negotiated pricing — used to show the agreed per-store
+    // price for subscribed (live) products in the upgrade-plan popup.
+    let clientPricing = await basePricingService.findOne( { clientId: clientInfo[0].clientId }, { standard: 1, step: 1 } );
+    let negotiateByProduct = {};
+    ( clientPricing?.standard || clientPricing?.step || [] ).forEach( ( p ) => {
+      if ( p && p.productName != null && p.negotiatePrice != null ) {
+        negotiateByProduct[p.productName] = p.negotiatePrice;
+      }
+    } );
     let activeProducts = clientInfo[0].planDetails.product;
     let liveProducts = [];
     let trialProducts = [];
@@ -160,6 +169,10 @@ export const clientBillingSubscriptionInfo = async ( req, res, next ) => {
         if ( price ) {
           element.price = price.basePrice;
         }
+        // Negotiated (agreed) per-store price for subscribed products.
+        if ( negotiateByProduct[element.productName] != null ) {
+          element.negotiatePrice = negotiateByProduct[element.productName];
+        }
         let getProductCount = productDetails.find( ( item ) => item.product == element.productName );
         element.storeCount = getProductCount?.count || 0;
         element.aliseProductName = convertTitleCase( element.productName );
@@ -2546,17 +2559,55 @@ async function updatePricing( req, res, update ) {
   if ( clientDetails ) {
     let products = clientDetails.planDetails.product.map( ( item ) => item.productName );
     let subscriptionProduct = clientDetails.planDetails.product.filter( ( item ) => item.status == 'live' );
+    // Negotiated prices coming from the Subscribe popup (or any caller) take
+    // precedence; otherwise we keep whatever was already saved for this
+    // client and only fall back to the global base defaults for brand-new
+    // products. This stops updatePricing from clobbering a manually agreed
+    // price every time the product list changes.
+    let pricingOverride = {};
+    if ( Array.isArray( req.body.pricing ) ) {
+      req.body.pricing.forEach( ( p ) => {
+        if ( p && p.productName ) {
+          pricingOverride[p.productName] = p;
+        }
+      } );
+    }
+    logger.info?.( { function: 'updatePricing', clientId: req.body.clientId, override: pricingOverride } );
+    let existingStandard = {};
+    let existingStep = {};
+    ( getPriceInfo?.standard || [] ).forEach( ( s ) => {
+      existingStandard[s.productName] = s;
+    } );
+    ( getPriceInfo?.step || [] ).forEach( ( s ) => {
+      existingStep[s.productName] = s;
+    } );
     let standardList = [];
     let stepList = [];
     products.forEach( ( product ) => {
       let baseDetails = baseProduct.basePricing.find( ( item ) => item.productName == product );
+      // A product missing from the global base pricing would otherwise crash
+      // the whole pricing save (and silently drop the negotiated override,
+      // since this runs un-awaited in a .then()). Fall back to safe zeros.
+      if ( !baseDetails ) {
+        baseDetails = { basePrice: 0, discoutPercentage: 0 };
+      }
       let discountPrice = ( baseDetails.basePrice * baseDetails.discoutPercentage ) / 100;
+      let defaultNegotiate = Number( baseDetails.basePrice - discountPrice );
+      // Precedence: explicit override from the request > previously saved
+      // client price > computed default from the global base pricing.
+      let override = pricingOverride[product];
+      let prevStandard = existingStandard[product];
+      let prevStep = existingStep[product];
+      let negotiateStandard = override && override.negotiatePrice != null ? Number( override.negotiatePrice ) :
+        ( prevStandard && prevStandard.negotiatePrice != null ? Number( prevStandard.negotiatePrice ) : defaultNegotiate );
+      let negotiateStep = override && override.negotiatePrice != null ? Number( override.negotiatePrice ) :
+        ( prevStep && prevStep.negotiatePrice != null ? Number( prevStep.negotiatePrice ) : defaultNegotiate );
       standardList.push(
           {
             productName: product,
             discountPercentage: baseDetails.discoutPercentage,
             basePrice: baseDetails.basePrice,
-            negotiatePrice: Number( baseDetails.basePrice - discountPrice ),
+            negotiatePrice: negotiateStandard,
           },
       );
       stepList.push(
@@ -2564,8 +2615,8 @@ async function updatePricing( req, res, update ) {
             productName: product,
             discountPercentage: baseDetails.discoutPercentage,
             basePrice: baseDetails.basePrice,
-            negotiatePrice: Number( baseDetails.basePrice - discountPrice ),
-            storeRange: '1-100',
+            negotiatePrice: negotiateStep,
+            storeRange: ( prevStep && prevStep.storeRange ) || '1-100',
           },
       );
     } );
@@ -2574,6 +2625,7 @@ async function updatePricing( req, res, update ) {
       step: stepList,
       clientId: req.body.clientId,
     };
+    console.log( '🚀 ~ updatePricing ~ data:', data );
     if ( !getPriceInfo ) {
       await basePricingService.create( data );
     } else {

package/src/dtos/validation.dtos.js

@@ -75,6 +75,12 @@ export const validateSubscibeSchema = joi.object( {
   product: joi.array().required(),
   clientId: joi.string().required(),
   stores: joi.array().optional(),
+  // Negotiated price overrides from the Subscribe popup — applied in
+  // updatePricing so a manually-agreed price isn't reset to base defaults.
+  pricing: joi.array().items( joi.object( {
+    productName: joi.string().required(),
+    negotiatePrice: joi.number().min( 0 ).required(),
+  } ).unknown( true ) ).optional(),
 } );
 
 export const validateSubscibeParams = {