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

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';
@@ -1290,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 );
+  }
+}

package/src/controllers/estimate.controller.js

@@ -0,0 +1,317 @@
+import * as estimateService from '../services/estimate.service.js';
+import * as clientService from '../services/clientPayment.services.js';
+import dayjs from 'dayjs';
+import { logger, download } from 'tango-app-api-middleware';
+import Handlebars from '../utils/validations/helper/handlebar.helper.js';
+import fs from 'fs';
+import path from 'path';
+import htmlpdf from 'html-pdf-node';
+import { symbolFor } from '../utils/currency.js';
+
+// ---------------------------------------------------------------------------
+// Estimates (quotations). A lightweight pre-invoice document with its own
+// lifecycle (draft → sent → accepted/declined/expired). Stored in the
+// `estimates` collection. Per-brand (clientId) listing for the Estimate tab.
+// ---------------------------------------------------------------------------
+
+function getCurrentFinancialYear() {
+  const today = new Date();
+  const month = today.getMonth();
+  const year = today.getFullYear();
+  if ( month >= 3 ) {
+    return year.toString().slice( -2 ) + '-' + ( year + 1 ).toString().slice( -2 );
+  }
+  return ( ( year - 1 ).toString().slice( -2 ) ) + '-' + year.toString().slice( -2 );
+}
+
+// Next EST-<FY>-<index> for the current financial year.
+async function nextEstimateNumber() {
+  const fy = getCurrentFinancialYear();
+  const previous = await estimateService.aggregate( [
+    { $match: { estimate: { $regex: `^EST-${fy}-` } } },
+    { $sort: { estimateIndex: -1 } },
+    { $limit: 1 },
+  ] );
+  const index = previous.length ? Number( previous[0].estimateIndex ) + 1 : 1;
+  return {
+    estimate: `EST-${fy}-${String( index ).padStart( 5, '0' )}`,
+    estimateIndex: index,
+  };
+}
+
+// Expire stale estimates lazily on read: anything sent/draft past validTill
+// flips to 'expired' so the list reflects reality without a cron.
+async function expireOverdue( clientId ) {
+  await estimateService.updateOne(
+      { clientId, status: { $in: [ 'draft', 'sent' ] }, validTill: { $lt: new Date() } },
+      { $set: { status: 'expired' } },
+  );
+}
+
+export async function estimateList( req, res ) {
+  try {
+    const clientId = req.body?.clientId;
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+    await expireOverdue( clientId );
+
+    const match = { clientId };
+    if ( req.body?.status && req.body.status !== 'All' ) {
+      match.status = req.body.status;
+    }
+
+    // Optional month / year filter on the estimate period (stored as a
+    // "MMM YYYY" string; createdDate is the reliable date to range on).
+    if ( req.body?.fromDate || req.body?.toDate ) {
+      match.createdDate = {};
+      if ( req.body.fromDate ) {
+        match.createdDate.$gte = new Date( dayjs( req.body.fromDate ).startOf( 'day' ).toISOString() );
+      }
+      if ( req.body.toDate ) {
+        match.createdDate.$lte = new Date( dayjs( req.body.toDate ).endOf( 'day' ).toISOString() );
+      }
+    }
+
+    if ( req.body?.searchValue ) {
+      match.$or = [
+        { estimate: { $regex: req.body.searchValue, $options: 'i' } },
+        { groupName: { $regex: req.body.searchValue, $options: 'i' } },
+        { period: { $regex: req.body.searchValue, $options: 'i' } },
+      ];
+    }
+
+    const query = [
+      { $match: match },
+      { $sort: { [req.body?.sortColumName || 'createdDate']: req.body?.sortBy === 1 ? 1 : -1, _id: -1 } },
+    ];
+
+    const countResult = await estimateService.aggregate( [ ...query, { $count: 'n' } ] );
+    const count = countResult[0]?.n || 0;
+
+    if ( req.body?.export ) {
+      const all = await estimateService.aggregate( query );
+      const rows = all.map( ( e ) => ( {
+        'Estimate #': e.estimate,
+        'Billing Group': e.groupName || '',
+        'Period': e.period || '',
+        'Generated': e.createdDate ? dayjs( e.createdDate ).format( 'DD MMM YYYY' ) : '',
+        'Valid Till': e.validTill ? dayjs( e.validTill ).format( 'DD MMM YYYY' ) : '',
+        'No of Stores': e.stores || 0,
+        'Amount (excl. GST)': e.amount || 0,
+        'Amount (incl. GST)': e.totalAmount || 0,
+        'Status': e.status,
+      } ) );
+      await download( rows, res );
+      return;
+    }
+
+    if ( req.body?.limit && req.body?.offset ) {
+      query.push(
+          { $skip: ( req.body.offset - 1 ) * req.body.limit },
+          { $limit: Number( req.body.limit ) },
+      );
+    }
+    const data = await estimateService.aggregate( query );
+
+    // Status counts over the brand's whole estimate set (filter-stable).
+    const statusAgg = await estimateService.aggregate( [
+      { $match: { clientId } },
+      { $group: { _id: '$status', count: { $sum: 1 } } },
+    ] );
+    const counts = { draft: 0, sent: 0, accepted: 0, declined: 0, expired: 0, total: 0 };
+    statusAgg.forEach( ( s ) => {
+      if ( counts[s._id] != null ) {
+        counts[s._id] = s.count;
+      }
+      counts.total += s.count;
+    } );
+
+    return res.sendSuccess( { count, data, counts } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'estimateList' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function createEstimate( req, res ) {
+  try {
+    const b = req.body || {};
+    if ( !b.clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+
+    const client = await clientService.findOne(
+        { clientId: b.clientId },
+        { 'clientName': 1, 'paymentInvoice.currencyType': 1 },
+    );
+
+    const amount = Math.round( Number( b.amount ) || 0 );
+    let totalAmount = Math.round( Number( b.totalAmount ) || 0 );
+    if ( !totalAmount && amount ) {
+      // Default to 18% GST when caller sends only the pre-tax amount.
+      totalAmount = Math.round( amount * 1.18 );
+    }
+
+    const { estimate, estimateIndex } = await nextEstimateNumber();
+    const createdDate = b.createdDate ? new Date( b.createdDate ) : new Date();
+    // Estimates are valid for 14 days unless an explicit date is supplied.
+    const validTill = b.validTill ? new Date( b.validTill ) : dayjs( createdDate ).add( 14, 'days' ).toDate();
+
+    const doc = {
+      clientId: b.clientId,
+      estimate,
+      estimateIndex,
+      companyName: b.companyName || client?.clientName || '',
+      companyAddress: b.companyAddress || '',
+      PlaceOfSupply: b.PlaceOfSupply || '',
+      GSTNumber: b.GSTNumber || '',
+      groupId: b.groupId || undefined,
+      groupName: b.groupName || 'Default Group',
+      period: b.period || dayjs( createdDate ).format( 'MMM YYYY' ),
+      stores: Number( b.stores ) || 0,
+      products: Array.isArray( b.products ) ? b.products : [],
+      tax: Array.isArray( b.tax ) ? b.tax : [],
+      amount,
+      totalAmount,
+      currency: b.currency || ( client?.paymentInvoice?.currencyType === 'dollar' ? 'dollar' : 'inr' ),
+      status: b.status === 'sent' ? 'sent' : 'draft',
+      createdDate,
+      validTill,
+      createdBy: req.user?.email || req.user?.userName || '',
+      notes: b.notes || '',
+    };
+
+    const created = await estimateService.create( doc );
+    logger.info?.( { function: 'createEstimate', estimate, clientId: b.clientId } );
+    return res.sendSuccess( created );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'createEstimate' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function getEstimate( req, res ) {
+  try {
+    const estimate = await estimateService.findOne( { _id: req.params.estimateId } );
+    if ( !estimate ) {
+      return res.sendError( 'Estimate not found', 404 );
+    }
+    return res.sendSuccess( estimate );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getEstimate' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function estimateStatusUpdate( req, res ) {
+  try {
+    const { estimateId, status } = req.body || {};
+    const allowed = [ 'draft', 'sent', 'accepted', 'declined', 'expired' ];
+    if ( !estimateId || !allowed.includes( status ) ) {
+      return res.sendError( 'estimateId and a valid status are required', 400 );
+    }
+    const result = await estimateService.updateOne( { _id: estimateId }, { $set: { status } } );
+    if ( !result?.matchedCount ) {
+      return res.sendError( 'Estimate not found', 404 );
+    }
+    return res.sendSuccess( { status } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'estimateStatusUpdate' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+// Renders the estimate to a PDF and streams it back. Mirrors the invoice PDF
+// flow (Handlebars template + html-pdf-node) but uses the estimate template.
+export async function downloadEstimate( req, res ) {
+  try {
+    const estimate = await estimateService.findOne( { _id: req.params.estimateId } );
+    if ( !estimate ) {
+      return res.sendError( 'Estimate not found', 404 );
+    }
+    const e = estimate._doc || estimate;
+    const currencyType = symbolFor( e.currency );
+    const fmt = ( n ) => Number( n || 0 ).toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } );
+
+    const products = ( e.products || [] ).map( ( p, i ) => {
+      let name = String( p.productName || '' ).replace( /([a-z])([A-Z])/g, '$1 $2' );
+      name = name.charAt( 0 ).toUpperCase() + name.slice( 1 );
+      return {
+        index: i + 1,
+        productName: name,
+        description: p.description || '',
+        hsn: p.hsn || p.hsnCode || '998314',
+        storeCount: p.storeCount || e.stores || '',
+        price: fmt( p.price ),
+        amount: fmt( p.amount ),
+      };
+    } );
+    const tax = ( e.tax || [] ).map( ( t ) => ( {
+      type: t.type || t.taxName || t.name || 'GST',
+      value: t.value ?? t.taxPercentage ?? t.percentage ?? '',
+      taxAmount: fmt( t.taxAmount ),
+    } ) );
+
+    const statusLabelMap = { draft: 'Draft', sent: 'Sent', accepted: 'Accepted', declined: 'Declined', expired: 'Expired' };
+    const data = {
+      estimate: e.estimate,
+      status: e.status,
+      statusLabel: statusLabelMap[e.status] || e.status,
+      companyName: e.companyName || '',
+      companyAddress: e.companyAddress || '',
+      GSTNumber: e.GSTNumber || '',
+      PlaceOfSupply: e.PlaceOfSupply || '',
+      groupName: e.groupName || '',
+      period: e.period || '',
+      createdDate: e.createdDate ? dayjs( e.createdDate ).format( 'DD/MM/YYYY' ) : '',
+      validTill: e.validTill ? dayjs( e.validTill ).format( 'DD/MM/YYYY' ) : '',
+      currencyType,
+      amount: fmt( e.amount ),
+      totalAmount: fmt( e.totalAmount ),
+      products,
+      tax,
+      notes: e.notes || '',
+      logo: `${JSON.parse( process.env.URL ).apiDomain}/logo.png`,
+    };
+
+    const templateHtml = fs.readFileSync( path.resolve( path.dirname( '' ) ) + '/src/hbs/estimatePdf.hbs', 'utf8' );
+    const template = Handlebars.compile( templateHtml );
+    const html = template( data );
+    const file = { content: html };
+    const options = {
+      executablePath: '/usr/bin/chromium',
+      args: [ '--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage', '--no-zygote', '--single-process' ],
+      format: 'A4',
+      margin: { top: '0.5in', right: '0.5in', bottom: '0.5in', left: '0.5in' },
+      printBackground: true,
+      preferCSSPageSize: true,
+    };
+    const pdfBuffer = await htmlpdf.generatePdf( file, options );
+
+    const filename = ( e.estimate + '-' + ( e.companyName || 'estimate' ) + '.pdf' ).split( '/' ).join( '_' ).split( '"' ).join( '' ).trim();
+    res.set( 'Content-Type', 'application/pdf' );
+    res.set( 'Content-Disposition', `attachment; filename="${filename}"` );
+    return res.send( pdfBuffer );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'downloadEstimate' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function deleteEstimate( req, res ) {
+  try {
+    const estimate = await estimateService.findOne( { _id: req.params.estimateId } );
+    if ( !estimate ) {
+      return res.sendError( 'Estimate not found', 404 );
+    }
+    if ( estimate.status === 'accepted' ) {
+      return res.sendError( 'An accepted estimate cannot be deleted.', 409 );
+    }
+    await estimateService.updateOne( { _id: req.params.estimateId }, { $set: { status: 'declined' } } );
+    return res.sendSuccess( 'Estimate removed' );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'deleteEstimate' } );
+    return res.sendError( error, 500 );
+  }
+}