tango-app-api-audit 3.3.0-alpha.2 → 3.3.0-alpha.21

package/src/controllers/zoneAudit.controller.js

@@ -1,1827 +0,0 @@
-import { download, fileUpload, getJsonFileData, getUTC, insertOpenSearchData, listFileByPath, listFileWithoutLimit, sendMessageToQueue, signedUrl, sqsReceive } from 'tango-app-api-middleware';
-import { aggregateZoneUserAudit, createZoneUserAudit, findOneZoneUserAudit, updateOneZoneUserAudit } from '../service/zoneUserAudit.service.js';
-import { logger } from 'tango-app-api-middleware';
-import { findOneUser } from '../service/user.service.js';
-import { findOneStore } from '../service/store.service.js';
-import dayjs from 'dayjs';
-import { aggregateUserAudit, findOneUserAudit, updateOneUserAudit } from '../service/userAudit.service.js';
-import { aggregateAssignAudit, createAssignAudit } from '../service/assignAudit.service.js';
-import { createAuditLog, findOneAuditLog } from '../service/auditLog.service.js';
-import { mapCustomer, mapEmployee, mapJunk, splitB20000, splitE0, splitG20000, zipDownloadImage } from '../validation/audit.validation.js';
-import { aggregateClient, findClient, findOneClient } from '../service/client.service.js';
-import _ from 'lodash';
-import mongoose from 'mongoose';
-import { listQueue } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
-import { getReauditImg } from './audit.controllers.js';
-import { getZoneAuditFilterData, getZoneAuditImageData } from '../validation/zoneAudit.validation.js';
-
-export async function getZoneAuditFile( req, res ) {
-  try {
-    const bucket = JSON.parse( process.env.BUCKET );
-    const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const inputData = req.query;
-    const data = await getUTC( new Date(), new Date() );
-    const start = data.start;
-    const end = data.end;
-    const fetchData = {};
-    let msg = {};
-
-    const userQuery = [
-      {
-        $match: {
-          $and: [
-            { userId: req.user._id },
-            { queueName: inputData.queueName },
-            { auditStatus: { $nin: [ 'completed', 'skipped' ] } },
-            { createdAt: { $gte: start } },
-            { createdAt: { $lte: end } },
-            { moduleType: 'zone' },
-          ],
-        },
-      },
-      {
-        $sort: { createdAt: -1 },
-      },
-      {
-        $limit: 1,
-      },
-    ];
-    const userDetails = await aggregateZoneUserAudit( userQuery );
-    const zoneAuditStatus =
-    userDetails && userDetails.length > 0 ? userDetails[0].auditStatus : null;
-
-    switch ( zoneAuditStatus ) {
-      case null:
-        const query = [
-          {
-            $match: {
-              $and: [
-                { userId: { $eq: req.user._id } },
-                { isCompleted: { $eq: false } },
-                { queueName: inputData.queueName },
-              ],
-            },
-          },
-          {
-            $sort: { createdAt: -1 },
-          },
-          {
-            $limit: 1,
-          },
-        ];
-
-        const userAssign = await aggregateAssignAudit( query );
-        if ( userAssign.length > 0 ) {
-          logger.info( 'Hit in user assign', { inputData } );
-        } else {
-          logger.info( 'Hit in new file', { inputData } );
-          const consumer = await sqsReceive( inputData.queueName );
-          if ( !consumer ) {
-            logger.error( {
-              error: consumer,
-              function: 'getAuditFile',
-              message: 'SQS Receive queue is empty',
-            } );
-            return res.sendError( `${inputData.queueName} is Empty`, 204 );
-          }
-          msg = JSON.parse( consumer );
-        }
-        break;
-
-      case 'drafted':
-        logger.info( 'userDetails drafted', { inputData } );
-
-        const log = await findOneZoneUserAudit(
-            {
-              userId: userDetails[0].userId,
-              fileDate: userDetails[0].fileDate,
-              storeId: userDetails[0].storeId,
-              totalCount: userDetails[0].beforeCount,
-              moduleType: 'zone',
-              zoneName: userDetails[0].zoneName,
-            },
-            {},
-            { createdAt: -1 },
-        );
-
-        if ( !log ) {
-          await updateOneZoneUserAudit(
-              { _id: userDetails[0]._id },
-              { $set: { isDraft: false, auditStatus: 'skipped' } },
-          );
-          logger.info( 'zone audit update in drafted', {
-            _id: userDetails[0]._id,
-            isDraft: false,
-            auditStatus: 'skipped',
-          } );
-          return res.sendError( 'User saved data has been deleted', 204 );
-        }
-        const file = {
-          auditId: userDetails[0]._id,
-          store_id: userDetails[0].storeId,
-          file_date: userDetails[0].fileDate,
-          type: userDetails[0].auditType,
-          queueName: log.queueName,
-          userId: log.userId,
-          zoneName: userDetails[0].zoneName,
-        };
-        const result = {
-          junk: log.junk,
-          junk_count: log.junkCount,
-          employee: log.employee,
-          employee_count: log.employeeCount,
-          customer: log.customer,
-          customer_count: log.customerCount,
-          retag_image: log.retagImage,
-          retag_count: log.retagCount,
-          total_count: log.totalCount,
-        };
-
-        const userdata = await findOneUser( { _id: log.userId } );
-
-        if (
-          !inputData.nextId ||
-          inputData.nextId === '' ||
-          inputData.nextId == null
-        ) {
-          const logData = {
-            userId: log.userId,
-            userName: userdata.name,
-            logType: 'auditZone',
-            logSubType: 'auditZoneStart',
-            logData: {
-              file_date: userDetails[0].fileDate,
-              auditType: userDetails[0].auditType,
-              storeId: userDetails[0].storeId,
-              clientName: log.queueName,
-              auditId: userDetails[0]._id,
-              zoneName: userDetails[0].zoneName,
-            },
-          };
-          logger.info( { logData: logData } );
-          await insertOpenSearchData( openSearch.activityLog, logData );
-        }
-
-        const storeQuery = {
-          storeId: userDetails[0].storeId,
-        };
-
-        const storeFields = {
-          storeId: 1,
-          storeName: 1,
-          address: '$storeProfile.address',
-        };
-        const storeDetails = await findOneStore( storeQuery, storeFields );
-        res.sendSuccess( {
-          result: result,
-          storeId: storeDetails?.storeId,
-          storeName: storeDetails?.storeName,
-          address: storeDetails?.address || '',
-          count: log.totalCount,
-          file: file,
-          isDraft: userDetails[0].isDraft,
-        } );
-        break;
-
-      default:
-        msg = {
-          store_id: userDetails[0].storeId,
-          curr_date: userDetails[0].fileDate,
-          audit_type: userDetails[0].auditType,
-          total_count: userDetails[0].beforeCount,
-          zone_id: userDetails[0].zoneName,
-        };
-        break;
-    }
-    /** *
-     *
-     * Reaudit pending
-     */
-
-    if ( msg.audit_type === 'ReAudit' ) {
-      logger.info( 'Hit in zone user ReAudit', { inputData } );
-      let reauditInsert = {};
-      const [ filterData, auditImage ] = await Promise.all( [
-        getZoneFilterData( msg ),
-        getZoneAuditImage( msg ),
-      ] );
-      if ( filterData.statusCode == 404 || auditImage.statusCode == 404 ) {
-        return res.sendError( 'No Data found', 204 );
-      }
-      const reauditImg = await getReauditImg( filterData, auditImage );
-      if ( userDetails.length === 0 ) {
-        const [ day, month, year ] = msg.curr_date.split( '-' );
-        const temp = `${year}-${month}-${day}`;
-        let start = new Date( temp );
-        const userTimezoneOffset = start.getTimezoneOffset() * 60000;
-        start = new Date( start.getTime() - userTimezoneOffset );
-        start.setUTCHours( 0, 0, 0, 0 );
-        const record = {
-          userId: req.user._id,
-          storeId: msg.store_id,
-          clientId: msg.store_id.split( '-' )[0],
-          auditType: msg.audit_type || 'ReAudit',
-          fileDate: msg.curr_date,
-          queueName: inputData.queueName,
-          beforeCount: reauditImg.length,
-          zoneAuditStatus: 'inprogress',
-          zoneName: msg.zone_id,
-          fileDateISO: start,
-          timeSpent: 0,
-          startTime: new Date(),
-          moduleType: 'zone',
-        };
-        const storeRecord = {
-          userId: req.user._id,
-          storeId: msg.store_id,
-          clientId: msg.store_id.split( '-' )[0],
-          auditType: msg.audit_type || 'ReAudit',
-          fileDate: msg.curr_date,
-          queueName: inputData.queueName,
-          beforeCount: reauditImg.length,
-          status: 'inprogress',
-          fileDateISO: start,
-          timeSpent: 0,
-          zoneName: msg.zone_id,
-        };
-        reauditInsert = await createZoneUserAudit( record );
-        await createStoreZoneAudit( storeRecord );
-      } else {
-        reauditInsert = userDetails[0];
-      }
-      const userdata = await findOneUser( { _id: req.user._id } );
-      if ( inputData.nextId ) {
-        const logData = {
-          userId: req.user._id,
-          userName: userdata.name,
-          logType: 'auditZone',
-          logSubType: 'auditZoneStart',
-          logData: {
-            fileDate: msg.curr_date,
-            auditType: msg.audit_type,
-            storeId: msg.store_id,
-            clientName: inputData.queueName,
-            auditId: reauditInsert._id,
-            zoneName: msg.zone_id,
-          },
-        };
-        await insertOpenSearchData( openSearch.activityLog, logData );
-      }
-
-      const storeQuery = {
-        storeId: msg.store_id,
-      };
-      const storeFields = {
-        storeId: 1,
-        storeName: 1,
-        address: '$storeProfile.address',
-      };
-      const storeInfo = await findOneStore( storeQuery, storeFields );
-      return res.sendSuccess( {
-        result: reauditImg,
-        count: reauditImg.length,
-        storeId: storeInfo?.storeId,
-        storeName: storeInfo?.storeName,
-        address: storeInfo?.address || '',
-        file: {
-          store_id: msg.store_id,
-          file_date: msg.curr_date,
-          type: msg.audit_type || 'ReAudit',
-          queueName: inputData.queueName,
-          auditId: reauditInsert._id,
-          userId: reauditInsert.userId,
-          zoneName: msg.zone_id,
-        },
-        isDraft: reauditInsert.isDraft,
-      } );
-    }
-    // ////////////
-
-    const storeId = msg.store_id;
-    const fileDate = msg.curr_date;
-    const files = [];
-    let insertData = {};
-    fetchData.Bucket = bucket.auditInput; // need to change
-    fetchData.file_path = `${fileDate}/${storeId}/${msg.zone_id}/`;
-    if ( inputData.limit ) {
-      fetchData.MaxKeys = inputData.limit;
-    }
-    if ( inputData.nextId ) {
-      fetchData.ContinuationToken = decodeURIComponent( inputData.nextId );
-    }
-    const list = await listFileByPath( fetchData );
-
-    const folderPath = list.data;
-    const nextQuery = list.pageToken;
-    logger.info( { list: list } );
-    if ( folderPath?.length > 0 ) {
-      for ( let i = 0; i < folderPath.length; i++ ) {
-        const img = folderPath[i].Key.split( '/' );
-        const image = img[3].split( '.' );
-        const indexes = image[0].split( '_' );
-        fetchData.file_path = folderPath[i].Key;
-
-        const data = await signedUrl( fetchData );
-        const mapimg = {
-          img_path: data,
-          img_name: indexes[1],
-          img_id: image[0],
-        };
-        files.push( {
-          img_path: data,
-          img_name: indexes[1],
-          img_id: image[0],
-          selected: false,
-          dropped: false,
-          count: 1,
-          mappedid: [ mapimg ],
-        } );
-      }
-      if ( userDetails.length === 0 ) {
-        const [ day, month, year ] = msg.curr_date.split( '-' );
-        const temp = `${year}-${month}-${day}`;
-        let start = new Date( temp );
-        logger.info( { start: start, date: msg.curr_date } );
-        const userTimezoneOffset = start.getTimezoneOffset() * 60000;
-        start = new Date( start.getTime() - userTimezoneOffset );
-        start.setUTCHours( 0, 0, 0, 0 );
-
-        const record = {
-          userId: req.user._id,
-          storeId: msg.store_id,
-          clientId: msg.store_id.split( '-' )[0],
-          auditType: 'Audit',
-          fileDate: msg.curr_date,
-          queueName: inputData.queueName,
-          beforeCount: msg.total_count || files.length,
-          zoneAuditStatus: 'inprogress',
-          zoneName: msg.zone_id,
-          fileDateISO: start,
-          timeSpent: 0,
-          startTime: new Date(),
-          moduleType: 'zone',
-        };
-
-        const storeRecord = {
-          userId: req.user._id,
-          storeId: msg.store_id,
-          clientId: msg.store_id.split( '-' )[0],
-          auditType: 'Audit',
-          fileDate: msg.curr_date,
-          queueName: inputData.queueName,
-          beforeCount: msg.total_count || files.length,
-          status: 'inprogress',
-          fileDateISO: start,
-          timeSpent: 0,
-          zoneName: msg.zone_id,
-
-        };
-        insertData = await createZoneUserAudit( record );
-        await createStoreZoneAudit( storeRecord );
-      } else {
-        insertData = userDetails[0];
-      }
-    } else {
-      logger.error( {
-        error: { folderPath: folderPath, nextQuery: nextQuery },
-        function: 'getAuditFile',
-        message: 'Bucket image data not availale',
-      } );
-      return res.sendError( 'Bucket is Empty', 204 );
-    }
-    const userdata = await findOneUser( { _id: insertData.userId } );
-    const storeQuery = {
-      storeId: storeId,
-    };
-    const storeFields = {
-      storeName: 1,
-      address: '$storeProfile.address',
-    };
-    const storeInfo = await findOneStore( storeQuery, storeFields );
-    if ( inputData.nextId ) {
-      const logData = {
-        userId: insertData.userId,
-        userName: userdata.name,
-        logType: 'auditZone',
-        logSubType: 'auditZoneStart',
-        logData: {
-          fileDate: insertData.fileDate,
-          auditType: insertData.auditType,
-          storeId: storeId,
-          clientName: inputData.queueName,
-          auditId: insertData._id,
-          zoneName: msg.zone_id,
-        },
-      };
-      await insertOpenSearchData( openSearch.activityLog, logData );
-    }
-    logger.info( { storeInfo: storeInfo } );
-
-    return res.sendSuccess( {
-      result: files,
-      count: msg.total_count,
-      storeId: storeId,
-      storeName: storeInfo?.storeName,
-      address: storeInfo?.address,
-      zoneName: msg.zone_id,
-      file: {
-        queueName: inputData.queueName,
-        store_id: storeId,
-        file_date: fileDate,
-        type: 'Audit',
-        auditId: insertData._id,
-        userId: insertData.userId,
-        nextToken: nextQuery ? encodeURIComponent( nextQuery ) : null,
-      },
-      isDraft: insertData.isDraft,
-    } );
-  } catch ( error ) {
-    // {"store_id": "430-5", "curr_date": '08-08-2024', "total_count": 115, "zone_id": "HR"}
-    // {"store_id":"11-2043","audit_type":"ReAudit","curr_date":"07-08-2024","total_count":41,"before_count":88}
-    // {store_id: '430-5', curr_date: '08-08-2024', total_count: 115,zone_id:'HR'}
-    // {'store_id': "430-5", 'curr_date': "08-08-2024", 'total_count': 115,'zone_id':"HR"}
-    // {'store_id': '430-5', 'curr_date': '08-08-2024', 'total_count': 115,'zone_id':"HR"}
-  //  {"store_id":"430-5","curr_date":"08-08-2024","total_count":115,"zone_id":"HR"}
-    logger.error( {
-      error: error,
-      message: req.query,
-      function: 'getZoneAuditFile',
-    } );
-    return res.sendError( error, 500 );
-  }
-}
-
-export async function saveDraft( req, res ) {
-  try {
-    const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const inputData = req.body;
-    inputData.userId = req.user._id;
-    const getUserAuditData = await findOneZoneUserAudit( { _id: inputData.auditId } );
-    if ( !getUserAuditData ) {
-      return res.sendError( 'No Data Found', 204 );
-    }
-    if ( getUserAuditData.auditStatus == 'skipped' ) {
-      return res.sendError( 'File Assigned to Someone else', 203 );
-    }
-
-    const userQuery = {
-      _id: inputData.auditId,
-    };
-    let userRecord = {
-      isDraft: true,
-      auditStatus: 'drafted',
-    };
-    const storeQuery = {
-      storeId: inputData.storeId,
-      fileDate: inputData.fileDate,
-    };
-
-    let storeRecord = {
-      status: 'drafted',
-    };
-
-    if ( getUserAuditData?.startTime ) {
-      const isoDate = getUserAuditData.startTime;
-      const currentTime = dayjs();
-      const isoDateTime = dayjs( isoDate );
-      const timeDifferenceInMinutes = currentTime.diff( isoDateTime, 'seconds' );
-
-      userRecord.timeSpent = timeDifferenceInMinutes;
-
-      storeRecord.timeSpent = timeDifferenceInMinutes;
-    }
-
-    if ( inputData.userCommands ) {
-      userRecord.userCommands = inputData.userCommands;
-      const logData = {
-        userId: req.user._id,
-        userName: req.user.userName,
-        logType: 'zoneAudit',
-        logSubType: 'auditDraft',
-        logData: {
-          auditType: inputData.auditType,
-          storeId: inputData.storeId,
-          clientName: inputData.queueName,
-          beforeCount: inputData.totalCount,
-          afterCount: inputData.customerCount,
-          auditId: inputData.auditId,
-        },
-      };
-      await insertOpenSearchData( openSearch.activityLog, logData );
-    }
-    await createAuditLog( inputData );
-    await updateOneUserAudit( userQuery, userRecord );
-    await updateOneStoreZoneAudit( storeQuery, storeRecord );
-    return res.sendSuccess( {
-      result: 'The file has been drafted successfully',
-    } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, message: req.body, function: 'saveDraft' } );
-    return res.sendError( err, 500 );
-  }
-}
-
-export async function getDraftedData( req, res ) {
-  try {
-    const inputData = req.query;
-    const userId = inputData.userId || req.user._id;
-    const query = {
-      fileDate: inputData.fileDate,
-      storeId: inputData.storeId,
-      zoneName: inputData.zoneName,
-      moduleType: 'zone',
-      userId: userId,
-    };
-    const result = await findOneAuditLog( query, {}, { createdAt: -1 }, 1 );
-
-    if ( !result ) {
-      return res.sendError( 'No Data Found', 204 );
-    }
-    return res.sendSuccess( { result: result } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( {
-      error: error,
-      message: req.query,
-      function: 'getDraftedData',
-    } );
-    return res.sendError( err, 500 );
-  }
-}
-
-export async function save( req, res ) {
-  try {
-    const bucket = JSON.parse( process.env.BUCKET );
-    const sqs = JSON.parse( process.env.SQS );
-
-    const inputData = req.body;
-    const params = {
-      Key: `${inputData.storeId}/${inputData.zoneName}/${inputData.fileDate}/${bucket.masterJsonFile}`,
-    };
-
-    if ( inputData.auditType === 'ReAudit' ) {
-      params.Bucket = bucket.auditUploadBucket;
-    } else {
-      params.Bucket = bucket.masterJson;
-    }
-    const fileData = await getJsonFileData( params );
-
-    if ( fileData?.statusCode ) {
-      logger.error( {
-        error: `ERROR IN UPLOAD PATH: ${inputData.storeId}/${inputData.zoneName}/${inputData.fileDate}/${bucket.masterJsonFile}`,
-        type: 'UPLOAD_ERROR',
-      } );
-      return res.sendError( fileData, 500 );
-    }
-
-    const masterJsonData = JSON.parse( fileData.toString( 'utf-8' ) );
-
-    const [ G20000, B20000, E0 ] = await Promise.all( [
-      splitG20000( masterJsonData.person_data ),
-      splitB20000( masterJsonData.person_data ),
-      splitE0( masterJsonData.person_data ),
-    ] );
-
-    const [ mappingData ] = await Promise.all( [
-      mapEmployee( B20000, inputData.employee ),
-      mapJunk( B20000, inputData.junk ),
-      mapCustomer( B20000, inputData.customer ),
-    ] );
-
-    const tempData = _.sortBy( [ ...mappingData, ...G20000, ...E0 ], 'index' );
-
-    const tempObject = { person_data: tempData };
-
-    const uploadDataParams = {
-      Bucket: bucket.auditUploadBucket,
-      Key: `${inputData.storeId}/${inputData.zoneName}/${inputData.fileDate}/`,
-      ContentType: 'application/json',
-      fileName: `${bucket.masterJsonFile}`,
-      body: JSON.stringify( tempObject ),
-    };
-    const mappingUpload = await fileUpload( uploadDataParams );
-
-    if ( mappingUpload?.statusCode ) {
-      logger.error( {
-        error: `ERROR IN UPLOAD PATH: ${inputData.storeId}/${inputData.zoneName}/${inputData.fileDate}/${bucket.masterJsonFile}`,
-        type: 'UPLOAD_ERROR',
-      } );
-      return res.sendError( mappingUpload, 500 );
-    }
-
-    let getUserAuditData = await findOneUserAudit( {
-      _id: inputData.auditId,
-    } );
-    const isoDate = getUserAuditData.startTime;
-    const currentTime = dayjs();
-    const isoDateTime = dayjs( isoDate );
-    const timeDifferenceInMinutes = currentTime.diff( isoDateTime, 'seconds' );
-
-    await updateOneUserAudit(
-        { _id: inputData.auditId },
-        {
-          auditStatus: 'completed',
-          endTime: Date.now(),
-          isDraft: false,
-          afterCount: inputData.customerCount,
-          timeSpent: timeDifferenceInMinutes,
-        },
-    );
-
-    /** *
-     *
-     * logs need to be added
-     *
-     *
-     */
-
-    let storeConfig = await findOneStore(
-        {
-          storeId: getUserAuditData.storeId,
-        },
-        {
-          auditConfigs: 1,
-          clientId: 1,
-        },
-    );
-    let storeAuditData = await findOneStoreZoneAudit( {
-      storeId: inputData.storeId,
-      zoneName: inputData.zoneName,
-      fileDate: inputData.fileDate,
-    } );
-
-    let clientData = await findClient( { clientId: storeConfig.clientId } );
-
-    if ( (
-      ( storeAuditData.beforeCount - inputData.customerCount ) /
-      storeAuditData.beforeCount <
-      storeConfig.auditConfigs.ratio
-    ) && inputData.auditType == 'Audit' ) {
-      logger.info(
-          `Hit in Reaudit pushing queue  Store Id=${inputData.storeId},zone Name = ${inputData.zoneName}File Date=${inputData.fileDate}, /n \nQueue Name = ${clientData[0].auditConfigs.queueName}`,
-          'Reaudit',
-      );
-
-      const sqsProduceQueue = {
-        QueueUrl: `${sqs.url}${clientData[0].auditConfigs.queueName}`,
-        MessageBody: JSON.stringify( {
-          store_id: inputData.storeId,
-          zone_id: inputData.zoneName,
-          audit_type: 'ReAudit',
-          curr_date: inputData.fileDate,
-          total_count: inputData.customerCount,
-          before_count: storeAuditData.beforeCount,
-        } ),
-      };
-      const sqsQueue = await sendMessageToQueue( sqsProduceQueue.QueueUrl, sqsProduceQueue.MessageBody );
-      logger.info( { sqsQueue: sqsQueue } );
-
-      if ( sqsQueue.statusCode ) {
-        logger.error( {
-          error: `ERROR IN UPLOAD PATH: ${inputData.storeId}/${inputData.zoneName}/${inputData.fileDate}/${bucket.masterJsonFile}`,
-          type: 'UPLOAD_ERROR',
-        } );
-        return res.sendError( mappingUpload, 500 );
-      }
-
-      await updateOneStoreZoneAudit( { storeId: inputData.storeId, zoneName: inputData.zoneName },
-          {
-            status: 'not_assign',
-            afterCount: inputData.customerCount,
-            auditType: 'ReAudit',
-            timeSpent: timeDifferenceInMinutes,
-          } );
-    } else {
-      logger.info( 'Hit in Features', { data: ( _.omit( inputData, [ 'junk', 'employee', 'customer' ] ) ) } );
-      await updateOneStoreZoneAudit( { storeId: inputData.storeId, zoneName: inputData.zoneName },
-          {
-            status: 'completed',
-            afterCount: inputData.customerCount,
-            timeSpent: timeDifferenceInMinutes,
-          } );
-
-      const sqsProduceQueue = {
-        QueueUrl: `${sqs.url}${sqs.feature}`,
-
-        MessageBody: JSON.stringify( {
-          store_id: inputData.storeId,
-          zone_id: inputData.zoneName,
-          store_date: inputData.fileDate,
-          bucket_name: `${bucket.auditUploadBucket}`,
-          process_type: 'audit',
-        } ),
-      };
-      logger.info( { sqsProduceQueue: sqsProduceQueue } );
-      const sqsQueue = await sendMessageToQueue( sqsProduceQueue.QueueUrl, sqsProduceQueue.MessageBody );
-      logger.info( { sqsQueue: sqsQueue } );
-    }
-
-    return res.sendSuccess( { result: 'Updated Successfully' } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, message: req.body, function: 'save' } );
-    return res.sendError( err, 500 );
-  }
-}
-
-export async function workSpace( req, res ) {
-  try {
-    const inputData = req.query;
-    const limit = inputData.limit || 10;
-    const offset = inputData.offset ?
-      ( inputData.offset - 1 ) * inputData.limit : 0;
-    const dateRange = await getUTC( new Date(), new Date() );
-
-    const temp = [];
-    const clientQuery = [
-      {
-        $match: {
-          $and: [
-            { status: { $in: [ 'active', 'hold' ] } },
-            { 'auditConfigs.audit': { $eq: true } }, // NOTE: modified the code need to check for enable zone
-          ],
-        },
-      },
-      {
-        $project: {
-          clientName: '$clientName',
-          clientId: '$clientId',
-        },
-      },
-    ];
-
-    if ( inputData.searchValue && inputData.searchValue !== '' ) {
-      clientQuery.push( {
-        $match: {
-          $or: [
-            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
-            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
-          ],
-        },
-      } );
-    }
-    const count = await aggregateClient( clientQuery );
-    logger.info( { count: count } );
-    if ( count?.length == 0 ) {
-      return res.sendError( 'No Data Found', 204 );
-    }
-
-    if ( inputData.limit && !inputData.isExport ) {
-      clientQuery.push( { $skip: offset }, { $limit: limit } );
-    }
-
-    const clientDetails = await aggregateClient( clientQuery );
-    const clientList = clientDetails.map( ( i ) => i.clientId );
-    // const query = [
-    //   {
-    //     $match: {
-    //       $and: [
-    //         {
-    //           clientId: { $in: clientList },
-    //         },
-    //         {
-    //           moduleType: 'zone',
-    //         },
-    //       ],
-
-    //     },
-    //   },
-    //   {
-    //     $group: {
-    //       _id: '$clientId',
-    //       clientId: { $last: '$clientId' },
-    //       totalFilesCount: { $last: '$totalFilesCount' },
-    //       clientName: { $last: '$clientName' },
-    //       queueName: { $last: '$queueName' },
-    //     },
-    //   },
-    //   {
-    //     $project: {
-    //       clientId: 1,
-    //       totalFilesCount: 1,
-    //       clientName: 1,
-    //       queueName: 1,
-    //     },
-    //   },
-    // ];
-
-    const fileDate = dayjs( dateRange.start ).subtract( 1, 'days' );
-
-    const completedFiles = [
-      {
-        $match: {
-          $and: [
-            { clientId: { $in: clientList } },
-            { fileDateISO: { $eq: new Date( fileDate ) } },
-          ],
-        },
-      },
-      {
-        $project: {
-          clientId: 1,
-          completed: {
-            $cond: [ { $eq: [ '$status', 'completed' ] }, 1, 0 ],
-          },
-        },
-      },
-      {
-        $group: {
-          _id: { clientId: '$clientId', storeId: '$storeId' },
-          clientId: { $first: '$clientId' },
-          completedCount: { $sum: '$completed' },
-        },
-      },
-      {
-        $group: {
-          _id: '$clientId',
-          clientId: { $first: '$clientId' },
-          completedCount: { $first: '$completedCount' },
-        },
-      },
-    ];
-
-    const auditFiles = [
-      {
-        $match: {
-          $and: [
-            { clientId: { $in: clientList } },
-            { moduleType: { $eq: 'zone' } },
-            { createdAt: { $gte: dateRange.start } },
-            { createdAt: { $lte: dateRange.end } },
-          ],
-        },
-      },
-      {
-        $project: {
-          clientId: 1,
-          pending: {
-            $cond: [
-              { $or: [ { $in: [ '$auditStatus', [ 'inprogress', 'drafted' ] ] } ] },
-              1,
-              0,
-            ],
-          },
-        },
-      },
-      {
-        $group: {
-          _id: { clientId: '$clientId', storeId: '$storeId' },
-          clientId: { $first: '$clientId' },
-          pendingCount: { $sum: '$pending' },
-          totalCount: { $sum: 1 },
-        },
-      },
-      {
-        $group: {
-          _id: '$clientId',
-          clientId: { $first: '$clientId' },
-          pendingCount: { $first: { $ifNull: [ '$pendingCount', 0 ] } },
-          totalCount: { $first: '$totalCount' },
-        },
-      },
-    ];
-
-    const draftedFiles = [
-      {
-        $match: {
-          $and: [
-            { clientId: { $in: clientList } },
-            { moduleType: { $eq: 'zone' } },
-            { userId: { $eq: inputData.userId } },
-            { createdAt: { $gte: dateRange.start } },
-            { createdAt: { $lte: dateRange.end } },
-          ],
-        },
-      },
-      {
-        $sort: {
-          updatedAt: -1,
-        },
-      },
-      {
-        $project: {
-          clientId: 1,
-          isDraft: 1,
-          draft: {
-            $cond: [ { $eq: [ '$auditStatus', 'drafted' ] }, 1, 0 ],
-          },
-          inprogress: {
-            $cond: [ { $eq: [ '$auditStatus', 'inprogress' ] }, 1, 0 ],
-          },
-        },
-      },
-      {
-        $group: {
-          _id: '$clientId',
-          clientId: { $first: '$clientId' },
-          isDrafted: { $first: '$isDraft' },
-          draftCount: { $sum: '$draft' },
-          inprogressCount: { $sum: '$inprogress' },
-        },
-      },
-    ];
-
-    const userAsign = [
-      {
-        $match: {
-          $and: [
-            { userId: { $eq: req.user._id } },
-            { isCompleted: false },
-            { clientId: { $in: clientList } },
-            { moduleType: { $eq: 'zone' } } ],
-        },
-      },
-      {
-        $group: {
-          _id: '$clientId',
-          clientId: { $first: '$clientId' },
-          asignedCount: { $sum: 1 },
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          clientId: 1,
-          asignedCount: 1,
-        },
-      },
-    ];
-
-    const clientAssign = [
-      {
-        $match: {
-          $and: [
-            { isCompleted: false },
-            { moduleType: { $eq: 'zone' } },
-            { clientId: { $in: clientList } },
-          ],
-        },
-      },
-      {
-        $group: {
-          _id: '$clientId',
-          clientId: { $first: '$clientId' },
-          ClientAsignedCount: { $sum: 1 },
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          clientId: 1,
-          ClientAsignedCount: { $ifNull: [ '$ClientAsignedCount', 0 ] },
-        },
-      },
-    ];
-
-    const auditDetails = [];// await aggregateAuditClientData( query );
-    const auditCount = await aggregateUserAudit( auditFiles );
-    const draftedCount = await aggregateUserAudit( draftedFiles );
-    const CompletedCount = await aggregateStoreZoneAudit( completedFiles );
-
-    const clientAssignresult = await aggregateAssignAudit( clientAssign );
-    const userAsignCount = await aggregateAssignAudit( userAsign );
-    const mergeAll = _.merge(
-        _.keyBy( clientDetails, 'clientId' ),
-        _.keyBy( auditCount, 'clientId' ),
-        _.keyBy( draftedCount, 'clientId' ),
-        _.keyBy( clientAssignresult, 'clientId' ),
-    );
-    const finalResult = _.values( mergeAll );
-    const merge = _.values(
-        _.merge(
-            _.keyBy( finalResult, 'clientId' ),
-            _.keyBy( auditDetails, 'clientId' ),
-            _.keyBy( userAsignCount, 'clientId' ),
-            _.keyBy( CompletedCount, 'clientId' ),
-        ),
-    );
-    logger.info( { merge: merge } );
-    let totalStores = 0;
-    for ( let i = 0; i < merge.length; i++ ) {
-      totalStores = totalStores + merge[i].totalFilesCount;
-
-      const pending = await listQueue( merge[i].queueName );
-
-      if ( !pending.statusCode ) {
-        temp.push( {
-          clientId: merge[i].clientId,
-          clientName: merge[i].clientName,
-          completedCount: merge[i].completedCount ?
-            Number( merge[i].completedCount ) :
-            0,
-          pendingByQueue: Number( pending ),
-          pendingByUser:
-            merge[i].pendingCount >= 0 ?
-              Number( merge[i].pendingCount ) +
-              ( merge[i].ClientAsignedCount ?
-                Number( merge[i].ClientAsignedCount ) :
-                0 ) :
-              0,
-          totalCount: merge[i].totalFilesCount,
-          queueName: merge[i].queueName,
-          isDraft: merge[i].isDrafted ? merge[i].isDrafted : false,
-          isEnable:
-            Number( pending ) > 0 ||
-              merge[i].isDrafted ||
-              ( merge[i].asignedCount && merge[i].asignedCount > 0 ) ||
-              ( merge[i].inprogressCount && merge[i].inprogressCount > 0 ) ?
-              true :
-              false,
-          completedRatio: merge[i].totalFilesCount ?
-            merge[i].completedCount ?
-              Math.round(
-                  ( Number( merge[i].completedCount ) /
-                  Number( merge[i].totalFilesCount ) ) *
-                100,
-              ) :
-              0 :
-            0,
-          isAssigned:
-            merge[i].asignedCount && merge[i].asignedCount > 0 ? true : false,
-          Assignedcount:
-            merge[i].asignedCount && merge[i].asignedCount > 0 ?
-              merge[i].asignedCount :
-              0,
-        } );
-      }
-    }
-
-    if ( inputData.isExport ) {
-      const exportdata = [];
-      temp.forEach( ( element ) => {
-        exportdata.push( {
-          'Client Name': element.clientName,
-          'Client Id': element.clientId,
-          'Completed Percentage': element.completedRatio + ' %',
-          'Pending Queue': element.pendingByQueue,
-          'Pending User': element.pendingByUser,
-          'Completed': element.completedCount,
-          'Draft': element.isDraft ? 1 : 0,
-          'Assigned': element.Assignedcount,
-        } );
-      } );
-      await download( exportdata, res );
-      return;
-    } else {
-      return res.sendSuccess( {
-        result: temp,
-        count: count.length,
-        totalStores: totalStores,
-      } );
-    }
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.info( { error: error, message: req.query, function: 'workSpace' } );
-    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.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: {
-                storeName: 1,
-              },
-            },
-          ], as: 'store',
-        },
-      },
-      {
-        $unwind: {
-          path: '$store', preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          fileDate: 1,
-          storeId: 1,
-          storeName: '$store.storeName',
-          clientName: '',
-          clientId: 1,
-          zoneName: 1,
-          userId: {
-            $arrayElemAt: [ '$userId', { $subtract: [ { $size: '$userId' }, 1 ] } ],
-          },
-          clientId: 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,
-          zoneName: 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' } },
-            { zoneName: { $regex: inputData.searchValue, $options: 'i' } },
-
-          ],
-        },
-      } );
-    }
-
-    if ( inputData.sortColumnName ) {
-      const sortBy = inputData.sortBy || -1;
-      query.push( {
-        $sort: { [inputData.sortColumName]: sortBy },
-      },
-      );
-    }
-
-    const count = await aggregateStoreZoneAudit( 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 aggregateStoreZoneAudit( 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,
-          'Zone 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 zoneAuditImages( req, res ) {
-  try {
-    const inputData = req.query;
-    let auditImageDownload = '';
-    switch ( inputData.imageType ) {
-      case 'BC':
-        const auditImageBC = await getZoneAuditImageData( inputData );
-        if ( auditImageBC?.errorCode ) {
-          const error = auditImageBC?.errorMsg;
-          const code = auditImageBC?.errorCode;
-          return res.sendError( { error: error }, code );
-        }
-
-        if ( inputData.export==true ) {
-          auditImageDownload= await zipDownloadImage( auditImageBC );
-          // Set response headers for the zip file
-          res.set( 'Content-Type', 'application/zip' );
-          res.set( 'Content-Disposition', `attachment; filename=${inputData.storeId}_${inputData.fileDate}_${inputData.imageType}_${inputData.zoneName}.zip` );
-
-          // Send the zip file as the API response
-          return res.send( auditImageDownload );
-        }
-        res.sendSuccess( { result: auditImageBC } );
-
-        break;
-
-      case 'AC':
-
-        const [ filterData, auditImageAC ] = await Promise.all( [ getZoneAuditFilterData( inputData ), getZoneAuditImageData( inputData ) ] );
-
-        if ( filterData?.errorCode || auditImageAC?.errorCode ) {
-          const error = filterData?.errorMsg || auditImageAC.errorMsg;
-          const code = filterData?.errorCode || auditImageAC.errorCode;
-          return res.sendError( { error: error }, code );
-        }
-
-        const reauditImg = await getReauditImg( filterData, auditImageAC );
-
-        logger.info( { filterData: filterData } );
-        logger.info( { auditImageAC: auditImageAC } );
-        logger.info( { reauditImg: reauditImg } );
-        if ( inputData.export==true ) {
-          auditImageDownload= await zipDownloadImage( reauditImg );
-          // Set response headers for the zip file
-          res.set( 'Content-Type', 'application/zip' );
-          res.set( 'Content-Disposition', `attachment; filename=${inputData.storeId}_${inputData.fileDate}_${inputData.imageType}.zip` );
-
-          // Send the zip file as the API response
-          return res.send( auditImageDownload );
-        }
-        res.sendSuccess( { result: reauditImg } );
-        break;
-      default:
-        res.sendError( 'No Data Found', 204 );
-        break;
-    }
-
-
-  //  return res.sendSuccess( { result: inputData } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.info( { error: error, message: req.body, function: 'beforeCountImages' } );
-    return res.sendError( err, 500 );
-  }
-}
-
-
-export async function getZoneFilterData( msg ) {
-  try {
-    const bucket = JSON.parse( process.env.BUCKET );
-    const params = {
-      Bucket: `${bucket.auditOutput}`,
-      Key: `${msg.store_id}/${inputData.zoneName}/${msg.curr_date}/${bucketName.masterJsonFile}`,
-    };
-    const mappingFile = await getJsonFileData( params );
-    if ( mappingFile.statusCode ) {
-      return mappingFile;
-    } else {
-      const mappingData = await JSON.parse( mappingFile.toString( 'utf-8' ) );
-      const filterData = await mappingData.person_data.filter(
-          ( item ) =>
-            item.temp_ids < 20000 &&
-          item.temp_ids > 0 &&
-          item.person_status === '',
-      );
-      const finalResult = await filterData.map( ( i ) => {
-        return { ...i, img: i.index.concat( '_', i.temp_ids ) };
-      } );
-      return finalResult;
-    }
-  } catch ( error ) {
-    logger.error( {
-      error: error,
-      type: 'MAPPING JSON getFilterData',
-      function: 'getZoneFilterData',
-    } );
-    return error;
-  }
-}
-
-export async function getZoneAuditImage( msg ) {
-  try {
-    const bucket = JSON.parse( process.env.BUCKET );
-    const storeId = msg.store_id;
-    const fileDate = msg.curr_date;
-    const files = [];
-    const fetchData = {};
-    fetchData.Bucket = `${bucket.auditInput}`;
-    fetchData.filePath = `${fileDate}/${storeId}/${msg.zone_id}/`;
-    const folderPath = await listFileWithoutLimit( fetchData );
-    if ( folderPath.statusCode == 404 ) {
-      return folderPath;
-    }
-    const auditImages = folderPath;
-    if ( auditImages && auditImages?.length > 0 ) {
-      for ( let i = 0; i < auditImages.length; i++ ) {
-        const img = auditImages[i].Key.split( '/' );
-        const image = img[2].split( '.' );
-        const indexes = image[0].split( '_' );
-        const params = {
-          file_path: auditImages[i].Key,
-          Bucket: fetchData.Bucket,
-        };
-        const data = await signedUrl( params );
-        const mapimg = {
-          img_path: data,
-          img_name: indexes[1],
-          img_id: image[0],
-        };
-        files.push( {
-          img_path: data,
-          img_name: indexes[1],
-          img_id: image[0],
-          selected: false,
-          dropped: false,
-          count: 1,
-          mappedid: [ mapimg ],
-        } );
-      }
-      return files;
-    }
-  } catch ( error ) {
-    logger.error( { error: error, type: 'AWS BUCKET --getAuditImage' } );
-    return error;
-  }
-}
-export async function clientMetrics( 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 } },
-      { moduleType: { $eq: 'zone' } },
-
-    ];
-    if ( inputData?.filterByClient?.length> 0 ) {
-      filter.push(
-          { clientId: { $in: inputData.filterByClient } },
-      );
-    }
-    const query = [
-      {
-        $match: {
-          $and: filter,
-        },
-      },
-      {
-        $project: {
-          fileDate: 1,
-          clientId: 1,
-          clientName: 1,
-          queueName: 1,
-          installedStore: 1,
-          totalFilesCount: 1,
-          notAssignedCount: { $ifNull: [ 0, 0 ] },
-          clientStatus: { $ifNull: [ '', '' ] },
-        },
-      },
-      {
-        $lookup: {
-          'from': 'storeZoneAudit',
-          'let': { clientId: '$clientId', fileDate: '$fileDate', totalAuditFiles: '$totalAuditFiles' },
-          'pipeline': [
-
-            {
-              $match: {
-                $expr: {
-                  $and: [
-                    { $eq: [ '$clientId', '$$clientId' ] },
-                    { $eq: [ '$fileDate', '$$fileDate' ] },
-                  ],
-                },
-              },
-            },
-            {
-              $project: {
-                completedStores: { $cond: [ { $eq: [ '$status', 'completed' ] }, 1, 0 ] },
-                notAssignedStores: { $cond: [ { $eq: [ '$status', 'not_assign' ] }, 1, 0 ] },
-                inprogressStores: { $cond: [ { $in: [ '$status', [ 'inprogress', 'drafted', 'assigned' ] ] }, 1, 0 ] },
-              },
-            },
-            {
-              $group: {
-                _id: { clientId: '$clientId', fileDate: '$fileDate' },
-                completedStores: { $sum: '$completedStores' },
-                inprogressStores: { $sum: '$inprogressStores' },
-                notAssignedStores: { $sum: '$notAssignedStores' },
-                fileCount: { $sum: 1 },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                completedStores: 1,
-                inprogressStores: 1,
-                notAssignedStores: 1,
-                fileCount: 1,
-                completionPercentage: { $ifNull: [
-                  {
-                    $round: [ {
-                      $multiply: [
-                        100, {
-                          $divide: [
-                            '$completedStores', '$$totalAuditFiles',
-                          ],
-                        },
-                      ],
-                    }, 1 ],
-
-                  },
-                  0,
-                ],
-                },
-              },
-            },
-          ], 'as': 'storeZoneAudit',
-        },
-      },
-      {
-        $unwind: {
-          path: '$storeZoneAudit',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $project: {
-          fileDate: 1,
-          clientId: 1,
-          clientName: 1,
-          totalFilesCount: 1,
-          installedStore: 1,
-          fileCount: '$storeZoneAudit.fileCount',
-          notAssignedStores: '$storeZoneAudit.notAssignedStores',
-          inprogressStoresCount: '$storeZoneAudit.inprogressStores',
-          notAssignedCount: 1,
-          clientStatus: { $cond: [ { $eq: [ '$storeZoneAudit.fileCount', 0 ] }, 'not-taken', { $cond: [ { $or: [ { $gt: [ '$notAssignedCount', 0 ] }, { $gt: [ '$storeZoneAudit.notAssignedStores', 0 ] } ] }, 'pending', 'completed' ] } ] },
-          completedStores: '$storeZoneAudit.completedStores',
-          completionPercentage: '$storeZoneAudit.completionPercentage',
-
-        },
-      },
-    ];
-
-    if ( inputData.searchValue && inputData.searchValue!== '' ) {
-      query.push( {
-        $match: {
-          $or: [
-            { clientId: { $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 },
-      },
-      );
-    }
-    logger.info( { query: query } );
-    const count = [];// await aggregateAuditClientData( 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',
-              'Client Name': '$clientName',
-              'Client Id': '$clientId',
-              'Completed Percentage': '$completionPercentage',
-              'Installed Stores': '$installedStore',
-              'Audit Stores': '$totalFilesCount',
-              'Inprogress Stores': '$inprogressStoresCount',
-              'Not Assigned': '$notAssignedCount',
-              'Not Assigned Stores': '$notAssignedStores',
-              'Completed': '$completedStores',
-              'Status': '$clientStatus',
-            },
-          },
-      );
-    }
-
-    logger.info( { query: query } );
-    const result = [];// await aggregateAuditClientData( 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 reTrigger( req, res ) {
-  try {
-    const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const inputData = req.body;
-    const sqs = JSON.parse( process.env.SQS );
-    const query ={
-      storeId: inputData.storeId,
-      fileDate: inputData.fileDate,
-      zoneName: inputData.zoneName,
-    };
-    const getQueueName = await findOneClient( { clientId: req.audit.clientId }, { 'auditConfigs': 1 } );
-    logger.info( { queueName: getQueueName.auditConfigs.zoneQueueName } );
-    if ( !getQueueName || getQueueName?.auditConfigs?.zoneQueueName == '' ) {
-      return res.sendError( 'queueName does not create', 400 );
-    }
-    const queueName = getQueueName?.auditConfigs?.zoneQueueName;
-
-    logger.info( { queueName: queueName } );
-    switch ( inputData.triggerType ) {
-      case 'queue':
-        const msg = {
-          store_id: inputData.storeId,
-          curr_date: inputData.fileDate,
-          audit_type: inputData.type,
-          total_count: inputData.totalCount,
-          zone_id: inputData.zoneName,
-        };
-
-        const sqsProduceQueue = {
-          QueueUrl: `${sqs.url}${queueName}`,
-          MessageBody: JSON.stringify( msg ),
-        };
-        const sqsQueue = await sendMessageToQueue( sqsProduceQueue.QueueUrl, sqsProduceQueue.MessageBody );
-        if ( sqsQueue?.errorCode ) {
-          const error = sqsQueue?.errorMsg;
-          const code = sqsQueue?.errorCode;
-          return res.sendError( error, code );
-        } else {
-          if ( req.audit.status !== 'completed' ) {
-            const userRecord ={
-              auditStatus: 'skipped',
-              isDraft: false,
-            };
-            const query ={
-              storeId: inputData.storeId,
-              fileDate: inputData.fileDate,
-              zoneName: inputData.zoneName,
-              auditStatus: req.audit.status,
-
-            };
-            await updateOneUserAudit( query, userRecord );
-          }
-
-          const storeRecord ={
-            status: req.audit.status !== 'completed' ? 'skipped': 'not_assign',
-          };
-
-          await updateOneStoreZoneAudit( query, storeRecord );
-          const logData = {
-            userId: req.user._id,
-            userName: req.user.userName,
-            logType: 'zoneAudit',
-            logSubType: 'reTrigger',
-            logData: {
-              beforeCount: inputData.totalCount,
-              afterCount: '',
-              fileDate: inputData.fileDate,
-              auditType: inputData.type,
-              storeId: inputData.storeId,
-              zoneName: inputData.zoneName,
-              queueName: queueName,
-              message: inputData.comments,
-              triggerBy: req.user.userName,
-              triggerId: req.user._id,
-              triggerType: inputData.triggerType,
-            },
-          };
-          await insertOpenSearchData( openSearch.activityLog, logData );
-        }
-        break;
-      case 'user':
-        const assignUser = await findOneUser( { _id: new mongoose.Types.ObjectId( inputData.userId ) } );
-        const assignUserRecord = {
-          storeId: inputData.storeId,
-          clientId: req.audit.clientId,
-          fileDate: inputData.fileDate,
-          zoneName: inputData.zoneName,
-          fileDateISO: dayjs( inputData.fileDate, 'DD-MM-YYYY' ).format(),
-          auditType: inputData.type,
-          moduleType: 'zone',
-          fileCount: inputData.beforeCount,
-          queueName: queueName,
-          userId: inputData.userId,
-          userName: assignUser.userName,
-        };
-        await createAssignAudit( assignUserRecord );
-
-        if ( req.audit.status !== 'completed' ) {
-          const userRecord ={
-            auditStatus: 'skipped',
-            isDraft: false,
-          };
-          const query ={
-            storeId: inputData.storeId,
-            fileDate: inputData.fileDate,
-            zoneName: inputData.zoneName,
-            auditStatus: req.audit.status,
-
-          };
-          await updateOneUserAudit( query, userRecord );
-        }
-
-        const storeRecord ={
-          status: req.audit.status !== 'completed' ? 'skipped': 'assigned',
-        };
-
-        await updateOneStoreZoneAudit( query, storeRecord );
-        const logData = {
-          userId: req.user._id,
-          userName: req.user.userName,
-          logType: 'zoneAudit',
-          logSubType: 'reTrigger',
-          logData: {
-            beforeCount: inputData.totalCount,
-            afterCount: '',
-            fileDate: inputData.fileDate,
-            auditType: inputData.type,
-            storeId: inputData.storeId,
-            zoneName: inputData.zoneName,
-            queueName: queueName,
-            message: inputData.comments,
-            triggerBy: req.user.userName,
-            triggerId: req.user._id,
-            triggerType: inputData.triggerType,
-          },
-        };
-        await insertOpenSearchData( openSearch.activityLog, logData );
-    }
-
-    return res.sendSuccess( { result: 'The File has been Re Trigger Succesfully' } );
-  } catch ( error ) {
-    const err = error.message;
-    logger.error( { error: error, message: req.body } );
-    return res.sendError( err, 500 );
-  }
-}
-
-export async function viewLog( req, res ) {
-  try {
-    // const inputData = req.body;
-    // const result = await
-  } catch ( error ) {
-    const err = error.message;
-    logger.error( { error: error, message: req.body, function: 'viewLog' } );
-    return res.sendError( err, 500 );
-  }
-}