tango-app-api-audit 1.0.24 → 1.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-audit",
-    "version": "1.0.24",
+    "version": "1.0.26",
     "description": "audit & audit metrics apis",
     "main": "index.js",
     "type": "module",
@@ -23,7 +23,7 @@
         "mongodb": "^6.7.0",
         "nodemon": "^3.1.3",
         "swagger-ui-express": "^5.0.1",
-        "tango-api-schema": "^2.0.122",
+        "tango-api-schema": "^2.0.124",
         "tango-app-api-middleware": "^3.1.24",
         "winston": "^3.13.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/auditMetrics.controllers.js

@@ -1,8 +1,13 @@
-import { download, getUTC, logger } from 'tango-app-api-middleware';
+import { download, getUTC, insertOpenSearchData, logger, sendMessageToQueue } from 'tango-app-api-middleware';
 import { aggregateAuditClientData } from '../service/auditClientData.service.js';
-import { aggregateUserAudit } from '../service/userAudit.service.js';
+import { aggregateUserAudit, findOneUserAudit, updateOneUserAudit } from '../service/userAudit.service.js';
 import mongoose from 'mongoose';
-import { aggregateStoreAudit } from '../service/storeAudit.service.js';
+import { aggregateStoreAudit, updateOneStoreAudit } from '../service/storeAudit.service.js';
+import { findOneUser } from '../service/user.service.js';
+import dayjs from 'dayjs';
+import { createAssignAudit } from '../service/assignAudit.service.js';
+import { countDocumentsStore } from '../service/store.service.js';
+import { findOneClient } from '../service/client.service.js';
 // import { listQueue } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
 
 export async function userAuditHistory( req, res ) {
@@ -800,9 +805,10 @@ export async function summarySplit( req, res ) {
       auditInprogress: 0,
       reAuditInprogress: 0,
       draft: 0,
-      notAssigned: 0,
+      assigned: 0,
       auditCompleted: 0,
       reAuditCompleted: 0,
+      completedCount: 0,
     };
 
     const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
@@ -885,7 +891,6 @@ export async function summarySplit( req, res ) {
           completedCount: 1,
           reAuditCompleted: 1,
           auditCompleted: 1,
-          completedCount: 1,
 
         },
       },
