tango-app-api-audit 1.0.53 → 1.0.55

package/src/controllers/auditMetrics.controllers.js

@@ -1,995 +1,16 @@
-import { download, getUTC, insertOpenSearchData, logger, sendMessageToQueue } from 'tango-app-api-middleware';
-import { aggregateUserAudit, updateOneUserAudit } from '../service/userAudit.service.js';
+import { insertOpenSearchData, logger, sendMessageToQueue } from 'tango-app-api-middleware';
+import { updateOneUserAudit } from '../service/userAudit.service.js';
 import mongoose from 'mongoose';
-import { aggregateStoreAudit, updateOneStoreAudit } from '../service/storeAudit.service.js';
+import { updateOneStoreAudit } from '../service/storeAudit.service.js';
 import { findOneUser } from '../service/user.service.js';
 import dayjs from 'dayjs';
 import { createAssignAudit } from '../service/assignAudit.service.js';
-import { countDocumentsStore } from '../service/store.service.js';
 import { findOneClient } from '../service/client.service.js';
 import { getAuditFilterData, getAuditImageData, zipDownloadImage } from '../validation/audit.validation.js';
 import { getReauditImg } from './audit.controllers.js';
 // import { listQueue } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
 
 
-export async function storeMetrics( req, res ) {
-  try {
-    const inputData = req.body;
-    const limit = inputData.limit || 10;
-    const offset = inputData.offset ? ( inputData.offset - 1 ) * limit : 0;
-    const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
-    let filter = [
-      { fileDateISO: { $gte: dateRange.start } },
-      { fileDateISO: { $lte: dateRange.end } },
-    ];
-    if ( inputData.filterByClientId && inputData.filterByClientId?.length > 0 ) {
-      filter.push( { clientId: { $in: inputData.filterByClientId } } );
-    }
-
-    if ( inputData.filterByStoreId && inputData.filterByStoreId?.length > 0 ) {
-      filter.push( { storeId: { $in: inputData.filterByStoreId } } );
-    }
-
-    if ( inputData.filterByStatus && inputData.filterByStatus?.length > 0 ) {
-      filter.push( { status: { $in: inputData.filterByStatus } } );
-    }
-
-    if ( inputData.filterByType && inputData.filterByType?.length > 0 ) {
-      filter.push( { auditType: { $in: inputData.filterByType } } );
-    }
-
-
-    const query = [
-      {
-        $match: {
-          $and: filter,
-        },
-      },
-
-      {
-        $lookup: {
-          from: 'stores',
-          let: { storeId: '$storeId' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$storeId', '$$storeId' ],
-                },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                storeName: 1,
-              },
-            },
-          ], as: 'stores',
-        },
-      },
-      {
-        $unwind: {
-          path: '$stores',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          fileDate: 1,
-          storeId: 1,
-          storeName: '$store.storeName',
-          clientName: '',
-          clientId: 1,
-          userId: {
-            $arrayElemAt: [ '$userId', { $subtract: [ { $size: '$userId' }, 1 ] } ],
-          },
-          auditType: 1,
-          beforeCount: 1,
-          afterCount: { $ifNull: [ '$afterCount', null ] },
-          accuracy: { $round: [
-            { $divide: [
-              { $multiply: [ { $ifNull: [ '$afterCount', 0 ] }, '$beforeCount' ] }, 100,
-            ] }, 2,
-          ],
-
-          },
-          timeSpent: 1,
-          status: 1,
-        },
-      },
-      {
-        $lookup: {
-          from: 'users',
-          let: { userId: '$userId' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$_id', '$$userId' ],
-                },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                userName: 1,
-                userEmail: '$email',
-              },
-            },
-          ], as: 'users',
-        },
-      },
-      {
-        $unwind: {
-          path: '$users',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $lookup: {
-          from: 'clients',
-          let: { clientId: '$clientId' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$clientId', '$$clientId' ],
-                },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                clientName: 1,
-              },
-            },
-          ], as: 'client',
-        },
-      },
-      {
-        $unwind: {
-          path: '$client',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          fileDate: 1,
-          storeId: 1,
-          storeName: '$stores.storeName',
-          userName: '$users.userName',
-          userEmail: '$users.userEmail',
-          clientId: 1,
-          clientName: '$client.clientName',
-          auditType: 1,
-          beforeCount: 1,
-          afterCount: { $ifNull: [ '$afterCount', null ] },
-          accuracy: { $round: [
-            { $divide: [
-              { $multiply: [ { $ifNull: [ '$afterCount', 0 ] }, '$beforeCount' ] }, 100,
-            ] }, 1,
-          ],
-
-          },
-          timeSpent: {
-
-            $cond: [
-              { $lt: [ '$timeSpent', 60 ] }, // Case 1: If less than 60 seconds
-              { $concat: [ { $toString: '$timeSpent' }, ' sec' ] },
-              {
-                $cond: [
-                  { $lt: [ '$timeSpent', 3600 ] }, // Case 2: If less than 60 minutes (3600 seconds)
-                  {
-                    $concat: [
-                      { $toString: { $round: [ { $divide: [ '$timeSpent', 60 ] }, 1 ] } }, // Convert to minutes
-                      ' min',
-                    ],
-                  },
-                  {
-                    $concat: [
-                      { $toString: { $round: [ { $divide: [ '$timeSpent', 3600 ] }, 1 ] } }, // Convert to hours
-                      ' hr',
-                    ],
-                  },
-                ],
-              },
-            ],
-
-          },
-          status: 1,
-        },
-      },
-
-    ];
-
-    if ( inputData.searchValue && inputData.searchValue !== '' ) {
-      query.push( {
-        $match: {
-          $or: [
-            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
-            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
-            { storeId: { $regex: inputData.searchValue, $options: 'i' } },
-            { storeName: { $regex: inputData.searchValue, $options: 'i' } },
-            { userName: { $regex: inputData.searchValue, $options: 'i' } },
-            { status: { $regex: inputData.searchValue, $options: 'i' } },
-            { auditType: { $regex: inputData.searchValue, $options: 'i' } },
-          ],
-        },
-      } );
-    }
-
-    if ( inputData.sortColumnName ) {
-      const sortBy = inputData.sortBy || -1;
-      query.push( {
-        $sort: { [inputData.sortColumName]: sortBy },
-      },
-      );
-    }
-    const count = await aggregateStoreAudit( query );
-
-    if ( count.length == 0 ) {
-      return res.sendError( 'No data Found', 204 );
-    }
-    if ( !inputData.isExport ) {
-      query.push( {
-        $skip: offset,
-      },
-      {
-        $limit: limit,
-      } );
-    } else {
-      query.push( { $limit: 10000 } );
-    }
-    const result = await aggregateStoreAudit( query );
-    if ( inputData.isExport ) {
-      const exportdata = [];
-      result.forEach( ( element ) => {
-        exportdata.push( {
-          'File Date': element.fileDate,
-          'Store Id': element.storeId,
-          'Store Name': element.storeName,
-          'Client Id': element.clientId,
-          'Client Name': element.clientName,
-          'User Name': element.userName,
-          'User Email': element.userEmail,
-          'Audit Type': element.auditType,
-          'Accuracy': element.accuracy,
-          'Time Spent': element.timeSpent,
-          'Status': element.status,
-        } );
-      } );
-      await download( exportdata, res );
-      return;
-    }
-    return res.sendSuccess( { result: result, count: count.length } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, data: req.body, function: 'storeMetrics' } );
-    return res.sendError( err, 500 );
-  }
-}
-
-
-export async function userMetrics( req, res ) {
-  try {
-    const inputData = req.body;
-    const limit = inputData.limit || 10;
-    const offset = inputData.offset ? ( inputData.offset - 1 ) * limit : 0;
-    const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
-    let filter = [];
-    if ( inputData.fileType == 'auditedDate' ) {
-      filter.push(
-          { updatedAt: { $gte: dateRange.start } },
-          { updatedAt: { $lte: dateRange.end } },
-
-      );
-    } else {
-      filter.push(
-          { fileDateISO: { $gte: dateRange.start } },
-          { fileDateISO: { $lte: dateRange.end } },
-
-      );
-    }
-    if ( inputData?.filterByAuditType?.length> 0 ) {
-      filter.push(
-          { moduleType: { $in: inputData.filterByAuditType } },
-      );
-    }
-    if ( inputData?.filterByStatus?.length> 0 ) {
-      filter.push(
-          { auditStatus: { $in: inputData.filterByStatus } },
-      );
-    }
-    if ( inputData?.filterByUser?.length> 0 ) {
-      const temp = inputData.filterByUser.map( ( item ) => new mongoose.Types.ObjectId( item ) );
-      logger.info( { temp: temp } );
-      filter.push(
-          { userId: { $in: temp } },
-      );
-    }
-
-    const query = [
-      {
-        $match: {
-          $and: filter,
-        },
-      },
-      {
-        $project: {
-          userId: 1,
-          fileDate: 1,
-          startTime: 1,
-          endTime: 1,
-          totalCompletedFiles: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, 1, 0 ] },
-          beforeCount: 1,
-          afterCount: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, '$afterCount', 0 ] },
-        },
-      },
-      {
-        $group: {
-          _id: { userId: '$userId', fileDate: '$fileDate' },
-          userId: { $first: '$userId' },
-          fileDate: { $first: '$fileDate' },
-          totalCompletedFiles: { $sum: '$totalCompletedFiles' },
-          beforeCount: { $sum: '$beforeCount' },
-          afterCount: { $sum: '$afterCount' },
-          checkIntime: { $first: '$startTime' },
-          checkOutTime: { $last: '$endTime' },
-
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          userId: 1,
-          fileDate: 1,
-          totalCompletedFiles: 1,
-          beforeCount: 1,
-          afterCount: 1,
-          mappingPerc: { $round: [
-            { $multiply: [
-              { $divide: [ '$afterCount', '$beforeCount' ] }, 100,
-            ] }, 2,
-          ] },
-          checkIntime: 1,
-          checkOutTime: 1,
-          differenceInSeconds: {
-            $divide: [ { $subtract: [ '$checkOutTime', '$checkIntime' ] }, 1000 ],
-          },
-        },
-      },
-      {
-        $project: {
-          userId: 1,
-          fileDate: 1,
-          totalCompletedFiles: 1,
-          beforeCount: 1,
-          afterCount: 1,
-          checkIntime: 1,
-          checkOutTime: 1,
-          mappingPerc: 1,
-          hours: { $floor: { $divide: [ '$differenceInSeconds', 3600 ] } },
-          minutes: { $floor: { $divide: [ { $mod: [ '$differenceInSeconds', 3600 ] }, 60 ] } },
-          seconds: { $mod: [ '$differenceInSeconds', 60 ] },
-        },
-      },
-      {
-        $project: {
-          event: 1,
-          userId: 1,
-          fileDate: 1,
-          totalCompletedFiles: 1,
-          beforeCount: 1,
-          afterCount: 1,
-          checkIntime: 1,
-          checkOutTime: 1,
-          hours: {
-            $cond: {
-              if: { $lt: [ '$hours', 10 ] },
-              then: { $concat: [ '0', { $toString: { $round: [ '$hours', 0 ] } } ] },
-              else: { $toString: { $round: [ '$hours', 0 ] } },
-            },
-          },
-          minutes: {
-            $cond: {
-              if: { $lt: [ '$minutes', 10 ] },
-              then: { $concat: [ '0', { $toString: { $round: [ '$minutes', 0 ] } } ] },
-              else: { $toString: { $round: [ '$minutes', 0 ] } },
-            },
-          },
-          seconds: {
-            $cond: {
-              if: { $lt: [ '$seconds', 10 ] },
-              then: { $concat: [ '0', { $toString: { $round: [ '$seconds', 0 ] } } ] },
-              else: { $toString: { $round: [ '$seconds', 0 ] } },
-            },
-          },
-
-        },
-      },
-      {
-        $project: {
-          event: 1,
-          userId: 1,
-          fileDate: 1,
-          totalCompletedFiles: 1,
-          beforeCount: 1,
-          afterCount: 1,
-          checkIntime: 1,
-          zoneName: 1,
-          checkOutTime: 1,
-          workingHours: {
-            $concat: [ '$hours', ':', '$minutes', ':', '$seconds' ],
-          },
-        },
-      },
-      {
-        $lookup: {
-          from: 'users',
-          let: { userId: '$userId' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$_id', '$$userId' ],
-                },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                userName: 1,
-              },
-            },
-          ], as: 'userInfo',
-        },
-      },
-      {
-        $unwind: {
-          path: '$userInfo', preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $project: {
-          event: 1,
-          userName: '$userInfo.userName',
-          userId: 1,
-          fileDate: 1,
-          totalCompletedFiles: 1,
-          beforeCount: 1,
-          afterCount: 1,
-          checkIntime: {
-            $dateToString: {
-              format: '%Y-%m-%d %H:%M:%S',
-              date: '$checkIntime',
-              timezone: 'Asia/Kolkata',
-            },
-          },
-          checkOutTime: {
-            $dateToString: {
-              format: '%Y-%m-%d %H:%M:%S',
-              date: '$checkOutTime',
-              timezone: 'Asia/Kolkata',
-            },
-          },
-          workingHours: 1,
-        },
-      },
-    ];
-    if ( inputData.searchValue && inputData.searchValue!== '' ) {
-      query.push( {
-        $match: {
-          $or: [
-            { userName: { $regex: inputData.searchValue, $options: 'i' } },
-            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
-          ],
-
-        },
-      } );
-    }
-    if ( inputData.sortColumnName ) {
-      const sortBy = inputData.sortBy || -1;
-      query.push( {
-        $sort: { [inputData.sortColumName]: sortBy },
-      },
-      );
-    }
-
-    const count = await aggregateUserAudit( query );
-    if ( count.length == 0 ) {
-      return res.sendError( 'No Data Found', 204 );
-    }
-
-    query.push(
-        { $skip: offset },
-        { $limit: limit },
-    );
-    if ( inputData.isExport ) {
-      query.push(
-          {
-            $project: {
-              '_id': 0,
-              'File Date': '$fileDate',
-              'User Name': '$userName',
-              'User Id': '$userId',
-              'Total Completed Files Count': '$totalCompletedFiles',
-              'Total efore Count': '$beforeCount',
-              'Total After Count': '$afterCount',
-              'check Intime': '$checkIntime',
-              'check OutTime': '$checkOutTime',
-              'working Hours': '$workingHours',
-            },
-          },
-      );
-    }
-
-
-    const result = await aggregateUserAudit( query );
-    if ( inputData.isExport ) {
-      await download( result, res );
-      return;
-    }
-    return res.sendSuccess( { result: result, count: count.length } );
-  } catch ( error ) {
-    const err = error.error || 'Internal Server Error';
-    logger.info( { error: error, message: req.body, function: 'clientMetrics' } );
-    return res.sendError( err, 500 );
-  }
-}
-
-export async function overViewCard( req, res ) {
-  try {
-    const inputData = req.body;
-    const temp = {
-      totalCount: 0,
-      auditFileCount: 0,
-      ReAuditFileCount: 0,
-      inprogressCount: 0,
-      completedCount: 0,
-    };
-
-    const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
-    let filters =[
-      { fileDateISO: { $gte: dateRange.start } },
-      { fileDateISO: { $lte: dateRange.end } },
-    ];
-    if ( inputData.clientId.length > 0 ) {
-      filters.push( { clientId: { $in: inputData.clientId } } );
-    }
-    const query =[
-      {
-        $match: {
-          $and: filters,
-        },
-
-      },
-      {
-        $project: {
-          auditFileCount: {
-            $cond: [
-              { $eq: [ '$auditType', 'Audit' ] }, 1, 0,
-            ],
-          },
-          ReAuditFileCount: {
-            $cond: [
-              { $eq: [ '$auditType', 'ReAudit' ] }, 1, 0,
-            ],
-          },
-          inprogressCount: {
-            $cond: [
-              { $ne: [ '$status', 'completed' ] }, 1, 0,
-            ],
-          },
-          completedCount: {
-            $cond: [
-              { $eq: [ '$status', 'completed' ] }, 1, 0,
-            ],
-          },
-        },
-      },
-      {
-        $group: {
-          _id: { fileDate: '$fileDate', clientId: '$clientId' },
-          totalCount: { $sum: 1 },
-          auditFileCount: { $sum: '$auditFileCount' },
-          ReAuditFileCount: { $sum: '$ReAuditFileCount' },
-          inprogressCount: { $sum: '$inprogressCount' },
-          completedCount: { $sum: '$completedCount' },
-
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          totalCount: 1,
-          auditFileCount: 1,
-          ReAuditFileCount: 1,
-          inprogressCount: 1,
-          completedCount: 1,
-        },
-      },
-    ];
-    const result = await aggregateStoreAudit( query );
-    logger.info( { result: result } );
-    return res.sendSuccess( { result: result.length> 0? result[0]: temp } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, message: req.body, function: 'overViewCard' } );
-    return res.sendError( err, 500 );
-  }
-}
-
-export async function summarySplit( req, res ) {
-  try {
-    const inputData = req.body;
-    const temp = {
-      totalInprogress: 0,
-      auditInprogress: 0,
-      reAuditInprogress: 0,
-      draft: 0,
-      assigned: 0,
-      auditCompleted: 0,
-      reAuditCompleted: 0,
-      completedCount: 0,
-    };
-
-    const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
-    let filters =[
-      { fileDateISO: { $gte: dateRange.start } },
-      { fileDateISO: { $lte: dateRange.end } },
-    ];
-    if ( inputData.clientId.length > 0 ) {
-      filters.push( { clientId: { $in: inputData.clientId } } );
-    }
-    const query =[
-      {
-        $match: {
-          $and: filters,
-        },
-
-      },
-      {
-        $project: {
-          auditInprogress: {
-            $cond: [
-              { $and: [ { $eq: [ '$auditType', 'Audit' ] }, { $eq: [ '$status', 'inprogress' ] } ] }, 1, 0,
-            ],
-          },
-          reAuditInprogress: {
-            $cond: [
-              { $and: [ { $eq: [ '$auditType', 'ReAudit' ] }, { $eq: [ '$status', 'inprogress' ] } ] }, 1, 0,
-            ],
-          },
-          draft: {
-            $cond: [
-              { $ne: [ '$status', 'drafted' ] }, 1, 0,
-            ],
-          },
-          assigned: {
-            $cond: [
-              { $ne: [ '$status', 'assigned' ] }, 1, 0,
-            ],
-          },
-          completedCount: {
-            $cond: [
-              { $eq: [ '$status', 'completed' ] }, 1, 0,
-            ],
-          },
-          reAuditCompleted: {
-            $cond: [
-              { $and: [ { $eq: [ '$auditType', 'ReAudit' ] }, { $eq: [ '$status', 'completed' ] } ] }, 1, 0,
-            ],
-          },
-          auditCompleted: {
-            $cond: [
-              { $and: [ { $eq: [ '$auditType', 'Audit' ] }, { $eq: [ '$status', 'completed' ] } ] }, 1, 0,
-            ],
-          },
-        },
-      },
-      {
-        $group: {
-          _id: { fileDate: '$fileDate', clientId: '$clientId' },
-          totalInprogress: { $sum: 1 },
-          auditInprogress: { $sum: '$auditInprogress' },
-          reAuditInprogress: { $sum: '$reAuditInprogress' },
-          draft: { $sum: '$draft' },
-          assigned: { $sum: 'assigned' },
-          completedCount: { $sum: '$completedCount' },
-          reAuditCompleted: { $sum: '$reAuditCompleted' },
-          auditCompleted: { $sum: '$auditCompleted' },
-          completedCount: { $sum: '$completedCount' },
-
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          totalInprogress: 1,
-          auditInprogress: 1,
-          reAuditInprogress: 1,
-          draft: 1,
-          assigned: 1,
-          completedCount: 1,
-          reAuditCompleted: 1,
-          auditCompleted: 1,
-
-        },
-      },
-    ];
-    const result = await aggregateStoreAudit( query );
-    logger.info( { result: result } );
-    return res.sendSuccess( { result: result.length> 0? result[0]: temp } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, message: req.body, function: 'summarySplit' } );
-    return res.sendError( err, 500 );
-  }
-}
-
-export async function overViewTable( req, res ) {
-  try {
-    const inputData = req.body;
-    const limit = inputData.limit || 10;
-    const offset = inputData.offset ? ( inputData.offset - 1 ) * limit : 0;
-    const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
-    let filters =[
-      { fileDateISO: { $gte: dateRange.start } },
-      { fileDateISO: { $lte: dateRange.end } },
-      { auditStatus: { $in: inputData.filterByStatus } },
-      { auditType: { $in: inputData.filterByType } },
-
-    ];
-    if ( inputData.clientId.length > 0 ) {
-      filters.push( { clientId: { $in: inputData.clientId } } );
-    }
-    if ( inputData.filterByAuditType.length > 0 ) {
-      filters.push( { moduleType: { $in: inputData.filterByAuditType } } );
-    }
-
-    const query =[
-      {
-        $match: {
-          $and: filters,
-        },
-
-      },
-      {
-        $project: {
-          _id: 0,
-          storeId: 1,
-          fileDate: 1,
-          beforeCount: 1,
-          startTime: 1,
-          auditType: 1,
-          auditStatus: 1,
-          userId: 1,
-        },
-      },
-      {
-        $lookup: {
-          from: 'users',
-          let: { userId: '$userId' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$_id', '$$userId' ],
-                },
-              },
-            },
-            {
-              $project: {
-                userName: 1,
-                userEmail: '$email',
-              },
-            },
-          ], as: 'user',
-        },
-      },
-      {
-        $unwind: {
-          path: '$user',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $project: {
-          storeId: 1,
-          fileDate: 1,
-          beforeCount: 1,
-          startTime: 1,
-          auditType: 1,
-          auditStatus: 1,
-          userName: '$user.userName',
-          userEmail: '$user.userEmail',
-
-        },
-      },
-    ];
-    if ( inputData.searchValue && inputData.searchValue!== '' ) {
-      query.push( {
-        $match: {
-          $or: [
-            { storeId: { $regex: inputData.searchValue, $options: 'i' } },
-            { fileDate: { $regex: inputData.searchValue, $options: 'i' } },
-            { auditType: { $regex: inputData.searchValue, $options: 'i' } },
-            { auditStatus: { $regex: inputData.searchValue, $options: 'i' } },
-            { userName: { $regex: inputData.searchValue, $options: 'i' } },
-            { userEmail: { $regex: inputData.searchValue, $options: 'i' } },
-          ],
-
-        },
-      } );
-    }
-    if ( inputData.sortColumnName ) {
-      const sortBy = inputData.sortBy || -1;
-      query.push( {
-        $sort: { [inputData.sortColumName]: sortBy },
-      },
-      );
-    }
-    const count = await aggregateUserAudit( query );
-    if ( count.length == 0 ) {
-      return res.sendError( 'No Data Found', 204 );
-    }
-
-    if ( inputData.isExport ) {
-      query.push( { limit: 10000 } );
-    } else {
-      query.push( {
-        $skip: offset,
-      },
-      {
-        $limit: limit,
-      } );
-    }
-
-    const result = await aggregateUserAudit( query );
-    if ( inputData.isExport ) {
-      const exportdata = [];
-      result.forEach( ( element ) => {
-        exportdata.push( {
-          'Store Id': element.storeId,
-          'File Date': element.fileDtae,
-          'Type': element.audittype,
-          'Before Count': element.beforeCount,
-          'Start Time': element.startTime,
-          'User Name': element.userName,
-          'User Email': element.userEmail,
-          'Status': element.auditStatus,
-          'Audit Type': element.moduleType,
-        } );
-      } );
-      await download( exportdata, res );
-      return;
-    }
-    return res.sendSuccess( { result: result, count: count.length } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, message: req.body, function: 'summarySplit' } );
-    return res.sendError( err, 500 );
-  }
-}
-
-export async function overAllAuditSummary( req, res ) {
-  try {
-    const inputData = req.body;
-    let temp = {
-      installedStores: 0,
-      auditStores: 0,
-      inprogreseStores: 0,
-      completedStores: 0,
-      auditInprogress: 0,
-      reAuditInprogress: 0,
-      draft: 0,
-      assigned: 0,
-      notAssigned: 0,
-      auditCompleted: 0,
-      reAuditCompleted: 0,
-
-    };
-    const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
-    let filters =[
-      { fileDateISO: { $gte: dateRange.start } },
-      { fileDateISO: { $lte: dateRange.end } },
-      { moduleType: { $eq: inputData.moduleType },
-      },
-    ];
-    if ( inputData.clientId.length > 0 ) {
-      filters.push( { clientId: { $in: inputData.clientId } } );
-    }
-    const storeQuery = inputData.clientId.length? { 'edge.firstFile': true, 'clientId': { $in: inputData. clientId } } : { 'edge.firstFile': true };
-    temp.installedStores = await countDocumentsStore( storeQuery );
-    // const auditClientDataQuery =[
-    //   {
-    //     $match: {
-    //       $and: filters,
-    //     },
-
-    //   },
-    //   {
-    //     $group: {
-    //       _id: null,
-    //       totalFilesCount: { $sum: '$totalFilesCount' },
-    //     },
-    //   },
-    // ];
-    const auditClientData = [];// await aggregateAuditClientData( auditClientDataQuery );
-    if ( auditClientData.length >0 ) {
-      temp.auditStores = auditClientData[0].totalFilesCount;
-    }
-    const storeAuditQuery =[
-      {
-        $match: {
-          $and: filters,
-        },
-
-      },
-      {
-        $project: {
-          completedStores: { $cond: [ { $eq: [ '$status', 'completed' ] }, 1, 0 ] },
-          auditInprogress: { $cond: [ { $and: [ { $in: [ '$status', [ 'inprogress' ] ] }, { $eq: [ '$auditType', 'Audit' ] } ] }, 1, 0 ] },
-          reAuditInprogress: { $cond: [ { $and: [ { $in: [ '$status', [ 'inprogress' ] ] }, { $eq: [ '$auditType', 'ReAudit' ] } ] }, 1, 0 ] },
-          draft: { $cond: [ { $eq: [ '$status', 'drafted' ] }, 1, 0 ] },
-          assigned: { $cond: [ { $eq: [ '$status', 'drafted' ] }, 1, 0 ] },
-          exceptNoAssigned: { $cond: [ { $in: [ '$status', [ 'skipped', 'not_assign' ] ] }, 1, 0 ] },
-          auditCompleted: { $cond: [ { $and: [ { $in: [ '$status', [ 'completed' ] ] }, { $eq: [ '$auditType', 'Audit' ] } ] }, 1, 0 ] },
-          reAuditCompleted: { $cond: [ { $and: [ { $in: [ '$status', [ 'completed' ] ] }, { $eq: [ '$auditType', 'ReAudit' ] } ] }, 1, 0 ] },
-
-
-        },
-      },
-      {
-        $group: {
-          _id: null,
-          completedStores: { $sum: '$completedStores' },
-          auditInprogress: { $sum: '$auditInprogress' },
-          reAuditInprogress: { $sum: '$reAuditInprogress' },
-          draft: { $sum: '$draft' },
-          assigned: { $sum: '$assigned' },
-          exceptNoAssigned: { $sum: '$exceptNoAssigned' },
-          auditCompleted: { $sum: '$auditCompleted' },
-          reAuditCompleted: { $sum: '$reAuditCompleted' },
-        },
-      },
-      {
-        $project: {
-          completedStores: 1,
-          inprogressStores: { $subtract: [ temp.auditStores, '$completedStores' ] },
-          auditInprogress: 1,
-          reAuditInprogress: 1,
-          draft: 1,
-          assigned: 1,
-          exceptNoAssigned: { $subtract: [ temp.auditStores, '$exceptNoAssigned' ] },
-          auditCompleted: 1,
-          reAuditCompleted: 1,
-        },
-      },
-    ];
-    const storeAudit = await aggregateStoreAudit( storeAuditQuery );
-    if ( storeAudit.length > 0 ) {
-      temp.inprogreseStores= storeAudit[0].inprogreseStores;
-      temp.completedStores = storeAudit[0].completedStores;
-      temp.auditInprogress = storeAudit[0].auditInprogress;
-      temp.reAuditInprogress = storeAudit[0].reAuditInprogress;
-      temp.draft = storeAudit[0].draft;
-      temp.assigned = storeAudit[0].assigned;
-      temp.notAssigned = storeAudit[0].exceptNoAssigned;
-      temp.auditCompleted = storeAudit[0].auditCompleted;
-      temp.reAuditCompleted = storeAudit[0].reAuditCompleted;
-    }
-
-    return res.sendSuccess( { result: temp } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, message: req.body, function: 'summarySplit' } );
-    return res.sendError( err, 500 );
-  }
-}
-
 export async function reTrigger( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );