tango-app-api-audit 3.4.3-alpha.1 → 3.4.3-alpha.11

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-audit",
-    "version": "3.4.3-alpha.1",
+    "version": "3.4.3-alpha.11",
     "description": "audit & audit metrics apis",
     "main": "index.js",
     "type": "module",

package/src/controllers/audit.controllers.js

@@ -9,6 +9,7 @@ import {
   signedUrl,
   getDate, getDateWithCustomizeTime,
   getUTC,
+  getOpenSearchData,
 } from 'tango-app-api-middleware';
 import {
   aggregateUserAudit,
@@ -63,6 +64,7 @@ import { aggregateStoreEmpDetection } from '../service/storeEmpDetection.service
 import { aggregateBinaryAudit } from '../service/binaryAudit.service.js';
 import { aggregateTraxAuditData, findOneTraxAuditData } from '../service/traxAuditData.service.js';
 import { createAuditUserWallet } from '../service/auditUserWallet.service.js';
+import { aggregateAuditUsers } from '../service/auditUsers.service.js';
 
 /*           < -- *** Configuration ***   -->      */
 
@@ -3567,6 +3569,43 @@ export async function totalNotAssignedCount( req, res ) {
         },
       },
     ];
+
+    const mappingInprogressCount = [
+      {
+        $match: {
+          fileDate: { $eq: latestTraxDate },
+        },
+      },
+      {
+        $project: {
+          inprogressAuditCount: {
+            $cond: [
+              { $in: [ '$status', [ 'completed', 'not_assign', 'skipped' ] ] }, 1, 0,
+            ],
+          },
+          inprogressTraxCount: {
+            $cond: [
+              { $and: [ { $in: [ '$status', [ 'completed', 'not_assign', 'skipped' ] ] } ] }, 1, 0,
+            ],
+          },
+
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          inprogressAuditCount: { $sum: '$inprogressAuditCount' },
+          inprogressTraxCount: { $sum: '$inprogressTraxCount' },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          inprogressAuditCount: { $ifNull: [ '$inprogressAuditCount', 0 ] },
+          inprogressTraxCount: { $ifNull: [ '$inprogressTraxCount', 0 ] },
+        },
+      },
+    ];
     // const binaryInprogressCount=[
     //   {
     //     $match: {