@@ -1043,10 +1048,19 @@ export async function overAllAuditSummary( req, res ) {
   try {
     const inputData = req.body;
     let temp = {
+      installedStores: 0,
+      auditStores: 0,
+      inprogreseStores: 0,
+      completedStores: 0,
+      auditInprogress: 0,
+      reAuditInprogress: 0,
+      draft: 0,
+      assigned: 0,
+      notAssigned: 0,
+      auditCompleted: 0,
+      reAuditCompleted: 0,
 
     };
-    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 ) );
     let filters =[
       { fileDateISO: { $gte: dateRange.start } },
@@ -1056,8 +1070,27 @@ export async function overAllAuditSummary( req, res ) {
     if ( inputData.clientId.length > 0 ) {
       filters.push( { clientId: { $in: inputData.clientId } } );
     }
+    const storeQuery = inputData.clientId.length? { 'edge.firstFile': true, 'clientId': { $in: inputData. clientId } } : { 'edge.firstFile': true };
+    temp.installedStores = await countDocumentsStore( storeQuery );
+    const auditClientDataQuery =[
+      {
+        $match: {
+          $and: filters,
+        },
 
-    const query =[
+      },
+      {
+        $group: {
+          _id: null,
+          totalFilesCount: { $sum: '$totalFilesCount' },
+        },
+      },
+    ];
+    const auditClientData = await aggregateAuditClientData( auditClientDataQuery );
+    if ( auditClientData.length >0 ) {
+      temp.auditStores = auditClientData[0].totalFilesCount;
+    }
+    const storeAuditQuery =[
       {
         $match: {
           $and: filters,
@@ -1066,107 +1099,191 @@ export async function overAllAuditSummary( req, res ) {
       },
       {
         $project: {
-          _id: 0,
-          storeId: 1,
-          fileDate: 1,
-          beforeCount: 1,
-          startTime: 1,
-          auditType: 1,
-          auditStatus: 1,
-          userId: 1,
+          completedStores: { $cond: [ { $eq: [ '$status', 'completed' ] }, 1, 0 ] },
+          auditInprogress: { $cond: [ { $and: [ { $in: [ '$status', [ 'inprogress' ] ] }, { $eq: [ '$auditType', 'Audit' ] } ] }, 1, 0 ] },
+          reAuditInprogress: { $cond: [ { $and: [ { $in: [ '$status', [ 'inprogress' ] ] }, { $eq: [ '$auditType', 'ReAudit' ] } ] }, 1, 0 ] },
+          draft: { $cond: [ { $eq: [ '$status', 'drafted' ] }, 1, 0 ] },
+          assigned: { $cond: [ { $eq: [ '$status', 'drafted' ] }, 1, 0 ] },
+          exceptNoAssigned: { $cond: [ { $in: [ '$status', [ 'skipped', 'not_assign' ] ] }, 1, 0 ] },
+          auditCompleted: { $cond: [ { $and: [ { $in: [ '$status', [ 'completed' ] ] }, { $eq: [ '$auditType', 'Audit' ] } ] }, 1, 0 ] },
+          reAuditCompleted: { $cond: [ { $and: [ { $in: [ '$status', [ 'completed' ] ] }, { $eq: [ '$auditType', 'ReAudit' ] } ] }, 1, 0 ] },
 
 
         },
       },
       {
-        $lookup: {
-          from: 'users',
-          let: { userId: '$userId' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$_id', '$$userId' ],
-                },
-              },
-            },
-            {
-              $project: {
-                userName: 1,
-                userEmail: '$email',
-              },
-            },
-          ], as: 'user',
-        },
-      },
-      {
-        $unwind: {
-          path: '$user',
-          preserveNullAndEmptyArrays: true,
+        $group: {
+          _id: null,
+          completedStores: { $sum: '$completedStores' },
+          auditInprogress: { $sum: '$auditInprogress' },
+          reAuditInprogress: { $sum: '$reAuditInprogress' },
+          draft: { $sum: '$draft' },
+          assigned: { $sum: '$assigned' },
+          exceptNoAssigned: { $sum: '$exceptNoAssigned' },
+          auditCompleted: { $sum: '$auditCompleted' },
+          reAuditCompleted: { $sum: '$reAuditCompleted' },
         },
       },
       {
         $project: {
-          storeId: 1,
-          fileDate: 1,
-          beforeCount: 1,
-          startTime: 1,
-          auditType: 1,
-          auditStatus: 1,
-          userName: '$users.userName',
-          userEmail: '$users.userEmail',
-
+          completedStores: 1,
+          inprogressStores: { $subtract: [ temp.auditStores, '$completedStores' ] },
+          auditInprogress: 1,
+          reAuditInprogress: 1,
+          draft: 1,
+          assigned: 1,
+          exceptNoAssigned: { $subtract: [ temp.auditStores, '$exceptNoAssigned' ] },
+          auditCompleted: 1,
+          reAuditCompleted: 1,
         },
       },
     ];
-
-    if ( inputData.sortColumnName ) {
-      const sortBy = inputData.sortBy || -1;
-      query.push( {
-        $sort: { [inputData.sortColumName]: sortBy },
-      },
-      );
+    const storeAudit = await aggregateStoreAudit( storeAuditQuery );
+    if ( storeAudit.length > 0 ) {
+      temp.inprogreseStores= storeAudit[0].inprogreseStores;
+      temp.completedStores = storeAudit[0].completedStores;
+      temp.auditInprogress = storeAudit[0].auditInprogress;
+      temp.reAuditInprogress = storeAudit[0].reAuditInprogress;
+      temp.draft = storeAudit[0].draft;
+      temp.assigned = storeAudit[0].assigned;
+      temp.notAssigned = storeAudit[0].exceptNoAssigned;
+      temp.auditCompleted = storeAudit[0].auditCompleted;
+      temp.reAuditCompleted = storeAudit[0].reAuditCompleted;
     }
 
-    const count = await aggregateAuditClientData( query );
-    if ( count.length == 0 ) {
-      return res.sendError( 'No Data Found', 204 );
+    return res.sendSuccess( { result: temp } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'summarySplit' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function reTrigger( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.body;
+    const sqs = JSON.parse( process.env.SQS );
+    const userAudit = await findOneUserAudit( { _id: inputData.auditId } );
+    const query ={
+      storeId: inputData.storeId,
+      fileDate: inputData.fileDate,
+    };
+    const getQueueName = await findOneClient( { clientId: req.audit.clientId }, { 'auditConfigs.queueName': 1 } );
+
+    if ( !getQueueName || getQueueName?.auditConfigs?.queueName == '' ) {
+      return res.sendError( 'queueName does not create', 400 );
     }
-    if ( !inputData.isExport ) {
-      query.push( {
-        $skip: offset,
-      },
-      {
-        $limit: limit,
-      } );
-    } else {
-      query.push( { $limit: 10000 } );
+    const queueName = getQueueName?.auditConfigs?.queueName;
+    logger.info( { queueName: queueName } );
+    switch ( inputData.triggerType ) {
+      case 'queue':
+        const msg = {
+          store_id: inputData.storeId,
+          curr_date: inputData.fileDate,
+          audit_type: inputData.auditType,
+          total_count: inputData.totalCount,
+        };
+
+        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 ( userAudit?.auditStatus !== 'completed' ) {
+            const userRecord ={
+              auditStatus: 'skipped',
+              isDraft: false,
+            };
+            await updateOneUserAudit( { _id: inputData.auditId }, userRecord );
+          }
+
+          const storeRecord ={
+            status: userAudit?.auditStatus !== 'completed' ? 'skipped': 'not_assign',
+          };
+
+          await updateOneStoreAudit( query, storeRecord );
+          const logData = {
+            userId: req.user._id,
+            userName: req.user.userName,
+            logType: 'audit',
+            logSubType: 'reTrigger',
+            logData: {
+              beforeCount: inputData.totalCount,
+              afterCount: '',
+              fileDate: inputData.fileDate,
+              auditType: inputData.auditType,
+              storeId: inputData.storeId,
+              queueName: queueName,
+              auditId: inputData.auditId,
+              message: inputData.comments,
+              triggerBy: req.user.userName,
+              triggerId: req.user._id,
+              triggerType: inputData.triggerType,
+            },
+          };
+          await insertOpenSearchData( openSearch.activityLog, logData );
+        }
+        break;
+      case 'user':
+        const assignUser = await findOneUser( { _id: new mongoose.Types.ObjectId( inputData.userId ) } );
+        const assignUserRecord = {
+          storeId: inputData.storeId,
+          clientId: req.audit.clientId,
+          fileDate: inputData.fileDate,
+          fileDateISO: dayjs( inputData.fileDate, 'DD-MM-YYYY' ).format(),
+          auditType: inputData.auditType,
+          fileCount: inputData.beforeCount,
+          queueName: queueName,
+          userId: inputData.userId,
+          userName: assignUser.userName,
+        };
+        await createAssignAudit( assignUserRecord );
+
+        if ( userAudit?.auditStatus !== 'completed' ) {
+          const userRecord ={
+            auditStatus: 'skipped',
+            isDraft: false,
+          };
+          await updateOneUserAudit( { _id: inputData.auditId }, userRecord );
+        }
+
+        const storeRecord ={
+          status: userAudit?.auditStatus !== 'completed' ? 'skipped': 'assigned',
+        };
+
+        await updateOneStoreAudit( query, storeRecord );
+        const logData = {
+          userId: req.user._id,
+          userName: req.user.userName,
+          logType: 'audit',
+          logSubType: 'reTrigger',
+          logData: {
+            beforeCount: inputData.totalCount,
+            afterCount: '',
+            fileDate: inputData.fileDate,
+            auditType: inputData.auditType,
+            storeId: inputData.storeId,
+            queueName: queueName,
+            auditId: inputData.auditId,
+            message: inputData.comments,
+            triggerBy: req.user.userName,
+            triggerId: req.user._id,
+            triggerType: inputData.triggerType,
+          },
+        };
+        await insertOpenSearchData( openSearch.activityLog, logData );
     }
 
-    const result = await aggregateStoreAudit( query );
-    if ( inputData.isExport ) {
-      const exportdata = [];
-      result.forEach( ( element ) => {
-        exportdata.push( {
-          'File Date': element.storeId,
-          'Store Id': element.fileDtae,
-          'Store Name': element.audittype,
-          'User Name': element.beforeCount,
-          'user Email': element.startTime,
-          'Audit Type': element.userName,
-          'Before Count': element.userEmail,
-          'After Count': element.auditStatus,
-          'Accuracy': element.Accuracy,
-          'Status': element.status,
-        } );
-      } );
-      await download( exportdata, res );
-      return;
-    }
-    return res.sendSuccess( { result: result.length> 0? result[0]: temp } );
+    return res.sendSuccess( { result: 'The File has been Re Trigger Succesfully' } );
   } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, message: req.body, function: 'summarySplit' } );
+    const err = error.message;
+    logger.error( { error: error, message: req.body } );
     return res.sendError( err, 500 );
   }
 }

package/src/docs/auditMetrics.docs.js

@@ -1,5 +1,5 @@
 import j2s from 'joi-to-swagger';
-import { clientMetricsSchema, getAuditImagesSchema, overViewCardSchema, overViewTableSchema, storeMetricsSchema, summarySplitSchema, userAuditHistorySchema, userMetricsSchema } from '../dtos/auditMetrics.dtos.js';
+import { clientMetricsSchema, getAuditImagesSchema, overAllAuditSummarySchema, overViewCardSchema, overViewTableSchema, reTriggerValidSchema, storeMetricsSchema, summarySplitSchema, userAuditHistorySchema, userMetricsSchema } from '../dtos/auditMetrics.dtos.js';
 
 export const auditMetricsDocs = {
 
@@ -179,4 +179,48 @@ export const auditMetricsDocs = {
       },
     },
   },
+  '/v3/audit-metrics/overall-audit-summary': {
+    post: {
+      tags: [ 'Audit Metrics' ],
+      description: `Get overall user taken data with some filters `,
+      operationId: 'overall-audit-summary',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( overAllAuditSummarySchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+  '/v3/audit-metrics/re-trigger': {
+    post: {
+      tags: [ 'Audit Metrics' ],
+      description: `Manual re trigger a file`,
+      operationId: '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/auditMetrics.dtos.js

@@ -150,3 +150,19 @@ export const overAllAuditSummarySchema = joi.object(
 export const overAllAuditSummaryValid = {
   body: overAllAuditSummarySchema,
 };
+
+export const reTriggerValidSchema = joi.object(
+    {
+      fileDate: joi.string().required(),
+      storeId: joi.string().required(),
+      auditType: joi.string().optional(),
+      triggerType: joi.string().optional(),
+      totalCount: joi.number().required(),
+      userId: joi.string().optional(),
+      auditId: joi.string().required(),
+    },
+);
+
+export const reTriggerValid = {
+  body: reTriggerValidSchema,
+};

package/src/routes/auditMetrics.routes.js

@@ -1,8 +1,9 @@
 
 import express from 'express';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { clientMetrics, overAllAuditSummary, overViewCard, overViewTable, storeMetrics, summarySplit, userAuditHistory, userMetrics } from '../controllers/auditMetrics.controllers.js';
-import { clientMetricsValid, overAllAuditSummaryValid, overViewCardValid, overViewTableValid, storeMetricsValid, summarySplitValid, userAuditHistoryValid, userMetricsValid } from '../dtos/auditMetrics.dtos.js';
+import { clientMetrics, overAllAuditSummary, overViewCard, overViewTable, reTrigger, storeMetrics, summarySplit, userAuditHistory, userMetrics } from '../controllers/auditMetrics.controllers.js';
+import { clientMetricsValid, overAllAuditSummaryValid, overViewCardValid, overViewTableValid, reTriggerValid, storeMetricsValid, summarySplitValid, userAuditHistoryValid, userMetricsValid } from '../dtos/auditMetrics.dtos.js';
+import { isAuditDocumentExist, isAuditInputFolderExist } from '../validation/audit.validation.js';
 
 export const auditMetricsRouter = express.Router();
 
@@ -13,6 +14,7 @@ auditMetricsRouter.post( '/user-metrics', isAllowedSessionHandler, validate( use
 auditMetricsRouter.post( '/overview-card', isAllowedSessionHandler, validate( overViewCardValid ), overViewCard );
 auditMetricsRouter.post( '/summary-split-up', isAllowedSessionHandler, validate( summarySplitValid ), summarySplit );
 auditMetricsRouter.post( '/overview-table', isAllowedSessionHandler, validate( overViewTableValid ), overViewTable );
-auditMetricsRouter.post( '/overall-audit-summary', isAllowedSessionHandler, validate( overAllAuditSummaryValid, overAllAuditSummary ) );
+auditMetricsRouter.post( '/overall-audit-summary', isAllowedSessionHandler, validate( overAllAuditSummaryValid ), overAllAuditSummary );
+auditMetricsRouter.post( '/re-trigger', isAllowedSessionHandler, validate( reTriggerValid ), isAuditDocumentExist, isAuditInputFolderExist, reTrigger );
 
 export default auditMetricsRouter;

package/src/service/assignAudit.service.js

@@ -6,3 +6,7 @@ export function aggregateAssignAudit( query ) {
 export function updateOneAssignAudit( query, record ) {
   return assignAuditModel.updateOne( query, { $set: record } );
 }
+
+export function createAssignAudit( query ) {
+  return assignAuditModel.create( query );
+}

package/src/service/client.service.js

@@ -8,3 +8,7 @@ export function aggregateClient( query ) {
 export function findClient( query, fields, sort={ createdAt: -1 } ) {
   return clientModel.find( query, fields ).sort( sort );
 }
+
+export function findOneClient( query, fields ) {
+  return clientModel.findOne( query, fields );
+}

package/src/service/store.service.js

@@ -5,6 +5,10 @@ export function findOneStore( query, fields ) {
   return storeModel.findOne( query, fields );
 }
 
+export function countDocumentsStore( query ) {
+  return storeModel.countDocuments( query );
+}
+
 export function aggregateStore( query, fields ) {
   return storeModel.aggregate( query, fields );
 }

package/src/validation/audit.validation.js

@@ -1,5 +1,6 @@
 import { checkFileExist, chunkArray, getQueueUrl, logger } from 'tango-app-api-middleware';
 import { findOneUserAudit } from '../service/userAudit.service.js';
+import { findOneStoreAudit } from '../service/storeAudit.service.js';
 
 export async function isExistsQueue( req, res, next ) {
   try {
@@ -159,4 +160,46 @@ const mapFunction = async ( chunkData, filterData ) => {
   return chunkData;
 };
 
+export async function isAuditInputFolderExist( req, res, next ) {
+  try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const inputData = req.body;
+    const params={
+      Bucket: bucket.auditInput,
+      Key: `${inputData.fileDate}/${inputData.storeId}`,
+    };
+    const isExist = await checkFileExist( params );
+    if ( isExist ) {
+      next();
+    } else {
+      return res.sendError( `Audit Input folder not available : ${inputData.fileDate}/${inputData.storeId}`, 400 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'isAuidtInputFolderExist' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function isAuditDocumentExist( req, res, next ) {
+  try {
+    const inputData = req.body;
+    const query={
+      storeId: inputData.storeId,
+      fileDate: inputData.fileDate,
+    };
+    const auditInfo = await findOneStoreAudit( query );
+    if ( auditInfo ) {
+      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 );
+  }
+}
+