tango-app-api-trax 1.0.0-beta-task.19 → 1.0.0-beta-task.20

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "1.0.0-beta-task.19",
+    "version": "1.0.0-beta-task.20",
     "description": "Trax",
     "main": "index.js",
     "type": "module",

package/src/controllers/download.controller.js

@@ -45,7 +45,7 @@ export const downloadInsert = async ( req, res ) => {
 
     if ( requestData.sourceCheckList_id && requestData.sourceCheckList_id != '' ) {
       let getChecklistQuery = [];
-      getChecklistQuery.push( { $project: { sourceCheckList_id: 1, date_iso: 1, store_id: 1, checklistStatus: 1 } } );
+      getChecklistQuery.push( { $project: { sourceCheckList_id: 1, date_iso: 1, store_id: 1, checklistStatus: 1, redoStatus: 1 } } );
       getChecklistQuery.push( {
         $match: {
           $and: [

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 * as processedChecklist from '../services/processedchecklist.services.js';
 import * as checklistLogs from '../services/checklistlog.service.js';
@@ -35,7 +36,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 );
@@ -302,14 +307,14 @@ export async function approveChecklist( req, res ) {
 
 
         if ( searchResponse.ok ) {
-          return res.sendSuccess( 'Checklist Approved successfully' );
+          return res.sendSuccess( 'Checklist has been approved the submitted stores' );
         } else {
           return res.sendError( 'Something went wrong', 500 );
         }
       }
     } else {
-      let redoList = checklistDetails.filter( ( ele ) => ele.checklistStatus == 'open' ).map( ( item ) => item.storeName );
-      return res.sendError( `redo stores ${redoList.toString()}`, 400 );
+      let redoList = taskDetails.filter( ( ele ) => ele.checklistStatus == 'open' );
+      return res.sendError( `${redoList.length} stores has not been approved since those stores are not submitted`, 400 );
     }
   } catch ( e ) {
     logger.error( { function: 'approveChecklist', error: e } );
@@ -488,3 +493,274 @@ export async function approvalstatus( req, res ) {
     return res.sendError( 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/controllers/mobileTrax.controller.js

@@ -5,6 +5,7 @@ import * as PCLconfig from '../services/processedchecklistconfig.services.js';
 import * as processedTaskConfigService from '../services/processedTaskConfig.service.js';
 import * as storeService from '../services/store.service.js';
 import * as checklistService from '../services/checklist.service.js';
+import * as taskConfigService from '../services/taskConfig.service.js';
 import * as processedTask from '../services/processedTaskList.service.js';
 import * as checklistLogs from '../services/checklistlog.service.js';
 import { insertSingleProcessData } from './trax.controller.js';
@@ -23,6 +24,8 @@ import { join } from 'path';
 import handlebars from 'handlebars';
 dayjs.extend( customParseFormat );
 dayjs.extend( timeZone );
+import isSameOrBefore from 'dayjs/plugin/isSameOrBefore.js';
+dayjs.extend( isSameOrBefore );
 
 export async function storeList( req, res ) {
   try {
@@ -441,11 +444,19 @@ export async function sopMobilechecklistValidater( req, res, next ) {
 export async function sopMobilechecklistQuestionValidator( req, res, next ) {
   try {
     let requestData = req.body;
+
+    logger.error( { function: 'CheckEmptyQA', error: requestData } );
+
     requestData.questionAnswers = typeof requestData.questionAnswers == 'string' ? JSON.parse( requestData.questionAnswers ) : requestData.questionAnswers;
     let getChecklistQA = await processedchecklist.findOne( { _id: new ObjectId( requestData.processedcheckListId ) }, { questionAnswers: 1 } );
     if ( !getChecklistQA ) {
       return res.sendError( 'Check List Got Edited Please Fill Again', 422 );
     }
+
+    if ( !requestData.questionAnswers.length ) {
+      return res.sendError( 'Please Fill all Required Fields', 400 );
+    }
+
     if ( requestData.submittype == 'submit' ) {
       let reqAnswers = requestData.questionAnswers;
       let CLQAnswers = getChecklistQA.questionAnswers;
@@ -1343,7 +1354,7 @@ export async function submitTask( req, res ) {
           `v5 => Checklist Save => store Name: ${storeName}, User Email: ${userEmail}, Checklist Name: ${checkListName}`,
       );
       updateData.submitTime_string = currentDateTime.format( 'hh:mm A, DD MMM YYYY' );
-    } else {
+    } else if ( submittype === 'submit' ) {
       logger.info(
           `v5 => Checklist Submit => store Name: ${storeName}, User Email: ${userEmail}, Checklist Name: ${checkListName}`,
       );
@@ -1385,6 +1396,38 @@ export async function submitTask( req, res ) {
             await processedTask.deleteMany( { _id: { $in: deleteIds } } );
           }
         }
+      } else if ( submittype === 'draft' ) {
+        const query2 = [
+          {
+            $match: {
+              _id: checklist.sourceCheckList_id,
+            },
+          },
+        ];
+        const [ taskConfig ] = await taskConfigService.aggregate( query2 );
+
+        if ( taskConfig.scheduleEndTimeISO ) {
+          const endDate = dayjs( taskConfig.scheduleEndTimeISO ).utc();
+          const startDate = dayjs().add( 1, 'day' );
+
+          let currentDate = startDate;
+
+          while ( currentDate.isSameOrBefore( endDate ) ) {
+            const updateDate = currentDate.format( 'YYYY-MM-DD' );
+
+            const updateQuery = {
+              sourceCheckList_id: taskConfig._id,
+              date_string: updateDate,
+              userId: user._id,
+            };
+
+            if ( Object.values( updateQuery ).length === 3 ) {
+              await processedTask.updateOne( updateQuery, { questionAnswers, checklistStatus: 'inprogress' } );
+            }
+
+            currentDate = currentDate.add( 1, 'day' );
+          }
+        }
       }
       const logInsertData = {
         // eslint-disable-next-line camelcase

package/src/controllers/traxDashboard.controllers.js

@@ -332,6 +332,38 @@ export const checklistPerformance = async ( req, res ) => {
         timeFlag: { $sum: '$timeFlag' },
         questionFlagCount: { $sum: '$questionFlag' },
         checkListType: { $last: '$checkListType' },
+        redo: { $sum: { $cond: [ { $eq: [ '$redoStatus', true ] }, 1, 0 ] } },
+        task: {
+          $sum: {
+            $reduce: {
+              input: '$questionAnswers',
+              initialValue: 0,
+              in: {
+                $add: [
+                  '$$value',
+                  {
+                    $reduce: {
+                      input: { $ifNull: [ '$$this.questions', [] ] },
+                      initialValue: 0,
+                      in: {
+                        $add: [
+                          '$$value',
+                          {
+                            $cond: [
+                              { $ifNull: [ '$$this.taskId', false ] },
+                              1,
+                              0,
+                            ],
+                          },
+                        ],
+                      },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        },
       },
     } );
     findQuery.push( {
@@ -350,6 +382,8 @@ export const checklistPerformance = async ( req, res ) => {
         submittedChecklist: 1,
         flaggedChecklist: { $add: [ '$timeFlag', '$questionFlagCount' ] },
         checkListType: 1,
+        redo: 1,
+        task: 1,
       },
     } );
 
@@ -381,11 +415,13 @@ export const checklistPerformance = async ( req, res ) => {
       const exportdata = [];
       getChecklistPerformanceData[0].data.forEach( ( element ) => {
         exportdata.push( {
-          'Checklist Name': element.checkListName,
-          'Scheduled': element.scheduleRepeatedType,
-          'Assigned To': element.storeCount,
-          'Submitted': element.submittedChecklist,
-          'Flags': element.flaggedChecklist,
+          'Checklist Name': element.checkListName || '--',
+          'Scheduled': element.scheduleRepeatedType || '--',
+          'Assigned To': element.storeCount || '--',
+          'Submitted': element.submittedChecklist || '--',
+          'Flags': element.flaggedChecklist || '--',
+          'Tasks': element.task || '--',
+          'ReDo': element.redo || '--',
         } );
       } );
       return await download( exportdata, res );
@@ -1138,7 +1174,11 @@ export const checklistInfo = async ( req, res ) => {
     );
 
     if ( requestData.checklistStatus && requestData.checklistStatus != 'All' ) {
-      findAndQuery.push( { checklistStatus: requestData.checklistStatus } );
+      if ( requestData.checklistStatus == 'redo' ) {
+        findAndQuery.push( { redoStatus: true } );
+      } else {
+        findAndQuery.push( { checklistStatus: requestData.checklistStatus } );
+      }
     }
 
     if ( requestData.groupByType == 'Checklist' ) {

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, redoChecklist, approveChecklist, approvalstatus, getLogs } from '../controllers/gallery.controller.js';
+import { getchecklist, viewchecklist, getMobileUseagelist, storeOpencloselist, getcustomerunattendedlist, storesList, checklistDropdown, redoChecklist, approveChecklist, approvalstatus, getLogs, 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
@@ -26,3 +26,5 @@ galleryRouter
     .post( '/redo', isAllowedSessionHandler, redoChecklist )
     .post( '/approvalstatus', isAllowedSessionHandler, approvalstatus )
     .post( '/getLogs', isAllowedSessionHandler, getLogs );
+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 );
+};