tango-app-api-trax 1.0.0-alpha-task.130

package/src/controllers/teaxFlag.controller.js

@@ -0,0 +1,2699 @@
+import { download, logger } from 'tango-app-api-middleware';
+import { aggregate } from '../services/processedchecklist.services.js';
+import dayjs from 'dayjs';
+import * as processedchecklistService from '../services/processedchecklist.services.js';
+import * as processedchecklistconfigService from '../services/processedchecklistconfig.services.js';
+
+
+import utc from 'dayjs/plugin/utc.js';
+dayjs.extend( utc );
+import mongoose from 'mongoose';
+
+export const overallFlagMetrics = async ( req, res ) => {
+  try {
+    const pipeline = [
+      {
+        $facet: {
+          currentPeriod: [
+            {
+              $match: {
+                $and: [
+                  { client_id: req.body.clientId },
+                  {
+                    store_id: {
+                      $in: req.body.stores,
+                    },
+                  },
+                  {
+                    date_iso: {
+                      $gte: new Date( req.body.startDate ),
+                    },
+                  },
+                  {
+                    date_iso: {
+                      $lte: new Date( req.body.endDate ),
+                    },
+                  },
+                ],
+              },
+            },
+            {
+              $project: {
+                timeFlag: 1,
+                questionFlag: 1,
+                mobileDetectionFlag: 1,
+                storeOpenCloseFlag: 1,
+                uniformDetectionFlag: 1,
+              },
+            },
+            {
+              $group: {
+                _id: '',
+                questionFlag: {
+                  $sum: '$questionFlag',
+                },
+                timeFlag: { $sum: '$timeFlag' },
+                detectionFlags: {
+                  $sum: {
+                    $cond: [
+                      {
+                        $or: [
+                          {
+                            $gt: [
+                              '$mobileDetectionFlag',
+                              0,
+                            ],
+                          },
+                          {
+                            $gt: [
+                              '$storeOpenCloseFlag',
+                              0,
+                            ],
+                          },
+                          {
+                            $gt: [
+                              '$uniformDetectionFlag',
+                              0,
+                            ],
+                          },
+                        ],
+                      },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+              },
+            },
+            {
+              $addFields: {
+                totalFlags: {
+                  $add: [
+                    '$questionFlag',
+                    '$timeFlag',
+                    '$detectionFlags',
+                  ],
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+              },
+            },
+          ],
+          last7Days: [
+            {
+              $match: {
+                $and: [
+                  { client_id: req.body.clientId },
+                  {
+                    store_id: {
+                      $in: req.body.stores,
+                    },
+                  },
+                  {
+                    date_iso: {
+                      $gte: dayjs.utc( req.body.endDate ).subtract( 7, 'days' ).startOf( 'day' ).toDate(),
+                    },
+                  },
+                  {
+                    date_iso: {
+                      $lte: dayjs.utc( req.body.startDate ).subtract( 1, 'day' ).startOf( 'day' ).toDate(),
+                    },
+                  },
+                ],
+              },
+            },
+            {
+              $project: {
+                timeFlag: 1,
+                questionFlag: 1,
+                mobileDetectionFlag: 1,
+                storeOpenCloseFlag: 1,
+                uniformDetectionFlag: 1,
+              },
+            },
+            {
+              $group: {
+                _id: '',
+                questionFlag: {
+                  $sum: '$questionFlag',
+                },
+                timeFlag: { $sum: '$timeFlag' },
+                detectionFlags: {
+                  $sum: {
+                    $cond: [
+                      {
+                        $or: [
+                          {
+                            $gt: [
+                              '$mobileDetectionFlag',
+                              0,
+                            ],
+                          },
+                          {
+                            $gt: [
+                              '$storeOpenCloseFlag',
+                              0,
+                            ],
+                          },
+                          {
+                            $gt: [
+                              '$uniformDetectionFlag',
+                              0,
+                            ],
+                          },
+                        ],
+                      },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+              },
+            },
+            // {
+            //   $addFields: {
+            //     questionFlag: {
+            //       $round: [
+            //         { $divide: [ '$questionFlag', 7 ] },
+            //         0,
+            //       ],
+            //     },
+            //     timeFlag: {
+            //       $round: [
+            //         { $divide: [ '$timeFlag', 7 ] },
+            //         0,
+            //       ],
+            //     },
+            //     detectionFlags: {
+            //       $round: [
+            //         {
+            //           $divide: [ '$detectionFlags', 7 ],
+            //         },
+            //         0,
+            //       ],
+            //     },
+            //   },
+            // },
+          ],
+        },
+      },
+    ];
+
+    const data = await aggregate( pipeline );
+
+    if ( !data[0]?.currentPeriod?.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    if ( !data[0]?.last7Days?.length ) {
+      const resData = {
+        ...data[0].currentPeriod[0],
+      };
+      return res.sendSuccess( resData );
+    }
+
+    const firstDate = dayjs.utc( req.body.startDate );
+    const secondDate = dayjs.utc( req.body.endDate );
+
+    const daysDifference = secondDate.diff( firstDate, 'day' ) + 1;
+
+    const currentRangeData = {
+      questionFlag: Math.round( data[0].currentPeriod[0].questionFlag / daysDifference ),
+      timeFlag: Math.round( data[0].currentPeriod[0].timeFlag / daysDifference ),
+      detectionFlags: Math.round( data[0].currentPeriod[0].detectionFlags / daysDifference ),
+    };
+
+    const last7RangeData = {
+      questionFlag: Math.round( data[0].currentPeriod[0].questionFlag / 7 ),
+      timeFlag: Math.round( data[0].currentPeriod[0].timeFlag / 7 ),
+      detectionFlags: Math.round( data[0].currentPeriod[0].detectionFlags / 7 ),
+    };
+
+    function calculatePercentage( currentPeriod, last7Days ) {
+      // const current = currentPeriod[0];
+      // const last7 = last7Days[0];
+
+      const calculateDiffPercentage = ( currentValue, last7Value ) => {
+        if ( last7Value === 0 ) {
+          return currentValue === 0 ? 0 : ( currentValue > 0 ? 100 : -100 );
+        }
+        return Math.round( ( ( currentValue - last7Value ) / last7Value ) * 100 );
+      };
+
+      const percentageQuestionFlag = calculateDiffPercentage( currentPeriod.questionFlag, last7Days.questionFlag );
+      const percentageTimeFlag = calculateDiffPercentage( currentPeriod.timeFlag, last7Days.timeFlag );
+      const percentageDetectionFlags = calculateDiffPercentage( currentPeriod.detectionFlags, last7Days.detectionFlags );
+
+      return {
+        percentageQuestionFlag,
+        percentageTimeFlag,
+        percentageDetectionFlags,
+      };
+    }
+
+    const percentageData = calculatePercentage( currentRangeData, last7RangeData );
+
+    const resData = {
+      ...data[0].currentPeriod[0],
+      ...percentageData,
+    };
+
+    return res.sendSuccess( resData );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'overallFlagMetrics' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const checklistFlagsTable = async ( req, res ) => {
+  try {
+    const matchStage = {
+      $match: {
+        $and: [
+          { client_id: req.body.clientId },
+          {
+            store_id: {
+              $in: req.body.stores,
+            },
+          },
+          {
+            date_iso: {
+              $gte: new Date( req.body.startDate ),
+            },
+          },
+          {
+            date_iso: {
+              $lte: new Date( req.body.endDate ),
+            },
+          },
+          {
+            $or: [
+              { timeFlag: { $gt: 0 } },
+              { questionFlag: { $gt: 0 } },
+              { mobileDetectionFlag: { $gt: 0 } },
+              { storeOpenCloseFlag: { $gt: 0 } },
+              { uniformDetectionFlag: { $gt: 0 } },
+            ],
+          },
+        ],
+      },
+    };
+
+    const pipeline = [
+      matchStage,
+      {
+        $project: {
+          sourceCheckList_id: 1,
+          checkListName: 1,
+          storeCount: 1,
+          store_id: 1,
+          checkListType: 1,
+          flags: [
+            {
+              flagType: 'Not Submitted',
+              flagValue: '$timeFlag',
+            },
+            {
+              flagType: 'Question',
+              flagValue: '$questionFlag',
+            },
+            {
+              flagType: 'Mobile Detection',
+              flagValue: '$mobileDetectionFlag',
+            },
+            {
+              flagType: 'Store Open/Close',
+              flagValue: '$storeOpenCloseFlag',
+            },
+            {
+              flagType: 'Uniform Detection',
+              flagValue: '$uniformDetectionFlag',
+            },
+          ],
+        },
+      },
+      {
+        $unwind: '$flags',
+      },
+      {
+        $match: {
+          'flags.flagValue': { $gt: 0 },
+        },
+      },
+      {
+        $group: {
+          _id: {
+            sourceCheckList_id: '$sourceCheckList_id',
+            flagType: '$flags.flagType',
+          },
+          checkListName: { $last: '$checkListName' },
+          checkListType: { $last: '$checkListType' },
+          checkListChar: {
+            $last: {
+              $substr: [ '$checkListName', 0, 2 ],
+            },
+          },
+          storeCount: { $max: '$storeCount' },
+          flaggedChecklist: { $sum: 1 },
+          flagType: { $last: '$flags.flagType' },
+          uniqueStores: { $addToSet: '$store_id' },
+        },
+      },
+      {
+        $project: {
+          _id: 1,
+          checkListName: 1,
+          checkListChar: 1,
+          checkListType: 1,
+          storeCount: 1,
+          flaggedChecklist: 1,
+          flagType: 1,
+          flagedStores: { $size: '$uniqueStores' },
+        },
+      },
+    ];
+
+    if ( req.body?.sortColumn && req.body?.sortBy ) {
+      pipeline.push(
+          {
+            $addFields: {
+              sortField: {
+                $toLower: `$${req.body.sortColumn}`,
+              },
+            },
+          },
+          {
+            $sort: {
+              [req.body.sortColumn]: req.body.sortBy,
+            },
+          },
+      );
+    }
+
+    pipeline.push(
+        {
+          $project: {
+            sortField: 0,
+          },
+        },
+
+    );
+
+    const facetStage = {
+      $facet: {
+        data: [
+          {
+            $skip: ( ( req.body.offset - 1 ) * req.body.limit ),
+          },
+          {
+            $limit: ( req.body.limit  ),
+          },
+        ],
+        pageInfo: [
+          {
+            $count: 'count',
+          },
+        ],
+      },
+    };
+
+
+    pipeline.push( facetStage );
+
+    pipeline.push( {
+      $unwind: {
+        path: '$pageInfo',
+      },
+    } );
+
+    if ( req.body.isExport ) {
+      facetStage.$facet.data = [];
+    }
+
+
+    const data = await aggregate( pipeline );
+
+    if ( !data[0] ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    if ( req.body.isExport ) {
+      const exportResult = [];
+      for ( let checklist of data[0].data ) {
+        exportResult.push( {
+          'Checklist Name': checklist.checkListName ||'',
+          'Flag Type': checklist.flagType||'',
+          'Assigned Stores': checklist.storeCount||'',
+          'Fragged Stores': checklist.flagedStores || '',
+          'Flagged Count': checklist.flaggedChecklist||'',
+        } );
+      }
+      await download( exportResult, res );
+      return;
+    }
+
+    return res.sendSuccess( data[0] );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'subscribedStoreList' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const flagChecklistCards = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await checklistCardData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'subscribedStoreList' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const flagChecklistComparisonCards = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await checklistComparisonData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'subscribedStoreList' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const flagChecklistTable = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await tableData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'subscribedStoreList' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const flagCards = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await flagCardData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'subscribedStoreList' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const flagComparisonCards = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await falgComparisonData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'subscribedStoreList' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const flagTables = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await flagTableData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'subscribedStoreList' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const checklistDropdown = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await checklistDropdownData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'subscribedStoreList' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const flagCardsV1 = async ( req, res ) => {
+  try {
+    const { clientId, storeId, fromDate, toDate } = req.body;
+    const adjustedToDate = new Date( new Date( toDate ).setUTCHours( 23, 59, 59, 999 ) );
+    const adjustedFromDate = new Date( fromDate );
+
+    const flagCards = {
+      totalFlag: 0,
+      questionFlag: { count: 0 },
+      delayInSubmission: { count: 0 },
+      detectionFlag: { count: 0 },
+    };
+
+    const findQuery = [
+      {
+        $match: {
+          client_id: clientId,
+          store_id: { $in: storeId },
+          date_iso: { $gte: adjustedFromDate, $lte: adjustedToDate },
+        },
+      },
+      {
+        $project: {
+          questionFlag: 1,
+          timeFlag: 1,
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          totalFlag: { $sum: { $add: [ '$questionFlag', '$timeFlag' ] } },
+          questionFlag: { $sum: '$questionFlag' },
+          delayInSubmission: { $sum: '$timeFlag' },
+        },
+      },
+    ];
+
+    const getOverallChecklistData = await processedchecklistService.aggregate( findQuery );
+
+    if ( !getOverallChecklistData.length ) {
+      const resVal = {
+        'flagCards': {
+          'totalFlag': 0,
+          'questionFlag': {
+            'count': 0,
+          },
+          'delayInSubmission': {
+            'count': 0,
+          },
+          'detectionFlag': {
+            'count': 0,
+          },
+        },
+      };
+      return res.sendSuccess( resVal );
+    }
+
+    const [ data ] = getOverallChecklistData;
+    if ( data.totalFlag ) flagCards.totalFlag = data.totalFlag;
+    if ( data.questionFlag ) flagCards.questionFlag.count = data.questionFlag;
+    if ( data.delayInSubmission ) flagCards.delayInSubmission.count = data.delayInSubmission;
+
+    const detectionPayload = { fromDate, toDate, storeId, clientId };
+    const lambdaURL = 'https://f65azvtljclaxp6l7rnx65cdmm0lcgvp.lambda-url.ap-south-1.on.aws/';
+    const resultData = await LamdaServiceCall( lambdaURL, detectionPayload );
+
+    if ( resultData && resultData.status_code === '200' ) {
+      flagCards.detectionFlag.count = resultData.totalDetection;
+      flagCards.totalFlag += flagCards.detectionFlag.count;
+    }
+
+    return res.sendSuccess( { flagCards } );
+  } catch ( error ) {
+    console.error( 'Error in flagCardsV1:', error );
+    logger.error( { error, function: 'flagCardsV1' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+
+export const flagComparisonCardsV1 = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let toDate = new Date( requestData.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+
+    let rangeOneFromDate;
+    let rangeOneToDate;
+    let rangeTwoFromDate;
+    let rangeTwoToDate;
+    if ( requestData.dateType == 'weekly' ) {
+      rangeOneFromDate = new Date( requestData.toDate );
+      rangeOneFromDate.setDate( rangeOneFromDate.getDate() - 6 );
+      rangeOneToDate = new Date( requestData.toDate );
+      rangeOneToDate = new Date( rangeOneToDate.getTime() - userTimezoneOffset );
+      rangeOneToDate.setUTCHours( 23, 59, 59, 59 );
+      rangeTwoToDate = new Date( requestData.toDate );
+      rangeTwoToDate.setDate( rangeTwoToDate.getDate() - 7 );
+      rangeTwoFromDate = new Date( rangeTwoToDate );
+      rangeTwoFromDate.setDate( rangeTwoFromDate.getDate() - 6 );
+      rangeTwoToDate = new Date( rangeTwoToDate.getTime() - userTimezoneOffset );
+      rangeTwoToDate.setUTCHours( 23, 59, 59, 59 );
+    } else if ( requestData.dateType == 'monthly' ) {
+      rangeOneFromDate = new Date( requestData.toDate );
+      rangeOneFromDate.setDate( rangeOneFromDate.getDate() - 30 );
+      rangeOneToDate = new Date( requestData.toDate );
+      rangeOneToDate = new Date( rangeOneToDate.getTime() - userTimezoneOffset );
+      rangeOneToDate.setUTCHours( 23, 59, 59, 59 );
+      rangeTwoToDate = new Date( requestData.toDate );
+      rangeTwoToDate.setDate( rangeTwoToDate.getDate() - 31 );
+      rangeTwoFromDate = new Date( rangeTwoToDate );
+      rangeTwoFromDate.setDate( rangeTwoFromDate.getDate() - 30 );
+      rangeTwoToDate = new Date( rangeTwoToDate.getTime() - userTimezoneOffset );
+      rangeTwoToDate.setUTCHours( 23, 59, 59, 59 );
+    } else {
+      rangeOneFromDate = new Date( requestData.toDate );
+      rangeOneFromDate.setDate( rangeOneFromDate.getDate() - 0 );
+      rangeOneToDate = new Date( requestData.toDate );
+      rangeOneToDate = new Date( rangeOneToDate.getTime() - userTimezoneOffset );
+      rangeOneToDate.setUTCHours( 23, 59, 59, 59 );
+      rangeTwoToDate = new Date( requestData.toDate );
+      rangeTwoToDate.setDate( rangeTwoToDate.getDate() - 1 );
+      rangeTwoFromDate = new Date( rangeTwoToDate );
+      rangeTwoFromDate.setDate( rangeTwoFromDate.getDate() - 0 );
+      rangeTwoToDate = new Date( rangeTwoToDate.getTime() - userTimezoneOffset );
+      rangeTwoToDate.setUTCHours( 23, 59, 59, 59 );
+    }
+
+    const createFindQuery = ( fromDate, toDate ) => [
+      { $match: { client_id: requestData.clientId, store_id: { $in: requestData.storeId }, date_iso: { $gte: fromDate, $lte: toDate } } },
+      {
+        $project: {
+          timeFlag: 1,
+          questionFlag: 1,
+        },
+      },
+      {
+        $group: {
+          _id: '',
+          questionFlag: { $sum: '$questionFlag' },
+          delayInSubmission: { $sum: '$timeFlag' },
+        },
+      },
+    ];
+
+    const calculateComparison = ( rangeOneVal, rangeTwoVal ) => {
+      if ( rangeOneVal === 0 ) {
+        return { comparisonData: 0, ComparisonFlag: false };
+      }
+
+      let comparisonData = Math.abs( ( ( rangeOneVal - rangeTwoVal ) / rangeTwoVal ) * 100 );
+      if ( comparisonData === Infinity ) comparisonData = 0;
+      comparisonData = comparisonData % 1 === 0 ? comparisonData.toFixed( 0 ) : comparisonData.toFixed( 1 );
+
+      comparisonData = parseInt( comparisonData );
+
+
+      const ComparisonFlag = rangeOneVal > rangeTwoVal;
+
+      return { comparisonData, ComparisonFlag };
+    };
+
+    const getDetectionCount = async ( fromDate, toDate ) => {
+      const detectionPayload = {
+        fromDate: dayjs( fromDate ).format( 'YYYY-MM-DD' ),
+        toDate: dayjs( toDate ).startOf( 'day' ).format( 'YYYY-MM-DD' ),
+        storeId: requestData.storeId,
+        clientId: requestData.clientId,
+      };
+
+      console.log( dayjs( fromDate ).format( 'YYYY-MM-DD' ), 'from date' );
+
+      console.log( dayjs( toDate ).subtract( 1, 'day' ).format( 'YYYY-MM-DD' ), 'current' );
+
+      console.log( dayjs( toDate ).format( 'YYYY-MM-DD' ), 'previous' );
+
+      console.log( dayjs( toDate ).startOf( 'day' ).subtract( 1, 'day' ).format( 'YYYY-MM-DD' ), 'new start of' );
+
+      const LamdaURL = 'https://f65azvtljclaxp6l7rnx65cdmm0lcgvp.lambda-url.ap-south-1.on.aws/';
+      const resultData = await LamdaServiceCall( LamdaURL, detectionPayload );
+
+      if ( resultData?.status_code === '200' ) {
+        return resultData.totalDetection;
+      }
+      return 0;
+    };
+
+    const [ rangeOneData, rangeTwoData, rangeOneDetectionCount, rangeTwoDetectionCount ] = await Promise.all( [
+      processedchecklistService.aggregate( createFindQuery( rangeOneFromDate, rangeOneToDate ) ),
+      processedchecklistService.aggregate( createFindQuery( rangeTwoFromDate, rangeTwoToDate ) ),
+      getDetectionCount( rangeOneFromDate, rangeOneToDate ),
+      getDetectionCount( rangeTwoFromDate, rangeTwoToDate ),
+    ] );
+
+    const flagComparisonCards = {
+      questionComparisonFlag: { comparisonData: 0, ComparisonFlag: false },
+      delayInSubmissionComparisonFlag: { comparisonData: 0, ComparisonFlag: false },
+      detectionComparisonFlag: { comparisonData: 0, ComparisonFlag: false },
+    };
+
+    if ( rangeOneData.length && rangeTwoData.length ) {
+      flagComparisonCards.questionComparisonFlag = calculateComparison( rangeOneData[0].questionFlag, rangeTwoData[0].questionFlag );
+      flagComparisonCards.delayInSubmissionComparisonFlag = calculateComparison( rangeOneData[0].delayInSubmission, rangeTwoData[0].delayInSubmission );
+      flagComparisonCards.detectionComparisonFlag = calculateComparison( rangeOneDetectionCount, rangeTwoDetectionCount );
+    }
+
+    return res.sendSuccess( { flagComparisonCards } );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error, function: 'flagComparisonCardsV1' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+
+export const flagTablesV1 = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let fromDate = new Date( requestData.fromDate );
+    let toDate = new Date( requestData.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+    let result = {};
+
+    let findQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { client_id: requestData.clientId },
+        { $or: [ { store_id: { $in: requestData.storeId } }, { aiStoreList: { $in: requestData.storeId } } ] },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+
+    if ( requestData?.filter === 'all' ) {
+      findAndQuery.push( { $or: [ { questionFlag: { $gte: 1 } }, { timeFlag: { $gte: 1 } }, { checkListType: { $ne: 'custom' } } ] } );
+    } else if ( requestData?.filter === 'question' ) {
+      findAndQuery.push( { checkListType: 'custom' } );
+      findAndQuery.push( { questionFlag: { $gte: 1 } } );
+    } else if ( requestData?.filter === 'time' ) {
+      findAndQuery.push( { checkListType: 'custom' } );
+      findAndQuery.push( { timeFlag: { $gte: 1 } } );
+    } else if ( requestData?.filter === 'detection' ) {
+      findAndQuery.push( { checkListType: { $ne: 'custom' } } );
+    }
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    if ( requestData.searchValue && requestData.searchValue != '' ) {
+      findQuery.push( { $match: { $or: [ { checkListName: { $regex: requestData.searchValue, $options: 'i' } } ] } } );
+    }
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListId: 1,
+        checkListName: 1,
+        storeCount: 1,
+        createdBy: 1,
+        createdByName: 1,
+        checklistStatus: 1,
+        timeFlag: 1,
+        questionFlag: 1,
+        questionCount: 1,
+        mobileDetectionFlag: 1,
+        storeOpenCloseFlag: 1,
+        uniformDetectionFlag: 1,
+        checkListType: 1,
+        scheduleRepeatedType: 1,
+        store_id: 1,
+        aiStoreList: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+        checkListName: { $last: '$checkListName' },
+        checkListChar: { $last: { $substr: [ '$checkListName', 0, 2 ] } },
+        sourceCheckList_id: { $last: '$sourceCheckList_id' },
+        checkListType: { $last: '$checkListType' },
+        storeCount: { $sum: 1 },
+        storeCountAi: { $max: '$storeCount' },
+        flaggedStores: {
+          $addToSet: {
+            $cond: [
+              {
+                $or: [
+                  { $gt: [ '$timeFlag', 0 ] },
+                  { $gt: [ '$questionFlag', 0 ] },
+                  { $gt: [ '$mobileDetectionFlag', 0 ] },
+                  { $gt: [ '$storeOpenCloseFlag', 0 ] },
+                  { $gt: [ '$uniformDetectionFlag', 0 ] },
+                  { $gt: [ '$customerUnattended', 0 ] },
+                  { $gt: [ '$staffLeftInTheMiddle', 0 ] },
+                ],
+              },
+              '$store_id',
+              '$$REMOVE',
+            ],
+          },
+        },
+        flagCount: {
+          $sum: {
+            $add: [ '$questionFlag', '$timeFlag' ],
+          },
+          // $sum: {
+          //   $cond: [ {
+          //     $or: [
+          //       { $gt: [ '$timeFlag', 0 ] },
+          //       { $gt: [ '$questionFlag', 0 ] },
+          //       { $gt: [ '$mobileDetectionFlag', 0 ] },
+          //       { $gt: [ '$storeOpenCloseFlag', 0 ] },
+          //       { $gt: [ '$uniformDetectionFlag', 0 ] },
+          //     ],
+          //   }, 1, 0 ],
+          // },
+        },
+        submittedChecklist: {
+          $sum: {
+            $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ],
+          },
+        },
+        questionFlag: {
+          $sum: '$questionFlag',
+          // $sum: {
+          //   $cond: [ { $gt: [ '$questionFlag', 0 ] }, 1, 0 ],
+          // },
+        },
+        timeFlag: {
+          $sum: '$timeFlag',
+        },
+        questionCount: {
+          $sum: '$questionCount',
+          // $sum: {
+          //   $cond: [ { $gt: [ '$questionCount', 0 ] }, 1, 0 ],
+          // },
+        },
+        aiStoreList: { $max: '$aiStoreList' },
+        submittedQuestionCount: {
+          $sum: {
+            $cond: [
+              { $eq: [ '$checklistStatus', 'submit' ] },
+              '$questionCount', // Sum this field if status is 'submit'
+              0, // Otherwise, add 0
+            ],
+          },
+        },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        assignedStores: '$storeCount',
+        assignedStoresAi: '$storeCountAi',
+        checkListName: 1,
+        checkListChar: 1,
+        sourceCheckList_id: 1,
+        checkListType: 1,
+        flagType: 1,
+        uniqueFlaggedStores: 1,
+        flaggedStores: { $size: '$flaggedStores' },
+        flagCount: 1,
+        questionCount: 1,
+        correctAnswers: { $subtract: [ '$submittedQuestionCount', '$questionFlag' ] },
+        // customType: {
+        //   $cond: { if: { $gte: [ '$questionFlag', 1 ] }, then: 'question', else: {
+        //     $cond: { if: { $gte: [ '$timeFlag', 1 ] }, then: 'time', else: '' },
+        //   },
+        //   },
+        // },
+        customQuestionFlagCount: '$questionFlag',
+        customTimeFlagCount: '$timeFlag',
+        // correctAnswers: '$questionFlag',
+        aiStoreList: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        checkListName: 1,
+        checkListChar: 1,
+        sourceCheckList_id: 1,
+        checkListType: 1,
+        flagType: 1,
+        assignedStores: 1,
+        assignedStoresAi: 1,
+        flaggedStores: 1,
+        flagCount: 1,
+        uniqueFlaggedStores: 1,
+        complianceRate: {
+          $cond: {
+            if: { $eq: [ '$questionCount', 0 ] },
+            then: 0,
+            else: {
+              $round: [ { $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ] }, 2 ],
+            },
+          },
+        },
+        // customType: 1,
+        customQuestionFlagCount: 1,
+        customTimeFlagCount: 1,
+        aiStoreList: 1,
+
+      },
+    } );
+
+    let getTotalCount = await processedchecklistService.aggregate( findQuery );
+    if ( !getTotalCount.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
+      findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
+    } else {
+      findQuery.push( { $sort: { ['submittedChecklist']: -1 } } );
+    }
+
+    if ( !requestData.export ) {
+      let limit = parseInt( requestData?.limit ) || 10;
+      let skip = limit * ( requestData?.offset ) || 0;
+      findQuery.push( { $skip: skip }, { $limit: limit } );
+    }
+
+
+    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
+
+    if ( getChecklistPerformanceData.length ) {
+      const detectionChecklists = getChecklistPerformanceData?.filter( ( val ) => val?.checkListType !== 'custom' );
+
+      if ( detectionChecklists?.length ) {
+        const detectionPayload = {
+          'fromDate': requestData.fromDate,
+          'toDate': requestData.toDate,
+          'storeId': requestData.storeId,
+          'clientId': requestData.clientId,
+        };
+
+        let LamdaURL = 'https://f65azvtljclaxp6l7rnx65cdmm0lcgvp.lambda-url.ap-south-1.on.aws/';
+        let resultData = await LamdaServiceCall( LamdaURL, detectionPayload );
+        if ( resultData ) {
+          if ( resultData.status_code == '200' ) {
+            for ( let index = 0; index < getChecklistPerformanceData.length; index++ ) {
+              if ( getChecklistPerformanceData[index].checkListType !== 'custom' ) {
+                getChecklistPerformanceData[index].flagCount = resultData?.[getChecklistPerformanceData[index]?.checkListType] || 0;
+                getChecklistPerformanceData[index].flaggedStores = resultData?.[`${getChecklistPerformanceData[index]?.checkListType}_flaggedstores`] || 0;
+                getChecklistPerformanceData[index].assignedStores = getChecklistPerformanceData[index]?.aiStoreList?.filter( ( element ) => requestData.storeId.includes( element ) )?.length || 0;
+                getChecklistPerformanceData[index].complianceRate = ( 100- ( getChecklistPerformanceData[index].flaggedStores / getChecklistPerformanceData[index].assignedStores ) * 100 );
+                getChecklistPerformanceData[index].complianceRate = Math.min( 100, Math.max( 0, getChecklistPerformanceData[index].complianceRate ) );
+                getChecklistPerformanceData[index].complianceRate = ( getChecklistPerformanceData[index].complianceRate % 1 === 0 ) ? getChecklistPerformanceData[index].complianceRate.toFixed( 0 ) : getChecklistPerformanceData[index].complianceRate.toFixed( 2 );
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if ( requestData.export ) {
+      const exportdata = [];
+      getChecklistPerformanceData.forEach( ( element ) => {
+        const data = {
+          'Checklist Name': element.checkListName,
+          'Flag Type': element?.checkListType === 'custom' ? 'Question' : 'Detection',
+          'Assigned Stores': element?.assignedStores,
+          'Flagged Stores': element?.flaggedStores,
+          'Compliance': element?.complianceRate,
+          'Flagged Count': element?.flagCount,
+          'Question Flags': element?.customQuestionFlagCount,
+          'Not Submitted Flags': element?.customTimeFlagCount,
+        };
+        if ( requestData?.filter === 'question' ) {
+          delete data['Flagged Count'];
+          delete data['Not Submitted Flags'];
+        } else if ( requestData?.filter === 'time' ) {
+          delete data['Flagged Count'];
+          delete data['Question Flags'];
+        } else if ( requestData?.filter === 'detection' ) {
+          delete data['Not Submitted Flags'];
+          delete data['Question Flags'];
+        }
+        exportdata.push( data );
+      } );
+      return await download( exportdata, res );
+    }
+
+
+    result.totalCount = getTotalCount.length;
+    result.checklistPerformance = getChecklistPerformanceData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'checklistPerformance' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+async function checklistCardData( checklistType ) {
+  try {
+    let resData = {};
+    switch ( checklistType ) {
+      case 'storeopenandclose':
+        resData.storeopenandcloseCards = {};
+        resData.storeopenandcloseCards = {
+          'totalAssignedStores': { 'count': 300 },
+          'lateOpenStores': { 'count': 200 },
+          'earlyClosedStores': { 'count': 100 },
+          'complianceRate': { 'rate': 100 },
+        };
+        break;
+      case 'mobileusagedetection':
+        resData.mobileusagedetectionCards = {};
+        resData.mobileusagedetectionCards = {
+          'totalAssignedStores': { 'count': 300 },
+          'flagIncidents': { 'count': 200 },
+          'complianceRate': { 'rate': 100 },
+        };
+        break;
+      case 'uniformdetection':
+        resData.uniformdetectionCards = {};
+        resData.uniformdetectionCards = {
+          'totalAssignedStores': { 'count': 300 },
+          'flagIncidents': { 'count': 200 },
+          'complianceRate': { 'rate': 100 },
+        };
+        break;
+      case 'customerunattended':
+        resData.customerunattendedCards = {};
+        resData.customerunattendedCards = {
+          'averageFootfall': {
+            'count': 300,
+          },
+          'stafftoCustomerRatio': {
+            'ratio': '6:5',
+          },
+          'attendedCustomers': {
+            'count': 100,
+          },
+          'unattendedCustomers': {
+            'count': 100,
+          },
+          'timeTakentoAssist': {
+            'mins': 100,
+          },
+          'timeSpentwithCustomer': {
+            'mins': 100,
+          },
+          'unattendedSummaryChart': {
+            'chart1': [
+              {
+                'category': 'Un-Attended Peak Hours',
+                'value': 60,
+              },
+              {
+                'category': 'Un-Attended Non Peak Hours',
+                'value': 30,
+              },
+              {
+                'category': 'Un-Attended Customer Rate',
+                'value': 10,
+              },
+            ],
+            'chart2': [
+              {
+                'category': 'Customer Attended Within Threshold',
+                'value': 60,
+              },
+              {
+                'category': 'Customer Attended After Threshold',
+                'value': 40,
+              },
+            ],
+          },
+        };
+        break;
+      case 'staffleftinthemiddle':
+        resData.staffleftinthemiddleCards = {};
+        resData.staffleftinthemiddleCards = {
+          'avgStaffPresent': {
+            'count': 300,
+          },
+          'avgStaffleft': {
+            'count': 200,
+          },
+          'avgStaffPresentInPeakHours': {
+            'rate': '6:5',
+          },
+          'staffAvgPunctualityRate': {
+            'rate': 50,
+          },
+          'staffAvgBreakHours': {
+            'mins': 100,
+          },
+          'staffAvgProductiveHours': {
+            'mins': 100,
+          },
+        };
+        break;
+      case 'custom':
+        resData.customCards = {};
+        resData.customCards = {
+          'totalAssignedStores': {
+            'count': 300,
+          },
+          'flagIncidents': {
+            'count': 200,
+          },
+          'complianceRate': {
+            'count': 100,
+          },
+        };
+        break;
+      default:
+        break;
+    }
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+async function checklistComparisonData( checklistType ) {
+  try {
+    let resData = {};
+    switch ( checklistType ) {
+      case 'storeopenandclose':
+        resData.storeopenandcloseCards = {};
+        resData.storeopenandcloseCards = {
+          'totalAssignedStores': {
+            'comparisonData': 40,
+            'ComparisonFlag': true,
+          },
+          'lateOpenStores': {
+            'comparisonData': 50,
+            'ComparisonFlag': true,
+          },
+          'earlyClosedStores': {
+            'comparisonData': 20,
+            'ComparisonFlag': false,
+          },
+          'complianceRate': {
+            'comparisonData': 10,
+            'ComparisonFlag': false,
+          },
+        };
+        break;
+      case 'mobileusagedetection':
+        resData.mobileusagedetectionCards = {};
+        resData.mobileusagedetectionCards = {
+          'totalAssignedStores': {
+            'comparisonData': 40,
+            'ComparisonFlag': true,
+          },
+          'flagIncidents': {
+            'comparisonData': 50,
+            'ComparisonFlag': false,
+          },
+          'complianceRate': {
+            'comparisonData': 40,
+            'ComparisonFlag': true,
+          },
+        };
+        break;
+      case 'uniformdetection':
+        resData.uniformdetectionCards = {};
+        resData.uniformdetectionCards = {
+          'totalAssignedStores': {
+            'comparisonData': 40,
+            'ComparisonFlag': true,
+          },
+          'flagIncidents': {
+            'comparisonData': 50,
+            'ComparisonFlag': false,
+          },
+          'complianceRate': {
+            'comparisonData': 40,
+            'ComparisonFlag': true,
+          },
+        };
+        break;
+      case 'customerunattended':
+        resData.customerunattendedCards = {};
+        resData.customerunattendedCards = {
+          'averageFootfall': {
+            'comparisonData': 40,
+            'ComparisonFlag': true,
+          },
+          'stafftoCustomerRatio': {
+            'comparisonData': 50,
+            'ComparisonFlag': true,
+          },
+          'attendedCustomers': {
+            'comparisonData': 40,
+            'ComparisonFlag': false,
+          },
+          'unattendedCustomers': {
+            'comparisonData': 10,
+            'ComparisonFlag': true,
+          },
+          'timeTakentoAssist': {
+            'comparisonData': 30,
+            'ComparisonFlag': false,
+          },
+          'timeSpentwithCustomer': {
+            'comparisonData': 40,
+            'ComparisonFlag': true,
+          },
+        };
+        break;
+      case 'staffleftinthemiddle':
+        resData.staffleftinthemiddleCards = {};
+        resData.staffleftinthemiddleCards = {
+          'avgStaffPresent': {
+            'comparisonData': 40,
+            'ComparisonFlag': false,
+          },
+          'avgStaffleft': {
+            'comparisonData': 50,
+            'ComparisonFlag': true,
+          },
+          'avgStaffPresentInPeakHours': {
+            'comparisonData': 30,
+            'ComparisonFlag': true,
+          },
+          'staffAvgPunctualityRate': {
+            'comparisonData': 50,
+            'ComparisonFlag': true,
+          },
+          'staffAvgBreakHours': {
+            'comparisonData': 40,
+            'ComparisonFlag': false,
+          },
+          'staffAvgProductiveHours': {
+            'comparisonData': 60,
+            'ComparisonFlag': true,
+          },
+        };
+        break;
+      case 'custom':
+        resData.customCards = {};
+        resData.customCards = {
+          'totalAssignedStores': {
+            'comparisonData': 40,
+            'ComparisonFlag': true,
+          },
+          'flagIncidents': {
+            'comparisonData': 20,
+            'ComparisonFlag': false,
+          },
+          'complianceRate': {
+            'comparisonData': 10,
+            'ComparisonFlag': false,
+          },
+        };
+        break;
+      default:
+        break;
+    }
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+async function tableData( checklistType ) {
+  try {
+    let resData = {};
+    resData.totalCount = 300;
+    switch ( checklistType ) {
+      case 'storeopenandclose':
+        resData.storeopenandcloseData = {};
+        resData.storeopenandcloseData = [
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST400',
+            'storeId': '11-10',
+            'storeSpocEmail': 'olivia@yopmail.com',
+            'openTime': '09:00 AM',
+            'openTimeFlag': false,
+            'closeTime': '10:00 PM',
+            'closeTimeFlag': false,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST401',
+            'storeId': '11-11',
+            'storeSpocEmail': 'yamini@yopmail.com',
+            'openTime': '09:10 AM',
+            'openTimeFlag': true,
+            'closeTime': '10:00 PM',
+            'closeTimeFlag': false,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'openTime': '09:00 AM',
+            'openTimeFlag': false,
+            'closeTime': '09:50 PM',
+            'closeTimeFlag': true,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'openTime': '09:10 AM',
+            'openTimeFlag': true,
+            'closeTime': '09:50 PM',
+            'closeTimeFlag': true,
+          },
+        ];
+        break;
+      case 'mobileusagedetection':
+        resData.mobileusagedetectionData = {};
+        resData.mobileusagedetectionData = [
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST400',
+            'storeId': '11-10',
+            'storeSpocEmail': 'olivia@yopmail.com',
+            'detections': 50,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST401',
+            'storeId': '11-11',
+            'storeSpocEmail': 'yamini@yopmail.com',
+            'detections': 60,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'detections': 70,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'detections': 90,
+          },
+        ];
+        break;
+      case 'uniformdetection':
+        resData.uniformdetectionData = {};
+        resData.uniformdetectionData = [
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST400',
+            'storeId': '11-10',
+            'storeSpocEmail': 'olivia@yopmail.com',
+            'detections': 50,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST401',
+            'storeId': '11-11',
+            'storeSpocEmail': 'yamini@yopmail.com',
+            'detections': 60,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'detections': 70,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'detections': 90,
+          },
+        ];
+        break;
+      case 'customerunattended':
+        resData.customerunattendedData = {};
+        resData.customerunattendedData = [
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST400',
+            'storeId': '11-10',
+            'storeSpocEmail': 'olivia@yopmail.com',
+            'detections': 50,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST401',
+            'storeId': '11-11',
+            'storeSpocEmail': 'yamini@yopmail.com',
+            'detections': 60,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'detections': 70,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'detections': 90,
+          },
+        ];
+        break;
+      case 'staffleftinthemiddle':
+        resData.staffleftinthemiddleData = {};
+        resData.staffleftinthemiddleData = [
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST400',
+            'storeId': '11-10',
+            'storeSpocEmail': 'olivia@yopmail.com',
+            'detections': 50,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST401',
+            'storeId': '11-11',
+            'storeSpocEmail': 'yamini@yopmail.com',
+            'detections': 60,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'detections': 70,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'detections': 90,
+          },
+        ];
+        break;
+      case 'custom':
+        resData.customData = {};
+        resData.customData = [
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST400',
+            'storeId': '11-10',
+            'storeSpocEmail': 'olivia@yopmail.com',
+            'detections': 50,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST401',
+            'storeId': '11-11',
+            'storeSpocEmail': 'yamini@yopmail.com',
+            'detections': 60,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'detections': 70,
+          },
+          {
+            'date': '02 Aug, 2024',
+            'dateString': '2024-10-10',
+            'storeName': 'LKST402',
+            'storeId': '11-12',
+            'storeSpocEmail': 'balaji@yopmail.com',
+            'detections': 90,
+          },
+        ];
+        break;
+      default:
+        break;
+    }
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+async function flagCardData( checklistType ) {
+  try {
+    let resData = {};
+    resData.flagCards = {
+      'totalFlag': 700,
+      'questionFlag': {
+        'count': 40,
+      },
+      'delayInSubmission': {
+        'count': 50,
+      },
+      'detectionFlag': {
+        'count': 20,
+      },
+    };
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+async function falgComparisonData( checklistType ) {
+  try {
+    let resData = {};
+    resData.flagComparisonCards = {
+      'questionComparisonFlag': {
+        'comparisonData': 40,
+        'ComparisonFlag': true,
+      },
+      'delayInSubmissionComparisonFlag': {
+        'comparisonData': 50,
+        'ComparisonFlag': false,
+      },
+      'detectionComparisonFlag': {
+        'comparisonData': 20,
+        'ComparisonFlag': true,
+      },
+    };
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+async function flagTableData( checklistType ) {
+  try {
+    let resData = {};
+    resData.totalCount = 300;
+    resData.flagTableData = [
+      {
+        'checklistName': 'Field VM- Store Visit Checklist',
+        'sourceCheckList_id': '668e3e1807d5312fa49b0046',
+        'checkListType': 'custom',
+        'flagType': 'Question',
+        'assignedStores': 400,
+        'flaggedStores': 50,
+        'flagCount': 30,
+        'complianceRate': 25,
+      },
+      {
+        'checklistName': 'DC Prep Checklist',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167361',
+        'checkListType': 'custom',
+        'flagType': 'Question',
+        'assignedStores': 500,
+        'flaggedStores': 66,
+        'flagCount': 66,
+        'complianceRate': 89,
+      },
+      {
+        'checklistName': 'Store Open and Close',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167361',
+        'checkListType': 'storeopenandclose',
+        'flagType': 'Question',
+        'assignedStores': 300,
+        'flaggedStores': 70,
+        'flagCount': 80,
+        'complianceRate': 25,
+      },
+      {
+        'checklistName': 'Mobileusage Detection',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167361',
+        'checkListType': 'mobileusagedetection',
+        'flagType': 'Detection',
+        'assignedStores': 250,
+        'flaggedStores': 30,
+        'flagCount': 80,
+        'complianceRate': 77,
+      },
+      {
+        'checklistName': 'Uniform Detection',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167361',
+        'checkListType': 'uniformdetection',
+        'flagType': 'Detection',
+        'assignedStores': 100,
+        'flaggedStores': 0,
+        'flagCount': 60,
+        'complianceRate': 45,
+      },
+      {
+        'checklistName': 'Customer Unattended',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167361',
+        'checkListType': 'customerunattended',
+        'flagType': 'Detection',
+        'assignedStores': 200,
+        'flaggedStores': 20,
+        'flagCount': 70,
+        'complianceRate': 55,
+      },
+      {
+        'checklistName': 'Staff Left in The Middle',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167361',
+        'checkListType': 'staffleftinthemiddle',
+        'flagType': 'Detection',
+        'assignedStores': 150,
+        'flaggedStores': 50,
+        'flagCount': 50,
+        'complianceRate': 30,
+      },
+    ];
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+async function checklistDropdownData( checklistType ) {
+  try {
+    let resData = {};
+    resData.checklistDropdownData = [
+      {
+        'checklistName': 'Field VM- Store Visit Checklist',
+        'sourceCheckList_id': '668e3e1807d5312fa49b0046',
+        'checkListType': 'custom',
+        'createdByName': 'Yamini',
+        'storeCount': 1853,
+        'scheduleRepeatedType': 'weekly',
+        'scheduleStartTime': '12:00 PM',
+        'scheduleEndTime': '06:00 PM',
+        'publish': true,
+      },
+      {
+        'checklistName': 'DC Prep Checklist',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167361',
+        'checkListType': 'custom',
+        'createdByName': 'Yamini',
+        'storeCount': 1853,
+        'scheduleRepeatedType': 'weekly',
+        'scheduleStartTime': '12:00 PM',
+        'scheduleEndTime': '06:00 PM',
+        'publish': true,
+      },
+      {
+        'checklistName': 'Store Open and Close',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167362',
+        'checkListType': 'storeopenandclose',
+        'createdByName': 'Yamini',
+        'storeCount': 1853,
+        'scheduleRepeatedType': 'weekly',
+        'scheduleStartTime': '12:00 PM',
+        'scheduleEndTime': '06:00 PM',
+        'publish': true,
+      },
+      {
+        'checklistName': 'Mobileusage Detection',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167363',
+        'checkListType': 'mobileusagedetection',
+        'createdByName': 'Yamini',
+        'storeCount': 1853,
+        'scheduleRepeatedType': 'weekly',
+        'scheduleStartTime': '12:00 PM',
+        'scheduleEndTime': '06:00 PM',
+        'publish': true,
+      },
+      {
+        'checklistName': 'Uniform Detection',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167364',
+        'checkListType': 'uniformdetection',
+        'createdByName': 'Yamini',
+        'storeCount': 1853,
+        'scheduleRepeatedType': 'weekly',
+        'scheduleStartTime': '12:00 PM',
+        'scheduleEndTime': '06:00 PM',
+        'publish': true,
+      },
+      {
+        'checklistName': 'Customer Unattended',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167365',
+        'checkListType': 'customerunattended',
+        'createdByName': 'Yamini',
+        'storeCount': 1853,
+        'scheduleRepeatedType': 'weekly',
+        'scheduleStartTime': '12:00 PM',
+        'scheduleEndTime': '06:00 PM',
+        'publish': true,
+      },
+      {
+        'checklistName': 'Staff Left in The Middle',
+        'sourceCheckList_id': '6690d95b747d2cc1f1167366',
+        'checkListType': 'staffleftinthemiddle',
+        'createdByName': 'Yamini',
+        'storeCount': 1853,
+        'scheduleRepeatedType': 'weekly',
+        'scheduleStartTime': '12:00 PM',
+        'scheduleEndTime': '06:00 PM',
+        'publish': true,
+      },
+      {
+        'checklistName': 'Field VM- Store Visit Checklist Field VM- Store Visit Checklist',
+        'sourceCheckList_id': '668e3e1807d5312fa49b0046',
+        'checkListType': 'custom',
+        'createdByName': 'Yamini',
+        'storeCount': 1853,
+        'scheduleRepeatedType': 'weekly',
+        'scheduleStartTime': '12:00 PM',
+        'scheduleEndTime': '06:00 PM',
+        'publish': true,
+      },
+    ];
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+
+// 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;
+  }
+}
+
+export const flagChecklistCardsV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+
+    if ( reqestData.ChecklistType == 'custom' ) {
+      const pipeline = [
+        {
+          $match: {
+            $and: [
+              { client_id: reqestData?.clientId },
+              { store_id: { $in: reqestData?.storeId } },
+              { date_iso: { $gte: new Date( reqestData?.fromDate ) } },
+              { date_iso: { $lte: dayjs.utc( reqestData.toDate ).endOf( 'day' ).toDate() } },
+              { sourceCheckList_id: new mongoose.Types.ObjectId( reqestData.sourceCheckList_id ) },
+            ],
+          },
+        },
+        {
+          $project: {
+            storeCount: 1,
+            sourceCheckList_id: 1,
+            timeFlag: 1,
+            questionFlag: 1,
+            questionCount: 1,
+          },
+        },
+        {
+          $group: {
+            _id: '$sourceCheckList_id',
+            totalAssignedStores: {
+              $max: '$storeCount',
+            },
+            flagIncidents: {
+              $sum: { $add: [ '$questionFlag', '$timeFlag' ] },
+              // $sum: {
+              //   $cond: [ {
+              //     $or: [
+              //       { $gt: [ '$timeFlag', 0 ] },
+              //       { $gt: [ '$questionFlag', 0 ] },
+              //     ],
+              //   }, 1, 0 ],
+              // },
+
+            },
+            questionFlag: {
+              $sum: '$questionFlag',
+              // $sum: {
+              //   $cond: [ { $gt: [ '$questionFlag', 0 ] }, 1, 0 ],
+              // },
+            },
+            questionCount: {
+              $sum: '$questionCount',
+              // $sum: {
+              //   $cond: [ { $gt: [ '$questionCount', 0 ] }, 1, 0 ],
+              // },
+            },
+
+          },
+        },
+        {
+          $project: {
+            totalAssignedStores: 1,
+            flagIncidents: 1,
+            questionCount: 1,
+            correctAnswers: { $subtract: [ '$questionCount', '$questionFlag' ] },
+
+          },
+        },
+        {
+          $project: {
+            totalAssignedStores: 1,
+            flagIncidents: 1,
+            complianceRate: {
+              $cond: {
+                if: { $eq: [ '$questionCount', 0 ] },
+                then: 0,
+                else: {
+                  $round: [ { $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ] }, 2 ],
+                },
+              },
+            },
+          },
+        },
+      ];
+
+
+      const cardData = await processedchecklistService.aggregate( pipeline );
+
+      if ( !cardData?.[0] ) {
+        return res.sendError( 'No Content', 204 );
+      }
+
+      const resData ={
+        customCards: {
+          totalAssignedStores: {
+            count: cardData?.[0]?.totalAssignedStores,
+          },
+          flagIncidents: {
+            count: cardData?.[0]?.flagIncidents,
+          },
+          complianceRate: {
+            count: cardData?.[0]?.complianceRate,
+          },
+        },
+      };
+
+
+      return res.sendSuccess( resData );
+    } else {
+      const pipeline = [
+        {
+          $match:
+            {
+              date_iso: {
+                $gte: new Date( reqestData.fromDate ),
+              },
+              date_iso: {
+                $lte: dayjs.utc( reqestData.toDate ).endOf( 'day' ).toDate(),
+              },
+              store_id: {
+                $in: reqestData.storeId,
+              },
+              client_id: reqestData.clientId,
+              sourceCheckList_id: new mongoose.Types.ObjectId( reqestData.sourceCheckList_id ),
+            },
+        },
+        {
+          $project: {
+            storeCount: 1,
+          },
+        },
+        {
+          $sort: { storeCount: -1 },
+        },
+        {
+          $limit: 1,
+        },
+      ];
+      const checklist = await aggregate( pipeline );
+      reqestData.storeCount = checklist[0]?.storeCount | 0;
+      let LamdaURL = 'https://k462fpztd3zaucty5ruoks6z540qqgqj.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 ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'flagChecklistCardsV1' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+
+export const flagChecklistComparisonCardsV1 = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let toDate = new Date( requestData.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+
+    let rangeOneFromDate;
+    let rangeOneToDate;
+    let rangeTwoFromDate;
+    let rangeTwoToDate;
+    if ( requestData.dateType == 'weekly' ) {
+      rangeOneFromDate = new Date( requestData.toDate );
+      rangeOneFromDate.setDate( rangeOneFromDate.getDate() - 6 );
+      rangeOneToDate = new Date( requestData.toDate );
+      rangeOneToDate = new Date( rangeOneToDate.getTime() - userTimezoneOffset );
+      rangeOneToDate.setUTCHours( 23, 59, 59, 59 );
+      rangeTwoToDate = new Date( requestData.toDate );
+      rangeTwoToDate.setDate( rangeTwoToDate.getDate() - 7 );
+      rangeTwoFromDate = new Date( rangeTwoToDate );
+      rangeTwoFromDate.setDate( rangeTwoFromDate.getDate() - 6 );
+      rangeTwoToDate = new Date( rangeTwoToDate.getTime() - userTimezoneOffset );
+      rangeTwoToDate.setUTCHours( 23, 59, 59, 59 );
+    } else if ( requestData.dateType == 'monthly' ) {
+      rangeOneFromDate = new Date( requestData.toDate );
+      rangeOneFromDate.setDate( rangeOneFromDate.getDate() - 30 );
+      rangeOneToDate = new Date( requestData.toDate );
+      rangeOneToDate = new Date( rangeOneToDate.getTime() - userTimezoneOffset );
+      rangeOneToDate.setUTCHours( 23, 59, 59, 59 );
+      rangeTwoToDate = new Date( requestData.toDate );
+      rangeTwoToDate.setDate( rangeTwoToDate.getDate() - 31 );
+      rangeTwoFromDate = new Date( rangeTwoToDate );
+      rangeTwoFromDate.setDate( rangeTwoFromDate.getDate() - 30 );
+      rangeTwoToDate = new Date( rangeTwoToDate.getTime() - userTimezoneOffset );
+      rangeTwoToDate.setUTCHours( 23, 59, 59, 59 );
+    } else {
+      rangeOneFromDate = new Date( requestData.toDate );
+      rangeOneFromDate.setDate( rangeOneFromDate.getDate() - 0 );
+      rangeOneToDate = new Date( requestData.toDate );
+      rangeOneToDate = new Date( rangeOneToDate.getTime() - userTimezoneOffset );
+      rangeOneToDate.setUTCHours( 23, 59, 59, 59 );
+      rangeTwoToDate = new Date( requestData.toDate );
+      rangeTwoToDate.setDate( rangeTwoToDate.getDate() - 1 );
+      rangeTwoFromDate = new Date( rangeTwoToDate );
+      rangeTwoFromDate.setDate( rangeTwoFromDate.getDate() - 0 );
+      rangeTwoToDate = new Date( rangeTwoToDate.getTime() - userTimezoneOffset );
+      rangeTwoToDate.setUTCHours( 23, 59, 59, 59 );
+    }
+
+    let flagComparisonCards = {
+      'totalAssignedStores': {
+        'comparisonData': 0,
+        'ComparisonFlag': '',
+      },
+      'flagIncidents': {
+        'comparisonData': 0,
+        'ComparisonFlag': '',
+      },
+      'complianceRate': {
+        'comparisonData': 0,
+        'ComparisonFlag': '',
+      },
+    };
+
+
+    if ( requestData.ChecklistType == 'custom' ) {
+      const range1pipeline = [
+        {
+          $match: {
+            $and: [
+              { client_id: requestData?.clientId },
+              { store_id: { $in: requestData?.storeId } },
+              { date_iso: { $gte: rangeOneFromDate } },
+              { date_iso: { $lte: rangeOneToDate } },
+              { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.sourceCheckList_id ) },
+            ],
+          },
+        },
+        {
+          $project: {
+            storeCount: 1,
+            sourceCheckList_id: 1,
+            timeFlag: 1,
+            questionFlag: 1,
+            questionCount: 1,
+          },
+        },
+        {
+          $group: {
+            _id: '$sourceCheckList_id',
+            totalAssignedStores: {
+              $max: '$storeCount',
+            },
+            flagIncidents: {
+
+              $sum: {
+                $add: [ '$questionFlag', '$timeFlag' ],
+                // $cond: [ {
+                //   $or: [
+                //     { $gt: [ '$timeFlag', 0 ] },
+                //     { $gt: [ '$questionFlag', 0 ] },
+                //   ],
+                // }, 1, 0 ],
+              },
+
+            },
+            questionFlag: {
+              $sum: '$questionFlag',
+              // $sum: {
+              //   $cond: [ { $gt: [ '$questionFlag', 0 ] }, 1, 0 ],
+              // },
+            },
+            questionCount: {
+              $sum: '$questionCount',
+              // $sum: {
+              //   $cond: [ { $gt: [ '$questionCount', 0 ] }, 1, 0 ],
+              // },
+            },
+
+          },
+        },
+        {
+          $project: {
+            totalAssignedStores: 1,
+            flagIncidents: 1,
+            questionCount: 1,
+            correctAnswers: { $subtract: [ '$questionCount', '$questionFlag' ] },
+
+          },
+        },
+        {
+          $project: {
+            totalAssignedStores: 1,
+            flagIncidents: 1,
+            complianceRate: {
+              $cond: {
+                if: { $eq: [ '$questionCount', 0 ] },
+                then: 0,
+                else: {
+                  $round: [ { $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ] }, 2 ],
+                },
+              },
+            },
+          },
+        },
+      ];
+
+      const range2pipeline = [
+        {
+          $match: {
+            $and: [
+              { client_id: requestData?.clientId },
+              { store_id: { $in: requestData?.storeId } },
+              { date_iso: { $gte: rangeTwoFromDate } },
+              { date_iso: { $lte: rangeTwoToDate } },
+              { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.sourceCheckList_id ) },
+            ],
+          },
+        },
+        {
+          $project: {
+            storeCount: 1,
+            sourceCheckList_id: 1,
+            timeFlag: 1,
+            questionFlag: 1,
+            questionCount: 1,
+          },
+        },
+        {
+          $group: {
+            _id: '$sourceCheckList_id',
+            totalAssignedStores: {
+              $max: '$storeCount',
+            },
+            flagIncidents: {
+              $sum: {
+                $add: [ '$questionFlag', '$timeFlag' ],
+                // $cond: [ {
+                //   $or: [
+                //     { $gt: [ '$timeFlag', 0 ] },
+                //     { $gt: [ '$questionFlag', 0 ] },
+                //   ],
+                // }, 1, 0 ],
+              },
+
+            },
+            questionFlag: {
+              $sum: '$questionFlag',
+              // $sum: {
+              //   $cond: [ { $gt: [ '$questionFlag', 0 ] }, 1, 0 ],
+              // },
+            },
+            questionCount: {
+              $sum: '$questionCount',
+              // $sum: {
+              //   $cond: [ { $gt: [ '$questionCount', 0 ] }, 1, 0 ],
+              // },
+            },
+
+          },
+        },
+        {
+          $project: {
+            totalAssignedStores: 1,
+            flagIncidents: 1,
+            questionCount: 1,
+            correctAnswers: { $subtract: [ '$questionCount', '$questionFlag' ] },
+
+          },
+        },
+        {
+          $project: {
+            totalAssignedStores: 1,
+            flagIncidents: 1,
+            complianceRate: {
+              $cond: {
+                if: { $eq: [ '$questionCount', 0 ] },
+                then: 0,
+                else: {
+                  $round: [ { $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ] }, 2 ],
+                },
+              },
+            },
+          },
+        },
+      ];
+
+      const [ rangeOneData, rangeTwoData ] = await Promise.all( [ processedchecklistService.aggregate( range1pipeline ), processedchecklistService.aggregate( range2pipeline ) ] );
+
+
+      if ( rangeOneData.length >0 && rangeTwoData.length >0 ) {
+        flagComparisonCards.totalAssignedStores.comparisonData = ( ( ( rangeOneData[0].totalAssignedStores - rangeTwoData[0].totalAssignedStores )/rangeOneData[0].totalAssignedStores )*100 ).toFixed( 1 );
+        if ( flagComparisonCards.totalAssignedStores.comparisonData > 0 ) {
+          flagComparisonCards.totalAssignedStores.ComparisonFlag = true;
+        } else {
+          flagComparisonCards.totalAssignedStores.ComparisonFlag = false;
+        }
+        flagComparisonCards.flagIncidents.comparisonData = ( ( ( rangeOneData[0].flagIncidents - rangeTwoData[0].flagIncidents )/rangeOneData[0].flagIncidents )*100 ).toFixed( 1 );
+        if ( flagComparisonCards.flagIncidents.comparisonData > 0 ) {
+          flagComparisonCards.flagIncidents.ComparisonFlag = true;
+        } else {
+          flagComparisonCards.flagIncidents.ComparisonFlag = false;
+        }
+        flagComparisonCards.complianceRate.comparisonData = ( ( ( rangeOneData[0].complianceRate - rangeTwoData[0].complianceRate )/rangeOneData[0].complianceRate )*100 ).toFixed( 1 );
+        if ( flagComparisonCards.complianceRate.comparisonData > 0 ) {
+          flagComparisonCards.complianceRate.ComparisonFlag = true;
+        } else {
+          flagComparisonCards.complianceRate.ComparisonFlag = false;
+        }
+
+        flagComparisonCards.totalAssignedStores.comparisonData = Math.abs( flagComparisonCards.totalAssignedStores.comparisonData );
+        flagComparisonCards.flagIncidents.comparisonData = Math.abs( flagComparisonCards.flagIncidents.comparisonData );
+        flagComparisonCards.complianceRate.comparisonData = Math.abs( flagComparisonCards.complianceRate.comparisonData );
+      }
+
+      let result = {
+        'customCards': flagComparisonCards,
+      };
+
+      return res.sendSuccess( result );
+    } else {
+      const fromPipeline = [
+        {
+          $match:
+            {
+              date_iso: {
+                $gte: rangeOneFromDate,
+              },
+              date_iso: {
+                $lte: rangeOneToDate,
+              },
+              store_id: {
+                $in: requestData.storeId,
+              },
+              client_id: requestData.clientId,
+              sourceCheckList_id: new mongoose.Types.ObjectId( requestData.sourceCheckList_id ),
+            },
+        },
+        {
+          $project: {
+            storeCount: 1,
+          },
+        },
+        {
+          $sort: { storeCount: -1 },
+        },
+        {
+          $limit: 1,
+        },
+      ];
+      const from = await aggregate( fromPipeline );
+      requestData.range1StoreCount = from[0]?.storeCount | 0;
+
+      const toPipeline = [
+        {
+          $match:
+            {
+              date_iso: {
+                $gte: rangeTwoFromDate,
+              },
+              date_iso: {
+                $lte: rangeTwoToDate,
+              },
+              store_id: {
+                $in: requestData.storeId,
+              },
+              client_id: requestData.clientId,
+              sourceCheckList_id: new mongoose.Types.ObjectId( requestData.sourceCheckList_id ),
+            },
+        },
+        {
+          $project: {
+            storeCount: 1,
+          },
+        },
+        {
+          $sort: { storeCount: -1 },
+        },
+        {
+          $limit: 1,
+        },
+      ];
+
+
+      const to = await aggregate( toPipeline );
+      requestData.range2StoreCount = to[0]?.storeCount | 0;
+      let LamdaURL = 'https://5m55vcuecg2hll7jzfppx6h53y0lvcmq.lambda-url.ap-south-1.on.aws/';
+      let resultData = await LamdaServiceCall( LamdaURL, requestData );
+      // console.log( 'resultData =>', resultData );
+      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 ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'flagChecklistComparisonCardsV1' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+
+export const flagChecklistTableV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    if ( reqestData.ChecklistType == 'custom' ) {
+      const match = {
+        $match: {
+          $and: [
+            { client_id: reqestData?.clientId },
+            { store_id: { $in: reqestData?.storeId } },
+            { date_iso: { $gte: new Date( reqestData?.fromDate ) } },
+            { date_iso: { $lte: dayjs.utc( reqestData.toDate ).endOf( 'day' ).toDate() } },
+            { sourceCheckList_id: new mongoose.Types.ObjectId( reqestData.sourceCheckList_id ) },
+            // {
+            //   $or: [
+            //     { timeFlag: { $gt: 0 } },
+            //     { questionFlag: { $gt: 0 } },
+            //   ],
+            // },
+          ],
+        },
+      };
+
+      if ( reqestData?.filter === 'question' ) {
+        match.$match.$and.push( { questionFlag: { $gte: 1 } } );
+      } else if ( reqestData?.filter === 'time' ) {
+        match.$match.$and.push( { timeFlag: { $gte: 1 } } );
+      }
+      const pipeline = [
+        match,
+        {
+          $project: {
+            storeSpocEmail: '$userEmail',
+            dateString: '$date_string',
+            storeName: 1,
+            storeId: '$store_id',
+            date_iso: 1,
+            checklistStatus: 1,
+            questionFlagCount: '$questionFlag',
+            timeFlagCount: '$timeFlag',
+            reinitiateStatus: true,
+            // detections: {
+            //   $sum: {
+            //     $cond: [
+            //       {
+            //         $or: [
+            //           { $gt: [ '$timeFlag', 0 ] },
+            //           { $gt: [ '$questionFlag', 0 ] },
+            //         ],
+            //       },
+            //       1,
+            //       0,
+            //     ],
+            //   },
+            // },
+            detections: {
+              $sum: {
+                $add: [ '$questionFlag', '$timeFlag' ],
+              },
+            },
+          },
+        },
+      ];
+
+      if ( reqestData.search && reqestData.search != '' ) {
+        pipeline[0].$match.$and.push( { storeName: { $regex: reqestData.search, $options: 'i' } } );
+      }
+
+      const total = await processedchecklistService.aggregate( pipeline );
+
+      if ( !total.length ) {
+        return res.sendError( { error: 'No Data Found' }, 204 );
+      }
+
+      if ( reqestData.sortColumnName && reqestData.sortColumnName != '' && reqestData.sortBy && reqestData.sortBy !='' ) {
+        pipeline.push( { $sort: { [reqestData.sortColumnName]: reqestData.sortBy } } );
+      } else {
+        pipeline.push( { $sort: { ['date_iso']: -1 } } );
+      }
+
+      if ( reqestData.export ) {
+        const exportdata = [];
+        total.forEach( ( element ) => {
+          exportdata.push( {
+            'Date': dayjs( element.dateString ).format( 'DD MMM, YYYY' ),
+            'Store Name': element?.storeName,
+            'Store Id': element?.storeId,
+            'Store Spoc Email': element?.storeSpocEmail,
+            'Detections': element?.detections,
+          } );
+        } );
+        return await download( exportdata, res );
+      }
+
+      const limit = parseInt( reqestData?.limit ) || 10;
+      const skip = limit * ( reqestData?.offset ) || 0;
+      pipeline.push( { $skip: skip }, { $limit: limit } );
+
+      const data = await processedchecklistService.aggregate( pipeline );
+      if ( !data.length ) {
+        return res.sendError( { error: 'No Data Found' }, 204 );
+      }
+
+      for ( let index = 0; index < data.length; index++ ) {
+        data[index].date = dayjs( data[index].dateString ).format( 'DD MMM, YYYY' );
+      }
+
+
+      return res.sendSuccess( { customData: data, totalCount: total?.length } );
+    } else {
+      if ( reqestData.export ) {
+        reqestData.limit = 10000;
+        reqestData.offset = 0;
+        let LamdaURL = 'https://vpcejaftccr3jzqf5wrdkks7yy0krqix.lambda-url.ap-south-1.on.aws/';
+        let resultData = await LamdaServiceCall( LamdaURL, reqestData );
+        if ( resultData ) {
+          if ( resultData.status_code == '200' ) {
+            const exportdata = [];
+            resultData[reqestData.ChecklistType + 'Data'].forEach( ( element ) => {
+              exportdata.push( {
+                'Date': element?.date,
+                'Store Name': element?.storeName,
+                'Store Id': element?.storeId,
+                // 'Store Spoc Email': element?.SpocEmail,
+                'Detections': element?.detections,
+              } );
+            } );
+            return await download( exportdata, res );
+          } else {
+            return res.sendError( 'No Content', 204 );
+          }
+        } else {
+          return res.sendError( 'No Content', 204 );
+        }
+      }
+
+      let LamdaURL = 'https://vpcejaftccr3jzqf5wrdkks7yy0krqix.lambda-url.ap-south-1.on.aws/';
+      let resultData = await LamdaServiceCall( LamdaURL, reqestData );
+      // console.log( 'resultData =>', resultData );
+      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 ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'flagChecklistTableV1' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const checklistDropdownSourceChecklist = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let fromDate = new Date( requestData.fromDate );
+    let toDate = new Date( requestData.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+    let result = {};
+
+    let findQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { client_id: requestData.clientId },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListName: 1,
+        checkListType: 1,
+        createdByName: 1,
+        storeCount: 1,
+        scheduleRepeatedType: 1,
+        scheduleStartTime: 1,
+        scheduleEndTime: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+        sourceCheckList_id: { $last: '$sourceCheckList_id' },
+        checkListName: { $last: '$checkListName' },
+        checkListType: { $last: '$checkListType' },
+        createdByName: { $last: '$createdByName' },
+        storeCount: { $max: '$storeCount' },
+        scheduleRepeatedType: { $last: '$scheduleRepeatedType' },
+        scheduleStartTime: { $last: '$scheduleStartTime' },
+        scheduleEndTime: { $last: '$scheduleEndTime' },
+      },
+    } );
+
+    findQuery.push( {
+      $lookup: {
+        from: 'checklistconfigs',
+        let: { sourceCheckList_id: '$sourceCheckList_id' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: [ '$_id', '$$sourceCheckList_id' ] },
+                ],
+              },
+            },
+          },
+          {
+            $project: {
+              checkListName: 1,
+              publish: 1,
+            },
+          },
+        ], as: 'checklistconfigs',
+      },
+    } );
+    findQuery.push( { $unwind: { path: '$checklistconfigs', preserveNullAndEmptyArrays: true } } );
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListName: 1,
+        checkListType: 1,
+        createdByName: 1,
+        storeCount: 1,
+        scheduleRepeatedType: 1,
+        scheduleStartTime: 1,
+        scheduleEndTime: 1,
+        publish: '$checklistconfigs.publish',
+      },
+    } );
+
+    let getTotalCount = await processedchecklistconfigService.aggregate( findQuery );
+    if ( !getTotalCount.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
+      findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
+    } else {
+      findQuery.push( { $sort: { ['checkListName']: -1 } } );
+    }
+
+    let getChecklistData = await processedchecklistconfigService.aggregate( findQuery );
+    result.checklistData = getChecklistData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'checklistDropdownV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const checklistDropdownV1 = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let fromDate = new Date( requestData.fromDate );
+    let toDate = new Date( requestData.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+    let result = {};
+
+    let findQuery = [
+      { $match: { $and: [
+        { client_id: requestData.clientId },
+        {
+          $or: [
+            { store_id: { $in: requestData.storeId } },
+            { aiStoreList: { $in: requestData.storeId } },
+          ],
+        },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+        {
+          $or: [
+            { questionFlag: { $gte: 1 } },
+            { timeFlag: { $gte: 1 } },
+            { checkListType: { $ne: 'custom' } },
+          ],
+        },
+      ] } },
+      {
+        $project: {
+          sourceCheckList_id: 1,
+          checkListName: 1,
+        },
+      },
+      {
+        $group: {
+          _id: '$sourceCheckList_id',
+          checkListName: { $last: '$checkListName' },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          sourceCheckList_id: '$_id',
+          checkListName: 1,
+        },
+      },
+      {
+        $lookup: {
+          from: 'checklistconfigs',
+          let: { sourceId: '$sourceCheckList_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$_id', '$$sourceId' ] },
+                  ],
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 1,
+                checkListName: 1,
+                checkListNameLowercase: { $toLower: '$checkListName' },
+                checkListType: 1,
+                createdByName: 1,
+                publish: 1,
+                scheduleEndTime: 1,
+                scheduleRepeatedType: 1,
+                scheduleStartTime: 1,
+                sourceCheckList_id: '$_id',
+                storeCount: 1,
+              },
+            },
+          ], as: 'checklistData',
+        },
+      },
+      { $unwind: { path: '$checklistData', preserveNullAndEmptyArrays: true } },
+      {
+        $project: {
+          _id: '$checklistData._id',
+          checkListName: '$checklistData.checkListName',
+          checkListNameLowercase: { $toLower: '$checkListName' },
+          checkListType: '$checklistData.checkListType',
+          createdByName: '$checklistData.createdByName',
+          publish: '$checklistData.publish',
+          scheduleEndTime: '$checklistData.scheduleEndTime',
+          scheduleRepeatedType: '$checklistData.scheduleRepeatedType',
+          scheduleStartTime: '$checklistData.scheduleStartTime',
+          sourceCheckList_id: '$checklistData._id',
+          storeCount: '$checklistData.storeCount',
+        },
+      },
+    ];
+
+    findQuery.push( { $sort: { checkListName: 1 } } );
+
+    let getChecklistData = await processedchecklistService.aggregate( findQuery );
+
+    if ( !getChecklistData.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+    result.totalCount = getChecklistData.length;
+    result.checklistData = getChecklistData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'checklistDropdown' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};