tango-app-api-audit 3.4.3-alpha.9 → 3.4.3

package/src/controllers/audit.controllers.js

@@ -64,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 ***   -->      */
 
@@ -355,6 +356,7 @@ export async function getAuditFile( req, res ) {
               auditId: userDetails[0]._id,
               moduleType: userDetails[0].moduleType,
               zoneName: userDetails[0].zoneName,
+              beforeCount: userDetails[0].beforeCount,
             },
             createdAt: new Date(),
           };
@@ -457,6 +459,7 @@ export async function getAuditFile( req, res ) {
             auditId: reauditInsert._id,
             zoneName: msg.zone_id,
             moduleType: inputData.moduleType,
+            beforeCount: msg.total_count,
           },
           createdAt: new Date(),
         };
@@ -609,6 +612,7 @@ export async function getAuditFile( req, res ) {
           auditId: insertData._id,
           zoneName: msg.zone_id,
           moduleType: inputData.moduleType,
+          beforeCount: msg.total_count,
         },
         createdAt: new Date(),
       };
@@ -1102,9 +1106,9 @@ export async function workSpace( req, res ) {
     }
 
     if ( inputData.isExport ) {
-      const exportdata = [];
+      const exportData = [];
       temp.forEach( ( element ) => {
-        exportdata.push( {
+        exportData.push( {
           'Client Name': element.clientName,
           'Client Id': element.clientId,
           'Completed stores Count': element.completedStoresCount,
@@ -1115,7 +1119,7 @@ export async function workSpace( req, res ) {
           'Assigned': element.Assignedcount,
         } );
       } );
-      await download( exportdata, res );
+      await download( exportData, res );
       return;
     } else {
       return res.sendSuccess( {
@@ -1217,6 +1221,7 @@ export async function getDraftedData( req, res ) {
       userId: userId,
       moduleType: inputData.moduleType,
       zoneName: inputData.zoneName,
+      auditId: inputData.auditId,
     };
     const result = await findOneAuditLog( query, {}, { createdAt: -1 }, 1 );
 
@@ -1237,8 +1242,10 @@ export async function getDraftedData( req, res ) {
 
 export async function save( req, res ) {
   try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     const bucket = JSON.parse( process.env.BUCKET );
     const sqs = JSON.parse( process.env.SQS );
+    const auditConfig = JSON.parse( process.env.AUDIT_CONFIG );
     const inputData = req.body;
     let storeAuditData = await findOneStoreAudit( {
       storeId: inputData.storeId,
@@ -1329,12 +1336,29 @@ export async function save( req, res ) {
         },
     );
 
-    /** *
-     *
-     * logs need to be added
-     *
-     *
-     */
+    const logData = {
+      userId: req.user._id,
+      userName: req.user.userName,
+      logType: 'audit',
+      logSubType: 'auditDone',
+      logData: {
+        fileDate: req.userAudit?.fileDate,
+        auditType: req.userAudit?.auditType,
+        storeId: req.userAudit?.storeId,
+        zoneName: req.userAudit?.zoneName,
+        moduleType: req.userAudit?.moduleType,
+        queueName: req.userAudit?.queueName,
+        clientId: req.userAudit?.clientId,
+        beforeCount: req.userAudit?.beforeCount,
+        afterCount: inputData.customerCount,
+        startTime: req.userAudit?.startTime,
+        endTime: Date.now(),
+        timeSpent: timeDifferenceInMinutes,
+        auditId: new mongoose.Types.ObjectId( inputData.auditId ),
+      },
+      createdAt: Date.now(),
+    };
+    await insertOpenSearchData( openSearch.auditLog, logData );
 
     let storeConfig = await findOneStore(
         {
@@ -1399,6 +1423,31 @@ export async function save( req, res ) {
             timeSpent: timeDifferenceInMinutes,
           },
       );
+
+      const logData = {
+        userId: req.user._id,
+        userName: req.user.userName,
+        logType: 'audit',
+        logSubType: 'reAuditPush',
+        logData: {
+          fileDate: req.userAudit?.fileDate,
+          auditType: req.userAudit?.auditType,
+          storeId: req.userAudit?.storeId,
+          moduleType: req.userAudit?.moduleType,
+          zoneName: req.userAudit?.zoneName,
+          queueName: req.userAudit?.queueName,
+          clientId: req.userAudit?.clientId,
+          beforeCount: req.userAudit?.beforeCount,
+          afterCount: inputData.customerCount,
+          startTime: req.userAudit?.startTime,
+          endTime: Date.now(),
+          timeSpent: timeDifferenceInMinutes,
+          auditId: new mongoose.Types.ObjectId( inputData.auditId ),
+        },
+        createdAt: Date.now(),
+      };
+
+      await insertOpenSearchData( openSearch.auditLog, logData );
     } else {
       logger.info( 'Hit in Features', {
         data: _.omit( inputData, [ 'junk', 'employee', 'customer' ] ),
@@ -1417,10 +1466,8 @@ export async function save( req, res ) {
             timeSpent: timeDifferenceInMinutes,
           },
       );
-
       const sqsProduceQueue = {
-        QueueUrl: `${sqs.url}${sqs.feature}`,
-
+        QueueUrl: ( auditConfig?.isCheckMinAfterCount ==1 && auditConfig?.minAfterCount ) >1500? `${sqs.url}${sqs.feature_new}`: `${sqs.url}${sqs.feature}`,
         MessageBody: JSON.stringify( {
           store_id: inputData.storeId,
           store_date: inputData.fileDate,
@@ -1658,21 +1705,22 @@ export async function userAuditHistory( req, res ) {
         chunk.forEach( ( element ) => {
           exportData.push( {
             'File Date': element.fileDate,
-            'Brand ID': element.clientId,
             'Brand Name': element.clientName,
-            'Store ID': element.storeId,
+            'Brand ID': element.clientId,
             'Store Name': element.storeName,
+            'Store ID': element.storeId,
             'Zone Name': element.moduleType == 'zone' ? element.zoneName : '',
             'Audit Type': element.auditType,
             'Product Type': element.moduleType,
             'Before Count': element.beforeCount,
             'After Count': element.afterCount || '',
             'Accuracy': element.accuracy || '',
+            'Audited Date': dayjs( element.createdAt ).format( 'YYYY,MMM D' ),
             'Start Time': element.startTime,
             'End Time': element.endTime || '',
             'Time Spent': element.timeSpent,
-            'Audit Status': element.auditStatus,
-            'Audited Date': dayjs( element.createdAt ).format( 'YYYY,MMM D' ),
+            'Status': element.auditStatus,
+
 
           } );
         } );
@@ -1889,16 +1937,16 @@ export async function clientMetrics( req, res ) {
             $project: {
               '_id': 0,
               'File Date': '$fileDate',
-              'Client Name': '$clientName',
-              'Client Id': '$clientId',
+              'Brand Name': '$clientName',
+              'Brand Id': '$clientId',
               'Product Type': '$moduleType',
-              'Completed Percentage': '$completionPercentage',
+              // 'Completed Percentage': '$completionPercentage',
               'Installed Stores': '$installedStore',
               'Audit Stores': '$totalFilesCount',
               'Inprogress Stores': '$inprogressStoresCount',
-              'Not Assigned': '$notAssignedCount',
+              'Not Assigned stores': '$notAssignedCount',
               // 'Not Assigned Stores': '$notAssignedStores',
-              'Completed': '$completedStores',
+              'Completed Stores': '$completedStores',
               'Status': '$clientStatus',
             },
           },
@@ -2164,44 +2212,46 @@ export async function storeMetrics( req, res ) {
     }
     const result = await aggregateStoreAudit( query );
     if ( inputData.isExport ) {
-      const exportdata = [];
+      const exportData = [];
       result.forEach( ( element ) => {
         if ( element.moduleType == 'zone' ) {
-          exportdata.push( {
+          exportData.push( {
             'File Date': element.fileDate,
-            'Store ID': element.storeId,
             'Store Name': element.storeName,
-            'Client Id': element.clientId,
-            'Client Name': element.clientName,
+            'Store ID': element.storeId,
+            // 'Client Id': element.clientId,
+            // 'Client Name': element.clientName,
+            'Product Type': element.moduleType,
             'Zone Name': element.zoneName,
             'User Name': element.userName,
             'User Email': element.userEmail,
             'Before Count': element.beforeCount,
             'After Count': element.afterCount,
-            'Audit Type': element.auditType,
             'Accuracy': element.accuracy,
             'Time Spent': element.timeSpent,
+            'Audit Type': element.auditType,
             'Status': element.status,
           } );
         } else {
-          exportdata.push( {
+          exportData.push( {
             'File Date': element.fileDate,
-            'Store ID': element.storeId,
             'Store Name': element.storeName,
-            'Client Id': element.clientId,
-            'Client Name': element.clientName,
+            'Store ID': element.storeId,
+            // 'Client Id': element.clientId,
+            // 'Client Name': element.clientName,
+            'Product Type': element.moduleType,
             'User Name': element.userName,
             'User Email': element.userEmail,
             'Before Count': element.beforeCount,
             'After Count': element.afterCount,
-            'Audit Type': element.auditType,
             'Accuracy': element.accuracy,
             'Time Spent': element.timeSpent,
+            'Audit Type': element.auditType,
             'Status': element.status,
           } );
         }
       } );
-      await download( exportdata, res );
+      await download( exportData, res );
       return;
     }
     return res.sendSuccess( { result: result, count: count.length } );
@@ -2263,6 +2313,7 @@ export async function userMetrics( req, res ) {
           totalCompletedFiles: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, 1, 0 ] },
           beforeCount: 1,
           afterCount: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, '$afterCount', 0 ] },
+          createdAt: 1,
         },
       },
       {
@@ -2275,6 +2326,7 @@ export async function userMetrics( req, res ) {
           afterCount: { $sum: '$afterCount' },
           checkIntime: { $first: '$startTime' },
           checkOutTime: { $last: '$endTime' },
+          createdAt: { $first: '$createdAt' },
 
         },
       },
@@ -2300,6 +2352,7 @@ export async function userMetrics( req, res ) {
           differenceInSeconds: {
             $divide: [ { $subtract: [ '$checkOutTime', '$checkIntime' ] }, 1000 ],
           },
+          createdAt: 1,
         },
       },
       {
@@ -2315,6 +2368,7 @@ export async function userMetrics( req, res ) {
           hours: { $floor: { $divide: [ '$differenceInSeconds', 3600 ] } },
           minutes: { $floor: { $divide: [ { $mod: [ '$differenceInSeconds', 3600 ] }, 60 ] } },
           seconds: { $mod: [ '$differenceInSeconds', 60 ] },
+          createdAt: 1,
         },
       },
       {
@@ -2349,7 +2403,7 @@ export async function userMetrics( req, res ) {
               else: { $toString: { $round: [ '$seconds', 0 ] } },
             },
           },
-
+          createdAt: 1,
         },
       },
       {
@@ -2367,6 +2421,7 @@ export async function userMetrics( req, res ) {
           workingHours: {
             $concat: [ '$hours', ':', '$minutes', ':', '$seconds' ],
           },
+          createdAt: 1,
         },
       },
       {
@@ -2420,6 +2475,7 @@ export async function userMetrics( req, res ) {
             },
           },
           workingHours: 1,
+          createdAt: 1,
         },
       },
     ];
@@ -2457,15 +2513,17 @@ export async function userMetrics( req, res ) {
           {
             $project: {
               '_id': 0,
-              'File Date': '$fileDate',
               'User Name': '$userName',
-              'Total Completed Files Count': '$totalCompletedFiles',
+              'File Date': '$fileDate',
+              'Completed Files': '$totalCompletedFiles',
+              'Product Type': '$moduleType',
               'Total Before Count': '$beforeCount',
               'Total After Count': '$afterCount',
-              'check Intime': '$checkIntime',
-              'check OutTime': '$checkOutTime',
-              'working Hours': '$workingHours',
               'Mapping Percentage': '$mappingPerc',
+              'Check Intime': '$checkIntime',
+              'Check OutTime': '$checkOutTime',
+              'Working Hours': '$workingHours',
+              'Audited Date': { $dateToString: { format: '%Y,%b %d', date: '$createdAt' } },
             },
           },
       );
@@ -2620,10 +2678,10 @@ export async function pendingSummaryTable( req, res ) {
 
     const result = await aggregateUserAudit( query );
     if ( inputData.isExport ) {
-      const exportdata = [];
+      const exportData = [];
       result.forEach( ( element ) => {
         if ( element.moduleType == 'zone' ) {
-          exportdata.push( {
+          exportData.push( {
             'Store ID': element.storeId,
             'zoneName': element.zoneName,
             'File Date': element.fileDate,
@@ -2636,7 +2694,7 @@ export async function pendingSummaryTable( req, res ) {
             'Status': element.auditStatus,
           } );
         } else {
-          exportdata.push( {
+          exportData.push( {
             'Store ID': element.storeId,
             'File Date': element.fileDate,
             'Product Type': element.moduleType,
@@ -2649,7 +2707,7 @@ export async function pendingSummaryTable( req, res ) {
           } );
         }
       } );
-      await download( exportdata, res );
+      await download( exportData, res );
       return;
     }
     return res.sendSuccess( { result: result, count: count.length } );
@@ -2938,6 +2996,7 @@ export async function overViewCard( req, res ) {
       inprogressCount: 0,
       completedCount: 0,
       pendingCount: 0,
+      notAssigned: 0,
     };
 
     const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
@@ -2968,7 +3027,7 @@ export async function overViewCard( req, res ) {
           },
           inprogressCount: {
             $cond: [
-              { $ne: [ '$status', 'completed' ] }, 1, 0,
+              { $in: [ '$status', [ 'inprogress', 'assigned', 'drafted' ] ] }, 1, 0,
             ],
           },
           completedCount: {
@@ -3195,7 +3254,10 @@ export async function summarySplit( req, res ) {
     ];
     const result = await aggregateStoreAudit( query );
     const totalCount = await aggregateAuditStoreData( totalQuery );
-    result[0].totalCount = totalCount[0]?.total;
+    if ( totalCount.length> 0 ) {
+      result[0].totalCount = totalCount[0]?.total;
+    }
+
     return res.sendSuccess( { result: result.length > 0 ? result[0] : temp } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
@@ -3336,38 +3398,32 @@ export async function overviewTable( req, res ) {
 
     const result = await aggregateStoreAudit( query );
     if ( inputData.isExport ) {
-      const exportdata = [];
+      const exportData = [];
       result.forEach( ( element ) => {
         if ( element.moduleType == 'zone' ) {
-          exportdata.push( {
-            'Store ID': element.storeId,
+          exportData.push( {
+            'File Date': element.fileDate,
             'Brand ID': element.clientId,
+            'Store ID': element.storeId,
             'Zone Name': element.zoneName,
-            'File Date': element.fileDate,
-            'Product Type': element.moduleType,
-            'Audit Type': element.auditType,
             'Before Count': element.beforeCount,
             'After Count': element.afterCount,
-            // 'User Name': element.userName,
-            // 'User Email': element.userEmail,
-            'Status': element.status,
+            'Audit Type': element.auditType,
+            'Status': toCamelCase( element.status ),
           } );
         } else {
-          exportdata.push( {
-            'Store ID': element.storeId,
-            'Brand ID': element.clientId,
+          exportData.push( {
             'File Date': element.fileDate,
-            'Product Type': element.moduleType,
-            'Audit Type': element.auditType,
+            'Brand ID': element.clientId,
+            'Store ID': element.storeId,
             'Before Count': element.beforeCount,
             'After Count': element.afterCount,
-            // 'User Name': element.userName,
-            // 'User Email': element.userEmail,
-            'Status': element.status,
+            'Audit Type': element.auditType,
+            'Status': toCamelCase( element.status ),
           } );
         }
       } );
-      await download( exportdata, res );
+      await download( exportData, res );
       return;
     }
     return res.sendSuccess( { result: result, count: count.length } );
@@ -3378,6 +3434,18 @@ export async function overviewTable( req, res ) {
   }
 }
 
+export function toCamelCase( str ) {
+  logger.info( { str: str } );
+  return str
+      .split( '-' ) // Split the string by spaces
+      .map( ( word, index ) =>
+      // index === 0 ?
+      // word.toLowerCase() : // Lowercase the first word
+        word.charAt( 0 ).toUpperCase() + word.slice( 1 ).toLowerCase(), // Capitalize the first letter of subsequent words
+      )
+      .join( '' ); // Join the words without spaces
+}
+
 export async function totalNotAssignedCount( req, res ) {
   try {
     let notAssignedCount = {
@@ -3572,7 +3640,7 @@ export async function totalNotAssignedCount( req, res ) {
     const mappingInprogressCount = [
       {
         $match: {
-          fileDate: { $eq: latestDate },
+          fileDate: { $eq: latestTraxDate },
         },
       },
       {
@@ -3594,17 +3662,14 @@ export async function totalNotAssignedCount( req, res ) {
         $group: {
           _id: null,
           inprogressAuditCount: { $sum: '$inprogressAuditCount' },
-          inprogressZoneCount: { $sum: '$inprogressZoneCount' },
-          inprogressTrafficCount: { $sum: '$inprogressTrafficCount' },
-
+          inprogressTraxCount: { $sum: '$inprogressTraxCount' },
         },
       },
       {
         $project: {
           _id: 0,
           inprogressAuditCount: { $ifNull: [ '$inprogressAuditCount', 0 ] },
-          inprogressZoneCount: { $ifNull: [ '$inprogressZoneCount', 0 ] },
-          inprogressTrafficCount: { $ifNull: [ '$inprogressTrafficCount', 0 ] },
+          inprogressTraxCount: { $ifNull: [ '$inprogressTraxCount', 0 ] },
         },
       },
     ];
@@ -3693,6 +3758,7 @@ export async function totalNotAssignedCount( req, res ) {
     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 );
@@ -3801,18 +3867,45 @@ export async function auditImages( req, res ) {
 export async function getUserAuditCount( req, res ) {
   try {
     const userWallet = JSON.parse( process.env.USER_WALLET );
-    const previousDate = dayjs( new Date() ).subtract( 1, 'days' );
+    const previousDate = dayjs( new Date() ).subtract( 19, 'days' );
     const fileDate = dayjs( previousDate ).format( 'DD-MM-YYYY' );
     const configTimeSpentSec = userWallet.minTimeSpentSec; // 18000;
-    const beforeCountX = userWallet.beforeCountCreditPerc; // 0.0335;
-    const afterCountY = userWallet.afterCountCreditPerc; // 0.0035;
+    // 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 } },
           ],
         },
       },
@@ -3887,6 +3980,11 @@ export async function getUserAuditCount( req, res ) {
     }
     const zoneMinimumTarget =userCount[0]?.zoneUserCount?.length !== 0 && userCount[0]?.zoneFilesCount !==0 ? Math.floor( userCount[0].zoneFilesCount/userCount[0].zoneUserCount.length ) : 0;
     const trafficMinimumTarget =userCount[0]?.trafficUserCount?.length !== 0 && userCount[0]?.trafficFilesCount !==0 ? Math.floor( userCount[0].trafficFilesCount/userCount[0].trafficUserCount.length ) : 0;
+
+    const beforeCountTraffic = 544/trafficMinimumTarget;
+    const beforeCountZone = 544/zoneMinimumTarget; // 0.0035;
+    const afterCountCredit = 136;
+
     const query = [
       {
         $match: {
@@ -3895,11 +3993,13 @@ export async function getUserAuditCount( req, res ) {
             {
               auditStatus: { $eq: 'completed' },
             },
+            { userId: { $in: auditUserList[0].userList } },
           ],
         },
       },
       {
-        $set: { minimumTarget: { $cond: [ { $eq: [ '$moduleType', 'traffic' ] }, trafficMinimumTarget, zoneMinimumTarget ] } },
+        $set: { minimumTarget: { $cond: [ { $eq: [ '$moduleType', 'traffic' ] }, trafficMinimumTarget, zoneMinimumTarget ] },
+          afterCountCredit: afterCountCredit },
       },
       {
         $project: {
@@ -3911,9 +4011,13 @@ export async function getUserAuditCount( req, res ) {
           fileDate: 1,
           fileDateISO: 1,
           minimumTarget: 1,
+          afterCountCredit: 1,
           totalEarn: { $ifNull: [ 0, 0 ] },
+          singleImageAmount: { $ifNull: [ 0, 0 ] },
           totalReducedAmount: { $ifNull: [ 0, 0 ] },
           totalCredit: { $ifNull: [ 0, 0 ] },
+          deductionBytimeSpent: { $ifNull: [ 0, 0 ] },
+          deductionByMinimumTarget: { $ifNull: [ 0, 0 ] },
         },
       },
       {
@@ -3928,9 +4032,13 @@ export async function getUserAuditCount( req, res ) {
           fileDateISO: { $first: '$fileDateISO' },
           userId: { $first: '$userId' },
           minimumTarget: { $first: '$minimumTarget' },
+          afterCountCredit: { $first: '$afterCountCredit' },
           totalEarn: { $first: '$totalEarn' },
           totalReducedAmount: { $first: '$totalReducedAmount' },
           totalCredit: { $first: '$totalCredit' },
+          deductionByMinimumTarget: { $first: '$deductionByMinimumTarget' },
+          deductionBytimeSpent: { $first: '$deductionBytimeSpent' },
+          singleImageAmount: { $first: '$singleImageAmount' },
         },
       },
       {
@@ -3944,7 +4052,33 @@ export async function getUserAuditCount( req, res ) {
           fileDate: 1,
           fileDateISO: 1,
           minimumTarget: 1,
-          totalEarn: { $add: [ { $multiply: [ '$totalBeforeCount', beforeCountX ] }, { $multiply: [ '$totalAfterCount', afterCountY ] } ] },
+          singleImageAmount: { $cond: [ { $eq: [ '$moduleType', 'traffic' ] }, beforeCountTraffic, beforeCountZone ] },
+          beforeCountCredit: { $multiply: [ '$totalBeforeCount', { $cond: [ { $eq: [ '$moduleType', 'traffic' ] }, beforeCountTraffic, beforeCountZone ] } ] },
+          // afterCountCredit: { $cond: [ { $and: [
+          //   { $gte: [ { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] }, 0.4 ] }, { $lte: [ { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] }, 0.7 ] },
+          // ] }, 136,
+          // {
+          //   $cond: [ { $gt: [ { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] }, 0.7 ] },
+          //     { $subtract: [ 136, { $multiply: [ { $subtract: [ { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] }, 0.7 ] }, 136 ] } ] },
+          //     { $subtract: [ 136, { $multiply: [ { $subtract: [ 0.4, { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] } ] }, 136 ] } ] },
+          //   ],
+          // },
+          // ] },
+          afterCountCredit: afterCountCredit,
+          totalEarn: { $add: [ { $multiply: [ '$totalBeforeCount', { $cond: [ { $eq: [ '$moduleType', 'traffic' ] }, beforeCountTraffic, beforeCountZone ] } ] }, 136 ] },
+          deductionBytimeSpent: 1,
+          deductionByMinimumTarget: 1,
+          mappingperc: { $multiply: [ { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] }, 100 ] },
+          deductionByMapping: { $cond: [ { $and: [
+            { $gte: [ { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] }, 0.4 ] }, { $lte: [ { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] }, 0.7 ] },
+          ] }, 0,
+          {
+            $cond: [ { $gt: [ { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] }, 0.7 ] },
+              { $multiply: [ { $subtract: [ { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] }, 0.7 ] }, 136 ] },
+              { $multiply: [ { $subtract: [ 0.4, { $divide: [ '$totalAfterCount', '$totalBeforeCount' ] } ] }, 136 ] },
+            ],
+          },
+          ] },
           totalReducedAmount: 1,
           totalCredit: 1,
 
@@ -3958,16 +4092,36 @@ 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,
+          singleImageAmount: { $cond: [ { $eq: [ '$moduleType', 'traffic' ] }, beforeCountTraffic, beforeCountZone ] },
+          beforeCountCredit: 1,
+          afterCountCredit: 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',
           ] },
+          mappingperc: 1,
+          deductionByMapping: 1,
           totalCredit: { $subtract: [ '$totalEarn', '$totalReducedAmount' ] },
 
+
         },
       },
 
@@ -3978,18 +4132,39 @@ export async function getUserAuditCount( req, res ) {
           moduleType: 1,
           totalBeforeCount: 1,
           totalAfterCount: 1,
-          totalTimeSpent: 1,
+          totalTimeSpent: {
+            $cond: [ { $eq: [ '$hours', 0 ] },
+              { $concat: [
+                '00:', { $toString: '$minutes' }, ':00',
+              ] },
+              { $cond: [ { $eq: [ '$minutes', 0 ] },
+                { $concat: [
+                  { $toString: '$hours' }, ':00:00',
+                ] },
+                {
+                  $concat: [
+                    { $toString: '$hours' }, ':',
+                    { $toString: '$minutes' }, ':00',
+                  ],
+                },
+              ] },
+            ],
+
+          },
           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',
-            ] },
-
+          beforeCountCredit: 1,
+          afterCountCredit: 1,
+          totalEarn: 1,
+          deductionByMinimumTarget: 1,
+          singleImageAmount: 1,
+          deductionBytimeSpent: 1,
+          mappingperc: 1,
+          deductionByMapping: 1,
           totalCredit: { $subtract: [ '$totalEarn', '$totalReducedAmount' ] },
+          totalReducedAmount: { $round: [ { $add: [ '$deductionBytimeSpent', '$deductionByMinimumTarget', '$deductionByMapping' ] }, 2 ] },
+
         },
       },
       {
@@ -4021,15 +4196,23 @@ 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 ] },
-          totalCredit: { $round: [ { $subtract: [ '$totalEarn', '$totalReducedAmount' ] }, 2 ] },
+          beforeCountCredit: 1,
+          afterCountCredit: 1,
           totalEarn: { $round: [ '$totalEarn', 2 ] },
           minimumTarget: 1,
+          singleImageAmount: 1,
+          deductionByMinimumTarget: { $round: [ '$deductionByMinimumTarget', 2 ] },
+          deductionBytimeSpent: { $round: [ '$deductionBytimeSpent', 2 ] },
+          mappingperc: 1,
+          deductionByMapping: 1,
+          totalReducedAmount: 1,
+          totalCredit: { $round: [ { $subtract: [ '$totalEarn', '$totalReducedAmount' ] }, 2 ] },
           userEmail: '$users.email', // Access first element from array
-          userName: '$users.userName', // Access first element from array
+          userName: '$users.userName', // Access first element from array,
+
         },
       },
     ];
@@ -4354,35 +4537,80 @@ export async function auditViewLogs( req, res ) {
   try {
     const inputData = req.query;
     const parsedOpenSearch = JSON.parse( process.env.OPENSEARCH );
-    let downTimeQuery = {
+    const logData =[];
+    let logsQuery = {
       'size': 100,
       'query': {
         'bool': {
           'must': [
             {
               'term': {
-                'doc.logData.fileDate.keyword': dayjs( inputData.fileDate ).format( 'DD-MM-YYYY' ),
+                'logData.fileDate.keyword': inputData.fileDate,
               },
             },
             {
               'term': {
-                'doc.logData.storeId.keyword': inputData.storeId,
+                'logData.storeId.keyword': inputData.storeId,
               },
             },
             {
               'term': {
-                'doc.logData.moduleType.keyword': inputData.moduleType,
+                'logData.moduleType.keyword': inputData.moduleType,
+              },
+            },
+            {
+              'terms': {
+                'logSubType.keyword': [ 'auditDone', 'reAuditPush', 'reTrigger' ],
               },
             },
           ],
-
         },
       },
     };
-    const downtime = await getOpenSearchData( parsedOpenSearch.auditLog, downTimeQuery );
-    return res.sendSuccess( downtime );
-  } catch ( err ) {
-
+    const logs = await getOpenSearchData( parsedOpenSearch.auditLog, logsQuery );
+    if ( logs.body.hits.hits.length > 0 ) {
+      if ( logs.body.hits.hits[0]._source.logSubType == 'auditDone' ) {
+        const convertedTime = await convertTimestampToDateTime( logs.body.hits.hits[0]._source.logData.endTime );
+        logData.push( {
+          ...logs.body.hits.hits[0]._source, // Spread the _source object
+          time: convertedTime, // Add the converted time
+        } );
+      } else {
+        const convertedTime = await convertTimestampToDateTime( logs.body.hits.hits[0]._source.createdAt );
+        logData.push( {
+          ...logs.body.hits.hits[0]._source, // Spread the _source object
+          time: convertedTime, // Add the converted time
+        } );
+      }
+      return res.sendSuccess( logData );
+    } else {
+      return res.sendError( 'No Record Inserted', 204 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.info( { error: error, message: req.body, function: 'auditViewLogs' } );
+    return res.sendError( err, 500 );
   }
 }
 
+export async function convertTimestampToDateTime( timestamp ) {
+  // Check if the timestamp is too large (nanoseconds), then convert it to milliseconds
+  if ( timestamp > 9999999999999 ) {
+    timestamp = Math.floor( timestamp / 1000 ); // Convert to milliseconds if needed
+  }
+
+  // Create a new Date object
+  const date = new Date( timestamp );
+
+  // Format the date and time components
+  const year = date.getFullYear();
+  const month = ( '0' + ( date.getMonth() + 1 ) ).slice( -2 ); // Months are zero-based
+  const day = ( '0' + date.getDate() ).slice( -2 );
+
+  const hours = ( '0' + date.getHours() ).slice( -2 );
+  const minutes = ( '0' + date.getMinutes() ).slice( -2 );
+  const seconds = ( '0' + date.getSeconds() ).slice( -2 );
+
+  // Return formatted date and time string
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}