@@ -3651,6 +3690,8 @@ export async function totalNotAssignedCount( req, res ) {
     const getTotalTraxAudit = await aggregateTraxAuditData( traxQuery );
     const getInprogressCount = await aggregateStoreAudit( inprogressCount );
     const getBinaryInprogressCount = await aggregateBinaryAudit( binaryInprogressCount );
+    const getMappingInprogressCount = await aggregateStoreEmpDetection( mappingInprogressCount );
+    logger.info( { getMappingInprogressCount: getMappingInprogressCount } );
     // const getMappingInprogressCount = await aggregateStoreEmpDetection( mappingInprogressCount );
     if ( getTotalcount.length == 0 && getTotalTraxAudit.length == 0 ) {
       return res.sendError( 'No Data Found', 204 );
@@ -3671,6 +3712,12 @@ export async function totalNotAssignedCount( req, res ) {
     } else {
       notAssignedCount.totalTraxAuditCount = getTotalTraxAudit[0]?.totalTraxAuditCount;
     }
+
+    if ( getMappingInprogressCount.length > 0 ) {
+      notAssignedCount.totalTraxAuditCount = getTotalTraxAudit[0].totalTraxAuditCount > getMappingInprogressCount[0].inprogressTraxCount ? getTotalTraxAudit[0].totalTraxAuditCount - getMappingInprogressCount[0].inprogressTraxCount : 0;
+    } else {
+      notAssignedCount.totalTraxAuditCount = getTotalTraxAudit[0]?.totalTraxAuditCount;
+    }
     return res.sendSuccess( { result: notAssignedCount } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
@@ -3759,12 +3806,39 @@ export async function getUserAuditCount( req, res ) {
     const beforeCountX = userWallet.beforeCountCreditPerc; // 0.0335;
     const afterCountY = userWallet.afterCountCreditPerc; // 0.0035;
     const reduce = userWallet.reductionPerc; // 0.05;
+    const auditUserQuery=[
+      {
+        $match: {
+          $and: [
+            { type: { $eq: 'consultant' } },
+            { isActive: { $eq: true } },
+          ],
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          userList: { $push: '$userId' },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          userList: 1,
+        },
+      },
+    ];
+    const auditUserList = await aggregateAuditUsers( auditUserQuery );
+    if ( auditUserList.length==0 ) {
+      return res.sendError( 'No users available', 204 );
+    }
     const userCountQuery= [
       {
         $match: {
           $and: [
             { fileDate: { $eq: fileDate } },
             { auditStatus: { $eq: 'completed' } },
+            { userId: { $in: auditUserList[0].userList } },
           ],
         },
       },
@@ -3847,6 +3921,7 @@ export async function getUserAuditCount( req, res ) {
             {
               auditStatus: { $eq: 'completed' },
             },
+            { userId: { $in: auditUserList[0].userList } },
           ],
         },
       },
@@ -3866,6 +3941,8 @@ export async function getUserAuditCount( req, res ) {
           totalEarn: { $ifNull: [ 0, 0 ] },
           totalReducedAmount: { $ifNull: [ 0, 0 ] },
           totalCredit: { $ifNull: [ 0, 0 ] },
+          deductionBytimeSpent: { $ifNull: [ 0, 0 ] },
+          deductionByMinimumTarget: { $ifNull: [ 0, 0 ] },
         },
       },
       {
@@ -3883,6 +3960,8 @@ export async function getUserAuditCount( req, res ) {
           totalEarn: { $first: '$totalEarn' },
           totalReducedAmount: { $first: '$totalReducedAmount' },
           totalCredit: { $first: '$totalCredit' },
+          deductionByMinimumTarget: { $first: '$deductionByMinimumTarget' },
+          deductionBytimeSpent: { $first: '$deductionBytimeSpent' },
         },
       },
       {
@@ -3899,6 +3978,9 @@ export async function getUserAuditCount( req, res ) {
           totalEarn: { $add: [ { $multiply: [ '$totalBeforeCount', beforeCountX ] }, { $multiply: [ '$totalAfterCount', afterCountY ] } ] },
           totalReducedAmount: 1,
           totalCredit: 1,
+          deductionBytimeSpent: 1,
+          deductionByMinimumTarget: 1,
+
 
         },
       },
@@ -3910,13 +3992,27 @@ export async function getUserAuditCount( req, res ) {
           totalBeforeCount: 1,
           totalAfterCount: 1,
           totalTimeSpent: 1,
+          hours: { $floor: { $divide: [ '$totalTimeSpent', 3600 ] } },
+          minutes: {
+            $floor: {
+              $divide: [
+                { $mod: [ '$totalTimeSpent', 3600 ] }, // Get remaining minutes after hours
+                60,
+              ] },
+          },
           fileDate: 1,
           fileDateISO: 1,
           minimumTarget: 1,
           totalEarn: 1,
-          totalReducedAmount: { $cond: [
+          deductionBytimeSpent: { $cond: [
             { $lt: [ '$totalTimeSpent', configTimeSpentSec ] },
-            { $add: [ '$totalReducedAmount', { $multiply: [ reduce, '$totalEarn' ] } ] }, '$totalReducedAmount',
+            { $multiply: [ reduce, '$totalEarn' ] }, '$deductionBytimeSpent',
+          ] },
+
+          deductionByMinimumTarget:
+          { $cond: [
+            { $lt: [ '$totalBeforeCount', '$minimumTarget' ] },
+            { $multiply: [ reduce, '$totalEarn' ] }, '$deductionByMinimumTarget',
           ] },
           totalCredit: { $subtract: [ '$totalEarn', '$totalReducedAmount' ] },
 
@@ -3930,18 +4026,33 @@ export async function getUserAuditCount( req, res ) {
           moduleType: 1,
           totalBeforeCount: 1,
           totalAfterCount: 1,
-          totalTimeSpent: 1,
+          totalTimeSpent: {
+            $cond: [ { $eq: [ '$hours', 0 ] },
+              { $concat: [
+                { $toString: '$minutes' }, ' minutes',
+              ] },
+              { $cond: [ { $eq: [ '$minutes', 0 ] },
+                { $concat: [
+                  { $toString: '$hours' }, ' hours',
+                ] },
+                {
+                  $concat: [
+                    { $toString: '$hours' }, ' hours and ',
+                    { $toString: '$minutes' }, ' minutes',
+                  ],
+                },
+              ] },
+            ],
+
+          },
           fileDate: 1,
           fileDateISO: 1,
           minimumTarget: 1,
           totalEarn: { $add: [ { $multiply: [ '$totalBeforeCount', beforeCountX ] }, { $multiply: [ '$totalAfterCount', afterCountY ] } ] },
-          totalReducedAmount:
-            { $cond: [
-              { $lt: [ '$totalBeforeCount', '$minimumTarget' ] },
-              { $add: [ '$totalReducedAmount', { $multiply: [ reduce, '$totalEarn' ] } ] }, '$totalReducedAmount',
-            ] },
-
+          deductionByMinimumTarget: 1,
+          deductionBytimeSpent: 1,
           totalCredit: { $subtract: [ '$totalEarn', '$totalReducedAmount' ] },
+          totalReducedAmount: { $round: [ { $add: [ '$deductionBytimeSpent', '$deductionByMinimumTarget' ] }, 2 ] },
         },
       },
       {
@@ -3973,10 +4084,12 @@ export async function getUserAuditCount( req, res ) {
           moduleType: 1,
           totalAfterCount: { $round: [ '$totalAfterCount', 2 ] },
           totalBeforeCount: { $round: [ '$totalBeforeCount', 2 ] },
-          timeSpent: { $round: [ '$totalTimeSpent', 2 ] },
+          timeSpent: '$totalTimeSpent',
           fileDate: 1,
           fileDateISO: 1,
-          totalReducedAmount: { $round: [ '$totalReducedAmount', 2 ] },
+          deductionByMinimumTarget: { $round: [ '$deductionByMinimumTarget', 2 ] },
+          deductionBytimeSpent: { $round: [ '$deductionBytimeSpent', 2 ] },
+          totalReducedAmount: 1,
           totalCredit: { $round: [ { $subtract: [ '$totalEarn', '$totalReducedAmount' ] }, 2 ] },
           totalEarn: { $round: [ '$totalEarn', 2 ] },
           minimumTarget: 1,
@@ -4302,3 +4415,39 @@ export async function getUserAuditCountMTD( req, res ) {
   }
 }
 
+export async function auditViewLogs( req, res ) {
+  try {
+    const inputData = req.query;
+    const parsedOpenSearch = JSON.parse( process.env.OPENSEARCH );
+    let downTimeQuery = {
+      'size': 100,
+      'query': {
+        'bool': {
+          'must': [
+            {
+              'term': {
+                'doc.logData.fileDate.keyword': dayjs( inputData.fileDate ).format( 'DD-MM-YYYY' ),
+              },
+            },
+            {
+              'term': {
+                'doc.logData.storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              'term': {
+                'doc.logData.moduleType.keyword': inputData.moduleType,
+              },
+            },
+          ],
+
+        },
+      },
+    };
+    const downtime = await getOpenSearchData( parsedOpenSearch.auditLog, downTimeQuery );
+    return res.sendSuccess( downtime );
+  } catch ( err ) {
+
+  }
+}
+

package/src/controllers/traxAudit.controllers.js

@@ -4,16 +4,19 @@ import { countDocumentsStore, findOneStore } from '../service/store.service.js';
 import { findOneUser } from '../service/user.service.js';
 import { aggregateUserEmpDetection, createUserEmpDetection, updateOneUserEmpDetection } from '../service/userEmpDetection.service.js';
 import { aggregateTraxAuditData, findOneTraxAuditData } from '../service/traxAuditData.service.js';
-import { aggregateClient } from '../service/client.service.js';
+import { aggregateClient, findOneClient } from '../service/client.service.js';
 import dayjs from 'dayjs';
 import { aggregateAssignAudit } from '../service/assignAudit.service.js';
-import { aggregateStoreEmpDetection, updateManyStoreEmpDetection } from '../service/storeEmpDetection.service.js';
-import { listQueue } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
+import { aggregateStoreEmpDetection, updateManyStoreEmpDetection, updateOneStoreEmpDetection } from '../service/storeEmpDetection.service.js';
+import { listQueue, sendMessageToQueue } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
 import _ from 'lodash';
 import mongoose from 'mongoose';
-import { findOneAuditLog } from '../service/auditLog.service.js';
-
-
+import { findOneAuditLog, createAuditLog,
+} from '../service/auditLog.service.js';
+import {
+  findOneUserEmpDetection,
+} from '../service/userEmpDetection.service.js';
+import { updateOneEmpDetectionOutput } from '../service/empDetectionOutput.service.js';
 // export async function getDetectionAuditFile( req, res ) {
 //   try {
 //     const bucket = JSON.parse( process.env.BUCKET );
@@ -334,13 +337,13 @@ import { findOneAuditLog } from '../service/auditLog.service.js';
 //         const data = await signedUrl( fetchData );
 //         const mapimg = {
 //           img_path: data,
-//           img_name: image[0],
-//           img_id: indexes[1],
+//           img_name: inputData.moduleType=='mobile-detection'?`${indexes[0]}-${indexes[3]}` :image[0],
+//           img_id: img[3],
 //         };
 //         files.push( {
 //           img_path: data,
-//          img_name: image[0],
-//           img_id: indexes[1],
+//          img_name: inputData.moduleType=='mobile-detection'?`${indexes[0]}-${indexes[3]}` :image[0],
+//           img_id: img[3],
 //           selected: false,
 //           dropped: false,
 //           count: 1,
@@ -742,7 +745,7 @@ export async function workSpace( req, res ) {
       },
     ];
 
-    logger.info( { moduleType: inputData.moduleType, key: inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] ), dateStart: new Date( dayjs( fileDate ).format( 'YYYY-MM-DD' ) ), end: dateRange.end, user: req.user._id, client: clientList } );
+    logger.info( { moduleType: inputData.moduleType, key: [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType ), dateStart: new Date( dayjs( fileDate ).format( 'YYYY-MM-DD' ) ), end: dateRange.end, user: req.user._id, client: clientList } );
 
     const userAsignAudit = [
       {
@@ -796,11 +799,11 @@ export async function workSpace( req, res ) {
       },
     ];
 
-    const auditUserCount = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateUserEmpDetection( auditFiles ) : await aggregateBinaryAudit( auditFiles );
-    const userIncompleteFilesCount = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateUserEmpDetection( userIncompleteFiles ) : await aggregateBinaryAudit( userIncompleteFiles );
+    const auditUserCount = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )?await aggregateUserEmpDetection( auditFiles ) : await aggregateBinaryAudit( auditFiles );
+    const userIncompleteFilesCount = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )?await aggregateUserEmpDetection( userIncompleteFiles ) : await aggregateBinaryAudit( userIncompleteFiles );
     logger.info( { moduleType: inputData.moduleType, userIncompleteFiles: userIncompleteFilesCount } );
     const userAsignAuditCount = await aggregateAssignAudit( userAsignAudit );
-    const completedStoresCount = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateStoreEmpDetection( completedStores ) : await aggregateBinaryAudit( binarCompletedStores );
+    const completedStoresCount = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )? await aggregateStoreEmpDetection( completedStores ) : await aggregateBinaryAudit( binarCompletedStores );
     const clientAssignedCount = await aggregateAssignAudit( clientAssign );
     const auditStoreData = await aggregateTraxAuditData(
         auditStoreDataQuery,
@@ -1697,7 +1700,7 @@ export async function userAuditHistory( req, res ) {
       },
       );
     }
