tango-app-api-analysis-traffic 3.0.0-alpha.0 → 3.0.0-alpha.2

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "tango-app-api-analysis-traffic",
-    "version": "3.0.0-alpha.0",
+    "version": "3.0.0-alpha.2",
     "description": "Traffic Analysis",
-    "main": "app.js",
+    "main": "index.js",
     "type": "module",
     "scripts": {
-        "start": "nodemon --exec \"eslint --fix . && node app.js\""
+        "start": "nodemon --exec \"eslint --fix . && node index.js\""
     },
     "engines": {
         "node": ">=18.10.0"

package/src/controllers/tangoTrafficV1.controllers.js

@@ -0,0 +1,905 @@
+import { logger } from 'tango-app-api-middleware';
+import * as clientService from '../services/clients.services.js';
+import {
+  aggregateStore,
+} from '../services/stores.service.js';
+import { aggregateUserAssignedStore, findOneUserAssignedStore } from '../services/userAssignedStore.service.js';
+import { aggregateGroup } from '../services/group.service.js';
+
+// Lamda Service Call //
+async function LamdaServiceCall( url, data ) {
+  try {
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify( data ),
+    };
+    const response = await fetch( url, requestOptions );
+    if ( !response.ok ) {
+      throw new Error( `Response status: ${response.status}` );
+      return false;
+    }
+    const json = await response.json();
+    return json;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'LamdaServiceCall' } );
+  }
+}
+
+// ///// V1 API's ///////
+export const cardsFunnelV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getClientData = await clientService.findOne( { clientId: reqestData.clientId } );
+    if ( !getClientData ) {
+      return res.sendError( 'Invalid Client Id', 400 );
+    }
+    reqestData.currency = getClientData.paymentInvoice?.currencyType || 'INR';
+    reqestData.revenue = getClientData.averageTransactionValue || '0';
+    let LamdaURL = 'https://55mojecvuvtphucgsalx5jtyki0untzp.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const cardsGraphsV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://xvsz4gd4erdlmvhv33hhyot3ui0xzitq.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const recapVideoV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://u7xzph4jkl72sbefz2xx5rjw540rocck.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const densityDwellV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://wh2d4dkgsao5kbwpjxbmchcjja0cxjhv.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const overallCardsV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://dugu3ghkgalnpaydf2wdjp37240pzcmy.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const overallHourlyChartV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://p3xcs56mkjj4sfugvsibhyto3i0gdbda.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const overallChartV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://wtcllrsyec4iwkx6sg7xi2b7se0seawx.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const singleStoreChartV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://j2mqa4qhmku3e7htuptsjvpumi0qkhkf.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const demographicChartV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://7mslk3sde3m663mrgmwlc4rfou0alphk.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const buyerChartV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://2i76wug6swytd7fej3d2fvd2xa0ujxhz.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const footfallDirectoryFoldersV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://waxlhd7lfdlmyrkrdyv77najka0ayihq.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const footfallDirectoryV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://waxlhd7lfdlmyrkrdyv77najka0ayihq.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const summaryTableV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://fpmvquqpi7xw6hpaalxa5oa6pi0cvbql.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const footfallTrendV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://l5uacls7kfyham5d7pd3i6c6pq0pflem.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const storeOperationV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://mezoc2jy25t73v6eit57s3px6i0hxkwk.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: 'cardsFunnelV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const storesMapV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    const storeList = [
+      {
+        $match: {
+          clientId: { $eq: '11' },
+          storeId: { $in: reqestData.storeId },
+          $and: [
+            { 'storeProfile.latitude': { $exists: true } },
+            { 'storeProfile.latitude': { $gt: 0 } },
+            { 'storeProfile.latitude': { $exists: true } },
+            { 'storeProfile.latitude': { $gt: 0 } },
+          ],
+        },
+      },
+      {
+        $project: {
+          '_id': 0,
+          'storeId': 1,
+          'storeName': 1,
+          'appId': 1,
+          'storeProfile': 1,
+          'spocDetails': { $arrayElemAt: [ '$spocDetails', 0 ] },
+          'businessType': 1,
+          'storeType': 1,
+          'avgFootfall': '100',
+          'avgWeekdayFootfall': '30',
+          'avgWeekendFootfall': '60',
+          'hourlyFootfall': '60',
+          'openTime': '10:31 AM',
+          'closeTime': '10:31 PM',
+        },
+      },
+      {
+        $sort: {
+          createdAt: -1,
+        },
+      },
+    ];
+    const getStores = await aggregateStore( storeList );
+    // Call Lamba and Get Footfall Count for each stores
+
+    if ( !getStores ) {
+      return res.sendError( 'No Content', 204 );
+    } else {
+      // let LamdaURL = 'https://luliwxsfuncjvpjbbilhwxp52q0zacvc.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 );
+      // }
+    }
+
+    return res.sendSuccess( getStores );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'trafficCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const headerLocationsV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getUserEmail = req.user.email;
+    let getClientId = reqestData.clientId;
+    let totalStores = await getAllStores( getUserEmail, getClientId );
+    if ( totalStores && totalStores.length>0 ) {
+      let storeQuery = [
+        {
+          $match: {
+            $and: [
+              { 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 ) {
+        return res.sendSuccess( { locationData: cityList } );
+      } 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;
+    let getUserEmail = req.user.email;
+    let groupQuery = [
+      {
+        $match: {
+          $and: [
+            { userEmail: { $eq: getUserEmail } },
+            { assignedType: { $eq: 'group' } },
+          ],
+        },
+      },
+      {
+        $group: {
+          _id: '$assignedValue',
+        },
+      },
+      {
+        $lookup: {
+          from: 'groups',
+          let: { groupId: { $toObjectId: '$_id' } },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$_id', '$$groupId' ],
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                groupName: 1,
+              },
+            },
+          ], as: 'groups',
+        },
+      },
+      {
+        $unwind: {
+          path: '$groups', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $unwind: {
+          path: '$groups.groupName', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          groupName: '$groups.groupName',
+        },
+      },
+    ];
+    const groupList = await aggregateUserAssignedStore( groupQuery );
+    if ( groupList && groupList.length > 0 ) {
+      return res.sendSuccess( { groupData: groupList } );
+    } else {
+      return res.sendError( 'No Group', 400 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'trafficCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const headerStoresV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getUserEmail = req.user.email;
+    let getClientId = reqestData.clientId;
+    let totalStores = await getAllStores( getUserEmail, getClientId );
+    if ( totalStores && totalStores.length>0 ) {
+      let storeQuery = [];
+      if ( reqestData.city.length>0 && reqestData.group.length>0 ) {
+        let unqueCityStores = await getLocationStores( getClientId, reqestData.city );
+        let unqueGroupStores = await getGroupStores( getClientId, reqestData.group );
+        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 unqueCityStores = await getLocationStores( getClientId, reqestData.city );
+        storeQuery = [
+          {
+            $match: {
+              $and: [
+                { storeId: { $in: totalStores } },
+                { storeId: { $in: unqueCityStores } },
+              ],
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeId: '$storeId',
+              storeName: '$storeName',
+            },
+          },
+        ];
+      } else if ( reqestData.group.length>0 ) {
+        let unqueGroupStores = await getGroupStores( getClientId, reqestData.group );
+        storeQuery = [
+          {
+            $match: {
+              $and: [
+                { storeId: { $in: totalStores } },
+                { storeId: { $in: unqueGroupStores } },
+              ],
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeId: '$storeId',
+              storeName: '$storeName',
+            },
+          },
+        ];
+      } else {
+        let totalStores = await getAllStores( getUserEmail, getClientId );
+        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( storeList );
+      } else {
+        return res.sendError( 'No Stores', 400 );
+      }
+    } else {
+      return res.sendError( 'No Stores', 400 );
+    }
+  } catch ( error ) {
+    console.log( 'headerStoresV1 =>', error );
+    logger.error( { error: error, message: req.query, function: 'headerStoresV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+async function getAllStores( getUserEmail, getClientId ) {
+  try {
+    if ( getUserEmail && getUserEmail !='' ) {
+      const assignedQuery = {
+        clientId: getClientId,
+        userEmail: getUserEmail,
+      };
+      const getAssignedType = await findOneUserAssignedStore( assignedQuery );
+      if ( getAssignedType ) {
+        if ( getAssignedType.userType == 'client' ) {
+          if ( getAssignedType.assignedType && getAssignedType.assignedType !='' ) {
+            let overAllStores = [];
+            switch ( getAssignedType.assignedType ) {
+              case 'store':
+                let getAS = await getAssignedStores( getClientId, getUserEmail, 'store' );
+                if ( getAS && getAS.length >0 ) {
+                  overAllStores = getAS;
+                }
+                break;
+              case 'group':
+                let getAGS = await getAssignedGroupStores( getClientId, getUserEmail, 'group' );
+                if ( getAGS && getAGS.length >0 ) {
+                  overAllStores = getAGS;
+                }
+                break;
+              case 'allstores':
+                let getAllS = await getAssignedAllStores( getClientId );
+                if ( getAllS && getAllS.length >0 ) {
+                  overAllStores = getAllS;
+                }
+                break;
+              default:
+                break;
+            }
+            return overAllStores;
+          } else {
+            return false;
+          }
+        } else if ( getAssignedType.userType == 'tango' ) {
+          if ( getAssignedType.assignedType && getAssignedType.assignedType !='' ) {
+            let overAllStores = [];
+            let getAllS = await getAssignedAllStores( getClientId );
+            if ( getAllS && getAllS.length >0 ) {
+              overAllStores = getAllS;
+            }
+            return overAllStores;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    console.log( 'getAllStores =>', error );
+    logger.error( { error: error, message: req.query, function: 'getAllStores' } );
+  }
+};
+
+async function getAssignedStores( clientId, userEmail, assignedType ) {
+  try {
+    if ( clientId && clientId !='' && userEmail && userEmail !='' && assignedType && assignedType !='' ) {
+      let storeQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: clientId } },
+              { userEmail: { $eq: userEmail } },
+              { assignedType: { $eq: assignedType } },
+            ],
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            stores: { $push: '$assignedValue' },
+          },
+        },
+      ];
+      const storeList = await aggregateUserAssignedStore( storeQuery );
+      if ( storeList && storeList.length>0 && storeList[0]?.stores.length > 0 ) {
+        let uniqueStores = [ ...new Set( storeList[0].stores ) ];
+        return uniqueStores;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    console.log( 'getAssignedStores error =>', error );
+    logger.error( { error: error, message: data, function: 'getAssignedStores' } );
+  }
+}
+
+async function getAssignedGroupStores( clientId, userEmail, assignedType ) {
+  try {
+    if ( clientId && clientId !='' && userEmail && userEmail !='' && assignedType && assignedType !='' ) {
+      const groupQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: clientId } },
+              { userEmail: { $eq: userEmail } },
+              { assignedType: { $eq: assignedType } },
+            ],
+          },
+        },
+        {
+          $lookup: {
+            from: 'groups',
+            let: { groupId: { $toObjectId: '$assignedValue' } },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $eq: [ '$_id', '$$groupId' ],
+                  },
+                },
+              },
+              {
+                $project: {
+                  _id: 0,
+                  storeList: 1,
+                },
+              },
+            ], as: 'groups',
+          },
+        },
+        {
+          $unwind: {
+            path: '$groups', preserveNullAndEmptyArrays: true,
+          },
+        },
+        {
+          $unwind: {
+            path: '$groups.storeList', preserveNullAndEmptyArrays: true,
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            stores: { $push: '$groups.storeList' },
+          },
+        },
+      ];
+      const groupStoreList = await aggregateUserAssignedStore( groupQuery );
+      if ( groupStoreList && groupStoreList.length>0 && groupStoreList[0]?.stores.length > 0 ) {
+        let uniqueStores = [ ...new Set( groupStoreList[0].stores ) ];
+        return uniqueStores;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    console.log( 'getAssignedGroupStores error =>', error );
+    logger.error( { error: error, message: data, function: 'getAssignedGroupStores' } );
+  }
+}
+
+async function getAssignedAllStores( userClientId ) {
+  try {
+    if ( userClientId && userClientId !='' ) {
+      let storeQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: userClientId } },
+              { status: { $eq: 'active' } },
+            ],
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            stores: { $push: '$storeId' },
+          },
+        },
+      ];
+      const storeList = await aggregateStore( storeQuery );
+      if ( storeList && storeList.length>0 && storeList[0]?.stores.length > 0 ) {
+        let uniqueStores = [ ...new Set( storeList[0].stores ) ];
+        return uniqueStores;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    console.log( 'getAssignedAllStores error =>', error );
+    logger.error( { error: error, message: data, function: 'getAssignedAllStores' } );
+  }
+}
+
+async function getGroupStores( userClientId, groupList ) {
+  try {
+    if ( userClientId && userClientId !='' && groupList && groupList.length >0 ) {
+      let groupQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: userClientId } },
+              { groupName: { $in: groupList } },
+            ],
+          },
+        },
+        {
+          $unwind: {
+            path: '$storeList', preserveNullAndEmptyArrays: true,
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            stores: { $push: '$storeList' },
+          },
+        },
+      ];
+      const groupStoreList = await aggregateGroup( groupQuery );
+      if ( groupStoreList && groupStoreList.length>0 && groupStoreList[0]?.stores.length > 0 ) {
+        let uniqueStores = [ ...new Set( groupStoreList[0].stores ) ];
+        return uniqueStores;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    console.log( 'getGroupStores error =>', error );
+    logger.error( { error: error, message: data, function: 'getGroupStores' } );
+  }
+}
+
+async function getLocationStores( userClientId, cityList ) {
+  try {
+    if ( userClientId && userClientId !='' && cityList && cityList.length >0 ) {
+      let storeQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: userClientId } },
+              { 'storeProfile.city': { $in: cityList } },
+            ],
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            storeId: '$storeId',
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            stores: { $push: '$storeId' },
+          },
+        },
+      ];
+      const cityStoreList = await aggregateStore( storeQuery );
+      if ( cityStoreList && cityStoreList.length>0 && cityStoreList[0]?.stores.length > 0 ) {
+        let uniqueStores = [ ...new Set( cityStoreList[0].stores ) ];
+        return uniqueStores;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    console.log( 'getLocationStores error =>', error );
+    logger.error( { error: error, message: data, function: 'getLocationStores' } );
+  }
+}

