tango-app-api-analysis-traffic 3.0.0-alpha.33 → 3.0.0-alpha.35

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-analysis-traffic",
-    "version": "3.0.0-alpha.33",
+    "version": "3.0.0-alpha.35",
     "description": "Traffic Analysis",
     "main": "index.js",
     "type": "module",
@@ -22,7 +22,7 @@
         "mongodb": "^6.8.0",
         "nodemon": "^3.1.4",
         "tango-api-schema": "^2.0.131",
-        "tango-app-api-middleware": "^3.1.41",
+        "tango-app-api-middleware": "^3.1.43-alpha.6",
         "winston": "^3.13.1",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/tangoTrafficV1.controllers.js

@@ -5,6 +5,7 @@ import {
   findOneStore,
 } from '../services/stores.service.js';
 import { aggregateUserAssignedStore, findOneUserAssignedStore } from '../services/userAssignedStore.service.js';
+import { aggregateCluster } from '../services/cluster.service.js';
 import { aggregateGroup } from '../services/group.service.js';
 import dayjs from 'dayjs';
 import mongoose from 'mongoose';
@@ -62,6 +63,33 @@ export const cardsFunnelV1 = async ( req, res ) => {
   }
 };
 
+export const funnelV1 = 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;
+    reqestData.currency = getClientData.paymentInvoice?.currencyType || 'inr';
+    reqestData.revenue = getClientData.averageTransactionValue || '0';
+    let LamdaURL = 'https://k3mv4jr6w7er4tn3ku2kkdgdha0ovyog.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 ) {
+    logger.error( { error: error, message: req.query, function: 'funnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
 export const cardsGraphsV1 = async ( req, res ) => {
   try {
     let reqestData = req.body;
@@ -655,7 +683,56 @@ export const headerLocationsV1 = async ( req, res ) => {
     return res.sendError( { error: error }, 500 );
   }
 };
-
+export const headerLocationsV2 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getUserEmail = req.user.email;
+    let getUserType = req.user.userType;
+    let getRole = req.user.role;
+    let getClientId = reqestData.clientId;
+    let totalStores = await getStoresList( getUserEmail, getClientId, getUserType, getRole, req );
+    if ( totalStores && totalStores.length>0 ) {
+      let storeQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: getClientId } },
+              { storeId: { $in: totalStores } },
+            ],
+          },
+        },
+        {
+          $group: {
+            _id: '$storeProfile.city',
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            city: '$_id',
+          },
+        },
+        {
+          $sort: {
+            city: -1,
+          },
+        },
+      ];
+      const cityList = await aggregateStore( storeQuery );
+      if ( cityList && cityList.length > 0 ) {
+        let city = cityList.filter( ( data ) => data.city!='' );
+        return res.sendSuccess( { locationData: city } );
+      } else {
+        return res.sendError( 'No City', 400 );
+      }
+    } else {
+      return res.sendError( 'No stores', 400 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'trafficCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
 export const headerGroupsV1 = async ( req, res ) => {
   try {
     let requestData = req.body;
@@ -664,7 +741,7 @@ export const headerGroupsV1 = async ( req, res ) => {
     let getRole = req.user.role;
     let groupIds;
     if ( requestData.city && requestData.city.length>0 ) {
-      let getGroupIds = await getCityStores( requestData.clientId, getUserEmail, getRole, requestData.city, getUserType );
+      let getGroupIds = await getCityStores( requestData.clientId, getUserEmail, getRole, requestData.city, getUserType, req );
       if ( getGroupIds && getGroupIds.length>0 ) {
         groupIds = getGroupIds;
       } else {
@@ -730,7 +807,141 @@ export const headerGroupsV1 = async ( req, res ) => {
     return res.sendError( { error: error }, 500 );
   }
 };
+export async function headerClustersV2( req, res ) {
+  try {
+    let requestData = req.body;
+    let getUserEmail = req.user.email;
+    let getUserType = req.user.userType;
+    let getRole = req.user.role;
+    let clusterNames=[];
+    if ( requestData.city && requestData.city.length>0 ) {
+      let getcityclustes = await getCityClusters( requestData.clientId, getUserEmail, getRole, requestData.city, getUserType, req );
+      if ( getcityclustes && getcityclustes.length>0 ) {
+        clusterNames = getcityclustes;
+      } else {
+        clusterNames = [];
+      }
+    } else {
+      if ( getUserType == 'tango' ) {
+        clusterNames = await getclusterList( requestData.clientId, req );
+      } else if ( getUserType == 'client' ) {
+        if ( getRole == 'superadmin' ) {
+          clusterNames = await getclusterList( requestData.clientId, req );
+        } else {
+          clusterNames = await getclusterList( requestData.clientId, req );
+        }
+      }
+    }
+    const dataObjects = clusterNames.map( ( item ) => ( { groupName: item } ) );
+    res.sendSuccess( { groupData: dataObjects } );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'headerClustersV2' } );
+    return res.sendError( { error: error }, 500 );
+  }
+}
+
 
+async function getCityClusters( userClientId, getUserEmail, getRole, requestCity, getUserType, req ) {
+  try {
+    if ( userClientId && userClientId !='' && getUserEmail && getUserEmail !='', getRole && getRole !='', requestCity && requestCity.length>0 ) {
+      let cityStores = await getLocationStores( userClientId, requestCity, req );
+      if ( cityStores && cityStores.length > 0 ) {
+        let storeGroups = await getClusterStoresIds( userClientId, cityStores, getRole, getUserType, getUserEmail );
+        if ( storeGroups && storeGroups.length > 0 ) {
+          return storeGroups;
+        } else {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getCityClusters' } );
+    return false;
+  }
+}
+async function getClusterStoresIds( userClientId, storeIds, getRole, getUserType, getUserEmail ) {
+  try {
+    if ( userClientId && userClientId !='' && storeIds && storeIds !='' && getRole && getRole !='' && getUserType && getUserType !='', getUserEmail && getUserEmail !='' ) {
+      let clusterQuery = [];
+      if ( getUserType == 'client' ) {
+        if ( getRole == 'superadmin' ) {
+          clusterQuery = [
+            {
+              $match: {
+                $and: [
+                  { clientId: { $eq: userClientId } },
+                  { 'stores.storeId': { $in: storeIds } },
+                ],
+              },
+            },
+            {
+              $group: {
+                _id: null,
+                clusterName: { $push: '$clusterName' },
+              },
+            },
+          ];
+        } else {
+          let getAssignedGroupIds = [
+            {
+              $match: {
+                $and: [
+                  { clientId: { $eq: userClientId } },
+                  { 'stores.storeId': { $in: storeIds } },
+                ],
+              },
+            },
+            {
+              $group: {
+                _id: null,
+                clusterName: { $push: '$clusterName' },
+              },
+            },
+          ];
+          const assignedclusters = await aggregateCluster( getAssignedGroupIds );
+          if ( assignedclusters && assignedclusters.length>0 && assignedclusters[0]?.clusterName.length > 0 ) {
+            let uniqueclusters = [ ...new Set( assignedclusters[0].clusterName ) ];
+            return uniqueclusters;
+          }
+        }
+      } else if ( getUserType == 'tango' ) {
+        clusterQuery = [
+          {
+            $match: {
+              $and: [
+                { clientId: { $eq: userClientId } },
+                { 'stores.storeId': { $in: storeIds } },
+              ],
+            },
+          },
+          {
+            $group: {
+              _id: null,
+              clusterName: { $push: '$clusterName' },
+            },
+          },
+        ];
+      }
+
+      const assignedclusters = await aggregateCluster( clusterQuery );
+      if ( assignedclusters && assignedclusters.length>0 && assignedclusters[0]?.clusterName.length > 0 ) {
+        let uniqueclusters = [ ...new Set( assignedclusters[0].clusterName ) ];
+        return uniqueclusters;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getGroupIds' } );
+    return false;
+  }
+}
 export const headerStoresV1 = async ( req, res ) => {
   try {
     let reqestData = req.body;
@@ -834,6 +1045,140 @@ export const headerStoresV1 = async ( req, res ) => {
     return res.sendError( { error: error }, 500 );
   }
 };
+export const headerStoresV2 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getUserEmail = req.user.email;
+    let getUserType = req.user.userType;
+    let getRole = req.user.role;
+    let getClientId = reqestData.clientId;
+    let totalStores = await getStoresList( getUserEmail, getClientId, getUserType, getRole, req );
+    if ( totalStores && totalStores.length>0 ) {
+      let storeQuery = [];
+      if ( reqestData.city.length>0 && reqestData.clusters.length>0 ) {
+        let unqueCityStores = await getLocationStores( getClientId, reqestData.city, req );
+        let unqueGroupStores = await getClusterStores( getClientId, reqestData.clusters );
+        storeQuery = [
+          {
+            $match: {
+              $and: [
+                { storeId: { $in: totalStores } },
+                { storeId: { $in: unqueCityStores } },
+                { storeId: { $in: unqueGroupStores } },
+              ],
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeId: '$storeId',
+              storeName: '$storeName',
+            },
+          },
+        ];
+      } else if ( reqestData.city.length>0 ) {
+        let uniqueCityStores = await getLocationStores( getClientId, reqestData.city, req );
+        storeQuery = [
+          {
+            $match: {
+              $and: [
+                { storeId: { $in: totalStores } },
+                { storeId: { $in: uniqueCityStores } },
+              ],
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeId: '$storeId',
+              storeName: '$storeName',
+            },
+          },
+        ];
+      } else if ( reqestData.clusters.length>0 ) {
+        let uniqueclusterStores = await getClusterStores( getClientId, reqestData.clusters );
+        storeQuery = [
+          {
+            $match: {
+              $and: [
+                { storeId: { $in: totalStores } },
+                { storeId: { $in: uniqueclusterStores } },
+              ],
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeId: '$storeId',
+              storeName: '$storeName',
+            },
+          },
+        ];
+      } else {
+        let totalStores = await getStoresList( getUserEmail, getClientId, getUserType, getRole, req );
+        storeQuery = [
+          {
+            $match: {
+              $and: [
+                { storeId: { $in: totalStores } },
+              ],
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeId: '$storeId',
+              storeName: '$storeName',
+            },
+          },
+        ];
+      }
+
+      const storeList = await aggregateStore( storeQuery );
+      if ( storeList && storeList.length > 0 ) {
+        return res.sendSuccess( { storesData: storeList } );
+      } else {
+        return res.sendError( 'No Stores', 400 );
+      }
+    } else {
+      return res.sendError( 'No Stores', 400 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'headerStoresV2' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+
+async function getStoresList( getUserEmail, getClientId, getUserType, getRole, req ) {
+  try {
+    if ( getUserEmail && getUserEmail !='' && getClientId && getClientId !='' && getUserType && getUserType !='' && getRole && getRole!='' ) {
+      let overAllStores = [];
+      if ( getUserType == 'tango' ) {
+        let getAllS = await getAssignedAllStores( getClientId );
+        if ( getAllS && getAllS.length >0 ) {
+          overAllStores = getAllS;
+        }
+        return overAllStores;
+      } else if ( getUserType == 'client' ) {
+        if ( getRole == 'superadmin' ) {
+          let getAllS = await getAssignedAllStores( getClientId );
+          if ( getAllS && getAllS.length >0 ) {
+            overAllStores = getAllS;
+          }
+          return overAllStores;
+        } else {
+          return req.body.assignedStores;
+        }
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'getAllStores' } );
+  }
+};
+
 
 async function getAllStores( getUserEmail, getClientId, getUserType, getRole ) {
   try {
@@ -1036,6 +1381,59 @@ async function getAssignedAllStores( userClientId ) {
   }
 }
 
+
+async function getClusterStores( userClientId, ClusterList ) {
+  try {
+    if ( userClientId && userClientId !='' && ClusterList && ClusterList.length >0 ) {
+      let ClusterQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: userClientId } },
+              { clusterName: { $in: ClusterList } },
+            ],
+          },
+        },
+        {
+          $unwind: {
+            path: '$storeList', preserveNullAndEmptyArrays: true,
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            storesList: { $push: '$stores' },
+          },
+        },
+        {
+          $project: {
+            storesList: {
+              $reduce: {
+                input: '$storesList', // Merge arrays using $reduce
+                initialValue: [],
+                in: { $concatArrays: [ '$$value', '$$this' ] },
+              },
+            },
+          },
+        },
+      ];
+      const clusterStoreList = await aggregateCluster( ClusterQuery );
+      if ( clusterStoreList && clusterStoreList.length>0 && clusterStoreList[0]?.storesList.length > 0 ) {
+        let storeIds = clusterStoreList[0].storesList.map( ( data ) => data.storeId );
+        let uniqueStores = [ ...new Set( storeIds ) ];
+        return uniqueStores;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'getClusterStores' } );
+    return false;
+  }
+}
+
 async function getGroupStores( userClientId, groupList ) {
   try {
     if ( userClientId && userClientId !='' && groupList && groupList.length >0 ) {
@@ -1076,16 +1474,21 @@ async function getGroupStores( userClientId, groupList ) {
   }
 }
 
-async function getLocationStores( userClientId, cityList ) {
+async function getLocationStores( userClientId, cityList, req ) {
   try {
     if ( userClientId && userClientId !='' && cityList && cityList.length >0 ) {
+      let filter = [
+        { clientId: { $eq: userClientId } },
+        { 'storeProfile.city': { $in: cityList } },
+      ];
+      if ( req.body.assignedStores&&req.body.assignedStores.length>0 ) {
+        filter.push( { storeId: { $in: req.body.assignedStores } } );
+      }
+
       let storeQuery = [
         {
           $match: {
-            $and: [
-              { clientId: { $eq: userClientId } },
-              { 'storeProfile.city': { $in: cityList } },
-            ],
+            $and: filter,
           },
         },
         {
@@ -1105,6 +1508,40 @@ async function getLocationStores( userClientId, cityList ) {
       if ( cityStoreList && cityStoreList.length>0 && cityStoreList[0]?.stores.length > 0 ) {
         let uniqueStores = [ ...new Set( cityStoreList[0].stores ) ];
         return uniqueStores;
+      } else {
+        return [];
+      }
+    } else {
+      return [];
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getLocationStores' } );
+    return false;
+  }
+}
+async function getclusterList( userClientId, req ) {
+  try {
+    if ( userClientId && userClientId !='' ) {
+      let clusterQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: userClientId } },
+              { 'stores.storeId': { $in: req.body.assignedStores } },
+            ],
+          },
+        },
+        {
+          $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 ) ];
+        return uniqueclusterIds;
       } else {
         return false;
       }
@@ -1112,11 +1549,10 @@ async function getLocationStores( userClientId, cityList ) {
       return false;
     }
   } catch ( error ) {
-    logger.error( { error: error, message: data, function: 'getLocationStores' } );
+    logger.error( { error: error, function: 'getclusterList' } );
     return false;
   }
 }
-
 async function getGroupIds( userClientId ) {
   try {
     if ( userClientId && userClientId !='' ) {
@@ -1191,10 +1627,10 @@ async function getAssignedGroupIds( userClientId, getUserEmail ) {
   }
 }
 
-async function getCityStores( userClientId, getUserEmail, getRole, requestCity, getUserType ) {
+async function getCityStores( userClientId, getUserEmail, getRole, requestCity, getUserType, req ) {
   try {
     if ( userClientId && userClientId !='' && getUserEmail && getUserEmail !='', getRole && getRole !='', requestCity && requestCity.length>0 ) {
-      let cityStores = await getLocationStores( userClientId, requestCity );
+      let cityStores = await getLocationStores( userClientId, requestCity, req );
       if ( cityStores && cityStores.length > 0 ) {
         let storeGroups = await getGroupStoresIds( userClientId, cityStores, getRole, getUserType, getUserEmail );
         if ( storeGroups && storeGroups.length > 0 ) {

package/src/dtos/validation.dtos.js

@@ -202,10 +202,17 @@ export const validateHeaderSchema = joi.object( {
   group: joi.array().required(),
 } );
 
+export const validateHeaderSchemav2 = joi.object( {
+  clientId: joi.string().required(),
+  city: joi.array().required(),
+  clusters: joi.array().required(),
+} );
 export const validateHeaderParams = {
   body: validateHeaderSchema,
 };
-
+export const validateHeaderParamsv2 = {
+  body: validateHeaderSchemav2,
+};
 export const getMyProductSchema = joi.object( {
   clientId: joi.string().required(),
   storeId: joi.array().optional().empty(),

package/src/routes/traffic.routes.js

@@ -1,5 +1,5 @@
 import express from 'express';
-import { validate, isAllowedSessionHandler, authorize, isAllowedClient } from 'tango-app-api-middleware';
+import { validate, isAllowedSessionHandler, isAllowedClient, getAssinedStore } from 'tango-app-api-middleware';
 import * as validationDtos from '../dtos/validation.dtos.js';
 
 export const analysisTrafficRouter = express.Router();
@@ -53,6 +53,10 @@ import {
   headerGroupsV1,
   getMySubscription,
   getStoreMapData,
+  funnelV1,
+  headerStoresV2,
+  headerClustersV2,
+  headerLocationsV2,
 } from '../controllers/tangoTrafficV1.controllers.js';
 
 
@@ -79,112 +83,33 @@ analysisTrafficRouter
     .post( '/headerLocations', headerLocations )
     .post( '/headerGroups', headerGroups )
     .post( '/headerStores', headerStores )
-    .post( '/cardsFunnel_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateCardFunnelParams ), cardsFunnelV1 )
-    .post( '/cardsGraphs_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateCardGraphParams ), cardsGraphsV1 )
-    .post( '/recapVideo_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateRecapVideoParams ), recapVideoV1 )
-    .post( '/densityDwell_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateDensityDwellParams ), densityDwellV1 )
-    .post( '/overallCards_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateOverallCharParams ), overallCardsV1 )
-    .post( '/overallHourlyChart_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateOverallCharParams ), overallHourlyChartV1 )
-    .post( '/overallChart_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateOverallCharParams ), overallChartV1 )
-    .post( '/singleStoreChart_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateSingleStoreChartParams ), singleStoreChartV1 )
-    .post( '/demographicChart_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateDemographicChartParams ), demographicChartV1 )
-    .post( '/buyerChart_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateBuyerChartParams ), buyerChartV1 )
-    .post( '/footfallDirectoryFolders_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateFootfallDirectoryFoldersParams ), footfallDirectoryFoldersV1 )
-    .post( '/footfallDirectory_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateFootfallDirectoryParams ), footfallDirectoryV1 )
-    .post( '/summaryTable_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateSummaryTableParams ), summaryTableV1 )
-    .post( '/footfallTrend_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateFootfallTrendParams ), footfallTrendV1 )
-    .post( '/storeOperation_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateStoreOperationParams ), storeOperationV1 )
-    .post( '/performanceMatrix_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateperformanceMatrixParams ), performanceMatrixV1 )
-    .post( '/zoneDwellTimeSplit_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateStoreOperationParams ), zoneDwellTimeSplitV1 )
-    .post( '/storesMap_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateStoresMapParams ), storesMapV1 )
-    .post( '/headerLocations_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateHeaderParams ), headerLocationsV1 )
-    .post( '/headerGroups_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateHeaderParams ), headerGroupsV1 )
-    .post( '/headerStores_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
-      userType: [ 'tango', 'client' ], access: [
-        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
-      ],
-    } ), validate( validationDtos.validateHeaderParams ), headerStoresV1 )
+    .post( '/cardsFunnel_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateCardFunnelParams ), cardsFunnelV1 )
+    .post( '/funnel_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateCardFunnelParams ), funnelV1 )
+    .post( '/cardsGraphs_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateCardGraphParams ), cardsGraphsV1 )
+    .post( '/recapVideo_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateRecapVideoParams ), recapVideoV1 )
+    .post( '/densityDwell_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateDensityDwellParams ), densityDwellV1 )
+    .post( '/overallCards_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateOverallCharParams ), overallCardsV1 )
+    .post( '/overallHourlyChart_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateOverallCharParams ), overallHourlyChartV1 )
+    .post( '/overallChart_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateOverallCharParams ), overallChartV1 )
+    .post( '/singleStoreChart_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateSingleStoreChartParams ), singleStoreChartV1 )
+    .post( '/demographicChart_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateDemographicChartParams ), demographicChartV1 )
+    .post( '/buyerChart_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateBuyerChartParams ), buyerChartV1 )
+    .post( '/footfallDirectoryFolders_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateFootfallDirectoryFoldersParams ), footfallDirectoryFoldersV1 )
+    .post( '/footfallDirectory_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateFootfallDirectoryParams ), footfallDirectoryV1 )
+    .post( '/summaryTable_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateSummaryTableParams ), summaryTableV1 )
+    .post( '/footfallTrend_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateFootfallTrendParams ), footfallTrendV1 )
+    .post( '/storeOperation_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateStoreOperationParams ), storeOperationV1 )
+    .post( '/performanceMatrix_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateperformanceMatrixParams ), performanceMatrixV1 )
+    .post( '/zoneDwellTimeSplit_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateStoreOperationParams ), zoneDwellTimeSplitV1 )
+    .post( '/storesMap_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateStoresMapParams ), storesMapV1 )
+    .post( '/headerLocations_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateHeaderParams ), headerLocationsV1 )
+    .post( '/headerGroups_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateHeaderParams ), headerGroupsV1 )
+    .post( '/headerStores_v1', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateHeaderParams ), headerStoresV1 )
     .post( '/getMySubscription', isAllowedSessionHandler, validate( validationDtos.getMyProductParams ), getMySubscription )
-    .post( '/getStoreMapData', isAllowedSessionHandler, validate( validationDtos.getStoreCameraImageParams ), getStoreMapData );
+    .post( '/getStoreMapData', isAllowedSessionHandler, validate( validationDtos.getStoreCameraImageParams ), getStoreMapData )
+    .post( '/headerStores_v2', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateHeaderParamsv2 ), getAssinedStore, headerStoresV2 )
+    .post( '/headercluster_v2', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateHeaderParams ), getAssinedStore, headerClustersV2 )
+    .post( '/headerLocations_v2', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateHeaderParams ), getAssinedStore, headerLocationsV2 );
+
 
 export default analysisTrafficRouter;

package/src/services/cluster.service.js

@@ -0,0 +1,28 @@
+import clusterModel from 'tango-api-schema/schema/cluster.model.js';
+
+export async function updateOneCluster( query, record ) {
+  return await clusterModel.updateOne( query, { $set: record } );
+};
+
+export async function updateCluster( query, record ) {
+  return await clusterModel.updateMany( query, record );
+};
+
+export async function aggregateCluster( query ) {
+  return await clusterModel.aggregate( query );
+};
+
+export async function findOneCluster( query ={}, field={} ) {
+  return await clusterModel.findOne( query, field );
+};
+export async function deleteCluster( query ={} ) {
+  return await clusterModel.deleteOne( query );
+};
+
+export async function createclusterModel( data ) {
+  return await clusterModel.create( data );
+};
+
+export async function findcluster( query, project ) {
+  return await clusterModel.find( query, project );
+};