-    const count = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const count = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )? await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
     if ( count.length == 0 ) {
       return res.sendError( 'No Data Found', 204 );
     }
@@ -1767,7 +1770,7 @@ export async function userAuditHistory( req, res ) {
     {
       $limit: limit,
     } );
-    const result = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const result = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )? await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
 
     return res.sendSuccess( { result: result, count: count.length } );
   } catch ( error ) {
@@ -1919,6 +1922,125 @@ export async function clientMetrics( req, res ) {
       },
     ];
 
+    const MappingQuery =[
+      {
+        $match: {
+          $and: filter,
+        },
+      },
+      {
+        $group: {
+          _id: { clientId: '$clientId', fileDate: '$fileDate', moduleType: '$moduleType' },
+          fileDate: { $last: '$fileDate' },
+          clientId: { $last: '$clientId' },
+          clientName: { $last: '$clientName' },
+          moduleType: { $last: '$moduleType' },
+          installedStore: { $last: '$installedStore' },
+          queueName: { $last: '$queueName' },
+          totalFilesCount: { $sum: 1 },
+        },
+      },
+      {
+        $project: {
+          fileDate: 1,
+          clientId: 1,
+          clientName: 1,
+          queueName: 1,
+          installedStore: 1,
+          totalFilesCount: 1,
+          moduleType: 1,
+          notAssignedCount: { $ifNull: [ 0, 0 ] },
+          clientStatus: { $ifNull: [ '', '' ] },
+        },
+      },
+      {
+        $lookup: {
+          'from': 'storeEmpDetection',
+          'let': { clientId: '$clientId', fileDate: '$fileDate', totalAuditFiles: '$totalFilesCount' },
+          'pipeline': [
+
+            {
+              $match: {
+                $expr: {
+                  $and: storeAuditFilter,
+                },
+              },
+            },
+            {
+              $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: { $ifNull: [ '$fileCount', 0 ] },
+                completionPercentage: { $ifNull: [
+                  {
+                    $round: [ {
+                      $multiply: [
+                        100, {
+                          $divide: [
+                            '$completedStores', '$$totalAuditFiles',
+                          ],
+                        },
+                      ],
+                    }, 1 ],
+
+                  },
+                  0,
+                ],
+                },
+              },
+            },
+          ], 'as': 'binaryAudit',
+        },
+      },
+      {
+        $unwind: {
+          path: '$binaryAudit',
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          fileDate: 1,
+          clientId: 1,
+          clientName: 1,
+          totalFilesCount: 1,
+          moduleType: 1,
+          value: {
+            $replaceAll: { input: '$moduleType', find: '-', replacement: ' ' }, // Replacing "-" with " "
+          },
+          installedStore: 1,
+          // notAssignedStores: '$binaryAudit.notAssignedStores',
+          inprogressStoresCount: '$binaryAudit.inprogressStores',
+          // fileCount: '$binaryAudit.fileCount',
+          notAssignedCount: { $subtract: [ '$totalFilesCount', { $subtract: [ { $ifNull: [ '$binaryAudit.fileCount', 0 ] }, { $ifNull: [ '$binaryAudit.notAssignedStores', 0 ] } ] } ] },
+          clientStatus: { $cond: [ { $eq: [ { $ifNull: [ '$binaryAudit.fileCount', 0 ] }, 0 ] }, 'not-taken', { $cond: [ { $gte: [ '$binaryAudit.completedStores', '$totalFilesCount' ] }, 'completed', 'pending' ] } ] }, // { $cond: [ { $or: [ { $gt: [ '$notAssignedCount', 0 ] }, { $gt: [ '$binaryAudit.notAssignedStores', 0 ] } ] }
+          completedStores: '$binaryAudit.completedStores',
+          completionPercentage: '$binaryAudit.completionPercentage',
+
+        },
+      },
+    ];
+
+
     if ( inputData?.filterByStatus?.length> 0 ) {
       query.push(
           {
@@ -1950,7 +2072,7 @@ export async function clientMetrics( req, res ) {
       );
     }
 
-    const count = await aggregateTraxAuditData( query );
+    const count = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )? await aggregateTraxAuditData( MappingQuery ) : await aggregateTraxAuditData( query );
     logger.info( { count: count } );
     if ( count.length == 0 ) {
       return res.sendError( 'No Data Found', 204 );
@@ -1983,7 +2105,7 @@ export async function clientMetrics( req, res ) {
     }
 
     logger.info( { query: query } );
-    const result = await aggregateTraxAuditData( query );
+    const result = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )? await aggregateTraxAuditData( MappingQuery ) : await aggregateTraxAuditData( query );
     if ( result.length == 0 ) {
       return res.sendError( 'No Data Found', 204 );
     }
@@ -2426,7 +2548,9 @@ export async function storeMetrics( req, res ) {
       },
       );
     }
