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

package/src/controllers/traxDashboard.controllers.js

@@ -0,0 +1,3523 @@
+import { logger, download } from 'tango-app-api-middleware';
+import * as processedchecklistService from '../services/processedchecklist.services.js';
+import * as processedchecklistconfigService from '../services/processedchecklistconfig.services.js';
+import * as checklistconfigService from '../services/checklist.service.js';
+import mongoose from 'mongoose';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+dayjs.extend( utc );
+
+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: 'welcome' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const overallCardsOld = 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 activeUnique = 0;
+    let notSubmittedInstances = {
+      'count': '',
+      'open': '',
+      'inprogress': '',
+    };
+    let totalInstances = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let completedInstances = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let flags = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let completionScore = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let complianceRate = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let result = {};
+
+    let findQuery = [];
+    let findUniqueQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListId: 1,
+        checklistStatus: 1,
+        timeFlag: 1,
+        questionFlag: 1,
+        mobileDetectionFlag: 1,
+        storeOpenCloseFlag: 1,
+        uniformDetectionFlag: 1,
+        markasread: 1,
+        checkListType: 1,
+        questionCount: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '',
+        totalChecklist: { $sum: 1 },
+        notSubmittedChecklist: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $ne: [ '$checklistStatus', 'submit' ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+        openChecklist: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $eq: [ '$checklistStatus', 'open' ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+        inprogressChecklist: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $eq: [ '$checklistStatus', 'inprogress' ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+        submittedChecklist: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $eq: [ '$checklistStatus', 'submit' ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+        flaggedChecklist: {
+          $sum: {
+            $cond: [ {
+              $or: [
+                { $gt: [ '$timeFlag', 0 ] },
+                { $gt: [ '$mobileDetectionFlag', 0 ] },
+                { $gt: [ '$storeOpenCloseFlag', 0 ] },
+                { $gt: [ '$uniformDetectionFlag', 0 ] },
+              ],
+            }, 1, 0 ],
+          },
+        },
+        questionFlagCount: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $gt: [ '$questionFlag', 0 ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+        questionCount: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $gt: [ '$questionCount', 0 ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        totalChecklist: 1,
+        notSubmittedChecklist: 1,
+        openChecklist: 1,
+        inprogressChecklist: 1,
+        submittedChecklist: 1,
+        flaggedChecklist: 1,
+        completionScore: {
+          $multiply: [
+            { $divide: [ '$submittedChecklist', '$totalChecklist' ] },
+            100,
+          ],
+        },
+        questionFlagCount: 1,
+        questionCount: 1,
+        questionCompletionScore: {
+          $multiply: [
+            { $divide: [
+              { $subtract: [ '$questionCount', '$questionFlagCount' ] },
+              '$questionCount',
+            ] },
+            100,
+          ],
+        },
+      },
+    } );
+    let getOverallChecklistData = await processedchecklistService.aggregate( findQuery );
+
+    findUniqueQuery.push( { $match: { $and: findAndQuery } } );
+    findUniqueQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+      },
+    } );
+    findUniqueQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+      },
+    } );
+    findUniqueQuery.push( {
+      $count: 'totalUniqueChecklist',
+    } );
+    let getUniqueChecklistData = await processedchecklistService.aggregate( findUniqueQuery );
+    if ( !getUniqueChecklistData.length && !getOverallChecklistData.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( getUniqueChecklistData.length && getUniqueChecklistData.length>0 ) {
+      if ( getUniqueChecklistData[0].totalUniqueChecklist ) {
+        activeUnique = getUniqueChecklistData[0]?.totalUniqueChecklist;
+      }
+    }
+
+    if ( getOverallChecklistData.length && getOverallChecklistData.length>0 ) {
+      if ( getOverallChecklistData[0].totalChecklist ) {
+        totalInstances.count = getOverallChecklistData[0]?.totalChecklist;
+      }
+      if ( getOverallChecklistData[0].notSubmittedChecklist ) {
+        notSubmittedInstances.count = getOverallChecklistData[0]?.notSubmittedChecklist;
+      }
+      if ( getOverallChecklistData[0].openChecklist ) {
+        notSubmittedInstances.open = getOverallChecklistData[0]?.openChecklist;
+      }
+      if ( getOverallChecklistData[0].inprogressChecklist ) {
+        notSubmittedInstances.inprogress = getOverallChecklistData[0]?.inprogressChecklist;
+      }
+      if ( getOverallChecklistData[0].submittedChecklist ) {
+        completedInstances.count = getOverallChecklistData[0]?.submittedChecklist;
+      }
+      if ( getOverallChecklistData[0].flaggedChecklist ) {
+        flags.count = getOverallChecklistData[0]?.flaggedChecklist;
+      }
+      if ( getOverallChecklistData[0].completionScore ) {
+        completionScore.count = getOverallChecklistData[0]?.completionScore;
+      }
+      if ( getOverallChecklistData[0].questionCompletionScore ) {
+        complianceRate.count = getOverallChecklistData[0]?.questionCompletionScore;
+      }
+    }
+    result.overallCards = {
+      'activeUnique': activeUnique,
+      'totalInstances': totalInstances,
+      'notSubmittedInstances': notSubmittedInstances,
+      'completedInstances': completedInstances,
+      'flags': flags,
+      'completionScore': completionScore,
+      'complianceRate': complianceRate,
+    };
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'overallCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const checklistPerformance = 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(
+        { checkListType: { $eq: 'custom' } },
+        { date_iso: { $gte: fromDate, $lte: toDate } },
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    if ( requestData.searchValue && requestData.searchValue != '' ) {
+      let checkListSearch = requestData.searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
+      let query;
+      if ( checkListSearch.length > 1 ) {
+        findQuery.push( { $addFields: { cheklistlowercase: { $toLower: '$checkListName' } } } );
+        query = { cheklistlowercase: { $in: checkListSearch } };
+      } else {
+        query = { checkListName: { $regex: requestData.searchValue.trim(), $options: 'i' } };
+      }
+      findQuery.push( { $match: { $or: [ query ] } } );
+    }
+
+    // findQuery.push( {
+    //   $project: {
+    //     sourceCheckList_id: 1,
+    //     checkListId: 1,
+    //     checkListName: 1,
+    //     storeCount: 1,
+    //     createdBy: 1,
+    //     createdByName: 1,
+    //     checklistStatus: 1,
+    //     timeFlag: 1,
+    //     questionFlag: 1,
+    //     checkListType: 1,
+    //     scheduleRepeatedType: 1,
+    //   },
+    // } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+        sourceCheckList_id: { $last: '$sourceCheckList_id' },
+        checkListName: { $last: '$checkListName' },
+        checkListChar: { $last: { $substr: [ '$checkListName', 0, 2 ] } },
+        scheduleRepeatedType: { $last: '$scheduleRepeatedType' },
+        // storeCount: { $max: '$storeCount' },
+        storeCount: { $sum: 1 },
+        submittedChecklist: {
+          $sum: {
+            $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ],
+          },
+        },
+        timeFlag: { $sum: '$timeFlag' },
+        questionFlagCount: { $sum: '$questionFlag' },
+        checkListType: { $last: '$checkListType' },
+      },
+    } );
+    findQuery.push( {
+      $project: {
+        _id: 1,
+        sourceCheckList_id: 1,
+        checkListName: 1,
+        checkListChar: 1,
+        scheduleRepeatedType: {
+          $concat: [
+            { $toUpper: { $substr: [ '$scheduleRepeatedType', 0, 1 ] } }, // Capitalize the first letter
+            { $substr: [ '$scheduleRepeatedType', 1, { $strLenCP: '$scheduleRepeatedType' } ] }, // Append the rest of the string
+          ],
+        },
+        storeCount: 1,
+        submittedChecklist: 1,
+        flaggedChecklist: { $add: [ '$timeFlag', '$questionFlagCount' ] },
+        checkListType: 1,
+      },
+    } );
+
+    if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
+      findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
+    } else {
+      findQuery.push( { $sort: { ['submittedChecklist']: -1 } } );
+    }
+
+    let limit = parseInt( requestData?.limit ) || 10;
+    let skip = limit * ( requestData?.offset ) || 0;
+
+    findQuery.push( {
+      $facet: {
+        data: [
+          { $skip: skip }, { $limit: limit },
+        ],
+        count: [
+          { $count: 'total' },
+        ],
+      },
+    } );
+    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
+    if ( !getChecklistPerformanceData[0].data.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+
+    if ( requestData.export ) {
+      const exportdata = [];
+      getChecklistPerformanceData[0].data.forEach( ( element ) => {
+        exportdata.push( {
+          'Checklist Name': element.checkListName,
+          'Scheduled': element.scheduleRepeatedType,
+          'Assigned To': element.storeCount,
+          'Submitted': element.submittedChecklist,
+          'Flags': element.flaggedChecklist,
+        } );
+      } );
+      return await download( exportdata, res );
+    }
+
+    result.totalCount = getChecklistPerformanceData[0].count[0].total;
+    result.checklistPerformance = getChecklistPerformanceData[0].data;
+    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 );
+  }
+};
+
+export const storePerformance = 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 },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+        { checkListType: { $eq: 'custom' } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    // if ( requestData.searchValue && requestData.searchValue != '' ) {
+    //   findQuery.push( { $match: { $or: [ { storeName: { $regex: requestData.searchValue, $options: 'i' } } ] } } );
+    // }
+
+    if ( requestData.searchValue && requestData.searchValue != '' ) {
+      let storeList = requestData.searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
+      let query;
+      if ( storeList.length > 1 ) {
+        findQuery.push( { $addFields: { store: { $toLower: '$storeName' } } } );
+        query = { store: { $in: storeList } };
+      } else {
+        query = { storeName: { $regex: requestData.searchValue.trim(), $options: 'i' } };
+      }
+      findQuery.push( { $match: { $or: [ query ] } } );
+    }
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListId: 1,
+        checkListName: 1,
+        storeCount: 1,
+        createdBy: 1,
+        createdByName: 1,
+        checklistStatus: 1,
+        timeFlag: 1,
+        questionFlag: 1,
+        questionCount: 1,
+        checkListType: 1,
+        scheduleRepeatedType: 1,
+        store_id: 1,
+        storeName: 1,
+        userEmail: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$store_id',
+        totalChecklist: { $sum: 1 },
+        storeName: { $last: '$storeName' },
+        userEmail: { $last: '$userEmail' },
+        checkListCount: { $sum: '$_id' },
+        timeFlag: { $sum: '$timeFlag' },
+        submittedChecklist: {
+          $sum: {
+            $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ],
+          },
+        },
+        checkListType: { $last: '$checkListType' },
+        // questionFlag: { $sum: '$questionFlag' },
+        questionFlag: { $sum: { $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, '$questionFlag', 0 ] } },
+        questionCount: { $sum: '$questionCount' },
+        submitQuestionCount: { $sum: { $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, '$questionCount', 0 ] } },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        store_id: 1,
+        storeName: 1,
+        userEmail: 1,
+        checkListCount: { $sum: '$totalChecklist' },
+        flaggedCount: { $add: [ '$timeFlag', '$questionFlag' ] },
+        submittedChecklist: 1,
+        checkListType: 1,
+        questionCount: 1,
+        questionFlag: 1,
+        timeFlag: 1,
+        completion: {
+          $round: [ { $multiply: [ { $divide: [ '$submittedChecklist', '$totalChecklist' ] }, 100 ] }, 0 ],
+        },
+        correctAnswers: { $subtract: [ '$submitQuestionCount', '$questionFlag' ] },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        store_id: 1,
+        storeName: 1,
+        userEmail: 1,
+        checkListCount: 1,
+        flaggedCount: 1,
+        submittedChecklist: 1,
+        checkListType: 1,
+        questionCount: 1,
+        questionFlag: 1,
+        timeFlag: 1,
+        completion: 1,
+        correctAnswers: 1,
+        compliance: {
+          $cond: {
+            if: { $eq: [ '$questionCount', 0 ] },
+            then: 0,
+            else: {
+              $round: [ { $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ] }, 0 ],
+            },
+          },
+        },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        store_id: 1,
+        storeName: 1,
+        lowercaseStoreName: { $toLower: '$storeName' },
+        userEmail: 1,
+        checkListCount: 1,
+        flaggedCount: 1,
+        submittedChecklist: 1,
+        checkListType: 1,
+        questionCount: 1,
+        questionFlag: 1,
+        timeFlag: 1,
+        correctAnswers: 1,
+        completion: 1,
+        compliance: 1,
+        performance: { $round: [ { $divide: [ { $add: [ '$completion', '$compliance' ] }, 2 ] }, 0 ] },
+      },
+    } );
+
+    // 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 !='' ) {
+      if ( requestData.sortColumnName == 'storeName' ) {
+        findQuery.push( { $sort: { ['lowercaseStoreName']: requestData.sortBy } } );
+      } else {
+        findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
+      }
+    } else {
+      findQuery.push( { $sort: { ['submittedChecklist']: -1 } } );
+    }
+
+    let limit = parseInt( requestData?.limit ) || 10;
+    let skip = limit * ( requestData?.offset ) || 0;
+    findQuery.push( {
+      $facet: {
+        data: [
+          { $skip: skip }, { $limit: limit },
+        ],
+        count: [
+          { $count: 'total' },
+        ],
+      },
+    },
+    );
+
+    let getStorePerformanceData = await processedchecklistService.aggregate( findQuery );
+    if ( !getStorePerformanceData[0].data.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+
+    if ( requestData.export ) {
+      const exportdata = [];
+      getStorePerformanceData[0].data.forEach( ( element ) => {
+        exportdata.push( {
+          'Store Name': element.storeName,
+          'Store Spoc': element.userEmail,
+          'Checklist Assigned': element.checkListCount,
+          'Flags': element.flaggedCount,
+          'Completion': element.completion,
+          'Compliance': element.compliance,
+          'Performance': element.performance,
+        } );
+      } );
+      return await download( exportdata, res );
+    }
+
+    result.totalCount = getStorePerformanceData[0].count[0].total;
+    result.storePerformance = getStorePerformanceData[0].data;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'storePerformance' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const userPerformance = 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(
+        { date_iso: { $gte: fromDate, $lte: toDate } },
+        { checkListType: { $eq: 'custom' } },
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    // if ( requestData.searchValue && requestData.searchValue != '' ) {
+    //   findQuery.push( { $match: { $or: [ { userName: { $regex: requestData.searchValue, $options: 'i' } } ] } } );
+    // }
+
+    if ( requestData.searchValue && requestData.searchValue != '' ) {
+      let userSearch = requestData.searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
+      let query;
+      if ( userSearch.length > 1 ) {
+        findQuery.push( { $addFields: { userNamelowercase: { $toLower: '$userName' } } } );
+        query = { userNamelowercase: { $in: userSearch } };
+      } else {
+        query = { userName: { $regex: requestData.searchValue.trim(), $options: 'i' } };
+      }
+      findQuery.push( { $match: { $or: [ query ] } } );
+    }
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListId: 1,
+        checkListName: 1,
+        storeCount: 1,
+        createdBy: 1,
+        createdByName: 1,
+        checklistStatus: 1,
+        timeFlag: 1,
+        questionFlag: 1,
+        mobileDetectionFlag: 1,
+        storeOpenCloseFlag: 1,
+        uniformDetectionFlag: 1,
+        checkListType: 1,
+        scheduleRepeatedType: 1,
+        store_id: 1,
+        storeName: 1,
+        userEmail: 1,
+        userName: 1,
+        questionCount: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$userName',
+        totalChecklist: { $sum: 1 },
+        userEmail: { $last: '$userEmail' },
+        checkListCount: { $sum: '$_id' },
+        timeFlag: { $sum: '$timeFlag' },
+        submittedChecklist: {
+          $sum: {
+            $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ],
+          },
+        },
+        checkListType: { $last: '$checkListType' },
+        // questionFlag: { $sum: '$questionFlag' },
+        questionFlag: { $sum: { $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, '$questionFlag', 0 ] } },
+        questionCount: { $sum: '$questionCount' },
+        submittedChecklistQuestionCount: { $sum: { $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, '$questionCount', 0 ] } },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        userName: '$_id',
+        userEmail: 1,
+        checkListCount: { $sum: '$totalChecklist' },
+        flaggedCount: { $add: [ '$timeFlag', '$questionFlag' ] },
+        submittedChecklist: 1,
+        timeFlag: 1,
+        checkListType: 1,
+        questionCount: 1,
+        questionFlag: 1,
+        completion: {
+          $round: [ { $multiply: [ { $divide: [ '$submittedChecklist', '$totalChecklist' ] }, 100 ] }, 0 ],
+          // $multiply: [ { $divide: [ '$submittedChecklist', '$totalChecklist' ] }, 100 ],
+        },
+        correctAnswers: { $subtract: [ '$submittedChecklistQuestionCount', '$questionFlag' ] },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        userName: 1,
+        userEmail: 1,
+        checkListCount: 1,
+        flaggedCount: 1,
+        submittedChecklist: 1,
+        checkListType: 1,
+        questionCount: 1,
+        questionFlag: 1,
+        timeFlag: 1,
+        completion: 1,
+        compliance: 1,
+        compliance: {
+          $cond: {
+            if: { $eq: [ '$questionCount', 0 ] },
+            then: 0,
+            else: {
+              $round: [ { $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ] }, 0 ],
+              // $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ],
+            },
+          },
+        },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        userName: 1,
+        lowercaseUserName: { $toLower: '$userName' },
+        userEmail: 1,
+        checkListCount: 1,
+        flaggedCount: 1,
+        submittedChecklist: 1,
+        checkListType: 1,
+        questionCount: 1,
+        questionFlag: 1,
+        timeFlag: 1,
+        correctAnswers: 1,
+        completion: 1,
+        compliance: 1,
+        performance: { $round: [ { $divide: [ { $add: [ '$completion', '$compliance' ] }, 2 ] }, 0 ] },
+        // performance: { $divide: [ { $add: [ '$completion', '$compliance' ] }, 2 ] },
+      },
+    } );
+
+    // 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 !='' ) {
+      if ( requestData.sortColumnName == 'userName' ) {
+        findQuery.push( { $sort: { ['lowercaseUserName']: requestData.sortBy } } );
+      } else {
+        findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
+      }
+    } else {
+      findQuery.push( { $sort: { ['userName']: -1 } } );
+    }
+
+    let limit = parseInt( requestData?.limit ) || 10;
+    let skip = limit * ( requestData?.offset ) || 0;
+    findQuery.push( {
+      $facet: {
+        data: [
+          { $skip: skip }, { $limit: limit },
+        ],
+        count: [
+          { $count: 'total' },
+        ],
+      },
+    },
+    );
+
+    let getUserPerformanceData = await processedchecklistService.aggregate( findQuery );
+
+    if ( !getUserPerformanceData[0].data.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    result.totalCount = getUserPerformanceData[0].count[0].total;
+    result.userPerformance = getUserPerformanceData[0].data;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'userPerformance' } );
+    return res.sendError( { error: 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 } },
+        { checkListType: { $eq: 'custom' } },
+    );
+
+    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: 'checklistDropdown' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const storeDropdown = 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 },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    findQuery.push( {
+      $project: {
+        store_id: 1,
+        storeName: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$store_id',
+        storeName: { $last: '$storeName' },
+      },
+    } );
+    findQuery.push( {
+      $project: {
+        _id: 0,
+        store_id: '$_id',
+        storeName: 1,
+      },
+    } );
+    findQuery.push( {
+      $lookup: {
+        from: 'stores',
+        let: { store_id: '$store_id' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: [ '$storeId', '$$store_id' ] },
+                ],
+              },
+            },
+          },
+          {
+            $project: {
+              appId: 1,
+              status: 1,
+              storeId: 1,
+            },
+          },
+        ], as: 'stores',
+      },
+    } );
+    findQuery.push( { $unwind: { path: '$stores', preserveNullAndEmptyArrays: true } } );
+    findQuery.push( {
+      $project: {
+        _id: 0,
+        store_id: 1,
+        storeName: 1,
+        appId: '$stores.appId',
+      },
+    } );
+
+    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: { ['store_id']: -1 } } );
+    }
+
+    let getstoreData = await processedchecklistService.aggregate( findQuery );
+    result.storeData = getstoreData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'storeDropdown' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+export async function checklistbasedStoreDropdown( req, res ) {
+  try {
+    let findQuery = [];
+    let findAndQuery = [];
+    let fromDate = new Date( req.body.fromDate );
+    let toDate = new Date( req.body.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+    findAndQuery.push(
+        { client_id: req.body.clientId },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+    console.log( findAndQuery );
+    findQuery.push( { $match: { $and: findAndQuery } } );
+    let getTotalCount = await processedchecklistService.aggregate( findQuery );
+    console.log( '----->', getTotalCount );
+    res.sendSuccess( getTotalCount );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'checklistbasedStoreDropdown' } );
+    return res.sendError( { error: error }, 500 );
+  }
+}
+export const userDropdown = 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 },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    findQuery.push( {
+      $project: {
+        userEmail: 1,
+        userName: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$userEmail',
+        userName: { $last: '$userName' },
+        userNameChar: { $last: { $substr: [ '$userName', 0, 2 ] } },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        _id: 0,
+        userEmail: '$_id',
+        userName: 1,
+        userNameChar: 1,
+      },
+    } );
+    findQuery.push( {
+      $lookup: {
+        from: 'users',
+        let: { userEmail: '$userEmail' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: [ '$email', '$$userEmail' ] },
+                ],
+              },
+            },
+          },
+          {
+            $project: {
+              email: 1,
+              userName: 1,
+              role: 1,
+            },
+          },
+        ], as: 'users',
+      },
+    } );
+    findQuery.push( { $unwind: { path: '$users', preserveNullAndEmptyArrays: true } } );
+    findQuery.push( {
+      $project: {
+        _id: 0,
+        userEmail: 1,
+        userName: 1,
+        userNameChar: 1,
+        role: '$users.role',
+      },
+    } );
+    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: { ['userName']: -1 } } );
+    }
+    let getuserData = await processedchecklistService.aggregate( findQuery );
+    result.userData = getuserData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'userDropdown' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const checklistInfo = 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 },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+        { checkListType: { $eq: 'custom' } },
+    );
+
+    if ( requestData.checklistStatus && requestData.checklistStatus != 'All' ) {
+      findAndQuery.push( { checklistStatus: requestData.checklistStatus } );
+    }
+
+    if ( requestData.groupByType == 'Checklist' ) {
+      findAndQuery.push( { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.groupByValue ) } );
+    }
+
+    if ( requestData.groupByType == 'User' ) {
+      findAndQuery.push( { userEmail: requestData.groupByValue } );
+    }
+
+    if ( requestData.groupByType == 'Store' ) {
+      findAndQuery.push( { store_id: requestData.groupByValue } );
+    }
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    if ( requestData.searchValue && requestData.searchValue != '' ) {
+      if ( requestData.groupByType == 'Checklist' ) {
+        // findQuery.push( { $match: { $or: [ { storeName: { $regex: requestData.searchValue, $options: 'i' } } ] } } );
+        let storeList = requestData.searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
+        let query;
+        if ( storeList.length > 1 ) {
+          findQuery.push( { $addFields: { store: { $toLower: '$storeName' } } } );
+          query = { store: { $in: storeList } };
+        } else {
+          query = { storeName: { $regex: requestData.searchValue.trim(), $options: 'i' } };
+        }
+        findQuery.push( { $match: { $or: [ query ] } } );
+      } else {
+        // findQuery.push( { $match: { $or: [ { checkListName: { $regex: requestData.searchValue, $options: 'i' } } ] } } );
+        let checkListSearch = requestData.searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
+        let query;
+        if ( checkListSearch.length > 1 ) {
+          findQuery.push( { $addFields: { cheklistlowercase: { $toLower: '$checkListName' } } } );
+          query = { cheklistlowercase: { $in: checkListSearch } };
+        } else {
+          query = { checkListName: { $regex: requestData.searchValue.trim(), $options: 'i' } };
+        }
+        findQuery.push( { $match: { $or: [ query ] } } );
+      }
+    }
+
+    findQuery.push( {
+      $project: {
+        checkListName: 1,
+        createdByName: 1,
+        userName: 1,
+        userEmail: 1,
+        checklistStatus: 1,
+        submitTime_string: 1,
+        storeName: 1,
+        checkListType: 1,
+        scheduleRepeatedType: 1,
+        timeFlag: 1,
+        questionFlag: 1,
+        date_iso: 1,
+        store_id: 1,
+        timeFlag: 1,
+        date_string: 1,
+        sourceCheckList_id: 1,
+        reinitiateStatus: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        checkListName: 1,
+        checkListChar: { $substr: [ '$checkListName', 0, 2 ] },
+        createdByName: 1,
+        userName: 1,
+        userEmail: 1,
+        checklistStatus: {
+          $cond: {
+            if: { $eq: [ '$checklistStatus', 'submit' ] },
+            then: 'Submitted',
+            else: {
+              $cond: {
+                if: { $eq: [ '$checklistStatus', 'open' ] },
+                then: 'Open',
+                else: 'In Progress',
+              },
+            },
+          },
+        },
+        // submitTime_string: 1,
+        submitTime_string: {
+          $cond: {
+            if: { $eq: [ '$checklistStatus', 'submit' ] },
+            then: '$submitTime_string',
+            else: '',
+          },
+        },
+        storeName: 1,
+        checkListType: 1,
+        scheduleRepeatedType: 1,
+        flaggedChecklist: { $add: [ '$timeFlag', '$questionFlag' ] },
+        timeFlag: 1,
+        questionFlag: 1,
+        date_iso: 1,
+        store_id: 1,
+        timeFlag: 1,
+        date_string: 1,
+        checklistDate: '$date_string',
+        sourceCheckList_id: 1,
+        reinitiateStatus: 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: { ['date_iso']: -1 } } );
+    }
+
+    let limit = parseInt( requestData?.limit ) || 10;
+    let skip = limit * ( requestData?.offset ) || 0;
+    findQuery.push( { $skip: skip }, { $limit: limit } );
+    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
+
+    result.totalCount = getTotalCount.length;
+    for ( let i = 0; i < getChecklistPerformanceData.length; i++ ) {
+      getChecklistPerformanceData[i].date_string = dayjs( getChecklistPerformanceData[i].date_string ).format( 'DD MMM YYYY' );
+    }
+    result.checklistInfo = getChecklistPerformanceData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'checklistInfo' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const infoCardsOld = 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 activeUnique = 0;
+    let notSubmittedInstances = {
+      'count': '',
+      'open': '',
+      'inprogress': '',
+    };
+    let totalInstances = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let completedInstances = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let flags = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let completionScore = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let complianceRate = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let result = {};
+
+    let findQuery = [];
+    let findUniqueQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+
+    if ( requestData.groupByType == 'checklist' ) {
+      findAndQuery.push( { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.groupByValue ) } );
+    }
+
+    if ( requestData.groupByType == 'user' ) {
+      findAndQuery.push( { userEmail: requestData.groupByValue } );
+    }
+
+    if ( requestData.groupByType == 'store' ) {
+      findAndQuery.push( { store_id: requestData.groupByValue } );
+    }
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListId: 1,
+        checklistStatus: 1,
+        timeFlag: 1,
+        questionFlag: 1,
+        mobileDetectionFlag: 1,
+        storeOpenCloseFlag: 1,
+        uniformDetectionFlag: 1,
+        markasread: 1,
+        checkListType: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '',
+        totalChecklist: { $sum: 1 },
+        notSubmittedChecklist: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $ne: [ '$checklistStatus', 'submit' ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+        openChecklist: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $eq: [ '$checklistStatus', 'open' ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+        inprogressChecklist: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $eq: [ '$checklistStatus', 'inprogress' ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+        submittedChecklist: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $eq: [ '$checklistStatus', 'submit' ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+        flaggedChecklist: {
+          $sum: {
+            $cond: [ {
+              $or: [
+                { $gt: [ '$timeFlag', 0 ] },
+                { $gt: [ '$mobileDetectionFlag', 0 ] },
+                { $gt: [ '$storeOpenCloseFlag', 0 ] },
+                { $gt: [ '$uniformDetectionFlag', 0 ] },
+              ],
+            }, 1, 0 ],
+          },
+        },
+      },
+    } );
+    let getOverallChecklistData = await processedchecklistService.aggregate( findQuery );
+
+    findUniqueQuery.push( { $match: { $and: findAndQuery } } );
+    findUniqueQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+      },
+    } );
+    findUniqueQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+      },
+    } );
+    findUniqueQuery.push( {
+      $count: 'totalUniqueChecklist',
+    } );
+    let getUniqueChecklistData = await processedchecklistService.aggregate( findUniqueQuery );
+    if ( !getUniqueChecklistData.length && !getOverallChecklistData.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( getUniqueChecklistData.length && getUniqueChecklistData.length>0 ) {
+      if ( getUniqueChecklistData[0].totalUniqueChecklist ) {
+        activeUnique = getUniqueChecklistData[0]?.totalUniqueChecklist;
+      }
+    }
+
+    if ( getOverallChecklistData.length && getOverallChecklistData.length>0 ) {
+      if ( getOverallChecklistData[0].totalChecklist ) {
+        totalInstances.count = getOverallChecklistData[0]?.totalChecklist;
+      }
+      if ( getOverallChecklistData[0].notSubmittedChecklist ) {
+        notSubmittedInstances.count = getOverallChecklistData[0]?.notSubmittedChecklist;
+      }
+      if ( getOverallChecklistData[0].openChecklist ) {
+        notSubmittedInstances.open = getOverallChecklistData[0]?.openChecklist;
+      }
+      if ( getOverallChecklistData[0].inprogressChecklist ) {
+        notSubmittedInstances.inprogress = getOverallChecklistData[0]?.inprogressChecklist;
+      }
+      if ( getOverallChecklistData[0].submittedChecklist ) {
+        completedInstances.count = getOverallChecklistData[0]?.submittedChecklist;
+      }
+      if ( getOverallChecklistData[0].flaggedChecklist ) {
+        flags.count = getOverallChecklistData[0]?.flaggedChecklist;
+      }
+    }
+    result.infoCards = {
+      'activeUnique': activeUnique,
+      'totalInstances': totalInstances,
+      'notSubmittedInstances': notSubmittedInstances,
+      'completedInstances': completedInstances,
+      'flags': flags,
+      'completionScore': completionScore,
+      'complianceRate': complianceRate,
+    };
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'infoCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const monthlyGraph = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await monthlyChartData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'checklistPerformance' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const monthlyGraphOLD = 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 },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+
+    if ( requestData.groupByType == 'checklist' ) {
+      findAndQuery.push( { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.groupByValue ) } );
+    }
+
+    if ( requestData.groupByType == 'user' ) {
+      findAndQuery.push( { userEmail: requestData.groupByValue } );
+    }
+
+    if ( requestData.groupByType == 'store' ) {
+      findAndQuery.push( { store_id: requestData.groupByValue } );
+    }
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListId: 1,
+        checkListName: 1,
+        storeCount: 1,
+        createdBy: 1,
+        createdByName: 1,
+        checklistStatus: 1,
+        timeFlag: 1,
+        questionFlag: 1,
+        mobileDetectionFlag: 1,
+        storeOpenCloseFlag: 1,
+        uniformDetectionFlag: 1,
+        checkListType: 1,
+        scheduleRepeatedType: 1,
+        date_string: 1,
+        date_iso: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$date_string',
+        date_iso: { $last: '$date_iso' },
+        storeCount: { $max: '$storeCount' },
+        submittedChecklist: {
+          $sum: {
+            $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ],
+          },
+        },
+        flaggedChecklist: {
+          $sum: {
+            $cond: [ {
+              $or: [
+                { $gt: [ '$timeFlag', 0 ] },
+                { $gt: [ '$questionFlag', 0 ] },
+                { $gt: [ '$mobileDetectionFlag', 0 ] },
+                { $gt: [ '$storeOpenCloseFlag', 0 ] },
+                { $gt: [ '$uniformDetectionFlag', 0 ] },
+              ],
+            }, 1, 0 ],
+          },
+        },
+        checkListType: { $last: '$checkListType' },
+      },
+    } );
+
+    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: { ['date_iso']: 1 } } );
+    }
+    let getmonthlyData = await processedchecklistService.aggregate( findQuery );
+
+    result.monthlyData = getmonthlyData;
+    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 );
+  }
+};
+
+export const flagDetectionCards = 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(
+        { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.sourceCheckList_id ) },
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    if ( requestData.checklistType == 'storeopenandclose' ) {
+      findQuery.push( {
+        $project: {
+          store_id: 1,
+          storeName: 1,
+          sourceCheckList_id: 1,
+          mobileDetectionFlag: 1,
+          storeOpenCloseFlag: 1,
+          uniformDetectionFlag: 1,
+        },
+      } );
+
+      findQuery.push( {
+        $group: {
+          _id: '$store_id',
+          storeName: { $last: '$storeName' },
+          mobileDetectionFlag: { $sum: '$mobileDetectionFlag' },
+          storeOpenCloseFlag: { $sum: '$storeOpenCloseFlag' },
+          uniformDetectionFlag: { $sum: '$uniformDetectionFlag' },
+        },
+      } );
+
+      findQuery.push( {
+        $project: {
+          _id: 1,
+          storeName: 1,
+          detectionFlag: { $sum: [ '$mobileDetectionFlag', '$storeOpenCloseFlag', '$uniformDetectionFlag' ] },
+        },
+      } );
+
+      findQuery.push( {
+        $group: {
+          _id: '',
+          storeCount: { $sum: 1 },
+          detectionSum: { $sum: '$detectionFlag' },
+        },
+      } );
+
+      let getTotalCount = await processedchecklistService.aggregate( findQuery );
+      if ( !getTotalCount.length ) {
+        return res.sendError( { error: 'No Data Found' }, 204 );
+      }
+      result.cards = {};
+      result.cards.totalAssignedStores = {
+        'count': getTotalCount[0]?.storeCount || 0,
+        'comparisonData': '',
+        'ComparisonFlag': '',
+      };
+
+      result.cards.lateOpenStores = {
+        'count': 0,
+        'comparisonData': '',
+        'ComparisonFlag': '',
+      };
+
+      result.cards.earlyClosedStores = {
+        'count': 0,
+        'comparisonData': '',
+        'ComparisonFlag': '',
+      };
+
+      result.cards.Compliance = {
+        'count': '',
+        'comparisonData': '',
+        'ComparisonFlag': '',
+      };
+    } else if ( requestData.checklistType == 'uniformdetection' || requestData.checklistType == 'mobileusagedetection' || requestData.checklistType == 'custom' ) {
+      findQuery.push( {
+        $project: {
+          store_id: 1,
+          storeName: 1,
+          sourceCheckList_id: 1,
+          mobileDetectionFlag: 1,
+          storeOpenCloseFlag: 1,
+          uniformDetectionFlag: 1,
+        },
+      } );
+
+      findQuery.push( {
+        $group: {
+          _id: '$store_id',
+          storeName: { $last: '$storeName' },
+          mobileDetectionFlag: { $sum: '$mobileDetectionFlag' },
+          storeOpenCloseFlag: { $sum: '$storeOpenCloseFlag' },
+          uniformDetectionFlag: { $sum: '$uniformDetectionFlag' },
+        },
+      } );
+
+      findQuery.push( {
+        $project: {
+          _id: 1,
+          storeName: 1,
+          detectionFlag: { $sum: [ '$mobileDetectionFlag', '$storeOpenCloseFlag', '$uniformDetectionFlag' ] },
+        },
+      } );
+
+      findQuery.push( {
+        $group: {
+          _id: '',
+          storeCount: { $sum: 1 },
+          detectionSum: { $sum: '$detectionFlag' },
+        },
+      } );
+
+      let getTotalCount = await processedchecklistService.aggregate( findQuery );
+      if ( !getTotalCount.length ) {
+        return res.sendError( { error: 'No Data Found' }, 204 );
+      }
+      result.cards = {};
+      result.cards.totalAssignedStores = {
+        'count': getTotalCount[0]?.storeCount || 0,
+        'comparisonData': '',
+        'ComparisonFlag': '',
+      };
+
+      result.cards.flagIncidents = {
+        'count': getTotalCount[0]?.detectionSum || 0,
+        'comparisonData': '',
+        'ComparisonFlag': '',
+      };
+
+      result.cards.Compliance = {
+        'count': '',
+        'comparisonData': '',
+        'ComparisonFlag': '',
+      };
+    }
+
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'flagDetectionTables' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const flagDetectionTables = 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(
+        { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.sourceCheckList_id ) },
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+        { checklistStatus: { $eq: 'submit' } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    if ( requestData.searchValue && requestData.searchValue != '' ) {
+      findQuery.push( { $match: { $or: [ { storeName: { $regex: requestData.searchValue, $options: 'i' } } ] } } );
+    }
+
+    if ( requestData.checklistType == 'storeopenandclose' ) {
+      // console.log( 'check1' );
+      findQuery.push( {
+        $project: {
+          checkListName: 1,
+          createdByName: 1,
+          userName: 1,
+          userEmail: 1,
+          checklistStatus: 1,
+          submitTime_string: 1,
+          date_string: 1,
+          storeName: 1,
+          checkListType: 1,
+          scheduleRepeatedType: 1,
+          detectionFlag: { $sum: [ '$mobileDetectionFlag', '$storeOpenCloseFlag', '$uniformDetectionFlag' ] },
+          date_iso: 1,
+          store_id: 1,
+          openTime: '09:05 AM',
+          lateOpenFlag: '1',
+          CloseTime: '10:00 PM',
+          closeTimeFlag: '0',
+        },
+      } );
+    } else if ( requestData.checklistType == 'uniformdetection' || requestData.checklistType == 'mobileusagedetection' || requestData.checklistType == 'custom' ) {
+      // console.log( 'check2' );
+      findQuery.push( {
+        $project: {
+          checkListName: 1,
+          createdByName: 1,
+          userName: 1,
+          userEmail: 1,
+          checklistStatus: 1,
+          submitTime_string: 1,
+          date_string: 1,
+          storeName: 1,
+          checkListType: 1,
+          scheduleRepeatedType: 1,
+          detectionFlag: { $sum: [ '$mobileDetectionFlag', '$storeOpenCloseFlag', '$uniformDetectionFlag' ] },
+          date_iso: 1,
+          store_id: 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: { ['detectionFlag']: -1 } } );
+    }
+
+    let limit = parseInt( requestData?.limit ) || 10;
+    let skip = limit * ( requestData?.offset ) || 0;
+    findQuery.push( { $skip: skip }, { $limit: limit } );
+    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
+
+    result.totalCount = getTotalCount.length;
+    result.checklistInfo = getChecklistPerformanceData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'flagDetectionTables' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const overallCards = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await overallCardsData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'overallCards' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const overallComparisonCards = 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: 'overallComparisonCards' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+async function overallCardsData( checklistType ) {
+  try {
+    let resData = {};
+    let activeUnique = 50;
+    let notSubmittedInstances = {
+      'count': 300,
+      'open': 100,
+      'inprogress': 200,
+    };
+    let totalInstances = {
+      'count': 500,
+    };
+    let completedInstances = {
+      'count': 200,
+    };
+    let flags = {
+      'count': 50,
+    };
+    let completionScore = {
+      'count': 49,
+    };
+    let complianceRate = {
+      'count': 66,
+    };
+
+    resData.overallCards = {
+      'activeUnique': activeUnique,
+      'totalInstances': totalInstances,
+      'notSubmittedInstances': notSubmittedInstances,
+      'completedInstances': completedInstances,
+      'flags': flags,
+      'completionScore': completionScore,
+      'complianceRate': complianceRate,
+    };
+
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+async function checklistComparisonData( checklistType ) {
+  try {
+    let resData = {};
+    let flags = {
+      'comparisonData': 40,
+      'ComparisonFlag': true,
+    };
+    let completionScore = {
+      'comparisonData': 20,
+      'ComparisonFlag': false,
+    };
+    let complianceRate = {
+      'comparisonData': 60,
+      'ComparisonFlag': true,
+    };
+
+    resData.overallComparisonCards = {
+      'flags': flags,
+      'completionScore': completionScore,
+      'complianceRate': complianceRate,
+    };
+
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+export const infoCards = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await infoCardsData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'infoCards' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const infoComparisonCards = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await infoCardsComparisonData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'infoComparisonCards' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+async function infoCardsData( checklistType ) {
+  try {
+    let resData = {};
+    let activeUnique = 800;
+    let notSubmittedInstances = {
+      'count': 500,
+      'open': 300,
+      'inprogress': 200,
+    };
+    let totalInstances = {
+      'count': 300,
+    };
+    let completedInstances = {
+      'count': 70,
+    };
+    let flags = {
+      'count': 60,
+    };
+    let completionScore = {
+      'count': 10,
+    };
+    let complianceRate = {
+      'count': 4,
+    };
+
+    resData.overallCards = {
+      'activeUnique': activeUnique,
+      'totalInstances': totalInstances,
+      'notSubmittedInstances': notSubmittedInstances,
+      'completedInstances': completedInstances,
+      'flags': flags,
+      'completionScore': completionScore,
+      'complianceRate': complianceRate,
+    };
+
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+async function infoCardsComparisonData( checklistType ) {
+  try {
+    let resData = {};
+    let totalInstances = {
+      'comparisonData': 30,
+      'ComparisonFlag': false,
+    };
+    let completedInstances = {
+      'comparisonData': 50,
+      'ComparisonFlag': true,
+    };
+    let flags = {
+      'comparisonData': 40,
+      'ComparisonFlag': true,
+    };
+    let completionScore = {
+      'comparisonData': 20,
+      'ComparisonFlag': false,
+    };
+    let complianceRate = {
+      'comparisonData': 60,
+      'ComparisonFlag': true,
+    };
+
+    resData.overallComparisonCards = {
+      'totalInstances': totalInstances,
+      'completedInstances': completedInstances,
+      'flags': flags,
+      'completionScore': completionScore,
+      'complianceRate': complianceRate,
+    };
+
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+async function monthlyChartData( checklistType ) {
+  try {
+    let resData = {};
+    resData.totalCount = 300;
+    resData.monthlyChartData = {};
+    resData.monthlyChartData = [
+      { 'date': 1, 'colorClass': 'primary900' },
+      { 'date': 3, 'colorClass': 'blue33B5FF' },
+      { 'date': 6, 'colorClass': 'redF04438' },
+      { 'date': 7, 'colorClass': 'lightBlue6BCAFF' },
+      { 'date': 8, 'colorClass': 'blue33B5FF' },
+      { 'date': 9, 'colorClass': 'primary900' },
+      { 'date': 12, 'colorClass': 'primary900' },
+      { 'date': 14, 'colorClass': 'orangeF79009' },
+      { 'date': 15, 'colorClass': 'blue33B5FF' },
+      { 'date': 18, 'colorClass': 'redF04438' },
+    ];
+
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+export const overallCardsV1 = 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 activeUnique = 0;
+    let notSubmittedInstances = {
+      'count': 0,
+      'open': 0,
+      'inprogress': 0,
+    };
+    let totalInstances = {
+      'count': 0,
+    };
+    let completedInstances = {
+      'count': 0,
+    };
+    let flags = {
+      'count': 0,
+    };
+    let completionScore = {
+      'count': 0,
+    };
+    let complianceRate = {
+      'count': 0,
+    };
+    let result = {};
+
+    let findQuery = [];
+    let findUniqueQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { checkListType: { $eq: 'custom' } },
+        { date_iso: { $gte: fromDate, $lte: toDate } },
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+    findQuery.push( {
+      $group: {
+        _id: '$checklistStatus',
+        count: { $sum: 1 },
+        totalQuestionCount: { $sum: '$questionCount' },
+        totalQuestionFlagCount: { $sum: '$questionFlag' },
+        totalTimeFlag: { $sum: '$timeFlag' },
+      },
+    } );
+    findQuery.push( {
+      $group: {
+        _id: null,
+        totalChecklist: { $sum: '$count' },
+        statusCounts: {
+          $push: { k: '$_id', v: '$count' },
+        },
+        submiitedQuestionCount: {
+          $push: { k: '$_id', v: '$totalQuestionCount' },
+        },
+        flaggedQuestionCount: {
+          $push: { k: '$_id', v: '$totalQuestionFlagCount' },
+        },
+        questionCountSum: { $sum: '$totalQuestionCount' },
+        questionFlagCountSum: { $sum: '$totalQuestionFlagCount' },
+        timeFlagSum: { $sum: '$totalTimeFlag' },
+      },
+    } );
+    findQuery.push( {
+      $addFields: {
+        statusCounts: { $arrayToObject: '$statusCounts' },
+        submittedChecklistQuestionCount: { $arrayToObject: '$submiitedQuestionCount' },
+        submittedChecklistFlagQuestionCount: { $arrayToObject: '$flaggedQuestionCount' },
+      },
+    } );
+    findQuery.push( {
+      $project: {
+        totalChecklist: 1,
+        questionCountSum: 1,
+        questionFlagCountSum: 1,
+        timeFlagSum: 1,
+        statusCounts: 1,
+        submittedChecklistQuestionCount: 1,
+        submittedChecklistFlagQuestionCount: 1,
+      },
+    } );
+    findQuery.push( {
+      $project: {
+        totalChecklist: 1,
+        notSubmittedChecklist: { $add: [ { $ifNull: [ '$statusCounts.open', 0 ] }, { $ifNull: [ '$statusCounts.inprogress', 0 ] } ] },
+        openChecklist: { $ifNull: [ '$statusCounts.open', 0 ] },
+        inprogressChecklist: { $ifNull: [ '$statusCounts.inprogress', 0 ] },
+        submittedChecklist: { $ifNull: [ '$statusCounts.submit', 0 ] },
+        flaggedChecklist: { $add: [ { $ifNull: [ '$timeFlagSum', 0 ] }, { $ifNull: [ '$questionFlagCountSum', 0 ] } ] },
+        completionScore: { $round: [ { $multiply: [ { $divide: [ { $ifNull: [ '$statusCounts.submit', 0 ] }, { $ifNull: [ '$totalChecklist', 0 ] } ] }, 100 ] }, 0 ] },
+        // completionScore: { $multiply: [ { $divide: [ '$statusCounts.submit', '$totalChecklist' ] }, 100 ] },
+        questionFlagCount: { $ifNull: [ '$questionFlagCountSum', 0 ] },
+        questionCount: { $ifNull: [ '$questionCountSum', 0 ] },
+        correctAnswers: { $subtract: [ { $ifNull: [ '$submittedChecklistQuestionCount.submit', 0 ] }, { $ifNull: [ '$submittedChecklistFlagQuestionCount.submit', 0 ] } ] },
+      },
+    } );
+    findQuery.push( {
+      $project: {
+        totalChecklist: 1,
+        notSubmittedChecklist: 1,
+        openChecklist: 1,
+        inprogressChecklist: 1,
+        submittedChecklist: 1,
+        flaggedChecklist: 1,
+        completionScore: 1,
+        questionFlagCount: 1,
+        questionCount: 1,
+        questionCompletionScore: {
+          $cond: {
+            if: { $eq: [ '$questionCount', 0 ] },
+            then: 0,
+            else: {
+              $round: [ { $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ] }, 0 ],
+              // $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ],
+            },
+          },
+        },
+      },
+    } );
+    console.log( 'overallCardsV1 Query Hit 1=>' );
+    findUniqueQuery.push( { $match: { $and: findAndQuery } } );
+    findUniqueQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+      },
+    } );
+    findUniqueQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+      },
+    } );
+    findUniqueQuery.push( {
+      $count: 'totalUniqueChecklist',
+    } );
+
+    const [ getOverallChecklistData, getUniqueChecklistData ] = await Promise.all( [
+      processedchecklistService.aggregate( findQuery ),
+      processedchecklistService.aggregate( findUniqueQuery ),
+    ] );
+
+
+    if ( getUniqueChecklistData.length && getUniqueChecklistData.length>0 ) {
+      if ( getUniqueChecklistData[0].totalUniqueChecklist ) {
+        activeUnique = getUniqueChecklistData[0]?.totalUniqueChecklist || 0;
+      }
+    }
+
+    if ( getOverallChecklistData.length && getOverallChecklistData.length>0 ) {
+      if ( getOverallChecklistData[0].totalChecklist ) {
+        totalInstances.count = getOverallChecklistData[0]?.totalChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].notSubmittedChecklist ) {
+        notSubmittedInstances.count = getOverallChecklistData[0]?.notSubmittedChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].openChecklist ) {
+        notSubmittedInstances.open = getOverallChecklistData[0]?.openChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].inprogressChecklist ) {
+        notSubmittedInstances.inprogress = getOverallChecklistData[0]?.inprogressChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].submittedChecklist ) {
+        completedInstances.count = getOverallChecklistData[0]?.submittedChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].flaggedChecklist ) {
+        flags.count = getOverallChecklistData[0]?.flaggedChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].completionScore ) {
+        completionScore.count = Math.round( getOverallChecklistData[0]?.completionScore ) || 0; // .toFixed( 2 )
+      }
+      if ( getOverallChecklistData[0].questionCompletionScore ) {
+        complianceRate.count = Math.round( getOverallChecklistData[0]?.questionCompletionScore ) || 0; // .toFixed( 2 )
+      }
+    }
+    result.overallCards = {
+      'activeUnique': activeUnique,
+      'totalInstances': totalInstances,
+      'notSubmittedInstances': notSubmittedInstances,
+      'completedInstances': completedInstances,
+      'flags': flags,
+      'completionScore': completionScore,
+      'complianceRate': complianceRate,
+    };
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'overallCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const overallComparisonCardsV1 = 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 rangeOneFromDate = new Date( requestData.toDate );
+    // rangeOneFromDate.setDate( rangeOneFromDate.getDate() - 6 );
+    // let rangeOneToDate = new Date( requestData.toDate );
+    // rangeOneToDate = new Date( rangeOneToDate.getTime() - userTimezoneOffset );
+    // rangeOneToDate.setUTCHours( 23, 59, 59, 59 );
+    // let rangeTwoToDate = new Date( requestData.toDate );
+    // rangeTwoToDate.setDate( rangeTwoToDate.getDate() - 7 );
+    // let rangeTwoFromDate = new Date( rangeTwoToDate );
+    // rangeTwoFromDate.setDate( rangeTwoFromDate.getDate() - 6 );
+    // rangeTwoToDate = new Date( rangeTwoToDate.getTime() - userTimezoneOffset );
+    // rangeTwoToDate.setUTCHours( 23, 59, 59, 59 );
+
+    console.log( 'rangeOneFromDate =>', rangeOneFromDate );
+    console.log( 'rangeOneToDate =>', rangeOneToDate );
+    console.log( 'rangeTwoFromDate =>', rangeTwoFromDate );
+    console.log( 'rangeTwoToDate =>', rangeTwoToDate );
+
+    let flags = {
+      'comparisonData': 0,
+      'ComparisonFlag': 0,
+    };
+    let completionScore = {
+      'comparisonData': 0,
+      'ComparisonFlag': 0,
+    };
+    let complianceRate = {
+      'comparisonData': 0,
+      'ComparisonFlag': 0,
+    };
+
+    let overallComparisonCards = {
+      'flags': flags,
+      'completionScore': completionScore,
+      'complianceRate': complianceRate,
+    };
+
+    let rangeOneFindQuery = [];
+    let rangeOneFindAndQuery = [];
+    rangeOneFindAndQuery.push(
+        { checkListType: { $eq: 'custom' } },
+        { date_iso: { $gte: rangeOneFromDate, $lte: rangeOneToDate } },
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+    );
+
+    rangeOneFindQuery.push( { $match: { $and: rangeOneFindAndQuery } } );
+
+    let queryFormat = [
+      {
+        $group: {
+          _id: '$checklistStatus',
+          count: { $sum: 1 },
+          totalQuestionCount: { $sum: '$questionCount' },
+          totalQuestionFlagCount: { $sum: '$questionFlag' },
+          totalTimeFlag: { $sum: '$timeFlag' },
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          totalChecklist: { $sum: '$count' },
+          statusCounts: {
+            $push: { k: '$_id', v: '$count' },
+          },
+          submiitedQuestionCount: {
+            $push: { k: '$_id', v: '$totalQuestionCount' },
+          },
+          flaggedQuestionCount: {
+            $push: { k: '$_id', v: '$totalQuestionFlagCount' },
+          },
+          questionCountSum: { $sum: '$totalQuestionCount' },
+          questionFlagCountSum: { $sum: '$totalQuestionFlagCount' },
+          timeFlagSum: { $sum: '$totalTimeFlag' },
+        },
+      },
+      {
+        $addFields: {
+          statusCounts: { $arrayToObject: '$statusCounts' },
+          submittedChecklistQuestionCount: { $arrayToObject: '$submiitedQuestionCount' },
+          submittedChecklistFlagQuestionCount: { $arrayToObject: '$flaggedQuestionCount' },
+        },
+      },
+      {
+        $project: {
+          totalChecklist: 1,
+          questionCountSum: 1,
+          questionFlagCountSum: 1,
+          timeFlagSum: 1,
+          statusCounts: 1,
+          submittedChecklistQuestionCount: 1,
+          submittedChecklistFlagQuestionCount: 1,
+        },
+      },
+      {
+        $project: {
+          totalChecklist: 1,
+          notSubmittedChecklist: { $add: [ { $ifNull: [ '$statusCounts.open', 0 ] }, { $ifNull: [ '$statusCounts.inprogress', 0 ] } ] },
+          openChecklist: { $ifNull: [ '$statusCounts.open', 0 ] },
+          inprogressChecklist: { $ifNull: [ '$statusCounts.inprogress', 0 ] },
+          submittedChecklist: { $ifNull: [ '$statusCounts.submit', 0 ] },
+          flaggedChecklist: { $add: [ { $ifNull: [ '$timeFlagSum', 0 ] }, { $ifNull: [ '$questionFlagCountSum', 0 ] } ] },
+          completionScore: { $round: [ { $multiply: [ { $divide: [ { $ifNull: [ '$statusCounts.submit', 0 ] }, { $ifNull: [ '$totalChecklist', 0 ] } ] }, 100 ] }, 0 ] },
+          // completionScore: { $multiply: [ { $divide: [ '$statusCounts.submit', '$totalChecklist' ] }, 100 ] },
+          questionFlagCount: { $ifNull: [ '$questionFlagCountSum', 0 ] },
+          questionCount: { $ifNull: [ '$questionCountSum', 0 ] },
+          correctAnswers: { $subtract: [ { $ifNull: [ '$submittedChecklistQuestionCount.submit', 0 ] }, { $ifNull: [ '$submittedChecklistFlagQuestionCount.submit', 0 ] } ] },
+        },
+      },
+      {
+        $project: {
+          totalChecklist: 1,
+          notSubmittedChecklist: 1,
+          openChecklist: 1,
+          inprogressChecklist: 1,
+          submittedChecklist: 1,
+          flaggedChecklist: 1,
+          completionScore: 1,
+          questionFlagCount: 1,
+          questionCount: 1,
+          questionCompletionScore: {
+            $cond: {
+              if: { $eq: [ '$questionCount', 0 ] },
+              then: 0,
+              else: {
+                $round: [ { $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ] }, 0 ],
+                // $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ],
+              },
+            },
+          },
+        },
+      },
+    ];
+    rangeOneFindQuery.push( ...queryFormat );
+    let rangeTwoFindQuery = [];
+    let rangeTwoFindAndQuery = [];
+    rangeTwoFindAndQuery.push(
+        { checkListType: { $eq: 'custom' } },
+        { date_iso: { $gte: rangeTwoFromDate, $lte: rangeTwoToDate } },
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+    );
+
+    rangeTwoFindQuery.push( { $match: { $and: rangeTwoFindAndQuery } } );
+    rangeTwoFindQuery.push( ...queryFormat );
+    const [ rangeOneData, rangeTwoData ] = await Promise.all( [
+      processedchecklistService.aggregate( rangeOneFindQuery ),
+      processedchecklistService.aggregate( rangeTwoFindQuery ),
+    ] );
+    console.log( 'rangeTwoData =>', rangeTwoData );
+    console.log( 'rangeOneData =>', rangeOneData );
+
+
+    if ( rangeOneData.length >0 && rangeTwoData.length >0 ) {
+      overallComparisonCards.flags.comparisonData = Math.round( ( ( ( rangeOneData[0].flaggedChecklist - rangeTwoData[0].flaggedChecklist )/rangeTwoData[0].flaggedChecklist )*100 ) ); // .toFixed( 2 )
+      if ( overallComparisonCards.flags.comparisonData > 0 ) {
+        overallComparisonCards.flags.ComparisonFlag = true;
+      } else {
+        overallComparisonCards.flags.ComparisonFlag = false;
+      }
+      overallComparisonCards.completionScore.comparisonData = Math.round( ( ( ( rangeOneData[0].completionScore - rangeTwoData[0].completionScore )/rangeTwoData[0].completionScore )*100 ) ); // .toFixed( 2 )
+      if ( overallComparisonCards.completionScore.comparisonData > 0 ) {
+        overallComparisonCards.completionScore.ComparisonFlag = true;
+      } else {
+        overallComparisonCards.completionScore.ComparisonFlag = false;
+      }
+      overallComparisonCards.complianceRate.comparisonData = Math.round( ( ( ( rangeOneData[0].questionCompletionScore - rangeTwoData[0].questionCompletionScore )/rangeTwoData[0].questionCompletionScore )*100 ) ); // .toFixed( 2 )
+      if ( overallComparisonCards.complianceRate.comparisonData > 0 ) {
+        overallComparisonCards.complianceRate.ComparisonFlag = true;
+      } else {
+        overallComparisonCards.complianceRate.ComparisonFlag = false;
+      }
+
+      overallComparisonCards.flags.comparisonData = Math.abs( overallComparisonCards.flags.comparisonData );
+      overallComparisonCards.completionScore.comparisonData = Math.abs( overallComparisonCards.completionScore.comparisonData );
+      overallComparisonCards.complianceRate.comparisonData = Math.abs( overallComparisonCards.complianceRate.comparisonData );
+    }
+
+    let result = {
+      'overallComparisonCards': overallComparisonCards,
+    };
+    console.log( 'result =>', result );
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'overallCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const reportChecklistTable = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await reportChecklistData( requestData.checklistType );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'subscribedStoreList' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+async function reportChecklistData( checklistType ) {
+  try {
+    let resData = {};
+    resData.totalCount = 300;
+    resData.reportChecklistTableData = [
+      {
+        'submittedDate': '2024-10-20',
+        'checklistName': 'Field VM- Store Visit Checklist',
+        'storeName': 'LKST400',
+        'submittedBy': 'Balaji',
+        'submittedByChar': 'Ba',
+        'submittedTime': '11:02 AM, 01 Sep',
+        'flagCount': 50,
+      },
+      {
+        'submittedDate': '2024-10-19',
+        'checklistName': 'Field VM- Store Visit Checklist',
+        'storeName': 'LKST400',
+        'submittedBy': 'Balaji',
+        'submittedByChar': 'Ba',
+        'submittedTime': '11:02 AM, 01 Sep',
+        'flagCount': 50,
+      },
+      {
+        'submittedDate': '2024-10-19',
+        'checklistName': 'DC Prep Checklist',
+        'storeName': 'LKST400',
+        'submittedBy': 'Balaji',
+        'submittedByChar': 'Ba',
+        'submittedTime': '11:02 AM, 01 Sep',
+        'flagCount': 50,
+      },
+      {
+        'submittedDate': '2024-10-20',
+        'checklistName': 'DC Prep Checklist',
+        'storeName': 'LKST400',
+        'submittedBy': 'Balaji',
+        'submittedByChar': 'Ba',
+        'submittedTime': '11:02 AM, 01 Sep',
+        'flagCount': 50,
+      },
+    ];
+    return resData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'returnServerError' } );
+  }
+}
+
+export const infoCardsV1 = 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 activeUnique = 0;
+    let notSubmittedInstances = {
+      'count': 0,
+      'open': 0,
+      'inprogress': 0,
+    };
+    let totalInstances = {
+      'count': 0,
+    };
+    let completedInstances = {
+      'count': 0,
+    };
+    let flags = {
+      'count': 0,
+    };
+    let completionScore = {
+      'count': 0,
+    };
+    let complianceRate = {
+      'count': 0,
+    };
+    let result = {};
+
+    let findQuery = [];
+    let findUniqueQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+        { checkListType: { $eq: 'custom' } },
+    );
+
+    if ( requestData.groupByType == 'Checklist' ) {
+      findAndQuery.push( { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.groupByValue ) } );
+    }
+
+    if ( requestData.groupByType == 'User' ) {
+      findAndQuery.push( { userEmail: requestData.groupByValue } );
+    }
+
+    if ( requestData.groupByType == 'Store' ) {
+      findAndQuery.push( { store_id: requestData.groupByValue } );
+    }
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListId: 1,
+        checklistStatus: 1,
+        timeFlag: 1,
+        questionFlag: 1,
+        mobileDetectionFlag: 1,
+        storeOpenCloseFlag: 1,
+        uniformDetectionFlag: 1,
+        markasread: 1,
+        checkListType: 1,
+        questionCount: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: null,
+        totalChecklist: { $sum: 1 },
+        notSubmittedChecklist: {
+          $sum: { $cond: [ { $ne: [ '$checklistStatus', 'submit' ] }, 1, 0 ] },
+        },
+        openChecklist: {
+          $sum: { $cond: [ { $eq: [ '$checklistStatus', 'open' ] }, 1, 0 ] },
+        },
+        inprogressChecklist: {
+          $sum: { $cond: [ { $eq: [ '$checklistStatus', 'inprogress' ] }, 1, 0 ] },
+        },
+        submittedChecklist: {
+          $sum: { $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ] },
+        },
+        timeFlag: { $sum: '$timeFlag' },
+        questionFlagCount: { $sum: '$questionFlag' },
+        questionCount: { $sum: '$questionCount' },
+        submittedQuestionCount: {
+          $sum: {
+            $cond: [
+              { $eq: [ '$checklistStatus', 'submit' ] },
+              '$questionCount', // Sum this field if status is 'submit'
+              0, // Otherwise, add 0
+            ],
+          },
+        },
+      },
+    } );
+    findQuery.push( {
+      $project: {
+        totalChecklist: 1,
+        notSubmittedChecklist: 1,
+        openChecklist: 1,
+        inprogressChecklist: 1,
+        submittedChecklist: 1,
+        questionFlagCount: 1,
+        questionCount: 1,
+        timeFlag: 1,
+        submittedQuestionCount: 1,
+        flaggedChecklist: { $add: [ { $ifNull: [ '$timeFlag', 0 ] }, { $ifNull: [ '$questionFlagCount', 0 ] } ] },
+        completionScore: { $round: [ { $multiply: [ { $divide: [ { $ifNull: [ '$submittedChecklist', 0 ] }, { $ifNull: [ '$totalChecklist', 0 ] } ] }, 100 ] }, 0 ] },
+        // completionScore: { $multiply: [ { $divide: [ '$submittedChecklist', '$totalChecklist' ] }, 100 ] },
+        correctAnswers: { $subtract: [ { $ifNull: [ '$submittedQuestionCount', 0 ] }, { $ifNull: [ '$questionFlagCount', 0 ] } ] },
+      },
+    } );
+    findQuery.push( {
+      $project: {
+        totalChecklist: 1,
+        notSubmittedChecklist: 1,
+        openChecklist: 1,
+        inprogressChecklist: 1,
+        submittedChecklist: 1,
+        flaggedChecklist: 1,
+        completionScore: 1,
+        questionFlagCount: 1,
+        questionCount: 1,
+        timeFlag: 1,
+        correctAnswers: 1,
+        submittedQuestionCount: 1,
+        questionCompletionScore: {
+          $cond: {
+            if: { $eq: [ '$questionCount', 0 ] },
+            then: 0,
+            else: {
+              $round: [ { $multiply: [ { $divide: [ { $ifNull: [ '$correctAnswers', 0 ] }, { $ifNull: [ '$questionCount', 0 ] } ] }, 100 ] }, 0 ],
+              // $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ],
+            },
+          },
+        },
+      },
+    } );
+    let getOverallChecklistData = await processedchecklistService.aggregate( findQuery );
+    console.log( 'infoCardsV1 =>', getOverallChecklistData );
+    if ( !getOverallChecklistData.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    findUniqueQuery.push( { $match: { $and: findAndQuery } } );
+    findUniqueQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+      },
+    } );
+    findUniqueQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+      },
+    } );
+    findUniqueQuery.push( {
+      $count: 'totalUniqueChecklist',
+    } );
+    let getUniqueChecklistData = await processedchecklistService.aggregate( findUniqueQuery );
+    if ( !getUniqueChecklistData.length && !getOverallChecklistData.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( getUniqueChecklistData.length && getUniqueChecklistData.length>0 ) {
+      if ( getUniqueChecklistData[0].totalUniqueChecklist ) {
+        activeUnique = getUniqueChecklistData[0]?.totalUniqueChecklist || 0;
+      }
+    }
+
+    if ( getOverallChecklistData.length && getOverallChecklistData.length>0 ) {
+      if ( getOverallChecklistData[0].totalChecklist ) {
+        totalInstances.count = getOverallChecklistData[0]?.totalChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].notSubmittedChecklist ) {
+        notSubmittedInstances.count = getOverallChecklistData[0]?.notSubmittedChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].openChecklist ) {
+        notSubmittedInstances.open = getOverallChecklistData[0]?.openChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].inprogressChecklist ) {
+        notSubmittedInstances.inprogress = getOverallChecklistData[0]?.inprogressChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].submittedChecklist ) {
+        completedInstances.count = getOverallChecklistData[0]?.submittedChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].flaggedChecklist ) {
+        flags.count = getOverallChecklistData[0]?.flaggedChecklist || 0;
+      }
+      if ( getOverallChecklistData[0].completionScore ) {
+        completionScore.count = Math.round( getOverallChecklistData[0]?.completionScore ) || 0; // .toFixed( 2 )
+      }
+      if ( getOverallChecklistData[0].questionCompletionScore ) {
+        complianceRate.count = Math.round( getOverallChecklistData[0]?.questionCompletionScore ) || 0; // .toFixed( 2 )
+      }
+    }
+    result.overallInfoCards = {
+      'activeUnique': activeUnique,
+      'totalInstances': totalInstances,
+      'notSubmittedInstances': notSubmittedInstances,
+      'completedInstances': completedInstances,
+      'flags': flags,
+      'completionScore': completionScore,
+      'complianceRate': complianceRate,
+    };
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'infoCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const infoComparisonCardsV1 = 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 rangeOneFromDate = new Date( requestData.toDate );
+    // rangeOneFromDate.setDate( rangeOneFromDate.getDate() - 6 );
+    // let rangeOneToDate = new Date( requestData.toDate );
+    // rangeOneToDate = new Date( rangeOneToDate.getTime() - userTimezoneOffset );
+    // rangeOneToDate.setUTCHours( 23, 59, 59, 59 );
+    // let rangeTwoToDate = new Date( requestData.toDate );
+    // rangeTwoToDate.setDate( rangeTwoToDate.getDate() - 7 );
+    // let rangeTwoFromDate = new Date( rangeTwoToDate );
+    // rangeTwoFromDate.setDate( rangeTwoFromDate.getDate() - 6 );
+    // rangeTwoToDate = new Date( rangeTwoToDate.getTime() - userTimezoneOffset );
+    // rangeTwoToDate.setUTCHours( 23, 59, 59, 59 );
+
+    console.log( 'rangeOneFromDate =>', rangeOneFromDate );
+    console.log( 'rangeOneToDate =>', rangeOneToDate );
+    console.log( 'rangeTwoFromDate =>', rangeTwoFromDate );
+    console.log( 'rangeTwoToDate =>', rangeTwoToDate );
+
+    let totalInstances = {
+      'comparisonData': 0,
+      'ComparisonFlag': 0,
+    };
+    let completedInstances = {
+      'comparisonData': 0,
+      'ComparisonFlag': 0,
+    };
+    let flags = {
+      'comparisonData': 0,
+      'ComparisonFlag': 0,
+    };
+    let completionScore = {
+      'comparisonData': 0,
+      'ComparisonFlag': 0,
+    };
+    let complianceRate = {
+      'comparisonData': 0,
+      'ComparisonFlag': 0,
+    };
+
+    let infoComparisonCards = {
+      'totalInstances': totalInstances,
+      'completedInstances': completedInstances,
+      'flags': flags,
+      'completionScore': completionScore,
+      'complianceRate': complianceRate,
+    };
+
+    let rangeOneFindQuery = [];
+    let rangeOneFindAndQuery = [];
+    rangeOneFindAndQuery.push(
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: rangeOneFromDate } },
+        { date_iso: { $lte: rangeOneToDate } },
+        { checkListType: { $eq: 'custom' } },
+    );
+
+    if ( requestData.groupByType == 'Checklist' ) {
+      rangeOneFindAndQuery.push( { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.groupByValue ) } );
+    }
+
+    if ( requestData.groupByType == 'User' ) {
+      rangeOneFindAndQuery.push( { userEmail: requestData.groupByValue } );
+    }
+
+    if ( requestData.groupByType == 'Store' ) {
+      rangeOneFindAndQuery.push( { store_id: requestData.groupByValue } );
+    }
+
+    rangeOneFindQuery.push( { $match: { $and: rangeOneFindAndQuery } } );
+
+
+    let queryFormat = [
+      {
+        $project: {
+          sourceCheckList_id: 1,
+          checkListId: 1,
+          checklistStatus: 1,
+          timeFlag: 1,
+          questionFlag: 1,
+          mobileDetectionFlag: 1,
+          storeOpenCloseFlag: 1,
+          uniformDetectionFlag: 1,
+          markasread: 1,
+          checkListType: 1,
+          questionCount: 1,
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          totalChecklist: { $sum: 1 },
+          notSubmittedChecklist: {
+            $sum: { $cond: [ { $ne: [ '$checklistStatus', 'submit' ] }, 1, 0 ] },
+          },
+          openChecklist: {
+            $sum: { $cond: [ { $eq: [ '$checklistStatus', 'open' ] }, 1, 0 ] },
+          },
+          inprogressChecklist: {
+            $sum: { $cond: [ { $eq: [ '$checklistStatus', 'inprogress' ] }, 1, 0 ] },
+          },
+          submittedChecklist: {
+            $sum: { $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ] },
+          },
+          timeFlag: { $sum: '$timeFlag' },
+          questionFlagCount: { $sum: '$questionFlag' },
+          questionCount: { $sum: '$questionCount' },
+          submittedQuestionCount: {
+            $sum: {
+              $cond: [
+                { $eq: [ '$checklistStatus', 'submit' ] },
+                '$questionCount', // Sum this field if status is 'submit'
+                0, // Otherwise, add 0
+              ],
+            },
+          },
+        },
+      },
+      {
+        $project: {
+          totalChecklist: 1,
+          notSubmittedChecklist: 1,
+          openChecklist: 1,
+          inprogressChecklist: 1,
+          submittedChecklist: 1,
+          questionFlagCount: 1,
+          questionCount: 1,
+          timeFlag: 1,
+          submittedQuestionCount: 1,
+          flaggedChecklist: { $add: [ { $ifNull: [ '$timeFlag', 0 ] }, { $ifNull: [ '$questionFlagCount', 0 ] } ] },
+          completionScore: { $round: [ { $multiply: [ { $divide: [ { $ifNull: [ '$submittedChecklist', 0 ] }, { $ifNull: [ '$totalChecklist', 0 ] } ] }, 100 ] }, 0 ] },
+          // completionScore: { $multiply: [ { $divide: [ '$submittedChecklist', '$totalChecklist' ] }, 100 ] },
+          correctAnswers: { $subtract: [ { $ifNull: [ '$submittedQuestionCount', 0 ] }, { $ifNull: [ '$questionFlagCount', 0 ] } ] },
+        },
+      },
+      {
+        $project: {
+          totalChecklist: 1,
+          notSubmittedChecklist: 1,
+          openChecklist: 1,
+          inprogressChecklist: 1,
+          submittedChecklist: 1,
+          flaggedChecklist: 1,
+          completionScore: 1,
+          questionFlagCount: 1,
+          questionCount: 1,
+          timeFlag: 1,
+          correctAnswers: 1,
+          submittedQuestionCount: 1,
+          questionCompletionScore: {
+            $cond: {
+              if: { $eq: [ '$questionCount', 0 ] },
+              then: 0,
+              else: {
+                $round: [ { $multiply: [ { $divide: [ { $ifNull: [ '$correctAnswers', 0 ] }, { $ifNull: [ '$questionCount', 0 ] } ] }, 100 ] }, 0 ],
+                // $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ],
+              },
+            },
+          },
+        },
+      },
+    ];
+    rangeOneFindQuery.push( ...queryFormat );
+    let rangeOneData = await processedchecklistService.aggregate( rangeOneFindQuery );
+    console.log( 'rangeOneData =>', rangeOneData );
+
+    let rangeTwoFindQuery = [];
+    let rangeTwoFindAndQuery = [];
+    rangeTwoFindAndQuery.push(
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: rangeTwoFromDate } },
+        { date_iso: { $lte: rangeTwoToDate } },
+        { checkListType: { $eq: 'custom' } },
+    );
+    if ( requestData.groupByType == 'Checklist' ) {
+      rangeTwoFindAndQuery.push( { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.groupByValue ) } );
+    }
+
+    if ( requestData.groupByType == 'user' ) {
+      rangeTwoFindAndQuery.push( { userEmail: requestData.groupByValue } );
+    }
+
+    if ( requestData.groupByType == 'store' ) {
+      rangeTwoFindAndQuery.push( { store_id: requestData.groupByValue } );
+    }
+
+    rangeTwoFindQuery.push( { $match: { $and: rangeTwoFindAndQuery } } );
+
+    rangeTwoFindQuery.push( ...queryFormat );
+    let rangeTwoData = await processedchecklistService.aggregate( rangeTwoFindQuery );
+    console.log( 'rangeTwoData =>', rangeTwoData );
+
+    if ( !rangeOneData.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( rangeOneData.length >0 && rangeTwoData.length >0 ) {
+      infoComparisonCards.totalInstances.comparisonData = Math.round( ( ( ( rangeOneData[0].totalChecklist - rangeTwoData[0].totalChecklist )/rangeTwoData[0].totalChecklist )*100 ) ); // .toFixed( 2 )
+      if ( infoComparisonCards.totalInstances.comparisonData > 0 ) {
+        infoComparisonCards.totalInstances.ComparisonFlag = true;
+      } else {
+        infoComparisonCards.totalInstances.ComparisonFlag = false;
+      }
+      infoComparisonCards.completedInstances.comparisonData = Math.round( ( ( ( rangeOneData[0].submittedChecklist - rangeTwoData[0].submittedChecklist )/rangeTwoData[0].submittedChecklist )*100 ) ); // .toFixed( 2 )
+      if ( infoComparisonCards.completedInstances.comparisonData > 0 ) {
+        infoComparisonCards.completedInstances.ComparisonFlag = true;
+      } else {
+        infoComparisonCards.completedInstances.ComparisonFlag = false;
+      }
+      infoComparisonCards.flags.comparisonData = Math.round( ( ( ( rangeOneData[0].flaggedChecklist - rangeTwoData[0].flaggedChecklist )/rangeTwoData[0].flaggedChecklist )*100 ) ); // .toFixed( 2 )
+      if ( infoComparisonCards.flags.comparisonData > 0 ) {
+        infoComparisonCards.flags.ComparisonFlag = true;
+      } else {
+        infoComparisonCards.flags.ComparisonFlag = false;
+      }
+      infoComparisonCards.completionScore.comparisonData = Math.round( ( ( ( rangeOneData[0].questionCompletionScore - rangeTwoData[0].questionCompletionScore )/rangeTwoData[0].questionCompletionScore )*100 ) ); // .toFixed( 2 )
+      if ( infoComparisonCards.completionScore.comparisonData > 0 ) {
+        infoComparisonCards.completionScore.ComparisonFlag = true;
+      } else {
+        infoComparisonCards.completionScore.ComparisonFlag = false;
+      }
+      infoComparisonCards.complianceRate.comparisonData = Math.round( ( ( ( rangeOneData[0].completionScore - rangeTwoData[0].completionScore )/rangeTwoData[0].completionScore )*100 ) ); // .toFixed( 2 )
+      if ( infoComparisonCards.complianceRate.comparisonData > 0 ) {
+        infoComparisonCards.complianceRate.ComparisonFlag = true;
+      } else {
+        infoComparisonCards.complianceRate.ComparisonFlag = false;
+      }
+
+      infoComparisonCards.totalInstances.comparisonData = Math.abs( infoComparisonCards.totalInstances.comparisonData ) || 0;
+      infoComparisonCards.completedInstances.comparisonData = Math.abs( infoComparisonCards.completedInstances.comparisonData ) || 0;
+      infoComparisonCards.flags.comparisonData = Math.abs( infoComparisonCards.flags.comparisonData ) || 0;
+      infoComparisonCards.completionScore.comparisonData = Math.abs( infoComparisonCards.completionScore.comparisonData ) || 0;
+      infoComparisonCards.complianceRate.comparisonData = Math.abs( infoComparisonCards.complianceRate.comparisonData ) || 0;
+    }
+    console.log( 'infoComparisonCards =>', infoComparisonCards );
+    let result = {
+      'infoComparisonCards': infoComparisonCards,
+    };
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'infoCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const reportChecklistTableV1 = 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 },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+        { checklistStatus: { $eq: 'submit' } },
+        { sourceCheckList_id: { $eq: new mongoose.Types.ObjectId( requestData.sourceCheckList_id ) } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    if ( requestData.searchValue && requestData.searchValue != '' ) {
+      let storeList = requestData.searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
+      let query;
+      if ( storeList.length > 1 ) {
+        findQuery.push( { $addFields: { store: { $toLower: '$storeName' } } } );
+        query = { store: { $in: storeList } };
+      } else {
+        query = { storeName: { $regex: requestData.searchValue.trim(), $options: 'i' } };
+      }
+      findQuery.push( { $match: { $or: [ query ] } } );
+    }
+
+    findQuery.push( {
+      $project: {
+        submittedDate: '$submitTime_string',
+        submittedTime: '$submitTime_string',
+        checkListName: 1,
+        storeName: 1,
+        store_id: 1,
+        submittedBy: '$userName',
+        submittedByChar: { $substr: [ '$userName', 0, 2 ] },
+        flagCount: {
+          $sum: {
+            $cond: [ {
+              $or: [
+                { $gt: [ '$timeFlag', 0 ] },
+                { $gt: [ '$questionFlag', 0 ] },
+                { $gt: [ '$mobileDetectionFlag', 0 ] },
+                { $gt: [ '$storeOpenCloseFlag', 0 ] },
+                { $gt: [ '$uniformDetectionFlag', 0 ] },
+              ],
+            }, 1, 0 ],
+          },
+        },
+      },
+    } );
+
+    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: { ['date_iso']: -1 } } );
+    }
+
+    let limit = parseInt( requestData?.limit ) || 10;
+    let skip = limit * ( requestData?.offset ) || 0;
+    findQuery.push( { $skip: skip }, { $limit: limit } );
+    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
+
+    result.totalCount = getTotalCount.length;
+    result.reportChecklistTableData = getChecklistPerformanceData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'checklistInfo' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const monthlyGraphV1 = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let currentDate = dayjs().set( 'hour', 0 ).set( 'minute', 0 ).set( 'second', 0 ).set( 'millisecond', 0 );
+    let targetDate = dayjs( requestData.toDate ).set( 'hour', 0 ).set( 'minute', 0 ).set( 'second', 0 ).set( 'millisecond', 0 );
+    let startOfMonth;
+    let endOfMonth;
+    let monthDate = requestData.monthDate || requestData.toDate;
+    if ( currentDate.format( 'YYYY-MM-DDTHH:mm:ss.SSS[+00:00]' ) > targetDate.format( 'YYYY-MM-DDTHH:mm:ss.SSS[+00:00]' ) ) {
+      if ( currentDate.format( 'YYYY-MM' ) == targetDate.format( 'YYYY-MM' ) ) {
+        startOfMonth = dayjs( monthDate ).startOf( 'month' ).format( 'YYYY-MM-DD' );
+        endOfMonth = currentDate.format( 'YYYY-MM-DD' );
+      } else {
+        startOfMonth = dayjs( monthDate ).startOf( 'month' ).format( 'YYYY-MM-DD' );
+        endOfMonth = dayjs( monthDate ).endOf( 'month' ).format( 'YYYY-MM-DD' );
+      }
+    } else {
+      startOfMonth = dayjs( monthDate ).startOf( 'month' ).format( 'YYYY-MM-DD' );
+      endOfMonth = currentDate.format( 'YYYY-MM-DD' );
+    }
+
+    let fromDate = new Date( startOfMonth );
+    let toDate = new Date( endOfMonth );
+    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 },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+        { checkListType: { $eq: 'custom' } },
+    );
+
+    if ( requestData.groupByType == 'Checklist' ) {
+      findAndQuery.push( { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.groupByValue ) } );
+    }
+
+    if ( requestData.groupByType == 'User' ) {
+      findAndQuery.push( { userEmail: requestData.groupByValue } );
+    }
+
+    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,
+        checklistStatus: 1,
+        date_iso: 1,
+        date_string: 1,
+        _id: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$date_iso',
+        totalChecklist: { $sum: 1 },
+        submittedChecklist: {
+          $sum: {
+            $cond: [
+              {
+                $and: [
+                  { $eq: [ '$checklistStatus', 'submit' ] },
+                ],
+              }, 1, 0 ],
+          },
+        },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        date: { $dayOfMonth: '$_id' },
+        totalChecklist: 1,
+        submittedChecklist: 1,
+        completionScore: {
+          $multiply: [
+            { $divide: [ '$submittedChecklist', '$totalChecklist' ] },
+            100,
+          ],
+        },
+        colorClass: '',
+      },
+    } );
+
+    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: { ['date_iso']: -1 } } );
+    }
+
+    // let limit = parseInt( requestData?.limit ) || 10;
+    // let skip = limit * ( requestData?.offset ) || 0;
+    // findQuery.push( { $skip: skip }, { $limit: limit } );
+    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
+
+    let colorcode ={
+      darkBlue: 'primary900',
+      blue: 'blue33B5FF',
+      liteBlue: 'lightBlue6BCAFF',
+      red: 'redF04438',
+      organge: 'orangeF79009',
+    };
+    for ( let i=0; i<getChecklistPerformanceData.length; i++ ) {
+      if ( getChecklistPerformanceData[i].completionScore > 40 && getChecklistPerformanceData[i].completionScore <= 55 ) {
+        getChecklistPerformanceData[i].colorClass = colorcode.organge;
+      } else if ( getChecklistPerformanceData[i].completionScore >= 56 && getChecklistPerformanceData[i].completionScore <= 70 ) {
+        getChecklistPerformanceData[i].colorClass = colorcode.liteBlue;
+      } else if ( getChecklistPerformanceData[i].completionScore >= 71 && getChecklistPerformanceData[i].completionScore <= 85 ) {
+        getChecklistPerformanceData[i].colorClass = colorcode.blue;
+      } else if ( getChecklistPerformanceData[i].completionScore >= 86 && getChecklistPerformanceData[i].completionScore <= 100 ) {
+        getChecklistPerformanceData[i].colorClass = colorcode.darkBlue;
+      } else {
+        getChecklistPerformanceData[i].colorClass = colorcode.red;
+      }
+    }
+
+    result.totalCount = getTotalCount.length;
+    result.monthlyChartData = getChecklistPerformanceData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'checklistInfo' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const reinitiatechecklist = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let findQuery = [];
+    let findAndQuery = [];
+
+    if ( requestData._id ) {
+      findAndQuery.push(
+          { _id: new mongoose.Types.ObjectId( requestData._id ) },
+      );
+      findQuery.push( { $match: { $and: findAndQuery } } );
+      findQuery.push( {
+        $project: {
+          _id: 1,
+          reinitiateStatus: 1,
+        },
+      } );
+      let getChecklist = await processedchecklistService.aggregate( findQuery );
+      console.log( 'getChecklist by _id=>', getChecklist );
+      if ( getChecklist.length>0 ) {
+        let updateChecklist = await processedchecklistService.updateOne( { _id: new mongoose.Types.ObjectId( requestData._id ) }, { reinitiateStatus: true } );
+        if ( updateChecklist ) {
+          // Delete Time Flag Detection //
+
+          return res.sendSuccess( 'Reinitiate Successfully' );
+        } else {
+          return res.sendError( { error: 'Something Went wrong Please Try Again' }, 400 );
+        }
+      } else {
+        return res.sendError( { error: 'Invalid Checklist Id' }, 400 );
+      }
+    } else if ( requestData.sourceCheckList_id ) {
+      findAndQuery.push(
+          { _id: new mongoose.Types.ObjectId( requestData.sourceCheckList_id ) },
+      );
+      findQuery.push( { $match: { $and: findAndQuery } } );
+      findQuery.push( {
+        $project: {
+          _id: 1,
+          reinitiateStatus: 1,
+        },
+      } );
+      let getChecklist = await processedchecklistService.aggregate( findQuery );
+      console.log( 'getChecklist source checklist=>', getChecklist );
+      if ( getChecklist.length>0 ) {
+        let updateQuery = {
+          _id: new mongoose.Types.ObjectId( requestData.sourceCheckList_id ),
+          timeFlag: { $gt: 0 },
+        };
+        let updateChecklist = await processedchecklistService.updateMany( updateQuery, { reinitiateStatus: true } );
+        if ( updateChecklist ) {
+          // Delete Time Flag Detection //
+
+          return res.sendSuccess( 'Reinitiate Successfully' );
+        } else {
+          return res.sendError( { error: 'Something Went wrong Please Try Again' }, 400 );
+        }
+      } else {
+        return res.sendError( { error: 'Invalid Checklist Id' }, 400 );
+      }
+    } else {
+      return res.sendError( { error: '_id or sourceCheckList_id is required' }, 400 );
+    }
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'checklistInfo' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const checklistDropdownOld = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let result = {};
+    let findQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { client_id: requestData.clientId },
+        { checkListType: 'custom' },
+    );
+    findQuery.push( { $match: { $and: findAndQuery } } );
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: '$_id',
+        checkListName: 1,
+        checkListNameLowercase: { $toLower: '$checkListName' },
+        checkListType: 1,
+        createdByName: 1,
+        storeCount: 1,
+        scheduleRepeatedType: 1,
+        scheduleStartTime: 1,
+        scheduleEndTime: 1,
+        publish: 1,
+      },
+    } );
+    if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
+      findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
+    } else {
+      findQuery.push( { $sort: { ['checkListNameLowercase']: 1 } } );
+    }
+    let getChecklistData = await checklistconfigService.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 );
+  }
+};
+
+export const checklistDropdown = 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 },
+        { store_id: { $in: requestData.storeId } },
+        { date_iso: { $gte: fromDate, $lte: toDate } },
+        { checkListType: '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',
+        },
+      },
+    ];
+    if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
+      findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
+    } else {
+      findQuery.push( { $sort: { ['checkListNameLowercase']: -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 ) {
+    logger.error( { error: error, message: req.query, function: 'checklistDropdownV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};