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

package/src/controllers/tangoTrafficV1.controllers.js

@@ -1,10 +1,15 @@
-import { logger } from 'tango-app-api-middleware';
+import { logger, download, signedUrl } from 'tango-app-api-middleware';
 import * as clientService from '../services/clients.services.js';
 import {
   aggregateStore,
+  findOneStore,
 } from '../services/stores.service.js';
 import { aggregateUserAssignedStore, findOneUserAssignedStore } from '../services/userAssignedStore.service.js';
 import { aggregateGroup } from '../services/group.service.js';
+import dayjs from 'dayjs';
+import mongoose from 'mongoose';
+const ObjectId = mongoose.Types.ObjectId;
+import { findCamera } from '../services/camera.service.js';
 
 // Lamda Service Call //
 async function LamdaServiceCall( url, data ) {
@@ -24,8 +29,8 @@ async function LamdaServiceCall( url, data ) {
     const json = await response.json();
     return json;
   } catch ( error ) {
-    console.log( 'error =>', error );
     logger.error( { error: error, message: data, function: 'LamdaServiceCall' } );
+    return false;
   }
 }
 
@@ -99,6 +104,7 @@ export const recapVideoV1 = async ( req, res ) => {
 export const densityDwellV1 = async ( req, res ) => {
   try {
     let reqestData = req.body;
+    reqestData.hourFormat = 12;
     let LamdaURL = 'https://wh2d4dkgsao5kbwpjxbmchcjja0cxjhv.lambda-url.ap-south-1.on.aws/';
     let resultData = await LamdaServiceCall( LamdaURL, reqestData );
     if ( resultData ) {
@@ -119,6 +125,14 @@ export const densityDwellV1 = async ( req, res ) => {
 export const overallCardsV1 = async ( req, res ) => {
   try {
     let reqestData = req.body;
+    if ( reqestData.processType && reqestData.processType == 'missedOpportunity' ) {
+      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://dugu3ghkgalnpaydf2wdjp37240pzcmy.lambda-url.ap-south-1.on.aws/';
     let resultData = await LamdaServiceCall( LamdaURL, reqestData );
     if ( resultData ) {
@@ -139,6 +153,7 @@ export const overallCardsV1 = async ( req, res ) => {
 export const overallHourlyChartV1 = async ( req, res ) => {
   try {
     let reqestData = req.body;
+    reqestData.hourFormat = 12;
     let LamdaURL = 'https://p3xcs56mkjj4sfugvsibhyto3i0gdbda.lambda-url.ap-south-1.on.aws/';
     let resultData = await LamdaServiceCall( LamdaURL, reqestData );
     if ( resultData ) {
@@ -239,6 +254,7 @@ export const buyerChartV1 = async ( req, res ) => {
 export const footfallDirectoryFoldersV1 = async ( req, res ) => {
   try {
     let reqestData = req.body;
+    reqestData.hourFormat = 12;
     let LamdaURL = 'https://waxlhd7lfdlmyrkrdyv77najka0ayihq.lambda-url.ap-south-1.on.aws/';
     let resultData = await LamdaServiceCall( LamdaURL, reqestData );
     if ( resultData ) {
@@ -283,7 +299,39 @@ export const summaryTableV1 = async ( req, res ) => {
     let resultData = await LamdaServiceCall( LamdaURL, reqestData );
     if ( resultData ) {
       if ( resultData.status_code == '200' ) {
-        return res.sendSuccess( resultData );
+        if ( reqestData.export ) {
+          if ( resultData.summaryData.length>0 ) {
+            const exportdata = [];
+            resultData.summaryData.forEach( ( element ) => {
+              exportdata.push( {
+                'Store Name': element.storeName,
+                'Store Id': element.storeId,
+                'Footfall Count': element.footfallCount,
+                'Bounced Count': element.bouncedCount,
+                'Engagers Count': element.engagersCount,
+                'Conversion Rate': element.conversionRate,
+                'PotentialBuyers Count': element.potentialBuyersCount,
+                'MissedOpportunity Count': element.missedOpportunityCount,
+                'AVG Dwell Time': element.avgDwellTime,
+                'AVG InfraDown Time': element.avgInfraDowntime,
+                'Male': element.male,
+                'Female': element.female,
+                'below12': element.below12,
+                '13-19': element['13-19'],
+                '20-30': element['20-30'],
+                '31-40': element['31-40'],
+                '41-50': element['41-50'],
+                '51-60': element['51-60'],
+                '60 above': element['60 above'],
+              } );
+            } );
+            return await download( exportdata, res );
+          } else {
+            return res.sendError( 'No Content', 204 );
+          }
+        } else {
+          return res.sendSuccess( resultData );
+        }
       } else {
         return res.sendError( 'No Content', 204 );
       }
@@ -336,19 +384,59 @@ 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 zoneDwellTimeSplitV1 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let LamdaURL = 'https://7tfzazsi6lcejnjdzijv7bwg7y0yxhdx.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: 'trafficCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
 export const storesMapV1 = async ( req, res ) => {
   try {
     let reqestData = req.body;
     const storeList = [
       {
         $match: {
-          clientId: { $eq: '11' },
+          clientId: { $eq: reqestData.clientId },
           storeId: { $in: reqestData.storeId },
           $and: [
             { 'storeProfile.latitude': { $exists: true } },
             { 'storeProfile.latitude': { $gt: 0 } },
-            { 'storeProfile.latitude': { $exists: true } },
-            { 'storeProfile.latitude': { $gt: 0 } },
+            { 'storeProfile.longitude': { $exists: true } },
+            { 'storeProfile.longitude': { $gt: 0 } },
           ],
         },
       },
@@ -359,15 +447,17 @@ export const storesMapV1 = async ( req, res ) => {
           'storeName': 1,
           'appId': 1,
           'storeProfile': 1,
+          'lat': '$storeProfile.latitude',
+          'lng': '$storeProfile.longitude',
           'spocDetails': { $arrayElemAt: [ '$spocDetails', 0 ] },
           'businessType': 1,
           'storeType': 1,
-          'avgFootfall': '100',
-          'avgWeekdayFootfall': '30',
-          'avgWeekendFootfall': '60',
-          'hourlyFootfall': '60',
-          'openTime': '10:31 AM',
-          'closeTime': '10:31 PM',
+          'avgFootfall': '',
+          'avgWeekdayFootfall': '',
+          'avgWeekendFootfall': '',
+          'hourlyFootfall': '',
+          'openTime': '',
+          'closeTime': '',
         },
       },
       {
@@ -382,23 +472,14 @@ export const storesMapV1 = async ( req, res ) => {
     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 );
-      // }
+      if ( getStores.length >0 ) {
+        return res.sendSuccess( { storeData: getStores } );
+      } 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' } );
+    logger.error( { error: error, message: req.query, function: 'storesMapV1' } );
     return res.sendError( { error: error }, 500 );
   }
 };
@@ -407,13 +488,16 @@ export const headerLocationsV1 = 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 getAllStores( getUserEmail, getClientId );
+    let totalStores = await getAllStores( getUserEmail, getClientId, getUserType, getRole );
     if ( totalStores && totalStores.length>0 ) {
       let storeQuery = [
         {
           $match: {
             $and: [
+              { clientId: { $eq: getClientId } },
               { storeId: { $in: totalStores } },
             ],
           },
@@ -452,68 +536,75 @@ export const headerLocationsV1 = async ( req, res ) => {
 
 export const headerGroupsV1 = async ( req, res ) => {
   try {
-    // let requestData = req.body;
+    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,
+    let getUserType = req.user.userType;
+    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 );
+      if ( getGroupIds && getGroupIds.length>0 ) {
+        groupIds = getGroupIds;
+      } else {
+        groupIds = [];
+      }
+    } else {
+      if ( getUserType == 'tango' ) {
+        groupIds = await getGroupIds( requestData.clientId );
+      } else if ( getUserType == 'client' ) {
+        if ( getRole == 'superadmin' ) {
+          groupIds = await getGroupIds( requestData.clientId );
+        } else {
+          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 {
+        groupIds = [];
+      }
+    }
+
+    if ( groupIds && groupIds.length > 0 ) {
+      let groupQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: requestData.clientId } },
+              { _id: { $in: groupIds } },
+            ],
+          },
         },
-      },
-      {
-        $project: {
-          _id: 0,
-          groupName: '$groups.groupName',
+        {
+          $project: {
+            _id: 0,
+            groupName: 1,
+          },
         },
-      },
-    ];
-    const groupList = await aggregateUserAssignedStore( groupQuery );
-    if ( groupList && groupList.length > 0 ) {
-      return res.sendSuccess( { groupData: groupList } );
+      ];
+      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 ) {
-    logger.error( { error: error, message: req.query, function: 'trafficCards' } );
+    logger.error( { error: error, message: req.query, function: 'headerGroupsV1' } );
     return res.sendError( { error: error }, 500 );
   }
 };
@@ -522,8 +613,10 @@ export const headerStoresV1 = 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 getAllStores( getUserEmail, getClientId );
+    let totalStores = await getAllStores( getUserEmail, getClientId, getUserType, getRole );
     if ( totalStores && totalStores.length>0 ) {
       let storeQuery = [];
       if ( reqestData.city.length>0 && reqestData.group.length>0 ) {
@@ -586,7 +679,7 @@ export const headerStoresV1 = async ( req, res ) => {
           },
         ];
       } else {
-        let totalStores = await getAllStores( getUserEmail, getClientId );
+        let totalStores = await getAllStores( getUserEmail, getClientId, getUserType, getRole );
         storeQuery = [
           {
             $match: {
@@ -607,7 +700,7 @@ export const headerStoresV1 = async ( req, res ) => {
 
       const storeList = await aggregateStore( storeQuery );
       if ( storeList && storeList.length > 0 ) {
-        return res.sendSuccess( storeList );
+        return res.sendSuccess( { storesData: storeList } );
       } else {
         return res.sendError( 'No Stores', 400 );
       }
@@ -615,72 +708,70 @@ export const headerStoresV1 = async ( req, res ) => {
       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 ) {
+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;
+    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;
           }
-        } 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 {
+          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;
             }
-            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' } );
   }
 };
@@ -716,8 +807,8 @@ async function getAssignedStores( clientId, userEmail, assignedType ) {
       return false;
     }
   } catch ( error ) {
-    console.log( 'getAssignedStores error =>', error );
     logger.error( { error: error, message: data, function: 'getAssignedStores' } );
+    return false;
   }
 }
 
@@ -783,8 +874,8 @@ async function getAssignedGroupStores( clientId, userEmail, assignedType ) {
       return false;
     }
   } catch ( error ) {
-    console.log( 'getAssignedGroupStores error =>', error );
     logger.error( { error: error, message: data, function: 'getAssignedGroupStores' } );
+    return false;
   }
 }
 
@@ -818,8 +909,8 @@ async function getAssignedAllStores( userClientId ) {
       return false;
     }
   } catch ( error ) {
-    console.log( 'getAssignedAllStores error =>', error );
     logger.error( { error: error, message: data, function: 'getAssignedAllStores' } );
+    return false;
   }
 }
 
@@ -858,8 +949,8 @@ async function getGroupStores( userClientId, groupList ) {
       return false;
     }
   } catch ( error ) {
-    console.log( 'getGroupStores error =>', error );
     logger.error( { error: error, message: data, function: 'getGroupStores' } );
+    return false;
   }
 }
 
@@ -899,7 +990,390 @@ async function getLocationStores( userClientId, cityList ) {
       return false;
     }
   } catch ( error ) {
-    console.log( 'getLocationStores error =>', error );
     logger.error( { error: error, message: data, function: 'getLocationStores' } );
+    return false;
+  }
+}
+
+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 ) {
+    logger.error( { error: error, message: data, function: 'getGroupIds' } );
+    return false;
   }
 }
+
+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 ) {
+    logger.error( { error: error, message: data, function: 'getAssignedGroupIds' } );
+    return false;
+  }
+}
+
+async function getCityStores( userClientId, getUserEmail, getRole, requestCity, getUserType ) {
+  try {
+    if ( userClientId && userClientId !='' && getUserEmail && getUserEmail !='', getRole && getRole !='', requestCity && requestCity.length>0 ) {
+      let cityStores = await getLocationStores( userClientId, requestCity );
+      if ( cityStores && cityStores.length > 0 ) {
+        let storeGroups = await getGroupStoresIds( 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, message: data, function: 'getAssignedGroupIds' } );
+    return false;
+  }
+}
+
+async function getGroupStoresIds( userClientId, storeIds, getRole, getUserType, getUserEmail ) {
+  try {
+    if ( userClientId && userClientId !='' && storeIds && storeIds !='' && getRole && getRole !='' && getUserType && getUserType !='', getUserEmail && getUserEmail !='' ) {
+      let groupQuery = [];
+      if ( getUserType == 'client' ) {
+        if ( getRole == 'superadmin' ) {
+          groupQuery = [
+            {
+              $match: {
+                $and: [
+                  { clientId: { $eq: userClientId } },
+                  { storeList: { $in: storeIds } },
+                ],
+              },
+            },
+            {
+              $group: {
+                _id: null,
+                groupName: { $push: '$_id' },
+              },
+            },
+          ];
+        } else {
+          let getAssignedGroupIds = [
+            {
+              $match: {
+                $and: [
+                  { clientId: { $eq: userClientId } },
+                  { userEmail: { $eq: getUserEmail } },
+                ],
+              },
+            },
+            {
+              $group: {
+                _id: null,
+                groupName: { $push: '$assignedValue' },
+              },
+            },
+          ];
+          const assignedGroups = await aggregateUserAssignedStore( getAssignedGroupIds );
+          if ( assignedGroups && assignedGroups.length>0 && assignedGroups[0]?.groupName.length > 0 ) {
+            let uniqueGroups = [ ...new Set( assignedGroups[0].groupName ) ];
+            let uniqueGroupIds = [];
+            for ( let i = 0; i < uniqueGroups.length; i++ ) {
+              uniqueGroupIds.push( new ObjectId( uniqueGroups[i] ) );
+            }
+            groupQuery = [
+              {
+                $match: {
+                  $and: [
+                    { clientId: { $eq: userClientId } },
+                    { storeList: { $in: storeIds } },
+                    { _id: { $in: uniqueGroupIds } },
+                  ],
+                },
+              },
+              {
+                $group: {
+                  _id: null,
+                  groupName: { $push: '$_id' },
+                },
+              },
+            ];
+          }
+        }
+      } else if ( getUserType == 'tango' ) {
+        groupQuery = [
+          {
+            $match: {
+              $and: [
+                { clientId: { $eq: userClientId } },
+                { storeList: { $in: storeIds } },
+              ],
+            },
+          },
+          {
+            $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 ) {
+    logger.error( { error: error, message: data, function: 'getGroupIds' } );
+    return false;
+  }
+}
+
+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 );
+  }
+}
+
+export const getMySubscription = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getClientData = await clientService.findOne( { clientId: reqestData.clientId }, { planDetails: 1 } );
+    if ( getClientData ) {
+      if ( getClientData.planDetails && getClientData.planDetails.product && getClientData.planDetails.product.length>0 ) {
+        let clientSubscription = {};
+        let clientProducts = {
+          tangoTraffic: false,
+          tangoZone: false,
+          tangoTrax: false,
+        };
+        clientSubscription.subscriptionType = getClientData.planDetails.subscriptionType;
+        let actualProduct = getClientData.planDetails.product;
+        for ( let clientIndex = 0; clientIndex < actualProduct.length; clientIndex++ ) {
+          if ( actualProduct[clientIndex].productName == 'tangoTraffic' ) {
+            clientProducts.tangoTraffic = true;
+          }
+          if ( actualProduct[clientIndex].productName == 'tangoZone' ) {
+            clientProducts.tangoZone = true;
+          }
+          if ( actualProduct[clientIndex].tangoTrax == 'tangoTrax' ) {
+            clientProducts.tangoTrax = true;
+          }
+        }
+        clientSubscription.product = clientProducts;
+        let storeSubscription = {};
+        let storeProducts = {
+          tangoTraffic: false,
+          tangoZone: false,
+          tangoTrax: false,
+        };
+        if ( reqestData.storeId && reqestData.storeId.length>0 ) {
+          let getStoreData = await findOneStore( { clientId: reqestData.clientId, storeId: { $in: reqestData.storeId[0] } }, { product: 1 } );
+          if ( getStoreData ) {
+            for ( let storeIndex = 0; storeIndex < getStoreData.product.length; storeIndex++ ) {
+              if ( getStoreData.product[storeIndex] == 'tangoTraffic' ) {
+                storeProducts.tangoTraffic = true;
+              }
+              if ( getStoreData.product[storeIndex] == 'tangoZone' ) {
+                storeProducts.tangoZone = true;
+              }
+              if ( getStoreData.product[storeIndex] == 'tangoTrax' ) {
+                storeProducts.tangoTrax = true;
+              }
+            }
+            storeSubscription.product = storeProducts;
+          } else {
+            storeSubscription.product = [];
+          }
+        } else {
+          storeSubscription.product = [];
+        }
+        let resultData = { clientSubscription, storeSubscription };
+        return res.sendSuccess( resultData );
+      } else {
+        return res.sendError( 'Not Subscribe', 400 );
+      }
+    } else {
+      return res.sendError( 'Invalid Client Id', 400 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'getMySubscription' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const getStoreMapData = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    if ( reqestData.storeId && reqestData.storeId.length > 0 ) {
+      let cameraBaseImage = '';
+      const bucket= JSON.parse( process.env.BUCKET );
+      if ( bucket && bucket.baseImage && bucket.baseImage != '' ) {
+        const camera = await findCamera( { storeId: reqestData.storeId[0], isUp: true, isActivated: true }, { thumbnailImage: 1 } );
+        if ( camera && camera.thumbnailImage && camera.thumbnailImage != '' ) {
+          const params = {
+            file_path: camera.thumbnailImage,
+            Bucket: bucket.baseImage,
+          };
+          cameraBaseImage = await signedUrl( params );
+        }
+      }
+      reqestData.fromDate = reqestData.storeDate;
+      reqestData.toDate = reqestData.storeDate;
+      let avgData = {
+        'avgFootfall': '',
+        'avgWeekdayFootfall': '',
+        'avgWeekendFootfall': '',
+      };
+      let hourlyData = {
+        'hourlyFootfall': '',
+        'openTime': '',
+        'closeTime': '',
+      };
+      let hourlyLamdaURL = 'https://ksxkjnhwwzvrgp7ngttw2ribsy0twqip.lambda-url.ap-south-1.on.aws/';
+      let hourlyResultData = await LamdaServiceCall( hourlyLamdaURL, reqestData );
+      if ( hourlyResultData && hourlyResultData.hourData.length>0 ) {
+        hourlyData.hourlyFootfall = hourlyResultData.hourData[0].hourlyFootfall;
+        hourlyData.openTime = hourlyResultData.hourData[0].openTime;
+        hourlyData.closeTime = hourlyResultData.hourData[0].closeTime;
+      }
+      let fromDate = new Date( dayjs( reqestData.fromDate ).subtract( 30, 'days' ) );
+      reqestData.fromDate = dayjs( fromDate ).format( 'YYYY-MM-DD' );
+      let footfallLamdaURL = 'https://3ircml3r6dm7fbiif3ti2wwdee0zqhyb.lambda-url.ap-south-1.on.aws/';
+      let footfallResultData = await LamdaServiceCall( footfallLamdaURL, reqestData );
+      if ( footfallResultData && footfallResultData.avgData.length>0 ) {
+        avgData.avgFootfall = footfallResultData.avgData[0].avgFootfall;
+        avgData.avgWeekdayFootfall = footfallResultData.avgData[0].avgWeekdayFootfall;
+        avgData.avgWeekendFootfall = footfallResultData.avgData[0].avgWeekendFootfall;
+      }
+      return res.sendSuccess( { cameraBaseImage: cameraBaseImage, hourlyData: hourlyData, avgData: avgData } );
+    } else {
+      return res.sendError( 'Store Id rewuired', 400 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'getMySubscription' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+// async function getGeocodedAddress( lat, lng ) {
+//   try {
+//     const apiKey = 'AIzaSyDlOezgwQO0JviD0aizrCuN1FY9tcWfR3o'; // Use this if you're using dotenv
+//     const url = `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${apiKey}`;
+
+//     const requestOptions = {
+//       method: 'GET',
+//       headers: {
+//         'Content-Type': 'application/json',
+//       },
+//     };
+//     const response = await fetch( url, requestOptions );
+//     console.log( 'response =>', response );
+//     if ( !response.ok ) {
+//       throw new Error( `Response status: ${response.status}` );
+//       return false;
+//     }
+//     const json = await response.json();
+//     return json;
+//   } catch ( error ) {
+//     console.log( 'getGeocodedAddress error =>', error );
+//     logger.error( { error: error, message: data, function: 'getGeocodedAddress' } );
+//   }
+// }
+// let getGEO = await getGeocodedAddress( 12.900260100404893, 80.23384232089138 );
+//     console.log( 'getGEO =>', getGEO );