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

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

@@ -6,12 +6,12 @@ const baseSchema = {
   storeId: joi.array().required().empty(),
   fromDate: joi.string().required(),
   toDate: joi.string().required(),
+  valueType: joi.string().optional().allow( '' ),
 };
 
 // Schema for Card Funnel
 export const validateCardFunnelSchema = joi.object( {
   ...baseSchema,
-  valueType: joi.string().required(),
 } );
 
 export const validateCardFunnelParams = {
@@ -21,7 +21,6 @@ export const validateCardFunnelParams = {
 // Schema for Card Graph (extends baseSchema with additional fields)
 export const validateCardGraphSchema = joi.object( {
   ...baseSchema,
-  valueType: joi.string().required(),
   dateType: joi.string().required(),
 } );
 
@@ -42,7 +41,6 @@ export const validateRecapVideoParams = {
 export const validateDensityDwellSchema = joi.object( {
   ...baseSchema,
   dateRange: joi.number().required(),
-  hourFormat: joi.number().required(),
 } );
 
 export const validateDensityDwellParams = {
@@ -61,7 +59,6 @@ export const validateOverallCardsParams = {
 
 export const validateOverallHourlyChartSchema = joi.object( {
   ...baseSchema,
-  hourFormat: joi.number().required(),
   processType: joi.string().required(),
 } );
 
@@ -135,11 +132,12 @@ 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(),
+  export: joi.boolean().required(),
 } );
 
 export const validateSummaryTableParams = {
@@ -148,11 +146,14 @@ export const validateSummaryTableParams = {
 
 export const validateFootfallTrendSchema = joi.object( {
   ...baseSchema,
+  dateType: joi.string().required(),
   filterBy: joi.string().required(),
-  processType: joi.string().required(),
+  processType: joi.string().optional().allow( '' ),
   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 +178,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(),
@@ -186,3 +197,22 @@ export const validateHeaderSchema = joi.object( {
 export const validateHeaderParams = {
   body: validateHeaderSchema,
 };
+
+export const getMyProductSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().optional().empty(),
+} );
+
+export const getMyProductParams = {
+  body: getMyProductSchema,
+};
+
+export const getStoreCameraImageSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().optional().empty(),
+  storeDate: joi.string().required(),
+} );
+
+export const getStoreCameraImageParams = {
+  body: getStoreCameraImageSchema,
+};