tango-app-api-payment-subscription 3.1.12 → 3.1.14-alpha.1

package/src/controllers/invoice.controller.js

@@ -1,274 +1,147 @@
-import { aggregatebilling } from '../services/billing.service.js';
 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 basePricingService from '../services/basePrice.service.js';
+import * as billingService from '../services/billing.service.js';
 import dayjs from 'dayjs';
-
-
-import { logger } from 'tango-app-api-middleware';
+import { logger, checkFileExist, signedUrl, download, sendEmailWithSES } from 'tango-app-api-middleware';
 import Handlebars from 'handlebars';
 import fs from 'fs';
 import path from 'path';
 import htmlpdf from 'html-pdf-node';
+import * as basepricingService from '../services/basePrice.service.js';
+import * as paymentAccountService from '../services/paymentAccount.service.js';
+
 export async function createInvoice( req, res ) {
   try {
-    for ( let client of req.body.clientList ) {
-      let invoiceGroup = await 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 invoiceGroupList = [];
+    if ( req.body.allClient ) {
+      if ( req.body.clientList && 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 );
+      }
 
-        const currentMonthDays = dayjs().daysInMonth();
-        let products = await dailyPricingService.aggregate( [
+      for ( let client of req.body.clientList ) {
+        let invoiceGroup = await billingService.aggregatebilling( [
           {
             $match: {
               clientId: client,
             },
           },
-          {
-            $sort: { dateISO: -1 },
-          },
-          { $limit: 1 },
-          {
-            $unwind: {
-              path: '$stores',
-              preserveNullAndEmptyArrays: false,
-            },
-          },
-          {
-            $unwind: {
-              path: '$stores.products',
-              preserveNullAndEmptyArrays: false,
-            },
-          },
-          {
-            $project: {
-              productName: '$stores.products.productName',
-              storeId: '$stores.storeId',
-              workingDays: '$stores.products.workingdays',
-            },
-          },
-          {
-            $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,
-                    ] },
-                },
-              },
+        ] );
+        for ( let invGrp of invoiceGroup ) {
+          invoiceGroupList.push( invGrp );
+        }
+      }
+    }
+    if ( req.body.invoiceId ) {
+      let findInvoice = await invoiceService.findOne( { invoice: req.body.invoiceId } );
+      let invoiceGroup = await billingService.findOne( { _id: findInvoice.groupId } );
+      invoiceGroupList.push( invoiceGroup );
+    }
+
+    for ( let group of invoiceGroupList ) {
+      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: group.clientId, status: 'active' } );
+      let products;
+
+      if ( getClient.priceType === 'standard' ) {
+        products = await standardPrice( group );
+      } else {
+        products = await stepPrice( group );
+      }
+      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 = Math.round( amount + taxAmount );
+        taxList.push(
+            {
+              'currency': '₹',
+              'type': 'CGST',
+              'value': 9,
+              'taxAmount': ( ( amount * 9 ) / 100 ).toFixed( 2 ),
+            }, {
+              'currency': '₹',
+              'type': 'SGST',
+              'value': 9,
+              'taxAmount': ( ( amount * 9 ) / 100 ).toFixed( 2 ),
             },
-          },
-          {
-            $group: {
-              _id: {
-                productName: '$productName',
-                period: '$period',
-              },
-              storeCount: { $sum: '$storeCount' },
-              amount: { $sum: '$perstorecost' },
+        );
+      } else {
+        let taxAmount = ( amount * 18 ) / 100;
+        totalAmount = Math.round( amount + taxAmount );
+        taxList.push(
+            {
+              'currency': '₹',
+              'type': 'IGST',
+              'value': 18,
+              'taxAmount': ( taxAmount ).toFixed( 2 ),
             },
+        );
+      }
+
+      let totalStoreCount = await dailyPricingService.aggregate( [
+        {
+          $match: {
+            clientId: group.clientId,
           },
-          {
-            $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',
-                },
+        },
+        {
+          $sort: { dateISO: -1 },
+        },
+        { $limit: 1 },
+        {
+          $project: {
+            stores: {
+              $filter: {
+                input: '$stores',
+                as: 'item',
+                cond: { $gt: [ '$$item.daysDifference', 0 ] },
               },
-              HsnNumber: '998314',
-              month: { $literal: dayjs().format( 'MMM YYYY' ) },
             },
           },
-        ] );
+        },
 
