tango-app-api-analysis-traffic 3.0.0-beta.2 → 3.1.0-alpha.1

package/src/controllers/emailers.controllers.js

@@ -0,0 +1,1862 @@
+import { logger, insertOpenSearchData, getOpenSearchData, getAssinedStoreEmailers, sendMessageToQueue, signedUrl, sendEmailWithSES, fileUpload, updateOpenSearchData } from 'tango-app-api-middleware';
+import * as clientService from '../services/clients.services.js';
+import * as userService from '../services/user.service.js';
+import * as storeService from '../services/stores.service.js';
+import { findCamera } from '../services/camera.service.js';
+import handlebars, { registerHelpers } from './handlebars.js';
+const __filename = fileURLToPath( import.meta.url );
+const __dirname = dirname( __filename );
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import puppeteer from 'puppeteer';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import dayjs from 'dayjs';
+registerHelpers();
+
+// Lamda Service Call //
+async function LamdaServiceCall( url, data ) {
+  try {
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify( data ),
+    };
+    const response = await fetch( url, requestOptions );
+    if ( !response.ok ) {
+      throw new Error( `Response status: ${response.status}` );
+      return false;
+    }
+    const json = await response.json();
+    return json;
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'LamdaServiceCall' } );
+    return false;
+  }
+}
+
+// ///// V1 API's ///////
+export const cardsFunnelV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getClientData = await getClientConfig( reqestData.clientId );
+    if ( !getClientData ) {
+      return res.sendError( 'Invalid Client Id', 400 );
+    }
+    reqestData.featureConfigs = getClientData.featureConfigs;
+    reqestData.currency = getClientData.paymentInvoice?.currencyType || 'inr';
+    reqestData.revenue = getClientData.averageTransactionValue || '0';
+    let LamdaURL = 'https://55mojecvuvtphucgsalx5jtyki0untzp.lambda-url.ap-south-1.on.aws/';
+    let resultData = await LamdaServiceCall( LamdaURL, reqestData );
+    if ( resultData ) {
+      if ( resultData.status_code == '200' ) {
+        return res.sendSuccess( resultData );
+      } else {
+        return res.sendError( 'No Content', 204 );
+      }
+    } else {
+      return res.sendError( 'No Content', 204 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+async function getClientConfig( clientId ) {
+  try {
+    let getClientData = await clientService.findOne( { clientId: clientId }, { 'paymentInvoice.currencyType': 1, 'averageTransactionValue': 1, 'featureConfigs.billableCalculation': 1, 'featureConfigs.missedOpportunityCalculation': 1, 'featureConfigs.conversionCalculation': 1, 'featureConfigs.open': 1, 'featureConfigs.close': 1, 'isFootfallAuditStores': 1 } );
+    if ( !getClientData ) {
+      return false;
+    }
+    return getClientData;
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'getClientConfig' } );
+    return false;
+  }
+}
+
+export const welcome = async ( req, res ) => {
+  try {
+    let result = {
+      'Message': 'Welcome',
+    };
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'trafficCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const createEmailers = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    const kolkataOffset = 5.5 * 60; // +5:30 in minutes
+    // // Check Client config ////
+    let getClientData = await clientService.findOne( { clientId: requestData.clientId }, { clientId: 1, emailersConfig: 1 } );
+
+    if ( !getClientData ) {
+      return res.sendError( 'Invalid clientId', 400 );
+    }
+
+    switch ( requestData.templateType ) {
+      case 'monthly':
+        if ( getClientData && !getClientData.emailersConfig.monthly ) {
+          return res.sendError( 'Client Not Enabled Monthly Emails', 400 );
+        }
+        break;
+      case 'weekly':
+        if ( getClientData && !getClientData.emailersConfig.weekly ) {
+          return res.sendError( 'Client Not Enabled Weekly Emails', 400 );
+        }
+        break;
+      default:
+        if ( getClientData && !getClientData.emailersConfig.daily ) {
+          return res.sendError( 'Client Not Enabled Daily Emails', 400 );
+        }
+        break;
+    }
+
+    // // Get active Users ////
+    let getUserData = await userService.findUserModel( { clientId: requestData.clientId, isActive: true, userType: 'client' }, { userName: 1, email: 1, role: 1, clientId: 1, isActive: 1, userType: 1, assignedStores: 1 } );
+
+    if ( !getUserData && getUserData.length < 1 ) {
+      return res.sendError( 'Active Users Empty', 400 );
+    }
+    let emailersIds = [];
+    // // Make for Loop and Get Assigned Stores each users ////
+    for ( let i = 0; i < getUserData.length; i++ ) {
+      let getUserStores = await getAssinedStoreEmailers( getUserData[i] );
+      let currentDate = new Date();
+      let emailersInsertData = {
+        clientId: requestData.clientId,
+        fromDate: requestData.fromDate,
+        toDate: requestData.toDate,
+        templateType: requestData.templateType,
+        status: 'open',
+        createdAt: currentDate,
+        dateISO: new Date( currentDate.getTime() + kolkataOffset * 60 * 1000 ),
+        userEmail: getUserData[i].email,
+        userName: getUserData[i].userName,
+        storeIds: getUserStores || [],
+      };
+      // // Insert emailers ////
+      let insertOS = await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).emailers, emailersInsertData );
+      if ( insertOS && insertOS.body.result == 'created' ) {
+        emailersIds.push( insertOS.body._id );
+      }
+    }
+    // // Send SQS Message ////
+    for ( let j = 0; j < emailersIds.length; j++ ) {
+      let sqsMessageRequestData = {
+        'emailersId': emailersIds[j],
+      };
+      const msg = sendMessageToQueue( `${JSON.parse( process.env.SQS ).url}${JSON.parse( process.env.SQS ).emailers}`, JSON.stringify( sqsMessageRequestData ) );
+      console.log( 'Send SQS Message =>'+[ j ], msg );
+    }
+    return res.sendSuccess( 'Emailers Triggered Successfully' );
+  } catch ( error ) {
+    // console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'createEmailers' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const emailersList = async ( req, res ) => {
+  try {
+    let requestBody = req.query;
+    // // Get Data From Emailers Collection Based on Filters////
+    let from = ( req.query.offset - 1 ) * req.query.limit;
+    let start = new Date( requestBody.fromDate );
+    let userTimezoneOffset = start.getTimezoneOffset() * 60000;
+    start = new Date( start.getTime() - userTimezoneOffset );
+    start.setUTCHours( 0, 0, 0, 0 );
+    let end = new Date( requestBody.toDate );
+    end = new Date( end.getTime() - userTimezoneOffset );
+    end.setUTCHours( 23, 59, 59, 59 );
+
+    const mustConditions = [];
+
+    if ( requestBody.clientId ) {
+      mustConditions.push( { match: { clientId: requestBody.clientId } } );
+    }
+
+    if ( requestBody.templateType ) {
+      mustConditions.push( { match: { templateType: requestBody.templateType } } );
+    }
+
+    if ( requestBody.userEmail ) {
+      mustConditions.push( { match: { userEmail: requestBody.userEmail } } );
+    }
+
+    if ( requestBody.status ) {
+      mustConditions.push( { match: { status: requestBody.status } } );
+    }
+
+    if ( requestBody._id ) {
+      mustConditions.push( { match: { _id: requestBody._id } } );
+    }
+
+    if ( requestBody.dateRange ) {
+      mustConditions.push( {
+        range: {
+          dateIso: {
+            gte: start, // Start date
+            lte: end, // End date
+          },
+        },
+      } );
+    }
+
+    // console.log( 'mustConditions =>', mustConditions );
+    let query = {
+      from: from,
+      size: req.query.limit,
+      query: {
+        bool: {
+          must: mustConditions,
+        },
+      },
+      sort: [
+        {
+          createdAt: {
+            order: 'desc',
+          },
+        },
+      ],
+    };
+    let result = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).emailers, query );
+    if ( !result || !result.body.hits.hits.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    return res.sendSuccess( { count: result.body.hits.total.value, result: result.body.hits.hits } );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'emailersList' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const sendEmailers = async ( req, res ) => {
+  try {
+    let requestBody = req.body;
+    // // Get Data From Emailers Collection Based on _id////
+    const mustConditions = [];
+    if ( requestBody._id ) {
+      mustConditions.push( { match: { _id: requestBody._id } } );
+    }
+    let query = {
+      query: {
+        bool: {
+          must: mustConditions,
+        },
+      },
+    };
+    let getEmailSourceData = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).emailers, query );
+    // console.log( 'getEmailSourceData =>', getEmailSourceData.body.hits.hits[0] );
+    // console.log( 'getEmailSourceData.length =>', getEmailSourceData.body.hits.hits.length );
+    if ( !getEmailSourceData.body.hits.hits.length ) {
+      return res.sendError( 'Invalide Emailer ID', 400 );
+    }
+
+    let emailerSourceData = getEmailSourceData.body.hits.hits[0];
+    if ( emailerSourceData._source.status == 'completed' ) {
+      return res.sendError( 'Email Already Send', 400 );
+    }
+    // // Get Stores Data ////
+    let getStoreSourceData = await storeService.findOneStore( { storeId: emailerSourceData._source.storeIds[0] }, { storeId: 1, storeName: 1, status: 1, storeProfile: 1 } );
+    const camera = await findCamera( { storeId: emailerSourceData._source.storeIds[0], isUp: true, isActivated: true }, { thumbnailImage: 1 } );
+    let cameraBaseImage = '';
+    const bucket= JSON.parse( process.env.BUCKET );
+    if ( camera ) {
+      const params = {
+        file_path: camera.thumbnailImage,
+        Bucket: bucket.baseImage,
+      };
+      cameraBaseImage = await signedUrl( params );
+    }
+    let storeData = {
+      storeId: getStoreSourceData.storeId,
+      storeName: getStoreSourceData.storeName,
+      storeLocation: getStoreSourceData.storeProfile.city+' '+getStoreSourceData.storeProfile.pincode,
+      storeCount: emailerSourceData._source.storeIds.length-1,
+      storeBaseImage: cameraBaseImage,
+    };
+
+    // // Get Client Data ///
+    let clientData = await clientService.findOne( { clientId: emailerSourceData._source.clientId }, { clientId: 1, emailersConfig: 1, featureConfigs: 1, clientName: 1 } );
+
+    // // Get Template Data ///
+    let templateData = {
+      userEmail: emailerSourceData._source.userEmail,
+      userName: emailerSourceData._source.userName,
+      templateType: emailerSourceData._source.templateType,
+      clientId: emailerSourceData._source.clientId,
+      clientName: clientData.clientName,
+      storeId: emailerSourceData._source.storeIds.slice( 0, 30 ),
+      allStores: emailerSourceData._source.storeIds,
+      fromDate: emailerSourceData._source.fromDate,
+      toDate: emailerSourceData._source.toDate,
+      templateType: emailerSourceData._source.templateType,
+      hourFormat: 12,
+      featureConfigs: {
+        open: clientData?.featureConfigs?.open || '10:00:00',
+        close: clientData?.featureConfigs?.close || '23:00:00',
+        billableCalculation: clientData?.featureConfigs?.billableCalculation || 'engagers-count',
+        conversionCalculation: clientData?.featureConfigs?.conversionCalculation || 'engagers-count',
+        missedOpportunityCalculation: clientData?.featureConfigs?.missedOpportunityCalculation || 'engagers-conversion',
+        bufferTime: 30,
+      },
+    };
+    // console.log( 'templateData =>', templateData );
+
+    // // Get Lamda Metrics Data ////
+    let lamdaMetrics = await getLamdaMetricsData( templateData );
+
+    // // Get Lamda Chart Data ///
+    let lamdaCharts = await getLamdaChartData( templateData );
+
+    // // Call Send Email Function ////
+    let emailStatus = await emailerSendEmail( storeData, clientData, lamdaMetrics, lamdaCharts, templateData );
+
+    // return res.sendSuccess( 'Email Send Successfully' );
+    // // Once Email Successfully Send Update Status to Completed ////
+    if ( emailStatus ) {
+      const document = {
+        doc: {
+          status: 'open',
+          // fromDate: '2025-01-13',
+          // toDate: '2025-01-19',
+          // status: 'completed',
+          // storeIds: [ '430-8' ],
+        },
+      };
+      let updateResult = await updateOpenSearchData( JSON.parse( process.env.OPENSEARCH ).emailers, requestBody._id, document );
+      if ( updateResult?.statusCode == 200 && updateResult?.body?.result == 'updated' ) {
+        return res.sendSuccess( 'Email Send Successfully' );
+      } else {
+        return res.sendSuccess( 'Email Send Successfully' );
+        // return res.sendError( { error: error }, 500 );
+      }
+    }
+  } catch ( error ) {
+    // console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'sendEmails' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+async function getLamdaMetricsData( templateData ) {
+  try {
+    let resultLamdaMetricsData;
+    if ( templateData.allStores.length == 1 && templateData.templateType == 'daily' ) {
+      // // Call Lamda API No 1 Single Store Single Date
+      // API Number: 1 (Daily Emailer With Single Store)
+      resultLamdaMetricsData = await lamdaAPI1( templateData );
+      return resultLamdaMetricsData;
+    } else if ( templateData.allStores.length > 1 && templateData.templateType == 'daily' ) {
+      // // Call Lamda API No 2 Multiple Store Single Date
+      // API Number: 3 (Daily Emailer With Multi Stores)
+      resultLamdaMetricsData = await lamdaAPI3( templateData );
+      return resultLamdaMetricsData;
+    } else if ( templateData.allStores.length == 1 && templateData.templateType == 'weekly' ) {
+      // // Call Lamda API No 3 Single Store Multiple Date
+      // API Number: 2 (Weekly Emailer With Single Store)
+      resultLamdaMetricsData = await lamdaAPI2( templateData );
+      return resultLamdaMetricsData;
+    } else if ( templateData.allStores.length > 1 && templateData.templateType == 'weekly' ) {
+      // // Call Lamda API No 4 Multiple Store Multiple Date
+      // API Number: 4 (Weekly Emailer With Multi Stores)
+      resultLamdaMetricsData = await lamdaAPI4( templateData );
+      return resultLamdaMetricsData;
+    } else if ( templateData.allStores.length == 1 && templateData.templateType == 'monthly' ) {
+      // // Call Lamda API No 5 Single Store Multiple Date
+
+    } else if ( templateData.allStores.length > 1 && templateData.templateType == 'monthly' ) {
+      // // Call Lamda API No 6 Multiple Store Multiple Date
+
+    } else {
+      // Default Value
+    }
+  } catch ( error ) {
+    // console.log( 'error =>', error );
+    logger.error( { error: error, function: 'getLamdaMetricsData' } );
+    return false;
+  }
+}
+
+async function lamdaAPI1( templateData ) {
+  try {
+    // let lamdaAPIResultData = {
+    //   'status_code': '200',
+    //   'emailerCards': {
+    //     'footfall': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89, // Daily => sameDayLastWeek
+    //       'lastWeekComparisonFlag': false, // Daily => sameDayLastWeekComparisonFlag
+    //       'vsMTDAvgRate': 60,
+    //       'vsMTDAvgComparisonFlag': true,
+    //     },
+    //     'potentialBuyers': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89, // Daily => sameDayLastWeek
+    //       'lastWeekComparisonFlag': true, // Daily => sameDayLastWeekComparisonFlag
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'conversion': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89, // Daily => sameDayLastWeek
+    //       'lastWeekComparisonFlag': true, // Daily => sameDayLastWeekComparisonFlag
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'avgDwellTime': {
+    //       'dwellTime': 100,
+    //       'lastWeekRate': 89, // Daily => sameDayLastWeek
+    //       'lastWeekComparisonFlag': true, // Daily => sameDayLastWeekComparisonFlag
+    //       'vsMTDAvg': 70,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'operationalHours': {
+    //       'openTime': '09:00 AM',
+    //       'closeTime': '10:00 PM',
+    //     },
+    //   },
+    //   'highestFootfall': {
+    //     'PeekFootfallBetween': '04:00 PM - 06:00 PM',
+    //     'customerCount': 60,
+    //     'vsSameDayLastWeekRate': 20,
+    //     'vsSameDayLastWeekComparisonFlag': true,
+    //   },
+    // };
+    let newTemplateData = templateData;
+
+    // newTemplateData.dateType = 'daily';
+    // newTemplateData.valueType = 'actual';
+    // newTemplateData.filterBy = 'actual';
+    // newTemplateData.nob = false;
+    // newTemplateData.processType = 'conversion';
+    // newTemplateData.limit = 20;
+    // newTemplateData.offset = 0;
+
+    const overallLamdaURL = 'https://qkox3l2cg5qhblymaie7qlgku40toykp.lambda-url.ap-south-1.on.aws/';
+    let lamdaAPIResultData = await LamdaServiceCall( overallLamdaURL, newTemplateData );
+    if ( !lamdaAPIResultData || lamdaAPIResultData.status_code !== '200' ) {
+      return '';
+    }
+    return lamdaAPIResultData;
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'lamdaAPI1' } );
+    return false;
+  }
+}
+
+async function lamdaAPI2( templateData ) {
+  try {
+    // let lamdaAPIResultData = {
+    //   'status_code': '200',
+    //   'emailerCards': {
+    //     'footfall': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89,
+    //       'lastWeekComparisonFlag': true,
+    //       'vsMTDAvgRate': 60,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'potentialBuyers': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89,
+    //       'lastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': true,
+    //     },
+    //     'conversion': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89,
+    //       'lastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': true,
+    //     },
+    //     'avgDwellTime': {
+    //       'dwellTime': 100,
+    //       'lastWeekRate': 89,
+    //       'lastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': true,
+    //     },
+    //     'operationalHours': {
+    //       'lastWeekRate': 89,
+    //       'lastWeekComparisonFlag': false,
+    //       'lateOpenDays': 3,
+    //       'earlyCloseDays': 5,
+    //     },
+    //   },
+    //   'highestFootfall': {
+    //     'PeekFootfallDay': 'Sunday',
+    //     'customerCount': 60,
+    //     'PeekFootfallBetween': '04:00 PM - 06:00 PM',
+    //     'vsLastWeekRate': 20,
+    //     'vsLastWeekComparisonFlag': false,
+    //   },
+    //   'highestWeekdayFootfall': {
+    //     'PeekFootfallDay': 'Sunday',
+    //     'customerCount': 60,
+    //     'PeekFootfallBetween': '04:00 PM - 06:00 PM',
+    //     'vsLastWeekRate': 20,
+    //     'vsLastWeekComparisonFlag': false,
+    //   },
+    //   'storeHeath': {
+    //     'storeHeath': 'Good', // ["Red","Amber", "Good"]
+    //   },
+    // };
+    let newTemplateData = templateData;
+    const overallLamdaURL = 'https://6mgiyf73ktst7nskse7zn5zcxy0ptezt.lambda-url.ap-south-1.on.aws/';
+    let lamdaAPIResultData = await LamdaServiceCall( overallLamdaURL, newTemplateData );
+    if ( !lamdaAPIResultData || lamdaAPIResultData.status_code !== '200' ) {
+      return '';
+    }
+    return lamdaAPIResultData;
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'lamdaAPI2' } );
+    return false;
+  }
+}
+
+async function lamdaAPI3( templateData ) {
+  try {
+    // let lamdaAPIResultData = {
+    //   'status_code': '200',
+    //   'emailerCards': {
+    //     'avgFootfall': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89, // Daily => sameDayLastWeek
+    //       'lastWeekComparisonFlag': true, // Daily => sameDayLastWeekComparisonFlag
+    //       'vsMTDAvgRate': 60,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'avgPotentialBuyers': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89, // Daily => sameDayLastWeek
+    //       'lastWeekComparisonFlag': false, // Daily => sameDayLastWeekComparisonFlag
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': true,
+    //     },
+    //     'avgConversion': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89, // Daily => sameDayLastWeek
+    //       'lastWeekComparisonFlag': false, // Daily => sameDayLastWeekComparisonFlag
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': true,
+    //     },
+    //     'avgDwellTime': {
+    //       'dwellTime': 100,
+    //       'lastWeekRate': 89, // Daily => sameDayLastWeek
+    //       'lastWeekComparisonFlag': false, // Daily => sameDayLastWeekComparisonFlag
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': true,
+    //     },
+    //     'avgOperationalHours': {
+    //       'avgOperationalHours': 9,
+    //       'lastWeekRate': 30,
+    //       'lastWeekComparisonFlag': true,
+    //     },
+    //   },
+    //   'conversionMetrics': {
+    //     'highEngagers': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'lowEngagers': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'highPotentialBuyers': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'lowPotentialBuyers': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'highFootfallCount': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'lowFootfallCount': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //   },
+    //   'lowOperationalHours': [
+    //     { 'storeName': 'LKST2025', 'storeId': '11-2025' },
+    //     { 'storeName': 'LKST2024', 'storeId': '11-2024' },
+    //     { 'storeName': 'LKST2023', 'storeId': '11-2023' },
+    //   ],
+    //   'fullDownTime': [
+    //     { 'storeName': 'LKST2025', 'storeId': '11-2025' },
+    //     { 'storeName': 'LKST2024', 'storeId': '11-2024' },
+    //     { 'storeName': 'LKST2023', 'storeId': '11-2023' },
+    //   ],
+    // };
+    let newTemplateData = templateData;
+    const overallLamdaURL = 'https://bqk7ozecu7smfrzyb2hbb5lo540avjkl.lambda-url.ap-south-1.on.aws/';
+    let lamdaAPIResultData = await LamdaServiceCall( overallLamdaURL, newTemplateData );
+    if ( !lamdaAPIResultData || lamdaAPIResultData.status_code !== 200 ) {
+      return '';
+    }
+    return lamdaAPIResultData;
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'lamdaAPI2' } );
+    return false;
+  }
+}
+
+
+async function lamdaAPI4( templateData ) {
+  try {
+    // let lamdaAPIResultData = {
+    //   'status_code': '200',
+    //   'emailerCards': {
+    //     'avgFootfall': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89,
+    //       'lastWeekComparisonFlag': true,
+    //       'vsMTDAvgRate': 60,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'avgPotentialBuyers': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89,
+    //       'lastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': true,
+    //     },
+    //     'avgConversion': {
+    //       'totalCount': 100,
+    //       'lastWeekRate': 89,
+    //       'lastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': true,
+    //     },
+    //     'avgDwellTime': {
+    //       'dwellTime': 100,
+    //       'lastWeekRate': 89,
+    //       'lastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 70,
+    //       'vsMTDAvgComparisonFlag': true,
+    //     },
+    //     'avgOperationalHours': {
+    //       'lastWeekRate': 89,
+    //       'lastWeekComparisonFlag': false,
+    //       'lateOpenDays': 3,
+    //       'earlyCloseDays': 5,
+    //     },
+    //   },
+    //   'conversionMetrics': {
+    //     'highEngagers': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'lowEngagers': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'highPotentialBuyers': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'lowPotentialBuyers': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'highFootfallCount': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //     'lowFootfallCount': {
+    //       'storeName': 'LKST2025',
+    //       'storeId': '11-2025',
+    //       'vsSameDayLastWeekRate': 20,
+    //       'vsSameDayLastWeekComparisonFlag': false,
+    //       'vsMTDAvgRate': 20,
+    //       'vsMTDAvgComparisonFlag': false,
+    //     },
+    //   },
+    //   'avgWeekdayFootfall': {
+    //     'weekDay': 'Sunday',
+    //     'customerCount': 60,
+    //     'PeekFootfallBetween': '04:00 PM - 06:00 PM',
+    //     'vsLastWeekRate': 20,
+    //     'vsLastWeekComparisonFlag': false,
+    //   },
+    //   'lowOperationalHours': [
+    //     { 'storeName': 'LKST2025', 'storeId': '11-2025' },
+    //     { 'storeName': 'LKST2024', 'storeId': '11-2024' },
+    //     { 'storeName': 'LKST2023', 'storeId': '11-2023' },
+    //   ],
+    //   'fullDownTime': [
+    //     { 'storeName': 'LKST2025', 'storeId': '11-2025' },
+    //     { 'storeName': 'LKST2024', 'storeId': '11-2024' },
+    //     { 'storeName': 'LKST2023', 'storeId': '11-2023' },
+    //   ],
+    // };
+    let newTemplateData = templateData;
+    const overallLamdaURL = 'https://7ozawm36scwmwhh4vzkecqkgv40lpjxt.lambda-url.ap-south-1.on.aws/';
+    let lamdaAPIResultData = await LamdaServiceCall( overallLamdaURL, newTemplateData );
+    if ( !lamdaAPIResultData || lamdaAPIResultData.status_code !== '200' ) {
+      return '';
+    }
+    return lamdaAPIResultData;
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'lamdaAPI4' } );
+    return false;
+  }
+}
+
+async function hourlyChartLamdaAPI( templateData ) {
+  try {
+    // console.log( 'hourlyChartLamdaAPI' );
+    const bucketDetails = JSON.parse( process.env.BUCKET );
+    let hourlyChartUrl;
+
+    // let lamdaAPIResultData = {
+    //   'status_code': 200,
+    //   'hourlyData': [
+    //     { rate: 6, count: 22, time: '01:00' },
+    //     { rate: 1, count: 2, time: '03:00' },
+    //     { rate: 1, count: 3, time: '05:00' },
+    //     { rate: 10, count: 36, time: '07:00' },
+    //     { rate: 6, count: 21, time: '09:00' },
+    //     { rate: 8, count: 32, time: '11:00' },
+    //     { rate: 7, count: 28, time: '13:00' },
+    //     { rate: 15, count: 56, time: '15:00' },
+    //     { rate: 12, count: 47, time: '17:00' },
+    //     { rate: 12, count: 47, time: '19:00' },
+    //     { rate: 10, count: 36, time: '21:00' },
+    //     { rate: 13, count: 48, time: '23:59' },
+    //   ],
+    // };
+    // return lamdaAPIResultData;
+
+    let newTemplateData = templateData;
+    newTemplateData.valueType = 'actual';
+    newTemplateData.nob = false;
+    newTemplateData.processType = 'footfall';
+    newTemplateData.limit = 20;
+    newTemplateData.offset = 0;
+
+    const overallLamdaURL = 'https://okpiyyhjvzbopvufnburhf3ase0hjfnl.lambda-url.ap-south-1.on.aws/';
+    let lamdaAPIResultData = await LamdaServiceCall( overallLamdaURL, newTemplateData );
+    if ( !lamdaAPIResultData || lamdaAPIResultData.status_code !== 200 ) {
+      return hourlyChartUrl;
+    }
+
+    let hourlyData = lamdaAPIResultData.hourlyData || [];
+    let hourlyChartImagePath = await overallHourlyChart( hourlyData );
+
+    // Upload hourly chart
+    const hourlyChartParams = {
+      Bucket: bucketDetails.mailer,
+      Key: `${dayjs().format( 'YYYY-MM-DD-HH:mm:ss' )}/mail/emailHourlyUserChart.png`,
+      ContentType: 'image/png',
+      body: hourlyChartImagePath,
+    };
+
+    const hourlyChartResponse = await fileUpload( hourlyChartParams );
+    if ( hourlyChartResponse && hourlyChartResponse.Key ) {
+      hourlyChartUrl = await signedUrl( {
+        Bucket: bucketDetails.mailer,
+        file_path: hourlyChartResponse.Key,
+      } );
+    } else {
+      throw new Error( 'S3 Upload failed for hourly chart' );
+    }
+
+    return hourlyChartUrl;
+  } catch ( error ) {
+    // console.log( ' error hourlyChartLamdaAPI=>', error );
+    logger.error( { error: error, function: 'hourlyChartLamdaAPI' } );
+    return false;
+  }
+}
+
+async function dailyChartLamdaAPI( templateData ) {
+  try {
+    const bucketDetails = JSON.parse( process.env.BUCKET );
+    let chartUrl;
+
+    // let lamdaAPIResultData = {
+    //   'status_code': '200',
+    //   'storeData': [ { count: 378, storeName: 'VS T1', storeId: '430-8' } ],
+    //   'totalCount': 1,
+    // };
+    // return lamdaAPIResultData;
+
+    let newTemplateData = templateData;
+    newTemplateData.valueType = 'actual';
+    newTemplateData.nob = false;
+    newTemplateData.processType = 'footfall';
+    newTemplateData.limit = 20;
+    newTemplateData.offset = 0;
+    const overallLamdaURL = 'https://eboa7d5kzefml2srjo567sbxoe0bzmog.lambda-url.ap-south-1.on.aws/';
+    let lamdaAPIResultData = await LamdaServiceCall( overallLamdaURL, newTemplateData );
+    // console.log( 'newTemplateData =>', newTemplateData );
+    // console.log( 'lamdaAPIResultData =>', lamdaAPIResultData );
+    if ( !lamdaAPIResultData || lamdaAPIResultData.status_code !== '200' ) {
+      return chartUrl;
+    }
+
+    let dailyData = lamdaAPIResultData.storeData || [];
+    let chartImagePath = await overallChart( dailyData );
+    // Upload overall chart
+    const overallChartParams = {
+      Bucket: bucketDetails.mailer,
+      Key: `${dayjs().format( 'YYYY-MM-DD-HH:mm:ss' )}/mail/emaildailyUserChart.png`,
+      ContentType: 'image/png',
+      body: chartImagePath,
+    };
+    const overallChartResponse = await fileUpload( overallChartParams );
+    if ( overallChartResponse && overallChartResponse.Key ) {
+      chartUrl = await signedUrl( {
+        Bucket: bucketDetails.mailer,
+        file_path: overallChartResponse.Key,
+      } );
+    } else {
+      throw new Error( 'S3 Upload failed for overall chart' );
+    }
+
+    return chartUrl;
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'dailyChartLamdaAPI' } );
+    return false;
+  }
+}
+
+async function dailyFootfallTrendChartLamdaAPI( templateData ) {
+  try {
+    const bucketDetails = JSON.parse( process.env.BUCKET );
+    let chartUrl;
+
+    // let lamdaAPIResultData = {
+    //   'fromDate': '2025-01-02',
+    //   'status_code': '200',
+    //   'toDate': '2025-01-08',
+    //   'totalCount': 7,
+    //   'footfallTrendData': [
+    //     {
+    //       'engagers_count': 39,
+    //       'footfallGroupCount': 37,
+    //       'down_time': '0%',
+    //       'conversion_count': 16,
+    //       'bounced_footfall_count_avg': 1,
+    //       'engagersGroupCount': 36,
+    //       'storeId': '11-1002',
+    //       'conversionRate': 40,
+    //       'bounced_count': 1,
+    //       'footfall_count': 40,
+    //       'potentialBuyers_count': 36,
+    //       'footfall_count_avg': 40,
+    //       'avgDwellTime': 21,
+    //       'engagers_count_avg': 39,
+    //       'storeName': '2025-01-03',
+    //       'missedOpportunity_count_avg': 4,
+    //       'missedOpportunity_count': 4,
+    //     },
+    //     {
+    //       'engagers_count': 51,
+    //       'footfallGroupCount': 48,
+    //       'down_time': '0%',
+    //       'conversion_count': 31,
+    //       'bounced_footfall_count_avg': 6,
+    //       'engagersGroupCount': 43,
+    //       'storeId': '11-1002',
+    //       'conversionRate': 54,
+    //       'bounced_count': 6,
+    //       'footfall_count': 57,
+    //       'potentialBuyers_count': 43,
+    //       'footfall_count_avg': 57,
+    //       'avgDwellTime': 32,
+    //       'engagers_count_avg': 51,
+    //       'storeName': '2025-01-08',
+    //       'missedOpportunity_count_avg': 1,
+    //       'missedOpportunity_count': 1,
+    //     },
+    //     {
+    //       'engagers_count': 79,
+    //       'footfallGroupCount': 80,
+    //       'down_time': '1%',
+    //       'conversion_count': 44,
+    //       'bounced_footfall_count_avg': 8,
+    //       'engagersGroupCount': 72,
+    //       'storeId': '11-1002',
+    //       'conversionRate': 51,
+    //       'bounced_count': 8,
+    //       'footfall_count': 87,
+    //       'potentialBuyers_count': 72,
+    //       'footfall_count_avg': 87,
+    //       'avgDwellTime': 38,
+    //       'engagers_count_avg': 79,
+    //       'storeName': '2025-01-06',
+    //       'missedOpportunity_count_avg': 10,
+    //       'missedOpportunity_count': 10,
+    //     },
+    //     {
+    //       'engagers_count': 70,
+    //       'footfallGroupCount': 63,
+    //       'down_time': '0%',
+    //       'conversion_count': 33,
+    //       'bounced_footfall_count_avg': 1,
+    //       'engagersGroupCount': 62,
+    //       'storeId': '11-1002',
+    //       'conversionRate': 46,
+    //       'bounced_count': 1,
+    //       'footfall_count': 71,
+    //       'potentialBuyers_count': 62,
+    //       'footfall_count_avg': 71,
+    //       'avgDwellTime': 35,
+    //       'engagers_count_avg': 70,
+    //       'storeName': '2025-01-05',
+    //       'missedOpportunity_count_avg': 5,
+    //       'missedOpportunity_count': 5,
+    //     },
+    //     {
+    //       'engagers_count': 45,
+    //       'footfallGroupCount': 43,
+    //       'down_time': '1%',
+    //       'conversion_count': 23,
+    //       'bounced_footfall_count_avg': 2,
+    //       'engagersGroupCount': 41,
+    //       'storeId': '11-1002',
+    //       'conversionRate': 49,
+    //       'bounced_count': 2,
+    //       'footfall_count': 47,
+    //       'potentialBuyers_count': 41,
+    //       'footfall_count_avg': 47,
+    //       'avgDwellTime': 32,
+    //       'engagers_count_avg': 45,
+    //       'storeName': '2025-01-02',
+    //       'missedOpportunity_count_avg': 7,
+    //       'missedOpportunity_count': 7,
+    //     },
+    //     {
+    //       'engagers_count': 70,
+    //       'footfallGroupCount': 68,
+    //       'down_time': '1%',
+    //       'conversion_count': 36,
+    //       'bounced_footfall_count_avg': 8,
+    //       'engagersGroupCount': 60,
+    //       'storeId': '11-1002',
+    //       'conversionRate': 46,
+    //       'bounced_count': 8,
+    //       'footfall_count': 78,
+    //       'potentialBuyers_count': 60,
+    //       'footfall_count_avg': 78,
+    //       'avgDwellTime': 31,
+    //       'engagers_count_avg': 70,
+    //       'storeName': '2025-01-04',
+    //       'missedOpportunity_count_avg': 5,
+    //       'missedOpportunity_count': 5,
+    //     },
+    //     {
+    //       'engagers_count': 60,
+    //       'footfallGroupCount': 61,
+    //       'down_time': '1%',
+    //       'conversion_count': 23,
+    //       'bounced_footfall_count_avg': 6,
+    //       'engagersGroupCount': 55,
+    //       'storeId': '11-1002',
+    //       'conversionRate': 35,
+    //       'bounced_count': 6,
+    //       'footfall_count': 66,
+    //       'potentialBuyers_count': 55,
+    //       'footfall_count_avg': 66,
+    //       'avgDwellTime': 28,
+    //       'engagers_count_avg': 60,
+    //       'storeName': '2025-01-07',
+    //       'missedOpportunity_count_avg': 6,
+    //       'missedOpportunity_count': 6,
+    //     },
+    //   ],
+    // };
+    // return lamdaAPIResultData;
+
+    let newTemplateData = templateData;
+    // newTemplateData.dateType = 'weekly';
+    let processTypeValue = 'engagers';
+    if ( templateData.featureConfigs.conversionCalculation !== 'engagers-count' ) {
+      processTypeValue='potentialBuyer';
+    }
+    let filterByTypeValue = 'average';
+    if ( templateData.templateType == 'daily' ) {
+      filterByTypeValue='actual';
+    }
+    newTemplateData.dateType = templateData.templateType;
+    newTemplateData.valueType = 'actual';
+    newTemplateData.filterBy = filterByTypeValue;
+    newTemplateData.nob = false;
+    newTemplateData.processType = processTypeValue;
+    newTemplateData.limit = 31;
+    newTemplateData.offset = 0;
+    const overallLamdaURL = 'https://x6sjlqwaqd64kyioxhwrwfesbm0jjitx.lambda-url.ap-south-1.on.aws/';
+    let lamdaAPIResultData = await LamdaServiceCall( overallLamdaURL, newTemplateData );
+    if ( !lamdaAPIResultData || lamdaAPIResultData.status_code !== '200' ) {
+      return chartUrl;
+    }
+
+    let dailyData = lamdaAPIResultData.footfallTrendData || [];
+    let chartImagePath = await footfallTrend( dailyData );
+    // Upload overall chart
+    const overallChartParams = {
+      Bucket: bucketDetails.mailer,
+      Key: `${dayjs().format( 'YYYY-MM-DD-HH:mm:ss' )}/mail/emailweeklyUserChart.png`,
+      ContentType: 'image/png',
+      body: chartImagePath,
+    };
+    const overallChartResponse = await fileUpload( overallChartParams );
+    if ( overallChartResponse && overallChartResponse.Key ) {
+      chartUrl = await signedUrl( {
+        Bucket: bucketDetails.mailer,
+        file_path: overallChartResponse.Key,
+      } );
+    } else {
+      throw new Error( 'S3 Upload failed for overall chart' );
+    }
+
+    return chartUrl;
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'dailyFootfallTrendChartLamdaAPI' } );
+    return false;
+  }
+}
+
+async function getLamdaChartData( templateData ) {
+  try {
+    let resultLamdaChartData = {
+      dailyData: '',
+      hourlyData: '',
+    };
+    if ( templateData.allStores.length == 1 && templateData.templateType == 'daily' ) {
+      // // Call Lamda API No 1 Single Store Single Date
+      const [ chartImagePath, hourlyChartImagePath ] = await Promise.all( [
+        dailyChartLamdaAPI( templateData ), // For the overall chart (col-8)
+        hourlyChartLamdaAPI( templateData ), // For the hourly chart (col-4)
+      ] );
+      resultLamdaChartData.dailyData = chartImagePath;
+      resultLamdaChartData.hourlyData = hourlyChartImagePath;
+      return resultLamdaChartData;
+    } else {
+      // Default Value
+      resultLamdaChartData.dailyFootfallTrendData = await dailyFootfallTrendChartLamdaAPI( templateData );
+      return resultLamdaChartData;
+    }
+  } catch ( error ) {
+    // console.log( 'error =>', error );
+    logger.error( { error: error, function: 'getLamdaChartData' } );
+    return false;
+  }
+}
+
+async function emailerSendEmail( storeData, clientData, lamdaMetrics, lamdaCharts, templateData ) {
+  try {
+    let hbsFileName = '../hbs/dailyMailerSingle.hbs';
+    if ( templateData.allStores.length == 1 && templateData.templateType == 'daily' ) {
+      // // Call Lamda API No 1 Single Store Single Date
+      hbsFileName = '../hbs/dailyMailerSingle.hbs';
+    } else if ( templateData.allStores.length > 1 && templateData.templateType == 'daily' ) {
+      // // Call Lamda API No 3 Multiple Store Single Date
+      hbsFileName = '../hbs/dailyMailerMultiple.hbs';
+    } else if ( templateData.allStores.length == 1 && templateData.templateType == 'weekly' ) {
+      // // Call Lamda API No 2 Single Store Multiple Date
+      hbsFileName = '../hbs/weeklyMailerSingle.hbs';
+    } else if ( templateData.allStores.length > 1 && templateData.templateType == 'weekly' ) {
+      // // Call Lamda API No 4 Multiple Store Multiple Date
+      hbsFileName = '../hbs/weeklyMailerMultiple.hbs';
+    } else if ( templateData.allStores.length == 1 && templateData.templateType == 'monthly' ) {
+      // // Call Lamda API No 5 Single Store Multiple Date
+      hbsFileName = '../hbs/dailyMailerSingle.hbs';
+    } else if ( templateData.allStores.length > 1 && templateData.templateType == 'monthly' ) {
+      // // Call Lamda API No 6 Multiple Store Multiple Date
+      hbsFileName = '../hbs/dailyMailerSingle.hbs';
+    } else {
+      // Default Value
+    }
+    // Prepare email with Handlebars template
+    const fileContent = readFileSync(
+        join( __dirname, hbsFileName ),
+        'utf8',
+    );
+    const htmlContent = handlebars.compile( fileContent );
+
+    const emailVars = {
+    // email: inputData.email,
+      clientName: clientData.clientName,
+      domain: JSON.parse( process.env.URL ).apiDomain,
+      overallChartImage: lamdaCharts.dailyData, // Use the S3 URL for the overall chart
+      hourlyChartImage: lamdaCharts.hourlyData, // Use the S3 URL for the hourly chart
+      lamdaMetrics: lamdaMetrics,
+      storeData: storeData,
+      templateData: templateData,
+      chartImage: lamdaCharts.dailyFootfallTrendData,
+      featureConfigs: {
+        open: clientData?.featureConfigs?.open || '10:00:00',
+        close: clientData?.featureConfigs?.close || '23:00:00',
+        billableCalculation: clientData?.featureConfigs?.billableCalculation || 'engagers-count',
+        conversionCalculation: clientData?.featureConfigs?.conversionCalculation || 'engagers-count',
+        missedOpportunityCalculation: clientData?.featureConfigs?.missedOpportunityCalculation || 'engagers-conversion',
+        bufferTime: 30,
+      },
+    };
+
+    const html = htmlContent( { data: emailVars } );
+
+    // Prepare email subject and send the email
+    const subject = `Footfall Trend Report for ${clientData.clientName}`;
+    const ses = JSON.parse( process.env.SES );
+
+    // templateData.userEmail
+    await sendEmailWithSES(
+        'nafila@tangotech.co.in',
+        subject,
+        html,
+        '',
+        ses.adminEmail,
+    );
+
+    // return res.sendSuccess( { result: 'EMAIL-SENT' } );
+
+    return true;
+  } catch ( error ) {
+    logger.error( { error: error, function: 'emailerSendEmail' } );
+    return false;
+  }
+}
+
+const overallChart = async ( data ) => {
+  // console.log( 'Generating footfall chart...' );
+
+  // let chartImagePath = path.resolve( __dirname, 'emailchart-image.png' );
+  // console.log( 'Chart Image Path:', chartImagePath );
+
+  const browser = await puppeteer.launch( { headless: true } );
+  const page = await browser.newPage();
+
+  const chartHtmlContent = `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <style>
+        #testGraphics {
+          width: 100%;
+          height: 600px;
+        }
+      </style>
+      <script src="https://cdn.amcharts.com/lib/5/index.js"></script>
+      <script src="https://cdn.amcharts.com/lib/5/xy.js"></script>
+      <script src="https://cdn.amcharts.com/lib/5/themes/Animated.js"></script>
+    </head>
+    <body>
+      <div id="testGraphics"></div>
+      <script>
+        am5.ready(function() {
+          const root = am5.Root.new("testGraphics");
+          root.setThemes([am5themes_Animated.new(root)]);
+ 
+          const chart = root.container.children.push(
+            am5xy.XYChart.new(root, {
+              panX: true,
+              panY: true,
+              wheelX: "panX",
+              wheelY: "zoomX",
+              pinchZoomX: true,
+              paddingLeft: 0,
+              paddingRight: 0,
+              width: am5.percent(100),
+            })
+          );
+ 
+          const cursor = chart.set("cursor", am5xy.XYCursor.new(root, {}));
+          cursor.lineY.set("visible", false);
+ 
+          const xRenderer = am5xy.AxisRendererX.new(root, {
+            minGridDistance: 30,
+            minorGridEnabled: true,
+          });
+ 
+          xRenderer.labels.template.setAll({
+            rotation: -45,
+            centerY: am5.p50,
+            centerX: am5.p100,
+            paddingRight: 5,
+          });
+ 
+          const xAxis = chart.xAxes.push(
+            am5xy.CategoryAxis.new(root, {
+              categoryField: "storeName",
+              renderer: xRenderer,
+            })
+          );
+ 
+          const yRenderer = am5xy.AxisRendererY.new(root, {
+            strokeOpacity: 0.1,
+          });
+ 
+          const yAxis = chart.yAxes.push(
+            am5xy.ValueAxis.new(root, {
+              renderer: yRenderer,
+            })
+          );
+ 
+          const formattedData = ${JSON.stringify( data )}.map((item) => ({
+            storeName: item.storeName,
+            value: Number(item.count),
+          }));
+ 
+          const series = chart.series.push(
+            am5xy.ColumnSeries.new(root, {
+              xAxis: xAxis,
+              yAxis: yAxis,
+              valueYField: "value",
+              categoryXField: "storeName",
+            })
+          );
+ 
+          xAxis.data.setAll(formattedData);
+          series.data.setAll(formattedData);
+ 
+          series.columns.template.setAll({ strokeOpacity: 0 });
+ 
+          series.appear(1000);
+          chart.appear(1000, 100);
+        });
+      </script>
+    </body>
+    </html>
+  `;
+  let chartBuffer;
+  try {
+    // console.log( 'overallChart... Try' );
+    await page.setContent( chartHtmlContent, { waitUntil: 'domcontentloaded' } );
+    await page.waitForSelector( '#testGraphics', { visible: true } );
+    chartBuffer = await page.screenshot( { encoding: 'binary' } );
+    // console.log( 'Screenshot saved to:', chartImagePath );
+  } catch ( err ) {
+    // console.error( 'Error generating chart screenshot:', err );
+    throw new Error( 'Failed to generate chart screenshot' );
+  } finally {
+    await browser.close();
+  }
+  // console.log( 'chartBuffer daily... Try', chartBuffer );
+  return chartBuffer;
+};
+
+const overallHourlyChart = async ( data ) => {
+  // console.log( 'Generating heatmap chart...' );
+
+  const browser = await puppeteer.launch( { headless: true } );
+  const page = await browser.newPage();
+
+  const chartHtmlContent = `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <style>
+        #heatmapchart {
+          width: 100%;
+          height: 600px;
+        }
+      </style>
+      <script src="https://cdn.amcharts.com/lib/5/index.js"></script>
+      <script src="https://cdn.amcharts.com/lib/5/xy.js"></script>
+      <script src="https://cdn.amcharts.com/lib/5/themes/Animated.js"></script>
+      <script src="https://cdn.amcharts.com/lib/5/themes/Responsive.js"></script>
+    </head>
+    <body>
+      <div id="heatmapchart"></div>
+      <script>
+        am5.ready(function () {
+          const root = am5.Root.new("heatmapchart");
+          root.setThemes([am5themes_Animated.new(root), am5themes_Responsive.new(root)]);
+ 
+          // Create chart
+          const chart = root.container.children.push(
+            am5xy.XYChart.new(root, {
+              panX: false,
+              panY: false,
+              wheelX: "none",
+              wheelY: "none",
+              paddingLeft: 0,
+              layout: root.verticalLayout,
+            })
+          );
+ 
+          // Create axes and renderers
+          const yRenderer = am5xy.AxisRendererY.new(root, {
+            minGridDistance: 20,
+            inversed: true,
+            opposite: true,
+            minorGridEnabled: true,
+          });
+ 
+          yRenderer.grid.template.set("visible", false);
+ 
+          const yAxis = chart.yAxes.push(
+            am5xy.CategoryAxis.new(root, {
+              renderer: yRenderer,
+              categoryField: "time",
+            })
+          );
+ 
+          const xRenderer = am5xy.AxisRendererX.new(root, {
+            minGridDistance: 30,
+            opposite: true,
+            minorGridEnabled: true,
+          });
+ 
+          xRenderer.grid.template.set("visible", false);
+ 
+          const xAxis = chart.xAxes.push(
+            am5xy.CategoryAxis.new(root, {
+              renderer: xRenderer,
+              categoryField: "weekday",
+            })
+          );
+ 
+          // Create series
+          const series = chart.series.push(
+            am5xy.ColumnSeries.new(root, {
+              calculateAggregates: true,
+              stroke: am5.color(0xffffff),
+              clustered: false,
+              xAxis: xAxis,
+              yAxis: yAxis,
+              categoryXField: "weekday",
+              categoryYField: "time",
+              valueField: "rate",
+            })
+          );
+ 
+          series.columns.template.setAll({
+            tooltipText: "{rate}",
+            strokeOpacity: 1,
+            strokeWidth: 2,
+            width: am5.percent(100),
+            height: am5.percent(100),
+            fill: am5.color(0xffffff),
+          });
+ 
+          // Apply range-based color rules
+          series.columns.template.adapters.add("fill", (fill, target) => {
+            const dataItem = target.dataItem?.dataContext;
+            if (dataItem && dataItem.rate !== undefined) {
+              const rate = dataItem.rate;
+              if (rate >= 0 && rate <= 10) {
+                return am5.color(0xEAF8FF);
+              } else if (rate > 10 && rate <= 20) {
+                return am5.color(0xCCE9FE);
+              } else if (rate > 20 && rate <= 30) {
+                return am5.color(0xB0D6FC);
+              } else if (rate > 30 && rate <= 40) {
+                return am5.color(0x94C2FA);
+              } else if (rate > 40 && rate <= 55) {
+                return am5.color(0x78A9F8);
+              } else if (rate > 55 && rate <= 75) {
+                return am5.color(0x99D2FD);
+              } else if (rate > 75 && rate <= 90) {
+                return am5.color(0x66BCFD);
+              } else if (rate > 90 && rate <= 100) {
+                return am5.color(0x3460F3);
+              } else {
+                return am5.color(0xFFF);
+              }
+            }
+            return fill;
+          });
+ 
+          series.bullets.push(() =>
+            am5.Bullet.new(root, {
+              sprite: am5.Label.new(root, {
+                text: "{rate.formatNumber('#.#')}%",
+                fill: am5.color(0x000000),
+                centerY: am5.p50,
+                centerX: am5.p50,
+                populateText: true,
+                fontSize: 16,
+                fontWeight: "bold",
+              }),
+            })
+          );
+ 
+          // Format data
+          const formattedData = ${JSON.stringify( data )}.map((item) => ({
+            ...item,
+            weekday: "Hourly Data",
+          }));
+ 
+          series.data.setAll(formattedData);
+ 
+          // Set axis data
+          const times = Array.from(new Set(formattedData.map((item) => item.time)));
+ 
+          xAxis.data.setAll([{ weekday: "Hourly Data" }]);
+          yAxis.data.setAll(times.map((time) => ({ time })));
+ 
+          chart.appear(1000, 100);
+        });
+      </script>
+    </body>
+    </html>
+  `;
+
+  let chartBuffer;
+  try {
+    await page.setContent( chartHtmlContent, { waitUntil: 'domcontentloaded' } );
+    await page.waitForSelector( '#heatmapchart', { visible: true } );
+    chartBuffer = await page.screenshot( { encoding: 'binary' } );
+  } catch ( err ) {
+    // console.error( 'Error generating chart screenshot:', err );
+    throw new Error( 'Failed to generate chart screenshot' );
+  } finally {
+    await browser.close();
+  }
+  // console.log( 'chartBuffer hourly... Try', chartBuffer );
+  return chartBuffer;
+};
+
+const footfallTrend = async ( data ) => {
+  // console.log( 'Generating footfall chart...' );
+
+  const browser = await puppeteer.launch( { headless: true } );
+  const page = await browser.newPage();
+
+  const chartHtmlContent = `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <style>
+        #Footfalltrend {
+          width: 100%;
+          height: 600px;
+        }
+      </style>
+      <script src="https://cdn.amcharts.com/lib/5/index.js"></script>
+      <script src="https://cdn.amcharts.com/lib/5/xy.js"></script>
+      <script src="https://cdn.amcharts.com/lib/5/themes/Animated.js"></script>
+    </head>
+    <body>
+      <div id="Footfalltrend"></div>
+      <script>
+        am5.ready(function() {
+          const root = am5.Root.new('Footfalltrend');
+          root.setThemes([am5themes_Animated.new(root)]);
+
+          const chart = root.container.children.push(
+            am5xy.XYChart.new(root, {
+              panX: false,
+              panY: false,
+              wheelX: 'panX',
+              wheelY: 'zoomX',
+              layout: root.verticalLayout
+            })
+          );
+
+          chart.set("scrollbarX", am5.Scrollbar.new(root, {
+            orientation: "horizontal"
+          }));
+
+          const xRenderer = am5xy.AxisRendererX.new(root, {
+            minGridDistance: 20,
+            minorGridEnabled: true,
+          });
+
+          xRenderer.labels.template.setAll({
+            rotation: -45,
+            centerY: am5.p50,
+            centerX: am5.p100,
+            paddingRight: 5,
+          });
+
+          const xAxis = chart.xAxes.push(
+            am5xy.CategoryAxis.new(root, {
+              categoryField: "storeName",
+              renderer: xRenderer,
+              tooltip: am5.Tooltip.new(root, { labelText: "{fullStoreName}" })
+            })
+          );
+
+          const formattedData = ${JSON.stringify( data )}.map((item) => ({
+            fullStoreName: item.storeName,
+            storeName: item.storeName,
+            footfall: Number(item.footfall_count),
+            conversion: Number(item.conversion_count),
+            bounced: Number(item.bounced_count),
+            engagers: Number(item.engagers_count),
+            missedopportunities: Number(item.missedOpportunity_count),
+          }));
+
+          formattedData.sort((a, b) => {
+            const dateA = new Date(a.storeName);
+            const dateB = new Date(b.storeName);
+            return dateA - dateB;
+          });
+
+          xAxis.data.setAll(formattedData);
+
+          const yAxis = chart.yAxes.push(
+            am5xy.ValueAxis.new(root, {
+              min: 0,
+              renderer: am5xy.AxisRendererY.new(root, {})
+            })
+          );
+
+          yAxis.children.unshift(am5.Label.new(root, {
+            rotation: -90,
+            text: "Footfall",
+            y: am5.p50,
+            centerX: am5.p50,
+            fontFamily: "Arial",
+            fontSize: "14px",
+            fill: am5.color(0x000000)
+          }));
+
+             const createColumnSeries = (name, field, color) => {
+            const series = chart.series.push(
+              am5xy.ColumnSeries.new(root, {
+                name: name,
+                xAxis: xAxis,
+                yAxis: yAxis,
+                valueYField: field,
+                categoryXField: "storeName",
+                fill: color,
+                stroke: color,
+                stacked: true,
+              })
+            );
+
+            series.data.setAll(formattedData);
+
+              series.bullets.push(() => {
+            return am5.Bullet.new(root, {
+              sprite: am5.Label.new(root, {
+                text: "{valueY}",
+                fill: root.interfaceColors.get("alternativeText"),
+                centerY: am5.p50,
+                centerX: am5.p50,
+                populateText: true,
+                fontSize: 12  // Reduce font size
+        })
+      });
+    });
+
+            series.columns.template.setAll({
+              tooltipText: "{name}: {valueY}",
+              width: am5.percent(90),
+              tooltipY: 0,
+            });
+
+            series.appear(1000);
+            return series;
+          };
+
+          createColumnSeries("Footfall", "footfall", am5.color(0x67b7dc));
+          createColumnSeries("Bounced", "bounced", am5.color(0x6794dc));
+          createColumnSeries("Engagers", "engagers", am5.color(0x6771dc));
+
+          const createLineSeries = (name, fieldName, xAxis, yAxis, color) => {
+            const series = chart.series.push(
+              am5xy.LineSeries.new(root, {
+                name: name,
+                xAxis: xAxis,
+                yAxis: yAxis,
+                valueYField: fieldName,
+                categoryXField: 'storeName',
+                tooltip: am5.Tooltip.new(root, {
+                  pointerOrientation: "horizontal",
+                  labelText: "{name}: {valueY}",
+                  background: am5.Rectangle.new(root, {
+                    fill: color // Tooltip background color
+                  })
+                })
+              })
+            );
+
+            series.strokes.template.setAll({
+              strokeWidth: 2,
+              stroke: color,
+              templateField: "strokeSettings",
+            });
+
+            series.data.setAll(formattedData);
+
+            series.bullets.push(() => {
+              return am5.Bullet.new(root, {
+                sprite: am5.Circle.new(root, {
+                  strokeWidth: 1,
+                  stroke: color,
+                  radius: 1,
+                  fill: root.interfaceColors.get("background")
+                }),
+              });
+            });
+
+            series.appear();
+          };
+
+          createLineSeries("Conversion", "conversion", xAxis, yAxis, am5.color(0x00FF00));
+
+          const legend = chart.children.push(
+            am5.Legend.new(root, {
+              centerX: am5.p50,
+              x: am5.p50
+            })
+          );
+
+          legend.data.setAll(chart.series.values);
+
+          chart.set("cursor", am5xy.XYCursor.new(root, {
+            behavior: "none"
+          }));
+
+          chart.appear(1000, 100);
+        });
+      </script>
+    </body>
+    </html>
+  `;
+
+  let weeklyChartBuffer;
+  try {
+    await page.setContent( chartHtmlContent, { waitUntil: 'domcontentloaded' } );
+    await page.waitForSelector( '#Footfalltrend', { visible: true } );
+    weeklyChartBuffer = await page.screenshot( { encoding: 'binary' } );
+  } catch ( err ) {
+    // console.error( 'Error generating chart screenshot:', err );
+    throw new Error( 'Failed to generate chart screenshot' );
+  } finally {
+    await browser.close();
+  }
+
+  return weeklyChartBuffer;
+};
+
+
+// const footfallTrend = async ( data ) => {
+//   console.log( 'Generating footfall chart...' );
+
+//   const browser = await puppeteer.launch( { headless: true } );
+//   const page = await browser.newPage();
+
+//   const chartHtmlContent = `
+//     <!DOCTYPE html>
+//     <html>
+//     <head>
+//       <style>
+//         #Footfalltrend {
+//           width: 100%;
+//           height: 600px;
+//         }
+//       </style>
+//       <script src="https://cdn.amcharts.com/lib/5/index.js"></script>
+//       <script src="https://cdn.amcharts.com/lib/5/xy.js"></script>
+//       <script src="https://cdn.amcharts.com/lib/5/themes/Animated.js"></script>
+//     </head>
+//     <body>
+//       <div id="Footfalltrend"></div>
+//       <script>
+//         am5.ready(function() {
+//           const root = am5.Root.new('Footfalltrend');
+//           root.setThemes([am5themes_Animated.new(root)]);
+
+//           const chart = root.container.children.push(
+//             am5xy.XYChart.new(root, {
+//               panX: false,
+//               panY: false,
+//               wheelX: 'panX',
+//               wheelY: 'zoomX',
+//               layout: root.verticalLayout
+//             })
+//           );
+
+//           chart.set("scrollbarX", am5.Scrollbar.new(root, {
+//             orientation: "horizontal"
+//           }));
+
+//           const xRenderer = am5xy.AxisRendererX.new(root, {
+//             minGridDistance: 20,
+//             minorGridEnabled: true,
+//           });
+
+//           xRenderer.labels.template.setAll({
+//             rotation: -45,
+//             centerY: am5.p50,
+//             centerX: am5.p100,
+//             paddingRight: 5,
+//           });
+
+//           const xAxis = chart.xAxes.push(
+//             am5xy.CategoryAxis.new(root, {
+//               categoryField: "storeName",
+//               renderer: xRenderer,
+//               tooltip: am5.Tooltip.new(root, { labelText: "{fullStoreName}" })
+//             })
+//           );
+
+//           const formattedData = ${JSON.stringify( data )}.map((item) => ({
+//             fullStoreName: item.storeName,
+//             storeName: item.storeName,
+//             footfall: Number(item.footfall_count),
+//             conversion: Number(item.conversion_count),
+//             bounced: Number(item.bounced_count),
+//             engagers: Number(item.engagers_count),
+//             missedopportunities: Number(item.missedOpportunity_count),
+//           }));
+
+//           formattedData.sort((a, b) => {
+//             const dateA = new Date(a.storeName);
+//             const dateB = new Date(b.storeName);
+//             return dateA - dateB;
+//           });
+
+//           xAxis.data.setAll(formattedData);
+
+//           const yAxis = chart.yAxes.push(
+//             am5xy.ValueAxis.new(root, {
+//               min: 0,
+//               renderer: am5xy.AxisRendererY.new(root, {})
+//             })
+//           );
+
+//           yAxis.children.unshift(am5.Label.new(root, {
+//             rotation: -90,
+//             text: "Footfall",
+//             y: am5.p50,
+//             centerX: am5.p50,
+//             fontFamily: "Arial",
+//             fontSize: "14px",
+//             fill: am5.color(0x000000)
+//           }));
+
+//           const createColumnSeries = (name, field, color) => {
+//             const series = chart.series.push(
+//               am5xy.ColumnSeries.new(root, {
+//                 name: name,
+//                 xAxis: xAxis,
+//                 yAxis: yAxis,
+//                 valueYField: field,
+//                 categoryXField: "storeName",
+//                 fill: color,
+//                 stroke: color,
+//                 stacked: true,
+//               })
+//             );
+
+//             series.data.setAll(formattedData);
+
+//               series.bullets.push(() => {
+//             return am5.Bullet.new(root, {
+//               sprite: am5.Label.new(root, {
+//                 text: "{valueY}",
+//                 fill: root.interfaceColors.get("alternativeText"),
+//                 centerY: am5.p50,
+//                 centerX: am5.p50,
+//                 populateText: true,
+//                 fontSize: 12  // Reduce font size
+//         })
+//       });
+//     });
+
+//             series.columns.template.setAll({
+//               tooltipText: "{name}: {valueY}",
+//               width: am5.percent(90),
+//               tooltipY: 0,
+//             });
+
+//             series.appear(1000);
+//             return series;
+//           };
+
+//           createColumnSeries("Bounced", "bounced", am5.color(0x67b7dc));
+//           createColumnSeries("Missed Opportunity", "missedopportunities", am5.color(0x6794dc));
+//           createColumnSeries("Conversion", "conversion", am5.color(0x6771dc));
+
+//           const legend = chart.children.push(
+//             am5.Legend.new(root, {
+//               centerX: am5.p50,
+//               x: am5.p50
+//             })
+//           );
+
+//           legend.data.setAll(chart.series.values);
+
+//           chart.set("cursor", am5xy.XYCursor.new(root, {
+//             behavior: "none"
+//           }));
+
+//           chart.appear(1000, 100);
+//         });
+//       </script>
+//     </body>
+//     </html>
+//   `;
+//   let weeklyChartBuffer;
+//   try {
+//     await page.setContent( chartHtmlContent, { waitUntil: 'domcontentloaded' } );
+//     await page.waitForSelector( '#Footfalltrend', { visible: true } );
+//     weeklyChartBuffer = await page.screenshot( { encoding: 'binary' } );
+//     // await page.screenshot( { path: chartImagePath } );
+//     // console.log( 'Screenshot saved to:', chartImagePath );
+//     // console.log( 'Screenshot saved to:', chartImagePath );
+//   } catch ( err ) {
+//     console.error( 'Error generating chart screenshot:', err );
+//     throw new Error( 'Failed to generate chart screenshot' );
+//   } finally {
+//     await browser.close();
+//   }
+
+//   return weeklyChartBuffer;
+// };