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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.5.15",
+    "version": "3.5.16",
     "description": "paymentSubscription",
     "main": "index.js",
     "type": "module",
@@ -29,7 +29,7 @@
         "nodemon": "^3.1.0",
         "puppeteer": "^24.41.0",
         "swagger-ui-express": "^5.0.0",
-        "tango-api-schema": "^2.6.29",
+        "tango-api-schema": "^2.6.34",
         "tango-app-api-middleware": "^3.6.18",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0",

package/src/controllers/brandsBilling.controller.js

@@ -582,6 +582,11 @@ export async function brandInvoiceList( req, res ) {
     let summary = {
       totalInvoices: allInvoices.length,
       totalInvoiced: allInvoices.reduce( ( sum, inv ) => sum + ( inv.totalAmount || 0 ), 0 ),
+      // Footer totals over the FULL filtered set (not just the current page):
+      // stores, amount excl. GST and amount incl. GST.
+      totalStores: allInvoices.reduce( ( sum, inv ) => sum + ( inv.stores || 0 ), 0 ),
+      totalAmountExclGst: allInvoices.reduce( ( sum, inv ) => sum + ( inv.amount || 0 ), 0 ),
+      totalAmountInclGst: allInvoices.reduce( ( sum, inv ) => sum + ( inv.totalAmount || 0 ), 0 ),
       pendingApproval: allInvoices.filter( ( inv ) => [ 'pendingCsm', 'pendingFinance', 'pendingApproval' ].includes( inv.status ) ).length,
       pendingPayment: allInvoices.filter( ( inv ) => inv.paymentStatus === 'unpaid' && inv.status === 'approved' ).length,
       paid: allInvoices.filter( ( inv ) => inv.paymentStatus === 'paid' ).length,
@@ -891,6 +896,32 @@ export async function latestDailyPricing( req, res ) {
       } },
     ] );
 
