tango-app-api-trax 3.3.1-beta-9 → 3.3.1-beta-11

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "3.3.1-beta-9",
+    "version": "3.3.1-beta-11",
     "description": "Trax",
     "main": "index.js",
     "type": "module",

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() );
@@ -874,52 +874,89 @@ export const assignedUserDetails = async ( req, res ) => {
         query.push( { $match: { storeName: { $regex: req.query.search.trim(), $options: 'i' } } } );
       }
     }
-    if ( req.query.sortColumn && req.query.sortBy ) {
-      query.push( { $sort: { [req.query.sortColumn]: parseInt( req.query.sortBy ) } } );
-    } else {
-      query.push( { $sort: { _id: -1 } } );
-    }
 
-    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 = [];
     let storeList = [];
     let userList = [];
-    checklistDetails[0].data.forEach( ( item ) => {
-      if ( item?.store_id ) {
-        storeList.push( item.assignId );
+    await Promise.all( checklistDetails.map( async ( ele ) => {
+      if ( ele?.store_id || ele?.clusterName ) {
+        storeList.push( ele.assignId );
       } else {
-        userList.push( item.assignId );
+        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.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,
-        clusterName: item?.clusterName,
-        teamName: item?.teamName,
+    } ) );
+    if ( req.query.sortColumn && req.query.sortBy ) {
+      const sortColumn = req.query.sortColumn;
+      const sortBy = parseInt( req.query.sortBy, 10 ) === -1 ? -1 : 1;
+      userDetails.sort( ( a, b ) => {
+        if ( a[sortColumn] == null || b[sortColumn] == null ) return 0;
+        if ( typeof a[sortColumn] === 'string' && typeof b[sortColumn] === 'string' ) {
+          return sortBy * a[sortColumn].localeCompare( b[sortColumn] );
+        }
       } );
-    } );
-    return res.sendSuccess( { users: userDetails, count: checklistDetails[0].count[0].total, storeList, userList } );
+    }
+    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 );
@@ -1266,6 +1303,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' ) {
@@ -1594,6 +1851,147 @@ 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 assignChecklistUser( req, res ) {
+  try {
+    let inputBody = req.body;
+    let assignDetails = inputBody.assignUsers;
+    let newUsers = inputBody.newUsers;
+    if ( inputBody.type == 'upload' ) {
+      await assignedService.deleteMany( { checkListId: inputBody.checklistId } );
+    }
+    let checklistDetails = await checklistService.findOne( { _id: inputBody.checklistId } );
+    if ( !checklistDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    await Promise.all( newUsers.map( async ( user ) => {
+      let getUser = inputBody.assignUsers.find( ( ele ) => ele.userEmail.toLowerCase() == user.toLowerCase() );
+      let userData = {
+        userName: getUser.userName,
+        email: user,
+        mobileNumber: getUser?.phone,
+        clientId: inputBody.clientId,
+      };
+      await createUser( userData );
+    } ) );
+    await Promise.all( assignDetails.map( async ( assign ) => {
+      assign.checklistId = inputBody.checklistId;
+      assign.checkListName = checklistDetails.checkListName;
+      assign.coverage = inputBody.coverage;
+      assign.clientId = inputBody.clientId;
+      assign.upload = inputBody.type;
+      await 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;
@@ -2726,168 +3124,114 @@ export const checklistV2 = async ( req, res ) => {
   }
 };
 
-export async function checklistAssign( req, res ) {
-  try {
-    if ( !req.body.checklistId ) {
-      return res.sendError( 'Checklist id is required', 400 );
-    }
-    if ( !req.body.coverage ) {
-      return res.sendError( 'Coverage is required', 400 );
-    }
-    if ( !req.body.id ) {
-      return res.sendError( 'Store/user id is required', 400 );
-    }
-
-    let checklistDetails = await checklistService.findOne( { _id: req.body.checklistId } );
-    if ( !checklistDetails ) {
-      return res.sendError( 'No data found', 204 );
-    }
-    checklistDetails.coverage = req.body.coverage;
-    checklistDetails.save();
-    let idList;
-    if ( req.body.coverage == 'store' ) {
-      let clusterDetails = await clusterServices.findOneCluster( { _id: req.body.id }, { stores: 1, clusterName: 1 } );
+async function assignUsers( data ) {
+  let assignedData;
+  if ( data.coverage == 'store' ) {
+    if ( data?.type == 'cluster' ) {
+      let query = !data?.upload ? { _id: data.id } : { clusterName: data.clusterName, clientId: data.clientId };
+      let clusterDetails = await clusterServices.findOneCluster( query, { stores: 1, clusterName: 1 } );
       if ( clusterDetails ) {
-        idList = clusterDetails.stores.map( ( item ) => item.store );
-      } else {
-        idList = [ new ObjectId( req.body.id ) ];
-      }
-      let getStoreDetails = await storeService.find( { _id: { $in: idList } } );
-      if ( !getStoreDetails.length ) {
-        return res.sendError( 'No data found', 204 );
+        assignedData = {
+          checkFlag: true,
+          checkListId: data.checklistId,
+          checkListName: data.checkListName,
+          client_id: data?.clientId,
+          clusterName: clusterDetails?.clusterName,
+          assignId: data?.id || clusterDetails?._id,
+        };
       }
-      let assignList = await Promise.all( getStoreDetails.map( async ( store ) => {
-        let userDetails = await userService.findOne( { userEmail: store?.spocDetails?.email, clientId: store.clientId } );
+    } else {
+      let query = !data?.upload ? { _id: data.id } : { storeName: data.storeName };
+      let storeDetails = await storeService.findOne( query );
+      if ( storeDetails ) {
+        let email = data?.upload ? data.userEmail : storeDetails?.spocDetails?.email;
+        let userDetails = await userService.findOne( { email: email, clientId: data.clientId } );
         if ( !userDetails ) {
-          let data = {
-            clientId: store.clientId,
-            userName: store.spocDetails?.[0]?.name,
-            mobileNumber: store.spocDetails?.[0]?.phone || '',
-            email: store.spocDetails[0].email,
-            password: '5dqFKAJj29PsV6P+kL+3Dw==',
-            role: 'user',
-            userType: 'client',
-            rolespermission: [
-              {
-                featureName: 'Global',
-                modules: [
-                  {
-                    name: 'Store',
-                    isAdd: false,
-                    isEdit: false,
-
-                  },
-                  {
-                    name: 'User',
-                    isAdd: false,
-                    isEdit: false,
-
-                  },
-                  {
-                    name: 'Camera',
-                    isAdd: false,
-                    isEdit: false,
-
-                  },
-                  {
-                    name: 'Configuration',
-                    isAdd: false,
-                    isEdit: false,
-
-                  },
-                  {
-                    name: 'Subscription',
-                    isAdd: false,
-                    isEdit: false,
-
-                  },
-                  {
-                    name: 'Billing',
-                    isAdd: false,
-                    isEdit: false,
-
-                  },
-                ],
-              },
-              {
-                featurName: 'TangoEye',
-                modules: [
-                  {
-                    name: 'ZoneTag',
-                    isAdd: false,
-                    isEdit: false,
-
-                  },
-                ],
-              },
-              {
-                featurName: 'TangoTrax',
-                modules: [
-                  {
-                    name: 'checklist',
-                    isAdd: false,
-                    isEdit: false,
-
-                  },
-                  {
-                    name: 'Task',
-                    isAdd: false,
-                    isEdit: false,
-
-                  },
-                ],
-              },
-            ],
+          let userData = {
+            userName: storeDetails.spocDetails?.[0]?.name,
+            email: storeDetails.spocDetails[0].email,
+            mobileNumber: storeDetails.spocDetails?.[0]?.phone,
+            clientId: data.clientId,
           };
-          userDetails = await userService.create( data );
+          userDetails = createUser( userData );
         }
-        let data = {
-          store_id: store.storeId,
-          storeName: store.storeName,
+        assignedData = {
+          store_id: storeDetails.storeId,
+          storeName: storeDetails.storeName,
           userId: userDetails._id,
           userName: userDetails.userName,
           userEmail: userDetails.email,
           userPhone: userDetails?.mobileNumber,
-          city: store?.storeProfile?.city,
-          country: store?.storeprofile?.country,
+          city: storeDetails?.storeProfile?.city,
+          country: storeDetails?.storeProfile?.country,
           checkFlag: true,
-          checkListId: req.body.checklistId,
-          checkListName: checklistDetails.checkListName,
-          client_id: store.clientId,
-          clusterName: clusterDetails?.clusterName,
-          assignId: req.body.id,
+          checkListId: data.checklistId,
+          checkListName: data.checkListName,
+          client_id: data.clientId,
+          assignId: data?.id || storeDetails._id,
         };
-        return data;
-      } ) );
-      await assignedService.insertMany( assignList );
-    } else {
-      let teamDetails = await teamsServices.findOneTeams( { _id: req.body.id }, { users: 1, teamName: 1 } );
+      }
+    }
+  } else {
+    if ( data.type == 'teams' ) {
+      let query = !data?.upload ? { _id: data.id } : { teamName: data.teamName, clientId: data.clientId };
+      let teamDetails = await teamsServices.findOneTeams( query, { users: 1, teamName: 1 } );
       if ( teamDetails ) {
-        idList = teamDetails.users.map( ( item ) => item.userId );
-      } else {
-        idList = [ new ObjectId( req.body.id ) ];
-      }
-      let userDetails = await userService.find( { _id: { $in: idList } } );
-      if ( !userDetails.length ) {
-        return res.sendError( 'No data found', 204 );
-      }
-      let assignList = [];
-      userDetails.forEach( ( user ) => {
-        assignList.push( {
-          userId: user._id,
-          userName: user.userName,
-          userEmail: user.email,
-          userPhone: user?.mobileNumber,
+        assignedData = {
           checkFlag: true,
-          checkListId: req.body.checklistId,
-          checkListName: checklistDetails.checkListName,
-          client_id: user.clientId,
+          checkListId: data.checklistId,
+          checkListName: data.checkListName,
+          client_id: data.clientId,
           teamName: teamDetails?.teamName,
-          assignId: req.body.id,
-        } );
-      } );
-      await assignedService.insertMany( assignList );
+          assignId: data?.id || teamDetails?._id,
+        };
+      }
+    } else {
+      let query = !data?.upload ? { _id: data.id } : { email: data.email, clientId: data.clientId };
+      let userDetails = await userService.findOne( query );
+      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 || userDetails?._id,
+        };
+      }
+    }
+  }
+  if ( assignedData ) {
+    await assignedService.create( assignedData );
+  }
+}
+
+export async function checklistAssign( req, res ) {
+  try {
+    if ( !req.body.coverage ) {
+      return res.sendError( 'coverage is required', 400 );
+    }
+    if ( !req.body.idList ) {
+      return res.sendError( 'Id list 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 Promise.all( req.body.idList.map( async ( ele ) => {
+      let storeData = { ...req.body, type: ele.type, id: ele.id };
+      await assignUsers( storeData );
+    } ) );
     return res.sendSuccess( 'Details updated successfully' );
   } catch ( e ) {
     logger.error( { functionName: 'checklistAssign', error: e } );
@@ -2914,3 +3258,20 @@ export async function removeAssign( req, res ) {
     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

@@ -13,9 +13,10 @@ traxRouter
     .post( '/runAIInsert', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ 'isEdit' ] } ] } ), validate( runaiValidation ), traxController.runAIInsert )
     .get( '/duplicateChecklist/:checklistId', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ 'isEdit' ] } ] } ), validate( duplicateValidation ), traxController.duplicateChecklist )
     .put( '/checklist/update/:checklistId', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ 'isEdit' ] } ] } ), validate( updateChecklistValidation ), traxController.update )
-    .post( '/validateUser', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ 'isEdit' ] } ] } ), validate( uploadUserValidation ), traxController.validateUser )
+    .post( '/validateUser', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'checklist', permissions: [ 'isEdit' ] } ] } ), validate( uploadUserValidation ), traxController.validateUserv1 )
     .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 )
@@ -25,6 +26,8 @@ traxRouter
     .post( '/selectAssign', validate( selectAssign ), traxController.selectAssign )
     .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( '/remove', isAllowedSessionHandler, traxController.removeAssign )
+    .post( '/removeAssignList', isAllowedSessionHandler, traxController.deleteAssignList )
+    .post( '/assignUpload', isAllowedSessionHandler, traxController.assignChecklistUser );
 
 // 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 );
+};
+