tango-app-api-audit 1.0.38 → 1.0.39

package/package.json

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

package/src/controllers/auditMetrics.controllers.js

@@ -1,4 +1,4 @@
-import { download, getUTC, insertOpenSearchData, logger, sendMessageToQueue } from 'tango-app-api-middleware';
+import { chunkArray, download, getUTC, insertOpenSearchData, logger, sendMessageToQueue } from 'tango-app-api-middleware';
 import { aggregateAuditClientData } from '../service/auditClientData.service.js';
 import { aggregateUserAudit, updateOneUserAudit } from '../service/userAudit.service.js';
 import mongoose from 'mongoose';
@@ -21,7 +21,8 @@ export async function userAuditHistory( req, res ) {
     const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
     let filter = [
 
-      { userId: { $eq: new mongoose.Types.ObjectId( userId ) } },
+      { userId: { $eq: userId } },
+      { moduleType: 'traffic' },
 
     ];
     if ( inputData.fileType == 'fileDate' ) {
@@ -36,6 +37,18 @@ export async function userAuditHistory( req, res ) {
       );
     }
 
+    if ( inputData.filterByStoreId?.length > 0 ) {
+      filter.push( {
+        storeId: { $in: inputData.filterByStoreId },
+      } );
+    }
+
+    if ( inputData.filterByStatus?.length > 0 ) {
+      filter.push( {
+        auditStatus: { $in: inputData.filterByStatus },
+      } );
+    }
+
     const query = [
       {
         $match: {
@@ -63,10 +76,39 @@ export async function userAuditHistory( req, res ) {
       );
     }
 
+    query.push( {
+      $lookup: {
+        from: 'stores',
+        let: { storeId: '$storeId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $eq: [ '$storeId', '$$storeId' ],
+              },
+            },
+          },
+          {
+            $project: {
+              storeName: 1,
+            },
+          },
+        ], as: 'store',
+      },
+
+    } );
+
+    query.push( {
+      $unwind: {
+        path: '$store', preserveNullAndEmptyArrays: true,
+      },
+    } );
+
     query.push( {
       $project: {
         storeId: 1,
-        storeName: '$storeId',
+        userId: 1,
+        storeName: '$store.storeName',
         auditType: 1,
         beforeCount: 1,
         afterCount: 1,
@@ -91,6 +133,35 @@ export async function userAuditHistory( req, res ) {
       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( {
+            'storeId': element.storeId,
+            'storeName': element.storeName,
+            'auditType': element.auditType,
+            'beforeCount': element.beforeCount,
+            'afterCount': element.afterCount,
+            'accuracy': element.accuracy,
+            'startTime': element.startTime,
+            'endTime': element.endTime,
+            'timeSpent': element.timeSpent,
+            'auditStatus': element.auditStatus,
+            'createdAt': element.createdAt,
+
+          } );
+        } );
+        return exportData;
+      } );
+      const mappedArrays = await Promise.all( promises );
+      mappedArrays.flat();
+
+      await download( mappedArrays, res );
+      return;
+    }
+
     query.push( {
       $skip: offset,
     },

package/src/controllers/zoneAudit.controller.js

@@ -1,4 +1,4 @@
-import { download, fileUpload, getJsonFileData, getUTC, insertOpenSearchData, listFileByPath, sendMessageToQueue, signedUrl, sqsReceive } from 'tango-app-api-middleware';
+import { chunkArray, download, fileUpload, getJsonFileData, getUTC, insertOpenSearchData, listFileByPath, sendMessageToQueue, signedUrl, sqsReceive } from 'tango-app-api-middleware';
 import { aggregateZoneUserAudit, createZoneUserAudit, findOneZoneUserAudit } from '../service/zoneUserAudit.service.js';
 import { logger } from 'tango-app-api-middleware';
 import { aggregateAssignZoneAudit } from '../service/assignZoneAudit.service.js';
@@ -898,3 +898,172 @@ export async function workSpace( req, res ) {
     return res.sendError( err, 500 );
   }
 }
