tango-app-api-trax 3.0.2 → 3.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "3.0.2",
+    "version": "3.0.3",
     "description": "Trax",
     "main": "index.js",
     "type": "module",

package/src/controllers/gallery.controller.js

@@ -3,6 +3,7 @@
 import { logger } from 'tango-app-api-middleware';
 import * as storeService from '../services/store.service.js';
 import * as groupService from '../services/group.service.js';
+import * as clusterService from '../services/cluster.service.js';
 import * as processedchecklistconfigService from '../services/processedchecklistconfig.services.js';
 // import axios from 'axios';
 async function LamdaServiceCall( url, data ) {
@@ -29,7 +30,11 @@ async function LamdaServiceCall( url, data ) {
 export async function getchecklist( req, res ) {
   try {
     let url = JSON.parse( process.env.LAMBDAURL );
+    console.log( url.checklistQuestion );
+
     let resultData = await LamdaServiceCall( url.checklistQuestion, req.body );
+    console.log( resultData );
+
     if ( resultData ) {
       if ( resultData.status_code == '200' ) {
         return res.sendSuccess( resultData );
@@ -247,3 +252,274 @@ export const checklistDropdown = async ( req, res ) => {
     return res.sendError( { error: error }, 500 );
   }
 };
+
+export const headerStoresV2 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getUserEmail = req.user.email;
+    let getUserType = req.user.userType;
+    let getRole = req.user.role;
+    let getClientId = reqestData.clientId;
+    let totalStores = await getStoresList( getUserEmail, getClientId, getUserType, getRole, req );
+    console.log( totalStores.length );
+
+    if ( totalStores && totalStores.length>0 ) {
+      let storeQuery = [];
+      if ( reqestData.city.length>0 && reqestData.clusters.length>0 ) {
+        let unqueCityStores = await getLocationStores( getClientId, reqestData.city, req );
+        let unqueGroupStores = await getClusterStores( getClientId, reqestData.clusters );
+        storeQuery = [
+          {
+            $match: {
+              $and: [
+                { storeId: { $in: totalStores } },
+                { storeId: { $in: unqueCityStores } },
+                { storeId: { $in: unqueGroupStores } },
+              ],
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeId: '$storeId',
+              storeName: '$storeName',
+            },
+          },
+        ];
+      } else if ( reqestData.city.length>0 ) {
+        let uniqueCityStores = await getLocationStores( getClientId, reqestData.city, req );
+        storeQuery = [
+          {
+            $match: {
+              $and: [
+                { storeId: { $in: totalStores } },
+                { storeId: { $in: uniqueCityStores } },
+              ],
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeId: '$storeId',
+              storeName: '$storeName',
+            },
+          },
+        ];
+      } else if ( reqestData.clusters.length>0 ) {
+        let uniqueclusterStores = await getClusterStores( getClientId, reqestData.clusters );
+        storeQuery = [
+          {
+            $match: {
+              $and: [
+                { storeId: { $in: totalStores } },
+                { storeId: { $in: uniqueclusterStores } },
+              ],
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeId: '$storeId',
+              storeName: '$storeName',
+            },
+          },
+        ];
+      } else {
+        let totalStores = await getStoresList( getUserEmail, getClientId, getUserType, getRole, req );
+        storeQuery = [
+          {
+            $match: {
+              $and: [
+                { storeId: { $in: totalStores } },
+              ],
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeId: '$storeId',
+              storeName: '$storeName',
+            },
+          },
+        ];
+      }
+
+      const storeList = await storeService.aggregate( storeQuery );
+      if ( storeList && storeList.length > 0 ) {
+        return res.sendSuccess( { storesData: storeList } );
+      } else {
+        return res.sendError( 'No Stores', 400 );
+      }
+    } else {
+      return res.sendError( 'No Stores', 400 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'headerStoresV2' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+
+async function getStoresList( getUserEmail, getClientId, getUserType, getRole, req ) {
+  try {
+    if ( getUserEmail && getUserEmail !='' && getClientId && getClientId !='' && getUserType && getUserType !='' && getRole && getRole!='' ) {
+      let overAllStores = [];
+      if ( getUserType == 'tango' ) {
+        let getAllS = await getAssignedAllStores( getClientId );
+        if ( getAllS && getAllS.length >0 ) {
+          overAllStores = getAllS;
+        }
+        return overAllStores;
+      } else if ( getUserType == 'client' ) {
+        if ( getRole == 'superadmin' ) {
+          let getAllS = await getAssignedAllStores( getClientId );
+          if ( getAllS && getAllS.length >0 ) {
+            overAllStores = getAllS;
+          }
+          return overAllStores;
+        } else {
+          return req.body.assignedStores;
+        }
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'getAllStores' } );
+  }
+};
+
+
+async function getAssignedAllStores( userClientId ) {
+  try {
+    if ( userClientId && userClientId !='' ) {
+      let storeQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: userClientId } },
+            ],
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            stores: { $push: '$storeId' },
+          },
+        },
+      ];
+      const storeList = await storeService.aggregate( 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 ) {
+    logger.error( { error: error, message: data, function: 'getAssignedAllStores' } );
+    return false;
+  }
+}
+
+
+async function getClusterStores( userClientId, ClusterList ) {
+  try {
+    if ( userClientId && userClientId !='' && ClusterList && ClusterList.length >0 ) {
+      let ClusterQuery = [
+        {
+          $match: {
+            $and: [
+              { clientId: { $eq: userClientId } },
+              { clusterName: { $in: ClusterList } },
+            ],
+          },
+        },
+        {
+          $unwind: {
+            path: '$storeList', preserveNullAndEmptyArrays: true,
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            storesList: { $push: '$stores' },
+          },
+        },
+        {
+          $project: {
+            storesList: {
+              $reduce: {
+                input: '$storesList', // Merge arrays using $reduce
+                initialValue: [],
+                in: { $concatArrays: [ '$$value', '$$this' ] },
+              },
+            },
+          },
+        },
+      ];
+      const clusterStoreList = await clusterService.aggregateCluster( ClusterQuery );
+      if ( clusterStoreList && clusterStoreList.length>0 && clusterStoreList[0]?.storesList.length > 0 ) {
+        let storeIds = clusterStoreList[0].storesList.map( ( data ) => data.storeId );
+        let uniqueStores = [ ...new Set( storeIds ) ];
+        return uniqueStores;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'getClusterStores' } );
+    return false;
+  }
+}
+
+
+async function getLocationStores( userClientId, cityList, req ) {
+  try {
+    if ( userClientId && userClientId !='' && cityList && cityList.length >0 ) {
+      let filter = [
+        { clientId: { $eq: userClientId } },
+        { 'storeProfile.city': { $in: cityList } },
+      ];
+      if ( req.body.assignedStores&&req.body.assignedStores.length>0 ) {
+        filter.push( { storeId: { $in: req.body.assignedStores } } );
+      }
+
+      let storeQuery = [
+        {
+          $match: {
+            $and: filter,
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            storeId: '$storeId',
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            stores: { $push: '$storeId' },
+          },
+        },
+      ];
+      const cityStoreList = await storeService.aggregate( storeQuery );
+      if ( cityStoreList && cityStoreList.length>0 && cityStoreList[0]?.stores.length > 0 ) {
+        let uniqueStores = [ ...new Set( cityStoreList[0].stores ) ];
+        return uniqueStores;
+      } else {
+        return [];
+      }
+    } else {
+      return [];
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getLocationStores' } );
+    return false;
+  }
+}

package/src/dtos/validation.dtos.js

@@ -11,6 +11,15 @@ export const checklistSchema = joi.object( {
 export const checklistValidation = {
   body: checklistSchema,
 };
+export const validateHeaderSchemav2 = joi.object( {
+  clientId: joi.string().required(),
+  city: joi.array().required(),
+  clusters: joi.array().required(),
+} );
+export const validateHeaderParamsv2 = {
+  body: validateHeaderSchemav2,
+};
+
 
 export const checklistDetailsSchema = joi.object( {
   checkListId: joi.string().optional(),

package/src/routes/gallery.routes.js

@@ -1,10 +1,10 @@
 
 
-import { getchecklist, viewchecklist, getMobileUseagelist, storeOpencloselist, getcustomerunattendedlist, storesList, checklistDropdown } from '../controllers/gallery.controller.js';
+import { getchecklist, viewchecklist, getMobileUseagelist, storeOpencloselist, getcustomerunattendedlist, storesList, checklistDropdown, headerStoresV2 } from '../controllers/gallery.controller.js';
 import express from 'express';
 export const galleryRouter = express.Router();
-import { isAllowedSessionHandler } from 'tango-app-api-middleware';
-
+import { validate, isAllowedSessionHandler, isAllowedClient, getAssinedStore } from 'tango-app-api-middleware';
+import * as validationDtos from '../dtos/validation.dtos.js';
 galleryRouter
     .post( '/getchecklist', isAllowedSessionHandler, getchecklist );
 galleryRouter
@@ -19,3 +19,5 @@ galleryRouter
     .post( '/checklistDropdown', isAllowedSessionHandler, checklistDropdown );
 galleryRouter
     .post( '/getcustomerunattendedlist', isAllowedSessionHandler, getcustomerunattendedlist );
+galleryRouter
+    .post( '/headerStores_v2', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateHeaderParamsv2 ), getAssinedStore, headerStoresV2 );

package/src/services/cluster.service.js

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