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

package/src/controllers/billing.controllers.js

@@ -4,6 +4,7 @@ import * as invoice from '../services/invoice.service.js';
 import { aggregatebilling, countDocuments, create, deleteOne, find, findOne, updateMany, updateOne } from '../services/billing.service.js';
 import * as invoiceService from '../services/invoice.service.js';
 import mongoose from 'mongoose';
+import axios from 'axios';
 import dayjs from 'dayjs';
 import { leadGet } from '../services/lead.service.js';
 import { findOneClient } from '../services/clientPayment.services.js';
@@ -577,7 +578,6 @@ export const getInvoices = async ( req, res ) => {
       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?.searchValue ) {
       matchStage.$match['$and'] = [
         { billingDate: { $gte: filterStartDate } },
@@ -868,4 +868,145 @@ export async function getClientProducts( req, res ) {
   }
 }
 
+// GSTIN address lookup via Sheet GST Check
+// (https://sheet.gstincheck.co.in). Returns the registered company name
+// + principal place of business address so the UI can auto-fill the
+// billing-group form.
+//
+// Requires GST_LOOKUP_API_KEY in the API environment. The key is embedded
+// in the provider's URL path (their auth scheme); we never log it.
+//
+// Caller validates GSTIN format (15 chars, alphanumeric). Server-side we
+// re-check before forwarding to the provider.
+export async function gstinLookup( req, res ) {
+  try {
+    const gstin = String( req.params.gstin || '' ).trim().toUpperCase();
+    if ( !/^[0-9A-Z]{15}$/.test( gstin ) ) {
+      return res.sendError( 'Invalid GSTIN format', 400 );
+    }
+
+    // GSTIN state-code prefix → State + Place of Supply (matches the
+    // table the frontend already maintains).
+    const stateMap = {
+      '01': 'Jammu and Kashmir', '02': 'Himachal Pradesh', '03': 'Punjab',
+      '04': 'Chandigarh', '05': 'Uttarakhand', '06': 'Haryana', '07': 'Delhi',
+      '08': 'Rajasthan', '09': 'Uttar Pradesh', '10': 'Bihar', '11': 'Sikkim',
+      '12': 'Arunachal Pradesh', '13': 'Nagaland', '14': 'Manipur',
+      '15': 'Mizoram', '16': 'Tripura', '17': 'Meghalaya', '18': 'Assam',
+      '19': 'West Bengal', '20': 'Jharkhand', '21': 'Odisha',
+      '22': 'Chhattisgarh', '23': 'Madhya Pradesh', '24': 'Gujarat',
+      '25': 'Daman and Diu', '27': 'Maharashtra', '29': 'Karnataka',
+      '30': 'Goa', '32': 'Kerala', '33': 'Tamil Nadu', '34': 'Puducherry',
+      '36': 'Telangana', '37': 'Andhra Pradesh',
+    };
+    const code = gstin.substring( 0, 2 );
+    const stateName = stateMap[code];
+    if ( !stateName ) {
+      return res.sendError( 'Unknown state code in GSTIN', 404 );
+    }
+
+    // Real lookup via Sheet GST Check (https://gstincheck.co.in/).
+    // Endpoint: GET https://sheet.gstincheck.co.in/check/{API_KEY}/{GSTIN}
+    // Auth: API key embedded in the URL path (no header). Set
+    // GST_LOOKUP_API_KEY in the API's environment.
+    const apiKey = process.env.GST_LOOKUP_API_KEY;
+    console.log( '🚀 ~ gstinLookup ~ apiKey:', apiKey );
+    if ( !apiKey ) {
+      // Fail explicitly rather than silently fall back — that way a missing
+      // key shows up immediately instead of mock data leaking into prod.
+      logger.error( { function: 'gstinLookup', message: 'GST_LOOKUP_API_KEY not set' } );
+      return res.sendError( 'GST lookup is not configured on the server', 500 );
+    }
+
+    let providerResponse;
+    try {
+      providerResponse = await axios.get(
+          `https://sheet.gstincheck.co.in/check/${encodeURIComponent( apiKey )}/${encodeURIComponent( gstin )}`,
+          { timeout: 8000 },
+      );
+    } catch ( axiosErr ) {
+      // Distinguish provider-down vs other errors so the client can show a
+      // useful message. 4xx from the provider is treated as a real error;
+      // network errors fall through to a generic 502.
+      const status = axiosErr?.response?.status;
+      logger.error( { error: axiosErr?.message, status, function: 'gstinLookup.provider', gstin } );
+      if ( status === 404 ) {
+        return res.sendError( 'GSTIN not found', 404 );
+      }
+      return res.sendError( 'GST lookup service unavailable', 502 );
+    }
+
+    const body = providerResponse?.data || {};
+    if ( !body.flag || !body.data ) {
+      // Provider reached but couldn't resolve this GSTIN.
+      return res.sendError( 'GSTIN not found', 404 );
+    }
+
+    // Map provider's response shape into the contract the frontend expects.
+    // Provider uses Indian-government short names (lgnm, tradeNam, pradr,
+    // sts, etc.); we normalize to our flat structure.
+    const src = body.data;
+    // TEMP: full raw response logged so we can confirm field names per
+    // GSTIN — remove once the mapping is verified across a few real cases.
+    logger.error( { function: 'gstinLookup.raw', gstin, providerData: src } );
+
+    const principal = src.pradr || src.pradr1 || {};
+    // The provider has used both `addr` (newer) and a flatter form
+    // (older). Coalesce — `addr` if present, otherwise the principal
+    // itself contains the address fields.
+    const addr = principal.addr || principal || {};
+
+    // If the provider returned a fully-formed display address string, use
+    // it directly for addressLineOne — that's the canonical comma-joined
+    // address GSTN itself displays. Otherwise build it from the
+    // individual fields. This avoids re-joining in a different order than
+    // the registry intended.
+    const fullAddr = ( principal.adr || principal.address || src.adr || '' ).trim();
+
+    let addressLineOne;
+    let addressLineTwo;
+    if ( fullAddr ) {
+      // The registry format is `bno, bnm, flno, st, loc, lndmrk, city,
+      // dst, stcd, pncd`. Split on commas, take the first half for line 1
+      // and the rest (minus city/state/pincode tail which goes to the
+      // separate fields) for line 2. Heuristic: split into two halves.
+      const parts = fullAddr.split( ',' ).map( ( s ) => s.trim() ).filter( Boolean );
+      const half = Math.ceil( parts.length / 2 );
+      addressLineOne = parts.slice( 0, half ).join( ', ' );
+      addressLineTwo = parts.slice( half ).join( ', ' );
+    } else {
+      const line1Parts = [ addr.bno, addr.bnm, addr.flno, addr.st ].filter( ( p ) => p && String( p ).trim() );
+      const line2Parts = [ addr.loc, addr.lndmrk, addr.dst ].filter( ( p ) => p && String( p ).trim() );
+      addressLineOne = line1Parts.join( ', ' );
+      addressLineTwo = line2Parts.join( ', ' );
+    }
+
+    // City: prefer explicit `city` / `dst`. Some records put the city
+    // name in `loc` and the colony / sub-area in `dst` — prefer city, but
+    // fall back to dst then loc when missing.
+    const cityValue = addr.city || addr.dst || addr.loc || '';
+
+    const data = {
+      gstin: src.gstin || gstin,
+      legalName: src.lgnm || src.legalName || '',
+      tradeName: src.tradeNam || src.tradeName || '',
+      addressLineOne,
+      addressLineTwo,
+      city: cityValue,
+      // Prefer provider's state name; fall back to our state-code map so a
+      // missing field doesn't blank out the Place of Supply.
+      state: addr.stcd || addr.state || stateName,
+      country: 'India',
+      pinCode: addr.pncd ? String( addr.pncd ) : ( addr.pincode ? String( addr.pincode ) : '' ),
+      placeOfSupply: `${addr.stcd || addr.state || stateName} (${code})`,
+      status: src.sts || '',
+    };
+
+    return res.sendSuccess( data );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'gstinLookup' } );
+    return res.sendError( error, 500 );
+  }
+}
+
 

