tango-app-api-analysis-traffic 3.8.7-vms.3 → 3.8.7-vms.30

package/src/controllers/tangoTrafficV3.controllers.js

@@ -3129,29 +3129,30 @@ export const managerTrafficDensityExport = async ( req, res ) => {
   }
 };
 
-// async function getGeocodedAddress( lat, lng ) {
-//   try {
-//     const apiKey = 'AIzaSyDlOezgwQO0JviD0aizrCuN1FY9tcWfR3o'; // Use this if you're using dotenv
-//     const url = `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${apiKey}`;
-
-//     const requestOptions = {
-//       method: 'GET',
-//       headers: {
-//         'Content-Type': 'application/json',
-//       },
-//     };
-//     const response = await fetch( url, requestOptions );
-//     console.log( 'response =>', response );
-//     if ( !response.ok ) {
-//       throw new Error( `Response status: ${response.status}` );
-//       return false;
-//     }
-//     const json = await response.json();
-//     return json;
-//   } catch ( error ) {
-//     console.log( 'getGeocodedAddress error =>', error );
-//     logger.error( { error: error, message: data, function: 'getGeocodedAddress' } );
-//   }
-// }
-// let getGEO = await getGeocodedAddress( 12.900260100404893, 80.23384232089138 );
-//     console.log( 'getGEO =>', getGEO );
+
+export const getStoreListv2 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getClientData = await getClientConfig( reqestData.clientId );
+    if ( !getClientData ) {
+      return res.sendError( 'Invalid Client Id', 400 );
+    }
+    reqestData.featureConfigs = getClientData.featureConfigs;
+    let LamdaURL = 'https://nmnnlq3ie65bljcvxauhxmsrpa0edhfa.lambda-url.ap-south-1.on.aws/';
+    let resultData = await LamdaServiceCall( LamdaURL, reqestData );
+    if ( resultData ) {
+      if ( resultData.status_code == '200' ) {
+        return res.sendSuccess( resultData );
+      } else {
+        return res.sendError( 'No Content', 204 );
+      }
+    } else {
+      return res.sendError( 'No Content', 204 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'getStoreListv2' } );
+    return res.sendError( err, 500 );
+  }
+};
+

package/src/dtos/revop.dtos.js

