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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.5.15",
+    "version": "3.5.17",
     "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.35",
         "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,
     };
@@ -2237,3 +2270,330 @@ export async function additionalProducts( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+
+// POST a JSON payload to a Lambda Function URL and return the parsed JSON
+// (or false on failure). Node's fetch forbids a body on GET, so POST is used.
+async function lamdaServiceCall( url, data ) {
+  try {
+    const response = await fetch( url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify( data ),
+      signal: AbortSignal.timeout( 300000 ),
+    } );
+    if ( !response.ok ) {
+      throw new Error( `Response status: ${response.status}` );
+    }
+    return await response.json();
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'lamdaServiceCall' } );
+    return false;
+  }
+}
+
+// Unit price for a product from the latest billing_details OpenSearch record.
+// productName match is case-insensitive. Returns 0 if not found / unavailable.
+async function billingDetailsPrice( clientId, productName ) {
+  try {
+    const osRes = await getOpenSearchData( BILLING_DETAILS_INDEX, {
+      size: 1,
+      query: { term: { 'client_id': clientId } },
+      sort: [ { date_string: { order: 'desc' } } ],
+    } );
+    const hits = osRes?.body?.hits?.hits || osRes?.hits?.hits || [];
+    const match = ( hits[0]?._source?.products || [] )
+        .find( ( p ) => String( p.productName ).toLowerCase() === String( productName ).toLowerCase() );
+    return Number( match?.price ) || 0;
+  } catch ( osErr ) {
+    logger.error( { error: osErr, function: 'billingDetailsPrice', clientId, productName } );
+    return 0;
+  }
+}
+
+// Build the Lambda-backed export rows (VMS / Run AI / etc.). Calls the product's
+// Lambda for store_names (storeIds), maps them to the stores collection for
+// name + country (Zone), with current-month days and the billing_details price.
+async function lambdaStoreExport( clientId, lambdaUrl, billingProductName ) {
+  const toDate = dayjs().format( 'DD-MM-YYYY' );
+  const lambdaResult = await lamdaServiceCall( lambdaUrl, { to_date: toDate, client_id: clientId } );
+  console.log( '🚀 ~ lambdaStoreExport ~ lambdaResult:', lambdaResult );
+  // These Lambdas return the storeIds under either `store_ids` (Run AI) or
+  // `store_names` (VMS) with no status_code. Accept whichever is present; data
+  // availability = a non-empty array.
+  const rawIds = ( lambdaResult && Array.isArray( lambdaResult.store_ids ) ) ? lambdaResult.store_ids :
+    ( ( lambdaResult && Array.isArray( lambdaResult.store_names ) ) ? lambdaResult.store_names : [] );
+  const storeIds = rawIds.map( ( s ) => String( s ) );
+  if ( !storeIds.length ) {
+    return [];
+  }
+  const price = await billingDetailsPrice( clientId, billingProductName );
+  const daysInMonth = dayjs().daysInMonth();
+  const stores = await storeService.find(
+      { clientId: clientId, storeId: { $in: storeIds } },
+      { 'storeId': 1, 'storeName': 1, 'storeProfile.country': 1 },
+  );
+  const byId = new Map( stores.map( ( s ) => [ String( s.storeId ), s ] ) );
+  return storeIds.map( ( id ) => {
+    const s = byId.get( String( id ) );
+    return {
+      'Store Names': s?.storeName || id,
+      'No of Days to be billed': daysInMonth,
+      'Final Amount': price,
+      'Zone': s?.storeProfile?.country || '',
+    };
+  } );
+}
+
+// tangoTraffic working days per store, from the latest daily-pricing doc.
+// Map<storeId, workingdays>; stores with no tangoTraffic record are absent.
+async function tangoTrafficDaysByStore( clientId ) {
+  const rows = await dailyPriceService.aggregate( [
+    { $match: { clientId: clientId } },
+    { $sort: { dateISO: -1 } },
+    { $limit: 1 },
+    { $unwind: '$stores' },
+    { $unwind: '$stores.products' },
+    { $match: { 'stores.products.productName': 'tangoTraffic' } },
+    { $group: { _id: '$stores.storeId', days: { $max: '$stores.products.workingdays' } } },
+  ] );
+  const map = new Map();
+  for ( const r of rows ) {
+    map.set( String( r._id ), r.days || 0 );
+  }
+  return map;
+}
+
+// Per-product detailed Excel export for the Additional Products section.
+// product selected via req.body.product / req.query.product. Eyetest is the
+// first; more products plug into the switch as their queries arrive.
+export async function additionalProductExport( req, res ) {
+  try {
+    const clientId = String( req.body?.clientId ?? req.query?.clientId ?? '' );
+    const product = String( req.body?.product ?? req.query?.product ?? '' ).toLowerCase();
+    // Optional date (YYYY-MM-DD) passed from the UI; defaults to today. Used by
+    // products that report by a specific day (e.g. Remote Optum).
+    const reqDate = String( req.body?.date ?? req.query?.date ?? '' ) || dayjs().format( 'YYYY-MM-DD' );
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+
+    if ( product === 'eyetest' ) {
+      // Eye-test streams joined to their store, grouped per store to a stream
+      // count; enriched with store name, country (Zone) and the store's
+      // tangoTraffic working days (No of Days to be billed).
+      const streamRows = await cameraService.aggregate( [
+        { $match: { $and: [
+          { clientId: clientId },
+          { isEyeTestStream: true },
+          { qrCode: { $exists: true } },
+        ] } },
+        { $lookup: {
+          from: 'stores',
+          let: { storeId: '$storeId' },
+          pipeline: [ { $match: { $expr: { $and: [ { $eq: [ '$storeId', '$$storeId' ] } ] } } } ],
+          as: 'stores',
+        } },
+        { $unwind: { path: '$stores', preserveNullAndEmptyArrays: true } },
+        { $group: {
+          _id: '$storeId',
+          streamCount: { $sum: 1 },
+          storeName: { $first: '$stores.storeName' },
+          country: { $first: '$stores.storeProfile.country' },
+        } },
+        { $sort: { storeName: 1 } },
+      ] );
+
+      const daysMap = await tangoTrafficDaysByStore( clientId );
+      const price = ADDITIONAL_PRODUCT_PRICES.eyetest;
+      const exportData = streamRows.map( ( r ) => {
+        const streamCount = r.streamCount || 0;
+        const days = daysMap.get( String( r._id ) ) || 0;
+        // Amount = streams x price (no proration).
+        return {
+          'storeId': r._id,
+          'storeName': r.storeName || '',
+          'Stream Count': streamCount,
+          'No of Days to be billed': days,
+          'Amount': streamCount * price,
+          'Zone': r.country || '',
+        };
+      } );
+
+      if ( !exportData.length ) {
+        return res.sendError( 'No data', 204 );
+      }
+      await download( exportData, res );
+      return;
+    }
+
+    if ( product === 'planogram' ) {
+      // Unique storeName from the planograms collection, enriched with the
+      // store's country (Zone) and tangoTraffic working days. Amount is the
+      // flat planogram price per store.
+      const planoRows = await planogramService.aggregate( [
+        { $match: { clientId: clientId } },
+        { $group: { _id: '$storeName', storeId: { $first: '$storeId' } } },
+        { $lookup: {
+          from: 'stores',
+          let: { sid: '$storeId' },
+          pipeline: [ { $match: { $expr: { $eq: [ '$storeId', '$$sid' ] } } } ],
+          as: 'store',
+        } },
+        { $unwind: { path: '$store', preserveNullAndEmptyArrays: true } },
+        { $project: { _id: 0, storeName: '$_id', storeId: 1, country: '$store.storeProfile.country' } },
+        { $sort: { storeName: 1 } },
+      ] );
+
+      const price = ADDITIONAL_PRODUCT_PRICES.planogram;
+      // Planogram bills the full current month — every store shows the number of
+      // days in the current calendar month (not per-store working days).
+      const daysInMonth = dayjs().daysInMonth();
+      const exportData = planoRows.map( ( r ) => {
+        // Amount = flat planogram price per store (no proration).
+        return {
+          'storeName': r.storeName || '',
+          'No of Days to be billed': daysInMonth,
+          'Amount': price,
+          'Zone': r.country || '',
+        };
+      } );
+
+      if ( !exportData.length ) {
+        return res.sendError( 'No data', 204 );
+      }
+      await download( exportData, res );
+      return;
+    }
+
+    if ( product === 'aimanager' ) {
+      // AI Manager bills the same stores as tangoTraffic running > 1 day. One
+      // row per such store with its tangoTraffic working days (No of Days to be
+      // billed), the flat AI Manager price, and the store's country (Zone).
+      const aiRows = await dailyPriceService.aggregate( [
+        { $match: { clientId: clientId } },
+        { $sort: { dateISO: -1 } },
+        { $limit: 1 },
+        { $unwind: '$stores' },
+        { $unwind: '$stores.products' },
+        { $match: { 'stores.products.productName': 'tangoTraffic', 'stores.products.workingdays': { $gt: 1 } } },
+        { $group: {
+          _id: '$stores.storeId',
+          storeName: { $first: '$stores.storeName' },
+          days: { $max: '$stores.products.workingdays' },
+        } },
+        { $lookup: {
+          from: 'stores',
+          let: { sid: '$_id' },
+          pipeline: [ { $match: { $expr: { $eq: [ '$storeId', '$$sid' ] } } } ],
+          as: 'store',
+        } },
+        { $unwind: { path: '$store', preserveNullAndEmptyArrays: true } },
+        { $project: { _id: 0, storeId: '$_id', storeName: 1, days: 1, country: '$store.storeProfile.country' } },
+        { $sort: { storeName: 1 } },
+      ] );
+
+      const price = ADDITIONAL_PRODUCT_PRICES.aiManager;
+      const exportData = aiRows.map( ( r ) => {
+        // Amount = flat AI Manager price per store (no proration).
+        return {
+          'Store Name': r.storeName || '',
+          'No of Days to be billed': r.days || 0,
+          'Final Amount': price,
+          'Zone': r.country || '',
+        };
+      } );
+
+      if ( !exportData.length ) {
+        return res.sendError( 'No data', 204 );
+      }
+      await download( exportData, res );
+      return;
+    }
+
+    if ( product === 'vms' ) {
+      const exportData = await lambdaStoreExport(
+          clientId,
+          'https://ppf3l3mxc2lorh5hkrsj6zwyim0bupxw.lambda-url.ap-south-1.on.aws/',
+          'VMS',
+      );
+      if ( !exportData.length ) {
+        return res.sendError( 'No data', 204 );
+      }
+      await download( exportData, res );
+      return;
+    }
+
+    if ( product === 'runai' ) {
+      const exportData = await lambdaStoreExport(
+          clientId,
+          'https://mdm3mf7wuficgv3jjspkws2nu40azlsc.lambda-url.ap-south-1.on.aws/',
+          'Run AI',
+      );
+      console.log( '🚀 ~ additionalProductExport ~ exportData:', exportData );
+      if ( !exportData.length ) {
+        return res.sendError( 'No data', 204 );
+      }
+      await download( exportData, res );
+      return;
+    }
+
+    if ( product === 'remoteoptum' ) {
+      // Detailed optom-audit export from the remote_optom_steps_summary index
+      // for the given date (passed from the UI, defaults to today). Each record
+      // is one row; the nested `steps` object is flattened into TRUE/FALSE
+      // columns in a fixed (alphabetical) order.
+      const STEP_COLUMNS = [
+        'Adjust-Phoropter', 'DuoChrome-Test', 'Explanation', 'Final-Prescription',
+        'Handover', 'History-Taking', 'JCC', 'Near-Vision', 'Personal-Intro',
+        'Subjective-Refraction', 'Trial-Frame', 'VA-Check',
+      ];
+      let optomHits = [];
+      try {
+        const osRes = await getOpenSearchData( 'remote_optom_steps_summary', {
+          // A single day is well under the 10k window; pull up to the cap.
+          // NOTE: do NOT sort on StartTime — it's an analyzed text field, and
+          // sorting on it makes OpenSearch return ZERO hits. The day filter is
+          // enough; rows come back in index order.
+          size: 10000,
+          query: { term: { 'Date': reqDate } },
+        } );
+        optomHits = osRes?.body?.hits?.hits || osRes?.hits?.hits || [];
+      } catch ( osErr ) {
+        logger.error( { error: osErr, function: 'additionalProductExport.remoteOptum', clientId } );
+        return res.sendError( 'Failed to fetch Remote Optum data', 502 );
+      }
+
+      const exportData = optomHits.map( ( h ) => {
+        const s = h._source || {};
+        const steps = s.steps || {};
+        const row = {
+          'storeName': s.storeName || '',
+          'engagementId': s.engagementId || '',
+          'queue_id': s.queue_id || '',
+          'optm_name': s.optm_name || '',
+          'optm_id': s.optm_id || '',
+          'optm_Emailid': s.optm_Emailid || '',
+          'Date': s.Date || '',
+          'StartTime': s.StartTime || '',
+          'EndTime': s.EndTime || '',
+          'Duration (min)': s['Duration (min)'] != null ? s['Duration (min)'] : '',
+        };
+        for ( const col of STEP_COLUMNS ) {
+          row[col] = steps[col] === true ? 'TRUE' : 'FALSE';
+        }
+        return row;
+      } );
+
+      if ( !exportData.length ) {
+        return res.sendError( 'No data', 204 );
+      }
+      await download( exportData, res );
+      return;
+    }
+
+    return res.sendError( `Unsupported product: ${product}`, 400 );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'additionalProductExport' } );
+    return res.sendError( error, 500 );
+  }
+}