package/src/controllers/brandsBilling.controller.js

@@ -3,6 +3,8 @@ import * as invoiceService from '../services/invoice.service.js';
 import * as billingService from '../services/billing.service.js';
 import * as dailyPriceService from '../services/dailyPrice.service.js';
 import * as storeService from '../services/store.service.js';
+import * as assignedStoreService from '../services/assignedStore.service.js';
+import * as basePriceService from '../services/basePrice.service.js';
 import dayjs from 'dayjs';
 import { logger, checkFileExist, signedUrl, download, insertOpenSearchData } from 'tango-app-api-middleware';
 import * as XLSX from 'xlsx';
@@ -339,6 +341,7 @@ export async function brandInvoiceList( req, res ) {
             totalAmount: 1,
             status: 1,
             paymentStatus: 1,
+            paidAmount: { $ifNull: [ '$paidAmount', 0 ] },
             clientId: 1,
             currency: 1,
             dueDate: 1,
@@ -1289,3 +1292,290 @@ export async function bulkUpdateBillingGroups( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+
+// ---------------------------------------------------------------------------
+// Billing Summary (landing tab): one row per client — monthly store counts,
+// revenue, price-per-store and installation fee all from the invoice
+// collection (the billed `stores` count per invoice), products + status from
+// clients, CSM from userAssignedStore. Window: last 5 calendar months
+// including the current. Filtering/sorting happen client-side (the dataset
+// is one row per client).
+// ---------------------------------------------------------------------------
+// Today's USD->INR rate for dollar-priced clients. Live rate (cached 6h)
+// with an env override (USD_INR_RATE) and a last-known/static fallback so
+// the summary never fails because a rate API is down.
+let usdRateCache = { rate: null, at: 0 };
+async function getUsdInrRate() {
+  const override = Number( process.env.USD_INR_RATE );
+  if ( override > 0 ) {
+    return override;
+  }
+  if ( usdRateCache.rate && ( Date.now() - usdRateCache.at ) < 6 * 60 * 60 * 1000 ) {
+    return usdRateCache.rate;
+  }
+  try {
+    const resp = await fetch( 'https://open.er-api.com/v6/latest/USD', { signal: AbortSignal.timeout( 4000 ) } );
+    const body = await resp.json();
+    const rate = Number( body?.rates?.INR );
+    if ( rate > 0 ) {
+      usdRateCache = { rate, at: Date.now() };
+      return rate;
+    }
+  } catch ( err ) {
+    logger.error( { error: err, function: 'getUsdInrRate' } );
+  }
+  return usdRateCache.rate || 83.33;
+}
+
+export async function billingSummary( req, res ) {
+  try {
+    const now = dayjs();
+    const months = [];
+    for ( let i = 4; i >= 0; i-- ) {
+      const m = now.subtract( i, 'month' );
+      months.push( { key: m.format( 'YYYY-MM' ), label: m.format( 'MMM-YY' ) } );
+    }
+    const windowStart = new Date( now.subtract( 4, 'month' ).startOf( 'month' ).toISOString() );
+
+    // Revenue (excl. GST), billed stores and installation fees per client per
+    // month. billingDate is a string on some legacy rows — coerce first.
+    const invoices = await invoiceService.aggregate( [
+      { $addFields: { billingDateD: { $cond: [
+        { $eq: [ { $type: '$billingDate' }, 'date' ] },
+        '$billingDate',
+        { $toDate: '$billingDate' },
+      ] } } },
+      { $match: { billingDateD: { $gte: windowStart } } },
+      { $project: {
+        clientId: 1,
+        companyName: 1,
+        amount: { $ifNull: [ '$amount', 0 ] },
+        stores: { $ifNull: [ '$stores', 0 ] },
+        isDollar: { $eq: [ '$currency', 'dollar' ] },
+        ym: { $dateToString: { format: '%Y-%m', date: '$billingDateD' } },
+        installation: { $sum: { $map: {
+          input: { $filter: {
+            input: { $ifNull: [ '$products', [] ] },
+            cond: { $eq: [ '$$this.productName', 'installationFee' ] },
+          } },
+          in: { $ifNull: [ '$$this.amount', 0 ] },
+        } } },
+      } },
+      // Dollar invoices are summed separately so they can be converted to
+      // INR at today's rate when the months are merged below.
+      { $group: {
+        _id: { c: '$clientId', ym: '$ym' },
+        revenueInr: { $sum: { $cond: [ '$isDollar', 0, '$amount' ] } },
+        revenueUsd: { $sum: { $cond: [ '$isDollar', '$amount', 0 ] } },
+        stores: { $sum: '$stores' },
+        installationInr: { $sum: { $cond: [ '$isDollar', 0, '$installation' ] } },
+        installationUsd: { $sum: { $cond: [ '$isDollar', '$installation', 0 ] } },
+        companyName: { $last: '$companyName' },
+      } },
+    ] );
+
+    const clients = await clientService.find( {}, {
+      'clientId': 1,
+      'clientName': 1,
+      'planDetails.product.productName': 1,
+      'planDetails.product.status': 1,
+      'paymentInvoice.currencyType': 1,
+    } );
+    const clientById = new Map( clients.map( ( c ) => [ String( c.clientId ), c ] ) );
+
+    // Per-client CSM (userAssignedStore, tangoUserType 'csm'); display the
+    // email's local part since the collection carries no display name.
+    const usdRate = await getUsdInrRate();
+
+    // Current month's store count comes from dailyPricing (latest reading
+    // this month) — invoices for the running month usually don't exist yet.
+    const curMonthStart = new Date( now.startOf( 'month' ).toISOString() );
+    const latestDp = await dailyPriceService.aggregate( [
+      { $match: { dateISO: { $gte: curMonthStart } } },
+      { $project: { clientId: 1, activeStores: 1, dateISO: 1 } },
+      { $sort: { dateISO: 1 } },
+      { $group: { _id: '$clientId', stores: { $last: '$activeStores' } } },
+    ] );
+    const curStoresByClient = new Map( latestDp.map( ( d ) => [ String( d._id ), d.stores || 0 ] ) );
+
+    // Negotiated price per store from the basepricing collection — standard
+    // rows sum across products; step rows are resolved by store-count range.
+    const pricingDocs = await basePriceService.find(
+        { clientId: { $exists: true, $nin: [ '', null ] } },
+        { clientId: 1, standard: 1, step: 1 },
+    );
+    const pricingByClient = new Map( pricingDocs.map( ( d ) => [ String( d.clientId ), d ] ) );
+    const rangeContains = ( rangeStr, count ) => {
+      const s = String( rangeStr || '' );
+      const between = s.match( /(\d+)\s*-\s*(\d+)/ );
+      if ( between ) {
+        return count >= Number( between[1] ) && count <= Number( between[2] );
+      }
+      const plus = s.match( /(\d+)\s*\+/ );
+      if ( plus ) {
+        return count >= Number( plus[1] );
+      }
+      return false;
+    };
+
+    const csms = await assignedStoreService.find( { tangoUserType: 'csm' }, { clientId: 1, userEmail: 1 } );
+    const csmByClient = new Map();
+    for ( const a of csms ) {
+      const key = String( a.clientId ?? '' );
+      const name = String( a.userEmail || '' ).split( '@' )[0];
+      if ( !name ) {
+        continue;
+      }
+      const pretty = name.charAt( 0 ).toUpperCase() + name.slice( 1 );
+      if ( !csmByClient.has( key ) ) {
+        csmByClient.set( key, new Set() );
+      }
+      csmByClient.get( key ).add( pretty );
+    }
+
+    // Merge — a client appears when it has billed invoices in the window.
+    const rows = new Map();
+    const rowOf = ( clientId ) => {
+      const key = String( clientId ?? '' );
+      if ( !rows.has( key ) ) {
+        const c = clientById.get( key );
+        const products = ( c?.planDetails?.product || [] );
+        rows.set( key, {
+          clientId: key,
+          clientName: c?.clientName || '',
+          registeredEntity: '',
+          status: products.length && products.every( ( p ) => p.status === 'trial' ) ? 'Trial' : 'Paid',
+          products: [ ...new Set( products.map( ( p ) => String( p.productName || '' )
+              .replace( /^tango/i, '' ).replace( /^./, ( ch ) => ch.toUpperCase() ) ).filter( Boolean ) ) ],
+          // Price/Store only counts products the client actually subscribes
+          // to (status 'live') — trials are excluded.
+          liveProductSet: new Set( products.filter( ( p ) => p.status === 'live' )
+              .map( ( p ) => String( p.productName || '' ).toLowerCase() ) ),
+          currency: c?.paymentInvoice?.currencyType === 'dollar' ? 'dollar' : 'inr',
+          csm: [ ...( csmByClient.get( key ) || [] ) ].join( ', ' ),
+          revenueMonths: {},
+          billedStoresMonths: {},
+          installationFee: 0,
+        } );
+      }
+      return rows.get( key );
+    };
+
+    for ( const inv of invoices ) {
+      const r = rowOf( inv._id.c );
+      r.revenueMonths[inv._id.ym] = Math.round( ( ( inv.revenueInr || 0 ) + ( inv.revenueUsd || 0 ) * usdRate ) * 100 ) / 100;
+      r.billedStoresMonths[inv._id.ym] = inv.stores || 0;
+      r.installationFee += ( inv.installationInr || 0 ) + ( inv.installationUsd || 0 ) * usdRate;
+      if ( inv.companyName ) {
+        r.registeredEntity = inv.companyName;
+      }
+    }
+
+    const curKey = months[4].key;
+    const prevKey = months[3].key;
+    const data = [ ...rows.values() ].map( ( r ) => {
+      const revPrev = r.revenueMonths[prevKey] ?? null;
+      // Price per store from the basepricing collection (negotiated price,
+      // base price fallback). Step pricing picks the row whose store-count
+      // range covers the latest billed store count. Clients without a
+      // basepricing doc fall back to revenue / stores so the column never
+      // lies silently.
+      let latestStores = curStoresByClient.get( r.clientId ) ?? null;
+      if ( latestStores == null ) {
+        for ( let i = months.length - 1; i >= 0; i-- ) {
+          if ( r.billedStoresMonths[months[i].key] ) {
+            latestStores = r.billedStoresMonths[months[i].key];
+            break;
+          }
+        }
+      }
+      let pricePerStore = null;
+      const pdoc = pricingByClient.get( r.clientId );
+      const isLive = ( name ) => r.liveProductSet.has( String( name || '' ).toLowerCase() );
+      if ( pdoc?.standard?.length ) {
+        const liveRows = pdoc.standard.filter( ( p ) => isLive( p.productName ) );
+        pricePerStore = liveRows.length ?
+          liveRows.reduce( ( a, p ) => a + ( Number( p.negotiatePrice ) || Number( p.basePrice ) || 0 ), 0 ) :
+          null;
+      } else if ( pdoc?.step?.length ) {
+        const byProduct = new Map();
+        for ( const p of pdoc.step ) {
+          if ( !isLive( p.productName ) ) {
+            continue;
+          }
+          const key = p.productName || '';
+          if ( !byProduct.has( key ) ) {
+            byProduct.set( key, [] );
+          }
+          byProduct.get( key ).push( p );
+        }
+        let sum = 0;
+        for ( const list of byProduct.values() ) {
+          const hit = ( latestStores != null && list.find( ( x ) => rangeContains( x.storeRange, latestStores ) ) ) || list[0];
+          sum += Number( hit?.negotiatePrice ) || Number( hit?.basePrice ) || 0;
+        }
+        pricePerStore = sum || null;
+      }
+      if ( pricePerStore == null ) {
+        for ( let i = months.length - 1; i >= 0; i-- ) {
+          const k = months[i].key;
+          if ( r.revenueMonths[k] && r.billedStoresMonths[k] ) {
+            // revenueMonths is INR — divide back for dollar clients so the
+            // fallback price stays in their native currency.
+            pricePerStore = r.revenueMonths[k] / r.billedStoresMonths[k] / ( r.currency === 'dollar' ? usdRate : 1 );
+            break;
+          }
+        }
+      }
+      pricePerStore = pricePerStore == null ? null : Math.round( pricePerStore );
+      // Current month's revenue: the invoice amount once generated; until
+      // then an estimate of live store count x price per store.
+      let revCur = r.revenueMonths[curKey] ?? null;
+      let revCurEstimated = false;
+      if ( revCur == null ) {
+        const curStores = curStoresByClient.get( r.clientId );
+        if ( curStores && pricePerStore != null ) {
+          // Dollar clients carry a USD per-store price — convert the
+          // projection to INR at today's rate.
+          revCur = curStores * pricePerStore * ( r.currency === 'dollar' ? usdRate : 1 );
+          revCurEstimated = true;
+        }
+      }
+      let variance = null;
+      if ( revCur != null && revPrev != null && revPrev > 0 ) {
+        variance = Math.round( ( revCur - revPrev ) / revPrev * 100 );
+      } else if ( revCur == null && revPrev != null ) {
+        variance = -100;
+      }
+      // All revenue figures are already INR (dollar invoices converted at
+      // aggregation time; the estimate converted above). Price/Store stays
+      // in native USD for dollar clients.
+      revCur = revCur == null ? null : Math.round( revCur );
+      const revPrevOut = revPrev == null ? null : Math.round( revPrev );
+      const installationOut = r.installationFee ? Math.round( r.installationFee ) : null;
+      return {
+        clientId: r.clientId,
+        clientName: r.clientName || r.registeredEntity || r.clientId,
+        registeredEntity: r.registeredEntity,
+        status: r.status,
+        products: r.products,
+        csm: r.csm,
+        currency: r.currency,
+        stores: months.map( ( m, i ) => i === months.length - 1 ?
+          ( curStoresByClient.get( r.clientId ) ?? r.billedStoresMonths[m.key] ?? null ) :
+          ( r.billedStoresMonths[m.key] ?? null ) ),
+        pricePerStore,
+        revPrev: revPrevOut,
+        revCur,
+        revCurEstimated,
+        variance,
+        installationFee: installationOut,
+      };
+    } ).sort( ( a, b ) => ( b.revCur || 0 ) - ( a.revCur || 0 ) );
+
+    return res.sendSuccess( { months, data, usdRate } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'billingSummary' } );
+    return res.sendError( error, 500 );
+  }
+}