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

package/package.json

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

package/src/controllers/traxAudit.controllers.js

@@ -1,7 +1,15 @@
-import { checkFileExist, getDate, insertOpenSearchData, listFileByPath, logger, signedUrl, sqsReceive } from 'tango-app-api-middleware';
-import { aggregateBinaryAuditModel, createBinaryAudit } from '../service/binaryAudit.service.js';
+import { checkFileExist, download, getDate, getDateWithCustomizeTime, getUTC, insertOpenSearchData, listFileByPath, logger, signedUrl, sqsReceive } from 'tango-app-api-middleware';
+import { aggregateBinaryAudit, createBinaryAudit, updateOneBinaryAuditModel } from '../service/binaryAudit.service.js';
 import { findOneStore } from '../service/store.service.js';
 import { findOneUser } from '../service/user.service.js';
+import { aggregateUserEmpDetection, createUserEmpDetection } from '../service/userEmpDetection.service.js';
+import { aggregateTraxAuditData, findOneTraxAuditData } from '../service/traxAuditData.service.js';
+import { aggregateClient } from '../service/client.service.js';
+import dayjs from 'dayjs';
+import { aggregateAssignAudit } from '../service/assignAudit.service.js';
+import { aggregateStoreEmpDetection } from '../service/storeEmpDetection.service.js';
+import { listQueue } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
+import _ from 'lodash';
 
 
 export async function getDetectionAuditFile( req, res ) {
@@ -37,7 +45,7 @@ export async function getDetectionAuditFile( req, res ) {
       },
     ];
 
-    const userDetails = await aggregateUserAudit( userQuery );
+    const userDetails = await aggregateUserEmpDetection( userQuery );
     logger.info( { userDetails: userDetails, function: 'userDetails' } );
     const auditStatus =
         userDetails && userDetails.length > 0 ? userDetails[0].auditStatus : null;
@@ -380,7 +388,7 @@ export async function getDetectionAuditFile( req, res ) {
           moduleType: inputData.moduleType,
         };
 
-        insertData = await createUserAudit( record );
+        insertData = await createUserEmpDetection( record );
         await updateManyStoreAudit( query, storeRecord );
       } else {
         insertData = userDetails[0];
@@ -451,6 +459,403 @@ export async function getDetectionAuditFile( req, res ) {
   }
 }
 
