tango-app-api-audit 1.0.4 → 1.0.6

package/index.js

@@ -4,8 +4,10 @@ import { auditRouter } from './src/routes/audit.routes.js';
 import { auditMetricsRouter } from './src/routes/auditMetrics.routes.js';
 import { auditMetricsDocs } from './src/docs/auditMetrics.docs.js';
 import { auditDocs } from './src/docs/audit.docs.js';
+import clientRouter from './src/routes/client.routes.js';
+import { clientDocs } from './src/docs/client.docs.js';
 
 
-export { auditRouter, auditMetricsRouter, auditMetricsDocs, auditDocs };
+export { auditRouter, auditMetricsRouter, auditMetricsDocs, auditDocs, clientRouter, clientDocs };
 
 

package/package.json

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

package/src/controllers/audit.controllers.js

@@ -1,12 +1,12 @@
-import { chunkArray, getJsonFileData, getUTC, listFileByPath, listFileWithoutLimit, signedUrl } from 'tango-app-api-middleware';
-import { aggregateUserAudit, createUserAudit } from '../service/userAudit.service.js';
+import { chunkArray, getJsonFileData, getOpenSearchData, getUTC, insertOpenSearchData, listFileByPath, listFileWithoutLimit, signedUrl } from 'tango-app-api-middleware';
+import { aggregateUserAudit, createUserAudit, findOneUserAudit, updateOneUserAudit } from '../service/userAudit.service.js';
 import { aggregateAssignAudit, updateOneAssignAudit } from '../service/assignAudit.service.js';
 import { findOneUser } from '../service/user.service.js';
 import dayjs from 'dayjs';
 import { aggregateClient } from '../service/client.service.js';
 import { logger } from 'tango-app-api-middleware';
 import { sqsReceive } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
