tango-app-api-task 3.3.1-beta-1 → 3.3.1-beta-3

package/src/controllers/task.controller.js

@@ -8,7 +8,9 @@ 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 clusterModel from '../service/cluster.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 domainService from '../service/domain.service.js';
 import mongoose from 'mongoose';
 const ObjectId = mongoose.Types.ObjectId;
@@ -125,38 +127,6 @@ 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,
@@ -294,9 +264,29 @@ export async function taskDetails( req, res ) {
     }
     if ( storechecklistdetails ) {
       result.checkListDetails = { ...storechecklistdetails._doc };
-      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 } };
+      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 };
     }
     return res.sendSuccess( result );
   } catch ( e ) {
@@ -307,7 +297,7 @@ export async function taskDetails( req, res ) {
 
 export async function validateUser( req, res ) {
   try {
-    if ( !req.body.assignedUsers.length ) {
+    if ( !req.body.assignedUsers?.length ) {
       return res.sendError( 'Please Enter User Details', 400 );
     }
 
@@ -465,6 +455,186 @@ 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()] ) {
+            acc[obj.userEmail.toLowerCase()].name.push( obj.userName.toLowerCase() );
+            acc[obj.userEmail.toLowerCase()].count++;
+          }
+        }
+        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;
@@ -595,55 +765,83 @@ 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 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 limit = parseInt( req.query.limit ) || 5;
+    // let page = parseInt( req.query.offset ) || 0;
+    // let skip = limit * page;
 
-    query.push( {
-      $facet: {
-        data: [
-          { $skip: skip }, { $limit: limit },
-        ],
-        count: [
-          { $count: 'total' },
-        ],
-      },
-    } );
+    let query = [ { $match: { checkListId: new ObjectId( req.query.taskId ), isdeleted: false } }, { $sort: { _id: -1 } } ];
 
     let taskDetails = await taskAssignService.aggregate( query );
-
-    if ( !taskDetails[0].data.length ) {
+    if ( !taskDetails.length ) {
       return res.sendError( 'No data found', 204 );
     }
 
     let 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 } );
+    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, Teamlead: 1 } );
+        if ( teamDetails ) {
+          let idList = [ ...teamDetails.users.map( ( ele ) => ele.userId ), ...teamDetails.Teamlead.map( ( ele ) => ele.userId ) ];
+          let teamUserDetails = await userService.find( { _id: { $in: idList } } );
+          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 {
+        let checkActiveUsers;
+        if ( ele?.coverage == 'user' ) {
+          checkActiveUsers = await userService.findOne( { _id: ele.userId, isActive: true } );
+        }
+        if ( checkActiveUsers || ele?.coverage == 'store' ) {
+          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 } );
   } catch ( e ) {
-    logger.error( { functionName: 'userDetails', error: e, message: req.body } );
+    logger.error( 'userDetails =>', e );
     return res.sendError( e, 500 );
   }
 };
@@ -651,20 +849,22 @@ 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.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.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?.approver.length && inputBody.submitType == 'publish' ) {
       return res.sendError( { message: 'Please assign approver' }, 400 );
     }
@@ -682,7 +882,7 @@ export async function taskConfig( req, res ) {
     };
     await checklistLogs.create( logInsertData );
 
-    checklistDetails = await taskService.findOne( { _id: inputBody._id, isdeleted: false } );
+    checklistDetails = await taskService.findOne( { _id: inputBody._id, isdeleted: false, client_id: inputBody.clientId } );
 
     if ( !checklistDetails ) {
       return res.sendError( 'No data found', 204 );
@@ -720,39 +920,7 @@ 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' );
@@ -845,6 +1013,7 @@ 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( {
@@ -910,7 +1079,6 @@ 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 );
           }
@@ -926,10 +1094,15 @@ 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,
     },
   } );
@@ -938,7 +1111,109 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
 
   if ( allQuestion ) {
     let userIdList = [];
-    for ( let element4 of allQuestion ) {
+    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 ) => {
       let query;
       query = {
         date_string: dayjs( date ).format( 'YYYY-MM-DD' ),
@@ -954,43 +1229,45 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
       let getsubmitDetails = await taskProcessedService.find( query );
       if ( getsubmitDetails.length ) {
         userIdList.push( element4._id );
-        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;
-    }
+      } 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 );
+      }
+    } ) );
     if ( userIdList.length ) {
-      allQuestion = allQuestion.filter( ( item ) => typeof item._id == 'undefined' );
+      assignUserList = assignUserList.filter( ( item ) => typeof item._id == 'undefined' );
     }
 
