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

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 );
+  }
+}