-import { createStoreAudit } from '../service/storeAudit.service.js';
+import { createStoreAudit, updateOneStoreAudit } from '../service/storeAudit.service.js';
 
 export async function getAuditFile( req, res ) {
   try {
@@ -742,3 +742,139 @@ export async function getQueueDetailList( req, res ) {
     return res.sendError( error );
   }
 }
+
+export async function saveDraft( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.body;
+    inputData.userId = req.user._id;
+    const getUserAuditData = await findOneUserAudit( { _id: inputData.auditId } );
+    if ( !getUserAuditData ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    if ( getUserAuditData.auditStatus == 'skipped' ) {
+      return res.sendError( 'File Assigned to Someone else', 203 );
+    }
+
+    const userQuery = {
+      _id: inputData.auditId,
+    };
+    let userRecord ={
+      isDraft: true,
+      auditStatus: 'drafted',
+    };
+    const storeQuery ={
+      storeId: inputData.storeId,
+      fileDate: inputData.fileDate,
+    };
+
+    let storeRecord ={
+      status: 'drafted',
+    };
+
+    if ( getUserAuditData?.startTime ) {
+      const isoDate = getUserAuditData.startTime;
+      const currentTime = dayjs();
+      const isoDateTime = dayjs( isoDate );
+      const timeDifferenceInMinutes = currentTime.diff( isoDateTime, 'seconds' );
+
+      userRecord.timeSpent=timeDifferenceInMinutes;
+
+      storeRecord.timeSpent = timeDifferenceInMinutes;
+    }
+
+    if ( inputData.userCommands ) {
+      userRecord.userCommands = inputData.userCommands;
+      const logData = {
+        userId: req.user._id,
+        userName: req.user.userName,
+        logType: 'audit',
+        logSubType: 'auditDraft',
+        logData: {
+          auditType: inputData.auditType,
+          storeId: inputData.storeId,
+          clientName: inputData.queueName,
+          beforeCount: inputData.totalCount,
+          afterCount: inputData.customerCount,
+          auditId: inputData.auditId,
+        },
+      };
+      await insertOpenSearchData( openSearch.activityLog, logData );
+      logger.info( { logData: logData } ); // need to insert to os
+    }
+    await insertOpenSearchData( openSearch.auditLog, inputData );
+    await updateOneUserAudit( userQuery, userRecord );
+    await updateOneStoreAudit( storeQuery, storeRecord );
+    return res.sendSuccess( { result: 'The file has been drafted successfully' } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'saveDraft' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function getDraftedData( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.query;
+    logger.info( { inputData: inputData } );
+    const getLog = await getOpenSearchData( openSearch.auditLog,
+        {
+          'size': 1,
+          'query': {
+            'bool': {
+              'must': [
+                {
+                  'term': {
+                    'fileDate.keyword': inputData.fileDate,
+                  },
+                },
+                {
+                  'term': {
+                    'storeId.keyword': inputData.storeId,
+                  },
+                },
+                {
+                  'term': {
+                    'userId.keyword': req.user._id,
+                  },
+                },
+
+              ],
+
+            },
+          },
+
+          'sort': [
+            {
+              'timestamp': {
+                'order': 'desc',
+              },
+            },
+          ],
+
+        } );
+    const result = getLog?.body?.hits?.hits;
+    if ( result.length ==0 ) {
+      return res.sendError( 'No Data Found', 500 );
+    }
+    return res.sendSuccess( { result: result } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'getDraftedData' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function save( req, res ) {
+  try {
+    const inputData = req.body;
+    return res.sendSuccess( { result: inputData } );
+  } catch ( error ) {
+    const err= error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'save' } );
+    return res.sendError( err );
+  }
+}
+
+

package/src/controllers/auditMetrics.controllers.js

@@ -245,8 +245,13 @@ export async function clientMetrics( req, res ) {
     let filter = [
       { fileDateISO: { $gte: dateRange.start } },
       { fileDateISO: { $lte: dateRange.end } },
-      { clientId: { $in: inputData.filterByClient } },
+
     ];
+    if ( inputData?.filterByClient?.length> 0 ) {
+      filter.push(
+          { clientId: { $in: inputData.filterByClient } },
+      );
+    }
     const query = [
       {
         $match: {
@@ -374,10 +379,11 @@ export async function clientMetrics( req, res ) {
       query.push(
           {
             $project: {
+              '_id': 0,
               'File Date': '$fileDate',
               'Client Name': '$clientName',
               'Client Id': '$clientId',
-              'Completed Percentage': '$completionPercentage' + ' %',
+              'Completed Percentage': '$completionPercentage',
               'Installed Stores': '$installedStore',
               'Audit Stores': '$totalFilesCount',
               'Inprogress Stores': '$inprogressStoresCount',
@@ -386,9 +392,6 @@ export async function clientMetrics( req, res ) {
               'Status': '$clientStatus',
             },
           },
-          {
-
-          },
       );
     }
 

package/src/controllers/client.controllers.js

@@ -0,0 +1,35 @@
+import { logger } from 'tango-app-api-middleware';
+import { aggregateClient } from '../service/client.service.js';
+
+export async function clients( req, res ) {
+  try {
+    const inputData = req.query;
+    const query =[
+      {
+        $match: {
+          'status': { $in: [ 'active', 'hold' ] },
+          'auditConfigs.audit': true,
+        },
+      },
+    ];
+
+    const count = await aggregateClient( query );
+    if ( count.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    if ( inputData.limit ) {
+      const offset = inputData.offset ? ( inputData.offset - 1 ) * inputData.limit : 0;
+      query.push(
+          { $skip: offset },
+          { $limit: limit },
+      );
+    }
+    const getAuditClients = await aggregateClient( query );
+
+    return res.sendSuccess( { result: getAuditClients, count: count.length } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.info( { error: error, messgae: req.query, function: 'clients' } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/docs/audit.docs.js

@@ -1,4 +1,4 @@
-import { getFileSchema } from '../dtos/audit.dtos.js';
+import { getDraftedDataSchema, getFileSchema, saveDraftSchema, saveSchema } from '../dtos/audit.dtos.js';
 import j2s from 'joi-to-swagger';
 
 export const auditDocs = {
@@ -28,7 +28,79 @@ export const auditDocs = {
         },
       ],
       responses: {
-        200: { description: 'Successfully' },
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+  '/v3/audit/save-draft': {
+    post: {
+      tags: [ 'Audit' ],
+      description: `save audited file. which is save in the mongo db`,
+      operationId: 'save-draft',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( saveDraftSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+  '/v3/audit/get-drafted-data': {
+    get: {
+      tags: [ 'Audit' ],
+      description: 'Get a saved file via DB',
+      operationId: 'get-drafted-data',
+      parameters: [
+        {
+          in: 'query',
+          name: 'fileDate',
+          scema: j2s( getDraftedDataSchema ).swagger,
+          require: true,
+        },
+        {
+          in: 'query',
+          name: 'storeId',
+          scema: j2s( getDraftedDataSchema ).swagger,
+          require: false,
+        },
+      ],
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+  '/v3/audit/save': {
+    post: {
+      tags: [ 'Audit' ],
+      description: `submit the audit file. which is store in the bucket in the json format`,
+      operationId: 'save',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( saveSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'The Audited file has been submited successfully ' },
         401: { description: 'Unauthorized User' },
         422: { description: 'Field Error' },
         500: { description: 'Server Error' },

package/src/docs/client.docs.js

@@ -0,0 +1,33 @@
+import j2s from 'joi-to-swagger';
+import { clientSchema } from '../dtos/client.dtos.js';
+
+export const clientDocs = {
+  '/v3/audit/client/clients': {
+    get: {
+      tags: [ 'Audit/Client' ],
+      description: 'Get client list which is enable for audit',
+      operationId: 'clients',
+      parameters: [
+        {
+          in: 'query',
+          name: 'limit',
+          scema: j2s( clientSchema ).swagger,
+          require: false,
+        },
+        {
+          in: 'query',
+          name: 'offset',
+          scema: j2s( clientSchema ).swagger,
+          require: false,
+        },
+      ],
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+};

package/src/dtos/audit.dtos.js

@@ -13,6 +13,53 @@ export const getFileValid = {
   query: getFileSchema,
 };
 
+export const saveDraftSchema = joi.object(
+    {
+      userCommands: joi.string().optional(),
+      storeId: joi.string().required(),
+      auditId: joi.string().required(),
+      auditType: joi.string().required(),
+      fileDate: joi.string().required(),
+      queueName: joi.string().required(),
+      totalCount: joi.number().required(),
+      junkCount: joi.number().optional(),
+      junk: joi.array().optional(),
+      employeeCount: joi.number().optional(),
+      employee: joi.array().optional(),
+      customerCount: joi.number().optional(),
+      customer: joi.array().optional(),
+      retagCount: joi.number().optional(),
+      retagImage: joi.array().optional(),
+    },
+);
+
+export const saveDraftValid = {
+  body: saveDraftSchema,
+};
+
+export const getDraftedDataSchema = joi.object(
+    {
+      storeId: joi.string().required(),
+      fileDate: joi.string().required(),
+    },
+);
+
+export const getDraftedDataValid = {
+  query: getDraftedDataSchema,
+};
+
+export const saveSchema = joi.object(
+    {
+      auditId: joi.string().required(),
+      storeId: joi.string().required(),
+      fileDate: joi.string().required(),
+    },
+);
+
+export const saveValid = {
+  body: saveSchema,
+};
+
 export const getQueueDetailListSchema = joi.object(
     {
       searchValue: joi.string().optional(),

package/src/dtos/auditMetrics.dtos.js

@@ -47,7 +47,7 @@ export const clientMetricsSchema = joi.object(
       toDate: joi.string().required(),
       searchValue: joi.string().optional(),
       filterByClient: joi.array().required(),
-      status: joi.array().optional(),
+      filterByStatus: joi.array().optional(),
       sortColumnName: joi.string().optional(),
       sortBy: joi.number().optional(),
       limit: joi.number().optional(),

package/src/dtos/client.dtos.js

@@ -0,0 +1,13 @@
+import joi from 'joi';
+
+
+export const clientSchema = joi.object(
+    {
+      limit: joi.number().optional(),
+      offset: joi.number().optional(),
+    },
+);
+
+export const clientValid = {
+  query: clientSchema,
+};

package/src/routes/audit.routes.js

@@ -1,12 +1,15 @@
 import express from 'express';
-import { isExistsQueue } from '../validation/audit.validation.js';
+import { isExistsQueue, validateUserAudit } from '../validation/audit.validation.js';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { getAuditFile, getQueueDetailList } from '../controllers/audit.controllers.js';
-import { getFileValid, getQueueDetailListValid } from '../dtos/audit.dtos.js';
+import { getAuditFile, getDraftedData, getQueueDetailList, save, saveDraft } from '../controllers/audit.controllers.js';
+import { getDraftedDataValid, getFileValid, getQueueDetailListValid, saveDraftValid, saveValid } from '../dtos/audit.dtos.js';
 
 export const auditRouter = express.Router();
 
-auditRouter.get( '/get-file', validate( getFileValid ), isAllowedSessionHandler, isExistsQueue, getAuditFile );
-auditRouter.get( '/get-queue-detail-list', validate( getQueueDetailListValid ), isAllowedSessionHandler, getQueueDetailList );
+auditRouter.get( '/get-file', isAllowedSessionHandler, validate( getFileValid ), isExistsQueue, getAuditFile );
+auditRouter.post( '/save-draft', isAllowedSessionHandler, validate( saveDraftValid ), saveDraft );
+auditRouter.get( '/get-drafted-data', isAllowedSessionHandler, validate( getDraftedDataValid ), getDraftedData );
+auditRouter.post( '/save', isAllowedSessionHandler, validate( saveValid ), validateUserAudit, save );
+auditRouter.get( '/get-queue-detail-list', isAllowedSessionHandler, validate( getQueueDetailListValid ), getQueueDetailList );
 
 export default auditRouter;

package/src/routes/client.routes.js

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
+import { clients } from '../controllers/client.controllers.js';
+import { clientValid } from '../dtos/client.dtos.js';
+
+export const clientRouter = Router();
+
+clientRouter.get( '/clients', isAllowedSessionHandler, validate( clientValid ), clients );
+
+export default clientRouter;

package/src/service/assignAudit.service.js

@@ -4,5 +4,5 @@ export function aggregateAssignAudit( query ) {
   return assignAuditModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
 }
 export function updateOneAssignAudit( query, record ) {
-  return assignAuditModel.updateOne( query, record );
+  return assignAuditModel.updateOne( query, { $set: record } );
 }

package/src/service/client.service.js

@@ -4,3 +4,7 @@ import clientModel from 'tango-api-schema/schema/client.model.js';
 export function aggregateClient( query ) {
   return clientModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
 }
+
+export function findClient( query, fields, sort={ createdAt: -1 } ) {
+  return clientModel.find( query, fields ).sort( sort );
+}

package/src/service/storeAudit.service.js

@@ -1,7 +1,7 @@
 import storeAuditModel from 'tango-api-schema/schema/storeAudit.model.js';
 
 export function updateOneStoreAudit( query, record ) {
-  return storeAuditModel.updateOne( query, record );
+  return storeAuditModel.updateOne( query, { $set: record } );
 }
 
 export function createStoreAudit( record ) {

package/src/service/userAudit.service.js

@@ -6,9 +6,13 @@ export function aggregateUserAudit( query ) {
 }
 
 export function updateOneUserAudit( query, record ) {
-  return userAuditModel.updateOne( query, record );
+  return userAuditModel.updateOne( query, { $set: record } );
 }
 
 export function createUserAudit( record ) {
   return userAuditModel.create( record );
 }
+
+export function findOneUserAudit( query, fields ) {
+  return userAuditModel.findOne( query, fields );
+}

package/src/validation/audit.validation.js

@@ -1,4 +1,5 @@
-import { getQueueUrl, logger } from 'tango-app-api-middleware';
+import { checkFileExist, getQueueUrl, logger } from 'tango-app-api-middleware';
+import { findOneUserAudit } from '../service/userAudit.service.js';
 
 export async function isExistsQueue( req, res, next ) {
   try {
@@ -14,3 +15,44 @@ export async function isExistsQueue( req, res, next ) {
     return res.sendError( error, 500 );
   }
 }
+
+export async function validateUserAudit( req, res, next ) {
+  try {
+    const inputData = req.body;
+    const userAuditDetails = findOneUserAudit( { _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.body.userAudit = userAuditDetails;
+    next();
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'validateUserAudit' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function isMasterJsonExists( req, res, next ) {
+  try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const inputData = req.body;
+    params={
+      Bucket: bucket.masterJson,
+      Key: `${inputData.storeId}/${inputData.fileDate}/${bucket.masterJsonFile}`,
+    };
+    const isExist = await checkFileExist( params );
+    if ( isExist ) {
+      next();
+    } else {
+      return res.sendError( `NO_MASTER_JSON_AVAILABLE : ${inputData.storeId}/${inputData.fileDate}/${bucketName.masterJsonFile}`, 400 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'isMasterJsonExists' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+