+    // Newly onboarded stores = stores whose FIRST FILE date falls in the current
+    // calendar month. Counted over the FULL store list (record.stores), not the
+    // status/search-filtered view, so the card reflects all new onboardings.
+    // First-file date is edgefirstFileDate, with processfirstFileDate as the
+    // fallback (same rule the annexure uses); some legacy rows store it as a
+    // string, so coerce defensively.
+    const monthStart = dayjs().startOf( 'month' );
+    const monthEnd = dayjs().endOf( 'month' );
+    const newlyOnboardedStoreList = ( record.stores || [] )
+        .map( ( s ) => {
+          const raw = s.edgefirstFileDate || s.processfirstFileDate;
+          const ff = raw ? dayjs( raw ) : null;
+          return { store: s, ff };
+        } )
+        .filter( ( x ) => x.ff && x.ff.isValid() &&
+          x.ff.isAfter( monthStart.subtract( 1, 'millisecond' ) ) &&
+          x.ff.isBefore( monthEnd.add( 1, 'millisecond' ) ) )
+        .map( ( x ) => ( {
+          storeId: x.store.storeId,
+          storeName: x.store.storeName,
+          status: x.store.status,
+          firstFileDate: x.ff.format( 'YYYY-MM-DD' ),
+        } ) )
+        .sort( ( a, b ) => a.firstFileDate.localeCompare( b.firstFileDate ) );
+    const newlyOnboardedStores = newlyOnboardedStoreList.length;
+
     let data = {
       clientId: record.clientId,
       brandName: record.brandName,
@@ -901,6 +932,8 @@ export async function latestDailyPricing( req, res ) {
       status: record.status,
       proRate: record.proRate,
       count,
+      newlyOnboardedStores,
+      newlyOnboardedStoreList,
       data: storeList,
       monthlyBillingSummary,
     };

package/src/controllers/invoice.controller.js

@@ -286,6 +286,58 @@ export async function createInvoice( req, res ) {
         products = expanded;
       }
 
+      // One-time onboarding fee: stores in THIS billing group whose first file
+      // date falls in the invoice's billing month, charged a flat
+      // oneTimeFeePerStore (from the client's basepricing). Added AFTER the
+      // multi-month expansion so it's billed ONCE per invoice (not per month).
+      // It's a normal line item, so it lands in the taxable subtotal below.
+      try {
+        const oneTimeBp = await basepricingService.findOne(
+            { clientId: group.clientId },
+            { oneTimeFeePerStore: 1 },
+        );
+        const oneTimeFeePerStore = Number( oneTimeBp?.oneTimeFeePerStore ) || 0;
+        if ( oneTimeFeePerStore > 0 && Array.isArray( group.stores ) && group.stores.length ) {
+          const monthStart = new Date( baseDate.startOf( 'month' ).toISOString() );
+          const monthEnd = new Date( baseDate.endOf( 'month' ).toISOString() );
+          // Distinct group stores whose first file date is within the billing
+          // month. First file = edgefirstFileDate, fallback processfirstFileDate.
+          const newStoreAgg = await dailyPricingService.aggregate( [
+            { $match: { clientId: group.clientId } },
+            { $sort: { dateISO: -1 } },
+            { $limit: 1 },
+            { $project: { stores: { $filter: {
+              input: '$stores', as: 'item', cond: { $in: [ '$$item.storeId', group.stores ] },
+            } } } },
+            { $unwind: '$stores' },
+            { $addFields: { ff: {
+              $convert: {
+                input: { $ifNull: [ '$stores.edgefirstFileDate', '$stores.processfirstFileDate' ] },
+                to: 'date', onError: null, onNull: null,
+              },
+            } } },
+            { $match: { ff: { $ne: null, $gte: monthStart, $lte: monthEnd } } },
+            { $group: { _id: '$stores.storeId' } },
+            { $count: 'newStores' },
+          ] );
+          const newStoreCount = newStoreAgg?.[0]?.newStores || 0;
+          if ( newStoreCount > 0 ) {
+            products.push( {
+              productName: 'oneTimeFee',
+              period: 'fullmonth',
+              storeCount: newStoreCount,
+              amount: Math.round( newStoreCount * oneTimeFeePerStore * 100 ) / 100,
+              price: oneTimeFeePerStore,
+              description: `One-Time Fee - ${newStoreCount} stores`,
+              HsnNumber: '998314',
+              month: baseDate.format( 'MMM YYYY' ),
+            } );
+          }
+        }
+      } catch ( oneTimeErr ) {
+        logger.error( { error: oneTimeErr, function: 'createInvoice.oneTimeFee', clientId: group.clientId } );
+      }
+
       let amount = products.reduce( ( sum, product ) => sum + product.amount, 0 );
       let taxList = [];
       let totalAmount = 0;
@@ -1481,134 +1533,40 @@ async function stepPrice( group, getClient ) {
       billingTypeMap[p.productName] = p.billingType || 'perStore';
     } );
   }