package/src/dtos/validation.dtos.js

@@ -0,0 +1,188 @@
+import joi from 'joi';
+
+// Base schema
+const baseSchema = {
+  clientId: joi.string().required(),
+  storeId: joi.array().required().empty(),
+  fromDate: joi.string().required(),
+  toDate: joi.string().required(),
+};
+
+// Schema for Card Funnel
+export const validateCardFunnelSchema = joi.object( {
+  ...baseSchema,
+  valueType: joi.string().required(),
+} );
+
+export const validateCardFunnelParams = {
+  body: validateCardFunnelSchema,
+};
+
+// Schema for Card Graph (extends baseSchema with additional fields)
+export const validateCardGraphSchema = joi.object( {
+  ...baseSchema,
+  valueType: joi.string().required(),
+  dateType: joi.string().required(),
+} );
+
+export const validateCardGraphParams = {
+  body: validateCardGraphSchema,
+};
+
+export const validateRecapVideoSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().required().empty(),
+  recapVideoDate: joi.string().required(),
+} );
+
+export const validateRecapVideoParams = {
+  body: validateRecapVideoSchema,
+};
+
+export const validateDensityDwellSchema = joi.object( {
+  ...baseSchema,
+  dateRange: joi.number().required(),
+  hourFormat: joi.number().required(),
+} );
+
+export const validateDensityDwellParams = {
+  body: validateDensityDwellSchema,
+};
+
+export const validateOverallCardsSchema = joi.object( {
+  ...baseSchema,
+  revenue: joi.number().required(),
+  processType: joi.string().required(),
+} );
+
+export const validateOverallCardsParams = {
+  body: validateOverallCardsSchema,
+};
+
+export const validateOverallHourlyChartSchema = joi.object( {
+  ...baseSchema,
+  hourFormat: joi.number().required(),
+  processType: joi.string().required(),
+} );
+
+export const validateOverallHourlyChartParams = {
+  body: validateOverallHourlyChartSchema,
+};
+
+export const validateOverallCharSchema = joi.object( {
+  ...baseSchema,
+  limit: joi.number().required(),
+  offset: joi.number().required(),
+  processType: joi.string().required(),
+} );
+
+export const validateOverallCharParams = {
+  body: validateOverallCharSchema,
+};
+
+export const validateSingleStoreChartSchema = joi.object( {
+  ...baseSchema,
+  limit: joi.number().required(),
+  offset: joi.number().required(),
+  processType: joi.string().required(),
+} );
+
+export const validateSingleStoreChartParams = {
+  body: validateSingleStoreChartSchema,
+};
+
+export const validateDemographicChartSchema = joi.object( {
+  ...baseSchema,
+  processType: joi.string().required(),
+} );
+
+export const validateDemographicChartParams = {
+  body: validateDemographicChartSchema,
+};
+
+export const validateBuyerChartSchema = joi.object( {
+  ...baseSchema,
+  processType: joi.string().required(),
+} );
+
+export const validateBuyerChartParams = {
+  body: validateBuyerChartSchema,
+};
+
+export const validateFootfallDirectoryFoldersSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().required().empty(),
+  footfallDate: joi.string().required(),
+  processType: joi.string().required(),
+} );
+
+export const validateFootfallDirectoryFoldersParams = {
+  body: validateFootfallDirectoryFoldersSchema,
+};
+
+export const validateFootfallDirectorySchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().required().empty(),
+  footfallDate: joi.string().required(),
+  processType: joi.string().required(),
+  folderName: joi.string().required(),
+} );
+
+export const validateFootfallDirectoryParams = {
+  body: validateFootfallDirectorySchema,
+};
+
+export const validateSummaryTableSchema = joi.object( {
+  ...baseSchema,
+  valueType: joi.string().required(),
+  search: joi.string().optional(),
+  sortBy: joi.number().optional(),
+  sort: joi.string().optional(),
+  limit: joi.number().required(),
+  offset: joi.number().required(),
+} );
+
+export const validateSummaryTableParams = {
+  body: validateSummaryTableSchema,
+};
+
+export const validateFootfallTrendSchema = joi.object( {
+  ...baseSchema,
+  filterBy: joi.string().required(),
+  processType: joi.string().required(),
+  forecast: joi.boolean().optional(),
+  limit: joi.number().required(),
+  offset: joi.number().required(),
+} );
+
+export const validateFootfallTrendParams = {
+  body: validateFootfallTrendSchema,
+};
+
+export const validateStoreOperationSchema = joi.object( {
+  ...baseSchema,
+} );
+
+export const validateStoreOperationParams = {
+  body: validateStoreOperationSchema,
+};
+
+export const validateStoresMapSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().required().empty(),
+  storeDate: joi.string().required(),
+} );
+
+export const validateStoresMapParams = {
+  body: validateStoresMapSchema,
+};
+
+export const validateHeaderSchema = joi.object( {
+  clientId: joi.string().required(),
+  city: joi.array().required(),
+  group: joi.array().required(),
+} );
+
+export const validateHeaderParams = {
+  body: validateHeaderSchema,
+};

