tango-app-api-payment-subscription 3.0.59-dev → 3.0.61-dev

package/src/controllers/invoice.controller.js

@@ -0,0 +1,867 @@
+import * as invoiceService from '../services/invoice.service.js';
+import * as dailyPricingService from '../services/dailyPrice.service.js';
+import * as clientService from '../services/clientPayment.services.js';
+import * as billingService from '../services/billing.service.js';
+import dayjs from 'dayjs';
+import { logger, checkFileExist, signedUrl } from 'tango-app-api-middleware';
+import Handlebars from 'handlebars';
+import fs from 'fs';
+import path from 'path';
+import htmlpdf from 'html-pdf-node';
+import basePricingModel from 'tango-api-schema/schema/basePricing.model.js';
+export async function createInvoice( req, res ) {
+  try {
+    if ( req.body.clientList.length > 0 ) {
+      req.body.clientList = req.body.clientList;
+    } else {
+      let clients = await clientService.find( { status: 'active' } );
+      req.body.clientList = clients.map( ( client ) => client.clientId );
+    }
+    for ( let client of req.body.clientList ) {
+      let invoiceGroup = await billingService.aggregatebilling( [
+        {
+          $match: {
+            clientId: client,
+          },
+        },
+      ] );
+      for ( let group of invoiceGroup ) {
+        let Finacialyear = getCurrentFinancialYear();
+        let previousinvoice = await invoiceService.findandsort( {}, {}, { invoiceIndex: -1 } );
+        let invoiceNo = '00001';
+        if ( previousinvoice && previousinvoice.length > 0 ) {
+          invoiceNo = Number( previousinvoice[0].invoiceIndex ) + 1;
+          invoiceNo = invoiceNo.toString().padStart( 5, '0' );
+        }
+
+        let address = group.addressLineOne + group.addressLineTwo + group.city + ',' + group.state + ',' + group.country + ' -' + group.pinCode;
+        let getClient = await clientService.findOne( { clientId: client, status: 'active' } );
+        let products;
+        if ( getClient.priceType === 'standard' ) {
+          products = await standardPrice( client, group );
+        } else {
+          products = await stepPrice( client, group, res );
+        }
+        let amount = products.reduce( ( sum, product ) => sum + product.amount, 0 );
+        let taxList = [];
+        let totalAmount = 0;
+        if ( group.gst && group.gst.slice( 0, 2 ) == '33' ) {
+          let taxAmount = ( amount * 18 ) / 100;
+          totalAmount = ( amount + taxAmount ).toFixed( 2 );
+          taxList.push(
+              {
+                'currency': '₹',
+                'type': 'CGST',
+                'value': 9,
+                'taxAmount': ( ( amount * 9 ) / 100 ).toFixed( 2 ),
+              }, {
+                'currency': '₹',
+                'type': 'SGST',
+                'value': 9,
+                'taxAmount': ( ( amount * 9 ) / 100 ).toFixed( 2 ),
+              },
+          );
+        } else {
+          let taxAmount = ( amount * 18 ) / 100;
+          totalAmount = ( amount + taxAmount ).toFixed( 2 );
+          taxList.push(
+              {
+                'currency': '₹',
+                'type': 'IGST',
+                'value': 18,
+                'taxAmount': ( taxAmount ).toFixed( 2 ),
+              },
+          );
+        }
+
+
+        let totalStoreCount = products.reduce( ( sum, item ) => sum + item.storeCount, 0 );
+        let data = {
+          groupName: group.groupName,
+          groupId: group._id,
+          invoice: `INV-${Finacialyear}-${invoiceNo}`,
+          products: products,
+          status: 'pending',
+          amount: amount,
+          invoiceIndex: invoiceNo,
+          tax: taxList,
+          companyName: group.registeredCompanyName,
+          companyAddress: address,
+          PlaceOfSupply: group.placeOfSupply,
+          GSTNumber: group.gst,
+          totalAmount: totalAmount,
+          clientId: client,
+          paymentMethod: '',
+          billingDate: new Date(),
+          stores: totalStoreCount,
+        };
+
+        let invoiceExists = await invoiceService.findOne( { monthOfbilling: req.body.monthOfbilling, clientId: getClient.clientId } );
+        if ( invoiceExists ) {
+          logger.info( `invoice already exist for the month${req.body.monthOfbilling} for ${getClient.clientId}` );
+        } else {
+          await invoiceService.create( data );
+        }
+      }
+    }
+    res.sendSuccess( 'Invoice Created SuccessFully' );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'createInvoice' } );
+    return res.sendError( error, 500 );
+  }
+}
+function getCurrentFinancialYear() {
+  const today = new Date();
+  const currentMonth = today.getMonth();
+  const currentYear = today.getFullYear();
+  if ( currentMonth >= 3 ) {
+    return currentYear.toString().slice( -2 ) + '-' + ( currentYear + 1 ).toString().slice( -2 );
+  } else {
+    return ( ( currentYear - 1 ).toString().slice( -2 ) ) + '-' + currentYear.toString().slice( -2 );
+  }
+}
+
+
+export async function invoiceDownload( req, res ) {
+  try {
+    let invoiceData;
+    let invoiceInfo = await invoiceService.findOne( { _id: req.params.invoiceId } );
+    if ( invoiceInfo ) {
+      let clientDetails = await clientService.findOne( { clientId: invoiceInfo.clientId } );
+      invoiceInfo.products.forEach( ( item, index ) => {
+        item.index = index + 1;
+        let [ firstWord, secondWord ] = item.productName.replace( /([a-z])([A-Z])/g, '$1 $2' ).split( ' ' );
+        firstWord = firstWord.charAt( 0 ).toUpperCase() + firstWord.slice( 1 );
+        item.productName = firstWord + ' ' + secondWord;
+        item.price = item.price.toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } );
+        item.amount = item.amount.toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } );
+        item.currency = clientDetails?.paymentInvoice?.currencyType == 'dollar' ? '$' : '₹';
+      } );
+
+
+      for ( let tax of invoiceInfo.tax ) {
+        tax.taxAmount = tax.taxAmount.toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } );
+      }
+      let invoiceDate = dayjs( invoiceInfo.createdAt ).format( 'DD/MM/YYYY' );
+      let days = clientDetails?.paymentInvoice?.extendPaymentPeriodDays || 10;
+      let dueDate = invoiceInfo?.dueDate ? dayjs( invoiceInfo?.dueDate ).format( 'DD/MM/YYYY' ) : dayjs().add( days, 'days' ).format( 'DD/MM/YYYY' );
+
+      invoiceInfo.totalAmount = Math.round( invoiceInfo.totalAmount );
+      let AmountinWords = inWords( invoiceInfo.totalAmount );
+      invoiceData = {
+        ...invoiceInfo._doc,
+        clientName: clientDetails.clientName,
+        extendDays: clientDetails.paymentInvoice.extendPaymentPeriodDays,
+        address: clientDetails.billingDetails.billingAddress,
+        subtotal: invoiceInfo.amount.toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } ),
+        companyName: invoiceInfo.companyName,
+        companyAddress: invoiceInfo.companyAddress,
+        PlaceOfSupply: invoiceInfo.PlaceOfSupply,
+        GSTNumber: invoiceInfo.GSTNumber,
+        PoNum: '',
+        amountwords: AmountinWords,
+        Terms: `Term ${clientDetails.paymentInvoice.extendPaymentPeriodDays}`,
+        currencyType: clientDetails?.paymentInvoice?.currencyType == 'dollar' ? '$' : '₹',
+        totalAmount: invoiceInfo.totalAmount.toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } ),
+        invoiceDate,
+        dueDate,
+      };
+      const currentMonthDays = dayjs().daysInMonth();
+      let getgroup = await billingService.findOne( { _id: invoiceInfo.groupId } );
+      let annuxureData = await dailyPricingService.aggregate( [
+        {
+          $match: {
+            clientId: invoiceInfo.clientId,
+          },
+        },
+        {
+          $sort: { dateISO: -1 },
+        },
+        { $limit: 1 },
+        {
+          $project: {
+            stores: {
+              $filter: {
+                input: '$stores',
+                as: 'item',
+                cond: { $in: [ '$$item.storeId', getgroup.stores ] },
+              },
+            },
+          },
+        },
+        {
+          $unwind: {
+            path: '$stores',
+            preserveNullAndEmptyArrays: false,
+          },
+        },
+        {
+          $unwind: {
+            path: '$stores.products',
+            preserveNullAndEmptyArrays: false,
+          },
+        },
+        {
+          $project: {
+            productName: '$stores.products.productName',
+            storeId: '$stores.storeId',
+            storeName: '$stores.storeName',
+            edgefirstFileDate: '$stores.edgefirstFileDate',
+            workingdays: '$stores.products.workingdays',
+            currencyType: { $literal: clientDetails?.paymentInvoice?.currencyType == 'dollar' ? '$' : '₹' },
+          },
+        },
+        {
+          $sort: {
+            productName: 1,
+            workingdays: -1,
+          },
+        },
+        {
+          $match: { workingdays: { $gt: 0 } },
+        },
+
+        {
+          $lookup: {
+            from: 'basepricings',
+            let: { clientId: invoiceInfo.clientId },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $eq: [ '$clientId', '$$clientId' ],
+                  },
+                },
+              },
+              {
+                $project: {
+                  standard: 1,
+                  step: 1,
+                },
+              },
+            ],
+            as: 'basepricing',
+          },
+        },
+        {
+          $unwind: { path: '$basepricing', preserveNullAndEmptyArrays: true },
+        },
+        {
+          $project: {
+            productName: 1,
+            workingdays: 1,
+            storeName: 1,
+            currencyType: 1,
+            edgefirstFileDate: { $ifNull: [ '$edgefirstFileDate', '$processfirstFileDate' ] },
+            storeId: 1,
+            standard: {
+              $filter: {
+                input: '$basepricing.standard',
+                as: 'standard',
+                cond: { $eq: [ '$$standard.productName', '$productName' ] },
+              },
+            },
+            step: '$basepricing.step',
+          },
+        },
+        {
+          $unwind: { path: '$standard', preserveNullAndEmptyArrays: true },
+        },
+        {
+          $project: {
+            productName: {
+              $concat: [
+                { $toUpper: { $substr: [ '$productName', 0, 1 ] } }, // Uppercase first letter
+                { $substr: [ '$productName', 1, { $strLenCP: '$productName' } ] }, // Rest of the string
+              ],
+            },
+            currencyType: 1,
+            workingdays: 1,
+            storeName: 1,
+            edgefirstFileDate: { $dateToString: { format: '%Y-%m-%d', date: '$edgefirstFileDate' } },
+            storeId: 1,
+            period: {
+              $cond: {
+                if: { $lt: [ '$workingdays', currentMonthDays ] },
+                then: 'prorate',
+                else: 'fullmonth',
+              },
+            },
+            standardPrice: '$standard.negotiatePrice',
+            runningCost: {
+              $round: [
+                {
+                  $multiply: [
+                    { $divide: [ '$standard.negotiatePrice', currentMonthDays ] },
+                    '$workingdays',
+                  ],
+                },
+                2,
+              ],
+            },
+          },
+        },
+      ],
+      );
+      invoiceData.annuxureData = annuxureData;
+
+      const templateHtml = fs.readFileSync( path.resolve( path.dirname( '' ) ) + '/src/hbs/invoicePdf.hbs', 'utf8' );
+      const template = Handlebars.compile( templateHtml );
+      const html = template( { ...invoiceData } );
+      let file = {
+        content: html,
+      };
+      let options = {
+        format: 'A4', margin: {
+          top: '0.5in',
+          right: '0.5in',
+          bottom: '0.5in',
+          left: '0.5in',
+        },
+        printBackground: true,
+        preferCSSPageSize: true,
+      };
+      const date = dayjs( invoiceData.monthOfbilling, 'MM' );
+      const monthName = date.format( 'MMMM' );
+
+      htmlpdf.generatePdf( file, options ).then( async function( pdfBuffer ) {
+        if ( req.body.sendInvoice ) {
+          let mailSubject = `Invoice for ${monthName} - Tango/${clientDetails.clientName}`;
+          let mailbody = `<div>Dear Team,</div>
+              <div style="margin-top:10px">
+              Please find attached the Invoice for the month of ${monthName}'24.
+              </div>
+              <div style="margin-top:10px">
+              Best Regards,
+              </div>
+              <div style="margin-top:5px">
+              Tango Finance
+              </div>`;
+
+          let filename = `${clientDetails.clientName}-${invoiceData.invoice}-${monthName}.pdf`;
+          let attachments = {
+            filename: `${filename}`,
+            content: pdfBuffer,
+            contentType: 'application/pdf', // e.g., 'application/pdf'
+          };
+          clientDetails.paymentInvoice.invoiceCC = [ ...clientDetails.paymentInvoice.invoiceCC, ...[ 'sireesha@tangotech.co.in' ] ];
+          const result = await sendEmailWithSES( clientDetails.paymentInvoice.invoiceTo, mailSubject, mailbody, attachments, 'no-reply@tangotech.ai', clientDetails.paymentInvoice.invoiceCC );
+          if ( result ) {
+            await invoiceService.updateOne( { _id: req.params.invoiceId }, { status: req.body.status } );
+            return res.sendSuccess( result );
+          }
+        }
+        res.set( 'Content-Disposition', 'attachment; filename="generated-pdf.pdf"' );
+        res.set( 'Content-Type', 'application/pdf' );
+        res.send( pdfBuffer );
+      } );
+      return;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'invoiceDownload' } );
+    return res.sendError( error, 500 );
+  }
+}
+function inWords( num ) {
+  let a = [ '', 'one ', 'two ', 'three ', 'four ', 'five ', 'six ', 'seven ', 'eight ', 'nine ', 'ten ', 'eleven ', 'twelve ', 'thirteen ', 'fourteen ', 'fifteen ', 'sixteen ', 'seventeen ', 'eighteen ', 'nineteen ' ]; let b = [ '', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety' ];
+  if ( ( num = num.toString() ).length > 9 ) return 'overflow';
+  let n = ( '000000000' + num ).substr( -9 ).match( /^(\d{2})(\d{2})(\d{2})(\d{1})(\d{2})$/ );
+  if ( !n ) return; let str = '';
+  str += ( n[1] != 0 ) ? ( a[Number( n[1] )] || b[n[1][0]] + ' ' + a[n[1][1]] ) + 'crore ' : '';
+  str += ( n[2] != 0 ) ? ( a[Number( n[2] )] || b[n[2][0]] + ' ' + a[n[2][1]] ) + 'lakh ' : '';
+  str += ( n[3] != 0 ) ? ( a[Number( n[3] )] || b[n[3][0]] + ' ' + a[n[3][1]] ) + 'thousand ' : '';
+  str += ( n[4] != 0 ) ? ( a[Number( n[4] )] || b[n[4][0]] + ' ' + a[n[4][1]] ) + 'hundred ' : '';
+  str += ( n[5] != 0 ) ? ( ( str != '' ) ? 'and ' : '' ) + ( a[Number( n[5] )] || b[n[5][0]] + ' ' + a[n[5][1]] ) : '';
+
+  return str.toLowerCase().split( ' ' ).map( ( word ) => word.charAt( 0 ).toUpperCase() + word.slice( 1 ) ).join( ' ' );
+}
+
+
+async function standardPrice( client, group ) {
+  const currentMonthDays = dayjs().daysInMonth();
+  let products = await dailyPricingService.aggregate( [
+    {
+      $match: {
+        clientId: client,
+      },
+    },
+    {
+      $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',
+      },
+    },
+    {
+      $match: {
+        workingDays: { $gt: 0 },
+      },
+    },
+    {
+      $project: {
+        productName: 1,
+        storeId: 1,
+        prorate: { $literal: group.proRata },
+        workingDays: 1,
+        storeStatus: 1,
+      },
+    },
+    {
+      $project: {
+        productName: 1,
+        storeId: 1,
+        workingDays: {
+          $cond: { if: { $and: [ { $gte: [ '$workingDays', 15 ] }, { $eq: [ '$storeStatus', 'active' ] }, { $eq: [ '$prorate', 'before15' ] } ] }, then: currentMonthDays, else: '$workingDays' },
+        },
+        storeStatus: 1,
+      },
+    },
+    {
+      $group: {
+        _id: {
+          productName: '$productName',
+          storeId: '$storeId',
+        },
+        workingdays: { $first: '$workingDays' },
+      },
+    },
+    {
+      $group: {
+        _id: {
+          productName: '$_id.productName',
+          workingdays: '$workingdays',
+        },
+        storeCount: { $sum: 1 },
+      },
+    },
+    {
+      $project: {
+        _id: 0,
+        productName: '$_id.productName',
+        workingdays: '$_id.workingdays',
+        storeCount: '$storeCount',
+      },
+    },
+    {
+      $lookup: {
+        from: 'basepricings',
+        let: { clientId: client },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $eq: [ '$clientId', '$$clientId' ],
+              },
+            },
+          },
+          {
+            $project: {
+              standard: 1,
+              step: 1,
+            },
+          },
+        ],
+        as: 'basepricing',
+      },
+    },
+    {
+      $unwind: { path: '$basepricing', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $project: {
+        productName: 1,
+        workingdays: 1,
+        storeCount: 1,
+        standard: {
+          $filter: {
+            input: '$basepricing.standard',
+            as: 'standard',
+            cond: { $eq: [ '$$standard.productName', '$productName' ] },
+          },
+        },
+        step: '$basepricing.step',
+      },
+    },
+    {
+      $unwind: { path: '$standard', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $project: {
+        productName: 1,
+        workingdays: 1,
+        period: {
+          $cond: {
+            if: { $lt: [ '$workingdays', currentMonthDays ] },
+            then: 'prorate',
+            else: 'fullmonth',
+          },
+        },
+        storeCount: 1,
+        standardPrice: '$standard.negotiatePrice',
+        runningCost: {
+          $round: [
+            {
+              $multiply: [
+                { $divide: [ '$standard.negotiatePrice', currentMonthDays ] },
+                '$workingdays',
+              ],
+            },
+            2,
+          ],
+        },
+        perstorecost: {
+          $cond: {
+            if: { $eq: [ '$workingdays', currentMonthDays ] },
+            then: {
+              $multiply: [ '$standard.negotiatePrice', '$storeCount' ],
+            },
+            else: {
+              $round: [
+                {
+                  $multiply: [
+                    {
+                      $multiply: [
+                        { $divide: [ '$standard.negotiatePrice', currentMonthDays ] },
+                        '$workingdays',
+                      ],
+                    },
+                    '$storeCount',
+                  ],
+                },
+                2,
+              ],
+            },
+          },
+        },
+      },
+    },
+    {
+      $group: {
+        _id: {
+          productName: '$productName',
+          period: '$period',
+        },
+        storeCount: { $sum: '$storeCount' },
+        amount: { $sum: '$perstorecost' },
+      },
+    },
+    {
+      $project: {
+        _id: 0,
+        productName: '$_id.productName',
+        period: '$_id.period',
+        price: {
+          $round: [ { $divide: [ '$amount', '$storeCount' ] }, 2 ],
+        },
+        storeCount: 1,
+        amount: 1,
+        description: {
+          $cond: {
+            if: { $eq: [ '$_id.productName', 'tangoZone' ] },
+            then: 'Product category/section analytics',
+            else: 'Customer Footfall Analytics',
+          },
+        },
+        HsnNumber: '998314',
+        month: { $literal: dayjs().format( 'MMM YYYY' ) },
+      },
+    },
+  ] );
+
+
+  return products;
+}
+
+
+async function stepPrice( client, group, res ) {
+  const currentMonthDays = dayjs().daysInMonth();
+  let products = await dailyPricingService.aggregate( [
+    {
+      $match: {
+        clientId: client,
+      },
+    },
+    {
+      $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',
+      },
+    },
+    {
+      $match: {
+        workingDays: { $gt: 0 },
+      },
+    },
+    {
+      $project: {
+        productName: 1,
+        storeId: 1,
+        prorate: { $literal: group.proRata },
+        workingDays: 1,
+        storeStatus: 1,
+      },
+    },
+    {
+      $project: {
+        productName: 1,
+        storeId: 1,
+        workingDays: {
+          $cond: { if: { $and: [ { $gte: [ '$workingDays', 15 ] }, { $eq: [ '$storeStatus', 'active' ] }, { $eq: [ '$prorate', 'before15' ] } ] }, then: currentMonthDays, else: '$workingDays' },
+        },
+        storeStatus: 1,
+      },
+    }, {
+      $group: {
+        _id: {
+          productName: '$productName',
+          storeId: '$storeId',
+        },
+        workingdays: { $first: '$workingDays' },
+      },
+    },
+    {
+      $group: {
+        _id: {
+          productName: '$_id.productName',
+          workingdays: '$workingdays',
+        },
+        storeCount: { $sum: 1 },
+      },
+    },
+    {
+      $project: {
+        _id: 0,
+        productName: '$_id.productName',
+        workingdays: '$_id.workingdays',
+        storeCount: '$storeCount',
+      },
+    },
+    {
+      $sort: {
+        workingdays: -1,
+      },
+    },
+
+
+  ] );
+  let stepPrice = await basePricingModel.findOne( { clientId: client } );
+  let data = products;
+  let pricing = stepPrice.step;
+
+  const applyPricing = ( data, pricing ) => {
+    let totalcount = 0;
+    return data.map( ( item ) => {
+      totalcount = totalcount + item.storeCount;
+
+
+      let applicablePricing = pricing.find( ( price ) => {
+        const [ minRange, maxRange ] = price.storeRange.split( '-' ).map( Number );
+        return totalcount >= minRange && totalcount <= maxRange;
+      } );
+      if ( item.workingdays === currentMonthDays ) {
+        item.period = 'fullMonth';
+        item.runningCost = item.storeCount * applicablePricing.negotiatePrice;
+      } else {
+        item.period = 'proRate';
+        item.runningCost = ( item.storeCount * ( applicablePricing.negotiatePrice / currentMonthDays ) * item.workingdays ).toFixed( 2 );
+      }
+
+      return {
+        ...item,
+        negotiatePrice: applicablePricing.negotiatePrice,
+        perstorecost: ( ( applicablePricing.negotiatePrice / currentMonthDays ) * item.workingdays ).toFixed( 2 ),
+      };
+    } );
+  };
+
+  const result = applyPricing( data, pricing );
+  const groupedData = result.reduce( ( acc, item ) => {
+    const { productName, period, runningCost } = item;
+    const key = `${productName}_${period}`;
+    if ( !acc[key] ) {
+      acc[key] = {
+        productName,
+        period,
+        totalRunningCost: 0,
+        count: 0,
+      };
+    }
+
+    acc[key].totalRunningCost += parseFloat( runningCost );
+    acc[key].count += item.storeCount;
+
+    return acc;
+  }, {} );
+
+  // Calculating average running cost
+  const finalresult = Object.values( groupedData ).map( ( group ) => {
+    let description = '';
+    if ( group.productName === 'tangoTraffic' ) {
+      description = 'Customer Footfall Analytics';
+    } else if ( group.productName === 'tangoZone' ) {
+      description = 'Product category/section analytics';
+    } else {
+      description = '';
+    }
+    return {
+      productName: group.productName,
+      period: group.period,
+      storeCount: group.count,
+      description: description,
+      HsnNumber: '998314',
+      amount: group.totalRunningCost,
+      month: dayjs().format( 'MMM YYYY' ),
+      price: ( group.totalRunningCost / group.count ).toFixed( 2 ),
+    };
+  } );
+
+  // return res.sendSuccess( finalresult );
+  return finalresult;
+}
+
+
+export async function clientInvoiceList( req, res ) {
+  try {
+    let query = [ {
+      $match: {
+        clientId: { $in: req.body.clientId },
+      },
+    }, {
+      $lookup: {
+        from: 'clients',
+        let: { clientId: '$clientId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $eq: [ '$clientId', '$$clientId' ],
+              },
+            },
+          },
+          {
+            $project: {
+              clientName: 1,
+              logo: '$profileDetails.logo',
+              currencyType: '$paymentInvoice.currencyType',
+            },
+          },
+        ],
+        as: 'clientDetails',
+      },
+    },
+    {
+      $unwind: { path: '$clientDetails', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $project: {
+        clientName: '$clientDetails.clientName',
+        logo: '$clientDetails.logo',
+        currencyType: '$clientDetails.currencyType',
+        invoice: 1,
+        stores: 1,
+        totalAmount: 1,
+        groupName: 1,
+        status: 1,
+        paymentStatus: 1,
+        clientId: 1,
+      },
+    },
+    ];
+    if ( req.body.searchValue && req.body.searchValue != '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { groupName: { $regex: req.body.searchValue, $options: 'i' } },
+            { clientName: { $regex: req.body.searchValue, $options: 'i' } },
+            { paymentStatus: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      query.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
+    let count = await invoiceService.aggregate( query );
+    if ( req.body.limit && req.body.offset && !req.body.export ) {
+      query.push(
+          { $skip: ( req.body.offset - 1 ) * req.body.limit },
+          { $limit: Number( req.body.limit ) },
+      );
+    }
+    let invoiceList = await invoiceService.aggregate( query );
+    const bucket = JSON.parse( process.env.BUCKET );
+    for ( let client of invoiceList ) {
+      const isLogoExist = await checkFileExist( { Bucket: bucket.assets, Key: `${client.clientId}/logo/${client?.logo}` } );
+      if ( isLogoExist ) {
+        client.logo = await signedUrl( { Bucket: bucket.assets, file_path: `${client.clientId}/logo/${client?.logo}` } );
+      } else {
+        client.logo = '';
+      }
+      // return client;
+    }
+
+    res.sendSuccess( { count: count.length, data: invoiceList } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'clientInvoiceList' } );
+    return res.sendError( error, 500 );
+  }
+}