tango-app-api-analysis-traffic 3.0.0-alpha.4 → 3.0.0-alpha.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-analysis-traffic",
-    "version": "3.0.0-alpha.4",
+    "version": "3.0.0-alpha.6",
     "description": "Traffic Analysis",
     "main": "index.js",
     "type": "module",

package/src/controllers/tangoTraffic.controllers.js

@@ -1677,7 +1677,6 @@ export const footfallTrend = async ( req, res ) => {
   }
 };
 
-
 export const storesMap = async ( req, res ) => {
   try {
     let reqestData = req.body;
@@ -1752,11 +1751,27 @@ export const performanceMatrix = async ( req, res ) => {
     }
 
     let result = {
-      'downTime': 22,
-      'health': 'GOOD',
-      'recapVideoData': [
-        { 'thumbImage': 'https://123', 'videoURL': 'https://123' },
-        { 'thumbImage': 'https://123', 'videoURL': 'https://123' },
+      'performanceData': [
+        {
+          'storeId': '11-1',
+          'storeName': 'Lositon',
+          'avgFootfall': 50,
+          'avgOpenTime': '10:31 AM',
+          'avgCloseTime': '10:31 PM',
+          'top': '40%',
+          'left': '45%',
+          'position': 'High_High',
+        },
+        {
+          'storeId': '11-2',
+          'storeName': 'Lositon-1',
+          'avgFootfall': 50,
+          'avgOpenTime': '10:31 AM',
+          'avgCloseTime': '10:31 PM',
+          'top': '40%',
+          'left': '45%',
+          'position': 'High_Low',
+        },
       ],
     };
     return res.sendSuccess( result );

package/src/controllers/tangoTrafficV1.controllers.js

@@ -336,6 +336,26 @@ export const storeOperationV1 = async ( req, res ) => {
   }
 };
 
+export const performanceMatrixV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://5l3pjpivqpyboludmbridailpu0axrov.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: 'performanceMatrixV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
 export const storesMapV1 = async ( req, res ) => {
   try {
     let reqestData = req.body;
@@ -408,8 +428,9 @@ export const headerLocationsV1 = async ( req, res ) => {
     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 getAllStores( getUserEmail, getClientId, getUserType );
+    let totalStores = await getAllStores( getUserEmail, getClientId, getUserType, getRole );
     if ( totalStores && totalStores.length>0 ) {
       let storeQuery = [
         {
@@ -457,30 +478,33 @@ export const headerGroupsV1 = async ( req, res ) => {
     let requestData = req.body;
     let getUserEmail = req.user.email;
     let getUserType = req.user.userType;
-    const assignedQuery = {
-      clientId: requestData.clientId,
-      userEmail: getUserEmail,
-    };
+    let getRole = req.user.role;
     let groupIds;
-    const getAssignedType = await findOneUserAssignedStore( assignedQuery );
-    if ( getAssignedType ) {
-      if ( getAssignedType.userType == 'client' ) {
-        if ( getAssignedType.assignedType == 'allstores' ) {
-          groupIds = await getGroupIds( requestData.clientId );
-        } else if ( getAssignedType.assignedType == 'group' ) {
-          groupIds = await getAssignedGroupIds( requestData.clientId, getUserEmail );
-        }
-      } else if ( getAssignedType.userType == 'tango' ) {
+    if ( getUserType == 'tango' ) {
+      groupIds = await getGroupIds( requestData.clientId );
+    } else if ( getUserType == 'client' ) {
+      if ( getRole == 'superadmin' ) {
         groupIds = await getGroupIds( requestData.clientId );
       } else {
-        groupIds = [];
+        const assignedQuery = {
+          clientId: requestData.clientId,
+          userEmail: getUserEmail,
+        };
+        const getAssignedType = await findOneUserAssignedStore( assignedQuery );
+        if ( getAssignedType ) {
+          if ( getAssignedType.userType == 'client' ) {
+            if ( getAssignedType.assignedType == 'group' ) {
+              groupIds = await getAssignedGroupIds( requestData.clientId, getUserEmail );
+            }
+          } else {
+            groupIds = [];
+          }
+        } else {
+          groupIds = [];
+        }
       }
     } else {
-      if ( getUserType == 'tango' ) {
-        groupIds = await getGroupIds( requestData.clientId );
-      } else {
-        return res.sendError( 'No User Assign', 400 );
-      }
+      groupIds = [];
     }
 
     if ( groupIds && groupIds.length > 0 ) {
@@ -521,8 +545,9 @@ export const headerStoresV1 = async ( req, res ) => {
     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 getAllStores( getUserEmail, getClientId, getUserType );
+    let totalStores = await getAllStores( getUserEmail, getClientId, getUserType, getRole );
     if ( totalStores && totalStores.length>0 ) {
       let storeQuery = [];
       if ( reqestData.city.length>0 && reqestData.group.length>0 ) {
@@ -585,7 +610,7 @@ export const headerStoresV1 = async ( req, res ) => {
           },
         ];
       } else {
-        let totalStores = await getAllStores( getUserEmail, getClientId, getUserType );
+        let totalStores = await getAllStores( getUserEmail, getClientId, getUserType, getRole );
         storeQuery = [
           {
             $match: {
@@ -620,64 +645,59 @@ export const headerStoresV1 = async ( req, res ) => {
   }
 };
 
-async function getAllStores( getUserEmail, getClientId, getUserType ) {
+async function getAllStores( getUserEmail, getClientId, getUserType, getRole ) {
   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' ) {
-          let overAllStores = [];
-          let getAllS = await getAssignedAllStores( getClientId );
-          if ( getAllS && getAllS.length >0 ) {
-            overAllStores = getAllS;
-          }
-          return overAllStores;
-        } else {
-          return false;
+    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;
         }
-      } else {
-        if ( getUserType && getUserType == 'tango' ) {
-          let overAllStores = [];
+        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 false;
+          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;
+                  default:
+                    break;
+                }
+                return overAllStores;
+              } else {
+                return false;
+              }
+            } else {
+              return false;
+            }
+          } else {
+            return false;
+          }
         }
       }
     } else {
@@ -981,3 +1001,41 @@ async function getAssignedGroupIds( userClientId, getUserEmail ) {
     logger.error( { error: error, message: data, function: 'getAssignedGroupIds' } );
   }
 }
+
+export async function isAllowedClient( req, res, next ) {
+  try {
+    let reqestData = req.body;
+    let getUserEmail = req.user.email;
+    let getUserType = req.user.userType;
+    let getClientId = req.user.clientId;
+    let getRole = req.user.role;
+    if ( getUserType == 'tango' ) {
+      if ( getRole == 'superadmin' ) {
+        next();
+      } else {
+        const assignedQuery = {
+          userEmail: getUserEmail,
+          assignedType: 'client',
+          assignedValue: reqestData.clientId,
+        };
+        const getAssignedType = await findOneUserAssignedStore( assignedQuery );
+        if ( getAssignedType ) {
+          next();
+        } else {
+          return res.sendError( 'Client Not Assigned', 400 );
+        }
+      }
+    } else if ( getUserType == 'client' ) {
+      if ( getClientId == reqestData.clientId ) {
+        next();
+      } else {
+        return res.sendError( 'Client Not Assigned', 400 );
+      }
+    } else {
+      return res.sendError( 'Client Not Assigned', 400 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'isAllowedClient' } );
+    return res.sendError( error, 500 );
+  }
+}

package/src/controllers/tangoTrafficV2.controllers.js

@@ -0,0 +1,586 @@
+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';
+
+export const headerLocationsV2 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getUserEmail = req.user.email;
+    let getUserType = req.user.userType;
+    let getClientId = reqestData.clientId;
+    let totalStores = await getAllStores( getUserEmail, getClientId, getUserType );
+    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 ) {
+        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 headerGroupsV2 = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let getUserEmail = req.user.email;
+    let getUserType = req.user.userType;
+    const assignedQuery = {
+      clientId: requestData.clientId,
+      userEmail: getUserEmail,
+    };
+    let groupIds;
+    const getAssignedType = await findOneUserAssignedStore( assignedQuery );
+    if ( getAssignedType ) {
+      if ( getAssignedType.userType == 'client' ) {
+        if ( getAssignedType.assignedType == 'allstores' ) {
+          groupIds = await getGroupIds( requestData.clientId );
+        } else if ( getAssignedType.assignedType == 'group' ) {
+          groupIds = await getAssignedGroupIds( requestData.clientId, getUserEmail );
+        }
+      } else if ( getAssignedType.userType == 'tango' ) {
+        groupIds = await getGroupIds( requestData.clientId );
+      } else {
+        groupIds = [];
+      }
+    } else {
+      if ( getUserType == 'tango' ) {
+        groupIds = await getGroupIds( requestData.clientId );
+      } else {
+        return res.sendError( 'No User Assign', 400 );
+      }
+    }
+
+    if ( groupIds && groupIds.length > 0 ) {
+      let groupQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: requestData.clientId } },
+              { _id: { $in: groupIds } },
+            ],
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            groupName: 1,
+          },
+        },
+      ];
+      const groupResult = await aggregateGroup( groupQuery );
+      if ( groupResult && groupResult.length > 0 ) {
+        return res.sendSuccess( { groupData: groupResult } );
+      } else {
+        return res.sendError( 'No Group', 400 );
+      }
+    } else {
+      return res.sendError( 'No Group', 400 );
+    }
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'trafficCards' } );
+    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 getClientId = reqestData.clientId;
+    let totalStores = await getAllStores( getUserEmail, getClientId, getUserType );
+    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, getUserType );
+        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 ) {
+    console.log( 'headerStoresV1 =>', error );
+    logger.error( { error: error, message: req.query, function: 'headerStoresV1' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+async function getAllStores( getUserEmail, getClientId, getUserType ) {
+  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' ) {
+          let overAllStores = [];
+          let getAllS = await getAssignedAllStores( getClientId );
+          if ( getAllS && getAllS.length >0 ) {
+            overAllStores = getAllS;
+          }
+          return overAllStores;
+        } else {
+          return false;
+        }
+      } else {
+        if ( getUserType && getUserType == 'tango' ) {
+          let overAllStores = [];
+          let getAllS = await getAssignedAllStores( getClientId );
+          if ( getAllS && getAllS.length >0 ) {
+            overAllStores = getAllS;
+          }
+          return overAllStores;
+        } 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' } );
+  }
+}
+
+async function getGroupIds( userClientId ) {
+  try {
+    if ( userClientId && userClientId !='' ) {
+      let groupQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: userClientId } },
+            ],
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            groupName: { $push: '$_id' },
+          },
+        },
+      ];
+      const groupGroupIds = await aggregateGroup( groupQuery );
+      if ( groupGroupIds && groupGroupIds.length>0 && groupGroupIds[0]?.groupName.length > 0 ) {
+        let uniqueGroupIds = [ ...new Set( groupGroupIds[0].groupName ) ];
+        return uniqueGroupIds;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    console.log( 'getGroupIds error =>', error );
+    logger.error( { error: error, message: data, function: 'getGroupIds' } );
+  }
+}
+
+async function getAssignedGroupIds( userClientId, getUserEmail ) {
+  try {
+    if ( userClientId && userClientId !='' && getUserEmail && getUserEmail !='' ) {
+      let groupQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: userClientId } },
+              { userEmail: { $eq: getUserEmail } },
+              { assignedType: { $eq: 'group' } },
+            ],
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            groupName: { $push: '$assignedValue' },
+          },
+        },
+      ];
+      const groupStoreList = await aggregateUserAssignedStore( groupQuery );
+      if ( groupStoreList && groupStoreList.length>0 && groupStoreList[0]?.groupName.length > 0 ) {
+        let uniqueGroupIdsData = [ ...new Set( groupStoreList[0].groupName ) ];
+        let uniqueGroupIds = [];
+        for ( let i = 0; i < uniqueGroupIdsData.length; i++ ) {
+          uniqueGroupIds.push( new ObjectId( uniqueGroupIdsData[i] ) );
+        }
+        return uniqueGroupIds;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    console.log( 'getAssignedGroupIds error =>', error );
+    logger.error( { error: error, message: data, function: 'getAssignedGroupIds' } );
+  }
+}

