tango-app-api-analysis-traffic 3.8.1-alpha.2 → 3.8.1-alpha.20

package/app.js

@@ -0,0 +1,46 @@
+import express from 'express';
+import { analysisTrafficRouter, mobileTrafficAnalysisRouter, nobRouter, revopRouter } from './index.js';
+
+import dotenv from 'dotenv';
+import { logger } from 'tango-app-api-middleware';
+import { connectdb } from './config/database/database.js';
+import responseMiddleware from './config/response/response.js';
+import errorMiddleware from './config/response/error.js';
+import pkg from 'body-parser';
+import { swaggerConfig } from './config/swagger/swagger.js';
+import swagger from 'swagger-ui-express';
+import cors from 'cors';
+
+const { json, urlencoded } = pkg;
+const env=dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+
+app.use( json( { limit: '500mb' } ) );
+app.use(
+    urlencoded( {
+      extended: true,
+    } ),
+);
+
+app.use( cors() );
+app.use( responseMiddleware );
+app.use( errorMiddleware );
+
+if ( env.error ) {
+  logger.error( '.env not found' );
+  process.exit( 1 );
+}
+app.use( '/api-docs', swagger.serve, swagger.setup( swaggerConfig ) );
+
+app.use( '/v3/trafficAnalysis', analysisTrafficRouter );
+app.use( '/v3/mobile/trafficAnalysis', mobileTrafficAnalysisRouter );
+app.use( '/v3/nob', nobRouter );
+app.use( '/v3/revops', revopRouter );
+
+app.listen( PORT, () => {
+  logger.info( `server is running on port= ${PORT} ` );
+  connectdb();
+} );

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "tango-app-api-analysis-traffic",
-    "version": "3.8.1-alpha.2",
+    "version": "3.8.1-alpha.20",
     "description": "Traffic Analysis",
-    "main": "index.js",
+    "main": "app.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"
@@ -23,8 +23,8 @@
         "mongodb": "^6.8.0",
         "nodemon": "^3.1.4",
         "swagger-ui-express": "^5.0.1",
-        "tango-api-schema": "^2.2.201",
-        "tango-app-api-middleware": "^3.1.88",
+        "tango-api-schema": "^2.2.203",
+        "tango-app-api-middleware": "^3.1.92",
         "winston": "^3.13.1",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/revop.controller.js

@@ -1,7 +1,7 @@
 import { logger, insertOpenSearchData, getOpenSearchData, updateOpenSearchData } from 'tango-app-api-middleware';
 import { findOnerevopConfig } from '../services/revopConfig.service.js';
 import * as clientService from '../services/clients.services.js';
-import { upsertWithScript } from 'tango-app-api-middleware/src/utils/openSearch.js';
+import { bulkUpdate, upsertWithScript } from 'tango-app-api-middleware/src/utils/openSearch.js';
 import dayjs from 'dayjs';
 // Lamda Service Call //
 async function LamdaServiceCall( url, data ) {
@@ -74,6 +74,7 @@ export async function revoptagging( req, res ) {
       } else {
         item.createdAt = new Date();
         item.updatedAt = new Date();
+        item.type='tagging';
         await insertOpenSearchData( openSearch.revops, item );
       }
     }
@@ -229,12 +230,25 @@ export async function storeProcessedData( req, res ) {
       ],
     };
 
-
     const getData = await getOpenSearchData( openSearch.footfall, getQuery );
