tango-app-api-trax 3.3.1-beta-8 → 3.3.1-beta-10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "3.3.1-beta-8",
+    "version": "3.3.1-beta-10",
     "description": "Trax",
     "main": "index.js",
     "type": "module",
@@ -26,7 +26,7 @@
         "mongodb": "^6.8.0",
         "nodemon": "^3.1.4",
         "path": "^0.12.7",
-        "tango-api-schema": "^2.2.35",
+        "tango-api-schema": "^2.2.41",
         "tango-app-api-middleware": "^3.1.50",
         "url": "^0.11.4",
         "winston": "^3.13.1",

package/src/controllers/gallery.controller.js

@@ -354,14 +354,14 @@ export async function redoChecklist( req, res ) {
       return res.sendError( 'section is not found', 400 );
     }
 
-    let findQuestion = question[sectionIndex].questions.findIndex( ( ele ) => ele.qno == req.body.payload.qno );
+    let findQuestion = question[sectionIndex].questions.findIndex( ( ele ) => ele?.parentQuestion ? ele.qno == req.body.payload.qno && ele.parentQuestion == req.body.payload.parentQuestion : ele.qno == req.body.payload.qno );
 
     let data = { ...question[sectionIndex].questions[findQuestion], redo: true, redoComment: req.body.payload?.checklistDescription || '' };
     // if ( checklistDetails.client_id == '458' ) {
     data.answers.forEach( ( item ) => {
       if ( item.showLinked ) {
         item.nestedQuestion.forEach( ( ele ) => {
-          let eleIndex = question[sectionIndex].questions.findIndex( ( qn ) => qn.qno == parseInt( ele ) );
+          let eleIndex = question[sectionIndex].questions.findIndex( ( qn ) => qn?.parentQuestion ? qn.qno == parseInt( ele ) && qn?.parentQuestion == req.body.payload?.parentQuestion : qn.qno == parseInt( ele ) );
           let element = { ...question[sectionIndex].questions[eleIndex], redo: true, redoComment: '', linkquestionenabled: false };
           question[sectionIndex].questions[eleIndex] = element;
           question[sectionIndex].questions[eleIndex].userAnswer = [];

package/src/controllers/mobileTrax.controller.js

@@ -149,7 +149,7 @@ export async function startChecklist( req, res ) {
     }
 
     let updateData = {};
-    let storeTimeZone = await storeService.findOne( { storeName: getBeforeChecklist[0].storeName }, { 'storeProfile.timeZone': 1 } );
+    let storeTimeZone = await storeService.findOne( { storeName: { $regex: getBeforeChecklist[0].storeName, $options: 'i' }, clientId: getBeforeChecklist[0].client_id }, { 'storeProfile.timeZone': 1 } );
     let currentDateTime;
     if ( storeTimeZone?.storeProfile?.timeZone ) {
       currentDateTime = dayjs().tz( storeTimeZone?.storeProfile?.timeZone );
@@ -244,6 +244,7 @@ export async function startChecklist( req, res ) {
           questions = [];
           for ( let question of section.questions ) {
             if ( !question.linkType ) {
+              question.parentQuestion = question.qno;
               questions.push( question );
               let linkedAnswer = new Set( question.answers.filter( ( ele ) => ele.showLinked ).flatMap( ( ele ) => ele.nestedQuestion ) );
               let linkedQuestion = section.questions.filter( ( qn ) => linkedAnswer.has( qn.qno ) );
@@ -1725,12 +1726,12 @@ export async function submitChecklist( req, res ) {
       updateQuery._id = new ObjectId( requestData.processedcheckListId );
       updateQuery.userId = req.user._id;
       updateQuery.date_string = requestData.date;
-      let storeTimeZone = await storeService.findOne( { storeName: getchecklist[0].storeName }, { 'storeProfile.timeZone': 1 } );
+      let storeTimeZone = await storeService.findOne( { storeName: { $regex: getchecklist[0].storeName, $options: 'i' }, clientId: getchecklist[0].client_id }, { 'storeProfile.timeZone': 1 } );
       let currentDateTime;
       if ( storeTimeZone?.storeProfile?.timeZone ) {
         currentDateTime = dayjs().tz( storeTimeZone?.storeProfile?.timeZone );
       } else {
-        currentDateTime = dayjs();
+        currentDateTime = requestData?.currentTime ? dayjs( requestData.currentTime, 'HH:mm:ss' ) : dayjs();
       }
       let updateData = {};
       let flagCount = QuestionFlag( req, res );
@@ -2605,6 +2606,7 @@ export async function questionList( req, res ) {
           questions = [];
           for ( let question of section.questions ) {
             if ( !question.linkType ) {
+              question.parentQuestion = question.qno;
               questions.push( question );
               let linkedAnswer = new Set( question.answers.filter( ( ele ) => ele.showLinked ).flatMap( ( ele ) => ele.nestedQuestion ) );
               let linkedQuestion = section.questions.filter( ( qn ) => qn?.parentQuestion ? qn?.parentQuestion == question.qno && linkedAnswer.has( qn.qno ) : linkedAnswer.has( qn.qno ) );

package/src/controllers/teaxFlag.controller.js

@@ -564,7 +564,10 @@ export const flagCardsV1 = async ( req, res ) => {
       {
         $match: {
           client_id: clientId,
-          store_id: { $in: storeId },
+          $or: [
+            { store_id: { $in: storeId } },
+            { aiStoreList: { $in: storeId } },
+          ],
           date_iso: { $gte: adjustedFromDate, $lte: adjustedToDate },
         },
       },
@@ -634,7 +637,7 @@ export const flagCardsV1 = async ( req, res ) => {
           flagCards.detectionFlag.count += resultData[item];
         }
       } );
-      flagCards.totalFlag = flagCards.detectionFlag.count;
+      flagCards.totalFlag += flagCards.detectionFlag.count;
     }
 
     return res.sendSuccess( { flagCards } );
@@ -697,7 +700,12 @@ export const flagComparisonCardsV1 = async ( req, res ) => {
     }
 
     const createFindQuery = ( fromDate, toDate ) => [
-      { $match: { client_id: requestData.clientId, store_id: { $in: requestData.storeId }, date_iso: { $gte: fromDate, $lte: toDate } } },
+      { $match: { client_id: requestData.clientId,
+        $or: [
+          { store_id: { $in: requestData.storeId } },
+          { aiStoreList: { $in: requestData.storeId } },
+        ],
+        date_iso: { $gte: fromDate, $lte: toDate } } },
       {
         $project: {
           timeFlag: 1,

package/src/controllers/trax.controller.js

@@ -859,11 +859,11 @@ export const assignedUserDetails = async ( req, res ) => {
     if ( !req.params.checklistId ) {
       return res.sendError( { message: 'checklist Id is required' }, 400 );
     }
-    let limit = parseInt( req.query.limit ) || 10;
+    let limit = parseInt( req.query.limit ) || 5;
     let page = parseInt( req.query.offset ) || 0;
     let skip = limit * page;
 
-    let query = [ { $match: { checkListId: new ObjectId( req.params.checklistId ) } } ];
+    let query = [ { $match: { checkListId: new ObjectId( req.params.checklistId ), coverage: req.body.coverage } } ];
     if ( req.query.search.trim() && req.query.search.trim() != '' ) {
       let searchValue = req.query.search;
       searchValue = searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
@@ -875,37 +875,81 @@ export const assignedUserDetails = async ( req, res ) => {
       }
     }
 
-    query.push( {
-      $facet: {
-        data: [
-          { $skip: skip }, { $limit: limit },
-        ],
-        count: [
-          { $count: 'total' },
-        ],
-      },
-    } );
+    query.push( { $sort: { _id: -1 } } );
 
     let checklistDetails = await assignedService.aggregate( query );
-
-    if ( !checklistDetails[0].data.length ) {
+    if ( !checklistDetails.length ) {
       return res.sendError( 'no data found', 204 );
     }
 
     let userDetails = [];
-    checklistDetails[0].data.forEach( ( item ) => {
-      userDetails.push( {
-        id: item._id,
-        userName: item.userName,
-        userEmail: item.userEmail,
-        store_id: item.store_id,
-        storeName: item.storeName,
-        userPhone: item.userPhone,
-        city: item.city,
-        checkFlag: item.checkFlag,
-      } );
-    } );
-    return res.sendSuccess( { users: userDetails, count: checklistDetails[0].count[0].total } );
+    let storeList = [];
+    let userList = [];
+    await Promise.all( checklistDetails.map( async ( ele ) => {
+      if ( ele?.store_id || ele?.clusterName ) {
+        storeList.push( ele.assignId );
+      } else {
+        userList.push( ele.assignId );
+      }
+
+      if ( ele?.clusterName ) {
+        let clusterDetails = await clusterServices.findOneCluster( { _id: ele.assignId }, { stores: 1 } );
+        if ( clusterDetails ) {
+          let storeDetails = await storeService.find( { _id: { $in: clusterDetails.stores.map( ( item ) => item.store ) } } );
+          storeDetails.forEach( ( item ) => {
+            userDetails.push( {
+              id: ele._id,
+              userName: item.spocDetails?.[0]?.name,
+              userEmail: item.spocDetails[0].email,
+              store_id: item?.storeId,
+              storeName: item?.storeName,
+              userPhone: item.spocDetails?.[0]?.phone,
+              city: ele?.city,
+              checkFlag: ele.checkFlag,
+              clusterName: ele?.clusterName || '',
+              teamName: ele?.teamName || '',
+            } );
+          } );
+        }
+      } else if ( ele?.teamName ) {
+        let teamDetails = await teamsServices.findOneTeams( { _id: ele.assignId }, { users: 1, teamName: 1 } );
+        if ( teamDetails ) {
+          let teamUserDetails = await userService.find( { _id: { $in: teamDetails.users.map( ( item ) => item.userId ) } } );
+          teamUserDetails.forEach( ( item ) => {
+            userDetails.push( {
+              id: ele._id,
+              userName: item.userName,
+              userEmail: item.email,
+              store_id: ele?.storeId,
+              storeName: ele?.storeName,
+              userPhone: item?.mobileNumber,
+              city: ele?.city,
+              checkFlag: ele.checkFlag,
+              clusterName: ele?.clusterName || '',
+              teamName: ele?.teamName || '',
+            } );
+          } );
+        }
+      } else {
+        userDetails.push( {
+          id: ele._id,
+          userName: ele.userName,
+          userEmail: ele.userEmail,
+          store_id: ele?.store_id,
+          storeName: ele?.storeName,
+          userPhone: ele.userPhone,
+          city: ele.city,
+          checkFlag: ele.checkFlag,
+          clusterName: ele?.clusterName || '',
+          teamName: ele?.teamName || '',
+        } );
+      }
+    } ) );
+
+    userDetails.sort( ( a, b ) => b.teamName - a.teamName );
+    console.log( userDetails );
+    let limitedData = userDetails.slice( skip, limit + skip );
+    return res.sendSuccess( { count: userDetails.length, storeList, userList, users: limitedData } );
   } catch ( e ) {
     logger.error( 'assignedUserDetails =>', e );
     return res.sendError( e, 500 );
@@ -1252,6 +1296,226 @@ export const updateConfigure =async ( req, res ) => {
   }
 };
 
+export const updateConfigurev1 =async ( req, res ) => {
+  try {
+    let inputBody = req.body;
+    let id;
+    let checklistDetails;
+    if ( !inputBody.checkListDetails._id ) {
+      return res.sendError( 'checkListId is Required', 400 );
+    }
+
+    if ( inputBody.checkListDetails.checkListType == 'mobileusagedetection' && inputBody.submitType == 'publish' ) {
+      if ( !inputBody?.checkListDetails?.alert?.usageExceeds ) {
+        return res.sendError( 'Please Enter usage exceeds', 400 );
+      }
+
+      if ( !inputBody?.checkListDetails?.alert?.alertsTo.length ) {
+        return res.sendError( 'Please select users to send alert', 400 );
+      }
+
+      if ( !inputBody?.checkListDetails?.detectionArea.length ) {
+        return res.sendError( 'Please select detection area', 400 );
+      }
+    }
+
+    if ( !inputBody.checkListDetails.assignedUsers.length && inputBody.submitType == 'publish' ) {
+      return res.sendError( 'Please Assigned a user', 400 );
+    }
+
+    if ( !inputBody?.checkListDetails?.approver.length && inputBody.submitType == 'publish' ) {
+      return res.sendError( 'Please assign approver', 400 );
+    }
+
+
+    let logInsertData = {
+      action: inputBody.submitType == 'publish' ? 'checklistPublishUsingConfigPage' : 'checklistConfigDraft',
+      checklistId: inputBody.checkListDetails._id,
+      checkListName: inputBody?.checkListDetails.checkListName,
+      createdBy: req.user._id,
+      createdByName: req.user.userName,
+      client_id: req.body.clientId,
+      createdByEmail: req.user.email,
+      approver: inputBody?.checkListDetails?.approver || [],
+    };
+    await checklistLogs.create( logInsertData );
+
+    checklistDetails = await checklistService.findOne( { _id: inputBody.checkListDetails._id, type: 'checklist', isdeleted: false } );
+
+    if ( [ 'mobileusagedetection', 'storeopenandclose', 'uniformdetection' ].includes( inputBody.checkListDetails.checkListType ) && inputBody.uploadUser ) {
+      checklistDetails = await checklistService.findOne( { _id: inputBody.checkListDetails._id, type: 'checklist' } );
+    }
+
+    if ( !checklistDetails ) {
+      return res.sendError( 'no data found', 204 );
+    }
+
+    let currentDate = dayjs.utc().format();
+    let updatedscheduleEndTimeISO = dayjs.utc( inputBody?.checkListDetails?.scheduleEndTime, 'hh:mm A' ).format( 'HH:mm:ss' );
+    let newUpdatedDate = dayjs.utc( updatedscheduleEndTimeISO, 'HH:mm:ss' ).format();
+
+    if ( inputBody.submitType == 'publish' && inputBody?.showEdit && typeof inputBody?.editSubmit == 'undefined' && newUpdatedDate > currentDate ) {
+      let checkSubmitDetails = await processedchecklist.findOne( { sourceCheckList_id: inputBody.checkListDetails._id, date_string: dayjs().format( 'YYYY-MM-DD' ), checklistStatus: 'submit' } );
+      if ( checkSubmitDetails ) {
+        return res.sendError( 'Checklist got submitted', 400 );
+      }
+    }
+
+    if ( checklistDetails?.publishDate && inputBody.submitType == 'publish' ) {
+      let date = dayjs();
+      let diff = date.diff( dayjs.utc( checklistDetails?.publishDate ), 'minutes' );
+      if ( diff < 5 ) {
+        let mins = ( 5 - diff ) > 1 ? 'minutes' : 'minute';
+        return res.sendError( `Please try after ${5 - diff} ${mins}`, 400 );
+      }
+    }
+
+    if ( inputBody?.checkListDetails?.scheduleRepeatedMonthSetup == 'date' ) {
+      inputBody.checkListDetails.scheduleRepeatedDay = inputBody?.checkListDetails?.scheduleRepeatedDay;
+    }
+
+    if ( inputBody?.checkListDetails?.scheduleDate ) {
+      inputBody.checkListDetails.scheduleDate = new Date( inputBody?.checkListDetails?.scheduleDate );
+    }
+    let configDetails = {
+      ...inputBody?.checkListDetails,
+      publishDate: inputBody.checkListDetails.publish ? new Date() : '',
+      scheduleStartTimeISO: dayjs.utc( inputBody?.checkListDetails?.scheduleStartTime, 'hh:mm A' ).format(),
+      scheduleEndTimeISO: dayjs.utc( inputBody?.checkListDetails?.scheduleEndTime, 'hh:mm A' ).format(),
+      scheduleDate: inputBody?.checkListDetails?.scheduleDate ? dayjs( inputBody.checkListDetails.scheduleDate ).format() : '',
+      approver: inputBody?.checkListDetails?.approver.length ? inputBody?.checkListDetails?.approver.map( ( item ) => {
+        return { name: item.name, value: item.value };
+      } ) : [],
+    };
+
+    if ( inputBody?.checkListDetails?.approver.length ) {
+      let data = [];
+      let existEmail = await traxApprover.find( { checkListId: inputBody.checkListDetails._id, isDeleted: false } );
+      let mailList = existEmail.map( ( item ) => item.userEmail );
+      existEmail = inputBody?.checkListDetails?.approver.filter( ( item ) => mailList.includes( item.value ) ).map( ( item ) => item.value );
+      let userMailList = inputBody?.checkListDetails?.approver.map( ( ele ) => ele.value );
+      inputBody?.checkListDetails?.approver.forEach( ( ele ) => {
+        if ( !existEmail.includes( ele.value ) ) {
+          data.push( {
+            userEmail: ele.value,
+            checkListId: inputBody.checkListDetails._id,
+            type: 'checklist',
+            checkListName: inputBody?.checkListDetails.checkListName,
+            client_id: inputBody?.clientId,
+          } );
+        }
+      } );
+
+      await traxApprover.updateMany( { checkListId: inputBody.checkListDetails._id, userEmail: { $nin: userMailList } }, { isDeleted: true } );
+      if ( data.length ) {
+        await traxApprover.insertMany( data );
+      }
+    }
+
+    if ( checklistDetails.checkListType != 'custom' && !checklistDetails.client_id ) {
+      let getchecklistNumber = await checklistService.findOne( { client_id: req.body.clientId, type: 'checklist' }, { checkListNumber: 1 } );
+      let name = checklistDetails.checkListName.split( '(' )[0];
+      let checkListNameDetails = await checklistService.find( { checkListName: { $regex: name }, client_id: req.body.clientId, type: 'checklist', isdeleted: false } );
+      if ( checkListNameDetails.length ) {
+        let nameLength = ( checkListNameDetails.length-1 ) + 1;
+        checklistDetails.checkListName = checklistDetails.checkListName.split( '(' )[0] + '(' + nameLength + ')';
+      } else {
+        checklistDetails.checkListName = checklistDetails.checkListName;
+      }
+      configDetails.type = 'checklist';
+      configDetails.checkListName = checklistDetails.checkListName;
+      configDetails.checkListDescription = checklistDetails.checkListDescription;
+      if ( getchecklistNumber ) {
+        configDetails.checkListNumber = getchecklistNumber.checkListNumber + 1;
+      } else {
+        configDetails.checkListNumber = 1;
+      }
+      configDetails.createdBy= req.user._id;
+      configDetails.createdByName=req.user.userName;
+      delete inputBody.checkListDetails['_id'];
+      if ( [ 'storeopenandclose', 'uniformdetection' ].includes( checklistDetails.checkListType ) ) {
+        let query = { client_id: req.body.clientId, type: 'checklist', isdeleted: false };
+        if ( checklistDetails.checkListType == 'storeopenandclose' ) {
+          query.checkListType= 'storeopenandclose';
+        } else {
+          query.checkListType= 'uniformdetection';
+        }
+        let storeChecklisDetails = await checklistService.findOne( query );
+        if ( storeChecklisDetails ) {
+          inputBody.checkListDetails._id = storeChecklisDetails._id;
+        }
+      }
+    }
+    let query = {
+      client_id: req.body.clientId,
+      checkListType: checklistDetails.checkListType,
+      _id: inputBody.checkListDetails._id,
+    };
+    let response;
+    if ( inputBody.checkListDetails._id ) {
+      if ( [ 'mobileusagedetection', 'storeopenandclose', 'uniformdetection' ].includes( inputBody.checkListDetails.checkListType ) && inputBody.uploadUser ) {
+        configDetails.isdeleted = false;
+      }
+      id = inputBody.checkListDetails._id;
+      response = await checklistService.updateOne( query, configDetails );
+    } else {
+      configDetails.client_id = req.body.clientId;
+      configDetails.checkListType = checklistDetails.checkListType;
+      response = await checklistService.create( configDetails );
+      id = response._id;
+    }
+    // if ( inputBody.checkListDetails.assignedUsers.length ) {
+    //   await assignedService.deleteMany( { checkListId: inputBody.checkListDetails._id } );
+    //   await Promise.all( inputBody.checkListDetails.assignedUsers.map( async ( user ) => {
+    //     let data = {
+    //       ...user,
+    //       clientId: req.body.clientId,
+    //       checkListName: checklistDetails.checkListName,
+    //       checklistId: checklistDetails._id,
+    //     };
+    //     await assignUsers( data );
+    //   } ) );
+    // }
+    if ( inputBody.submitType == 'publish' ) {
+      if ( inputBody.checkListDetails.checkListType == 'custom' ) {
+        let currentDate = dayjs.utc().format();
+        let updatedscheduleEndTimeISO = dayjs.utc( configDetails.scheduleEndTimeISO ).format( 'HH:mm:ss' );
+        let newUpdatedDate = dayjs.utc( updatedscheduleEndTimeISO, 'HH:mm:ss' ).format();
+        if ( newUpdatedDate > currentDate ) {
+          let deleteQuery = {
+            $and: [
+              { date_string: dayjs().format( 'YYYY-MM-DD' ) },
+              { sourceCheckList_id: new ObjectId( req.params.checklistId ) },
+              { scheduleEndTime_iso: { $gt: currentDate } },
+            ],
+          };
+          deleteQuery.$and.push( { checklistStatus: { $ne: 'submit' } } );
+          let PClicklist = await processedchecklist.deleteMany( deleteQuery );
+          logger.info( { function: 'updateConfigure', query: deleteQuery } );
+          if ( PClicklist.acknowledged || inputBody.updateConfigure ) {
+            await insertSingleProcessData( inputBody.checkListDetails._id, 0, inputBody.updateConfigure, inputBody?.editSubmit, inputBody?.showEdit );
+          } else {
+            res.sendError( 'something went wrong, please try again', 500 );
+          }
+        } else {
+          logger.info( `Schudled End Time Breached Checklist publish true => Checklist Name: ${checklistDetails.checkListName}` );
+        }
+
+        futureDaysDataRemove( currentDate, req.params.checklistId, checklistDetails.checkListName, '333' );
+      }
+    }
+    if ( response?.modifiedCount || response?.matchedCount || response?.upsertedCount ) {
+      return res.sendSuccess( { id, message: 'Configured Updated Successfully' } );
+    }
+    if ( response._id ) {
+      return res.sendSuccess( { id, message: 'Configured Added Successfully' } );
+    }
+  } catch ( e ) {
+    logger.error( 'updateConfigure =>', e );
+    return res.sendError( e, 500 );
+  }
+};
+
 export const updatePublish = async ( req, res ) => {
   try {
     if ( typeof req?.body?.checklistId == 'undefined' && typeof req.body.type == 'undefined' ) {
@@ -1580,6 +1844,127 @@ export const validateUser = async ( req, res ) => {
   }
 };
 
+export const validateUserv1 = async ( req, res ) => {
+  try {
+    if ( !req.body.assignedUsers.length ) {
+      return res.sendError( 'Please Enter user Details', 400 );
+    }
+
+    let assignDetails = req.body.assignedUsers;
+
+    const duplicateStore = assignDetails.reduce( ( acc, obj ) => {
+      if ( !acc[obj.storeName.toLowerCase()] ) {
+        acc[obj.storeName.toLowerCase()] = {
+          email: [ obj.userEmail.toLowerCase() ],
+          count: 1,
+        };
+      } else {
+        if ( acc[obj.storeName.toLowerCase()] ) {
+          if ( acc[obj.storeName.toLowerCase()].email.includes( obj.userEmail.toLowerCase() ) ) {
+            acc[obj.storeName.toLowerCase()].count++;
+          } else {
+            acc[obj.storeName.toLowerCase()].email.push( obj.userEmail.toLowerCase() );
+          }
+        }
+      }
+      return acc;
+    }, {} );
+
+    const duplicateStores = Object.keys( duplicateStore ).filter( ( storeName ) => duplicateStore[storeName].count > 1 );
+    if ( duplicateStores.length ) {
+      return res.sendSuccess( { validate: false, ExistsEmail: duplicateStores, message: 'store and email is Duplicated' } );
+    }
+
+    if ( req.body.hasOwnProperty( 'delete' ) ) {
+      let checkExists = await assignedService.findOne( { userEmail: assignDetails[0].userEmail, storeName: assignDetails[0].storeName, checkListId: req.body.id } );
+      if ( checkExists ) {
+        return res.sendError( 'User already Exists', 400 );
+      }
+    }
+    // let userChunk =await chunkArray( users, 10 );
+
+    await Promise.all( users.map( async ( chunk ) => {
+      await processUser( [ chunk ] );
+    } ) );
+
+    let userEmailList = assignDetails.map( ( item ) => item.userEmail.toLowerCase() );
+    let storeList = assignDetails.map( ( item ) => item.storeName.toLowerCase() );
+
+    let userQuery = [
+      {
+        $project: {
+          newEmail: { $toLower: '$email' },
+          isActive: 1,
+          clientId: 1,
+        },
+      },
+      {
+        $match: {
+          newEmail: { $in: userEmailList },
+          isActive: true,
+          clientId: req.body.clientId,
+        },
+      },
+    ];
+
+    let storeQuery = [
+      {
+        $project: {
+          'storeName': { $toLower: '$storeName' },
+          'clientId': 1,
+          'storeProfile.city': 1,
+          'status': 1,
+        },
+      },
+      {
+        $match: {
+          clientId: req.body.clientId,
+          storeName: { $in: storeList },
+        },
+      },
+    ];
+
+    let [ userDetails, storeDetails ] = await Promise.all[
+        await userService.aggregate( userQuery ),
+        await storeService.aggregate( storeQuery )
+    ];
+
+    let existUSerEmail = userDetails.map( ( ele ) => ele.email );
+
+    userDetails = userEmailList.filter( ( ele ) => !existUSerEmail.includes( ele ) );
+
+    let existsStore = storeDetails.map( ( ele ) => ele.storeName );
+    storeDetails = storeList.filter( ( ele ) => !existsStore.includes( ele ) );
+
+    if ( userDetails.length || storeDetails.length ) {
+      return res.sendError( { validate: false, user: userDetails, store: storeDetails }, 400 );
+    }
+
+    return res.sendSuccess( { validate: true } );
+  } catch ( e ) {
+    logger.error( 'validateUser 2=>', e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export async function assignUser( req, res ) {
+  try {
+    let inputBody = req.body;
+    let assignDetails = inputBody.assignUsers;
+    if ( inputBody.type == 'upload' ) {
+      await assignedService.deleteMany( { checkListId: inputBody.checklistId } );
+    }
+    await Promise.all( assignDetails.map( ( assign ) => {
+      assignUsers( assign );
+    } ) );
+    return res.sendSuccess( 'Details updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'assignUser', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
 async function uploadUser( req, res ) {
   try {
     let inputBody = req.body;
@@ -2711,3 +3096,148 @@ export const checklistV2 = async ( req, res ) => {
     return res.sendError( e, 500 );
   }
 };
+
+async function assignUsers( data ) {
+  let assignedData;
+  if ( data.coverage == 'store' ) {
+    if ( data.type == 'cluster' ) {
+      let clusterDetails = await clusterServices.findOneCluster( { _id: data.id }, { stores: 1, clusterName: 1 } );
+      if ( clusterDetails ) {
+        assignedData = {
+          checkFlag: true,
+          checkListId: data.checklistId,
+          checkListName: data.checkListName,
+          client_id: data?.clientId,
+          clusterName: clusterDetails?.clusterName,
+          assignId: data.id,
+        };
+      }
+    } else {
+      let storeDetails = await storeService.findOne( { _id: data.id } );
+      if ( storeDetails ) {
+        let userDetails = await userService.findOne( { userEmail: storeDetails?.spocDetails?.email, clientId: data.clientId } );
+        if ( !userDetails ) {
+          let userData = {
+            userName: storeDetails.spocDetails?.[0]?.name,
+            email: storeDetails.spocDetails[0].email,
+            mobileNumber: storeDetails.spocDetails?.[0]?.phone,
+            clientId: data.clientId,
+          };
+          createUser( userData );
+        }
+        assignedData = {
+          store_id: storeDetails.storeId,
+          storeName: storeDetails.storeName,
+          userId: userDetails._id,
+          userName: userDetails.userName,
+          userEmail: userDetails.email,
+          userPhone: userDetails?.mobileNumber,
+          city: storeDetails?.storeProfile?.city,
+          country: storeDetails?.storeprofile?.country,
+          checkFlag: true,
+          checkListId: data.checklistId,
+          checkListName: data.checkListName,
+          client_id: data.clientId,
+          assignId: data.id,
+        };
+      }
+    }
+  } else {
+    if ( data.type == 'teams' ) {
+      let teamDetails = await teamsServices.findOneTeams( { _id: data.id }, { users: 1, teamName: 1 } );
+      if ( teamDetails ) {
+        assignedData = {
+          checkFlag: true,
+          checkListId: data.checklistId,
+          checkListName: data.checkListName,
+          client_id: data.clientId,
+          teamName: teamDetails?.teamName,
+          assignId: data.id,
+        };
+      }
+    } else {
+      let userDetails = await userService.findOne( { _id: { $in: data.id } } );
+      if ( userDetails ) {
+        assignedData = {
+          userId: userDetails._id,
+          userName: userDetails.userName,
+          userEmail: userDetails.email,
+          userPhone: userDetails?.mobileNumber,
+          checkFlag: true,
+          checkListId: data.checklistId,
+          checkListName: data.checkListName,
+          client_id: data.clientId,
+          assignId: data.id,
+        };
+      }
+    }
+  }
+  await assignedService.create( assignedData );
+}
+
+export async function checklistAssign( req, res ) {
+  try {
+    if ( !req.body.type ) {
+      return res.sendError( 'Type is required', 400 );
+    }
+    if ( !req.body.coverage ) {
+      return res.sendError( 'coverage is required', 400 );
+    }
+    if ( !req.body.id ) {
+      return res.sendError( 'coverage is required', 400 );
+    }
+    if ( !req.body.checklistId ) {
+      return res.sendError( 'Checklist id is required', 400 );
+    }
+    if ( !req.body.clientId ) {
+      return res.sendError( 'Client id is required', 400 );
+    }
+    let checklistDetails = await checklistService.findOne( { _id: req.body.checklistId } );
+    if ( !checklistDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    req.body.checkListName = checklistDetails.checkListName;
+    await assignUsers( req.body );
+    return res.sendSuccess( 'Details updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'checklistAssign', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function removeAssign( req, res ) {
+  try {
+    if ( !req.body.id ) {
+      return res.sendError( 'Id is required', 400 );
+    }
+    if ( !req.body.checkListId ) {
+      return res.sendError( 'Checklist id is required', 400 );
+    }
+    let checklistDetails = await checklistService.findOne( { _id: req.body.checkListId } );
+    if ( !checklistDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    await assignedService.deleteMany( { assignId: req.body.id } );
+    return res.sendSuccess( 'Details removed successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'removeAssign', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function deleteAssignList( req, res ) {
+  try {
+    if ( !req.body.checkListId ) {
+      return res.sendError( 'Checklist id is required', 400 );
+    }
+    let checklistDetails = await checklistService.findOne( { _id: req.body.checkListId, isdeleted: false } );
+    if ( !checklistDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    await assignedService.updateMany( { checkListId: req.body.checkListId }, { isdeleted: true } );
+    return res.sendSuccess( 'Assign details removed successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'deleteAssignList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}

package/src/routes/trax.routes.js

@@ -16,6 +16,7 @@ traxRouter
     .post( '/validateUser', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ 'isEdit' ] } ] } ), validate( uploadUserValidation ), traxController.validateUser )
     .get( '/userDetails/:checklistId', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ ] } ] } ), validate( duplicateValidation ), traxController.assignedUserDetails )
     .post( '/checklistConfigure', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ 'isEdit' ] } ] } ), traxController.updateConfigure )
+    .post( '/checklistConfigurev1', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ 'isEdit' ] } ] } ), traxController.updateConfigurev1 )
     .delete( '/deleteChecklist/:checklistId', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ 'isEdit' ] } ] } ), validate( duplicateValidation ), traxController.deleteChecklist )
     .put( '/publish', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ 'isEdit' ] } ] } ), validate( publishValidation ), traxController.updatePublish )
     .get( '/userList', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ ] } ] } ), traxController.userlist )
@@ -23,6 +24,9 @@ traxRouter
     .get( '/aichecklist', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ ] } ] } ), validate( aichecklistValidation ), traxController.aiChecklist )
     .get( '/predefinedChecklist', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ ] } ] } ), validate( aichecklistValidation ), traxController.preDefinedChecklist )
     .post( '/selectAssign', validate( selectAssign ), traxController.selectAssign )
-    .get( '/checklistV2', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ ] } ] } ), validate( checklistPageSchema ), traxController.checklistV2 );
+    .get( '/checklistV2', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ ] } ] } ), validate( checklistPageSchema ), traxController.checklistV2 )
+    .post( '/assign', isAllowedSessionHandler, traxController.checklistAssign )
+    .post( '/remove', isAllowedSessionHandler, traxController.removeAssign )
+    .post( '/removeAssignList', isAllowedSessionHandler, traxController.deleteAssignList );
 
 // isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ ] } ] } ),

package/src/services/checklistAssign.service.js

@@ -28,4 +28,8 @@ export const aggregate = async ( query = {} ) => {
   return model.checklistassignconfigModel.aggregate( query );
 };
 
+export const count = async ( query = {} ) => {
+  return model.checklistassignconfigModel.countDocuments( query );
+};
+