-    if ( allQuestion ) {
+    if ( assignUserList ) {
       let assigndeletequery = {
         date_iso: date,
         client_id: insertdata.client_id,
@@ -1013,7 +1290,7 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
 
       const taskToRetain = await taskProcessedService.find( retainTaskQuery );
 
-      const insertList = allQuestion.filter( ( item2 ) =>
+      const insertList = assignUserList.filter( ( item2 ) =>
         !taskToRetain.some( ( item1 ) =>
           item1.store_id === item2.store_id && item1.userEmail === item2.userEmail,
         ),
@@ -1079,6 +1356,7 @@ export async function uploadImage( req, res ) {
 
 async function createUser( data ) {
   try {
+    console.log( 'createUser ====>', data );
     let params = {
       userName: data.userName,
       email: data.email,
@@ -1161,7 +1439,8 @@ async function createUser( data ) {
       ],
     };
     let response = await userService.create( params );
-    return response._id;
+    // console.log( 'createUser ====>', response );
+    return response;
   } catch ( e ) {
     logger.error( 'createUser =>', e );
     return false;
@@ -1361,21 +1640,24 @@ export async function createChecklistTask( req, res ) {
         client_id: inputBody.clientId,
       };
       await taskQuestionService.create( question );
-      let storeDetails = await storeService.findOne( { storeName: inputBody.storeName, status: 'active' }, { storeId: 1, storeProfile: 1 } );
-      if ( !storeDetails ) {
-        return res.sendError( 'No data found', 204 );
+      let storeDetails;
+      if ( inputBody?.storeName ) {
+        storeDetails = await storeService.findOne( { storeName: inputBody.storeName, status: 'active' }, { storeId: 1, storeProfile: 1 } );
       }
+
       let userDetails = {
         userName: inputBody.userName,
         userEmail: inputBody.userEmail,
-        store_id: storeDetails.storeId,
-        storeName: inputBody.storeName,
-        city: storeDetails?.storeProfile?.city,
+        store_id: storeDetails?.storeId?storeDetails.storeId:'',
+        storeName: inputBody?.storeName?inputBody?.storeName:'',
+        city: storeDetails?.storeProfile?.city?storeDetails?.storeProfile?.city:'',
         checkFlag: true,
         checkListId: response?._id,
         checkListName: data.checkListName,
         client_id: inputBody.clientId,
         userId: userId,
+        assignId: storeDetails?._id,
+        coverage: response?.coverage || 'store',
       };
       await taskAssignService.create( userDetails );
 
@@ -1389,8 +1671,9 @@ export async function createChecklistTask( req, res ) {
         if ( sectionIndex == -1 ) {
           return res.sendError( 'section is not found', 400 );
         }
-        let data = { ...question[sectionIndex].questions[req.body.qno - 1], taskId: response?._id, task: true };
+        let findQuestion = question[sectionIndex].questions.findIndex( ( ele ) => ele.qno == req.body.qno );
 
+        let data = { ...question[sectionIndex].questions[findQuestion], taskId: response?._id, task: true };
         question[sectionIndex].questions[req.body.qno - 1] = data;
         taskDetails.questionAnswers = question;
         let updateData = {
@@ -1403,6 +1686,7 @@ export async function createChecklistTask( req, res ) {
             _id: inputBody.processedChecklistId,
             section_id: inputBody.sectionId,
             qno: inputBody.qno,
+            parentQuestion: inputBody.parentQuestion,
           },
           'upsert': {
             taskId: String( response?._id ),
@@ -1462,6 +1746,7 @@ 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': {
@@ -1539,6 +1824,7 @@ 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;
@@ -1555,8 +1841,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,
-        storeName: taskDetails.storeName,
+        store_id: taskDetails?.store_id?taskDetails?.store_id:'',
+        storeName: taskDetails.storeName?taskDetails.storeName:'',
         client_id: taskDetails.client_id,
         processedChecklistId: taskDetails._id,
         type: taskDetails.checkListType,
@@ -1578,6 +1864,7 @@ 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 {
@@ -1650,15 +1937,19 @@ 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' ] } },
     );
 
@@ -1674,6 +1965,7 @@ export const taskDropdown = async ( req, res ) => {
         scheduleRepeatedType: 1,
         scheduleStartTime: 1,
         scheduleEndTime: 1,
+        coverage: 1,
       },
     } );
 
@@ -1688,6 +1980,7 @@ export const taskDropdown = async ( req, res ) => {
         scheduleRepeatedType: { $last: '$scheduleRepeatedType' },
         scheduleStartTime: { $last: '$scheduleStartTime' },
         scheduleEndTime: { $last: '$scheduleEndTime' },
+        coverage: { $last: '$coverage' },
       },
     } );
 
@@ -1726,6 +2019,7 @@ export const taskDropdown = async ( req, res ) => {
         scheduleRepeatedType: 1,
         scheduleStartTime: 1,
         scheduleEndTime: 1,
+        coverage: 1,
         checkListDescription: '$checklistconfigs.checkListDescription',
         publish: '$checklistconfigs.publish',
       },
@@ -2161,13 +2455,13 @@ export async function clusterMigrations( req, res ) {
       if ( userexits ) {
         let findStore = await storeService.findOne( { storeName: user.FacilityCode } );
         if ( findStore ) {
-          let clusterExists = await clusterModel.findOneCluster( { clusterName: user.AomName } );
+          let clusterExists = await clusterServices.findOneCluster( { clusterName: user.AomName } );
           if ( clusterExists ) {
             let data = {
               storeId: findStore.storeId,
               store: findStore._id,
             };
-            let updatecluster = await clusterModel.updateCluster( { clusterName: user.AomName }, { $push: { stores: data } } );
+            let updatecluster = await clusterServices.updateCluster( { clusterName: user.AomName }, { $push: { stores: data } } );
             console.log( updatecluster );
           } else {
             let payload = {
@@ -2189,7 +2483,7 @@ export async function clusterMigrations( req, res ) {
               ],
               'users': [],
             };
-            let createcluster = await clusterModel.createclusterModel( payload );
+            let createcluster = await clusterServices.createclusterModel( payload );
             console.log( createcluster );
           }
         }
@@ -2389,14 +2683,15 @@ export async function StoreHygienetask( req, res ) {
     inputBody.approver = inputBody.approver.replace( /,$/, '' );
 
 
-    // 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}.`;
+    let userDetails = await userService.findOne( { _id: new mongoose.Types.ObjectId( finduser.userId ) } );
+    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 ) ) {
@@ -2607,14 +2902,15 @@ export async function eyeTesttask( req, res ) {
     inputBody.approver = inputBody.approver.replace( /,$/, '' );
 
 
-    // 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}.`;
+    let userDetails = await userService.findOne( { _id: new mongoose.Types.ObjectId( finduser.userId ) } );
+    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 ) ) {
@@ -2812,14 +3108,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 ) ) {
@@ -3257,6 +3553,43 @@ 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 ), ...teamDetails[0].Teamlead.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 {
@@ -3282,3 +3615,545 @@ 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 = [];
+    let userEmailList = req.body.assignedList.map( ( ele ) => ele.userEmail.toLowerCase() );
+    let query = [
+      {
+        $addFields: {
+          emailToLower: { $toLower: '$email' },
+        },
+      },
+      {
+        $match: {
+          clientId: req.body.clientId,
+          emailToLower: { $in: userEmailList },
+        },
+      },
+    ];
+    let assignUserDetails = await userService.aggregate( query );
+    await Promise.all( req.body.assignedList.map( async ( assign ) => {
+      let userDetails = assignUserDetails.find( ( ele ) => ele.email.toLowerCase() == assign.userEmail.toLowerCase() );
+      if ( !userDetails ) {
+        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.taskId,
+        coverage: req.body.coverage,
+        assignId: assign._id,
+        userId: userDetails?._id,
+        checkListName: taskDetails.checkListName,
+      };
+      delete data._id;
+      assignedUserList.push( data );
+    } ) );
+    let assignGroupDetails = [];
+    if ( req.body.coverage == 'store' ) {
+      assignGroupDetails = await clusterServices.findcluster( { _id: { $in: req.body.assignedGroup } } );
+    } else {
+      assignGroupDetails = await teamsServices.findteams( { _id: { $in: req.body.assignedGroup } } );
+    }
+    await Promise.all( req.body.assignedGroup.map( async ( assign ) => {
+      let groupDetails = assignGroupDetails.find( ( ele ) => ele._id.toString() == assign );
+      if ( groupDetails ) {
+        let groupData = {
+          client_id: req.body.clientId,
+          checkListId: req.body.taskId,
+          coverage: req.body.coverage,
+          assignId: assign,
+          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 } );
+  }
+};
+
+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 );
+        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 taskcreation( req, res ) {
+  try {
+    let inputBody = req.body;
+
+    inputBody.clientId = 458;
+    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 finduser = await userService.findOne( { clientId: inputBody.clientId, email: req.body.user, userType: 'client', isActive: true }, { userName: '$userName', email: 1, userId: '$_id' } );
+    console.log( finduser );
+
+    if ( !finduser ) {
+      return res.sendError( 'No user Found', 500 );
+    }
+
+    userId = finduser._id;
+    inputBody.userName = finduser.userName;
+    inputBody.userEmail = finduser.email;
+
+
+    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 userAdmin = await userService.find( { clientId: inputBody.clientId, email: inputBody?.approver, userType: 'client', isActive: true }, { name: '$userName', email: 1 } );
+
+
+    if ( userAdmin && userAdmin.length === 0 ) {
+      return res.sendError( 'Invalid Creator Details', 500 );
+    }
+
+    let creator = await userService.find( { clientId: inputBody.clientId, email: inputBody.creator, 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 > 1 ) {
+        let optionsResult = [];
+        for ( let option of inputBody?.options ) {
+          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: 'taskcreation ventota', error: e } );
+    return res.sendError( e, 500 );
+  }
+}