tango-app-api-audit 3.3.2 → 3.4.0-alpha.1

package/index.js

@@ -1,8 +1,10 @@
 
 
 import { auditRouter } from './src/routes/audit.routes.js';
+import { traxAuditRouter } from './src/routes/traxAudit.routes.js';
 import { auditDocs } from './src/docs/audit.docs.js';
+import { traxAuditDocs } from './src/docs/traxAudit.docs.js';
 
-export { auditRouter, auditDocs };
+export { auditRouter, auditDocs, traxAuditRouter, traxAuditDocs };
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-audit",
-    "version": "3.3.2",
+    "version": "3.4.0-alpha.1",
     "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.159",
+        "tango-api-schema": "^2.1.5",
         "tango-app-api-middleware": "^3.1.33",
         "winston": "^3.13.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/traxAudit.controllers.js

@@ -0,0 +1,737 @@
+import { checkFileExist, getDate, insertOpenSearchData, listFileByPath, logger, signedUrl, sqsReceive } from 'tango-app-api-middleware';
+import { aggregateBinaryAuditModel, createBinaryAudit } from '../service/binaryAudit.service.js';
+import { findOneStore } from '../service/store.service.js';
+import { findOneUser } from '../service/user.service.js';
+
+
+export async function getDetectionAuditFile( req, res ) {
+  try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.query;
+    const data = await getDate( new Date(), new Date() );
+    logger.info( { data: data, function: 'data', newDate: new Date() } );
+    logger.info( { userId: req.user._id, queueName: inputData.queueName, moduleType: inputData.moduleType } );
+    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: inputData.moduleType },
+          ],
+        },
+      },
+      {
+        $sort: { createdAt: -1 },
+      },
+      {
+        $limit: 1,
+      },
+    ];
+
+    const userDetails = await aggregateUserAudit( userQuery );
+    logger.info( { userDetails: userDetails, function: 'userDetails' } );
+    const auditStatus =
+        userDetails && userDetails.length > 0 ? userDetails[0].auditStatus : null;
+    switch ( auditStatus ) {
+      case null:
+        const query = [
+          {
+            $match: {
+              $and: [
+                { userId: { $eq: req.user._id } },
+                { isCompleted: { $eq: false } },
+                { queueName: inputData.queueName },
+                { moduleType: inputData.moduleType },
+              ],
+            },
+          },
+        ];
+        const userAssign = await aggregateAssignAudit( query );
+        if ( userAssign.length > 0 ) {
+          logger.info( 'Hit in user assign', { inputData } );
+            userAssign[0].auditType == 'Audit' ?
+              ( msg = {
+                store_id: userAssign[0].storeId,
+                curr_date: userAssign[0].fileDate,
+                total_count: userAssign[0].fileCount,
+                zone_id: userAssign[0].zoneName,
+              } ) :
+              ( msg = {
+                store_id: userAssign[0].storeId,
+                curr_date: userAssign[0].fileDate,
+                audit_type: userAssign[0].auditType,
+                total_count: userAssign[0].fileCount,
+                zone_id: userAssign[0].zoneName,
+              } );
+            await updateOneAssignAudit(
+                { _id: userAssign[0]._id },
+                { isCompleted: true },
+            );
+            logger.info( 'Hit in auditUserAssignModel updateOne', {
+              _id: userAssign[0]._id,
+              isCompleted: true,
+            } );
+        } 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 findOneAuditLog(
+            {
+              userId: userDetails[0].userId,
+              fileDate: userDetails[0].fileDate,
+              storeId: userDetails[0].storeId,
+              totalCount: userDetails[0].beforeCount,
+              moduleType: userDetails[0].moduleType,
+              zoneName: userDetails[0].zoneName,
+            },
+            {},
+            { createdAt: -1 },
+        );
+        if ( !log ) {
+          await updateOneUserAudit(
+              { _id: userDetails[0]._id },
+              { $set: { isDraft: false, auditStatus: 'skipped' } },
+          );
+          logger.info( '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,
+          moduleType: userDetails[0].moduleType,
+          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: 'audit',
+            logSubType: 'auditStart',
+            logData: {
+              fileDate: userDetails[0].fileDate,
+              auditType: userDetails[0].auditType,
+              storeId: userDetails[0].storeId,
+              clientName: log.queueName,
+              auditId: userDetails[0]._id,
+              moduleType: userDetails[0].moduleType,
+              zoneName: userDetails[0].zoneName,
+            },
+            createdAt: new Date(),
+          };
+          logger.info( { logData: logData } );
+          await insertOpenSearchData( openSearch.auditLog, 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;
+    }
+    if ( msg.audit_type === 'ReAudit' ) {
+      logger.info( 'Hit in user ReAudit', { inputData } );
+      let reauditInsert = {};
+      const [ filterData, auditImage ] = await Promise.all( [
+        getFilterData( msg ),
+        getAuditImage( 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,
+          auditStatus: 'inprogress',
+          fileDateISO: start,
+          timeSpent: 0,
+          startTime: new Date(),
+          zoneName: msg.zone_id,
+          moduleType: inputData.moduleType,
+        };
+        const query ={
+          storeId: msg.store_id,
+          zoneName: msg.zone_id,
+          fileDate: msg.curr_date,
+          moduleType: inputData.moduleType,
+        };
+        let storeRecord = {
+          userId: req.user._id,
+          auditType: msg.audit_type || 'ReAudit',
+          status: 'inprogress',
+          timeSpent: 0,
+        };
+        reauditInsert = await createUserAudit( record );
+
+        await updateOneStoreAudit( query, 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: 'audit',
+          logSubType: 'auditStart',
+          logData: {
+            fileDate: msg.curr_date,
+            auditType: msg.audit_type,
+            storeId: msg.store_id,
+            clientName: inputData.queueName,
+            auditId: reauditInsert._id,
+            zoneName: msg.zone_id,
+            moduleType: inputData.moduleType,
+          },
+          createdAt: new Date(),
+        };
+        await insertOpenSearchData( openSearch.auditLog, 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,
+          moduleType: inputData.moduleType,
+        },
+        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;
+    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,
+          auditStatus: 'inprogress',
+          fileDateISO: start,
+          timeSpent: 0,
+          startTime: new Date(),
+          zoneName: msg.zone_id,
+          moduleType: inputData.moduleType,
+        };
+        const query ={
+          storeId: msg.store_id,
+          zoneName: msg.zone_id,
+          fileDate: msg.curr_date,
+          moduleType: inputData.moduleType,
+        };
+        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,
+          moduleType: inputData.moduleType,
+        };
+
+        insertData = await createUserAudit( record );
+        await updateManyStoreAudit( query, 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: 'audit',
+        logSubType: 'auditStart',
+        logData: {
+          fileDate: insertData.fileDate,
+          auditType: insertData.auditType,
+          storeId: storeId,
+          clientName: inputData.queueName,
+          auditId: insertData._id,
+          zoneName: msg.zone_id,
+          moduleType: inputData.moduleType,
+        },
+        createdAt: new Date(),
+      };
+      await insertOpenSearchData( openSearch.auditLog, logData );
+    }
+    logger.info( { storeInfo: storeInfo } );
+    return res.sendSuccess( {
+      result: files,
+      count: msg.total_count,
+      storeId: storeId,
+      storeName: storeInfo?.storeName,
+      address: storeInfo?.address,
+      file: {
+        queueName: inputData.queueName,
+        store_id: storeId,
+        file_date: fileDate,
+        type: 'Audit',
+        auditId: insertData._id,
+        userId: insertData.userId,
+        zoneName: msg.zone_id,
+        moduleType: inputData.moduleType,
+        nextToken: nextQuery ? encodeURIComponent( nextQuery ) : null,
+      },
+      isDraft: insertData.isDraft,
+    } );
+  } catch ( error ) {
+    logger.error( {
+      error: error,
+      message: req.query,
+      function: 'getAuditFile',
+    } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function getAuditFile( req, res ) {
+  try {
+    const inputData = req.query;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const data = await getDate( new Date(), new Date() );
+    const start = data.start;
+    const end = data.end;
+    let msg = {};
+    const userQuery = [
+      {
+        $match: {
+          $and: [
+            { userId: req.user._id },
+            { queueName: inputData.queueName },
+            { auditStatus: { $in: [ 'inprogress' ] } },
+            { createdAt: { $gte: start } },
+            { createdAt: { $lte: end } },
+            { moduleType: inputData.moduleType },
+          ],
+        },
+      },
+      {
+        $sort: { createdAt: -1 },
+      },
+      {
+        $limit: 1,
+      },
+    ];
+
+    const userDetails = await aggregateBinaryAuditModel( userQuery );
+    logger.info( { userDetails: userDetails, function: 'userDetails' } );
+    const auditStatus = userDetails && userDetails.length > 0 ? userDetails[0].auditStatus : null;
+
+    switch ( auditStatus ) {
+      case null:
+
+        logger.info( 'Hit in new file', { inputData } );
+        const consumer = await sqsReceive( inputData.queueName );
+        if ( !consumer ) {
+          logger.error( {
+            error: consumer,
+            function: `get ${inputData.moduleType} File`,
+            message: 'SQS Receive queue is empty',
+          } );
+          return res.sendError( `${inputData.queueName} is Empty`, 204 );
+        }
+        msg = JSON.parse( consumer );
+
+        break;
+
+      case 'inprogress':
+
+        msg ={
+          storeId: userDetails[0].storeId,
+          fileDate: userDetails[0].fileDate,
+          moduleType: userDetails[0].moduleType,
+          tempId: userDetails[0].tempId,
+          question: userDetails[0].question,
+          fileDetails: userDetails[0].fileDetails,
+          inputBucketName: userDetails[0].inputBucketName,
+          questionType: userDetails[0].questionType,
+          streamName: userDetails[0].streamName,
+        };
+        break;
+
+      default:
+        logger.info( 'Hit in new file', { inputData } );
+        const message = await sqsReceive( inputData.queueName );
+        if ( !message ) {
+          logger.error( {
+            error: message,
+            function: `get ${inputData.moduleType} File`,
+            message: 'SQS Receive queue is empty',
+          } );
+          return res.sendError( `${inputData.queueName} is Empty`, 204 );
+        }
+        msg = JSON.parse( message );
+        break;
+    }
+    let result =[];
+    let insertData={};
+    switch ( inputData.moduleType ) {
+      case 'camera-angle-change':
+        const actualParams ={
+          Bucket: msg.inputBucketName,
+          Key: msg.actual,
+        };
+        const changedParams ={
+          Bucket: msg.inputBucketName,
+          Key: msg.changed,
+        };
+
+        const [ isActualExists, isChangedExists ] = await Promise.all( [ checkFileExist( actualParams ), checkFileExist( changedParams ) ] );
+        result =[
+          {
+            actualCameraImage: isActualExists? await signedUrl( { Bucket: msg.inputBucketName,
+              file_path: msg.actual } ) :'',
+          },
+          {
+            changedCameraImage: isChangedExists? await signedUrl( { Bucket: msg.inputBucketName,
+              file_path: msg.changed } ) : '',
+          },
+        ];
+        break;
+      case 'unattended-customer':
+        for ( let i =0; i< msg.fileDetails.length; i++ ) {
+          const files = [];
+          const params ={
+            Bucket: msg.inputBucketName,
+            file_path: msg?.fileDetails[i]?.folderPath,
+            MaxKeys: 1000,
+          };
+          const list = await listFileByPath( params );
+          const folderPath = list.data;
+          logger.info( { folderPath: list, params: params, list: list } );
+          if ( folderPath?.length ) {
+            for ( let i = 0; i < folderPath.length; i++ ) {
+              //   const img = folderPath[i].Key.split( '/' );
+              //   const image = img[3].split( '.' );
+              //   const indexes = image[0].split( '_' );
+              const signedParams ={
+                Bucket: msg.inputBucketName,
+                file_path: folderPath[i].Key,
+              };
+              const data = await signedUrl( signedParams );
+
+              files.push(
+                  data,
+              );
+            }
+          } else {
+            logger.error( {
+              error: { folderPath: folderPath },
+              function: `getAuditFile - ${inputData.moduleType}`,
+              message: 'Bucket image data not availale',
+            } );
+            return res.sendError( 'Bucket is Empty', 204 );
+          }
+          result.push( {
+            type: msg.fileDetails[i].type,
+            file: files,
+          } );
+        }
+        break;
+      case 'left-in-middle':
+        for ( let i =0; i< msg.fileDetails.length; i++ ) {
+          const files = [];
+          const params ={
+            Bucket: msg.inputBucketName,
+            file_path: msg?.fileDetails[i]?.folderPath,
+            MaxKeys: 1000,
+          };
+          const list = await listFileByPath( params );
+          const folderPath = list.data;
+          logger.info( { folderPath: list, params: params, list: list } );
+          if ( folderPath?.length ) {
+            for ( let i = 0; i < folderPath.length; i++ ) {
+              //   const img = folderPath[i].Key.split( '/' );
+              //   const image = img[3].split( '.' );
+              //   const indexes = image[0].split( '_' );
+              const signedParams ={
+                Bucket: msg.inputBucketName,
+                file_path: folderPath[i].Key,
+              };
+              const data = await signedUrl( signedParams );
+
+              files.push(
+                  data,
+              );
+            }
+          } else {
+            logger.error( {
+              error: { folderPath: folderPath },
+              function: `getAuditFile - ${inputData.moduleType}`,
+              message: 'Bucket image data not availale',
+            } );
+            return res.sendError( 'Bucket is Empty', 204 );
+          }
+          result.push( {
+            type: msg.fileDetails[i].type,
+            file: files,
+          } );
+        }
+        break;
+      default:
+        return res.sendError( 'Please given valid moduleType', 400 );
+    }
+
+
+    const storeQuery = {
+      storeId: msg.storeId,
+    };
+    const storeFields = {
+      'storeName': 1,
+      'storeProfile.address': 1,
+      'clientId': 1,
+    };
+    const storeInfo = await findOneStore( storeQuery, storeFields );
+
+    if ( userDetails.length === 0 ) {
+      const [ day, month, year ] = msg.fileDate.split( '-' );
+      const temp = `${year}-${month}-${day}`;
+      let start = new Date( temp );
+      logger.info( { start: start, date: msg.fileDate } );
+      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.storeId,
+        clientId: storeInfo?.clientId,
+        fileDate: msg.fileDate,
+        queueName: inputData.queueName,
+        auditStatus: 'inprogress',
+        fileDateISO: start,
+        timeSpent: 0,
+        startTime: new Date(),
+        tempId: msg.tempId,
+        fileDetails: msg.fileDetails,
+        moduleType: inputData.moduleType,
+        inputBucketName: msg.inputBucketName,
+        question: msg.question,
+        questionType: msg.questionType,
+        streamName: msg.streamName,
+      };
+      record.streamName = inputData.moduleType == 'camera-angle-change'? msg.streamName : '';
+      record.videoDetails = inputData.moduleType == 'left-in-middle'? {
+        'startHour': msg.startHour,
+        'inspectHour': msg.inspectHour,
+        'endHour': msg.endHour,
+        'startHourCount': msg.startHourCount,
+        'inspectHourCount': msg.inspectHourCount,
+        'endHourCount': msg.inspectHourCount,
+      } : {};
+      insertData = await createBinaryAudit( record );
+    } else {
+      insertData = userDetails[0];
+    }
+
+    const userdata = await findOneUser( { _id: insertData.userId } );
+
+
+    const logData = {
+      userId: insertData.userId,
+      userName: userdata.name,
+      logType: 'audit',
+      logSubType: 'auditStart',
+      data: {
+        fileDate: msg.fileDate,
+        storeId: msg.storeId,
+        clientId: storeInfo?.clientId,
+        tempId: msg.tempId,
+        value: msg.value,
+        auditId: insertData._id,
+        fileDetails: msg.fileDetails,
+        moduleType: inputData.moduleType,
+        question: msg.question,
+        questionType: msg.questionType,
+        streamName: msg.streamName,
+      },
+      createdAt: new Date(),
+    };
+    await insertOpenSearchData( openSearch.auditLog, logData );
+
+    return res.sendSuccess( {
+      result: result,
+      storeId: msg.storeId,
+      storeName: storeInfo?.storeName,
+      address: storeInfo?.address,
+      customerId: msg.tempId,
+      moduleType: inputData.moduleType,
+      value: inputData.moduleType == 'left-in-middle'? 'Employee Left in Middle ' : ( inputData.moduleType ).split( '-' ).join( ' ' ),
+      fileDate: msg.fileDate,
+      question: msg.question,
+      questionType: msg.questionType,
+      streamName: msg.streamName,
+    } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, data: req.query, function: 'getAuditFile' } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/docs/traxAudit.docs.js

@@ -0,0 +1,46 @@
+import j2s from 'joi-to-swagger';
+import { getFileSchema } from '../dtos/traxAudit.dtos.js';
+
+export const traxAuditDocs = {
+
+  '/v3/trax-audit/get-file': {
+    get: {
+      tags: [ 'Trax Audit' ],
+      description: 'Get a file via queue message',
+      operationId: 'get-file',
+      parameters: [
+        {
+          in: 'query',
+          name: 'queueName',
+          scema: j2s( getFileSchema ).swagger,
+          require: true,
+        },
+        // {
+        //   in: 'query',
+        //   name: 'nextId',
+        //   scema: j2s( getFileSchema ).swagger,
+        //   require: false,
+        // },
+        // {
+        //   in: 'query',
+        //   name: 'limit',
+        //   scema: j2s( getFileSchema ).swagger,
+        //   require: false,
+        // },
+        {
+          in: 'query',
+          name: 'moduleType',
+          scema: j2s( getFileSchema ).swagger,
+          require: true,
+        },
+      ],
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+};

package/src/dtos/traxAudit.dtos.js

@@ -0,0 +1,105 @@
+import joi from 'joi';
+/*           < -- *** Audit  Mapping ***   -->      */
+
+export const getFileSchema = joi.object(
+    {
+      queueName: joi.string().required(),
+      moduleType: joi.string().required(),
+    },
+);
+
+export const getFileValid = {
+  query: getFileSchema,
+};
+
+export const getDetectionFileSchema = joi.object( {
+  queueName: joi.string().required(),
+  nextId: joi.string().optional().allow( '' ),
+  limit: joi.number().optional(),
+  moduleType: joi.string().required(),
+} );
+
+export const getDetectionFileValid = {
+  query: getDetectionFileSchema,
+};
+
+export const saveDraftSchema = joi.object(
+    {
+      userCommands: joi.string().optional().allow( '' ),
+      storeId: joi.string().required(),
+      auditId: joi.string().required(),
+      moduleType: joi.string().required(),
+      zoneName: joi.string().required(),
+      auditType: joi.string().required(),
+      fileDate: joi.string().required(),
+      queueName: joi.string().required(),
+      totalCount: joi.number().required(),
+      junkCount: joi.number().optional(),
+      junk: joi.array().optional(),
+      employeeCount: joi.number().optional(),
+      employee: joi.array().optional(),
+      customerCount: joi.number().optional(),
+      customer: joi.array().optional(),
+      retagCount: joi.number().optional(),
+      retagImage: joi.array().optional(),
+    },
+);
+
+export const saveDraftValid = {
+  body: saveDraftSchema,
+};
+
+export const getDraftedDataSchema = joi.object(
+    {
+      storeId: joi.string().required(),
+      fileDate: joi.string().required(),
+      userId: joi.string().optional(),
+      moduleType: joi.string().required(),
+      zoneName: joi.string().required(),
+    },
+);
+
+export const getDraftedDataValid = {
+  query: getDraftedDataSchema,
+};
+
+export const saveSchema = joi.object(
+    {
+      auditId: joi.string().required(),
+      storeId: joi.string().required(),
+      fileDate: joi.string().required(),
+      auditType: joi.string().required(),
+      moduleType: joi.string().required(),
+      zoneName: joi.string().required(),
+      beforeCount: joi.number().required(),
+      junkCount: joi.number().required(),
+      junk: joi.array().required(),
+      employeeCount: joi.number().required(),
+      employee: joi.array().required(),
+      customerCount: joi.number().required(),
+      customer: joi.array().required(),
+      moduleType: joi.string().required(),
+      zoneName: joi.string().required(),
+    },
+);
+
+export const saveValid = {
+  body: saveSchema,
+};
+
+export const workSpaceSchema = joi.object(
+    {
+      searchValue: joi.string().optional().allow( '' ),
+      moduleType: joi.string().required(),
+      clientId: joi.array().optional(),
+      offset: joi.number().optional(),
+      limit: joi.number().optional(),
+      isExport: joi.boolean().optional(),
+      sortColumnName: joi.string().optional(),
+      sortBy: joi.number().optional(),
+    },
+);
+
+export const workSpaceValid = {
+  body: workSpaceSchema,
+};

package/src/routes/traxAudit.routes.js

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
+import { getDetectionFileValid, getFileValid } from '../dtos/traxAudit.dtos.js';
+import { isExistsQueue } from '../validation/audit.validation.js';
+import { getAuditFile, getDetectionAuditFile } from '../controllers/traxAudit.controllers.js';
+
+export const traxAuditRouter = Router();
+
+// Audit Mapping
+traxAuditRouter.get( '/get-file', isAllowedSessionHandler, validate( getFileValid ), isExistsQueue, getAuditFile );
+traxAuditRouter.get( '/get-file', isAllowedSessionHandler, validate( getDetectionFileValid ), isExistsQueue, getDetectionAuditFile );
+// traxAuditRouter.post( '/save-draft', isAllowedSessionHandler, validate( saveDraftValid ), saveDraft );
+// traxAuditRouter.get( '/get-drafted-data', isAllowedSessionHandler, validate( getDraftedDataValid ), getDraftedData );
+// traxAuditRouter.post( '/save', isAllowedSessionHandler, validate( saveValid ), validateUserAudit, save );
+// traxAuditRouter.post( '/work-space', isAllowedSessionHandler, validate( workSpaceValid ), workSpace );
+
+export default traxAuditRouter;

package/src/service/binaryAudit.service.js

@@ -0,0 +1,10 @@
+import binaryAuditModel from 'tango-api-schema/schema/binaryAudit.model.js';
+
+
+export function createBinaryAudit( record ) {
+  return binaryAuditModel.create( record );
+}
+
+export function aggregateBinaryAuditModel( query ) {
+  return binaryAuditModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
+}

package/src/service/userEmpDetection.service.js

@@ -0,0 +1,6 @@
+import userEmpDetectionModel from 'tango-api-schema/schema/userEmpDetection.model.js';
+
+
+export function aggregateUserAudit( query ) {
+  return userEmpDetectionModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
+}