@@ -56,8 +56,8 @@ export const tagTempIdSchema = joi.object( {
 
     const diff = today.diff( inputDate, 'day' );
 
-    if ( diff > 7 ) {
-      return helpers.message( 'Tagging is not allowed for a period exceeding 7 days' );
+    if ( diff > 3 ) {
+      return helpers.message( 'Tagging is not allowed for a period exceeding 3 days' );
     }
 
     return value;
@@ -84,6 +84,7 @@ export const tagTempIdSchema = joi.object( {
   entryTime: joi.string().required(),
   exitTime: joi.string().required(),
   filePath: joi.string().required(),
+  comments: joi.string().optional().allow( '' ),
 
 } );
 
@@ -104,3 +105,13 @@ export const getCategorizedImagesValid = {
   body: getCategorizedImagesSchema,
 };
 
+export const vmsDataMigrationSchema = joi.object( {
+  storeId: joi.string().optional(),
+  dateString: joi.string().optional(),
+  limit: joi.number().optional().default( 100 ),
+} );
+
+export const vmsDataMigrationValid = {
+  query: vmsDataMigrationSchema,
+};
+

package/src/dtos/validation.dtos.js

@@ -239,6 +239,17 @@ export const validateCountryHeaderSchemav2 = joi.object( {
 export const validateCountryHeaderParamsv2 = {
   body: validateCountryHeaderSchemav2,
 };
+
+export const validateGetStoreListSchemav2 = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().items( joi.string().required() ).required(),
+  downtime: joi.array().items( joi.string().required() ).optional(),
+  fromDate: joi.string().required(),
+  toDate: joi.string().required(),
+} );
+export const validateGetStoreList = {
+  body: validateGetStoreListSchemav2,
+};
 export const getMyProductSchema = joi.object( {
   clientId: joi.string().required(),
   storeId: joi.array().optional().empty(),

package/src/routes/revop.routes.js

@@ -1,8 +1,8 @@
 
 import express from 'express';
-import { storeProcessedData, getconfig, revoptagging, getrevoptagging, revoptaggingcount, footFallImages, tagTempId, getCategorizedImages } from '../controllers/revop.controller.js';
+import { storeProcessedData, getconfig, revoptagging, getrevoptagging, revoptaggingcount, footFallImages, tagTempId, getCategorizedImages, vmsDataMigration, migrateRevopIndex } from '../controllers/revop.controller.js';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { footfallImagesValid, getCategorizedImagesValid, storeProcessedDataValid, tagTempIdValid } from '../dtos/revop.dtos.js';
+import { footfallImagesValid, getCategorizedImagesValid, storeProcessedDataValid, tagTempIdValid, vmsDataMigrationValid } from '../dtos/revop.dtos.js';
 import { deleteTaggedDuplicate, getTaggingConfig, mappingConfig } from '../validations/revop.validation.js';
 
 export const revopRouter = express.Router();
@@ -11,15 +11,15 @@ revopRouter
     .get( '/getconfig', isAllowedSessionHandler, getconfig )
     .post( '/tagging', isAllowedSessionHandler, revoptagging )
     .post( '/getrevoptagging', isAllowedSessionHandler, getrevoptagging )
+    .post( '/migrate-revop', migrateRevopIndex )
     .post( '/revoptaggingcount', isAllowedSessionHandler, revoptaggingcount )
 
 // new enhnacemnet (for footfall directory)
     .get( '/store-processed-data', isAllowedSessionHandler, validate( storeProcessedDataValid ), storeProcessedData )
     .get( '/footfall-images', isAllowedSessionHandler, validate( footfallImagesValid ), getTaggingConfig, footFallImages )
     .post( '/tag-tempId', isAllowedSessionHandler, validate( tagTempIdValid ), deleteTaggedDuplicate, mappingConfig, tagTempId )
-
-
-    .post( '/get-categorized-images', isAllowedSessionHandler, validate( getCategorizedImagesValid ), getCategorizedImages );
+    .post( '/get-categorized-images', isAllowedSessionHandler, validate( getCategorizedImagesValid ), getCategorizedImages )
+    .post( '/vms-data-migration', validate( vmsDataMigrationValid ), vmsDataMigration );
 
 
 export default revopRouter;

package/src/routes/traffic.routes.js

@@ -92,6 +92,7 @@ import {
   funnelV3,
   getStoreMapDataV3,
   managerTrafficDensityExport,
+  getStoreListv2,
 } from '../controllers/tangoTrafficV3.controllers.js';
 analysisTrafficRouter
     .get( '/welcome', welcome )
@@ -175,5 +176,6 @@ analysisTrafficRouter
     .post( '/headerCountry_v2', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateCountryHeaderParamsv2 ), getAssinedStore, headerCountryV2 )
     .post( '/checkTodayReportStatus', isAllowedSessionHandler, checkTodayReportStatus )
     .post( '/headerZoneV2', isAllowedSessionHandler, headerZoneV2 )
-    .post( '/trafficDensityExport_v2', managerTrafficDensityExport );
+    .post( '/trafficDensityExport_v2', managerTrafficDensityExport )
+    .post( '/get-store-list-v2', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateGetStoreList ), getStoreListv2 );
 export default analysisTrafficRouter;

package/src/validations/revop.validation.js

@@ -1,26 +1,100 @@
 import { getOpenSearchCount, logger } from 'tango-app-api-middleware';
-import { findOneStore } from '../services/stores.service.js';
-import { deleteByQuery } from 'tango-app-api-middleware/src/utils/openSearch.js';
-import { findOne } from '../services/clients.services.js';
+import { deleteByQuery, getOpenSearchData } from 'tango-app-api-middleware/src/utils/openSearch.js';
+import { aggregate } from '../services/clients.services.js';
 
 export async function getTaggingConfig( req, res, next ) {
   try {
     const inputData= req.query;
     const clientId = inputData.storeId.split( '-' )[0];
-    const getData = await findOne( { clientId: clientId }, { footfallDirectoryConfigs: 1 } );
+    const configQuery = [
+      {
+        $match: {
+          clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
+              {
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
+              },
+              0,
+            ],
+          },
+        },
+      },
+
+      {
+        $project: {
+          config: 1,
+          effectiveLimitation: 1,
+          footfallDirectoryConfigs: 1,
+        },
+      },
+    ];
+
+
+    const getData = await aggregate( configQuery );
 
     // Convert "taggingLimitation" array (if present) to "config" object with expected key-value pairs
     let config = {};
-    if ( getData && Array.isArray( getData.taggingLimitation ) ) {
-      for ( const item of getData.taggingLimitation ) {
+    if ( getData && getData?.length > 0 && Array.isArray( getData?.[0]?.effectiveLimitation?.values ) ) {
+      for ( const item of getData?.[0]?.footfallDirectoryConfigs?.taggingLimitation?.[0]?.values ) {
         if ( item && item.type && typeof item.value !== 'undefined' && item.unit ) {
           config[item.type] = `${item.value}${item.unit}`;
         }
       }
     }
-    getData.config = config;
+    // getData[0].footfallDirectoryConfigs.taggingLimitation = [];
+    getData[0].footfallDirectoryConfigs.config = config;
 
-    req.store = getData;
+    getData[0].footfallDirectoryConfigs.taggingLimitation = getData?.[0]?.effectiveLimitation?.values;
+    req.store = getData[0];
     next();
   } catch ( error ) {
     logger.error( { error: error, message: req.body, function: 'traffic-revop-getTaggingConfig' } );
@@ -65,41 +139,126 @@ export async function getFootfallCount( req, res, next ) {
 export async function mappingConfig( req, res, next ) {
   try {
     const inputData = req.body;
+
     const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const config =await findOneStore( { storeId: inputData.storeId }, { revopTagging: 1 } );
-    if ( inputData.revopsType == 'employee' ) {
-      const getQuery = {
-        query: {
-          bool: {
-            must: [
-              {
-                term: {
-                  'storeId.keyword': inputData.storeId,
-                },
+    const footfallQuery ={
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'store_id.keyword': inputData.storeId,
               },
-              {
-                term: {
-                  'dateString': inputData.dateString,
-                },
+            },
+            {
+              term: {
+                'date_string': inputData.dateString,
               },
+            },
+
+          ],
+        },
+      },
+    };
+
+
+    const footfallOutput = await getOpenSearchData( openSearch.footfall, footfallQuery );
+    if ( footfallOutput?.body?.hits?.hits?.length === 0 ) {
+      return res.sendError( 'No updated footfall for this date', 400 );
+    }
+    const getFootfallCount = footfallOutput?.body?.hits?.hits;
+    const footfall = getFootfallCount?.[0]?._source?.footfall_count;
+    const clientId = inputData?.storeId?.split( '-' )[0];
+    const configQuery = [
+      {
+        $match: {
+          clientId: clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
               {
-                term: {
-                  'revopsType.keyword': inputData.revopsType,
-                },
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
               },
+              0,
             ],
           },
         },
-      };
+      },
 
-      const getData = await getOpenSearchCount( openSearch.revop, getQuery );
-      if ( getData && getData?.body?.count >= config?.revopTagging?.employee ) {
-        return res.sendError( `Select up to ${config?.revopTagging?.employee} items only`, 400 );
-      } else {
-        next();
-      }
-    } else if ( inputData.revopsType == 'house-keeping' ) {
-      const getQuery = {
+      {
+        $project: {
+          config: 1,
+          effectiveLimitation: 1,
+          footfallDirectoryConfigs: 1,
+        },
+      },
+    ];
+    const getConfig = await aggregate( configQuery );
+    const taggingLimitation = getConfig?.[0]?.effectiveLimitation?.values;
+
+    // Find the tagging limitation for the given revopsType
+    let matchedLimitation = null;
+    if ( Array.isArray( taggingLimitation ) ) {
+      matchedLimitation = taggingLimitation.find(
+          ( l ) => l.type === inputData.revopsType,
+      );
+    }
+
+    if ( matchedLimitation ) {
+      // Determine the limit value
+      let limitValue = Number( matchedLimitation.value ) || 0;
+      let unit = matchedLimitation.unit;
+
+      // Assuming getData and/or getOpenSearchCount provides the actual tagged count for revopsType
+      // Query OpenSearch for current tagged count for this revopsType
+      const taggedCountQuery = {
         query: {
           bool: {
             must: [
@@ -118,92 +277,51 @@ export async function mappingConfig( req, res, next ) {
                   'revopsType.keyword': inputData.revopsType,
                 },
               },
+              {
+                term: {
+                  'isParent': false,
+                },
+              },
             ],
           },
         },
       };
-      const getData = await getOpenSearchCount( openSearch.revop, getQuery );
-      if ( getData && getData?.body?.count >= config?.revopTagging?.houseKeeping ) {
-        return res.sendError( `Select up to ${config?.revopTagging?.houseKeeping} items only`, 400 );
+      const taggedData = await getOpenSearchCount( openSearch.revop, taggedCountQuery );
+      const taggedValue = ( taggedData?.body?.count || 0 )+ ( inputData.revopsType == 'duplicate'? inputData?.duplicateImage?.length : 1 );
+      // If the unit is %, compare percentage of taggedValue/footfall, otherwise compare taggedValue to limitValue directly
+      let isLimitExceeded = false;
+      if ( unit === '%' ) {
+        // footfall may be undefined, treat as 0 (avoid division by zero)
+        const totalFootfall = Number( footfall ) || 0;
+        const taggedPercent = totalFootfall > 0 ? ( taggedValue / totalFootfall ) * 100 : 0;
+        isLimitExceeded = taggedPercent > limitValue;
+        logger.info( {
+          limitType: 'PERCENT',
+          taggedValue,
+          totalFootfall,
+          taggedPercent,
+          limitValue,
+          isLimitExceeded,
+          forRevopsType: inputData.revopsType,
+        } );
       } else {
-        next();
+        // Non-percent, treat limitValue as an absolute number
+        isLimitExceeded = taggedValue > limitValue;
+        logger.info( {
+          limitType: 'ABSOLUTE',
+          taggedValue,
+          limitValue,
+          isLimitExceeded,
+          forRevopsType: inputData.revopsType,
+        } );
       }
-    } else if ( inputData.revopsType === 'junk' ) {
-      if ( ( req?.user?.userType == 'client' && req?.user?.userType !== 'user ' ) || req?.user?.userType === 'tango' ) {
-        next();
-        return;
-      } else {
-        return res.sendError( 'Forbidden to junk mapping', 500 );
+      if ( isLimitExceeded ) {
+        return res.sendError( `Limit exceed: Only ${limitValue}${unit || ''} items allowed for ${inputData.revopsType}`, 400 );
       }
+      return next();
     } else {
-      next();
+      return next();
     }
-    // else if ( inputData.revopsType == 'duplicate' ) {
-    //   const getFootfallQuery = {
-    //     query: {
-    //       terms: {
-    //         _id: [ inputData?.dateString ],
-    //       },
-    //     },
-    //     _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
-    //     sort: [
-    //       {
-    //         date_iso: {
-    //           order: 'desc',
-    //         },
-    //       },
-    //     ],
-    //   };
-
-    //   const getFootfall = await getOpenSearchData( openSearch.footfall, getFootfallQuery );
-    //   const footfall = getFootfall?.body?.hites?.hits?.[0]?._source?.footfall_count;
-    //   const getQuery = {
-    //     query: {
-    //       bool: {
-    //         must: [
-    //           {
-    //             term: {
-    //               'storeId.keyword': inputData.storeId,
-    //             },
-    //           },
-    //           {
-    //             term: {
-    //               'dateString': inputData.dateString,
-    //             },
-    //           },
-    //           {
-    //             term: {
-    //               'revopsType.keyword': inputData.revopsType,
-    //             },
-    //           },
-    //           {
-    //             term: {
-    //               'parent.keyword': null,
-    //             },
-    //           },
-    //         ],
-    //       },
-    //     },
-    //   };
-    //   const getData = await getOpenSearchCount( openSearch.revop, getQuery );
-    //   logger.info( { getData: getData, footfall: footfall, duplicate: config?.revopTagging?.duplicate } );
-    //   if ( getData && footfall && config?.revopTagging?.duplicate ) {
-    //     const data = config?.revopTagging?.duplicate;
-    //     // Convert "20%" → 0.2 (handle both "20%" and 20)
-    //     const percentStr = typeof data === 'string' ? data.replace( '%', '' ) : data;
-    //     logger.info( { percentStr: percentStr } );
-    //     const percentValue =percentStr / 100;
-
-    //     const result = percentValue * footfall;
-
-    //     logger.info( { result: result, footfall: footfall } );
-    //   }
-    //   if ( getData && getData?.body?.count >= Math.round( result ) ) {
-    //     return res.sendError( `Select up to ${config?.revopTagging?.duplicate} items only`, 400 );
-    //   } else {
-    //     next();
-    //   }
-    // }
   } catch ( error ) {
     logger.error( { error: error, message: req.body, function: 'traffic-revop-getTaggingConfig' } );
     next();