tango-app-api-task 3.2.1-beta-41 → 3.2.1-hotfix-1

package/src/controllers/task.controller.js

@@ -8,9 +8,7 @@ import * as storeService from '../service/store.service.js';
 import * as traxApprover from '../service/approver.service.js';
 import * as processedChecklist from '../service/processedChecklist.service.js';
 import * as checklistassignconfigModel from '../service/checklistAssign.service.js';
-import * as clusterServices from '../service/cluster.service.js';
-import * as teamsServices from '../service/teams.service.js';
-// import * as clusterModel from '../service/cluster.service.js';
+import * as clusterModel from '../service/cluster.service.js';
 // import * as domainService from '../service/domain.service.js';
 import mongoose from 'mongoose';
 const ObjectId = mongoose.Types.ObjectId;
@@ -127,6 +125,38 @@ export async function createUpdateTask( req, res ) {
             } );
           } );
 
+          for ( let [ index, question ] of section.questions.entries() ) {
+            await processNested( index, question );
+          }
+
+          async function processNested( qIdx, question, nestedIndex = -1 ) {
+            if ( question?.answers?.length ) {
+              for ( let [ index, answer ] of question?.answers?.entries() ) {
+                if ( !section.questions[qIdx].answers[index]?.nestedQuestion && nestedIndex == -1 ) {
+                  section.questions[qIdx].answers[index].nestedQuestion = [];
+                }
+                if ( answer.showLinked ) {
+                  if ( nestedIndex != -1 ) {
+                    section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
+                  } else {
+                    section.questions[qIdx].answers[index].nestedQuestion.push( answer.linkedQuestion );
+                  }
+                  let nestedLinkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
+                  if ( nestedLinkedQuestion ) {
+                    let findNestedAnswers = nestedLinkedQuestion.answers.find( ( item ) => item.showLinked );
+                    if ( findNestedAnswers ) {
+                      if ( nestedIndex != -1 ) {
+                        await processNested( qIdx, nestedLinkedQuestion, nestedIndex );
+                      } else {
+                        await processNested( qIdx, nestedLinkedQuestion, index );
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+
           sectionList.push( {
             section: section?.name || 'Section 1',
             createdBy: req.user._id,
@@ -264,29 +294,9 @@ export async function taskDetails( req, res ) {
     }
     if ( storechecklistdetails ) {
       result.checkListDetails = { ...storechecklistdetails._doc };
-      let query = {
-        checkListId: storechecklistdetails._id,
-        ...( storechecklistdetails.coverage == 'store' ) ? { $or: [ { store_id: { $exists: true } }, { clusterName: { $exists: true } } ] } : { $or: [ { userEmail: { $exists: true } }, { teamName: { $exists: true } } ] },
-      };
-      let assignList = await taskAssignService.find( query, { _id: 1, store_id: 1, clusterName: 1, userEmail: 1, teamName: 1, assignId: 1 } );
-      let singleAssign;
-      let groupAssign;
-      if ( storechecklistdetails.coverage == 'store' ) {
-        singleAssign = assignList.filter( ( item ) => typeof item?.store_id != 'undefined' && item?.store_id != '' ).map( ( item ) => {
-          return { id: item.assignId, type: 'store' };
-        } );
-        groupAssign = assignList.filter( ( item ) => typeof item?.clusterName != 'undefined' && item?.clusterName != '' ).map( ( item ) => {
-          return { id: item.assignId, type: 'cluster' };
-        } );
-      } else {
-        singleAssign = assignList.filter( ( item ) => typeof item?.userEmail != 'undefined' && item?.userEmail !='' ).map( ( item ) => {
-          return { id: item.assignId, type: 'user' };
-        } );
-        groupAssign = assignList.filter( ( item ) => typeof item?.teamName != 'undefined' && item?.teamName != '' ).map( ( item ) => {
-          return { id: item.assignId, type: 'teams' };
-        } );
-      }
-      result.checkListDetails = { ...result.checkListDetails, ...{ sections: sectionList }, singleAssign, groupAssign };
+      let removedUsers = await taskAssignService.find( { checkFlag: false, checkListId: storechecklistdetails._id }, { _id: 1 } );
+      removedUsers = removedUsers?.map( ( item ) => item._id );
+      result.checkListDetails = { ...result.checkListDetails, ...{ sections: sectionList }, ...{ removedUsers: removedUsers } };
     }
     return res.sendSuccess( result );
   } catch ( e ) {
@@ -455,189 +465,6 @@ export async function validateUser( 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;
-
-    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.sendError( { validate: false, duplicates: duplicateStores, message: 'Store and email is duplicated' }, 400 );
-      }
-    } 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.sendError( { validate: false, duplicates: duplicateUsers, message: 'Email is Duplicated' }, 400 );
-      }
-    }
-
-    if ( req.body.hasOwnProperty( 'addSingle' ) ) {
-      let checkExists = await taskAssignService.findOne( { userEmail: assignDetails[0]?.userEmail, storeName: assignDetails[0]?.storeName, checkListId: req.body.id } );
-      if ( checkExists ) {
-        return res.sendError( 'User already Exists', 400 );
-      }
-    }
-
-    let userEmailList = assignDetails.map( ( item ) => item.userEmail?.trim()?.toLowerCase() );
-    let storeList = assignDetails.map( ( item ) => item?.storeName?.trim()?.toLowerCase() );
-
-    let userQuery = [
-      {
-        $project: {
-          newEmail: { $toLower: '$email' },
-          isActive: 1,
-          clientId: 1,
-          userName: 1,
-          email: 1,
-        },
-      },
-      {
-        $match: {
-          newEmail: { $in: userEmailList },
-          isActive: true,
-          clientId: req.body.clientId,
-        },
-      },
-    ];
-
-    let emailCheckQuery = [
-      {
-        $project: {
-          newEmail: { $toLower: '$email' },
-          isActive: 1,
-          clientId: 1,
-        },
-      },
-      {
-        $match: {
-          newEmail: { $in: userEmailList },
-          isActive: true,
-          clientId: { $ne: req.body.clientId },
-        },
-      },
-    ];
-
-    let storeQuery = [
-      {
-        $project: {
-          'store': { $toLower: '$storeName' },
-          'clientId': 1,
-          'storeProfile.city': 1,
-          'status': 1,
-          'storeId': 1,
-          'spocDetails': 1,
-          'storeName': 1,
-        },
-      },
-      {
-        $match: {
-          clientId: req.body.clientId,
-          store: { $in: storeList },
-        },
-      },
-    ];
-
-    let [ userDetails, storeDetails, existEmail ] = await Promise.all( [
-      await userService.aggregate( userQuery ),
-      await storeService.aggregate( storeQuery ),
-      await userService.aggregate( emailCheckQuery ),
-    ] );
-
-    existEmail = existEmail.map( ( ele ) => ele.newEmail );
-    let existUserEmail = userDetails.map( ( ele ) => ele.newEmail );
-    let newUserList = userEmailList.filter( ( ele ) => !existUserEmail.includes( ele ) && !existEmail.includes( ele ) );
-    let inActiveStores = storeDetails.filter( ( ele ) => ele.status == 'deactive' ).map( ( ele ) => ele.storeName );
-
-    let existsStore = storeDetails.map( ( ele ) => ele.storeName.toLowerCase() );
-    let newStoreList = storeList.filter( ( ele ) => ele != null && !existsStore.includes( ele.toLowerCase() ) );
-    if ( req.body.coverage == 'store' ) {
-      assignDetails.forEach( ( item ) => {
-        let getStoreDetails = storeDetails.find( ( store ) => store.storeName.toLowerCase() == item.storeName.toLowerCase() );
-        if ( getStoreDetails ) {
-          let storeUserDetails = userDetails.find( ( ele ) => ele.newEmail.toLowerCase() == item.userEmail.toLowerCase() );
-          item._id = getStoreDetails._id;
-          item.storeId = getStoreDetails.storeId;
-          item.userName = getStoreDetails?.spocDetails?.[0]?.email.toLowerCase() == item.userEmail.toLowerCase() ? getStoreDetails?.spocDetails?.[0]?.name : storeUserDetails?.email == item.userEmail.toLowerCase() ? storeUserDetails?.userName : item.userName;
-          item.storeName = getStoreDetails.storeName;
-          item.userEmail = storeUserDetails?.email || item.userEmail;
-        }
-      } );
-    } else {
-      assignDetails.forEach( ( item ) => {
-        let getUserDetails = userDetails.find( ( user ) => user.newEmail.toLowerCase() == item.userEmail.toLowerCase() );
-        if ( getUserDetails ) {
-          item._id = getUserDetails._id;
-          item.userName = getUserDetails.userName;
-          item.userEmail = getUserDetails.email;
-        }
-      } );
-    }
-
-    if ( ( newUserList.length || newStoreList.length || existEmail.length || inActiveStores.length ) && !req.body?.addUser ) {
-      return res.sendError( { validate: false, user: newUserList, store: newStoreList, existEmail, inActiveStores, data: assignDetails }, 400 );
-    }
-    await Promise.all( newUserList.map( async ( ele ) => {
-      let findUserIndex = assignDetails.findIndex( ( item ) => item?.userEmail?.toLowerCase() == ele?.toLowerCase() );
-      if ( findUserIndex != -1 ) {
-        let data = {
-          userName: assignDetails[findUserIndex]?.userName,
-          email: ele,
-          mobileNumber: assignDetails[findUserIndex]?.mobileNumber,
-          clientId: req.body.clientId,
-        };
-        let response = await createUser( data );
-        if ( req.body.coverage == 'user' ) {
-          assignDetails[findUserIndex]._id = response._id;
-        }
-      }
-    } ) );
-    return res.sendSuccess( { validate: true, data: assignDetails } );
-  } catch ( e ) {
-    logger.error( 'validateUser 2=>', e );
-    return res.sendError( e, 500 );
-  }
-};
-
 async function uploadUser( req, res ) {
   try {
     let inputBody = req.body;
@@ -768,76 +595,55 @@ export async function userDetails( req, res ) {
     if ( !req.query.taskId ) {
       return res.sendError( { message: 'Task Id is required' }, 400 );
     }
-    // let limit = parseInt( req.query.limit ) || 5;
-    // let page = parseInt( req.query.offset ) || 0;
-    // let skip = limit * page;
+    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.query.taskId ) } } ];
+    if ( req.query?.search?.trim() && req.query?.search?.trim() != '' ) {
+      let searchValue = req.query.search;
+      searchValue = searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
+      if ( searchValue.length > 1 ) {
+        query.push( { $addFields: { storeLower: { $toLower: '$storeName' } } } );
+        query.push( { $match: { storeLower: { $in: searchValue } } } );
+      } else {
+        query.push( { $match: { storeName: { $regex: req.query.search.trim(), $options: 'i' } } } );
+      }
+    }
 
-    let query = [ { $match: { checkListId: new ObjectId( req.query.taskId ), isdeleted: false } }, { $sort: { _id: -1 } } ];
+    query.push( {
+      $facet: {
+        data: [
+          { $skip: skip }, { $limit: limit },
+        ],
+        count: [
+          { $count: 'total' },
+        ],
+      },
+    } );
 
     let taskDetails = await taskAssignService.aggregate( query );
-    if ( !taskDetails.length ) {
+
+    if ( !taskDetails[0].data.length ) {
       return res.sendError( 'No data found', 204 );
     }
 
     let userDetails = [];
-    await Promise.all( taskDetails.map( async ( ele ) => {
-      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 ) }, status: 'active' } );
-          storeDetails.forEach( ( item ) => {
-            userDetails.push( {
-              id: ele.assignId,
-              userName: item.spocDetails?.[0]?.name,
-              userEmail: item.spocDetails?.[0]?.email,
-              storeId: 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.assignId,
-              userName: item.userName,
-              userEmail: item.email,
-              storeId: 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.assignId,
-          userName: ele.userName,
-          userEmail: ele.userEmail,
-          storeId: ele?.store_id,
-          storeName: ele?.storeName,
-          userPhone: ele.userPhone,
-          city: ele.city,
-          checkFlag: ele.checkFlag,
-          clusterName: ele?.clusterName || '',
-          teamName: ele?.teamName || '',
-        } );
-      }
-    } ) );
-
-    return res.sendSuccess( { count: userDetails.length, userDetails } );
+    taskDetails[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: taskDetails[0].count[0].total } );
   } catch ( e ) {
-    logger.error( 'userDetails =>', e );
+    logger.error( { functionName: 'userDetails', error: e, message: req.body } );
     return res.sendError( e, 500 );
   }
 };