package/src/routes/traffic.routes.js

@@ -1,4 +1,6 @@
 import express from 'express';
+import { validate, isAllowedSessionHandler, authorize } from 'tango-app-api-middleware';
+import * as validationDtos from '../dtos/validation.dtos.js';
 
 export const analysisTrafficRouter = express.Router();
 
@@ -6,6 +8,7 @@ import {
   welcome,
   cardsFunnel,
   cardsGraphs,
+  recapVideo,
   densityDwell,
   overallCards,
   overallHourlyChart,
@@ -17,21 +20,43 @@ import {
   footfallDirectory,
   summaryTable,
   footfallTrend,
-  recapVideo,
-  storesMap,
-  performanceMatrix,
   zoneDwellTimeSplit,
   storeOperation,
+  performanceMatrix,
+  storesMap,
   headerLocations,
   headerGroups,
   headerStores,
 } from '../controllers/tangoTraffic.controllers.js';
 
+import {
+  cardsFunnelV1,
+  cardsGraphsV1,
+  recapVideoV1,
+  densityDwellV1,
+  overallCardsV1,
+  overallHourlyChartV1,
+  overallChartV1,
+  singleStoreChartV1,
+  demographicChartV1,
+  buyerChartV1,
+  footfallDirectoryFoldersV1,
+  footfallDirectoryV1,
+  summaryTableV1,
+  footfallTrendV1,
+  storeOperationV1,
+  storesMapV1,
+  headerStoresV1,
+  headerLocationsV1,
+  headerGroupsV1,
+} from '../controllers/tangoTrafficV1.controllers.js';
+
 
 analysisTrafficRouter
     .get( '/welcome', welcome )
     .post( '/cardsFunnel', cardsFunnel )
     .post( '/cardsGraphs', cardsGraphs )
+    .post( '/recapVideo', recapVideo )
     .post( '/densityDwell', densityDwell )
     .post( '/overallCards', overallCards )
     .post( '/overallHourlyChart', overallHourlyChart )
@@ -43,13 +68,107 @@ analysisTrafficRouter
     .post( '/footfallDirectoryFolders', footfallDirectoryFolders )
     .post( '/summaryTable', summaryTable )
     .post( '/footfallTrend', footfallTrend )
-    .post( '/recapVideo', recapVideo )
-    .post( '/storesMap', storesMap )
-    .post( '/performanceMatrix', performanceMatrix )
     .post( '/zoneDwellTimeSplit', zoneDwellTimeSplit )
     .post( '/storeOperation', storeOperation )
+    .post( '/performanceMatrix', performanceMatrix )
+    .post( '/storesMap', storesMap )
     .post( '/headerLocations', headerLocations )
     .post( '/headerGroups', headerGroups )
-    .post( '/headerStores', headerStores );
+    .post( '/headerStores', headerStores )
+    .post( '/cardsFunnel_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateCardFunnelParams ), cardsFunnelV1 )
+    .post( '/cardsGraphs_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateCardGraphParams ), cardsGraphsV1 )
+    .post( '/recapVideo_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateRecapVideoParams ), recapVideoV1 )
+    .post( '/densityDwell_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateDensityDwellParams ), densityDwellV1 )
+    .post( '/overallCards_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateOverallCardsParams ), overallCardsV1 )
+    .post( '/overallHourlyChart_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateOverallHourlyChartParams ), overallHourlyChartV1 )
+    .post( '/overallChart_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateOverallCharParams ), overallChartV1 )
+    .post( '/singleStoreChart_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateSingleStoreChartParams ), singleStoreChartV1 )
+    .post( '/demographicChart_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateDemographicChartParams ), demographicChartV1 )
+    .post( '/buyerChart_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateBuyerChartParams ), buyerChartV1 )
+    .post( '/footfallDirectoryFolders_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateFootfallDirectoryFoldersParams ), footfallDirectoryFoldersV1 )
+    .post( '/footfallDirectory_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateFootfallDirectoryParams ), footfallDirectoryV1 )
+    .post( '/summaryTable_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateSummaryTableParams ), summaryTableV1 )
+    .post( '/footfallTrend_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateFootfallTrendParams ), footfallTrendV1 )
+    .post( '/storeOperation_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateStoreOperationParams ), storeOperationV1 )
+    .post( '/storesMap_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateStoresMapParams ), storesMapV1 )
+    .post( '/headerLocations_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateHeaderParams ), headerLocationsV1 )
+    .post( '/headerGroups_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateHeaderParams ), headerGroupsV1 )
+    .post( '/headerStores_v1', isAllowedSessionHandler, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateHeaderParams ), headerStoresV1 );
 
 export default analysisTrafficRouter;

package/src/services/clients.services.js

@@ -0,0 +1,23 @@
+import model from 'tango-api-schema';
+
+export const find = ( query = {}, record = {} ) => {
+  return model.clientModel.find( query, record );
+};
+
+export const findOne = ( query = {}, record = {} ) => {
+  return model.clientModel.findOne( query, record ).sort( { updatedAt: -1 } );
+};
+
+export const updateOne = ( query = {}, record = {} ) => {
+  return model.clientModel.updateOne( query, { $set: record } );
+};
+
+export const aggregate = ( query = [] ) => {
+  return model.clientModel.aggregate( query );
+};
+
+export const getClientCount = ( query = {} ) => {
+  return model.clientModel.count( query );
+};
+
+

package/src/services/group.service.js

@@ -0,0 +1,6 @@
+import groupModel from 'tango-api-schema/schema/group.model.js';
+
+export async function aggregateGroup( query ) {
+  return await groupModel.aggregate( query );
+};
+

package/src/services/userAssignedStore.service.js

@@ -0,0 +1,9 @@
+import userAssignedStoreModel from 'tango-api-schema/schema/userAssignedStore.model.js';
+
+export async function aggregateUserAssignedStore( query ) {
+  return await userAssignedStoreModel.aggregate( query );
+};
+
+export async function findOneUserAssignedStore( query, record ) {
+  return await userAssignedStoreModel.findOne( query, record );
+};

package/app.js

@@ -1,40 +0,0 @@
-import express from 'express';
-import { analysisTrafficRouter } from './index.js';
-
-import dotenv from 'dotenv';
-import pkg from 'body-parser';
-const { json, urlencoded } = pkg;
-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 cors from 'cors';
-
-const env=dotenv.config();
-
-const app = express();
-const PORT = process.env.PORT || 3000;
-app.use( cors() );
-
-
-if ( env.error ) {
-  logger.error( '.env not found' );
-  process.exit( 1 );
-}
-
-app.use( json( { limit: '500mb' } ) );
-app.use(
-    urlencoded( {
-      extended: true,
-    } ),
-);
-
-app.use( responseMiddleware );
-app.use( errorMiddleware );
-
-app.use( '/api', analysisTrafficRouter );
-
-app.listen( PORT, () => {
-  console.log( `server is running on port= ${PORT} ` );
-  connectdb();
-} );