-    const count = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateStoreEmpDetection( query ) : await aggregateBinaryAudit( binaryQuery );
+    logger.info( { keyss: [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType ) } );
+    const count = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )?await aggregateStoreEmpDetection( query ) : await aggregateBinaryAudit( binaryQuery );
+
 
     if ( count.length == 0 ) {
       return res.sendError( 'No data Found', 204 );
@@ -2441,7 +2565,7 @@ export async function storeMetrics( req, res ) {
     } else {
       query.push( { $limit: 10000 } );
     }
-    const result = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const result = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )?await aggregateStoreEmpDetection( query ) : await aggregateBinaryAudit( query );
     if ( inputData.isExport ) {
       const exportdata = [];
       result.forEach( ( element ) => {
@@ -2744,7 +2868,7 @@ export async function userMetrics( req, res ) {
       );
     }
 
-    const count = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const count = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )?await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
     if ( count.length == 0 ) {
       return res.sendError( 'No Data Found', 204 );
     }
@@ -2778,7 +2902,7 @@ export async function userMetrics( req, res ) {
         'Product Type': '$value',
         // 'Mapping Percentage': '$mappingPerc',
       };
-      inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?
+      [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )?
       query.push(
           {
             $project: detection,
@@ -2792,7 +2916,7 @@ export async function userMetrics( req, res ) {
     }
 
 
-    const result = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const result = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )?await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
     if ( inputData.isExport ) {
       await download( result, res );
       return;
@@ -2936,7 +3060,7 @@ export async function pendingSummaryTable( req, res ) {
       },
       );
     }
-    const count = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const count = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )?await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
     if ( count.length == 0 ) {
       return res.sendError( 'No Data Found', 204 );
     }
