tango-app-api-analysis-traffic 3.8.6 → 3.8.7-vms.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-analysis-traffic",
-    "version": "3.8.6",
+    "version": "3.8.7-vms.1",
     "description": "Traffic Analysis",
     "main": "index.js",
     "type": "module",
@@ -23,7 +23,7 @@
         "mongodb": "^6.8.0",
         "nodemon": "^3.1.4",
         "swagger-ui-express": "^5.0.1",
-        "tango-api-schema": "^2.4.9",
+        "tango-api-schema": "^2.4.23",
         "tango-app-api-middleware": "^3.6.5",
         "winston": "^3.13.1",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/revop.controller.js

@@ -2,7 +2,8 @@ import { logger, insertOpenSearchData, getOpenSearchData, updateOpenSearchData }
 import { findOnerevopConfig } from '../services/revopConfig.service.js';
 import * as clientService from '../services/clients.services.js';
 import { bulkUpdate, upsertWithScript } from 'tango-app-api-middleware/src/utils/openSearch.js';
-import dayjs from 'dayjs';
+import { findOneVmsStoreRequest } from '../services/vmsStoreRequest.service.js';
+// import dayjs from 'dayjs';
 // Lamda Service Call //
 async function LamdaServiceCall( url, data ) {
   try {
@@ -211,44 +212,135 @@ export async function storeProcessedData( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
-    const previousDate = dayjs( inputData.dateString ).subtract( 1, 'day' ).format( 'YYYY-MM-DD' );
-    const dateString = `${inputData.storeId}_${inputData.dateString}`;
-    const dateStringPrevious = `${inputData.storeId}_${previousDate}`;
-    const getQuery = {
-      query: {
-        terms: {
-          _id: [ dateString, dateStringPrevious ],
-        },
-      },
-      _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
-      sort: [
-        {
-          date_iso: {
-            order: 'desc',
+    const { fromDate, toDate, storeId } = inputData;
+
+    // Multi-date range handling for a single store
+    if ( fromDate && toDate && storeId ) {
+      const dayjs = ( await import( 'dayjs' ) ).default;
+      const isSameOrBefore = ( await import( 'dayjs/plugin/isSameOrBefore.js' ) ).default;
+      dayjs.extend( isSameOrBefore );
+
+      let start = dayjs( fromDate );
+      let end = dayjs( toDate );
+
+      if ( !start.isValid() || !end.isValid() ) {
+        return res.sendError( 'Invalid date range supplied', 400 );
+      }
+
+      if ( end.isBefore( start ) ) {
+        [ start, end ] = [ end, start ];
+      }
+
+      const allDateStrings = [];
+      const orderedDates = [];
+
+      while ( start.isSameOrBefore( end ) ) {
+        const formatted = start.format( 'YYYY-MM-DD' );
+        orderedDates.push( formatted );
+        allDateStrings.push( `${storeId}_${formatted}` );
+        start = start.add( 1, 'day' );
+      }
+
+      if ( allDateStrings.length === 0 ) {
+        return res.sendSuccess( [] );
+      }
+
+      const footfallQuery = {
+        query: {
+          terms: {
+            _id: allDateStrings,
           },
         },
-      ],
-    };
+        _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
+        sort: [
+          { date_iso: { order: 'asc' } },
+        ],
+        size: allDateStrings.length,
+      };
 
-    const getData = await getOpenSearchData( openSearch.footfall, getQuery );
-    const hits = getData?.body?.hits?.hits || [];
+      const multiGet = await getOpenSearchData( openSearch.footfall, footfallQuery );
+      const multiHits = multiGet?.body?.hits?.hits || [];
+      const hitsMap = new Map();
+      multiHits.forEach( ( hit ) => {
+        hitsMap.set( hit?._id, hit?._source || null );
+      } );
 
-    const processedData = hits.find( ( d ) => d._id === dateString )?._source || null;
-    const previousData = hits.find( ( d ) => d._id === dateStringPrevious )?._source || null;
+      const responseArray = [];
 
-    let footfallCountTrend = 0;
+      for ( let i = 0; i < orderedDates.length; i++ ) {
+        const currentDate = orderedDates[i];
+        const currentId = `${storeId}_${currentDate}`;
+        const processedData = hitsMap.get( currentId );
+        if ( !processedData ) {
+          responseArray.push( {
+            date: currentDate,
+            footfallCount: 0,
+            footfallCountTrend: 0,
+            downtime: 0,
+          } );
+          continue;
+        }
 
-    if ( processedData && previousData && previousData.footfall_count ) {
-      footfallCountTrend = Math.round(
-          ( ( processedData.footfall_count - previousData.footfall_count ) / previousData.footfall_count ) * 100,
-      );
-    }
+        const prevDate = dayjs( currentDate ).subtract( 1, 'day' ).format( 'YYYY-MM-DD' );
+        const prevId = `${storeId}_${prevDate}`;
+        const previousData = hitsMap.get( prevId );
+
+        let footfallCountTrend = 0;
+        if ( previousData && previousData.footfall_count ) {
+          footfallCountTrend = Math.round(
+              ( ( processedData.footfall_count - previousData.footfall_count ) / previousData.footfall_count ) * 100,
+          );
+        }
+        // Add ticket status from openSearch.footfallDirectory (_source.status)
+        let ticketStatus = null;
+        // Try to find a matching footfallDirectory record for this date+storeId
+        // const ticketKey = `${storeId}_${currentDate}`;
+        const footfallDirQuery = {
+          query: {
+            bool: {
+              must: [
+                { term: { 'storeId.keyword': storeId } },
+                { term: { 'dateString': currentDate } },
+                { term: { 'ticketName.keyword': 'footfall-directory' } },
+              ],
+            },
+          },
+          size: 1,
+          _source: [ 'status' ],
+        };
+        try {
+          const footfallDirRes = await getOpenSearchData( openSearch.footfallDirectory, footfallDirQuery );
+          const hit = footfallDirRes?.body?.hits?.hits?.[0];
+          ticketStatus = hit?._source?.status || null;
+        } catch ( err ) {
+          logger.warn( { message: 'Could not get ticket status from footfallDirectory', error: err } );
+        }
+        // Check if request status ("raised") should be enabled or disabled by querying MongoDB config
+        // We'll assume findOnerevopConfig can fetch the record with status for this storeId and dateString
+        let raisedStatusEnabled = 'reset'; // default: enabled
+        try {
+          const mongoConfig = await findOneVmsStoreRequest( { storeId: storeId, dateString: currentDate } );
+          if ( mongoConfig && mongoConfig.status ) {
+            raisedStatusEnabled = mongoConfig.status;
+          }
+        } catch ( err ) {
+          logger.warn( { message: 'Could not get request status from MongoDB', error: err } );
+          // Leave raisedStatusEnabled as default
+        }
 
-    return res.sendSuccess( {
-      footfallCount: processedData?.footfall_count || 0,
-      footfallCountTrend,
-      downtime: processedData?.down_time || 0,
-    } );
+        responseArray.push( {
+          date: processedData?.date_string || currentDate,
+          footfallCount: processedData?.footfall_count || 0,
+          footfallCountTrend,
+          downtime: processedData?.down_time || 0,
+          ticketStatus,
+          raisedStatusEnabled,
+        } );
+      }
+
+      return res.sendSuccess( responseArray );
+    }
+    return res.sendError( 'Required parameters missing', 400 );
   } catch ( error ) {
     logger.error( { message: error, data: req.query, function: 'storeProcessedData' } );
     const err = error.message || 'Internal Server Error';
@@ -336,6 +428,7 @@ export async function tagTempId( req, res ) {
       clientId: inputData.storeId.split( '-' )[0],
       storeId: inputData.storeId,
       tempId: inputData.tempId,
+      id: `${inputData?.storeId}_${inputData?.dateString}_${inputData?.tempId}`,
       dateString: inputData.dateString,
       timeRange: inputData.timeRange,
       processType: inputData.processType,
@@ -348,6 +441,14 @@ export async function tagTempId( req, res ) {
       isChecked: inputData.isChecked,
       duplicateImage: inputData?.duplicateImage?.length>0? inputData?.duplicateImage :[],
       type: 'tagging-reflect',
+      ticketStatus: 'submitted',
+      isParent: inputData?.revopsType === 'duplicate'? true : false,
+      actions: [
+        {
+          actionType: 'tagging',
+          action: 'submitted',
+        },
+      ],
       createdAt: new Date(),
       updatedAt: new Date(),
 
@@ -386,6 +487,7 @@ export async function tagTempId( req, res ) {
           clientId: inputData.storeId.split( '-' )[0],
           storeId: inputData.storeId,
           tempId: item.tempId,
+          id: `${inputData?.storeId}_${inputData?.dateString}_${inputData?.tempId}`,
           dateString: inputData.dateString,
           timeRange: item.timeRange,
           isChecked: item.isChecked,
@@ -397,7 +499,15 @@ export async function tagTempId( req, res ) {
           status: item?.revopsType == 'non-tagging' ?'':'submitted',
           description: '',
           duplicateImage: [],
+          isParent: false,
           type: 'tagging-reflect',
+          ticketStatus: 'submitted',
+          actions: [
+            {
+              actionType: 'tagging',
+              action: 'submitted',
+            },
+          ],
           createdAt: new Date(),
           updatedAt: new Date(),
 

package/src/dtos/revop.dtos.js

@@ -4,7 +4,8 @@ import dayjs from 'dayjs';
 export const storeProcessedDataSchema = joi.object( {
 
   storeId: joi.string().required(),
-  dateString: joi.string().required(),
+  fromDate: joi.string().required(),
+  toDate: joi.string().required(),
 
 } );
 

package/src/services/vmsStoreRequest.service.js

@@ -0,0 +1,5 @@
+import vmsStoreRequestModel from 'tango-api-schema/schema/vmsStoreRequest.model.js';
+
+export async function findOneVmsStoreRequest( query = {} ) {
+  return await vmsStoreRequestModel.findOne( query );
+};