tango-app-api-trax 3.3.1-beta-50 → 3.3.1-beta-52

package/package.json

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

package/src/controllers/teaxFlag.controller.js

@@ -961,7 +961,12 @@ export const flagTablesV1 = async ( req, res ) => {
       $project: {
         checkListName: 1,
         checkListChar: 1,
-        coverage: 1,
+        coverage: {
+          $concat: [
+            { $toUpper: { $substr: [ { $ifNull: [ '$coverage', '' ] }, 0, 1 ] } },
+            { $substr: [ { $ifNull: [ '$coverage', '' ] }, 1, { $strLenCP: { $ifNull: [ '$coverage', '' ] } } ] },
+          ],
+        },
         sourceCheckList_id: 1,
         checkListType: 1,
         flagType: 1,

package/src/controllers/trax.controller.js

@@ -396,7 +396,7 @@ export const getConfigDetails = async ( req, res ) => {
       }
       let query = {
         checkListId: storechecklistdetails._id,
-        ...( storechecklistdetails.coverage == 'store' ) ? { $or: [ { store_id: { $exists: true } }, { clusterName: { $exists: true } } ] } : { $or: [ { userEmail: { $exists: true } }, { teamsName: { $exists: true } } ] },
+        ...( storechecklistdetails.coverage == 'store' ) ? { $or: [ { store_id: { $exists: true } }, { clusterName: { $exists: true } } ] } : { $or: [ { userEmail: { $exists: true } }, { teamName: { $exists: true } } ] },
       };
       let assignList = await assignedService.find( query, { _id: 1, store_id: 1, clusterName: 1, userEmail: 1, teamName: 1, assignId: 1 } );
       let singleAssign;
@@ -1593,20 +1593,6 @@ export const updateConfigurev1 =async ( req, res ) => {
       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,
-          coverage: inputBody?.checkListDetails.coverage,
-          insert: true,
-        };
-        await assignUsers( data );
-      } ) );
-    }
     if ( inputBody.submitType == 'publish' ) {
       if ( inputBody.checkListDetails.checkListType == 'custom' ) {
         let currentDate = dayjs.utc().format();
@@ -1983,6 +1969,54 @@ export const validateUserv1 = async ( req, res ) => {
 
     let assignDetails = req.body.assignedUsers;
 
+    if ( req.body.coverage == 'store' ) {
+      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' } );
+      }
+    } else {
+      const duplicateUser = assignDetails.reduce( ( acc, obj ) => {
+        if ( !acc[obj.userEmail.toLowerCase()] ) {
+          acc[obj.userEmail.toLowerCase()] = {
+            name: [ obj.userName.toLowerCase() ],
+            count: 1,
+          };
+        } else {
+          if ( acc[obj.userEmail.toLowerCase()] ) {
+            if ( acc[obj.userEmail.toLowerCase()].name.includes( obj.userName.toLowerCase() ) ) {
+              acc[obj.userEmail.toLowerCase()].count++;
+            } else {
+              acc[obj.userEmail.toLowerCase()].name.push( obj.userEmail.toLowerCase() );
+            }
+          }
+        }
+        return acc;
+      }, {} );
+
+      const duplicateUsers = Object.keys( duplicateUser ).filter( ( storeName ) => duplicateUser[storeName].count > 1 );
+      if ( duplicateUsers.length ) {
+        return res.sendSuccess( { validate: false, ExistsEmail: duplicateUsers, message: 'Email is Duplicated' } );
+      }
+    }
+
     if ( req.body.hasOwnProperty( 'addSingle' ) ) {
       let checkExists = await assignedService.findOne( { userEmail: assignDetails[0]?.userEmail, storeName: assignDetails[0]?.storeName, checkListId: req.body.id } );
       if ( checkExists ) {
@@ -2034,6 +2068,7 @@ export const validateUserv1 = async ( req, res ) => {
           'clientId': 1,
           'storeProfile.city': 1,
           'status': 1,
+          'storeId': 1,
         },
       },
       {
@@ -2044,75 +2079,88 @@ export const validateUserv1 = async ( req, res ) => {
       },
     ];
 
-    console.log( storeQuery );
-
     let [ userDetails, storeDetails, existEmail ] = await Promise.all( [
       await userService.aggregate( userQuery ),
       await storeService.aggregate( storeQuery ),
       await userService.aggregate( emailCheckQuery ),
     ] );
 
-    let existUSerEmail = userDetails.map( ( ele ) => ele.email );
 
-    userDetails = userEmailList.filter( ( ele ) => !existUSerEmail.includes( ele ) );
+    let existUserEmail = userDetails.map( ( ele ) => ele.newEmail );
+    let newUserList = userEmailList.filter( ( ele ) => !existUserEmail.includes( ele ) );
 
-    let existsStore = storeDetails.map( ( ele ) => ele.storeName && ele.storeName != null );
-    storeDetails = storeList.filter( ( ele ) => ele != null && !existsStore.includes( ele ) );
+    let existsStore = storeDetails.map( ( ele ) => ele?.storeName );
+    let newStoreList = storeList.filter( ( ele ) => ele != null && !existsStore.includes( ele.toLowerCase() ) );
+    if ( req.body.coverage == 'store' ) {
+      assignDetails.forEach( ( item ) => {
+        let getStoreId = storeDetails.find( ( store ) => store.storeName.toLowerCase() == item.storeName.toLowerCase() );
+        if ( getStoreId ) {
+          item._id = getStoreId._id;
+          item.storeId = getStoreId.storeId;
+        }
+      } );
+    } else {
+      assignDetails.forEach( ( item ) => {
+        let getUserId = userDetails.find( ( user ) => user.newEmail.toLowerCase() == item.userEmail.toLowerCase() );
+        if ( getUserId ) {
+          item._id = getUserId._id;
+        }
+      } );
+    }
 
-    if ( userDetails.length || storeDetails.length || existEmail.length ) {
-      return res.sendError( { validate: false, user: userDetails, store: storeDetails, existEmail }, 400 );
+    if ( newUserList.length || newStoreList.length || existEmail.length ) {
+      return res.sendError( { validate: false, user: newUserList, store: newStoreList, existEmail, data: assignDetails }, 400 );
     }
-    return res.sendSuccess( { validate: true } );
+    return res.sendSuccess( { validate: true, data: assignDetails } );
   } 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;
-    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 );
-    } ) );
-    let assignData = [];
-    await Promise.all( assignDetails.map( async ( assign ) => {
-      assign.checklistId = inputBody.taskId;
-      assign.checkListName = checklistDetails.checkListName;
-      assign.coverage = inputBody.coverage;
-      assign.clientId = inputBody.clientId;
-      assign.upload = inputBody.type;
-      let uploadData = await assignUsers( assign );
-      if ( uploadData ) {
-        if ( Array.isArray( uploadData ) ) {
-          assignData.push( ...uploadData );
-        } else {
-          assignData.push( uploadData );
-        }
-      }
-    } ) );
-    return res.sendSuccess( { idList: [ ...new Set( assignData.map( ( item ) => {
-      return { id: item?.assignId?.toString(), type: inputBody.coverage == 'store' ? typeof item.clusterName == 'undefined' ? 'store' : 'cluster' : typeof item.teamsName == 'undefined' ? 'user' : 'teams' };
-    } ) ) ], assignData } );
-  } catch ( e ) {
-    logger.error( { functionName: 'assignUser', error: 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;
+//     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 );
+//     } ) );
+//     let assignData = [];
+//     await Promise.all( assignDetails.map( async ( assign ) => {
+//       assign.checklistId = inputBody.taskId;
+//       assign.checkListName = checklistDetails.checkListName;
+//       assign.coverage = inputBody.coverage;
+//       assign.clientId = inputBody.clientId;
+//       assign.upload = inputBody.type;
+//       let uploadData = await assignUsers( assign );
+//       if ( uploadData ) {
+//         if ( Array.isArray( uploadData ) ) {
+//           assignData.push( ...uploadData );
+//         } else {
+//           assignData.push( uploadData );
+//         }
+//       }
+//     } ) );
+//     return res.sendSuccess( { idList: [ ...new Set( assignData.map( ( item ) => {
+//       return { id: item?.assignId?.toString(), type: inputBody.coverage == 'store' ? typeof item.clusterName == 'undefined' ? 'store' : 'cluster' : typeof item.teamsName == 'undefined' ? 'user' : 'teams' };
+//     } ) ) ], assignData } );
+//   } catch ( e ) {
+//     logger.error( { functionName: 'assignUser', error: e } );
+//     return res.sendError( e, 500 );
+//   }
+// }
 
 async function uploadUser( req, res ) {
   try {
@@ -3492,7 +3540,18 @@ export const selectAssign = async ( req, res ) => {
       if ( requestData.assignType == 'store' ) {
         let storeQuery = [
           { $match: { clientId: requestData.clientId, status: 'active' } },
-          { $project: { 'storeName': 1, 'storeId': 1, 'type': 'store' } },
+          {
+            $project: {
+              storeName: 1,
+              storeId: 1,
+              type: 'store',
+              userName: { $arrayElemAt: [ '$spocDetails.name', 0 ] },
+              userEmail: { $arrayElemAt: [ '$spocDetails.email', 0 ] },
+              contact: { $arrayElemAt: [ '$spocDetails.contact', 0 ] },
+              city: '$storeProfile.city',
+            },
+          },
+
         ];
         resuldData = await storeService.aggregate( storeQuery );
       } else {
@@ -3509,7 +3568,7 @@ export const selectAssign = async ( req, res ) => {
       if ( requestData.assignType == 'user' ) {
         let userQuery = [
           { $match: { clientId: requestData.clientId } },
-          { $project: { 'userEmail': 1, 'userName': 1, 'type': 'user' } },
+          { $project: { 'email': 1, 'userName': 1, 'type': 'user' } },
         ];
         resuldData = await userService.aggregate( userQuery );
       } else {
@@ -3535,213 +3594,40 @@ export const selectAssign = async ( req, res ) => {
 
 async function assignUsers( data ) {
   let assignedData;
-  if ( data.coverage == 'store' ) {
-    if ( data?.type == 'cluster' ) {
-      let query = [
-        {
-          $addFields: {
-            cluster: { $toLower: '$clusterName' },
-          },
-        },
-        {
-          $match: {
-            clientId: data.clientId,
-            ...( data?.id ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { cluster: data.clusterName.toLowerCase() },
-          },
-        },
-        {
-          $project: {
-            stores: 1,
-            clusterName: 1,
-          },
-        },
-      ];
-      let clusterDetails = await clusterServices.aggregateCluster( query );
-      if ( clusterDetails.length ) {
-        if ( data.insert ) {
-          assignedData = {
-            checkFlag: true,
-            checkListId: data.checklistId,
-            checkListName: data.checkListName,
-            client_id: data?.clientId,
-            clusterName: clusterDetails?.[0]?.clusterName,
-            assignId: data?.id || clusterDetails?.[0]?._id,
-            coverage: 'store',
-          };
-        } else {
-          let clusterList = clusterDetails[0].stores.map( ( ele ) => ele.store );
-          let storeDetails = await storeService.find( { _id: { $in: clusterList }, status: 'active' } );
-          assignedData = await Promise.all( storeDetails.map( async ( store ) => {
-            let userDetails = await userService.findOne( { email: store.spocDetails?.[0]?.email, clientId: data.clientId } );
-            if ( !userDetails && store?.spocDetails?.length ) {
-              let userData = {
-                userName: store.spocDetails?.[0]?.name,
-                email: store.spocDetails[0]?.email,
-                mobileNumber: store.spocDetails?.[0]?.phone,
-                clientId: data.clientId,
-              };
-              userDetails = await createUser( userData );
-            }
-            let userData = {
-              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 || clusterDetails?.[0]?._id,
-              coverage: 'store',
-              clusterName: clusterDetails?.[0]?.clusterName,
-              storeId: store.storeId,
-              storeName: store.storeName,
-            };
-            return userData;
-          } ) );
-        }
-      }
-    } else {
-      let query = [
-        {
-          $addFields: {
-            store: { $toLower: '$storeName' },
-          },
-        },
-        {
-          $match: {
-            clientId: data.clientId,
-            ...( data?.id ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { store: data.storeName.toLowerCase() },
-          },
-        },
-      ];
-      let storeDetails = await storeService.aggregate( query );
-      if ( storeDetails.length ) {
-        let email = data?.userEmail ? data.userEmail : storeDetails?.[0]?.spocDetails?.[0]?.email;
-        let userDetails = await userService.findOne( { email: email, clientId: data.clientId } );
-        if ( !userDetails ) {
-          let userData = {
-            userName: storeDetails?.[0]?.spocDetails?.[0]?.name,
-            email: data?.userEmail || storeDetails?.[0]?.spocDetails[0].email,
-            mobileNumber: storeDetails?.[0]?.spocDetails?.[0]?.phone,
-            clientId: data.clientId,
-          };
-          userDetails = await createUser( userData );
-        }
-        assignedData = {
-          store_id: storeDetails?.[0]?.storeId,
-          storeName: storeDetails?.[0]?.storeName,
-          userId: userDetails._id,
-          userName: userDetails.userName,
-          userEmail: userDetails.email,
-          userPhone: userDetails?.mobileNumber,
-          city: storeDetails?.[0]?.storeProfile?.city,
-          country: storeDetails?.[0]?.storeProfile?.country,
-          checkFlag: true,
-          checkListId: data.checklistId,
-          checkListName: data.checkListName,
-          client_id: data.clientId,
-          assignId: data?.id || storeDetails?.[0]?._id,
-          coverage: 'store',
+  if ( data?.type == 'cluster' ) {
+    let clusterDetails = await clusterServices.findcluster( { clientId: data.clientId, _id: new mongoose.Types.ObjectId( data.id ) } );
+    if ( clusterDetails.length ) {
+      let clusterList = clusterDetails[0].stores.map( ( ele ) => ele.store );
+      let storeDetails = await storeService.find( { _id: { $in: clusterList }, status: 'active' } );
+      assignedData = await Promise.all( storeDetails.map( async ( store ) => {
+        let userData = {
+          storeId: store.storeId,
+          storeName: store.storeName,
+          userName: store.spocDetails?.[0]?.name,
+          userEmail: store.spocDetails?.[0]?.email,
+          clusterName: clusterDetails?.[0]?.clusterName,
+          id: clusterDetails?.[0]?._id,
         };
-      }
+        return userData;
+      } ) );
     }
   } else {
-    if ( data.type == 'teams' ) {
-      let query = [
-        {
-          $addFields: {
-            team: { $toLower: '$teamName' },
-          },
-        },
-        {
-          $match: {
-            clientId: data.clientId,
-            ...( data?.id ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { team: data.teamName.toLowerCase() },
-          },
-        },
-      ];
-      let teamDetails = await teamsServices.aggregateTeams( query );
-      if ( teamDetails.length ) {
-        if ( data.insert ) {
-          assignedData = {
-            checkFlag: true,
-            checkListId: data.checklistId,
-            checkListName: data.checkListName,
-            client_id: data.clientId,
-            teamName: teamDetails?.[0]?.teamName,
-            assignId: data?.id || teamDetails?.[0]?._id,
-            coverage: 'user',
-          };
-        } else {
-          let userIdList = teamDetails[0].users.map( ( ele ) => ele.userId );
-          let userDetails = await userService.find( { _id: userIdList } );
-          assignedData = userDetails.map( ( user ) => {
-            let userData = {
-              userId: user._id,
-              userName: user.userName,
-              userEmail: user.email,
-              userPhone: user.mobileNumber,
-              checkFlag: true,
-              checkListId: data.checklistId,
-              checkListName: data.checkListName,
-              client_id: data.clientId,
-              assignId: data?.id || teamDetails?.[0]?._id,
-              coverage: 'user',
-              teamName: teamDetails?.[0]?.teamName,
-            };
-            return userData;
-          } );
-        }
-      }
-    } else {
-      let query = [
-        {
-          $addFields: {
-            userEmail: { $toLower: '$email' },
-          },
-        },
-        {
-          $match: {
-            clientId: data.clientId,
-            ...( data?.id ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { userEmail: data.userEmail.toLowerCase() },
-          },
-        },
-      ];
-      // console.log( 'data?.userEmail=>', data.userEmail );
-      let userDetails = await userService.aggregate( query );
-      if ( !userDetails.length ) {
+    let teamDetails = await teamsServices.findteams( { clientId: data.clientId, _id: new mongoose.Types.ObjectId( data.id ) } );
+    if ( teamDetails.length ) {
+      let userIdList = teamDetails[0].users.map( ( ele ) => ele.userId );
+      let userDetails = await userService.find( { _id: userIdList } );
+      assignedData = userDetails.map( ( user ) => {
         let userData = {
-          userName: data?.userEmail?.split( '@' )[0],
-          email: data.userEmail,
-          clientId: data.clientId,
-        };
-        // console.log( userData, 'userData', data );
-        let details = await createUser( userData );
-        userDetails = [ details ];
-      }
-      if ( userDetails.length ) {
-        assignedData = {
-          userId: userDetails?.[0]?._id,
-          userName: userDetails?.[0]?.userName,
-          userEmail: userDetails?.[0]?.email,
-          userPhone: userDetails?.[0]?.mobileNumber,
-          checkFlag: true,
-          checkListId: data.checklistId,
-          checkListName: data.checkListName,
-          client_id: data.clientId,
-          assignId: data?.id || userDetails?.[0]?._id,
-          coverage: 'user',
+          userName: user.userName,
+          userEmail: user.email,
+          teamName: teamDetails?.[0]?.teamName,
+          id: teamDetails?.[0]?._id,
         };
-      }
+        return userData;
+      } );
     }
   }
-
-  if ( assignedData && data?.insert ) {
-    await assignedService.updateOne( { checkListId: assignedData.checkListId, assignId: assignedData.assignId }, assignedData );
-  } else {
-    return assignedData;
-  }
+  return assignedData;
 }
 
 export async function checklistAssign( req, res ) {
@@ -3767,20 +3653,9 @@ export async function checklistAssign( req, res ) {
       let assignedData = {
         ...data,
         clientId: req.body.clientId,
-        checkListName: checklistDetails.checkListName,
-        checklistId: checklistDetails._id,
-        coverage: req.body.coverage,
-        insert: false,
       };
-      // console.log( assignedData, 'daterthj' );
       let uploadData = await assignUsers( assignedData );
-      if ( uploadData ) {
-        if ( Array.isArray( uploadData ) ) {
-          uniqueArr.push( ...uploadData );
-        } else {
-          uniqueArr.push( uploadData );
-        }
-      }
+      uniqueArr.push( ...uploadData );
     } ) );
 
     return res.sendSuccess( { count: uniqueArr.length, uniqueArr } );
@@ -3790,3 +3665,82 @@ export async function checklistAssign( req, res ) {
   }
 }
 
+export async function updateAssign( req, res ) {
+  try {
+    if ( !req.body.assignedList.length && !req.body.assignedGroup.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let checklistDetails = await checklistService.findOne( { _id: req.body.checkListId, client_id: req.body.clientId } );
+    if ( !checklistDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    req.body.assignedGroup = [ ...new Set( req.body.assignedGroup.map( ( item ) => item.id ) ) ];
+    req.body.assignedGroup = req.body.assignedGroup.map( ( ele ) => {
+      return { id: ele };
+    } );
+    await assignedService.deleteMany( { checkListId: req.body.checkListId } );
+    let assignedUserList = [];
+    await Promise.all( req.body.assignedList.map( async ( assign ) => {
+      delete assign._id;
+      delete assign.id;
+      let query = [
+        {
+          $addFields: {
+            emailToLower: { $toLower: '$email' },
+          },
+        },
+        {
+          $match: {
+            clientId: req.body.clientId,
+            emailToLower: assign.userEmail.toLowerCase(),
+          },
+        },
+      ];
+      let userDetails = await userService.aggregate( query );
+      if ( !userDetails.length ) {
+        let userData = {
+          userName: assign.userName,
+          email: assign.userEmail,
+          mobileNumber: assign?.phone || '',
+          clientId: req.body.clientId,
+        };
+        userDetails = await createUser( userData );
+      }
+      let data = {
+        ...assign,
+        store_id: assign.storeId,
+        client_id: req.body.clientId,
+        checkListId: req.body.checkListId,
+        coverage: req.body.coverage,
+        assignId: assign._id,
+        userId: userDetails._id,
+        checkListName: checklistDetails.checkListName,
+      };
+      assignedUserList.push( data );
+    } ) );
+    await Promise.all( req.body.assignedGroup.map( async ( assign ) => {
+      let groupDetails;
+      if ( req.body.coverage == 'store' ) {
+        groupDetails = await clusterServices.findOneCluster( { _id: assign.id } );
+      } else {
+        groupDetails = await teamsServices.findOneTeams( { _id: assign.id } );
+      }
+      if ( groupDetails ) {
+        let groupData = {
+          client_id: req.body.clientId,
+          checkListId: req.body.checkListId,
+          coverage: req.body.coverage,
+          assignId: assign.id,
+          checkListName: checklistDetails.checkListName,
+          ...( req.body.coverage == 'store' ) ? { clusterName: groupDetails?.clusterName } : { teamName: groupDetails?.teamName },
+        };
+        assignedUserList.push( groupData );
+      }
+    } ) );
+    await assignedService.insertMany( assignedUserList );
+    return res.sendSuccess( 'Assign details updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateAssign', error: e } );
+    return res.sendError( e, 500 );
+  }
+}