package/src/dtos/validation.dtos.js

@@ -135,9 +135,9 @@ export const validateFootfallDirectoryParams = {
 export const validateSummaryTableSchema = joi.object( {
   ...baseSchema,
   valueType: joi.string().required(),
-  search: joi.string().optional(),
-  sortBy: joi.number().optional(),
-  sort: joi.string().optional(),
+  search: joi.string().optional().allow( '' ),
+  sortBy: joi.number().optional().allow( '' ),
+  sort: joi.string().optional().allow( '' ),
   limit: joi.number().required(),
   offset: joi.number().required(),
 } );
@@ -148,11 +148,14 @@ export const validateSummaryTableParams = {
 
 export const validateFootfallTrendSchema = joi.object( {
   ...baseSchema,
+  dateType: joi.string().required(),
   filterBy: joi.string().required(),
   processType: joi.string().required(),
   forecast: joi.boolean().optional(),
   limit: joi.number().required(),
   offset: joi.number().required(),
+  sortBy: joi.number().optional().allow( '' ),
+  sort: joi.string().optional().allow( '' ),
 } );
 
 export const validateFootfallTrendParams = {
@@ -177,6 +180,16 @@ export const validateStoresMapParams = {
   body: validateStoresMapSchema,
 };
 
+export const validateperformanceMatrixSchema = joi.object( {
+  ...baseSchema,
+  processtype1: joi.string().required(),
+  processtype2: joi.string().required(),
+} );
+
+export const validateperformanceMatrixParams = {
+  body: validateperformanceMatrixSchema,
+};
+
 export const validateHeaderSchema = joi.object( {
   clientId: joi.string().required(),
   city: joi.array().required(),

package/src/routes/traffic.routes.js

@@ -45,10 +45,12 @@ import {
   summaryTableV1,
   footfallTrendV1,
   storeOperationV1,
+  performanceMatrixV1,
   storesMapV1,
   headerStoresV1,
   headerLocationsV1,
   headerGroupsV1,
+  isAllowedClient,
 } from '../controllers/tangoTrafficV1.controllers.js';
 
 
@@ -75,97 +77,102 @@ analysisTrafficRouter
     .post( '/headerLocations', headerLocations )
     .post( '/headerGroups', headerGroups )
     .post( '/headerStores', headerStores )
-    .post( '/cardsFunnel_v1', isAllowedSessionHandler, authorize( {
+    .post( '/cardsFunnel_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateCardFunnelParams ), cardsFunnelV1 )
-    .post( '/cardsGraphs_v1', isAllowedSessionHandler, authorize( {
+    .post( '/cardsGraphs_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateCardGraphParams ), cardsGraphsV1 )
-    .post( '/recapVideo_v1', isAllowedSessionHandler, authorize( {
+    .post( '/recapVideo_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateRecapVideoParams ), recapVideoV1 )
-    .post( '/densityDwell_v1', isAllowedSessionHandler, authorize( {
+    .post( '/densityDwell_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateDensityDwellParams ), densityDwellV1 )
-    .post( '/overallCards_v1', isAllowedSessionHandler, authorize( {
+    .post( '/overallCards_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateOverallCardsParams ), overallCardsV1 )
-    .post( '/overallHourlyChart_v1', isAllowedSessionHandler, authorize( {
+    .post( '/overallHourlyChart_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateOverallHourlyChartParams ), overallHourlyChartV1 )
-    .post( '/overallChart_v1', isAllowedSessionHandler, authorize( {
+    .post( '/overallChart_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateOverallCharParams ), overallChartV1 )
-    .post( '/singleStoreChart_v1', isAllowedSessionHandler, authorize( {
+    .post( '/singleStoreChart_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateSingleStoreChartParams ), singleStoreChartV1 )
-    .post( '/demographicChart_v1', isAllowedSessionHandler, authorize( {
+    .post( '/demographicChart_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateDemographicChartParams ), demographicChartV1 )
-    .post( '/buyerChart_v1', isAllowedSessionHandler, authorize( {
+    .post( '/buyerChart_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateBuyerChartParams ), buyerChartV1 )
-    .post( '/footfallDirectoryFolders_v1', isAllowedSessionHandler, authorize( {
+    .post( '/footfallDirectoryFolders_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateFootfallDirectoryFoldersParams ), footfallDirectoryFoldersV1 )
-    .post( '/footfallDirectory_v1', isAllowedSessionHandler, authorize( {
+    .post( '/footfallDirectory_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateFootfallDirectoryParams ), footfallDirectoryV1 )
-    .post( '/summaryTable_v1', isAllowedSessionHandler, authorize( {
+    .post( '/summaryTable_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateSummaryTableParams ), summaryTableV1 )
-    .post( '/footfallTrend_v1', isAllowedSessionHandler, authorize( {
+    .post( '/footfallTrend_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateFootfallTrendParams ), footfallTrendV1 )
-    .post( '/storeOperation_v1', isAllowedSessionHandler, authorize( {
+    .post( '/storeOperation_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateStoreOperationParams ), storeOperationV1 )
-    .post( '/storesMap_v1', isAllowedSessionHandler, authorize( {
+    .post( '/performanceMatrix_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
+      userType: [ 'tango', 'client' ], access: [
+        { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
+      ],
+    } ), validate( validationDtos.validateperformanceMatrixParams ), performanceMatrixV1 )
+    .post( '/storesMap_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateStoresMapParams ), storesMapV1 )
-    .post( '/headerLocations_v1', isAllowedSessionHandler, authorize( {
+    .post( '/headerLocations_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateHeaderParams ), headerLocationsV1 )
-    .post( '/headerGroups_v1', isAllowedSessionHandler, authorize( {
+    .post( '/headerGroups_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],
     } ), validate( validationDtos.validateHeaderParams ), headerGroupsV1 )
-    .post( '/headerStores_v1', isAllowedSessionHandler, authorize( {
+    .post( '/headerStores_v1', isAllowedSessionHandler, isAllowedClient, authorize( {
       userType: [ 'tango', 'client' ], access: [
         { featureName: 'analytics', name: 'tangoTraffic', permissions: [ 'isView' ] },
       ],