tango-app-api-report 3.4.0-beta.4 → 3.5.0

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "tango-app-api-report",
-    "version": "3.4.0-beta.4",
+    "version": "3.5.0",
     "description": "report",
     "main": "index.js",
     "type": "module",
     "scripts": {
-        "start": "nodemon --exec \"eslint --fix . && node index.js\""
+        "start": "nodemon --exec \"eslint --fix . && node app.js\""
     },
     "engines": {
         "node": ">=18.10.0"
@@ -25,7 +25,7 @@
         "nodemailer": "^6.9.13",
         "nodemon": "^3.1.0",
         "swagger-ui-express": "^5.0.0",
-        "tango-api-schema": "^2.1.58",
+        "tango-api-schema": "^2.4.7",
         "tango-app-api-middleware": "^3.1.45",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/report.controllers.js

@@ -266,10 +266,10 @@ export async function clientReportList( req, res ) {
       return res.sendError( 'No Data Found', 204 );
     }
     let paginatedData = count;
+
     if ( inputData?.reportStatus==='' ) {
       paginatedData = await paginate( count, offset, limit );
     }
-
     if ( inputData.reportStatus&&inputData.reportStatus!=='' ) {
       paginatedData = await splitArray( paginatedData );
       paginatedData= paginatedData.filter( ( ele ) => {
@@ -291,7 +291,7 @@ export async function clientReportList( req, res ) {
 }
 
 export async function mapFunction( array ) {
-  for ( let [ client ] of array.entries() ) {
+  for ( let client of array ) {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const reportLog = await getOpenSearchData( openSearch.auditLog,
         {
@@ -326,8 +326,10 @@ export async function mapFunction( array ) {
           },
 
         } );
+
     client.reportStatus='notsent';
-    if ( reportLog.body.hits.hits.length > 0 ) {
+
+    if ( reportLog?.body?.hits?.hits?.length > 0 ) {
       const sourcesArray = reportLog.body.hits.hits.map( ( hit ) => hit._source );
       if ( sourcesArray.length>0 ) {
         client.reportStatus='sent';
@@ -349,9 +351,8 @@ export async function splitArray( array ) {
 }
 
 export async function paginate( array, pageNumber, pageSize ) {
-  const startIndex = pageNumber * pageSize;
+  const startIndex = pageNumber;
   const endIndex = startIndex + pageSize;
-
   return array.slice( startIndex, endIndex );
 }
 
@@ -360,6 +361,7 @@ export async function generateReport( req, res ) {
     const sqs = JSON.parse( process.env.SQS );
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.body;
+    const revopType = req.report?.reportConfigs?.reportType || 'automate';
     const sqsProduceQueue = {
       QueueUrl: `${sqs.url}${sqs.generateReport}`,
       MessageBody: JSON.stringify( {
@@ -367,6 +369,7 @@ export async function generateReport( req, res ) {
         client_name: req.report?.reportConfigs?.reportName,
         client_id: Number( inputData.clientId ),
         message: 'good to trigger',
+        reportType: revopType,
       } ),
     };
     const sqsQueue = await sendMessageToQueue( sqsProduceQueue.QueueUrl, sqsProduceQueue.MessageBody );
@@ -381,16 +384,17 @@ export async function generateReport( req, res ) {
           reportName: req.report?.reportConfigs?.reportName,
           clientId: inputData.clientId,
           sqsMessageId: sqsQueue.MessageId,
+          reportType: revopType,
         },
         createdAt: Date.now(),
       };
       logger.info( { auditLog: openSearch.auditLog, openSearch: openSearch } );
       await insertOpenSearchData( openSearch.auditLog, log );
 
-      return res.sendSuccess( { result: 'Report has been Initiated Sucessfully' } );
+      return res.sendSuccess( { result: revopType !== 'manual'? 'The report has been initiated and will be sent automatically.':'The report has been initiated Successfully' } );
     }
   } catch ( error ) {
-    const err = error.code || 'Internal Server Error';
+    const err = error.message || 'Internal Server Error';
     logger.error( { error: error, message: req.body, function: 'generateReport' } );
     return res.sendError( err, 500 );
   }

package/src/routes/report.routes.js

@@ -3,7 +3,7 @@ import express from 'express';
 import { accessVerification, isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
 import { addReportValid, clientListTableValid, deleteReportValid, downloadReportValid, generateReportValid, getReportListValid, getReportLogValid, getReportValid, getSingleReportValid, sendReportValid, updateReportValid } from '../dtos/report.dtos.js';
 import { clientReportList, createReport, deleteReport, dowloadReport, generateReport, getReport, getReportList, getReportLog, getSingleReport, sendReport, updateBasePrice, updateReport, uploadManualReport } from '../controllers/report.controllers.js';
-import { isFileExist, isFolderExist, isReportEnable, isSendReportEnable } from '../validations/report.validations.js';
+import { getQueueCount, isAuditCompleted, isFeatureRunning, isFileExist, isFolderExist, isReportEnable, isSendReportEnable } from '../validations/report.validations.js';
 
 export const reportRouter = express.Router();
 // report setting configurations
@@ -30,7 +30,7 @@ reportRouter.post( '/generate-report', isAllowedSessionHandler,
     accessVerification( { userType: [ 'tango' ], access: [
       { featureName: 'TangoAdmin', name: 'Reports', permissions: [ 'isEdit' ] },
     ] } ),
-    validate( generateReportValid ), isReportEnable, generateReport );
+    validate( generateReportValid ), isReportEnable, getQueueCount, isAuditCompleted, isFeatureRunning, generateReport );
 
 reportRouter.post( '/upload-manual-report', isAllowedSessionHandler,
     accessVerification( { userType: [ 'tango' ], access: [

package/src/service/auditStoreData.service.js

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

package/src/service/storeAudit.service.js

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

package/src/validations/report.validations.js

@@ -1,11 +1,14 @@
 import { checkFileExist, logger } from 'tango-app-api-middleware';
 import { findOneClient } from '../service/client.service.js';
+import { aggregateStoreAudit } from '../service/storeAudit.service.js';
+import { getQueueUrl, receiveMessage } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
+import axios from 'axios';
 
 
 export async function isReportEnable( req, res, next ) {
   try {
     const inputData = req.method !== 'GET'? req.body: req.query;
-    const getReportName = await findOneClient( { 'clientId': inputData.clientId, 'status': { $in: [ 'active', 'hold' ] }, 'reportConfigs.report': true }, { '_id': 0, 'reportConfigs.reportName': 1, 'clientName': 1 } );
+    const getReportName = await findOneClient( { 'clientId': inputData.clientId, 'status': { $in: [ 'active', 'hold' ] }, 'reportConfigs.report': true }, { '_id': 0, 'reportConfigs': 1, 'clientName': 1, 'auditConfigs': 1 } );
     if ( !getReportName ) {
       return res.sendError( 'This action was forbidden', 403 );
     }
@@ -74,3 +77,211 @@ export async function isFileExist( req, res, next ) {
     return res.sendError( error, 500 );
   }
 }
+
+
+export async function isAuditCompleted( req, res, next ) {
+  try {
+    const inputData = req.body;
+    if ( req?.report?.reportConfigs?.reportType !== 'manual' ) {
+      logger.info( { inputData: inputData } );
+
+      const getStoreAuditQuery = [
+        {
+          $match: {
+            $and: [
+              {
+                fileDate: { $eq: inputData.fileDate },
+              },
+              {
+                clientId: { $eq: inputData.clientId },
+              },
+              {
+                status: { $ne: 'completed' },
+              },
+            ],
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            storeId: { $addToSet: '$storeId' },
+          },
+        },
+        {
+          $project: {
+            storeId: 1,
+          },
+        },
+      ];
+
+      const getStoreAudit = await aggregateStoreAudit( getStoreAuditQuery );
+      if ( getStoreAudit && getStoreAudit?.[0]?.storeId?.length >0 ) {
+        return res.sendError(
+            'Some files are not completed in the audit level for the selected date. Please try again later.',
+            400,
+        );
+      } else {
+        return next();
+      }
+    } else {
+      return next();
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'isAuditCompleted' } );
+    return res.sendError( error.message || 'Internal Server Error', 500 );
+  }
+}
+// -----------------------------
+// getQueueCount endpoint
+// -----------------------------
+export async function getQueueCount( req, res, next ) {
+  try {
+    if ( req?.report?.reportConfigs?.reportType !== 'manual' ) {
+      if ( !req?.report?.auditConfigs ) return next();
+
+      const temp = req.report.auditConfigs;
+
+      // Config flags
+      const auditConfig = {
+        track: temp.audit,
+        traffic: temp.trackAudit,
+      };
+
+
+      // Mapping of config flags to queue-check functions
+      const queueChecks = {
+        track: [ () => checkTrackingQueueCount( temp?.trackQueueName ) ],
+        traffic: [
+          () => checkTrafficQueueCount( temp?.trafficQueueName ),
+          () => checkZoneQueueCount( temp?.zoneQueueName ),
+        ],
+      };
+
+      // Run all enabled checks, stop on first true
+      const isProcessing = await runQueueChecks( auditConfig, queueChecks );
+
+      if ( isProcessing ) {
+        return res.sendError(
+            'This client is already being processed in the Queue. Please try again later.',
+            400,
+        );
+      }
+
+      return next();
+    } else {
+      return next();
+    }
+  } catch ( error ) {
+    logger.error( { error, message: req.body, function: 'getQueueCount' } );
+    return res.sendError( error.message || 'Internal Server Error', 500 );
+  }
+}
+
+
+// -----------------------------
+// Run queue checks in parallel, stop on first true
+// -----------------------------
+async function runQueueChecks( config, queueChecks ) {
+  const tasks = Object.entries( queueChecks )
+      .filter( ( [ flag ] ) => config[flag] )
+      .flatMap( ( [ , funcs ] ) => funcs.map( ( fn ) => fn() ) );
+
+  if ( tasks.length === 0 ) return false;
+
+  try {
+    const result = await Promise.any( tasks );
+    return result === true;
+  } catch {
+    return false; // all checks returned false
+  }
+}
+
+// -----------------------------
+// Helper: add timeout to promises
+// -----------------------------
+function withTimeout( promise, ms, fallback = false ) {
+  return Promise.race( [
+    promise,
+    new Promise( ( resolve ) => setTimeout( () => resolve( fallback ), ms ) ),
+  ] );
+}
+
+// -----------------------------
+// Generic safe queue check
+// -----------------------------
+async function safeQueueCheck( queueName ) {
+  if ( !queueName ) return false;
+
+  const [ queue, count ] = await Promise.all( [
+    withTimeout( getQueueUrl( queueName ), 5000 ),
+    withTimeout( receiveMessage( queueName ), 5000 ),
+  ] );
+
+  if ( queue?.statusCode ) return false;
+
+  return !!count && count !== 'null';
+}
+
+// -----------------------------
+// Queue check functions
+// -----------------------------
+async function checkTrackingQueueCount( queueName ) {
+  return safeQueueCheck( queueName );
+}
+
+async function checkTrafficQueueCount( queueName ) {
+  return safeQueueCheck( queueName );
+}
+
+async function checkZoneQueueCount( queueName ) {
+  return safeQueueCheck( queueName );
+}
+
+export async function isFeatureRunning( req, res, next ) {
+  try {
+    const inputData = req.body;
+    if ( req?.report?.reportConfigs?.reportType !== 'manual' ) {
+      const url = JSON.parse( process.env.URL );
+      const REIDURL = url.REIDStatus;
+      const FeatureURL = url.FeatureStatus;
+      const data = { 'client_id': inputData.clientId, 'store_date': inputData?.fileDate };
+
+      const isFeature = await callLambdaWithData( data, FeatureURL );
+      const isREID = await callLambdaWithData( data, REIDURL );
+      if ( isFeature?.status_code !== '200' ||isREID?.status_code !== '200' ) {
+        return res.sendError(
+            'This client is already being processed in REID/Feature layer for the selected date. Please try again later.',
+            400,
+        );
+      } else if ( isFeature?.data === false || isREID?.data === false ) {
+        return res.sendError(
+            'This client is already being processed in REID/Feature layer for the selected date. Please try again later.',
+            400,
+        );
+      } else {
+        return next();
+      }
+    } else {
+      return next();
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'isFeatureRunning' } );
+    return res.sendError( error.message || 'Iternal Server Error', 500 );
+  }
+}
+
+
+export const callLambdaWithData = async ( data, LAMBDA_URL ) => {
+  try {
+    const response = await axios.post( LAMBDA_URL, data, {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    } );
+    return response.data;
+  } catch ( error ) {
+    console.error( 'Error calling Lambda with data:', error );
+    throw error;
+  }
+};
+