@@ -845,22 +651,20 @@ export async function userDetails( req, res ) {
 export async function taskConfig( req, res ) {
   try {
     let inputBody = req.body;
+    let storeCount = 0;
+    let locationCount = 0;
     let checklistDetails;
     inputBody.client_id = inputBody.clientId;
     if ( !inputBody._id ) {
       return res.sendError( { message: 'Task Id is Required' }, 400 );
     }
 
-    if ( !inputBody.assignedUsers.length && inputBody.submitType == 'publish' ) {
-      return res.sendError( 'Please Assigned a user', 400 );
+    if ( inputBody.submitType == 'publish' ) {
+      let checkUserAssigned = await taskAssignService.findOne( { checkListId: inputBody._id, checkFlag: true } );
+      if ( !checkUserAssigned ) {
+        return res.sendError( { message: 'Please assign a user' }, 400 );
+      }
     }
-
-    // if ( inputBody.submitType == 'publish' ) {
-    //   let checkUserAssigned = await taskAssignService.findOne( { checkListId: inputBody._id, checkFlag: true } );
-    //   if ( !checkUserAssigned ) {
-    //     return res.sendError( { message: 'Please assign a user' }, 400 );
-    //   }
-    // }
     if ( !inputBody?.approver.length && inputBody.submitType == 'publish' ) {
       return res.sendError( { message: 'Please assign approver' }, 400 );
     }
@@ -878,7 +682,7 @@ export async function taskConfig( req, res ) {
     };
     await checklistLogs.create( logInsertData );
 
-    checklistDetails = await taskService.findOne( { _id: inputBody._id, isdeleted: false, client_id: inputBody.clientId } );
+    checklistDetails = await taskService.findOne( { _id: inputBody._id, isdeleted: false } );
 
     if ( !checklistDetails ) {
       return res.sendError( 'No data found', 204 );
@@ -916,7 +720,39 @@ export async function taskConfig( req, res ) {
         await traxApprover.insertMany( data );
       }
     }
+    await taskAssignService.updateMany( { checkListId: inputBody._id }, { checkFlag: true } );
+    if ( inputBody.removedUsers.length ) {
+      await taskAssignService.updateMany( { _id: { $in: inputBody.removedUsers } }, { checkFlag: false } );
+    }
     let storeConfigDetails = await taskAssignService.find( { checkListId: inputBody._id, checkFlag: true }, { _id: 0, store_id: 1, userEmail: 1, storeName: 1 } );
+    let storeList = storeConfigDetails.map( ( store ) => store.store_id );
+
+    storeCount = storeList.length;
+    if ( storeList.length ) {
+      let query = [
+        {
+          $match: {
+            client_id: inputBody.client_id,
+            id: { $in: storeList },
+            city: { $exists: true },
+          },
+        },
+        {
+          $group: {
+            _id: '$city',
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            city: '$_id',
+          },
+        },
+      ];
+      let storeDetails = await storeService.aggregate( query );
+      locationCount = storeDetails.length;
+    }
+    await taskService.updateOne( { _id: inputBody._id }, { storeCount, locationCount } );
     if ( inputBody.submitType == 'publish' ) {
       let taskName = checklistDetails.checkListName;
       let dueDate = dayjs( configDetails.scheduleEndTimeISO ).format( 'YYYY-MM-DD hh:mm A' );
@@ -1009,7 +845,6 @@ export async function insertSingleProcessData( checklistId ) {
       insertdata.remainder = getCLconfig?.remainder || [];
       insertdata.approver = getCLconfig?.approver || [];
       insertdata.restrictAttendance = getCLconfig?.restrictAttendance;
-      insertdata.coverage = getCLconfig?.coverage;
       let collectSections = [];
       let sectionQuery = [];
       sectionQuery.push( {
@@ -1075,6 +910,7 @@ export async function insertSingleProcessData( checklistId ) {
             await taskProcessedConfigService.updateOne( { _id: checklistDetails._id }, insertDataPerDay );
             updatedchecklist = checklistDetails;
           }
+
           if ( updatedchecklist ) {
             await insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, dateVal, startTimeIso, endTimeIso, insertdata );
           }
@@ -1090,13 +926,16 @@ export async function insertSingleProcessData( checklistId ) {
 
 async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date, startTimeIso, endTimeIso, insertdata ) {
   let getquestionQuery = [];
+
   if ( dayjs( getCLconfig.publishDate ).format( 'YYYY-MM-DD' ) != dayjs( date ).format( 'YYYY-MM-DD' ) ) {
     let todayDate = `${dayjs( date ).format( 'YYYY-MM-DD' )} 00:00 AM`;
     startTimeIso = dayjs.utc( todayDate, 'YYYY-MM-DD HH:mm A' );
   }
+
   getquestionQuery.push( {
     $match: {
       checkListId: new ObjectId( checklistId ),
+      checkFlag: true,
       isdeleted: false,
     },
   } );
@@ -1105,109 +944,7 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
 
   if ( allQuestion ) {
     let userIdList = [];
-    let assignList = [];
-    let assignUserList = [];
-    if ( getCLconfig.coverage == 'store' ) {
-      let clusterList = allQuestion.filter( ( ele ) => ele?.clusterName ).map( ( item ) => item.assignId );
-      if ( clusterList.length ) {
-        let clusterDetails = await clusterServices.findcluster( { _id: { $in: clusterList } } );
-        if ( clusterDetails.length ) {
-          let idList = clusterDetails.flatMap( ( item ) => item.stores.map( ( ele ) => ele.store ) );
-          let getStoreDetails = await storeService.find( { _id: { $in: idList }, status: 'active' } );
-          if ( getStoreDetails.length ) {
-            getStoreDetails = getStoreDetails.filter( ( store ) => {
-              let findStore = allQuestion.find( ( storeList ) => storeList.assignId.toString() == store._id.toString() );
-              if ( findStore ) {
-                return store?.spocDetails?.[0]?.email.toLowerCase() != findStore.userEmail.toLowerCase();
-              } else {
-                return true;
-              }
-            } );
-            assignList = await Promise.all( getStoreDetails.map( async ( store ) => {
-              let userQuery = [
-                {
-                  $project: {
-                    newEmail: { $toLower: '$email' },
-                    isActive: 1,
-                    clientId: 1,
-                    userName: 1,
-                    email: 1,
-                  },
-                },
-                {
-                  $match: {
-                    newEmail: store?.spocDetails?.[0]?.email.toLowerCase(),
-                    isActive: true,
-                    clientId: store.clientId,
-                  },
-                },
-              ];
-              let userDetails = await userService.aggregate( userQuery );
-              if ( !userDetails.length ) {
-                let data = {
-                  clientId: store.clientId,
-                  userName: store.spocDetails?.[0]?.name,
-                  mobileNumber: store.spocDetails?.[0]?.phone || '',
-                  email: store.spocDetails[0].email,
-                };
-                userDetails = await createUser( data );
-                userDetails = [ userDetails ];
-              }
-              let data = {
-                store_id: store?.storeId,
-                storeName: store?.storeName,
-                userId: userDetails?.[0]?._id,
-                userName: userDetails?.[0]?.userName,
-                userEmail: userDetails?.[0]?.email,
-                userPhone: userDetails?.[0]?.mobileNumber,
-                city: store?.storeProfile?.city,
-                country: store?.storeProfile?.country,
-                checkFlag: true,
-                checkListId: getCLconfig._id,
-                checkListName: getCLconfig.checkListName,
-                client_id: getCLconfig.client_id,
-              };
-              return data;
-            } ) );
-          }
-        }
-      }
-      allQuestion = allQuestion.filter( ( ele ) => !clusterList.includes( ele.assignId ) );
-    }
-    if ( getCLconfig.coverage == 'user' ) {
-      let teamsList = allQuestion.filter( ( ele ) => ele?.teamName ).map( ( item ) => item.assignId );
-      if ( teamsList.length ) {
-        let teamDetails = await teamsServices.findteams( { _id: { $in: teamsList } } );
-        if ( teamDetails.length ) {
-          let idList = teamDetails.flatMap( ( item ) => item.users.map( ( ele ) => ele.userId ) );
-          let userIdList = allQuestion.filter( ( qn ) => !qn?.teamName ).map( ( qn ) => qn.assignId.toString() );
-          idList = idList.filter( ( id ) => !userIdList.includes( id.toString() ) );
-          let getUserDetails = await userService.find( { _id: { $in: idList } } );
-          if ( getUserDetails.length ) {
-            assignList = getUserDetails.map( ( user ) => {
-              let data = {
-                store_id: '',
-                storeName: '',
-                userId: user._id,
-                userName: user.userName,
-                userEmail: user.email,
-                userPhone: user?.mobileNumber,
-                city: '',
-                country: '',
-                checkFlag: true,
-                checkListId: getCLconfig._id,
-                checkListName: getCLconfig.checkListName,
-                client_id: getCLconfig.client_id,
-              };
-              return data;
-            } );
-          }
-        }
-      }
-      allQuestion = allQuestion.filter( ( ele ) => !teamsList.includes( ele.assignId ) );
-    }
-    allQuestion = [ ...allQuestion, ...assignList ];
-    await Promise.all( allQuestion.map( async ( element4 ) => {
+    for ( let element4 of allQuestion ) {
       let query;
       query = {
         date_string: dayjs( date ).format( 'YYYY-MM-DD' ),
@@ -1223,45 +960,43 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
       let getsubmitDetails = await taskProcessedService.find( query );
       if ( getsubmitDetails.length ) {
         userIdList.push( element4._id );
-      } else {
-        delete element4._id;
-        delete element4.checkFlag;
-        delete element4.isdeleted;
-        delete element4.createdAt;
-        delete element4.updatedAt;
-        element4.checkListId = updatedchecklist._id;
-        element4.checkListName = getCLconfig.checkListName;
-        element4.checkListDescription = getCLconfig.checkListDescription;
-        element4.date_iso = new Date( dayjs( date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) );
-        element4.date_string = dayjs( date ).format( 'YYYY-MM-DD' );
-        element4.allowedOverTime = false;
-        element4.allowedStoreLocation = getCLconfig.allowedStoreLocation;
-        element4.scheduleStartTime = '12:00 AM';
-        element4.scheduleStartTime_iso = startTimeIso.format();
-        element4.scheduleEndTime = getCLconfig.scheduleEndTime;
-        element4.scheduleEndTime_iso = endTimeIso.format();
-        element4.createdBy = new ObjectId( getCLconfig.createdBy );
-        element4.createdByName = getCLconfig.createdByName;
-        element4.sourceCheckList_id = getCLconfig._id;
-        element4.checkListType = getCLconfig.checkListType;
-        element4.storeCount = getCLconfig.storeCount;
-        element4.questionCount = getCLconfig.questionCount;
-        element4.publishDate = getCLconfig.publishDate;
-        element4.locationCount = getCLconfig.locationCount;
-        element4.scheduleRepeatedType = 'daily';
-        element4.approvalEnable = getCLconfig.approver.length ? true : false;
-        element4.priorityType = getCLconfig.priorityType;
-        element4.remainder = getCLconfig?.remainder || [];
-        element4.restrictAttendance = getCLconfig?.restrictAttendance;
-        element4.coverage = getCLconfig?.coverage;
-        assignUserList.push( element4 );
-      }
-    } ) );
+        continue;
+      }
+      delete element4._id;
+      delete element4.checkFlag;
+      delete element4.isdeleted;
+      delete element4.createdAt;
+      delete element4.updatedAt;
+      element4.checkListId = updatedchecklist._id;
+      element4.checkListName = getCLconfig.checkListName;
+      element4.checkListDescription = getCLconfig.checkListDescription;
+      element4.date_iso = new Date( dayjs( date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) );
+      element4.date_string = dayjs( date ).format( 'YYYY-MM-DD' );
+      element4.allowedOverTime = false;
+      element4.allowedStoreLocation = getCLconfig.allowedStoreLocation;
+      element4.scheduleStartTime = '12:00 AM';
+      element4.scheduleStartTime_iso = startTimeIso.format();
+      element4.scheduleEndTime = getCLconfig.scheduleEndTime;
+      element4.scheduleEndTime_iso = endTimeIso.format();
+      element4.createdBy = new ObjectId( getCLconfig.createdBy );
+      element4.createdByName = getCLconfig.createdByName;
+      element4.sourceCheckList_id = getCLconfig._id;
+      element4.checkListType = getCLconfig.checkListType;
+      element4.storeCount = getCLconfig.storeCount;
+      element4.questionCount = getCLconfig.questionCount;
+      element4.publishDate = getCLconfig.publishDate;
+      element4.locationCount = getCLconfig.locationCount;
+      element4.scheduleRepeatedType = 'daily';
+      element4.approvalEnable = getCLconfig.approver.length ? true : false;
+      element4.priorityType = getCLconfig.priorityType;
+      element4.remainder = getCLconfig?.remainder || [];
+      element4.restrictAttendance = getCLconfig?.restrictAttendance;
+    }
     if ( userIdList.length ) {
-      assignUserList = assignUserList.filter( ( item ) => typeof item._id == 'undefined' );
+      allQuestion = allQuestion.filter( ( item ) => typeof item._id == 'undefined' );
     }
 
-    if ( assignUserList ) {
+    if ( allQuestion ) {
       let assigndeletequery = {
         date_iso: date,
         client_id: insertdata.client_id,
@@ -1284,7 +1019,7 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
 
       const taskToRetain = await taskProcessedService.find( retainTaskQuery );
 
-      const insertList = assignUserList.filter( ( item2 ) =>
+      const insertList = allQuestion.filter( ( item2 ) =>
         !taskToRetain.some( ( item1 ) =>
           item1.store_id === item2.store_id && item1.userEmail === item2.userEmail,
         ),
@@ -1350,7 +1085,6 @@ export async function uploadImage( req, res ) {
 
 async function createUser( data ) {
   try {
-    console.log( 'createUser ====>', data );
     let params = {
       userName: data.userName,
       email: data.email,
@@ -1433,8 +1167,7 @@ async function createUser( data ) {
       ],
     };
     let response = await userService.create( params );
-    // console.log( 'createUser ====>', response );
-    return response;
+    return response._id;
   } catch ( e ) {
     logger.error( 'createUser =>', e );
     return false;
@@ -1634,17 +1367,16 @@ export async function createChecklistTask( req, res ) {
         client_id: inputBody.clientId,
       };
       await taskQuestionService.create( question );
-      let storeDetails;
-      if ( inputBody?.storeName ) {
-        storeDetails = await storeService.findOne( { storeName: inputBody.storeName, status: 'active' }, { storeId: 1, storeProfile: 1 } );
+      let storeDetails = await storeService.findOne( { storeName: inputBody.storeName, status: 'active' }, { storeId: 1, storeProfile: 1 } );
+      if ( !storeDetails ) {
+        return res.sendError( 'No data found', 204 );
       }
-
       let userDetails = {
         userName: inputBody.userName,
         userEmail: inputBody.userEmail,
-        store_id: storeDetails?.storeId?storeDetails.storeId:'',
-        storeName: inputBody?.storeName?inputBody?.storeName:'',
-        city: storeDetails?.storeProfile?.city?storeDetails?.storeProfile?.city:'',
+        store_id: storeDetails.storeId,
+        storeName: inputBody.storeName,
+        city: storeDetails?.storeProfile?.city,
         checkFlag: true,
         checkListId: response?._id,
         checkListName: data.checkListName,
@@ -1663,9 +1395,8 @@ export async function createChecklistTask( req, res ) {
         if ( sectionIndex == -1 ) {
           return res.sendError( 'section is not found', 400 );
         }
-        let findQuestion = question[sectionIndex].questions.findIndex( ( ele ) => ele?.parentQuestion ? ele.qno == req.body.qno && ele.parentQuestion == req.body.parentQuestion : ele.qno == req.body.qno );
+        let data = { ...question[sectionIndex].questions[req.body.qno - 1], taskId: response?._id, task: true };
 
-        let data = { ...question[sectionIndex].questions[findQuestion], taskId: response?._id, task: true };
         question[sectionIndex].questions[req.body.qno - 1] = data;
         taskDetails.questionAnswers = question;
         let updateData = {
@@ -1678,7 +1409,6 @@ export async function createChecklistTask( req, res ) {
             _id: inputBody.processedChecklistId,
             section_id: inputBody.sectionId,
             qno: inputBody.qno,
-            parentQuestion: inputBody.parentQuestion,
           },
           'upsert': {
             taskId: String( response?._id ),
@@ -1738,7 +1468,6 @@ export async function approveTask( req, res ) {
             sourceCheckList_id: req.body.sourceCheckList_id,
             fromDate: req.body.fromDate,
             toDate: req.body.toDate,
-            filtertype: req.body.filtertype,
             store_id: inputstores,
           },
           'upsert': {
@@ -1816,7 +1545,6 @@ export async function redoTask( req, res ) {
     };
 
     let response = await taskProcessedService.updateOne( { _id: req.body.payload._id }, updateData );
-    console.log( response );
     if ( response.modifiedCount || response.matchedCount ) {
       let storeTimeZone = await storeService.findOne( { storeName: taskDetails.storeName }, { 'storeProfile.timeZone': 1 } );
       let currentDateTime;
@@ -1833,8 +1561,8 @@ export async function redoTask( req, res ) {
         sectionName: question[sectionIndex].sectionName,
         questionName: question[sectionIndex].questions[req.body.payload.qno - 1].qname,
         action: 'redo',
-        store_id: taskDetails?.store_id?taskDetails?.store_id:'',
-        storeName: taskDetails.storeName?taskDetails.storeName:'',
+        store_id: taskDetails.store_id,
+        storeName: taskDetails.storeName,
         client_id: taskDetails.client_id,
         processedChecklistId: taskDetails._id,
         type: taskDetails.checkListType,
@@ -1856,7 +1584,6 @@ export async function redoTask( req, res ) {
       };
       let url = JSON.parse( process.env.LAMBDAURL );
       let searchResponse = await fetch( url.redoTask, requestOptions );
-      console.log( searchResponse.ok );
       if ( searchResponse.ok ) {
         return res.sendSuccess( 'Question redo successfully' );
       } else {
@@ -1929,19 +1656,15 @@ export async function getAnswerCount( req, res ) {
 export const taskDropdown = async ( req, res ) => {
   try {
     let requestData = req.body;
-    let fromDate = new Date( requestData.fromDate );
-    let toDate = new Date( requestData.toDate );
-    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
-    toDate = new Date( toDate.getTime() - userTimezoneOffset );
-    toDate.setUTCHours( 23, 59, 59, 59 );
+
     let result = {};
 
     let findQuery = [];
     let findAndQuery = [];
     findAndQuery.push(
         { client_id: requestData.clientId },
-        { date_iso: { $gte: fromDate } },
-        { date_iso: { $lte: toDate } },
+        // { date_iso: { $gte: fromDate } },
+        // { date_iso: { $lte: toDate } },
         { checkListType: { $in: [ 'task', 'checklistTask', 'cctv' ] } },
     );
 
@@ -1957,7 +1680,6 @@ export const taskDropdown = async ( req, res ) => {
         scheduleRepeatedType: 1,
         scheduleStartTime: 1,
         scheduleEndTime: 1,
-        coverage: 1,
       },
     } );
 
@@ -1972,7 +1694,6 @@ export const taskDropdown = async ( req, res ) => {
         scheduleRepeatedType: { $last: '$scheduleRepeatedType' },
         scheduleStartTime: { $last: '$scheduleStartTime' },
         scheduleEndTime: { $last: '$scheduleEndTime' },
-        coverage: { $last: '$coverage' },
       },
     } );
 
@@ -2011,7 +1732,6 @@ export const taskDropdown = async ( req, res ) => {
         scheduleRepeatedType: 1,
         scheduleStartTime: 1,
         scheduleEndTime: 1,
-        coverage: 1,
         checkListDescription: '$checklistconfigs.checkListDescription',
         publish: '$checklistconfigs.publish',
       },
@@ -2447,13 +2167,13 @@ export async function clusterMigrations( req, res ) {
       if ( userexits ) {
         let findStore = await storeService.findOne( { storeName: user.FacilityCode } );
         if ( findStore ) {
-          let clusterExists = await clusterServices.findOneCluster( { clusterName: user.AomName } );
+          let clusterExists = await clusterModel.findOneCluster( { clusterName: user.AomName } );
           if ( clusterExists ) {
             let data = {
               storeId: findStore.storeId,
               store: findStore._id,
             };
-            let updatecluster = await clusterServices.updateCluster( { clusterName: user.AomName }, { $push: { stores: data } } );
+            let updatecluster = await clusterModel.updateCluster( { clusterName: user.AomName }, { $push: { stores: data } } );
             console.log( updatecluster );
           } else {
             let payload = {
@@ -2475,7 +2195,7 @@ export async function clusterMigrations( req, res ) {
               ],
               'users': [],
             };
-            let createcluster = await clusterServices.createclusterModel( payload );
+            let createcluster = await clusterModel.createclusterModel( payload );
             console.log( createcluster );
           }
         }
@@ -2860,216 +2580,9 @@ export async function StoreHygienetask( req, res ) {
     return res.sendError( e, 500 );
   }
 }
-export async function commonAiTask( req, res ) {
-  try {
-    let inputBody = req.body;
-
-    inputBody.clientId = 11;
-    inputBody.taskDescription = '';
-    let userId;
-    let storeDetails = await storeService.findOne( { storeName: inputBody.storeName, clientId: inputBody.clientId, status: 'active' }, { storeId: 1, storeName: 1, storeProfile: 1 } );
-    if ( !storeDetails ) {
-      return res.sendError( 'Store Not Found', 500 );
-    }
-
-    let url = JSON.parse( process.env.LAMBDAURL );
-    let checklistId = url.dailystoreChecklistId;
-    let finduser = await checklistassignconfigModel.findOne( { checkListId: new mongoose.Types.ObjectId( checklistId ), store_id: storeDetails.storeId } );
-
-    if ( !finduser ) {
-      return res.sendError( 'No user Found For this store', 500 );
-    }
-
-    userId = finduser.userId;
-    inputBody.userName = finduser.userName;
-    inputBody.userEmail = finduser.userEmail;
-
-
-    let teamList = await findteams( { users: { $elemMatch: { email: finduser.userEmail } } } );
-
-    inputBody.approver = '';
-    for ( let team of teamList ) {
-      for ( let user of team.Teamlead ) {
-        inputBody.approver = user.email + ',' + inputBody.approver;
-      }
-    }
-    inputBody.approver = inputBody.approver.replace( /,$/, '' );
-
-
-    let title = `New Task Alert ${inputBody.taskName}-${storeDetails.storeName}-${dayjs().format( 'YYYY-MM-DD' )}`;
-    let time = inputBody?.scheduleEndTime || '11:59 PM';
-    let date = inputBody?.scheduleDate || dayjs().format( 'YYYY-MM-DD' );
-    let description = `A new task has been assigned to ${storeDetails.storeName}. Please complete it before the due date of ${date}.`;
-    if ( userDetails&&userDetails.fcmToken ) {
-      const fcmToken = userDetails.fcmToken;
-      await sendPushNotification( title, description, fcmToken );
-    }
-    const inputDateTime = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' );
-    const currentTime = dayjs.utc();
-    if ( inputDateTime.isBefore( currentTime ) ) {
-      return res.sendError( 'The input date-time is before the current time.', 500 );
-    }
-
-    let approverList = inputBody?.approver.split( ',' );
-
-
-    let userAdmin = await userService.find( { clientId: inputBody.clientId, email: { $in: approverList }, userType: 'client', isActive: true }, { name: '$userName', email: 1 } );
-
-    if ( userAdmin && userAdmin.length === 0 ) {
-      userAdmin = await userService.find( { clientId: inputBody.clientId, email: 'rohit.chawla@lenskart.com', userType: 'client', isActive: true }, { name: '$userName', email: 1 } );
-    }
-
-    let creator = await userService.find( { clientId: inputBody.clientId, email: 'rohit.chawla@lenskart.com', userType: 'client', isActive: true } );
-    if ( creator && creator.length === 0 ) {
-      return res.sendError( 'Invalid Creator Details', 500 );
-    }
-
-    if ( req.body && req.body.referenceImage && req.body.referenceImage.length > 3 ) {
-      return res.sendError( 'Maximum 3 referenceImage only allowed', 500 );
-    }
-    let data = {
-      checkListName: `${inputBody.taskName}(${storeDetails.storeName}-${dayjs().format( 'YYYY-MM-DD' )})`,
-      checkListDescription: inputBody.taskDescription,
-      createdBy: creator[0]._id,
-      createdByName: creator[0].userName,
-      publish: true,
-      questionCount: 1,
-      storeCount: 1,
-      scheduleDate: date,
-      scheduleEndTime: time,
-      scheduleEndTimeISO: dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' ).format(),
-      priorityType: 'high',
-      client_id: inputBody.clientId,
-      checkListType: 'task',
-      publishDate: new Date(),
-      locationCount: 1,
-      ...( inputBody?.checkListId ) ? { referenceCheckListId: inputBody?.checkListId } : {},
-    };
-    data['approver'] = userAdmin;
-    let answer = await findAnswer( inputBody?.answerType );
-    if ( answer.length == 0 ) {
-      return res.sendError( 'please enter Valid AnswerType', 500 );
-    }
-    if ( inputBody?.answerType === 'multiplechoicesingle' || inputBody?.answerType === 'multiplechoicemultiple' ) {
-      if ( inputBody?.options && inputBody?.options.length > 0 ) {
-        let optionsResult = [];
-        let optionList = inputBody?.options.split( ',' );
-        for ( let option of optionList ) {
-          let optiondata = {
-            'answer': '',
-            'sopFlag': false,
-            'validation': false,
-            'validationType': '',
-            'referenceImage': [],
-            'runAI': false,
-            'allowUploadfromGallery': false,
-            'descriptivetype': '',
-            'showLinked': false,
-            'linkedQuestion': 0,
-            'nestedQuestion': [],
-          };
-          optiondata.answer = option;
-          optionsResult.push( optiondata );
-        }
-        answer = optionsResult;
-      } else {
-        return res.sendError( 'please enter Valid Options', 500 );
-      }
-    }
-    let response = await taskService.create( data );
-    if ( response?.approver.length ) {
-      let inputData = [];
-      response?.approver.forEach( ( ele ) => {
-        inputData.push( {
-          userEmail: ele.email,
-          checkListId: response._id,
-          type: 'task',
-          client_id: inputBody.clientId,
-          checkListName: data?.checkListName || '',
-        } );
-      } );
-      await traxApprover.insertMany( inputData );
-    }
-    if ( response?._id ) {
-      let question = [
-        {
-          'qno': 1,
-          'qname': inputBody.question,
-          'answerType': inputBody?.answerType || 'yes/no',
-          'runAI': false,
-          'runAIDescription': '',
-          'allowUploadfromGallery': false,
-          'linkType': false,
-          'questionReferenceImage': [],
-          'answers': answer,
-          'descriptivetype': 'text',
-        },
-      ];
-      let images = [];
-      for ( let imgpath of req.body.referenceImage ) {
-        let configURL = JSON.parse( process.env.BUCKET );
-        let inputData = {
-          Bucket: configURL.commonAiTaskBucket,
-          Key: imgpath,
-        };
-        let output = await getObject( inputData );
-        console.log( output );
-
-        let image = {
-          data: output.Body,
-          name: imgpath,
-          mimetype: output.ContentType,
-        };
-        let uplaodedImage = await uploadmultiImage( image );
-
-        let imgUrl = decodeURIComponent( uplaodedImage.imgUrl.split( '?' )[0] );
-        let url = imgUrl.split( '/' );
-        if ( url.includes( 'https:' ) || url.includes( 'http:' ) ) {
-          url.splice( 0, 3 );
-        }
-        images.push( url.join( '/' ) );
-      }
-      question[0].questionReferenceImage = images;
-
-      if ( inputBody?.answerType === 'image' || inputBody?.answerType === 'descriptiveImage' || inputBody?.answerType === 'multipleImage' ) {
-        answer[0].referenceImage = question[0].questionReferenceImage;
-      }
-
-
-      question = {
-        checkListId: response?._id,
-        question: question,
-        section: 'Section 1',
-        checkList: data.checkListName,
-        client_id: inputBody.clientId,
-      };
-      await taskQuestionService.create( question );
-
-      let userDetails = {
-        userName: inputBody.userName,
-        userEmail: inputBody.userEmail,
-        store_id: storeDetails.storeId,
-        storeName: storeDetails.storeName,
-        city: storeDetails?.storeProfile?.city,
-        checkFlag: true,
-        checkListId: response?._id,
-        checkListName: data.checkListName,
-        client_id: inputBody.clientId,
-        userId: userId,
-      };
-      await taskAssignService.create( userDetails );
-      await insertSingleProcessData( response?._id );
-      return res.sendSuccess( 'Task created successfully' );
-    }
-  } catch ( e ) {
-    logger.error( { function: 'commonAiTask', error: e } );
-    return res.sendError( e, 500 );
-  }
-}
 export async function eyeTesttask( req, res ) {
   try {
     let inputBody = req.body;
-    console.log( inputBody );
     inputBody.clientId = 11;
     inputBody.taskDescription = '';
     let userId;
@@ -3080,9 +2593,7 @@ export async function eyeTesttask( req, res ) {
 
     let url = JSON.parse( process.env.LAMBDAURL );
     let checklistId = url.dailystoreChecklistId;
-    console.log( checklistId );
     let finduser = await checklistassignconfigModel.findOne( { checkListId: new mongoose.Types.ObjectId( checklistId ), store_id: storeDetails.storeId } );
-    console.log( finduser );
 
     if ( !finduser ) {
       return res.sendError( 'No user Found For this store', 500 );
@@ -3241,10 +2752,8 @@ export async function eyeTesttask( req, res ) {
         }
         question[0].questionReferenceImage = images;
       } else {
-        console.log( req.file );
         let images = [];
         let uplaodedImage = await uploadmultiImage( req.files.referenceImage );
-        console.log( uplaodedImage );
         let imgUrl = decodeURIComponent( uplaodedImage.imgUrl.split( '?' )[0] );
         let url = imgUrl.split( '/' );
         if ( url.includes( 'https:' ) || url.includes( 'http:' ) ) {
@@ -3313,14 +2822,14 @@ export async function createAiTask( req, res ) {
     inputBody.userEmail = finduser.userEmail;
 
 
-    let title = `New Task Alert ${inputBody.taskName}-${storeDetails.storeName}-${dayjs().format( 'YYYY-MM-DD' )}`;
+    // let title = `New Task Alert ${inputBody.taskName}-${storeDetails.storeName}-${dayjs().format( 'YYYY-MM-DD' )}`;
     let time = inputBody?.scheduleEndTime || '11:59 PM';
     let date = inputBody?.scheduleDate || dayjs().format( 'YYYY-MM-DD' );
-    let description = `A new task has been assigned to ${storeDetails.storeName}. Please complete it before the due date of ${date}.`;
-    if ( userDetails&&userDetails.fcmToken ) {
-      const fcmToken = userDetails.fcmToken;
-      await sendPushNotification( title, description, fcmToken );
-    }
+    // let description = `A new task has been assigned to ${storeDetails.storeName}. Please complete it before the due date of ${date}.`;
+    // if ( userDetails&&userDetails.fcmToken ) {
+    //   const fcmToken = userDetails.fcmToken;
+    //   await sendPushNotification( title, description, fcmToken );
+    // }
     const inputDateTime = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' );
     const currentTime = dayjs.utc();
     if ( inputDateTime.isBefore( currentTime ) ) {
@@ -3758,43 +3267,6 @@ export async function uploadmultiImage( images ) {
   }
 };
 
-async function assignUsers( data ) {
-  let assignedData;
-  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 {
-    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: user.userName,
-          userEmail: user.email,
-          teamName: teamDetails?.[0]?.teamName,
-          id: teamDetails?.[0]?._id,
-        };
-        return userData;
-      } );
-    }
-  }
-  return assignedData;
-}
 
 export async function customertrial( params ) {
   try {
@@ -3820,145 +3292,3 @@ export async function customertrial( params ) {
   }
 };
 
-export async function taskAssign( req, res ) {
-  try {
-    if ( !req.body.taskId ) {
-      return res.sendError( 'task id is required', 400 );
-    }
-    if ( !req.body.coverage ) {
-      return res.sendError( 'Coverage is required', 400 );
-    }
-    if ( !req.body.idList ) {
-      return res.sendError( 'Id is required', 400 );
-    }
-
-    let taskDetails = await taskService.findOne( { _id: req.body.taskId } );
-    if ( !taskDetails ) {
-      return res.sendError( 'No data found', 204 );
-    }
-
-    let uniqueArr = [];
-
-    await Promise.all( req.body.idList.map( async ( data ) => {
-      let assignedData = {
-        ...data,
-        clientId: req.body.clientId,
-      };
-      let uploadData = await assignUsers( assignedData );
-      if ( uploadData?.length ) {
-        uniqueArr.push( ...uploadData );
-      }
-    } ) );
-
-    if ( uniqueArr.length ) {
-      if ( req.body.coverage == 'store' ) {
-        uniqueArr = uniqueArr.reduce( ( acc, obj ) => {
-          if ( acc[obj.storeName] ) {
-            acc[obj.storeName].clusterName += ',' + obj.clusterName;
-          } else {
-            acc[obj.storeName] = { ...obj };
-          }
-          return acc;
-        }, {} );
-
-        uniqueArr= Object.values( uniqueArr );
-      } else {
-        uniqueArr = uniqueArr.reduce( ( acc, obj ) => {
-          if ( acc[obj.userEmail] ) {
-            acc[obj.userEmail].teamName += ','+ obj.teamName;
-          } else {
-            acc[obj.userEmail] = { ...obj };
-          }
-          return acc;
-        }, {} );
-        uniqueArr = Object.values( uniqueArr );
-      }
-    }
-
-    return res.sendSuccess( { count: uniqueArr.length, uniqueArr } );
-  } catch ( e ) {
-    logger.error( { functionName: 'taskAssign', error: e } );
-    return res.sendError( e, 500 );
-  }
-}
-
-export async function updateAssign( req, res ) {
-  try {
-    // if ( !req.body.assignedList.length && !req.body.assignedGroup.length ) {
-    //   return res.sendError( 'No data found', 204 );
-    // }
-    let taskDetails = await taskService.findOne( { _id: req.body.taskId, client_id: req.body.clientId } );
-    if ( !taskDetails ) {
-      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 taskAssignService.deleteMany( { checkListId: req.body.taskId } );
-    let assignedUserList = [];
-    await Promise.all( req.body.assignedList.map( async ( assign ) => {
-      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 );
-        userDetails = [ userDetails ];
-      }
-      let data = {
-        ...assign,
-        store_id: assign?.storeId,
-        client_id: req.body.clientId,
-        checkListId: req.body.taskId,
-        coverage: req.body.coverage,
-        assignId: assign._id,
-        userId: userDetails?.[0]?._id,
-        checkListName: taskDetails.checkListName,
-      };
-      delete data._id;
-      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.taskId,
-          coverage: req.body.coverage,
-          assignId: assign.id,
-          checkListName: taskDetails.checkListName,
-          ...( req.body.coverage == 'store' ) ? { clusterName: groupDetails?.clusterName } : { teamName: groupDetails?.teamName },
-        };
-        assignedUserList.push( groupData );
-      }
-    } ) );
-    await taskAssignService.insertMany( assignedUserList );
-    return res.sendSuccess( 'Assign details updated successfully' );
-  } catch ( e ) {
-    logger.error( { functionName: 'updateAssign', error: e } );
-    return res.sendError( e, 500 );
-  }
-}
-