tango-app-api-audit 1.0.53 → 1.0.55

package/src/controllers/audit.controllers.js

@@ -39,7 +39,7 @@ import {
   createAuditLog,
   findOneAuditLog,
 } from '../service/auditLog.service.js';
-import { aggregateStore, findOneStore } from '../service/store.service.js';
+import { aggregateStore, countDocumentsStore, findOneStore } from '../service/store.service.js';
 import {
   mapCustomer,
   mapEmployee,
@@ -1884,3 +1884,1006 @@ export async function clientMetrics( req, res ) {
     return res.sendError( err, 500 );
   }
 }
+
+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.filterByAuditType && inputData.filterByAuditType?.length > 0 ) {
+      filter.push( { auditType: { $in: inputData.filterByAuditType } } );
+    }
+
+    if ( inputData.filterByModuleType && inputData.filterByModuleType?.length > 0 ) {
+      filter.push( { moduleType: { $in: inputData.filterByModuleType } } );
+    }
+
+
+    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,
+          zoneName: 1,
+          moduleType: 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',
+          zoneName: 1,
+          moduleType: 1,
+          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' } },
+            { moduleType: { $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.dateType == 'auditedDate' ) {
+      filter.push(
+          { updatedAt: { $gte: dateRange.start } },
+          { updatedAt: { $lte: dateRange.end } },
+
+      );
+    } else {
+      filter.push(
+          { fileDateISO: { $gte: dateRange.start } },
+          { fileDateISO: { $lte: dateRange.end } },
+
+      );
+    }
+    if ( inputData?.filterByModuleType?.length> 0 ) {
+      filter.push(
+          { moduleType: { $in: inputData.filterByModuleType } },
+      );
+    }
+    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 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 } },
+
+    ];
+
+    if ( inputData.clientId.length > 0 ) {
+      filters.push( { clientId: { $in: inputData.clientId } } );
+    }
+
+    if ( inputData.filterByModuleType.length > 0 ) {
+      filters.push( { moduleType: { $in: inputData.filterByModuleType } } );
+    }
+
+    if ( inputData.filterByAuditType.length > 0 ) {
+      filters.push( { auditType: { $in: inputData.filterByAuditType } } );
+    }
+    const query =[
+      {
+        $match: {
+          $and: filters,
+        },
+
+      },
+      {
+        $project: {
+          _id: 0,
+          storeId: 1,
+          zoneName: 1,
+          fileDate: 1,
+          moduleType: 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,
+          zoneName: 1,
+          fileDate: 1,
+          moduleType: 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,
+          'zoneName': element.zoneName,
+          'File Date': element.fileDate,
+          'Module Type': element.moduleType,
+          'Audit Type': element.auditType,
+          'Before Count': element.beforeCount,
+          'Start Time': element.startTime,
+          'User Name': element.userName,
+          'User Email': element.userEmail,
+          'Status': element.auditStatus,
+        } );
+      } );
+      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: { $in: 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: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          totalFilesCount: 1,
+        },
+      },
+    ];
+    const auditClientData = await aggregateAuditStoreDataSchema( 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,
+          exceptNoAssigned1: 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 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 );
+  }
+}