@@ -2952,7 +3076,7 @@ export async function pendingSummaryTable( req, res ) {
       } );
     }
 
-    const result = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const result = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )?await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
     if ( inputData.isExport ) {
       const exportdata = [];
       result.forEach( ( element ) => {
@@ -3146,7 +3270,7 @@ export async function overAllAuditSummary( req, res ) {
       },
     ];
 
-    const storeAudit = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateStoreEmpDetection( storeAuditQuery ) : await aggregateBinaryAudit( binaryAuditQuery );
+    const storeAudit = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )?await aggregateStoreEmpDetection( storeAuditQuery ) : await aggregateBinaryAudit( binaryAuditQuery );
     if ( storeAudit.length > 0 ) {
       temp.inprogressStores= storeAudit[0].inprogressStores;
       temp.completedStores = storeAudit[0].completedStores;
@@ -3188,6 +3312,63 @@ export async function summarySplit( req, res ) {
       { clientId: { $in: inputData.clientId } },
     ];
 
+
+    const binaryAuditQuery =[
+      {
+        $match: {
+          $and: filters,
+        },
+
+      },
+      {
+        $project: {
+          auditInprogress: {
+            $cond: [
+              { $and: [ { $eq: [ '$auditType', 'Audit' ] }, { $eq: [ '$auditStatus', 'inprogress' ] } ] }, 1, 0,
+            ],
+          },
+          reAuditInprogress: {
+            $cond: [
+              { $and: [ { $eq: [ '$auditType', 'ReAudit' ] }, { $eq: [ '$auditStatus', 'inprogress' ] } ] }, 1, 0,
+            ],
+          },
+
+          reAuditCompleted: {
+            $cond: [
+              { $and: [ { $eq: [ '$auditType', 'ReAudit' ] }, { $eq: [ '$auditStatus', 'completed' ] } ] }, 1, 0,
+            ],
+          },
+          auditCompleted: {
+            $cond: [
+              { $and: [ { $eq: [ '$auditType', 'Audit' ] }, { $eq: [ '$auditStatus', 'completed' ] } ] }, 1, 0,
+            ],
+          },
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          auditInprogress: { $sum: '$auditInprogress' },
+          reAuditInprogress: { $sum: '$reAuditInprogress' },
+          reAuditCompleted: { $sum: '$reAuditCompleted' },
+          auditCompleted: { $sum: '$auditCompleted' },
+
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          totalInprogress: 1,
+          auditInprogress: 1,
+          reAuditInprogress: 1,
+          reAuditCompleted: 1,
+          auditCompleted: 1,
+          totalCount: { $ifNull: [ 0, 0 ] },
+
+        },
+      },
+    ];
+
     const query =[
       {
         $match: {
@@ -3277,7 +3458,7 @@ export async function summarySplit( req, res ) {
         },
       },
     ];
-    const result = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const result = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )? await aggregateStoreEmpDetection( query ) : await aggregateBinaryAudit( binaryAuditQuery );
     const totalCount = await aggregateTraxAuditData( totalQuery );
     result[0].totalCount = totalCount[0]?.total;
     return res.sendSuccess( { result: result.length> 0? result[0]: temp } );
@@ -3424,7 +3605,7 @@ export async function overviewTable( req, res ) {
       },
       );
     }
-    const count = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateStoreEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const count = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )? await aggregateStoreEmpDetection( query ) : await aggregateBinaryAudit( query );
     if ( count.length == 0 ) {
       return res.sendError( 'No Data Found', 204 );
     }
@@ -3439,7 +3620,7 @@ export async function overviewTable( req, res ) {
         $limit: limit,
       } );
     }