+export async function workSpace( req, res ) {
+  try {
+    const inputData = req.body;
+    const limit = inputData.limit || 10;
+    const offset = inputData.offset ?
+        ( inputData.offset - 1 ) * limit :
+        0;
+    const dateRange = await getDate( new Date(), new Date() );
+    const filter =[
+      { status: { $in: [ 'active', 'hold' ] } },
+      { 'auditConfigs.audit': { $eq: true } },
+    ];
+    if ( inputData?.clientId?.length > 0 ) {
+      filter.push( { clientId: { $in: inputData.clientId } } );
+    }
+    const temp = [];
+    const clientQuery = [
+      {
+        $match: {
+          $and: filter,
+        },
+      },
+      {
+        $project: {
+          clientName: 1,
+          clientId: 1,
+          queueName: {
+            $cond: [
+              { $eq: [ inputData.moduleType, 'unattended-customer' ] }, '$auditConfigs.traxQueueName.unattendedCustomer',
+              { $cond: [
+                { $eq: [ inputData.moduleType, 'left-in-middle' ] }, '$auditConfigs.traxQueueName.leftInMiddle',
+                {
+                  $cond: [
+                    { $eq: [ inputData.moduleType, 'uniform-detection' ] }, '$auditConfigs.traxQueueName.uniformDetection',
+                    {
+                      $cond: [
+                        { $eq: [ inputData.moduleType, 'mobile-detection' ] }, '$auditConfigs.traxQueueName.mobileDetection', '$auditConfigs.traxQueueName.cameraAngleChange',
+                      ],
+                    },
+                  ],
+                },
+              ],
+              },
+            ],
+          },
+        },
+      },
+    ];
+
+
+    if ( inputData.searchValue && inputData.searchValue !== '' ) {
+      clientQuery.push( {
+        $match: {
+          $or: [
+            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
+            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    if ( inputData.sortColumnName ) {
+      const sortBy = inputData.sortBy || -1;
+      const sortColumn = inputData.sortColumnName;
+      clientQuery.push( {
+        $sort: { [sortColumn]: sortBy },
+      },
+      );
+    }
+
+    const count = await aggregateClient( clientQuery );
+    if ( count?.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+
+    if ( !inputData.isExport ) {
+      clientQuery.push( { $skip: offset }, { $limit: limit } );
+    }
+
+    const clientDetails = await aggregateClient( clientQuery );
+    const clientList = clientDetails.map( ( i ) => i.clientId );
+    const fileDate = dayjs( dateRange.start ).subtract( 1, 'days' );
+    const getStoreData = await findOneTraxAuditData(
+        {},
+        { fileDate: 1 },
+        { createdAt: -1 },
+    );
+    const latestDate = getStoreData?.fileDate || dayjs( fileDate ).format( 'DD-MM-YYYY' );
+    const auditStoreDataQuery = [
+      {
+        $match: {
+          clientId: { $in: clientList },
+          moduleType: { $eq: inputData.moduleType },
+          fileDate: { $eq: latestDate },
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $last: '$clientId' },
+          clientName: { $last: '$clientName' },
+          installedStore: { $last: '$installedStore' },
+          // queueName: { $last: '$queueName' },
+          totalCount: { $sum: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          clientId: 1,
+          clientName: 1,
+          installedStore: 1,
+          queueName: 1,
+          totalCount: 1,
+        },
+      },
+    ];
+
+    const completedStores = [
+      {
+        $match: {
+          $and: [
+            { clientId: { $in: clientList } },
+            { fileDate: { $eq: latestDate } },
+            { moduleType: { $eq: inputData.moduleType } },
+          ],
+        },
+      },
+      {
+        $project: {
+          clientId: 1,
+          completed: {
+            $cond: [ { $eq: [ '$status', 'completed' ] }, 1, 0 ],
+          },
+        },
+      },
+      // {
+      //   $group: {
+      //     _id: { clientId: '$clientId', storeId: '$storeId' },
+      //     clientId: { $first: '$clientId' },
+      //     completedStoresCount: { $sum: '$completed' },
+      //   },
+      // },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          // completedStoresCount: { $first: '$completedStoresCount' },
+          completedStoresCount: { $sum: '$completed' },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          clientId: 1,
+          completedStoresCount: 1,
+        },
+      },
+    ];
+
+    const auditFiles = [
+      {
+        $match: {
+          $and: [
+            { clientId: { $in: clientList } },
+            { createdAt: { $gte: dateRange.start } },
+            { createdAt: { $lte: dateRange.end } },
+            { moduleType: { $eq: inputData.moduleType } },
+          ],
+        },
+      },
+      {
+        $project: {
+          clientId: 1,
+          pending: {
+            $cond: [
+              { $or: [ { $in: [ '$auditStatus', [ 'inprogress', 'drafted' ] ] } ] },
+              1,
+              0,
+            ],
+          },
+        },
+      },
+      {
+        $group: {
+          _id: { clientId: '$clientId', storeId: '$storeId' },
+          clientId: { $first: '$clientId' },
+          pendingCount: { $sum: '$pending' },
+          totalFilesCount: { $sum: 1 },
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          pendingCount: { $first: { $ifNull: [ '$pendingCount', 0 ] } },
+          totalFilesCount: { $first: '$totalFilesCount' },
+        },
+      },
+    ];
+    const userIncompleteFiles = [
+      {
+        $match: {
+          $and: [
+            { clientId: { $in: clientList } },
+            { userId: { $eq: req.user._id } },
+            { moduleType: { $eq: inputData.moduleType } },
+            { createdAt: { $gte: dateRange.start } },
+            { createdAt: { $lte: dateRange.end } },
+          ],
+        },
+      },
+      {
+        $sort: {
+          updatedAt: -1,
+        },
+      },
+      {
+        $project: {
+          clientId: 1,
+          isDraft: 1,
+          draft: {
+            $cond: [ { $eq: [ '$auditStatus', 'drafted' ] }, 1, 0 ],
+          },
+          inprogress: {
+            $cond: [ { $eq: [ '$auditStatus', 'inprogress' ] }, 1, 0 ],
+          },
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          isDrafted: { $first: '$isDraft' },
+          userDraftCount: { $sum: '$draft' },
+          userInprogressCount: { $sum: '$inprogress' },
+        },
+      },
+    ];
+
+    const userAsignAudit = [
+      {
+        $match: {
+          $and: [
+            { userId: { $eq: req.user._id } },
+            { isCompleted: false },
+            { clientId: { $in: clientList } },
+            { moduleType: { $eq: inputData.moduleType } },
+          ],
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          userAsignedCount: { $sum: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          clientId: 1,
+          userAsignedCount: 1,
+        },
+      },
+    ];
+
+    const clientAssign = [
+      {
+        $match: {
+          $and: [ { isCompleted: false },
+            { clientId: { $in: clientList } },
+            { moduleType: { $eq: inputData.moduleType } },
+          ],
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          clientAsignedCount: { $sum: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          clientId: 1,
+          clientAsignedCount: { $ifNull: [ '$clientAsignedCount', 0 ] },
+        },
+      },
+    ];
+
+    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 userAsignAuditCount = await aggregateAssignAudit( userAsignAudit );
+    const completedStoresCount = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateStoreEmpDetection( completedStores ) : await aggregateBinaryAudit( completedStores );
+    const clientAssignedCount = await aggregateAssignAudit( clientAssign );
+    const auditStoreData = await aggregateTraxAuditData(
+        auditStoreDataQuery,
+    );
+
+    const mergeAll = _.merge(
+        _.keyBy( clientDetails, 'clientId' ),
+        _.keyBy( auditUserCount, 'clientId' ),
+        _.keyBy( userIncompleteFilesCount, 'clientId' ),
+        _.keyBy( clientAssignedCount, 'clientId' ),
+    );
+    const finalResult = _.values( mergeAll );
+    const merge = _.values(
+        _.merge(
+            _.keyBy( finalResult, 'clientId' ),
+            _.keyBy( auditStoreData, 'clientId' ),
+            _.keyBy( userAsignAuditCount, 'clientId' ),
+            _.keyBy( completedStoresCount, 'clientId' ),
+        ),
+    );
+    let totalStores = 0;
+    for ( let i = 0; i < merge.length; i++ ) {
+      totalStores = merge[i]?.totalCount || 0;
+
+      const pending = await listQueue( merge[i].queueName );
+
+      if ( !pending.statusCode ) {
+        temp.push( {
+          clientId: merge[i].clientId,
+          clientName: merge[i].clientName,
+          completedStoresCount: merge[i].completedStoresCount ?
+              Number( merge[i].completedStoresCount ) :
+              0,
+          pendingByQueue: Number( pending ),
+          pendingByUser:
+              merge[i].pendingCount >= 0 ?
+                Number( merge[i].pendingCount ) +
+                  ( merge[i].clientAsignedCount ?
+                    Number( merge[i].clientAsignedCount ) :
+                    0 ) :
+                0,
+          totalCount: merge[i].totalCount,
+          queueName: merge[i].queueName,
+          isDraft: merge[i]?.isDrafted || false,
+          isEnable:
+              Number( pending ) > 0 ||
+              merge[i].isDrafted ||
+              ( merge[i].userAsignedCount && merge[i].userAsignedCount > 0 ) ||
+              ( merge[i].userInprogressCount && merge[i].userInprogressCount > 0 ) ?
+                1 :
+                0,
+          completedRatio: merge[i].totalCount ?
+              merge[i].completedStoresCount ?
+                Math.round(
+                    ( Number( merge[i].completedStoresCount ) /
+                      Number( merge[i].totalCount ) ) *
+                      100,
+                ) :
+                0 :
+              0,
+          isAssigned:
+              merge[i].userAsignedCount && merge[i].userAsignedCount > 0 ?
+                true :
+                false,
+          Assignedcount:
+              merge[i].userAsignedCount && merge[i].userAsignedCount > 0 ?
+                merge[i].userAsignedCount :
+                0,
+        } );
+      }
+    }
+
+    if ( inputData.isExport ) {
+      const exportdata = [];
+      temp.forEach( ( element ) => {
+        exportdata.push( {
+          'Client Name': element.clientName,
+          'Client Id': element.clientId,
+          'Completed stores Count': element.completedStoresCount,
+          'Completed Percentage': element.completedRatio + ' %',
+          'Pending Queue': element.pendingByQueue,
+          'Pending User': element.pendingByUser,
+          'Draft': element.isDraft ? 1 : 0,
+          'Assigned': element.Assignedcount,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    } else {
+      return res.sendSuccess( {
+        result: temp,
+        count: count.length,
+        totalStores: totalStores,
+      } );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.info( { error: error, message: req.query, function: 'workSpace' } );
+    return res.sendError( err, 500 );
+  }
+}
+
 export async function getAuditFile( req, res ) {
   try {
     const inputData = req.query;
@@ -480,7 +885,7 @@ export async function getAuditFile( req, res ) {
       },
     ];
 
-    const userDetails = await aggregateBinaryAuditModel( userQuery );
+    const userDetails = await aggregateBinaryAudit( userQuery );
     logger.info( { userDetails: userDetails, function: 'userDetails' } );
     const auditStatus = userDetails && userDetails.length > 0 ? userDetails[0].auditStatus : null;
 
@@ -728,6 +1133,7 @@ export async function getAuditFile( req, res ) {
       question: msg.question,
       questionType: msg.questionType,
       streamName: msg.streamName,
+      auditId: insertData._id,
     } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
@@ -735,3 +1141,342 @@ export async function getAuditFile( req, res ) {
     return res.sendError( err, 500 );
   }
 }
+
+export async function saveBinary( req, res ) {
+  try {
+    const inputData = req.body;
+
+    switch ( inputData.moduleType ) {
+      case 'unattended-customer':
+        let unattendedquery ={
+          _id: inputData.auditId,
+          storeId: inputData.storeId,
+          fileDate: inputData.fileDate,
+          tempId: inputData.tempId,
+          moduleType: inputData.moduleType,
+        };
+
+        let update={
+          auditStatus: 'completed',
+          answer: inputData.answer,
+        };
+        let updatDataunattended= await updateOneBinaryAuditModel( unattendedquery, update );
+        if ( updatDataunattended.modifiedCount==0 ) {
+          return res.sendError( updatDataunattended, 204 );
+        }
+        logger.info( 'update in binary data', { query: unattendedquery, update: update } );
+        res.sendSuccess( `Successfully update in ${inputData.moduleType} ` );
+
+        break;
+
+      case 'left-in-middle':
+        let leftquery ={
+          _id: inputData.auditId,
+          storeId: inputData.storeId,
+          fileDate: inputData.fileDate,
+          question: inputData.question,
+          moduleType: inputData.moduleType,
+        };
+        let leftupdate={
+          auditStatus: 'completed',
+          answer: inputData.answer,
+        };
+        let updatDataleft= await updateOneBinaryAuditModel( leftquery, leftupdate );
+        if ( updatDataleft.modifiedCount==0 ) {
+          return res.sendError( updatDataleft, 204 );
+        }
+        logger.info( 'update in binary data', { query: leftquery, update: leftupdate } );
+        res.sendSuccess( `Successfully update in ${inputData.moduleType} ` );
+
+        break;
+
+      case 'camera-angle-change':
+        let cameraquery ={
+          _id: inputData.auditId,
+          storeId: inputData.storeId,
+          fileDate: inputData.fileDate,
+          streamName: inputData.streamName,
+          moduleType: inputData.moduleType,
+        };
+        let cameraupdate={
+          auditStatus: 'completed',
+          answer: inputData.answer,
+        };
+        let updatDatacamera= await updateOneBinaryAuditModel( cameraquery, cameraupdate );
+        if ( updatDatacamera.modifiedCount==0 ) {
+          return res.sendError( updatDatacamera, 204 );
+        }
+        logger.info( 'update in binary data', { query: cameraquery, update: cameraupdate } );
+        res.sendSuccess( `Successfully update in ${inputData.moduleType} ` );
+
+        break;
+
+      default:
+        res.sendError( 'no data', 204 );
+        break
+        ;
+    }
+  } catch ( error ) {
+    const err = error.mesage || 'Internal Server Error';
+    logger.error( { error: error, data: req.body, function: 'saveBinary' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function userAuditHistory( req, res ) {
+  try {
+    const inputData = req.body;
+    const userId = inputData.userId? new mongoose.Types.ObjectId( inputData.userId ) : req.user._id;
+    const limit = inputData.limit || 10;
+    const offset = inputData.offset ? ( inputData.offset - 1 ) * limit : 0;
+    const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
+    const dateRangeCreatedAt = await getDateWithCustomizeTime( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
+    let filter = [
+      { userId: { $eq: userId } },
+      { moduleType: { $eq: inputData.moduleType } },
+    ];
+
+    if ( inputData.dateType == 'fileDate' ) {
+      filter.push(
+          { fileDateISO: { $gte: dateRange.start } },
+          { fileDateISO: { $lte: dateRange.end } },
+      );
+    } else {
+      filter.push(
+          { createdAt: { $gte: dateRangeCreatedAt.start } },
+          { createdAt: { $lte: dateRangeCreatedAt.end } },
+      );
+    }
+
+
+    if ( inputData.filterByAuditType?.length > 0 ) {
+      filter.push( {
+        auditType: { $in: inputData.filterByAuditType },
+      } );
+    }
+
+    if ( inputData.filterByStoreId?.length > 0 ) {
+      filter.push( {
+        storeId: { $in: inputData.filterByStoreId },
+      } );
+    }
+
+    if ( inputData.filterByStatus?.length > 0 ) {
+      filter.push( {
+        auditStatus: { $in: inputData.filterByStatus },
+      } );
+    }
+    if ( inputData?.clientId?.length > 0 ) {
+      filter.push( { clientId: { $in: inputData.clientId } } );
+    }
+    const query = [
+      {
+        $match: {
+          $and: filter,
+        },
+      },
+      {
+        $lookup: {
+          from: 'stores',
+          let: { storeId: '$storeId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$storeId', '$$storeId' ],
+                },
+              },
+            },
+            {
+              $project: {
+                storeName: 1,
+              },
+            },
+          ], as: 'store',
+        },
+      },
+      {
+        $unwind: {
+          path: '$store', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $lookup: {
+          from: 'clients',
+          let: { clientId: '$clientId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$clientId', '$$clientId' ],
+                },
+              },
+            },
+            {
+              $project: {
+                clientName: 1,
+              },
+            },
+          ], as: 'client',
+        },
+
+      },
+      {
+        $unwind: {
+          path: '$client', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $project: {
+          storeId: 1,
+          userId: 1,
+          tempId: 1,
+          streamName: 1,
+          question: 1,
+          answer: 1,
+          storeName: '$store.storeName',
+          clientId: 1,
+          clientName: '$client.clientName',
+          fileDate: 1,
+          auditType: 1,
+          zoneName: 1,
+          moduleType: 1,
+          beforeCount: 1,
+          afterCount: 1,
+          accuracy: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, { $round: [
+            {
+              $multiply: [ { $divide: [ '$afterCount', '$beforeCount' ] }, 100 ],
+            }, 1,
+          ],
+          }, null ] },
+
+          startTime: {
+            $dateToString: {
+              format: '%Y-%m-%d %H:%M:%S',
+              date: '$startTime',
+              timezone: 'Asia/Kolkata',
+            },
+          },
+          endTime: {
+            $dateToString: {
+              format: '%Y-%m-%d %H:%M:%S',
+              date: '$endTime',
+              timezone: 'Asia/Kolkata',
+            },
+          },
+          // timeSpent: { $round: [
+          //   { $divide: [ '$timeSpent', 60 ] }, 2,
+          // ] },
+          timeSpent: {
+
+            $cond: [
+              { $lt: [ '$timeSpent', 60 ] }, // Case 1: If less than 60 seconds
+              { $concat: [ { $toString: '$timeSpent' }, ' sec' ] },
+              {
+                $cond: [
+                  { $lt: [ '$timeSpent', 3600 ] }, // Case 2: If less than 60 minutes (3600 seconds)
+                  {
+                    $concat: [
+                      { $toString: { $round: [ { $divide: [ '$timeSpent', 60 ] }, 1 ] } }, // Convert to minutes
+                      ' min',
+                    ],
+                  },
+                  {
+                    $concat: [
+                      { $toString: { $round: [ { $divide: [ '$timeSpent', 3600 ] }, 1 ] } }, // Convert to hours
+                      ' hr',
+                    ],
+                  },
+                ],
+              },
+            ],
+
+          },
+          auditStatus: 1,
+          createdAt: 1,
+        },
+      },
+    ];
+
+    if ( inputData.searchValue && inputData.searchValue!== '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
+            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
+            { storeId: { $regex: inputData.searchValue, $options: 'i' } },
+            { storeName: { $regex: inputData.searchValue, $options: 'i' } },
+            { streamName: { $regex: inputData.searchValue, $options: 'i' } },
+            { moduleType: { $regex: inputData.searchValue, $options: 'i' } },
+            { auditType: { $regex: inputData.searchValue, $options: 'i' } },
+            { auditStatus: { $regex: inputData.searchValue, $options: 'i' } },
+            { tempId: { $regex: inputData.searchValue, $options: 'i' } },
+            { question: { $regex: inputData.searchValue, $options: 'i' } },
+          ],
+
+        },
+      } );
+    }
+
+    if ( inputData.sortColumnName ) {
+      const sortBy = inputData.sortBy || -1;
+      const sortColumn = inputData.sortColumnName;
+      query.push( {
+        $sort: { [sortColumn]: sortBy },
+      },
+      );
+    }
+    const count = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
+    if ( count.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+
+    if ( inputData.isExport ) {
+      const chunkedMappingData = await chunkArray( count, 10 );
+      const promises = chunkedMappingData.map( async ( chunk ) => {
+        const exportData = [];
+        chunk.forEach( ( element ) => {
+          exportData.push( {
+            'File Date': element.fileDate,
+            'Brand ID': element.clientId,
+            'Brand Name': element.clientName,
+            'Store ID': element.storeId,
+            'Store Name': element.storeName,
+            'Stream Name': element.moduleType == 'camera-angle-change'? element.zoneName : '',
+            'Audit Type': element.auditType,
+            'Product Type': element.moduleType,
+            'Before Count': element.beforeCount,
+            'After Count': element.afterCount || '',
+            'Accuracy': element.accuracy || '',
+            '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' ),
+
+          } );
+        } );
+        return exportData;
+      } );
+      const mappedArrays = await Promise.all( promises );
+      mappedArrays.flat();
+      logger.info( { mappedArrays: mappedArrays[0] } );
+      await download( mappedArrays[0], res );
+      return;
+    }
+
+    query.push( {
+      $skip: offset,
+    },
+    {
+      $limit: limit,
+    } );
+    const result = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateUserEmpDetection( query ) : await aggregateBinaryAudit( query );
+
+    return res.sendSuccess( { result: result, count: count.length } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.info( { error: error, message: req.body, function: 'userAuditHistory' } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/docs/traxAudit.docs.js

@@ -1,5 +1,5 @@
 import j2s from 'joi-to-swagger';
-import { getFileSchema } from '../dtos/traxAudit.dtos.js';
+import { getFileSchema, userAuditHistorySchema, workSpaceSchema, saveSchema } from '../dtos/traxAudit.dtos.js';
 
 export const traxAuditDocs = {
 
@@ -43,4 +43,72 @@ export const traxAuditDocs = {
       },
     },
   },
+
+  '/v3/trax-audit/work-space': {
+    post: {
+      tags: [ 'Trax Audit' ],
+      description: 'queue wise info of audit files ',
+      operationId: 'work-space',
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( workSpaceSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/trax-audit/save-binary-audit': {
+    post: {
+      tags: [ 'Trax Audit' ],
+      description: 'Save binay data type',
+      operationId: 'save-binary-audit',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( saveSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/trax-audit/metrics/user-audit-history': {
+    post: {
+      tags: [ 'Trax Audit' ],
+      description: `Get list of user wise audit user details with date range`,
+      operationId: 'metrics/user-audit-history',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( userAuditHistorySchema ).swagger,
+          },
+        },
+      },
+      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

@@ -68,18 +68,11 @@ 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(),
+      tempId: joi.number().optional(),
       moduleType: joi.string().required(),
-      zoneName: joi.string().required(),
+      question: joi.string().optional(),
+      streamName: joi.string().optional(),
+      answer: joi.string().required(),
     },
 );
 
@@ -103,3 +96,28 @@ export const workSpaceSchema = joi.object(
 export const workSpaceValid = {
   body: workSpaceSchema,
 };
+
+export const userAuditHistorySchema = joi.object(
+    {
+      userId: joi.string().optional(),
+      fromDate: joi.string().required(),
+      toDate: joi.string().required(),
+      dateType: joi.string().required(),
+      clientId: joi.array().optional(),
+      filterByStoreId: joi.array().required(),
+      moduleType: joi.string().required(),
+      filterByAuditType: joi.array().optional(),
+      filterByStatus: joi.array().optional(),
+      searchValue: joi.string().optional().allow( '' ),
+      limit: joi.number().optional(),
+      offset: joi.number().optional(),
+      sortColumnName: joi.string().optional(),
+      sortBy: joi.number().optional(),
+      isExport: joi.boolean().optional(),
+
+    },
+);
+
+export const userAuditHistoryValid = {
+  body: userAuditHistorySchema,
+};

package/src/routes/traxAudit.routes.js

@@ -1,17 +1,26 @@
 import { Router } from 'express';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { getDetectionFileValid, getFileValid } from '../dtos/traxAudit.dtos.js';
+import { getDetectionFileValid, getFileValid, userAuditHistoryValid, workSpaceValid, saveValid } from '../dtos/traxAudit.dtos.js';
 import { isExistsQueue } from '../validation/audit.validation.js';
-import { getAuditFile, getDetectionAuditFile } from '../controllers/traxAudit.controllers.js';
+import { getAuditFile, getDetectionAuditFile, saveBinary, userAuditHistory, workSpace } from '../controllers/traxAudit.controllers.js';
+import { validateBinaryAudit } from '../validation/traxAuditValidation.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.get( '/get-file-detection', 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 );
+// traxAuditRouter.post( '/save', isAllowedSessionHandler, validate( saveValid ), validateUserEmpDetection, save );        use this validateuserEMpDetection
+traxAuditRouter.post( '/work-space', isAllowedSessionHandler, validate( workSpaceValid ), workSpace );
+
+
+// Y/n
+traxAuditRouter.get( '/get-file', isAllowedSessionHandler, validate( getFileValid ), isExistsQueue, getAuditFile ); // remove the reaudit concept
+traxAuditRouter.post( '/save-binary-audit', isAllowedSessionHandler, validate( saveValid ), validateBinaryAudit, saveBinary ); // need to add valid joi function, saveBinary function
 
 export default traxAuditRouter;
+
+// metrcis
+traxAuditRouter.post( '/metrics/user-audit-history', isAllowedSessionHandler, validate( userAuditHistoryValid ), userAuditHistory );

package/src/service/binaryAudit.service.js

@@ -5,6 +5,14 @@ export function createBinaryAudit( record ) {
   return binaryAuditModel.create( record );
 }
 
-export function aggregateBinaryAuditModel( query ) {
+export function aggregateBinaryAudit( query ) {
   return binaryAuditModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
 }
+
+export function findOneBinaryAudit( query ) {
+  return binaryAuditModel.findOne( query );
+}
+
+export function updateOneBinaryAuditModel( query, record ) {
+  return binaryAuditModel.updateOne( query, { $set: record } );
+}

package/src/service/storeEmpDetection.service.js

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

package/src/service/traxAuditData.service.js

@@ -0,0 +1,10 @@
+
+import traxAuditDataModel from 'tango-api-schema/schema/traxAuditData.model.js';
+
+export function findOneTraxAuditData( query, fields, sort ) {
+  return traxAuditDataModel.findOne( query, fields ).sort( sort );
+}
+
+export function aggregateTraxAuditData( query ) {
+  return traxAuditDataModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
+}

package/src/service/userEmpDetection.service.js

@@ -1,6 +1,14 @@
 import userEmpDetectionModel from 'tango-api-schema/schema/userEmpDetection.model.js';
 
 
-export function aggregateUserAudit( query ) {
+export function aggregateUserEmpDetection( query ) {
   return userEmpDetectionModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
 }
+
+export function createUserEmpDetection( record ) {
+  return userEmpDetectionModel.create( record );
+}
+
+export function findOneUserEmpDetection( query, fields ) {
+  return userEmpDetectionModel.findOne( query, fields );
+}

package/src/validation/traxAuditValidation.js

@@ -0,0 +1,39 @@
+import { findOneBinaryAudit } from '../service/binaryAudit.service.js';
+import { findOneUserEmpDetection } from '../service/userEmpDetection.service.js';
+
+
+export async function validateUserEmpDetection( req, res, next ) {
+  try {
+    const inputData = req.body;
+    const userAuditDetails =await findOneUserEmpDetection( { _id: inputData.auditId } );
+    if ( !userAuditDetails ) {
+      return res.sendError( 'No Data Available' );
+    } else if ( userAuditDetails && userAuditDetails.auditStatus == 'skipped' ) {
+      return res.sendError( 'The Audit file Assigned to some one else', 203 );
+    }
+    req.userAudit = userAuditDetails;
+    next();
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'validateUserEmpDetection' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function validateBinaryAudit( req, res, next ) {
+  try {
+    const inputData = req.body;
+    const userAuditDetails =await findOneBinaryAudit( { _id: inputData.auditId } );
+    if ( !userAuditDetails ) {
+      return res.sendError( 'No Data Available' );
+    } else if ( userAuditDetails && userAuditDetails.auditStatus == 'completed' ) {
+      return res.sendError( 'Forbidden to this action', 203 );
+    }
+    req.userAudit = userAuditDetails;
+    next();
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'validateBinaryAudit' } );
+    return res.sendError( err, 500 );
+  }
+}