-  let products = await dailyPricingService.aggregate( [
-    {
-      $match: {
-        clientId: group.clientId,
-      },
-    },
-    {
-      $sort: { dateISO: -1 },
-    },
+  // PER-STORE rows (not bucketed) so step tiers can be assigned to individual
+  // stores and each store charged tierPrice x its EXACT camera/zone count.
+  let perStoreRows = await dailyPricingService.aggregate( [
+    { $match: { clientId: group.clientId } },
+    { $sort: { dateISO: -1 } },
     { $limit: 1 },
-    {
-      $project: {
-        stores: {
-          $filter: {
-            input: '$stores',
-            as: 'item',
-            cond: { $in: [ '$$item.storeId', group.stores ] },
-          },
-        },
-      },
-    },
-    {
-      $unwind: {
-        path: '$stores',
-        preserveNullAndEmptyArrays: false,
-      },
-    },
-    {
-      $unwind: {
-        path: '$stores.products',
-        preserveNullAndEmptyArrays: false,
-      },
-    },
-    {
-      $project: {
-        productName: '$stores.products.productName',
-        storeId: '$stores.storeId',
-        workingDays: '$stores.products.workingdays',
-        storeStatus: '$stores.status',
-        zoneCount: { $ifNull: [ '$stores.zoneCount', 0 ] },
-        cameraCount: { $ifNull: [ '$stores.cameraCount', 0 ] },
-        // Pull per-store camera splits; same fix as standardPrice — without
-        // these the second $group sums missing fields and the perCamera
-        // branch in the downstream map silently falls back to perStore.
-        trafficCameraCount: { $ifNull: [ '$stores.trafficCameraCount', 0 ] },
-        zoneCameraCount: { $ifNull: [ '$stores.zoneCameraCount', 0 ] },
-      },
-    },
-    {
-      $match: {
-        workingDays: { $gt: 0 },
-      },
-    },
-    {
-      $project: {
-        productName: 1,
-        storeId: 1,
-        // Group-level flag baked into every doc; consumed by the next
-        // $project's $cond.
-        isFlatPricing: { $literal: isFlatPricing },
-        workingDays: 1,
-        storeStatus: 1,
-        zoneCount: 1,
-        cameraCount: 1,
-        trafficCameraCount: 1,
-        zoneCameraCount: 1,
-      },
-    },
-    {
-      $project: {
-        productName: 1,
-        storeId: 1,
-        // Flat => full month per store. Prorate => actual working days.
-        workingDays: {
-          $cond: { if: '$isFlatPricing', then: currentMonthDays, else: '$workingDays' },
-        },
-        storeStatus: 1,
-        zoneCount: 1,
-        cameraCount: 1,
-        trafficCameraCount: 1,
-        zoneCameraCount: 1,
-      },
-    }, {
-      $group: {
-        _id: {
-          productName: '$productName',
-          storeId: '$storeId',
-        },
-        workingdays: { $first: '$workingDays' },
-        zoneCount: { $first: '$zoneCount' },
-        cameraCount: { $first: '$cameraCount' },
-        trafficCameraCount: { $first: '$trafficCameraCount' },
-        zoneCameraCount: { $first: '$zoneCameraCount' },
-      },
-    },
-    {
-      $group: {
-        _id: {
-          productName: '$_id.productName',
-          workingdays: '$workingdays',
-        },
-        storeCount: { $sum: 1 },
-        totalZoneCount: { $sum: '$zoneCount' },
-        totalTrafficCameraCount: { $sum: '$trafficCameraCount' },
-        totalZoneCameraCount: { $sum: '$zoneCameraCount' },
-      },
-    },
-    {
-      $project: {
-        _id: 0,
-        productName: '$_id.productName',
-        workingdays: '$_id.workingdays',
-        storeCount: '$storeCount',
-        totalZoneCount: '$totalZoneCount',
-        totalTrafficCameraCount: '$totalTrafficCameraCount',
-        totalZoneCameraCount: '$totalZoneCameraCount',
-      },
-    },
-    {
-      // productName first so order is deterministic across views/PDF, then
-      // workingdays so step rows stay grouped consistently.
-      $sort: {
-        productName: 1,
-        workingdays: -1,
-      },
-    },
-
-
+    { $project: { stores: { $filter: {
+      input: '$stores', as: 'item', cond: { $in: [ '$$item.storeId', group.stores ] },
+    } } } },
+    { $unwind: { path: '$stores', preserveNullAndEmptyArrays: false } },
+    { $unwind: { path: '$stores.products', preserveNullAndEmptyArrays: false } },
+    { $project: {
+      productName: '$stores.products.productName',
+      storeId: '$stores.storeId',
+      storeName: '$stores.storeName',
+      workingDays: '$stores.products.workingdays',
+      zoneCount: { $ifNull: [ '$stores.zoneCount', 0 ] },
+      trafficCameraCount: { $ifNull: [ '$stores.trafficCameraCount', 0 ] },
+      zoneCameraCount: { $ifNull: [ '$stores.zoneCameraCount', 0 ] },
+    } },
+    { $match: { workingDays: { $gt: 0 } } },
+    // Flat pricing => bill every store for the full month.
+    { $project: {
+      _id: 0,
+      productName: 1,
+      storeId: 1,
+      storeName: 1,
+      workingDays: { $cond: { if: { $literal: isFlatPricing }, then: currentMonthDays, else: '$workingDays' } },
+      zoneCount: 1,
+      trafficCameraCount: 1,
+      zoneCameraCount: 1,
+    } },
+    // Deterministic order so per-store tier assignment is stable run to run.
+    { $sort: { productName: 1, storeId: 1 } },
   ] );
   // Build billingMethod map from group.products
   let billingMethodMap = {};
@@ -1721,168 +1679,100 @@ async function stepPrice( group, getClient ) {
     }
   }
 
-  // Filter out eachStore products from aggregated results
-  products = products.filter( ( p ) => !eachStoreProductNames.includes( p.productName ) );
+  // Drop eachStore products — those are handled by the per-store branch above.
+  perStoreRows = perStoreRows.filter( ( p ) => !eachStoreProductNames.includes( p.productName ) );
 
-  // Adjust storeCount based on billingType for tangoZone and tangoTraffic (overallStore only)
-  products = products.map( ( product ) => {
-    let productBillingType = billingTypeMap[product.productName] || 'perStore';
-    if ( product.productName === 'tangoZone' ) {
-      if ( productBillingType === 'perZone' && product.totalZoneCount > 0 ) {
-        product.storeCount = product.totalZoneCount;
-      } else if ( productBillingType === 'perCamera' && product.totalZoneCameraCount > 0 ) {
-        product.storeCount = product.totalZoneCameraCount;
-      }
-    } else if ( product.productName === 'tangoTraffic' ) {
-      if ( productBillingType === 'perCamera' && product.totalTrafficCameraCount > 0 ) {
-        product.storeCount = product.totalTrafficCameraCount;
-      }
-    }
-    delete product.totalZoneCount;
-    delete product.totalTrafficCameraCount;
-    delete product.totalZoneCameraCount;
-    return product;
-  } );
-
-  let stepPriceRecord = await basepricingService.findOne( { clientId: group.clientId } );
-  let data = products;
-  // Tiers must be ordered by range start for the cumulative step assignment in
-  // processArray to walk them low-to-high.
-  let pricing = ( stepPriceRecord.step || [] ).slice().sort( ( a, b ) => {
+  const stepPriceRecord = await basepricingService.findOne( { clientId: group.clientId } );
+  // Tiers ordered by range start so per-store tier assignment walks low-to-high.
+  const pricing = ( stepPriceRecord?.step || [] ).slice().sort( ( a, b ) => {
     const aStart = parseInt( String( a.storeRange || '0' ).split( '-' )[0], 10 ) || 0;
     const bStart = parseInt( String( b.storeRange || '0' ).split( '-' )[0], 10 ) || 0;
     return aStart - bStart;
   } );
-
-  const applyPricing = ( data, pricing ) => {
-    let totalcount = 0;
-    return data.map( ( item ) => {
-      totalcount = totalcount + item.storeCount;
-
-      console.log( '======>', item );
-      if ( item.workingdays === currentMonthDays ) {
-        item.period = 'fullMonth';
-        item.runningCost = item.storeCount * item.price;
-      } else {
-        item.period = 'proRate';
-        item.runningCost = ( item.storeCount * ( item.price / currentMonthDays ) * item.workingdays ).toFixed( 2 );
+  // Tiers grouped per product (only one product set here, but keep it general).
+  const tiersByProduct = {};
+  for ( const t of pricing ) {
+    if ( !tiersByProduct[t.productName] ) {
+      tiersByProduct[t.productName] = [];
+    }
+    tiersByProduct[t.productName].push( t );
+  }
+  // Resolve the tier price for a store's 1-based position within its product.
+  const tierPriceForPosition = ( productName, position ) => {
+    const tiers = tiersByProduct[productName] || [];
+    if ( !tiers.length ) {
+      return 0;
+    }
+    for ( const t of tiers ) {
+      const [ min, max ] = String( t.storeRange || '' ).split( '-' ).map( Number );
+      if ( position >= min && position <= max ) {
+        return Number( t.negotiatePrice ) || 0;
       }
-
-      return {
-        ...item,
-        negotiatePrice: item.price,
-        perstorecost: ( ( item.price / currentMonthDays ) * item.workingdays ).toFixed( 2 ),
-      };
-    } );
+    }
+    // Beyond the last defined tier -> last tier's price.
+    return Number( tiers[tiers.length - 1].negotiatePrice ) || 0;
   };
-  console.log( '---->', data, pricing );
 
-
-  function processArray( array1, array2 ) {
-    let updatedArray = [];
-
-    // Step tiers apply CUMULATIVELY across every working-days bucket of a
-    // product, not per bucket. Track how many stores of each product have
-    // already been priced so each bucket continues where the previous one left
-    // off. (Previously the tier counter reset for every bucket, so e.g. the 9
-    // prorated stores — really stores 75-83, in the $40 tier — were each priced
-    // from tier 1 at $45, producing extra/wrong-priced line items.)
-    const assignedByProduct = {};
-
-    for ( let item of array1 ) {
-      let remainingStores = item.storeCount;
-      let assigned = assignedByProduct[item.productName] || 0;
-
-      for ( let range of array2 ) {
-        const [ min, max ] = range.storeRange.split( '-' ).map( Number );
-        if ( remainingStores <= 0 ) {
-          break;
-        }
-        // How many of this tier's slots are still free given everything already
-        // assigned to this product across previous buckets.
-        const tierCapacityLeft = max - Math.max( min - 1, assigned );
-        if ( tierCapacityLeft <= 0 ) {
-          continue;
-        }
-        const applicableStores = Math.min( remainingStores, tierCapacityLeft );
-        updatedArray.push( {
-          productName: item.productName,
-          workingdays: item.workingdays,
-          storeCount: applicableStores,
-          // Each tier is charged at its own range's negotiated price.
-          price: range.negotiatePrice,
-        } );
-        remainingStores -= applicableStores;
-        assigned += applicableStores;
+  // EXACT per-store pricing: assign each store a 1-based position within its
+  // product (tier boundary counted in STORES), then charge tierPrice x that
+  // store's EXACT billable units — cameras (perCamera) / zones (perZone) / 1
+  // (perStore) — prorated by working days. Group lines by product + period +
+  // tier price so each tier collapses into a single line item.
+  const productPosition = {};
+  const grouped = {};
+  for ( const s of perStoreRows ) {
+    const billingType = billingTypeMap[s.productName] || 'perStore';
+    let units = 1;
+    if ( s.productName === 'tangoZone' ) {
+      if ( billingType === 'perZone' && s.zoneCount > 0 ) {
+        units = s.zoneCount;
+      } else if ( billingType === 'perCamera' && s.zoneCameraCount > 0 ) {
+        units = s.zoneCameraCount;
       }
-
-      // Any stores beyond the last defined tier are charged at the last tier.
-      if ( remainingStores > 0 && array2.length ) {
-        updatedArray.push( {
-          productName: item.productName,
-          workingdays: item.workingdays,
-          storeCount: remainingStores,
-          price: array2[array2.length - 1].negotiatePrice,
-        } );
-        assigned += remainingStores;
-        remainingStores = 0;
+    } else if ( s.productName === 'tangoTraffic' ) {
+      if ( billingType === 'perCamera' && s.trafficCameraCount > 0 ) {
+        units = s.trafficCameraCount;
       }
-
-      assignedByProduct[item.productName] = assigned;
     }
-    return updatedArray;
+    productPosition[s.productName] = ( productPosition[s.productName] || 0 ) + 1;
+    const price = tierPriceForPosition( s.productName, productPosition[s.productName] );
+    const fullMonth = s.workingDays >= currentMonthDays;
+    const amount = fullMonth ?
+      Math.round( units * price * 100 ) / 100 :
+      Math.round( ( units * ( price / currentMonthDays ) * s.workingDays ) * 100 ) / 100;
+    const period = fullMonth ? 'fullMonth' : 'proRate';
+    const key = `${s.productName}_${period}_${price}`;
+    if ( !grouped[key] ) {
+      grouped[key] = { productName: s.productName, period, price, totalAmount: 0, unitCount: 0 };
+    }
+    grouped[key].totalAmount += amount;
+    grouped[key].unitCount += units;
   }
 
-  let resultarray = processArray( data, pricing );
-  console.log( '++++++++++++', resultarray );
-  const result = applyPricing( resultarray, pricing );
-  console.log( '***********', result );
-  // Group by product + period + PRICE TIER so each step tier is its own line
-  // item, and all stores within a tier+period collapse into a single line:
-  //   - full-month stores of a tier  -> one line (sum cost, sum count)
-  //   - prorated stores of a tier     -> one averaged line (sum cost, sum count)
-  // Keying on price (not storeCount) is what merges the leftover prorated stores
-  // — which span several working-days buckets — into one $40 line instead of one
-  // line per working-days value.
-  const groupedData = result.reduce( ( acc, item ) => {
-    const { productName, period, runningCost } = item;
-    const key = `${productName}_${period}_${item.price}`;
-    if ( !acc[key] ) {
-      acc[key] = {
-        productName,
-        period,
-        totalRunningCost: 0,
-        count: 0,
-      };
-    }
-    acc[key].totalRunningCost += parseFloat( runningCost );
-    acc[key].count += item.storeCount;
-    return acc;
-  }, {} );
-  console.log( groupedData );
-  // Calculating average running cost
-  const finalresult = Object.values( groupedData ).map( ( grp ) => {
+  const finalresult = Object.values( grouped ).map( ( grp ) => {
     let description = '';
     if ( grp.productName === 'tangoTraffic' ) {
       description = 'Customer Footfall Analytics';
     } else if ( grp.productName === 'tangoZone' ) {
       description = 'Product category/section analytics';
-    } else {
-      description = '';
     }
+    const amount = Math.round( grp.totalAmount * 100 ) / 100;
     return {
       productName: grp.productName,
       period: grp.period,
-      storeCount: grp.count,
+      // Quantity = billable units (cameras for perCamera, zones for perZone,
+      // stores otherwise). For full-month lines price = tier price; for prorated
+      // lines it's the effective per-unit cost (amount / units).
+      storeCount: Math.round( grp.unitCount * 100 ) / 100,
       description: description,
       HsnNumber: '998314',
-      amount: grp.totalRunningCost,
+      amount: amount,
       month: dayjs().format( 'MMM YYYY' ),
-      price: ( grp.totalRunningCost / grp.count ).toFixed( 2 ),
+      price: grp.unitCount ? ( amount / grp.unitCount ).toFixed( 2 ) : '0.00',
     };
   } );
 
-  // Combine overallStore and eachStore products
+  // Combine overallStore (per-store tiered) and eachStore products.
   return [ ...finalresult, ...eachStoreProducts ];
 }
 

package/src/controllers/paymentSubscription.controllers.js

@@ -1,6 +1,6 @@
 
 /* eslint-disable new-cap */
-import { logger, download, sendEmailWithSES, insertOpenSearchData, getOpenSearchData, updateOpenSearchData, getOpenSearchById } from 'tango-app-api-middleware';
+import { logger, download, sendEmailWithSES, insertOpenSearchData, getOpenSearchData, updateOpenSearchData, getOpenSearchById, fileUpload, customSignedUrl } from 'tango-app-api-middleware';
 import * as paymentService from '../services/clientPayment.services.js';
 import * as basePriceService from '../services/basePrice.service.js';
 import * as storeService from '../services/store.service.js';
@@ -2246,7 +2246,7 @@ export const invoiceList = async ( req, res ) => {
 
 export const priceList = async ( req, res ) => {
   try {
-    let pricingDetails = await basePricingService.findOne( { clientId: { $exists: true }, clientId: req.body.clientId }, { standard: 1, step: 1 } );
+    let pricingDetails = await basePricingService.findOne( { clientId: { $exists: true }, clientId: req.body.clientId }, { standard: 1, step: 1, oneTimeFeePerStore: 1 } );
     if ( !pricingDetails ) {
       return res.sendError( 'no data found', 204 );
     }
@@ -2301,19 +2301,25 @@ export const priceList = async ( req, res ) => {
               product.showImg = true;
               product.showEditDelete = true;
             }
-            product.storeCount = item.storeCount;
+            // Last tier absorbs whatever stores remain after the earlier tiers.
+            // Never let it go negative when the actual store count is smaller
+            // than the defined tier ranges (e.g. 83 stores across 1-50 / 51-100
+            // left the last tier at 83 - 100 = -17).
+            product.storeCount = Math.max( item.storeCount, 0 );
             product.lastIndex = true;
-          } else if ( index == 0 ) {
-            product.storeCount = 100;
-            item.storeCount = item.storeCount - 100;
           } else {
-            product.showImg = true;
-            let rangeArray = product.storeRange.split( '-' );
+            // Non-last tier: use its own range size (end - start + 1), but cap at
+            // the stores still remaining so a tier can't claim more stores than
+            // exist. The first tier previously hardcoded 100, which overcounted
+            // (and pushed the last tier negative) whenever the range wasn't 1-100.
+            product.showImg = index != 0;
+            let rangeArray = String( product.storeRange || '' ).split( '-' );
             let startNumber = parseInt( rangeArray[0] );
             let endNumber = parseInt( rangeArray[1] );
-            let diff = endNumber - startNumber + 1;
-            product.storeCount = diff;
-            item.storeCount = item.storeCount - diff;
+            let diff = ( endNumber - startNumber + 1 ) || 0;
+            let assigned = Math.max( Math.min( diff, item.storeCount ), 0 );
+            product.storeCount = assigned;
+            item.storeCount = item.storeCount - assigned;
           }
         }
         // let discountPrice = product.basePrice * ( product.discountPercentage / 100 );
@@ -2335,6 +2341,7 @@ export const priceList = async ( req, res ) => {
     let finalValue = parseFloat( discountTotalPrice ) + gstAmount;
     let result = {
       product: data,
+      oneTimeFeePerStore: pricingDetails.oneTimeFeePerStore != null ? pricingDetails.oneTimeFeePerStore : null,
       totalActualPrice: originalTotalPrice,
       totalNegotiatePrice: discountTotalPrice.toFixed( 2 ),
       actualPrice: totalProductPrice,
@@ -2484,6 +2491,11 @@ export const pricingListUpdate = async ( req, res ) => {
     } else {
       getPriceInfo.step = req.body.products;
     }
+    // Brand-level one-time fee per store. Only overwrite when the request
+    // actually carries a value so other save paths don't wipe it.
+    if ( req.body.oneTimeFeePerStore != null && req.body.oneTimeFeePerStore !== '' ) {
+      getPriceInfo.oneTimeFeePerStore = Number( req.body.oneTimeFeePerStore ) || 0;
+    }
     getPriceInfo.save().then( async () => {
       let clientDetails = await paymentService.findOne( { clientId: req.body.clientId }, { priceType: 1, paymentInvoice: 1, planDetails: 1 } );
       clientDetails.priceType = req.body.type;
@@ -4130,3 +4142,96 @@ export async function createDefaultbillings( req, res ) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Brand documents (Plans & Subscription > Documents accordion).
+// Upload a single PDF for a client, store it in the assets bucket under
+// <clientId>/documents/, and record { documentName, path } on the client's
+// additionalDocuments array. List returns the docs with signed URLs.
+// ---------------------------------------------------------------------------
+export async function uploadClientDocument( req, res ) {
+  try {
+    const clientId = String( req.body?.clientId || '' );
+    const documentName = String( req.body?.documentName || '' ).trim();
+    const expiryDateRaw = req.body?.expiryDate;
+    const file = req.file; // multer single('file')
+
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+    if ( !documentName ) {
+      return res.sendError( 'documentName is required', 400 );
+    }
+    if ( !file ) {
+      return res.sendError( 'file is required', 400 );
+    }
+    // PDF only.
+    if ( file.mimetype !== 'application/pdf' ) {
+      return res.sendError( 'Only PDF files are allowed', 400 );
+    }
+
+    const client = await paymentService.findOneClient( { clientId }, { clientId: 1 } );
+    if ( !client ) {
+      return res.sendError( 'Client not found', 404 );
+    }
+
+    const bucket = JSON.parse( process.env.BUCKET );
+    // Unique-ish file name so re-uploads with the same display name don't clash.
+    const safeName = documentName.replace( /[^a-zA-Z0-9-_]/g, '_' );
+    const fileName = `${safeName}_${Date.now()}.pdf`;
+    const key = `${clientId}/documents/`;
+
+    await fileUpload( {
+      Bucket: bucket.assets,
+      Key: key,
+      fileName: fileName,
+      ContentType: file.mimetype,
+      body: file.buffer,
+    } );
+
+    const storedPath = `${key}${fileName}`;
+    const expiryDate = expiryDateRaw ? new Date( expiryDateRaw ) : null;
+    await paymentService.pushAdditionalDocument( { clientId }, {
+      documentName: documentName,
+      path: storedPath,
+      expiryDate: ( expiryDate && !isNaN( expiryDate.getTime() ) ) ? expiryDate : null,
+      uploadedAt: new Date(),
+    } );
+
+    return res.sendSuccess( { documentName, path: storedPath, expiryDate } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'uploadClientDocument' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function getClientDocuments( req, res ) {
+  try {
+    const clientId = String( req.query?.clientId || req.params?.clientId || '' );
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+    const client = await paymentService.findOneClient( { clientId }, { additionalDocuments: 1 } );
+    const bucket = JSON.parse( process.env.BUCKET );
+    const docs = await Promise.all( ( client?.additionalDocuments || [] ).map( async ( d ) => {
+      let url = '';
+      try {
+        url = await customSignedUrl( { Bucket: bucket.assets, file_path: d.path }, 8 );
+      } catch ( e ) {
+        url = '';
+      }
+      return {
+        _id: d._id,
+        documentName: d.documentName,
+        path: d.path,
+        expiryDate: d.expiryDate,
+        uploadedAt: d.uploadedAt,
+        url,
+      };
+    } ) );
+    return res.sendSuccess( { documents: docs } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getClientDocuments' } );
+    return res.sendError( error, 500 );
+  }
+}
+

package/src/dtos/validation.dtos.js

@@ -153,6 +153,7 @@ export const validatePriceSchema = joi.object( {
   type: joi.string().optional(),
   clientId: joi.string().required(),
   products: joi.array().optional(),
+  oneTimeFeePerStore: joi.number().optional().allow( null, '' ),
   pricing: joi.array().items( joi.object( {
     productName: joi.string().required(),
     negotiatePrice: joi.number().required(),

package/src/routes/paymentSubscription.routes.js

@@ -1,11 +1,16 @@
 
 import express from 'express';
+import multer from 'multer';
 import * as paymentController from '../controllers/paymentSubscription.controllers.js';
 import { validate, isAllowedSessionHandler, accessVerification } from 'tango-app-api-middleware';
 import * as validationDtos from '../dtos/validation.dtos.js';
 import { validateClient } from '../utils/validations/client.validation.js';
 export const paymentSubscriptionRouter = express.Router();
 
+// PDF document upload (Plans & Subscription > Documents). In-memory storage,
+// 10MB cap; the controller streams the buffer to the assets S3 bucket.
+const documentUpload = multer( { storage: multer.memoryStorage(), limits: { fileSize: 10 * 1024 * 1024 } } );
+
 paymentSubscriptionRouter.post( '/addBilling', isAllowedSessionHandler, accessVerification( {
   userType: [ 'tango', 'client' ], access: [
     { featureName: 'Global', name: 'Subscription', permissions: [ 'isAdd' ] },
@@ -146,4 +151,8 @@ paymentSubscriptionRouter.put( '/pushNotification/update/:notificationId', isAll
 paymentSubscriptionRouter.post( '/updateRemind/:notificationId', isAllowedSessionHandler, validate( validationDtos.validateId ), paymentController.updateRemind );
 paymentSubscriptionRouter.post( '/createDefaultbillings', paymentController.createDefaultbillings );
 
+// Brand documents (Plans & Subscription > Documents accordion).
+paymentSubscriptionRouter.post( '/client-document/upload', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ], access: [ { featureName: 'Global', name: 'Subscription', permissions: [ 'isEdit' ] } ] } ), documentUpload.single( 'file' ), paymentController.uploadClientDocument );
+paymentSubscriptionRouter.get( '/client-document/list', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ], access: [ { featureName: 'Global', name: 'Subscription', permissions: [] } ] } ), paymentController.getClientDocuments );
+
 

package/src/services/clientPayment.services.js

@@ -16,6 +16,11 @@ export const updateOne = ( query = {}, record = {} ) => {
   return model.clientModel.updateOne( query, { $set: record } );
 };
 
+// Push a document into the client's additionalDocuments array.
+export const pushAdditionalDocument = ( query = {}, document = {} ) => {
+  return model.clientModel.updateOne( query, { $push: { additionalDocuments: document } } );
+};
+
 export const aggregate = ( query = [] ) => {
   return model.clientModel.aggregate( query );
 };