-    const processedData = getData?.body?.hits?.hits?.[0]?._source;
-    const previousData = getData?.body?.hits?.hits?.[1]?._source;
-    const result=( ( processedData?.footfall_count - previousData?.footfall_count )/previousData?.footfall_count )*100;
-    return res.sendSuccess( { footfallCount: processedData?.footfall_count, footfallCountTrend: Math.round( result ), downtime: processedData?.down_time } );
+    const hits = getData?.body?.hits?.hits || [];
+
+    const processedData = hits.find( ( d ) => d._id === dateString )?._source || null;
+    const previousData = hits.find( ( d ) => d._id === dateStringPrevious )?._source || null;
+
+    let footfallCountTrend = 0;
+
+    if ( processedData && previousData && previousData.footfall_count ) {
+      footfallCountTrend = Math.round(
+          ( ( processedData.footfall_count - previousData.footfall_count ) / previousData.footfall_count ) * 100,
+      );
+    }
+
+    return res.sendSuccess( {
+      footfallCount: processedData?.footfall_count || 0,
+      footfallCountTrend,
+      downtime: processedData?.down_time || 0,
+    } );
   } catch ( error ) {
     logger.error( { message: error, data: req.query, function: 'storeProcessedData' } );
     const err = error.message || 'Internal Server Error';
@@ -244,21 +258,68 @@ export async function storeProcessedData( req, res ) {
 
 export async function footFallImages( req, res ) {
   try {
+    const revop = JSON.parse( process.env.URL );
     const inputData = req.query;
     inputData.clientId = inputData.storeId.split( '-' )[0];
     inputData.storeId=[ inputData.storeId ];
 
-    const LamdaURL = 'https://cncmzszloku7y3bewxbpiy6nkm0yunqe.lambda-url.ap-south-1.on.aws/';
-    let resultData = await LamdaServiceCall( LamdaURL, inputData );
-    if ( resultData ) {
-      if ( resultData.status_code == '200' ) {
-        return res.sendSuccess( { ...resultData, ticketStatus: '' } );
-      } else {
-        return res.sendError( 'No Content', 204 );
-      }
-    } else {
-      return res.sendError( 'No Content', 204 );
-    }
+    const opensearch = JSON.parse( process.env.OPENSEARCH );
+    const query = {
+      'query': {
+        'bool': {
+          must: [
+            {
+              'term': {
+                'storeId.keyword': inputData?.storeId[0],
+              },
+            },
+
+            {
+              'term': {
+                'dateString': inputData?.dateString,
+              },
+            },
+            {
+              'term': {
+                'ticketName.keyword': 'footfall-directory',
+              },
+            },
+          ],
+        },
+      },
+      '_source': [ 'dateString', 'storeId', 'duplicateCount', 'footfallCount', 'employeeCount', 'houseKeepingCount', 'status', 'ticketId', 'comments', 'userName', 'role', 'createdAt', 'email', 'houseKeepingACCount', 'duplicateACCount', 'employeeACCount', 'approverEmail', 'approverRole', 'approverUserName' ],
+
+    };
+
+    const getData = await getOpenSearchData( opensearch.footfallDirectory, query );
+    const ticketDetails = getData?.body?.hits?.hits[0];
+    let temp = [];
+   ticketDetails?._source? temp.push( ticketDetails?._source ) :null;
+   //  temp[0].status = 'open';
+   if ( ticketDetails?._source?.status == 'closed' ) {
+     delete temp[0].status;
+     temp.push( { ...ticketDetails?._source, status: 'closed' } );
+
+     temp[1].userName = getData?.body?.hits?.hits?.[0]?._source?.approverUserName;
+     temp[1].email = getData?.body?.hits?.hits?.[0]?._source?.approverEmail;
+     temp[1].role = getData?.body?.hits?.hits?.[0]?._source?.approverRole;
+     temp[1].employeeCount = getData?.body?.hits?.hits?.[0]?._source?.employeeACCount;
+     temp[1].houseKeepingCount = getData?.body?.hits?.hits?.[0]?._source?.houseKeepingACCount;
+     temp[1].duplicateCount = getData?.body?.hits?.hits?.[0]?._source?.duplicateACCount;
+   }
+   const LamdaURL = revop.getImages;
+   let resultData = await LamdaServiceCall( LamdaURL, inputData );
+   logger.info( { resultData: resultData } );
+   if ( resultData ) {
+   temp.length? temp[0].status = 'open': null;
+   if ( resultData.status_code == '200' ) {
+     return res.sendSuccess( { ...resultData, ticketStatus: temp?.length > 0? temp : null, config: req?.store?.revopTagging } );
+   } else {
+     return res.sendError( 'No Content', 204 );
+   }
+   } else {
+     return res.sendError( 'No Content', 204 );
+   }
   } catch ( error ) {
     logger.error( { message: error, data: req.query, function: 'storeProcessedData' } );
     const err = error.message || 'Internal Server Error';
@@ -281,9 +342,11 @@ export async function tagTempId( req, res ) {
       entryTime: inputData.entryTime,
       exitTime: inputData.exitTime,
       filePath: inputData.filePath,
-      status: 'submitted',
+      status: inputData?.revopsType == 'non-tagging' ?'':'submitted',
       description: '',
-      dublicateImage: inputData?.dublicateImage?.length>0? inputData?.dublicateImage :[],
+      isChecked: inputData.isChecked,
+      duplicateImage: inputData?.duplicateImage?.length>0? inputData?.duplicateImage :[],
+      type: 'tagging-reflect',
       createdAt: new Date(),
       updatedAt: new Date(),
 
@@ -297,15 +360,17 @@ export async function tagTempId( req, res ) {
     ctx._source.filePath = params.filePath;
     ctx._source.status = params.status;
     ctx._source.description = params.description;
-    ctx._source.dublicateImage = params.dublicateImage;
+    ctx._source.isChecked = params.isChecked;
+    ctx._source.duplicateImage = params.duplicateImage;
     ctx._source.updatedAt = params.updatedAt;
+    ctx._source.timeRange = params.timeRange;
     if (ctx._source.createdAt == null) {
       ctx._source.createdAt = params.createdAt;
        ctx._source.clientId = params.clientId;
     ctx._source.storeId = params.storeId;
     ctx._source.tempId = params.tempId;
     ctx._source.dateString = params.dateString;
-    ctx._source.timeRange = params.timeRange;
+    ctx._source.type = "tagging-reflect";
     ctx._source.processType = params.processType;
     }
   `,
@@ -313,7 +378,53 @@ export async function tagTempId( req, res ) {
     };
     const id = `${inputData.storeId}_${inputData.dateString}_${inputData.timeRange}_${inputData.tempId}`;
     await upsertWithScript( openSearch.revop, id, { script, upsert: upsertRecord } );
-    return res.sendSuccess( `tempId ${inputData.tempId} has been tagged successfully` );
+    if ( inputData?.duplicateImage?.length> 0 ) {
+      let bulkBody = [];
+      for ( let item of inputData?.duplicateImage ) {
+        const insertRecord = {
+          clientId: inputData.storeId.split( '-' )[0],
+          storeId: inputData.storeId,
+          tempId: item.tempId,
+          dateString: inputData.dateString,
+          timeRange: item.timeRange,
+          isChecked: item.isChecked,
+          processType: inputData.processType,
+          revopsType: item.revopsType,
+          entryTime: item.entryTime,
+          exitTime: inputData.exitTime,
+          filePath: item.filePath,
+          status: item?.revopsType == 'non-tagging' ?'':'submitted',
+          description: '',
+          duplicateImage: [],
+          type: 'tagging-reflect',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+
+        };
+        const id =`${inputData.storeId}_${inputData.dateString}_${item.timeRange}_${item.tempId}`;
+        const updatedDuplicateImages = {
+          ...insertRecord,
+          parent: inputData.tempId,
+        };
+        bulkBody.push(
+            { update: { _index: openSearch.revop, _id: id } },
+            { doc: updatedDuplicateImages, doc_as_upsert: true },
+        );
+      }
+      if ( bulkBody.length > 0 ) {
+        const res1 = await bulkUpdate( bulkBody );
+        if ( res1?.errors ) {
+          logger.error( 'Bulk update errors:', res1.items );
+          return { success: false, errors: res1.items };
+        } else {
+          logger.info( { msg: 'res1' } );
+          return res.sendSuccess( `tempId ${inputData.tempId} has been tagged successfully` );
+          // return { success: true };
+        }
+      }
+    } else {
+      return res.sendSuccess( `tempId ${inputData.tempId} has been tagged successfully` );
+    }
   } catch ( error ) {
     logger.error( { message: error, data: req.query, function: 'tagTempId' } );
     const err = error.message || 'Internal Server Error';

package/src/controllers/tangoTrafficV1.controllers.js

@@ -847,6 +847,7 @@ export async function headerClustersV2( req, res ) {
   try {
     let requestData = req.body;
     let getUserEmail = req.user.email;
+    let clientId = req?.user?.clientId;
     let getUserType = req.user.userType;
     let getRole = req.user.role;
     let clusterNames=[];
@@ -862,9 +863,9 @@ export async function headerClustersV2( req, res ) {
         clusterNames = await getclusterList( requestData.clientId, getUserType, getRole, req );
       } else if ( getUserType == 'client' ) {
         if ( getRole == 'superadmin' ) {
-          clusterNames = await getclusterList( requestData.clientId, getUserType, getRole, req );
+          clusterNames = await getclusterList( clientId, getUserType, getRole, req );
         } else {
-          clusterNames = await getclusterList( requestData.clientId, getUserType, getRole, req );
+          clusterNames = await getclusterList( clientId, getUserType, getRole, req );
         }
       }
     }
@@ -1577,31 +1578,30 @@ async function getLocationStores( userClientId, cityList, req ) {
 }
 async function getclusterList( userClientId, getUserType, getRole, req ) {
   try {
-    if ( userClientId && userClientId !='' ) {
-      let filter = [
-        { clientId: { $eq: userClientId } },
-      ];
+    if ( userClientId && userClientId !='' || getUserType === 'tango' ) {
+      let filter = [];
+      if ( userClientId && userClientId !='' ) {
+        filter.push( { clientId: { $eq: userClientId } },
+        );
+      }
       if ( req.body.assignedStores&&req.body.assignedStores.length>0 ) {
         filter.push( { 'stores.storeId': { $in: req.body.assignedStores } } );
       }
       if ( getUserType == 'client'&&getRole!='superadmin' ) {
         filter.push( { 'Teamlead.email': req.user.email } );
       }
+      let clusterQuery = [];
 
+      if ( filter.length > 0 ) {
+        clusterQuery.push( { $match: { $and: filter } } );
+      }
 
-      let clusterQuery = [
-        {
-          $match: {
-            $and: filter,
-          },
-        },
-        {
-          $group: {
-            _id: null,
-            clusterName: { $push: '$clusterName' },
-          },
+      clusterQuery.push( {
+        $group: {
+          _id: null,
+          clusterName: { $push: '$clusterName' },
         },
-      ];
+      } );
       const clusterIds = await aggregateCluster( clusterQuery );
       if ( clusterIds && clusterIds.length>0 && clusterIds[0]?.clusterName.length > 0 ) {
         let uniqueclusterIds = [ ...new Set( clusterIds[0].clusterName ) ];

package/src/dtos/revop.dtos.js

@@ -32,7 +32,18 @@ export const tagTempIdSchema = joi.object( {
   tempId: joi.number().required(),
   revopsType: joi.string().required(),
   timeRange: joi.string().required(),
-  dublicateImage: joi.array().optional(),
+  isChecked: joi.boolean().required().allow( null ),
+  duplicateImage: joi.array().items( joi.object(
+      {
+        tempId: joi.number().required(),
+        timeRange: joi.string().required(),
+        entryTime: joi.string().required(),
+        exitTime: joi.string().required(),
+        filePath: joi.string().required(),
+        revopsType: joi.string().required(),
+        isChecked: joi.boolean().required().allow( null ),
+      },
+  ) ).optional(),
   processType: joi.string().required(),
   entryTime: joi.string().required(),
   exitTime: joi.string().required(),

package/src/dtos/validation.dtos.js

@@ -208,7 +208,7 @@ export const validateperformanceMatrixParams = {
 };
 
 export const validateHeaderSchema = joi.object( {
-  clientId: joi.string().required(),
+  clientId: joi.string().required().allow( '' ),
   city: joi.array().required(),
   group: joi.array().required(),
   country: joi.array().optional().empty(),

package/src/routes/revop.routes.js

@@ -3,6 +3,7 @@ import express from 'express';
 import { storeProcessedData, getconfig, revoptagging, getrevoptagging, revoptaggingcount, footFallImages, tagTempId, getCategorizedImages } from '../controllers/revop.controller.js';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
 import { footfallImagesValid, getCategorizedImagesValid, storeProcessedDataValid, tagTempIdValid } from '../dtos/revop.dtos.js';
+import { deletetagedDuplicate, getTaggingConfig, mappingConfig } from '../validations/revop.validation.js';
 
 export const revopRouter = express.Router();
 
@@ -14,8 +15,8 @@ revopRouter
 
 // new enhnacemnet (for footfall directory)
     .get( '/store-processed-data', isAllowedSessionHandler, validate( storeProcessedDataValid ), storeProcessedData )
-    .get( '/footfall-images', isAllowedSessionHandler, validate( footfallImagesValid ), footFallImages )
-    .post( '/tag-tempId', isAllowedSessionHandler, validate( tagTempIdValid ), tagTempId )
+    .get( '/footfall-images', isAllowedSessionHandler, validate( footfallImagesValid ), getTaggingConfig, footFallImages )
+    .post( '/tag-tempId', isAllowedSessionHandler, validate( tagTempIdValid ), deletetagedDuplicate, mappingConfig, tagTempId )
 
 
     .post( '/get-categorized-images', isAllowedSessionHandler, validate( getCategorizedImagesValid ), getCategorizedImages );

package/src/validations/revop.validation.js

@@ -0,0 +1,145 @@
+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';
+
+export async function getTaggingConfig( req, res, next ) {
+  try {
+    const inputData= req.body;
+    const getData = await findOneStore( { storeId: inputData.storeId }, { revopTagging: 1 } );
+    req.store = getData;
+    next();
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'traffic-revop-getTaggingConfig' } );
+    next();
+  }
+}
+
+
+export async function getFootfallCount( req, res, next ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.query;
+    const dateString = `${inputData.storeId}_${inputData.dateString}`;
+    const getQuery = {
+      query: {
+        terms: {
+          _id: [ dateString ],
+        },
+      },
+      _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
+      sort: [
+        {
+          date_iso: {
+            order: 'desc',
+          },
+        },
+      ],
+    };
+
+    const getData = await getOpenSearchData( openSearch.footfall, getQuery );
+    const hits = getData?.body?.hits?.hits || [];
+
+    const processedData = hits.find( ( d ) => d._id === dateString )?._source || null;
+    req.Footfall =processedData;
+    next();
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'traffic-revop-getFootfallCount' } );
+    next();
+  }
+}
+
+export async function mappingConfig( req, res, next ) {
+  try {
+    const inputData = req.body;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    // const footfall = req?.footfall?.footfall_count;
+    if ( inputData.revopsType == 'employee' ) {
+      const getQuery = {
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'storeId.keyword': inputData.storeId,
+                },
+              },
+              {
+                term: {
+                  'dateString': inputData.dateString,
+                },
+              },
+              {
+                term: {
+                  'revopsType.keyword': inputData.revopsType,
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const getData = await getOpenSearchCount( openSearch.revop, getQuery );
+      if ( getData && getData?.body?.count >= 2 ) {
+        return res.sendError( 'Select up to 2 items only', 400 );
+      } else {
+        next();
+      }
+    } else if ( inputData.revopsType == 'house-keeping' ) {
+      const getQuery = {
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'storeId.keyword': inputData.storeId,
+                },
+              },
+              {
+                term: {
+                  'dateString': inputData.dateString,
+                },
+              },
+              {
+                term: {
+                  'revopsType.keyword': inputData.revopsType,
+                },
+              },
+            ],
+          },
+        },
+      };
+      const getData = await getOpenSearchCount( openSearch.revop, getQuery );
+      if ( getData && getData?.body?.count >= 1 ) {
+        return res.sendError( 'Select up to 1 items only', 400 );
+      } else {
+        next();
+      }
+    } else {
+      next();
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'traffic-revop-getTaggingConfig' } );
+    next();
+  }
+}
+
+export async function deletetagedDuplicate( req, res, next ) {
+  try {
+    const inputData = req.body;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const getQuery = {
+      query: {
+        term: {
+          parent: inputData?.tempId,
+        },
+      },
+
+    };
+    await deleteByQuery( openSearch.revop, getQuery );
+    next();
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'traffic-revop-deletetagedDuplicate' } );
+    next();
+  }
+}
+