-    const result = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateStoreEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const result = [ 'uniform-detection', 'mobile-detection' ].includes( inputData.moduleType )? await aggregateStoreEmpDetection( query ) : await aggregateBinaryAudit( query );
     if ( inputData.isExport ) {
       const exportdata = [];
       result.forEach( ( element ) => {
@@ -3812,13 +3993,13 @@ export async function getDetectionAuditFile( req, res ) {
         const data = await signedUrl( fetchData );
         const mapimg = {
           img_path: data,
-          img_name: image[0],
-          img_id: indexes[1],
+          img_name: inputData.moduleType=='mobile-detection'?`${indexes[0]}-${indexes[3]}` :image[0],
+          img_id: img[3],
         };
         files.push( {
           img_path: data,
-          img_name: image[0],
-          img_id: indexes[1],
+          img_name: inputData.moduleType=='mobile-detection'?`${indexes[0]}-${indexes[3]}` :image[0],
+          img_id: img[3],
           selected: false,
           dropped: false,
           count: 1,
@@ -3837,7 +4018,7 @@ export async function getDetectionAuditFile( req, res ) {
           userId: req.user._id,
           storeId: msg.storeId,
           clientId: msg.storeId.split( '-' )[0],
-          auditType: 'Audit',
+          auditType: msg.auditType || 'Audit',
           fileDate: msg.fileDate,
           inputBucketName: msg.inputBucketName,
           folderPath: msg.folderPath,
@@ -3858,7 +4039,7 @@ export async function getDetectionAuditFile( req, res ) {
           userId: req.user._id,
           storeId: msg.storeId,
           clientId: msg.storeId.split( '-' )[0],
-          auditType: 'Audit',
+          auditType: msg.auditType || 'Audit',
           fileDate: msg.fileDate,
           folderPath: msg.folderPath,
           inputBucketName: msg.inputBucketName,
@@ -3921,7 +4102,7 @@ export async function getDetectionAuditFile( req, res ) {
         queueName: inputData.queueName,
         storeId: storeId,
         fileDate: fileDate,
-        auditType: 'Audit',
+        auditType: msg.auditType || 'Audit',
         auditId: insertData._id,
         userId: insertData.userId,
         moduleType: inputData.moduleType,
@@ -3945,7 +4126,7 @@ export async function saveDraft( req, res ) {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.body;
     inputData.userId = req.user._id;
-    const getUserAuditData = await findOneUserAudit( { _id: inputData.auditId } );
+    const getUserAuditData = await findOneUserEmpDetection( { _id: inputData.auditId } );
     if ( !getUserAuditData ) {
       return res.sendError( 'No Data Found', 204 );
     }
@@ -3963,7 +4144,6 @@ export async function saveDraft( req, res ) {
     const storeQuery = {
       storeId: inputData.storeId,
       fileDate: inputData.fileDate,
-      zoneName: inputData.zoneName,
     };
 
     let storeRecord = {
@@ -4004,7 +4184,7 @@ export async function saveDraft( req, res ) {
     }
     await createAuditLog( inputData );
     await updateOneUserEmpDetection( userQuery, userRecord );
-    await updateOneStoreEmp( storeQuery, storeRecord );
+    await updateOneStoreEmpDetection( storeQuery, storeRecord );
     return res.sendSuccess( {
       result: 'The file has been drafted successfully',
     } );
@@ -4048,8 +4228,13 @@ export async function getDraftedData( req, res ) {
 export async function save( req, res ) {
   try {
     const inputData = req.body;
-    const data = await createEmpDetection( inputData );
+    const getUserAuditData = await findOneUserEmpDetection( { _id: inputData.auditId } );
+    inputData.clientId = getUserAuditData.clientId;
+    const query ={ storeId: inputData.storeId, moduleType: inputData.moduleType, fileDate: inputData.fileDate };
+    const data = await updateOneEmpDetectionOutput( query, { $set: inputData }, { upsert: true } );
     if ( data ) {
+      await updateOneUserEmpDetection( { _id: inputData.auditId }, { auditStatus: 'completed', afterCount: inputData.employeeCount } );
+      await updateOneStoreEmpDetection( query, { status: 'completed', afterCount: inputData.employeeCount } );
       return res.sendSuccess( { result: 'Updated Successfully' } );
     } else {
       return res.sendError( 'something went wrong', 403 );
@@ -4064,3 +4249,89 @@ export async function save( req, res ) {
     return res.sendError( err, 500 );
   }
 }
+
+export async function reTrigger( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.body;
+    const message = req.sqs;
+    const sqs = JSON.parse( process.env.SQS );
+    const getQueueName = await findOneClient( { clientId: req.audit.clientId }, { 'auditConfigs': 1 } );
+    const queueName = inputData.moduleType == 'uniform-detection' ? getQueueName?.auditConfigs?.traxQueueName?.uniformDetection : getQueueName?.auditConfigs?.traxQueueName?.mobileDetection;
+    if ( !getQueueName || queueName == '' ) {
+      return res.sendError( 'queueName does not create', 400 );
+    }
+    const msg = {
+      storeId: message.storeId,
+      fileDate: message.fileDate,
+      moduleType: message.moduleType,
+      inputBucketName: message.inputBucketName,
+      questionType: message.questionType,
+      question: message.question,
+      folderPath: message.folderPath,
+      fileCount: message.fileCount,
+    };
+    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,
+          auditStatus: req.audit.status,
+          moduleType: inputData.moduleType,
+
+        };
+        await updateOneUserEmpDetection( query, userRecord );
+      }
+
+      const storeQuery = {
+        storeId: inputData.storeId,
+        fileDate: inputData.fileDate,
+        moduleType: inputData.moduleType,
+
+      };
+
+      const storeRecord = {
+        status: 'not_assign',
+      };
+
+      await updateOneStoreEmpDetection( storeQuery, storeRecord );
+      const logData = {
+        userId: req.user._id,
+        userName: req.user.userName,
+        logType: 'traxAudit',
+        logSubType: 'reTrigger',
+        logData: {
+          beforeCount: message.fileCount,
+          afterCount: '',
+          fileDate: inputData.fileDate,
+          auditType: req.audit.auditType,
+          storeId: inputData.storeId,
+          moduleType: inputData.moduleType,
+          queueName: queueName,
+          triggerBy: req.user.userName,
+          triggerId: req.user._id,
+        },
+        createdAt: new Date(),
+      };
+      await insertOpenSearchData( openSearch.auditLog, logData );
+    }
+    return res.sendSuccess( { result: 'The File has been Re-Triggered Succesfully' } );
+  } catch ( error ) {
+    const err = error.message;
+    logger.error( { error: error, message: req.body, function: 'reTrigger' } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/docs/traxAudit.docs.js

@@ -1,5 +1,5 @@
 import j2s from 'joi-to-swagger';
-import { getFileSchema, userAuditHistorySchema, workSpaceSchema, saveSchema, clientMetricsSchema, storeMetricsSchema, userMetricsSchema, pendingSummaryTableSchema, overAllAuditSummarySchema, overviewTableSchema, summarySplitSchema, getUpdatedFileSchema, getDetectionFileValid, saveBinarySchema, saveDraftSchema, getDraftedDataSchema } from '../dtos/traxAudit.dtos.js';
+import { getFileSchema, userAuditHistorySchema, workSpaceSchema, saveSchema, clientMetricsSchema, storeMetricsSchema, userMetricsSchema, pendingSummaryTableSchema, overAllAuditSummarySchema, overviewTableSchema, summarySplitSchema, getUpdatedFileSchema, getDetectionFileValid, saveBinarySchema, saveDraftSchema, getDraftedDataSchema, reTriggerValidSchema } from '../dtos/traxAudit.dtos.js';
 
 export const traxAuditDocs = {
 
@@ -363,7 +363,7 @@ export const traxAuditDocs = {
     },
   },
 
-  '/v3/reax-audit/get-drafted-data': {
+  '/v3/trax-audit/get-drafted-data': {
     get: {
       tags: [ 'Trax Audit' ],
       description: 'Get a saved file via DB',
@@ -403,4 +403,26 @@ export const traxAuditDocs = {
       },
     },
   },
+  '/v3/trax-audit/metrics/re-trigger': {
+    post: {
+      tags: [ 'Trax Audit' ],
+      description: `Manual re trigger a file`,
+      operationId: 'metrics/re-trigger',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( reTriggerValidSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
 };

package/src/dtos/audit.dtos.js

@@ -266,7 +266,7 @@ export const reTriggerValid = {
 export const overViewCardSchema = joi.object( {
   fromDate: joi.string().required(),
   toDate: joi.string().required(),
-  clientId: joi.array().items( joi.string().required() ).required(),
+  clientId: joi.array().items( joi.string().required().allow( '' ) ).required(),
 } );
 
 export const overViewCardValid = {

package/src/dtos/traxAudit.dtos.js

@@ -45,7 +45,6 @@ export const saveDraftSchema = joi.object(
       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(),
@@ -273,8 +272,6 @@ export const saveSchema = joi.object( {
   auditType: joi.string().required(),
   moduleType: joi.string().required(),
   beforeCount: joi.number().required(),
-  junkCount: joi.number().required(),
-  junk: joi.array().required(),
   employeeCount: joi.number().required(),
   employee: joi.array().required(),
 } );
@@ -282,3 +279,15 @@ export const saveSchema = joi.object( {
 export const saveValid = {
   body: saveSchema,
 };
+
+
+export const reTriggerValidSchema = joi.object( {
+  fileDate: joi.string().required(),
+  storeId: joi.string().required(),
+  moduleType: joi.string().required(),
+
+} );
+
+export const reTriggerValid = {
+  body: reTriggerValidSchema,
+};

package/src/routes/audit.routes.js

@@ -1,7 +1,7 @@
 import express from 'express';
 import { isAuditDocumentExist, isAuditInputFolderExist, isExistsQueue, validateUserAudit } from '../validation/audit.validation.js';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { auditImages, auditStoreList, auditUserList, clientMetrics, clients, getAuditFile, getDraftedData, overAllAuditSummary, overViewCard, overviewTable, pendingSummaryTable, reTrigger, save, saveDraft, storeMetrics, summarySplit, totalNotAssignedCount, userAuditHistory, userMetrics, workSpace, getUserAuditCount, getUserAuditCountMTD } from '../controllers/audit.controllers.js';
+import { auditImages, auditStoreList, auditUserList, clientMetrics, clients, getAuditFile, getDraftedData, overAllAuditSummary, overViewCard, overviewTable, pendingSummaryTable, reTrigger, save, saveDraft, storeMetrics, summarySplit, totalNotAssignedCount, userAuditHistory, userMetrics, workSpace, getUserAuditCount, getUserAuditCountMTD, auditViewLogs } from '../controllers/audit.controllers.js';
 import { auditStoreValid, clientMetricsValid, clientValid, getDraftedDataValid, getFileValid, overAllAuditSummaryValid, overViewCardValid, pendingSummaryTableValid, reTriggerValid, saveDraftValid, saveValid, storeMetricsValid, summarySplitValid, userAuditHistoryValid, userMetricsValid, workSpaceValid, auditImageValid, overviewTableValid } from '../dtos/audit.dtos.js';
 
 export const auditRouter = express.Router();
@@ -39,4 +39,7 @@ auditRouter.get( '/total-not-assigned-count', isAllowedSessionHandler, totalNotA
 // audit user wallet
 auditRouter.get( '/get-user-audit-count', isAllowedSessionHandler, getUserAuditCount );
 auditRouter.get( '/get-user-audit-count-mtd', isAllowedSessionHandler, getUserAuditCountMTD );
+
+// audit log
+auditRouter.get( '/audit-view-logs', isAllowedSessionHandler, auditViewLogs );
 export default auditRouter;

package/src/routes/traxAudit.routes.js

@@ -1,10 +1,9 @@
 import { Router } from 'express';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { getDetectionFileValid, getFileValid, userAuditHistoryValid, workSpaceValid, saveValid, clientMetricsValid, storeMetricsValid, userMetricsValid, pendingSummaryTableValid, overAllAuditSummaryValid, summarySplitValid, overviewTableValid, getUpdatedFileValid, saveBinaryValid, getDraftedDataValid } from '../dtos/traxAudit.dtos.js';
+import { getDetectionFileValid, getFileValid, userAuditHistoryValid, workSpaceValid, saveValid, clientMetricsValid, storeMetricsValid, userMetricsValid, pendingSummaryTableValid, overAllAuditSummaryValid, summarySplitValid, overviewTableValid, getUpdatedFileValid, saveBinaryValid, getDraftedDataValid, saveDraftValid, reTriggerValidSchema } from '../dtos/traxAudit.dtos.js';
 import { isExistsQueue } from '../validation/audit.validation.js';
-import { clientMetrics, getAuditFile, getDetectionAuditFile, getUpdatedFile, overAllAuditSummary, overviewTable, pendingSummaryTable, saveBinary, storeMetrics, summarySplit, userAuditHistory, userMetrics, workSpace, saveDraft, getDraftedData, save } from '../controllers/traxAudit.controllers.js';
-import { isTraxAuditDocumentExist, validateBinaryAudit } from '../validation/traxAuditValidation.js';
-import { saveDraftValid } from '../dtos/audit.dtos.js';
+import { clientMetrics, getAuditFile, getDetectionAuditFile, getUpdatedFile, overAllAuditSummary, overviewTable, pendingSummaryTable, saveBinary, storeMetrics, summarySplit, userAuditHistory, userMetrics, workSpace, saveDraft, getDraftedData, save, reTrigger } from '../controllers/traxAudit.controllers.js';
+import { isMappingAuditInputFolderExist, isTraxAuditDocumentExist, isuserEmpDocumentExist, validateBinaryAudit } from '../validation/traxAuditValidation.js';
 
 export const traxAuditRouter = Router();
 
@@ -29,6 +28,7 @@ traxAuditRouter.post( '/metrics/store-metrics', isAllowedSessionHandler, validat
 traxAuditRouter.post( '/metrics/user-metrics', isAllowedSessionHandler, validate( userMetricsValid ), userMetrics );
 traxAuditRouter.post( '/metrics/pending-summary-table', isAllowedSessionHandler, validate( pendingSummaryTableValid ), pendingSummaryTable );
 traxAuditRouter.post( '/metrics/overall-audit-summary', isAllowedSessionHandler, validate( overAllAuditSummaryValid ), overAllAuditSummary );
+traxAuditRouter.post( '/metrics/re-trigger', isAllowedSessionHandler, validate( reTriggerValidSchema ), isuserEmpDocumentExist, isMappingAuditInputFolderExist, reTrigger );
 
 // summary
 

package/src/service/auditUserWallet.service.js

@@ -1,5 +1,5 @@
 import auditUserWalletModel from 'tango-api-schema/schema/auditUserWallet.model.js';
-
+import empDetectionOutputModel from 'tango-api-schema/schema/empDetectionOutput.model.js';
 
 export function createAuditUserWallet( record ) {
   return auditUserWalletModel.create( record );
@@ -8,3 +8,6 @@ export function createAuditUserWallet( record ) {
 export function updateManyAuditUserWallet( query, record ) {
   return auditUserWalletModel.updateMany( query, record, { upsert: true } );
 };
+export function createempDetectionOutput( query, field, option ) {
+  return empDetectionOutputModel.updateOne( query, field, option );
+};

package/src/service/auditUsers.service.js

@@ -0,0 +1,5 @@
+import auditUsersModel from 'tango-api-schema/schema/auditUsers.model.js';
+
+export function aggregateAuditUsers( query ) {
+  return auditUsersModel.aggregate( query );
+};

package/src/service/empDetectionOutput.service.js

@@ -1,5 +1,5 @@
 
 import empDetectionOutputModel from 'tango-api-schema/schema/empDetectionOutput.model.js';
-export function createAuditLog( record ) {
-  return empDetectionOutputModel.create( record );
+export function updateOneEmpDetectionOutput( query, record, upsert ) {
+  return empDetectionOutputModel.updateOne( query, record, upsert );
 }

package/src/service/storeEmpDetection.service.js

@@ -5,9 +5,14 @@ export function aggregateStoreEmpDetection( query ) {
   return storeEmpDetectionModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
 }
 
+export function findOneStoreEmpDetection( query ) {
+  return storeEmpDetectionModel.findOne( query );
+}
+
 export function updateOneStoreEmpDetection( query, record ) {
   return storeEmpDetectionModel.updateOne( query, { $set: record } );
 }
+
 export function updateManyStoreEmpDetection( query, record ) {
   return storeEmpDetectionModel.updateMany( query, { $set: record }, { upsert: true } );
 }

package/src/validation/traxAuditValidation.js

@@ -1,7 +1,8 @@
-import { logger } from 'tango-app-api-middleware';
+import { checkFileExist, logger } from 'tango-app-api-middleware';
 import { findOneBinaryAudit, updateOneBinaryAuditModel } from '../service/binaryAudit.service.js';
 import { findOneUserEmpDetection } from '../service/userEmpDetection.service.js';
 import { findOneTraxAuditData } from '../service/traxAuditData.service.js';
+import { findOneStoreEmpDetection } from '../service/storeEmpDetection.service.js';
 
 export async function validateUserEmpDetection( req, res, next ) {
   try {
@@ -116,3 +117,48 @@ export async function isTraxAuditDocumentExist( req, res, next ) {
     return res.sendError( err, 500 );
   }
 }
+
+export async function isuserEmpDocumentExist( req, res, next ) {
+  try {
+    const inputData = req.body;
+    const query={
+      storeId: inputData.storeId,
+      fileDate: inputData.fileDate,
+      moduleType: inputData.moduleType,
+    };
+    const auditInfo = await findOneStoreEmpDetection( query );
+    if ( auditInfo ) {
+      const sqs = await findOneTraxAuditData( query, { sqs: 1 } );
+      req.sqs = sqs.sqs.Body;
+      req.audit = auditInfo;
+      return next();
+    } else {
+      return res.sendError( 'No audited Record', 400 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'isAuditFileExist' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+
+export async function isMappingAuditInputFolderExist( req, res, next ) {
+  try {
+    // const inputData = req.method === 'POST' ? req.body : req.query;
+    const params={
+      Bucket: req.sqs.inputBucketName,
+      Key: req.sqs.folderPath.replace( /\/$/, '' ),
+    };
+    const isExist = await checkFileExist( params );
+    if ( isExist ) {
+      next();
+    } else {
+      return res.sendError( `Audit Input folder not available : ${req.sqs.folderPath}`, 400 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'isAuidtInputFolderExist' } );
+    return res.sendError( err, 500 );
+  }
+}