tango-app-api-audit 1.0.43 → 1.0.44

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-audit",
-    "version": "1.0.43",
+    "version": "1.0.44",
     "description": "audit & audit metrics apis",
     "main": "index.js",
     "type": "module",
@@ -24,7 +24,7 @@
         "mongodb": "^6.7.0",
         "nodemon": "^3.1.3",
         "swagger-ui-express": "^5.0.1",
-        "tango-api-schema": "^2.0.144",
+        "tango-api-schema": "^2.0.146",
         "tango-app-api-middleware": "^3.1.28",
         "winston": "^3.13.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/audit.controllers.js

@@ -210,7 +210,7 @@ export async function getAuditFile( req, res ) {
           address: '$storeProfile.address',
         };
         const storeDetails = await findOneStore( storeQuery, storeFields );
-        return res.sendSuccess( {
+        res.sendSuccess( {
           result: result,
           storeId: storeDetails?.storeId,
           storeName: storeDetails?.storeName,

package/src/controllers/zoneAudit.controller.js

@@ -1,5 +1,5 @@
-import { download, fileUpload, getJsonFileData, getUTC, insertOpenSearchData, listFileByPath, sendMessageToQueue, signedUrl, sqsReceive } from 'tango-app-api-middleware';
-import { aggregateZoneUserAudit, createZoneUserAudit, findOneZoneUserAudit } from '../service/zoneUserAudit.service.js';
+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 { aggregateAssignZoneAudit } from '../service/assignZoneAudit.service.js';
 import { aggregateStoreZoneAudit, createStoreZoneAudit, findOneStoreZoneAudit, updateOneStoreZoneAudit } from '../service/storeZoneAudit.service.js';
@@ -9,11 +9,13 @@ 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 } from '../validation/audit.validation.js';
+import { getZoneAuditImageData, mapCustomer, mapEmployee, mapJunk, splitB20000, splitE0, splitG20000, zipDownloadImage } from '../validation/audit.validation.js';
 import { aggregateClient, findClient, findOneClient } from '../service/client.service.js';
 import { aggregateAuditClientData } from '../service/auditClientData.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';
 
 export async function getZoneAuditFile( req, res ) {
   try {
@@ -88,21 +90,100 @@ export async function getZoneAuditFile( req, res ) {
         }
         break;
 
-        // case 'drafted':
-        //   logger.info( 'userDetails drafted', { inputData } );
+      case 'drafted':
+        logger.info( 'userDetails drafted', { inputData } );
 
-        //   const log = await findOneAuditLog(
-        //       {
-        //         userId: userDetails[0].userId,
-        //         fileDate: userDetails[0].fileDate,
-        //         storeId: userDetails[0].storeId,
-        //         totalCount: userDetails[0].beforeCount,
+        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,
+        };
 
-        //       },
-        //       {},
-        //       { createdAt: -1 },
-        //   );
+        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 = {
@@ -119,6 +200,104 @@ export async function getZoneAuditFile( req, res ) {
      * 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;
@@ -233,6 +412,7 @@ export async function getZoneAuditFile( req, res ) {
           storeId: storeId,
           clientName: inputData.queueName,
           auditId: insertData._id,
+          zoneName: msg.zone_id,
         },
       };
       await insertOpenSearchData( openSearch.activityLog, logData );
@@ -964,6 +1144,7 @@ export async function storeMetrics( req, res ) {
           storeName: '$store.storeName',
           clientName: '',
           clientId: 1,
+          zoneName: 1,
           userId: {
             $arrayElemAt: [ '$userId', { $subtract: [ { $size: '$userId' }, 1 ] } ],
           },
@@ -1042,6 +1223,7 @@ export async function storeMetrics( req, res ) {
           _id: 0,
           fileDate: 1,
           storeId: 1,
+          zoneName: 1,
           storeName: '$stores.storeName',
           userName: '$users.userName',
           userEmail: '$users.userEmail',
@@ -1099,6 +1281,8 @@ export async function storeMetrics( req, res ) {
             { userName: { $regex: inputData.searchValue, $options: 'i' } },
             { status: { $regex: inputData.searchValue, $options: 'i' } },
             { auditType: { $regex: inputData.searchValue, $options: 'i' } },
+            { zoneName: { $regex: inputData.searchValue, $options: 'i' } },
+
           ],
         },
       } );
@@ -1137,6 +1321,7 @@ export async function storeMetrics( req, res ) {
           '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,
@@ -1156,6 +1341,152 @@ export async function storeMetrics( req, res ) {
   }
 }
 
+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( [ getAuditFilterData( inputData ), getAuditImageData( 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;
@@ -1348,12 +1679,13 @@ export async function reTrigger( req, res ) {
       storeId: inputData.storeId,
       fileDate: inputData.fileDate,
     };
-    const getQueueName = await findOneClient( { clientId: req.audit.clientId }, { 'auditConfigs.zoneQueueName': 1 } );
-
+    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':

package/src/docs/zoneAudit.docs.js

@@ -1,5 +1,5 @@
 import j2s from 'joi-to-swagger';
-import { clientMetricsSchema, getDraftedDataSchema, getFileSchema, reTriggerValidSchema, saveDraftSchema, saveSchema, storeMetricsSchema, workSpaceSchema } from '../dtos/zoneAudit.dtos.js';
+import { clientMetricsSchema, getDraftedDataSchema, getFileSchema, saveDraftSchema, saveSchema, storeMetricsSchema, workSpaceSchema, zoneAuditImageValidSchema, reTriggerValidSchema } from '../dtos/zoneAudit.dtos.js';
 
 export const zoneAuditDocs = {
   '/v3/zone-audit/get-file': {
@@ -179,26 +179,66 @@ export const zoneAuditDocs = {
     },
   },
 
-  '/v3/zone-audit/metrics/client-metrics': {
-    post: {
-      tags: [ 'Zone Audit Metrics' ],
-      description: `Get list of client wise details with date range`,
-      operationId: 'metrics/client-metrics',
-      parameters: {},
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: j2s( clientMetricsSchema ).swagger,
+  '/v3/zone-audit/metrics/audit-images': {
+    get: {
+      'tags': [ 'Zone Audit Metrics' ],
+      'description': `View and Download audit images`,
+      'operationId': 'zone audit-images',
+      'parameters': [
+        {
+          in: 'query',
+          name: 'fileDate',
+          scema: j2s( zoneAuditImageValidSchema ).swagger,
+          require: true,
+        },
+        {
+          in: 'query',
+          name: 'storeId',
+          scema: j2s( zoneAuditImageValidSchema ).swagger,
+          require: true,
+        },
+        {
+          in: 'query',
+          name: 'imageType',
+          scema: j2s( zoneAuditImageValidSchema ).swagger,
+          require: true,
+        },
+        {
+          in: 'query',
+          name: 'export',
+          scema: j2s( zoneAuditImageValidSchema ).swagger,
+          require: true,
+        },
+        {
+          in: 'query',
+          name: 'zoneName',
+          scema: j2s( zoneAuditImageValidSchema ).swagger,
+          require: true,
+        },
+      ],
+
+      '/v3/zone-audit/metrics/client-metrics': {
+        post: {
+          tags: [ 'Zone Audit Metrics' ],
+          description: `Get list of client wise details with date range`,
+          operationId: 'metrics/client-metrics',
+          parameters: {},
+          requestBody: {
+            content: {
+              'application/json': {
+                schema: j2s( clientMetricsSchema ).swagger,
+              },
+            },
+          },
+          responses: {
+            200: { description: 'Successful' },
+            401: { description: 'Unauthorized User' },
+            422: { description: 'Field Error' },
+            500: { description: 'Server Error' },
+            204: { description: 'Not Found' },
           },
         },
       },
-      responses: {
-        200: { description: 'Successful' },
-        401: { description: 'Unauthorized User' },
-        422: { description: 'Field Error' },
-        500: { description: 'Server Error' },
-        204: { description: 'Not Found' },
-      },
     },
   },
 

package/src/dtos/zoneAudit.dtos.js

@@ -108,6 +108,19 @@ export const storeMetricsValid = {
   body: storeMetricsSchema,
 };
 
+export const zoneAuditImageValidSchema = joi.object(
+    {
+      fileDate: joi.string().required(),
+      storeId: joi.string().required(),
+      imageType: joi.string().required(),
+      export: joi.boolean().required(),
+      zoneName: joi.string().required(),
+    },
+);
+
+export const zoneAuditImageValid = {
+  query: zoneAuditImageValidSchema,
+};
 export const clientMetricsSchema = joi.object(
     {
       fromDate: joi.string().required(),

package/src/routes/zone.routes.js

@@ -1,9 +1,9 @@
 import { Router } from 'express';
-import { clientMetricsValid, getDraftedDataValid, getFileValid, reTriggerValid, saveDraftValid, saveValid, storeMetricsValid, workSpaceValid } from '../dtos/zoneAudit.dtos.js';
-import { isExistsQueue, validateUserAudit } from '../validation/audit.validation.js';
+import { clientMetricsValid, getDraftedDataValid, getFileValid, reTriggerValid, saveDraftValid, saveValid, workSpaceValid, zoneAuditImageValid } from '../dtos/zoneAudit.dtos.js';
+import { isAuditDocumentExist, isAuditInputFolderExist, isExistsQueue, isZoneAuditInputFolderExist, validateUserAudit } from '../validation/audit.validation.js';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { clientMetrics, getDraftedData, getZoneAuditFile, reTrigger, save, saveDraft, storeMetrics, workSpace } from '../controllers/zoneAudit.controller.js';
-import { isAuditDocumentExist, isAuditInputFolderExist } from '../validation/zoneAudit.validation.js';
+import { clientMetrics, getDraftedData, getZoneAuditFile, reTrigger, save, saveDraft, storeMetrics, workSpace, zoneAuditImages } from '../controllers/zoneAudit.controller.js';
+import { storeMetricsValid } from '../dtos/auditMetrics.dtos.js';
 
 export const zoneAuditRouter=Router();
 
@@ -17,5 +17,6 @@ zoneAuditRouter.get( '/work-space', isAllowedSessionHandler, validate( workSpace
 // metrics
 
 zoneAuditRouter.post( '/metrics/store-metrics', isAllowedSessionHandler, validate( storeMetricsValid ), storeMetrics );
+zoneAuditRouter.get( '/metrics/audit-images', isAllowedSessionHandler, validate( zoneAuditImageValid ), isZoneAuditInputFolderExist, zoneAuditImages );
 zoneAuditRouter.post( '/metrics/client-metrics', isAllowedSessionHandler, validate( clientMetricsValid ), clientMetrics );
 zoneAuditRouter.post( '/metrics/re-trigger', isAllowedSessionHandler, validate( reTriggerValid ), isAuditDocumentExist, isAuditInputFolderExist, reTrigger );

package/src/validation/audit.validation.js

@@ -329,3 +329,90 @@ export async function getAuditFilterData( data ) {
   }
 }
 
+// zone
+export async function isZoneAuditInputFolderExist( req, res, next ) {
+  try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const inputData = req.method === 'POST' ? req.body : req.query;
+    const params={
+      Bucket: bucket.auditInput,
+      Key: `${inputData.fileDate}/${inputData.storeId}/${inputData.zoneName}`,
+    };
+    const isExist = await checkFileExist( params );
+    if ( isExist ) {
+      next();
+    } else {
+      return res.sendError( `Audit Input folder not available : ${inputData.fileDate}/${inputData.storeId}`, 400 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'isAuidtInputFolderExist' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function getZoneAuditImageData( data ) {
+  try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const storeId = data.storeId;
+    const fileDate = data.fileDate;
+    const files = [];
+    const fetchData = {
+      Bucket: `${bucket.auditInput}`,
+      filePath: `${fileDate}/${storeId}/${data.zoneName}/`,
+    };
+
+    const folderPath = await listFileWithoutLimit( fetchData );
+    if ( folderPath.statusCode == 404 ) {
+      return folderPath;
+    }
+    const auditImages = folderPath;
+
+    if ( data.export==false ) {
+      if ( auditImages && auditImages?.length > 0 ) {
+        for ( let i = 0; i < auditImages.length; i++ ) {
+          const img = auditImages[i].Key.split( '/' );
+          const image = img[3].split( '.' );
+          const indexes = image[0].split( '_' );
+          const params = {
+            file_path: auditImages[i].Key,
+            Bucket: fetchData.Bucket,
+          };
+          const data = await signedUrl( params );
+          files.push( {
+            imgPath: data,
+            imgName: indexes[1],
+            imgId: image[0],
+            img_name: indexes[1],
+            // imgFile: auditImages[i],
+          } );
+        }
+        return files;
+      }
+    } else {
+      if ( auditImages && auditImages?.length > 0 ) {
+        for ( let i = 0; i < auditImages.length; i++ ) {
+          const img = auditImages[i].Key.split( '/' );
+          const image = img[3].split( '.' );
+          const indexes = image[0].split( '_' );
+          const params = {
+            file_path: auditImages[i].Key,
+            Bucket: fetchData.Bucket,
+          };
+          const data = await signedUrl( params );
+          files.push( {
+            imgPath: data,
+            imgName: indexes[1],
+            imgId: image[0],
+            imgFile: auditImages[i],
+            img_name: indexes[1],
+          } );
+        }
+        return files;
+      }
+    }
+  } catch ( error ) {
+    logger.error( { error: error, type: 'getAuditImageData' } );
+    return error;
+  }
+}