-        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 data = {
-          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: group.stores.length,
-        };
-        let getClient = await clientService.findOne( { clientId: client, status: 'active' } );
-        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 );
-        }
+      ] );
+
+
+      let data = {
+        groupName: group.groupName,
+        groupId: group._id,
+        invoice: `INV-${Finacialyear}-${invoiceNo}`,
+        products: products,
+        status: 'pending',
+        amount: Math.round( amount ),
+        invoiceIndex: invoiceNo,
+        tax: taxList,
+        companyName: group.registeredCompanyName,
+        companyAddress: address,
+        PlaceOfSupply: group.placeOfSupply,
+        GSTNumber: group.gst,
+        totalAmount: Math.round( totalAmount ),
+        clientId: group.clientId,
+        paymentMethod: '',
+        billingDate: new Date(),
+        stores: totalStoreCount.length?totalStoreCount[0].stores.length:0,
+        currency: group.currency ? group.currency : 'inr',
+      };
+      if ( req.body.invoiceId ) {
+        await invoiceService.deleteRecord( { invoice: req.body.invoiceId } );
       }
+      await invoiceService.create( data );
     }
+
     res.sendSuccess( 'Invoice Created SuccessFully' );
   } catch ( error ) {
     logger.error( { error: error, function: 'createInvoice' } );
@@ -294,7 +167,7 @@ export async function invoiceDownload( req, res ) {
     if ( invoiceInfo ) {
       let clientDetails = await clientService.findOne( { clientId: invoiceInfo.clientId } );
       invoiceInfo.products.forEach( ( item, index ) => {
-        item.index = index+1;
+        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;
@@ -330,8 +203,12 @@ export async function invoiceDownload( req, res ) {
         totalAmount: invoiceInfo.totalAmount.toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } ),
         invoiceDate,
         dueDate,
+        discountPercentage: invoiceInfo.discountPercentage ? invoiceInfo.discountPercentage : 0,
+        discountAmount: invoiceInfo.discountAmount ? invoiceInfo.discountAmount : 0,
+        logo: `${JSON.parse( process.env.URL ).apiDomain}/logo.png`,
       };
       const currentMonthDays = dayjs().daysInMonth();
+      let getgroup = await billingService.findOne( { _id: invoiceInfo.groupId } );
       let annuxureData = await dailyPricingService.aggregate( [
         {
           $match: {
@@ -342,6 +219,17 @@ export async function invoiceDownload( req, res ) {
           $sort: { dateISO: -1 },
         },
         { $limit: 1 },
+        {
+          $project: {
+            stores: {
+              $filter: {
+                input: '$stores',
+                as: 'item',
+                cond: { $in: [ '$$item.storeId', getgroup.stores ] },
+              },
+            },
+          },
+        },
         {
           $unwind: {
             path: '$stores',
@@ -370,6 +258,10 @@ export async function invoiceDownload( req, res ) {
             workingdays: -1,
           },
         },
+        {
+          $match: { workingdays: { $gt: 0 } },
+        },
+
         {
           $lookup: {
             from: 'basepricings',
@@ -453,7 +345,8 @@ export async function invoiceDownload( req, res ) {
       ],
       );
       invoiceData.annuxureData = annuxureData;
-
+      let virtualAccount = await paymentAccountService.findOneAccount( { clientId: invoiceInfo.clientId } );
+      invoiceData.virtualAccount = virtualAccount;
       const templateHtml = fs.readFileSync( path.resolve( path.dirname( '' ) ) + '/src/hbs/invoicePdf.hbs', 'utf8' );
       const template = Handlebars.compile( templateHtml );
       const html = template( { ...invoiceData } );
@@ -476,25 +369,18 @@ export async function invoiceDownload( req, res ) {
       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>`;
-
+          const templateHtml = fs.readFileSync( path.resolve( path.dirname( '' ) ) + '/src/hbs/invoicepaymentemail.hbs', 'utf8' );
+          const template = Handlebars.compile( templateHtml );
+          const mailbody = template( { ...invoiceData } );
           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 );
+          let billingGroup = await billingService.findOne( { _id: invoiceInfo.groupId } );
+
+          const result = await sendEmailWithSES( billingGroup.generateInvoiceTo, mailSubject, mailbody, attachments, 'no-reply@tangotech.ai' );
           if ( result ) {
             await invoiceService.updateOne( { _id: req.params.invoiceId }, { status: req.body.status } );
             return res.sendSuccess( result );
@@ -524,3 +410,664 @@ function inWords( num ) {
 
   return str.toLowerCase().split( ' ' ).map( ( word ) => word.charAt( 0 ).toUpperCase() + word.slice( 1 ) ).join( ' ' );
 }
+
+
+async function standardPrice( group ) {
+  const currentMonthDays = dayjs().daysInMonth();
+  let products = await dailyPricingService.aggregate( [
+    {
+      $match: {
+        clientId: group.clientId,
+      },
+    },
+    {
+      $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: group.clientId },
+        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( group ) {
+  const currentMonthDays = dayjs().daysInMonth();
+  let products = await dailyPricingService.aggregate( [
+    {
+      $match: {
+        clientId: group.clientId,
+      },
+    },
+    {
+      $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 basepricingService.findOne( { clientId: group.clientId } );
+  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 finalresult;
+}
+
+
+export async function clientInvoiceList( req, res ) {
+  try {
+    let findClients = await clientService.find( { clientId: { $in: req.body.clientId }, status: 'active' }, { clientId: 1 } );
+    findClients = findClients.map( ( a ) => {
+      return a.clientId;
+    } );
+    let query = [ {
+      $match: {
+        clientId: { $in: findClients },
+      },
+    }, {
+      $lookup: {
+        from: 'clients',
+        let: { clientId: '$clientId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $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: '$currency',
+        invoice: 1,
+        stores: 1,
+        totalAmount: 1,
+        groupName: 1,
+        status: 1,
+        paymentStatus: 1,
+        clientId: 1,
+        billingDate: 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 ( count.length == 0 ) {
+      return res.sendError( 'No data', 204 );
+    }
+
+    if ( req.body.export ) {
+      const exportdata = [];
+      count.forEach( ( element ) => {
+        exportdata.push( {
+          'Client': element.clientName,
+          'Invoice #': element.invoice,
+          'Billing date': dayjs( element.billingDate ).format( 'DD MMM, YYYY' ),
+          'Group Name': element.groupName,
+          'Amount': element.totalAmount,
+          'Stores': element.stores,
+          'Payment Status': element.paymentStatus,
+          'Approval Status': element.status,
+
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    }
+    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 ) {
+      if ( client?.logo && client?.logo != '' ) {
+        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 = '';
+        }
+      } else {
+        client.logo = '';
+      }
+    }
+    res.sendSuccess( { count: count.length, data: invoiceList } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'clientInvoiceList' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+
+export async function creditTransactionlist( req, res ) {
+  try {
+    let findClients = await clientService.find( { clientId: { $in: req.body.clientId }, status: 'active' }, { clientId: 1 } );
+    findClients = findClients.map( ( a ) => {
+      return a.clientId;
+    } );
+    let query = [ {
+      $match: {
+        clientId: { $in: findClients },
+      },
+    }, {
+      $lookup: {
+        from: 'clients',
+        let: { clientId: '$clientId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $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',
+        clientId: 1,
+        credit: 1,
+      },
+    },
+    ];
+    if ( req.body.searchValue && req.body.searchValue != '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { 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 paymentAccountService.aggregate( query );
+    if ( req.body.export ) {
+      const exportdata = [];
+      count.forEach( ( element ) => {
+        exportdata.push( {
+          'Client': element.clientName,
+          'Balance Credits': element.credit,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    }
+    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 TransactionsList = await paymentAccountService.aggregate( query );
+    const bucket = JSON.parse( process.env.BUCKET );
+    for ( let client of TransactionsList ) {
+      if ( client?.logo && client?.logo != '' ) {
+        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 = '';
+        }
+      } else {
+        client.logo = '';
+      }
+    }
+
+
+    res.sendSuccess( { count: count.length, data: TransactionsList } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'creditTransactionlist' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function pendingInvoices( req, res ) {
+  try {
+    let invoicelist = await invoiceService.find( { clientId: req.body.clientId, paymentStatus: 'unpaid' } );
+    res.sendSuccess( invoicelist );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'pendingInvoices' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function applyDiscount( req, res ) {
+  try {
+    let invoice = await invoiceService.findOne( { invoice: req.body.invoice } );
+    if ( invoice ) {
+      invoice.discountAmount = ( ( invoice.amount * req.body.discount ) / 100 ).toFixed( 2 );
+      invoice.amount = invoice.amount - invoice.discountAmount;
+      invoice.discountPercentage = req.body.discount;
+      if ( invoice.currency === 'inr' ) {
+        if ( invoice.tax.length ) {
+          for ( let i = 0; i < invoice.tax.length; i++ ) {
+            invoice.tax[i].taxAmount = ( ( invoice.amount * invoice.tax[i].value ) / 100 ).toFixed( 2 );
+            invoice.totalAmount = ( Number( invoice.amount ) + Number( invoice.tax[i].taxAmount ) ).toFixed( 2 );
+          }
+        }
+      }
+
+
+      await invoiceService.updateOne( { invoice: req.body.invoice }, invoice );
+    }
+    res.sendSuccess( 'updated Successfully' );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'applyDiscount' } );
+    return res.sendError( error, 500 );
+  }
+}