+
+export async function userZoneAuditHistory( req, res ) {
+  try {
+    const inputData = req.body;
+    const userId = 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 ) );
+    let filter = [
+
+      { userId: { $eq: userId } },
+      { moduleType: 'zone' },
+
+    ];
+    if ( inputData.fileType == 'fileDate' ) {
+      filter.push(
+          { fileDateISO: { $gte: dateRange.start } },
+          { fileDateISO: { $lte: dateRange.end } },
+      );
+    } else {
+      filter.push(
+          { createdAt: { $gte: dateRange.start } },
+          { createdAt: { $lte: dateRange.end } },
+      );
+    }
+    if ( inputData.filterByStoreId?.length > 0 ) {
+      filter.push( {
+        storeId: { $in: inputData.filterByStoreId },
+      } );
+    }
+
+    if ( inputData.filterByStatus?.length > 0 ) {
+      filter.push( {
+        auditStatus: { $in: inputData.filterByStatus },
+      } );
+    }
+
+    const query = [
+      {
+        $match: {
+          $and: filter,
+        },
+      },
+    ];
+
+    if ( inputData.searchValue && inputData.searchValue!== '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
+            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
+          ],
+
+        },
+      } );
+    }
+    if ( inputData.sortColumnName ) {
+      const sortBy = inputData.sortBy || -1;
+      query.push( {
+        $sort: { [inputData.sortColumName]: sortBy },
+      },
+      );
+    }
+
+    query.push( {
+      $lookup: {
+        from: 'stores',
+        let: { storeId: '$storeId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $eq: [ '$storeId', '$$storeId' ],
+              },
+            },
+          },
+          {
+            $project: {
+              storeName: 1,
+            },
+          },
+        ], as: 'store',
+      },
+
+    } );
+
+    query.push( {
+      $unwind: {
+        path: '$store', preserveNullAndEmptyArrays: true,
+      },
+    } );
+
+
+    query.push( {
+
+      $project: {
+        storeId: 1,
+        userId: 1,
+        storeName: '$store.storeName',
+        zoneName: 1,
+        auditType: 1,
+        beforeCount: 1,
+        afterCount: 1,
+        accuracy: { $round: [
+          {
+            $divide: [ { $multiply: [ '$beforeCount', { $ifNull: [ '$afterCount', 0 ] } ] }, 100 ],
+          }, 2,
+        ],
+        },
+        startTime: 1,
+        endTime: 1,
+        timeSpent: { $round: [
+          { $divide: [ '$timeSpent', 60 ] }, 2,
+        ] },
+        auditStatus: 1,
+        createdAt: 1,
+      },
+
+    } );
+
+    const count = await aggregateUserAudit( 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( {
+            'storeId': element.storeId,
+            'storeName': element.storeName,
+            'auditType': element.auditType,
+            'beforeCount': element.beforeCount,
+            'afterCount': element.afterCount,
+            'accuracy': element.accuracy,
+            'startTime': element.startTime,
+            'endTime': element.endTime,
+            'timeSpent': element.timeSpent,
+            'auditStatus': element.auditStatus,
+            'createdAt': element.createdAt,
+
+          } );
+        } );
+        return exportData;
+      } );
+      const mappedArrays = await Promise.all( promises );
+      mappedArrays.flat();
+
+      await download( mappedArrays, res );
+      return;
+    }
+
+    query.push( {
+      $skip: offset,
+    },
+    {
+      $limit: limit,
+    } );
+    const result = await aggregateUserAudit( query );
+
+    return res.sendSuccess( { result: result } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.info( { error: error, message: req.body, function: 'userZoneAuditHistory' } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/docs/zoneAudit.docs.js

@@ -1,5 +1,5 @@
 import j2s from 'joi-to-swagger';
-import { getDraftedDataSchema, getFileSchema, saveDraftSchema, saveSchema, workSpaceSchema } from '../dtos/zoneAudit.dtos.js';
+import { getDraftedDataSchema, getFileSchema, saveDraftSchema, saveSchema, userZoneAuditHistorySchema, workSpaceSchema } from '../dtos/zoneAudit.dtos.js';
 
 export const zoneAuditDocs = {
   '/v3/zone-audit/get-file': {
@@ -155,4 +155,27 @@ export const zoneAuditDocs = {
     },
   },
 
+  // metrics
+  '/v3/zone-audit/metrics/user-zone-audit-history': {
+    post: {
+      tags: [ 'Zone Audit Metrics' ],
+      description: `get zone audit work history of a user`,
+      operationId: '/metrics/user-zone-audit-history',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( userZoneAuditHistorySchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'The Audited file has been submited successfully ' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
 };

package/src/dtos/zoneAudit.dtos.js

@@ -86,3 +86,27 @@ export const workSpaceSchema = joi.object(
 export const workSpaceValid = {
   query: workSpaceSchema,
 };
+
+export const userZoneAuditHistorySchema = joi.object(
+    {
+      userId: joi.string().optional(),
+      fromDate: joi.string().required(),
+      toDate: joi.string().required(),
+      fileType: joi.string().required(),
+      filterByStoreId: joi.array().required(),
+      filterByType: joi.array().optional(),
+      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 userZoneAuditHistoryValid = {
+  body: userZoneAuditHistorySchema,
+};

package/src/routes/zone.routes.js

@@ -1,15 +1,17 @@
 import { Router } from 'express';
-import { getDraftedDataValid, getFileValid, saveDraftValid, saveValid, workSpaceValid } from '../dtos/zoneAudit.dtos.js';
+import { getDraftedDataValid, getFileValid, saveDraftValid, saveValid, userZoneAuditHistoryValid, workSpaceValid } from '../dtos/zoneAudit.dtos.js';
 import { isExistsQueue, validateUserAudit } from '../validation/audit.validation.js';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { getDraftedData, getZoneAuditFile, save, saveDraft, workSpace } from '../controllers/zoneAudit.controller.js';
+import { getDraftedData, getZoneAuditFile, save, saveDraft, userZoneAuditHistory, workSpace } from '../controllers/zoneAudit.controller.js';
 
 export const zoneAuditRouter=Router();
 
-
+// zone Audit
 zoneAuditRouter.get( '/get-file', isAllowedSessionHandler, validate( getFileValid ), isExistsQueue, getZoneAuditFile );
 zoneAuditRouter.post( '/save-draft', isAllowedSessionHandler, validate( saveDraftValid ), saveDraft );
 zoneAuditRouter.get( '/get-drafted-data', isAllowedSessionHandler, validate( getDraftedDataValid ), getDraftedData );
 zoneAuditRouter.post( '/save', isAllowedSessionHandler, validate( saveValid ), validateUserAudit, save );
 zoneAuditRouter.get( '/work-space', isAllowedSessionHandler, validate( workSpaceValid ), workSpace );
 
+// metrics
+zoneAuditRouter.post( '/metrics/user-zone-audit-history', isAllowedSessionHandler, validate( userZoneAuditHistoryValid ), userZoneAuditHistory );