tango-app-api-trax 3.2.1 → 3.3.1-airtalai-0

package/src/controllers/trax.controller.js

@@ -21,6 +21,8 @@ import utc from 'dayjs/plugin/utc.js';
 import isEqual from 'lodash/isEqual.js';
 dayjs.extend( utc );
 dayjs.extend( customParseFormat );
+import * as clusterServices from '../services/cluster.service.js';
+import * as teamsServices from '../services/teams.service.js';
 
 
 export const checklist = async ( req, res ) => {
@@ -54,6 +56,7 @@ export const checklist = async ( req, res ) => {
           $project: {
             checkList: { $toLower: '$checkListName' },
             checkListName: 1,
+            coverage: 1,
             createdBy: 1,
             userName: { $toLower: '$createdByName' },
             createdByName: 1,
@@ -124,7 +127,6 @@ export const checklist = async ( req, res ) => {
   }
 };
 
-
 export const create = async ( req, res ) => {
   try {
     let inputBody = req.body;
@@ -246,9 +248,13 @@ export const create = async ( req, res ) => {
                 }
                 if ( answer.showLinked ) {
                   if ( nestedIndex != -1 ) {
-                    section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
+                    if ( !section.questions[qIdx].answers[nestedIndex].nestedQuestion.includes( answer.linkedQuestion ) ) {
+                      section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
+                    }
                   } else {
-                    section.questions[qIdx].answers[index].nestedQuestion.push( answer.linkedQuestion );
+                    if ( !section.questions[qIdx].answers[index].nestedQuestion.includes( answer.linkedQuestion ) ) {
+                      section.questions[qIdx].answers[index].nestedQuestion.push( answer.linkedQuestion );
+                    }
                   }
                   let nestedLinkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
                   if ( nestedLinkedQuestion ) {
@@ -388,9 +394,29 @@ export const getConfigDetails = async ( req, res ) => {
         result.checkListDetails.scheduleStartTime = result.openTime;
         result.checkListDetails.scheduleEndTime = result.closeTime;
       }
-      let removedUsers = await assignedService.find( { checkFlag: false, checkListId: storechecklistdetails._id }, { _id: 1 } );
-      removedUsers = removedUsers?.map( ( item ) => item._id );
-      result.checkListDetails = { ...result.checkListDetails, ...{ sections: sectionList }, ...{ assignedUsers: [] }, ...{ 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 assignedService.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 );
@@ -542,7 +568,7 @@ async function createUser( data ) {
       ],
     };
     let response = await userService.create( params );
-    return response._id;
+    return response;
   } catch ( e ) {
     logger.error( 'createUser =>', e );
     return false;
@@ -751,9 +777,13 @@ export const update = async ( req, res ) => {
                 }
                 if ( answer.showLinked ) {
                   if ( nestedIndex != -1 ) {
-                    section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
+                    if ( !section.questions[qIdx].answers[nestedIndex].nestedQuestion.includes( answer.linkedQuestion ) ) {
+                      section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
+                    }
                   } else {
-                    section.questions[qIdx].answers[index].nestedQuestion.push( answer.linkedQuestion );
+                    if ( !section.questions[qIdx].answers[index].nestedQuestion.includes( answer.linkedQuestion ) ) {
+                      section.questions[qIdx].answers[index].nestedQuestion.push( answer.linkedQuestion );
+                    }
                   }
                   let nestedLinkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
                   if ( nestedLinkedQuestion ) {
@@ -799,6 +829,7 @@ export const update = async ( req, res ) => {
         }
       }
     } ).catch( ( e ) => {
+      logger.error( 'update =>', e );
       return res.sendError( e, 500 );
     } );
   } catch ( e ) {
@@ -849,11 +880,11 @@ export const assignedUserDetails = async ( req, res ) => {
     if ( !req.params.checklistId ) {
       return res.sendError( { message: 'checklist Id is required' }, 400 );
     }
-    let limit = parseInt( req.query.limit ) || 10;
+    let limit = parseInt( req.query.limit ) || 5;
     let page = parseInt( req.query.offset ) || 0;
     let skip = limit * page;
 
-    let query = [ { $match: { checkListId: new ObjectId( req.params.checklistId ) } } ];
+    let query = [ { $match: { checkListId: new ObjectId( req.params.checklistId ), ...( req.query.coverage ) ? { coverage: req.query.coverage } : {}, isdeleted: false } } ];
     if ( req.query.search.trim() && req.query.search.trim() != '' ) {
       let searchValue = req.query.search;
       searchValue = searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
@@ -865,37 +896,176 @@ export const assignedUserDetails = async ( req, res ) => {
       }
     }
 
-    query.push( {
-      $facet: {
-        data: [
-          { $skip: skip }, { $limit: limit },
-        ],
-        count: [
-          { $count: 'total' },
-        ],
-      },
-    } );
+    query.push( { $sort: { _id: -1 } } );
 
     let checklistDetails = await assignedService.aggregate( query );
-
-    if ( !checklistDetails[0].data.length ) {
+    if ( !checklistDetails.length ) {
       return res.sendError( 'no data found', 204 );
     }
 
     let userDetails = [];
-    checklistDetails[0].data.forEach( ( item ) => {
-      userDetails.push( {
-        id: item._id,
-        userName: item.userName,
-        userEmail: item.userEmail,
-        store_id: item.store_id,
-        storeName: item.storeName,
-        userPhone: item.userPhone,
-        city: item.city,
-        checkFlag: item.checkFlag,
+    let storeList = [];
+    let userList = [];
+    await Promise.all( checklistDetails.map( async ( ele ) => {
+      if ( ele?.store_id || ele?.clusterName ) {
+        storeList.push( ele.assignId );
+      } else {
+        userList.push( ele.assignId );
+      }
+
+      if ( ele?.clusterName ) {
+        let clusterDetails = await clusterServices.findOneCluster( { _id: ele.assignId }, { stores: 1 } );
+        if ( clusterDetails ) {
+          let storeDetails = await storeService.find( { _id: { $in: clusterDetails.stores.map( ( item ) => item.store ) }, status: 'active' } );
+          storeDetails.forEach( ( item ) => {
+            userDetails.push( {
+              id: ele._id,
+              userName: item.spocDetails?.[0]?.name,
+              userEmail: item.spocDetails?.[0]?.email,
+              store_id: item?.storeId,
+              storeName: item?.storeName,
+              userPhone: item.spocDetails?.[0]?.phone,
+              city: ele?.city,
+              checkFlag: ele.checkFlag,
+              clusterName: ele?.clusterName || '',
+              teamName: ele?.teamName || '',
+            } );
+          } );
+        }
+      } else if ( ele?.teamName ) {
+        let teamDetails = await teamsServices.findOneTeams( { _id: ele.assignId }, { users: 1, teamName: 1 } );
+        if ( teamDetails ) {
+          let teamUserDetails = await userService.find( { _id: { $in: teamDetails.users.map( ( item ) => item.userId ) } } );
+          teamUserDetails.forEach( ( item ) => {
+            userDetails.push( {
+              id: ele._id,
+              userName: item.userName,
+              userEmail: item.email,
+              store_id: ele?.storeId,
+              storeName: ele?.storeName,
+              userPhone: item?.mobileNumber,
+              city: ele?.city,
+              checkFlag: ele.checkFlag,
+              clusterName: ele?.clusterName || '',
+              teamName: ele?.teamName || '',
+            } );
+          } );
+        }
+      } else {
+        userDetails.push( {
+          id: ele._id,
+          userName: ele.userName,
+          userEmail: ele.userEmail,
+          store_id: ele?.store_id,
+          storeName: ele?.storeName,
+          userPhone: ele.userPhone,
+          city: ele.city,
+          checkFlag: ele.checkFlag,
+          clusterName: ele?.clusterName || '',
+          teamName: ele?.teamName || '',
+        } );
+      }
+    } ) );
+    if ( req.query.sortColumn && req.query.sortBy ) {
+      const sortColumn = req.query.sortColumn;
+      const sortBy = parseInt( req.query.sortBy, 10 ) === -1 ? -1 : 1;
+      userDetails.sort( ( a, b ) => {
+        if ( a[sortColumn] == null || b[sortColumn] == null ) return 0;
+        if ( typeof a[sortColumn] === 'string' && typeof b[sortColumn] === 'string' ) {
+          return sortBy * a[sortColumn].localeCompare( b[sortColumn] );
+        }
       } );
-    } );
-    return res.sendSuccess( { users: userDetails, count: checklistDetails[0].count[0].total } );
+    }
+    let limitedData = userDetails.slice( skip, limit + skip );
+    return res.sendSuccess( { count: userDetails.length, storeList, userList, users: limitedData } );
+  } catch ( e ) {
+    logger.error( 'assignedUserDetails =>', e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const assignedUserDetailsv1 = async ( req, res ) => {
+  try {
+    if ( !req.params.checklistId ) {
+      return res.sendError( { message: 'checklist 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.params.checklistId ), isdeleted: false } } ];
+
+    query.push( { $sort: { _id: -1 } } );
+
+    let checklistDetails = await assignedService.aggregate( query );
+    if ( !checklistDetails.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+
+    let userDetails = [];
+    await Promise.all( checklistDetails.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 }, isActive: true } );
+          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( 'assignedUserDetails =>', e );
     return res.sendError( e, 500 );
@@ -1242,187 +1412,401 @@ export const updateConfigure =async ( req, res ) => {
   }
 };
 
-export const updatePublish = async ( req, res ) => {
+export const updateConfigurev1 =async ( req, res ) => {
   try {
-    if ( typeof req?.body?.checklistId == 'undefined' && typeof req.body.type == 'undefined' ) {
-      return res.sendError( 'checklistId or type is required', 400 );
-    }
-
-    if ( typeof req?.body?.publish == 'undefined' ) {
-      return res.sendError( 'publish is required', 400 );
+    let inputBody = req.body;
+    let id;
+    let checklistDetails;
+    if ( !inputBody.checkListDetails._id ) {
+      return res.sendError( 'checkListId is Required', 400 );
     }
-    let getCheckDetails;
-    let query;
 
-    if ( req.body.checklistId && typeof req.body.type == 'undefined' ) {
-      query = { _id: req.body.checklistId };
-      getCheckDetails = await checklistService.findOne( { _id: req.body.checklistId, client_id: req.body.clientId, type: 'checklist' } );
-    } else {
-      query = { client_id: req.body.clientId, checkListType: req.body.type };
-      let findQuery = {};
-      if ( req.body.checklistId ) {
-        findQuery['_id'] = req.body.checklistId;
-      } else {
-        findQuery['client_id'] = { $exists: false };
-        findQuery['checkListType'] = req.body.type;
-      }
-      let aiDetails = await checklistService.findOne( findQuery );
-      if ( !req.body.checklistId ) {
-        getCheckDetails = { ...aiDetails._doc };
-        if ( !getCheckDetails.scheduleStartTime ) {
-          let brandDetails = await clientService.findOne( { clientId: req.body.clientId } );
-          if ( brandDetails ) {
-            getCheckDetails.scheduleStartTime = dayjs( brandDetails.featureConfigs.open, 'hh:mm:ss' ).format( 'hh:mm A' );
-            getCheckDetails.scheduleEndTime = dayjs( brandDetails.featureConfigs.close, 'hh:mm:ss' ).format( 'hh:mm A' );
-            getCheckDetails.scheduleEndTimeISO = dayjs.utc( getCheckDetails.scheduleEndTime, 'hh:mm A' ).format();
-            getCheckDetails.scheduleStartTimeISO = dayjs.utc( getCheckDetails.scheduleStartTime, 'hh:mm A' ).format();
-          }
-        }
-        getCheckDetails.schedule = 'daily';
-        getCheckDetails.client_id = req.body.clientId;
-        getCheckDetails.createdBy = req.user._id;
-        getCheckDetails.createdByName = req.user.userName;
-        delete getCheckDetails._id;
-      } else {
-        getCheckDetails = { ...aiDetails._doc };
+    if ( inputBody.checkListDetails.checkListType == 'mobileusagedetection' && inputBody.submitType == 'publish' ) {
+      if ( !inputBody?.checkListDetails?.alert?.usageExceeds ) {
+        return res.sendError( 'Please Enter usage exceeds', 400 );
       }
-    }
 
-    if ( !getCheckDetails ) {
-      return res.sendError( 'no data found', 204 );
-    }
+      if ( !inputBody?.checkListDetails?.alert?.alertsTo.length ) {
+        return res.sendError( 'Please select users to send alert', 400 );
+      }
 
-    if ( getCheckDetails?.publishDate && getCheckDetails.checkListType == 'custom' ) {
-      let date = dayjs();
-      let diff = date.diff( dayjs.utc( getCheckDetails?.publishDate ), 'minutes' );
-      if ( diff < 5 ) {
-        let mins = ( 5 - diff ) > 1 ? 'minutes' : 'minute';
-        return res.sendError( `Please try after ${5 - diff} ${mins}`, 400 );
+      if ( !inputBody?.checkListDetails?.detectionArea.length ) {
+        return res.sendError( 'Please select detection area', 400 );
       }
     }
 
-    if ( !getCheckDetails.approver.length && req.body.publish && getCheckDetails.checkListType == 'custom' ) {
-      return res.sendError( 'Please assign approver', 400 );
+    if ( !inputBody.checkListDetails.assignedUsers.length && inputBody.submitType == 'publish' ) {
+      return res.sendError( 'Please Assigned a user', 400 );
     }
 
-    getCheckDetails.publish = req.body.publish;
-    getCheckDetails.publishDate = req.body.publish ? new Date() : getCheckDetails?.publishDate;
-    let currentDate = dayjs();
-    if ( !req.body.publish ) {
-      await processedchecklistConfig.deleteMany( { date_string: { $gt: currentDate.format( 'YYYY-MM-DD' ) }, date_iso: { $gt: currentDate.format( '' ) }, sourceCheckList_id: req.body.checklistId } );
-      await processedchecklist.deleteMany( { date_string: { $gt: currentDate.format( 'YYYY-MM-DD' ) }, date_iso: { $gt: currentDate.format( '' ) }, sourceCheckList_id: req.body.checklistId, checklistStatus: { $ne: 'submit' } } );
-      logger.info( { function: 'updatePublish', query: { date_string: { $gt: currentDate.format( 'YYYY-MM-DD' ) }, date_iso: { $gt: currentDate.format( '' ) }, sourceCheckList_id: req.body.checklistId, checklistStatus: { $ne: 'submit' } } } );
+    if ( !inputBody?.checkListDetails?.approver.length && inputBody.submitType == 'publish' ) {
+      return res.sendError( 'Please assign approver', 400 );
     }
 
 
-    await checklistService.updateOne( query, getCheckDetails );
-    if ( getCheckDetails.checkListType == 'custom' ) {
-      let currentDate = dayjs.utc().format();
-      let updatedscheduleEndTimeISO = dayjs.utc( getCheckDetails.scheduleEndTimeISO ).format( 'HH:mm:ss' );
-      let newUpdatedDate = dayjs.utc( updatedscheduleEndTimeISO, 'HH:mm:ss' ).format();
-
-      if ( req.body.publish && req.body.publish == true ) {
-        if ( newUpdatedDate > currentDate ) {
-          let deleteQuery = {
-            $and: [
-              { date_string: dayjs().format( 'YYYY-MM-DD' ) },
-              { sourceCheckList_id: new ObjectId( req.body.checklistId ) },
-              { scheduleEndTime_iso: { $gt: currentDate } },
-            ],
-          };
-          deleteQuery.$and.push( { checklistStatus: { $eq: 'open' } } );
-          let PClicklist = await processedchecklist.deleteMany( deleteQuery );
-          logger.info( { function: 'updatePublish', query: deleteQuery } );
-          logger.info( `Deleted Checklist Before Insert => Checklist Name: ${getCheckDetails.checkListName}, PChecklist Count: ${PClicklist.deletedCount}` );
-          if ( PClicklist.acknowledged ) {
-            await insertSingleProcessData( req.body.checklistId );
-          } else {
-            res.sendError( 'something went wrong, please try again', 500 );
-          }
-        } else {
-          logger.info( `Schudled End Time Breached Checklist publish true => Checklist Name: ${getCheckDetails.checkListName}` );
-        }
-
-        futureDaysDataRemove( currentDate, req.body.checklistId, getCheckDetails.checkListName, '111' );
-      } else {
-        if ( newUpdatedDate > currentDate ) {
-          let deleteQuery = {
-            $and: [
-              { date_string: dayjs().format( 'YYYY-MM-DD' ) },
-              { sourceCheckList_id: new ObjectId( req.body.checklistId ) },
-              { scheduleEndTime_iso: { $gt: currentDate } },
-            ],
-          };
-          // await processedchecklistConfig.deleteMany( deleteQuery );
-          deleteQuery.$and.push( { checklistStatus: { $eq: 'open' } } );
-          await processedchecklist.deleteMany( deleteQuery );
-          logger.info( { function: 'updatePublish', query: deleteQuery } );
-
-          let checklistLogQuery = {};
-          checklistLogQuery.checkListName = getCheckDetails.checkListName;
-          checklistLogQuery.createdAt = { $gte: new Date( dayjs().format( 'YYYY-MM-DD' ) ) };
-          await checklistLogs.deleteMany( checklistLogQuery );
-
-          let checklistDetectionsQuery = {};
-          checklistDetectionsQuery.sourceChecklist_id = new ObjectId( req.body.checklistId );
-          checklistDetectionsQuery.date_iso = { $gte: new Date( dayjs().format( 'YYYY-MM-DD' ) ) };
-          // await processeddetections.deleteMany( checklistDetectionsQuery );
-          logger.info( { function: 'updatePublish', query: checklistDetectionsQuery } );
-        } else {
-          logger.info( `Schudled End Time Breached Checklist Unpublish false => Checklist Name: ${getCheckDetails.checkListName}` );
-        }
-
-        // //Delete Future Data////
-        futureDaysDataRemove( currentDate, req.body.checklistId, getCheckDetails.checkListName, '222' );
-      }
-    }
     let logInsertData = {
-      action: req.body.publish ? 'publishChecklist' : 'unPublishChecklist',
-      ...( req.body?.checklistId ) ? { checklistId: req.body?.checklistId } : { type: req.body?.type },
-      checkListName: getCheckDetails.checkListName,
+      action: inputBody.submitType == 'publish' ? 'checklistPublishUsingConfigPage' : 'checklistConfigDraft',
+      checklistId: inputBody.checkListDetails._id,
+      checkListName: inputBody?.checkListDetails.checkListName,
       createdBy: req.user._id,
       createdByName: req.user.userName,
       client_id: req.body.clientId,
       createdByEmail: req.user.email,
+      approver: inputBody?.checkListDetails?.approver || [],
     };
     await checklistLogs.create( logInsertData );
-    return res.sendSuccess( { checklistName: getCheckDetails.checkListName, message: 'Updated Successfully' } );
-  } catch ( e ) {
-    logger.error( 'updatePublish erroe =>', e );
-    return res.sendError( e, 500 );
-  }
-};
 
-async function futureDaysDataRemove( currentDate, checklistId, checkListName, sourcefrom ) {
-  // //Delete Future Datas////
-  let futureDataDeleteQuery = {
-    $and: [
-      { date_iso: { $gt: currentDate } },
-      { sourceCheckList_id: new ObjectId( checklistId ) },
-    ],
-  };
-  await processedchecklistConfig.deleteMany( futureDataDeleteQuery );
-  futureDataDeleteQuery.$and.push( { checklistStatus: { $ne: 'submit' } } );
-  await processedchecklist.deleteMany( futureDataDeleteQuery );
-  logger.info( { function: 'futureDaysDataRemove', query: futureDataDeleteQuery } );
-  // ///////////////////////////////
-  return true;
-}
+    checklistDetails = await checklistService.findOne( { _id: inputBody.checkListDetails._id, type: 'checklist', isdeleted: false } );
 
-export const validateUser = async ( req, res ) => {
-  try {
-    if ( !req.body.assignedUsers.length ) {
-      return res.sendError( 'Please Enter user Details', 400 );
+    if ( [ 'mobileusagedetection', 'storeopenandclose', 'uniformdetection' ].includes( inputBody.checkListDetails.checkListType ) && inputBody.uploadUser ) {
+      checklistDetails = await checklistService.findOne( { _id: inputBody.checkListDetails._id, type: 'checklist' } );
     }
 
-    let users = req.body.assignedUsers;
-    let userEmail = [];
-    let storeId = [];
-    let domainExists = [];
+    if ( !checklistDetails ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    let currentDate;
+    if ( inputBody.timeZone ) {
+      currentDate = dayjs().tz( inputBody.timeZone ).format();
+    } else {
+      currentDate = dayjs().format( 'HH:mm:ss' );
+    }
+    currentDate = dayjs.utc( currentDate, 'HH:mm:ss' ).format();
+    let updatedscheduleEndTimeISO = dayjs.utc( inputBody?.checkListDetails?.scheduleEndTime, 'hh:mm A' ).format( 'HH:mm:ss' );
+    let newUpdatedDate = dayjs.utc( updatedscheduleEndTimeISO, 'HH:mm:ss' ).format();
 
-    const duplicateStore = users.reduce( ( acc, obj ) => {
-      if ( !acc[obj.storeName.toLowerCase()] ) {
-        acc[obj.storeName.toLowerCase()] = {
+    if ( inputBody.submitType == 'publish' && inputBody?.showEdit && typeof inputBody?.editSubmit == 'undefined' && newUpdatedDate > currentDate ) {
+      let checkSubmitDetails = await processedchecklist.findOne( { sourceCheckList_id: inputBody.checkListDetails._id, date_string: dayjs().format( 'YYYY-MM-DD' ), checklistStatus: 'submit' } );
+      if ( checkSubmitDetails ) {
+        return res.sendError( 'Checklist got submitted', 400 );
+      }
+    }
+
+    if ( checklistDetails?.publishDate && inputBody.submitType == 'publish' ) {
+      let date = dayjs();
+      let diff = date.diff( dayjs.utc( checklistDetails?.publishDate ), 'minutes' );
+      if ( diff < 5 ) {
+        let mins = ( 5 - diff ) > 1 ? 'minutes' : 'minute';
+        return res.sendError( `Please try after ${5 - diff} ${mins}`, 400 );
+      }
+    }
+
+    if ( inputBody?.checkListDetails?.scheduleRepeatedMonthSetup == 'date' ) {
+      inputBody.checkListDetails.scheduleRepeatedDay = inputBody?.checkListDetails?.scheduleRepeatedDay;
+    }
+
+    if ( inputBody?.checkListDetails?.scheduleDate ) {
+      inputBody.checkListDetails.scheduleDate = new Date( inputBody?.checkListDetails?.scheduleDate );
+    }
+    let configDetails = {
+      ...inputBody?.checkListDetails,
+      publishDate: inputBody.checkListDetails.publish ? new Date() : '',
+      scheduleRepeatedType: inputBody?.checkListDetails?.schedule,
+      scheduleStartTimeISO: dayjs.utc( inputBody?.checkListDetails?.scheduleStartTime, 'hh:mm A' ).format(),
+      scheduleEndTimeISO: dayjs.utc( inputBody?.checkListDetails?.scheduleEndTime, 'hh:mm A' ).format(),
+      scheduleDate: inputBody?.checkListDetails?.scheduleDate ? dayjs( inputBody.checkListDetails.scheduleDate ).format() : '',
+      approver: inputBody?.checkListDetails?.approver.length ? inputBody?.checkListDetails?.approver.map( ( item ) => {
+        return { name: item.name, value: item.value };
+      } ) : [],
+    };
+
+    if ( inputBody?.checkListDetails?.approver.length ) {
+      let data = [];
+      let existEmail = await traxApprover.find( { checkListId: inputBody.checkListDetails._id, isDeleted: false } );
+      let mailList = existEmail.map( ( item ) => item.userEmail );
+      existEmail = inputBody?.checkListDetails?.approver.filter( ( item ) => mailList.includes( item.value ) ).map( ( item ) => item.value );
+      let userMailList = inputBody?.checkListDetails?.approver.map( ( ele ) => ele.value );
+      inputBody?.checkListDetails?.approver.forEach( ( ele ) => {
+        if ( !existEmail.includes( ele.value ) ) {
+          data.push( {
+            userEmail: ele.value,
+            checkListId: inputBody.checkListDetails._id,
+            type: 'checklist',
+            checkListName: inputBody?.checkListDetails.checkListName,
+            client_id: inputBody?.clientId,
+          } );
+        }
+      } );
+
+      await traxApprover.updateMany( { checkListId: inputBody.checkListDetails._id, userEmail: { $nin: userMailList } }, { isDeleted: true } );
+      if ( data.length ) {
+        await traxApprover.insertMany( data );
+      }
+    }
+
+    if ( checklistDetails.checkListType != 'custom' && !checklistDetails.client_id ) {
+      let getchecklistNumber = await checklistService.findOne( { client_id: req.body.clientId, type: 'checklist' }, { checkListNumber: 1 } );
+      let name = checklistDetails.checkListName.split( '(' )[0];
+      let checkListNameDetails = await checklistService.find( { checkListName: { $regex: name }, client_id: req.body.clientId, type: 'checklist', isdeleted: false } );
+      if ( checkListNameDetails.length ) {
+        let nameLength = ( checkListNameDetails.length-1 ) + 1;
+        checklistDetails.checkListName = checklistDetails.checkListName.split( '(' )[0] + '(' + nameLength + ')';
+      } else {
+        checklistDetails.checkListName = checklistDetails.checkListName;
+      }
+      configDetails.type = 'checklist';
+      configDetails.checkListName = checklistDetails.checkListName;
+      configDetails.checkListDescription = checklistDetails.checkListDescription;
+      if ( getchecklistNumber ) {
+        configDetails.checkListNumber = getchecklistNumber.checkListNumber + 1;
+      } else {
+        configDetails.checkListNumber = 1;
+      }
+      configDetails.createdBy= req.user._id;
+      configDetails.createdByName=req.user.userName;
+      delete inputBody.checkListDetails['_id'];
+      if ( [ 'storeopenandclose', 'uniformdetection' ].includes( checklistDetails.checkListType ) ) {
+        let query = { client_id: req.body.clientId, type: 'checklist', isdeleted: false };
+        if ( checklistDetails.checkListType == 'storeopenandclose' ) {
+          query.checkListType= 'storeopenandclose';
+        } else {
+          query.checkListType= 'uniformdetection';
+        }
+        let storeChecklisDetails = await checklistService.findOne( query );
+        if ( storeChecklisDetails ) {
+          inputBody.checkListDetails._id = storeChecklisDetails._id;
+        }
+      }
+    }
+    let query = {
+      client_id: req.body.clientId,
+      checkListType: checklistDetails.checkListType,
+      _id: inputBody.checkListDetails._id,
+    };
+    let response;
+    if ( inputBody.checkListDetails._id ) {
+      if ( [ 'mobileusagedetection', 'storeopenandclose', 'uniformdetection' ].includes( inputBody.checkListDetails.checkListType ) && inputBody.uploadUser ) {
+        configDetails.isdeleted = false;
+      }
+      id = inputBody.checkListDetails._id;
+      response = await checklistService.updateOne( query, configDetails );
+    } else {
+      configDetails.client_id = req.body.clientId;
+      configDetails.checkListType = checklistDetails.checkListType;
+      response = await checklistService.create( configDetails );
+      id = response._id;
+    }
+    if ( inputBody.submitType == 'publish' ) {
+      if ( inputBody.checkListDetails.checkListType == 'custom' ) {
+        let currentDate = dayjs.utc().format();
+        let updatedscheduleEndTimeISO = dayjs.utc( configDetails.scheduleEndTimeISO ).format( 'HH:mm:ss' );
+        let newUpdatedDate = dayjs.utc( updatedscheduleEndTimeISO, 'HH:mm:ss' ).format();
+        if ( newUpdatedDate > currentDate ) {
+          let deleteQuery = {
+            $and: [
+              { date_string: dayjs().format( 'YYYY-MM-DD' ) },
+              { sourceCheckList_id: new ObjectId( req.params.checklistId ) },
+              { scheduleEndTime_iso: { $gt: currentDate } },
+            ],
+          };
+          deleteQuery.$and.push( { checklistStatus: { $ne: 'submit' } } );
+          let PClicklist = await processedchecklist.deleteMany( deleteQuery );
+          logger.info( { function: 'updateConfigure', query: deleteQuery } );
+          if ( PClicklist.acknowledged || inputBody.updateConfigure ) {
+            await insertSingleProcessData( inputBody.checkListDetails._id, 0, inputBody.updateConfigure, inputBody?.editSubmit, inputBody?.showEdit );
+          } else {
+            res.sendError( 'something went wrong, please try again', 500 );
+          }
+        } else {
+          logger.info( `Schudled End Time Breached Checklist publish true => Checklist Name: ${checklistDetails.checkListName}` );
+        }
+
+        futureDaysDataRemove( currentDate, req.params.checklistId, checklistDetails.checkListName, '333' );
+      }
+    }
+    if ( response?.modifiedCount || response?.matchedCount || response?.upsertedCount ) {
+      return res.sendSuccess( { id, message: 'Configured Updated Successfully' } );
+    }
+    if ( response._id ) {
+      return res.sendSuccess( { id, message: 'Configured Added Successfully' } );
+    }
+  } catch ( e ) {
+    logger.error( 'updateConfigure =>', e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const updatePublish = async ( req, res ) => {
+  try {
+    if ( typeof req?.body?.checklistId == 'undefined' && typeof req.body.type == 'undefined' ) {
+      return res.sendError( 'checklistId or type is required', 400 );
+    }
+
+    if ( typeof req?.body?.publish == 'undefined' ) {
+      return res.sendError( 'publish is required', 400 );
+    }
+    let getCheckDetails;
+    let query;
+
+    if ( req.body.checklistId && typeof req.body.type == 'undefined' ) {
+      query = { _id: req.body.checklistId };
+      getCheckDetails = await checklistService.findOne( { _id: req.body.checklistId, client_id: req.body.clientId, type: 'checklist' } );
+    } else {
+      query = { client_id: req.body.clientId, checkListType: req.body.type };
+      let findQuery = {};
+      if ( req.body.checklistId ) {
+        findQuery['_id'] = req.body.checklistId;
+      } else {
+        findQuery['client_id'] = { $exists: false };
+        findQuery['checkListType'] = req.body.type;
+      }
+      let aiDetails = await checklistService.findOne( findQuery );
+      if ( !req.body.checklistId ) {
+        getCheckDetails = { ...aiDetails._doc };
+        if ( !getCheckDetails.scheduleStartTime ) {
+          let brandDetails = await clientService.findOne( { clientId: req.body.clientId } );
+          if ( brandDetails ) {
+            getCheckDetails.scheduleStartTime = dayjs( brandDetails.featureConfigs.open, 'hh:mm:ss' ).format( 'hh:mm A' );
+            getCheckDetails.scheduleEndTime = dayjs( brandDetails.featureConfigs.close, 'hh:mm:ss' ).format( 'hh:mm A' );
+            getCheckDetails.scheduleEndTimeISO = dayjs.utc( getCheckDetails.scheduleEndTime, 'hh:mm A' ).format();
+            getCheckDetails.scheduleStartTimeISO = dayjs.utc( getCheckDetails.scheduleStartTime, 'hh:mm A' ).format();
+          }
+        }
+        getCheckDetails.schedule = 'daily';
+        getCheckDetails.client_id = req.body.clientId;
+        getCheckDetails.createdBy = req.user._id;
+        getCheckDetails.createdByName = req.user.userName;
+        delete getCheckDetails._id;
+      } else {
+        getCheckDetails = { ...aiDetails._doc };
+      }
+    }
+
+    if ( !getCheckDetails ) {
+      return res.sendError( 'no data found', 204 );
+    }
+
+    if ( getCheckDetails?.publishDate && getCheckDetails.checkListType == 'custom' ) {
+      let date = dayjs();
+      let diff = date.diff( dayjs.utc( getCheckDetails?.publishDate ), 'minutes' );
+      if ( diff < 5 ) {
+        let mins = ( 5 - diff ) > 1 ? 'minutes' : 'minute';
+        return res.sendError( `Please try after ${5 - diff} ${mins}`, 400 );
+      }
+    }
+
+    if ( !getCheckDetails.approver.length && req.body.publish && getCheckDetails.checkListType == 'custom' ) {
+      return res.sendError( 'Please assign approver', 400 );
+    }
+
+    getCheckDetails.publish = req.body.publish;
+    getCheckDetails.publishDate = req.body.publish ? new Date() : getCheckDetails?.publishDate;
+    let currentDate = dayjs();
+    if ( !req.body.publish ) {
+      await processedchecklistConfig.deleteMany( { date_string: { $gt: currentDate.format( 'YYYY-MM-DD' ) }, date_iso: { $gt: currentDate.format( '' ) }, sourceCheckList_id: req.body.checklistId } );
+      await processedchecklist.deleteMany( { date_string: { $gt: currentDate.format( 'YYYY-MM-DD' ) }, date_iso: { $gt: currentDate.format( '' ) }, sourceCheckList_id: req.body.checklistId, checklistStatus: { $ne: 'submit' } } );
+      logger.info( { function: 'updatePublish', query: { date_string: { $gt: currentDate.format( 'YYYY-MM-DD' ) }, date_iso: { $gt: currentDate.format( '' ) }, sourceCheckList_id: req.body.checklistId, checklistStatus: { $ne: 'submit' } } } );
+    }
+
+
+    await checklistService.updateOne( query, getCheckDetails );
+    if ( getCheckDetails.checkListType == 'custom' ) {
+      let currentDate = dayjs.utc().format();
+      let updatedscheduleEndTimeISO = dayjs.utc( getCheckDetails.scheduleEndTimeISO ).format( 'HH:mm:ss' );
+      let newUpdatedDate = dayjs.utc( updatedscheduleEndTimeISO, 'HH:mm:ss' ).format();
+
+      if ( req.body.publish && req.body.publish == true ) {
+        if ( newUpdatedDate > currentDate ) {
+          let deleteQuery = {
+            $and: [
+              { date_string: dayjs().format( 'YYYY-MM-DD' ) },
+              { sourceCheckList_id: new ObjectId( req.body.checklistId ) },
+              { scheduleEndTime_iso: { $gt: currentDate } },
+            ],
+          };
+          deleteQuery.$and.push( { checklistStatus: { $eq: 'open' } } );
+          let PClicklist = await processedchecklist.deleteMany( deleteQuery );
+          logger.info( { function: 'updatePublish', query: deleteQuery } );
+          logger.info( `Deleted Checklist Before Insert => Checklist Name: ${getCheckDetails.checkListName}, PChecklist Count: ${PClicklist.deletedCount}` );
+          if ( PClicklist.acknowledged ) {
+            await insertSingleProcessData( req.body.checklistId );
+          } else {
+            res.sendError( 'something went wrong, please try again', 500 );
+          }
+        } else {
+          logger.info( `Schudled End Time Breached Checklist publish true => Checklist Name: ${getCheckDetails.checkListName}` );
+        }
+
+        futureDaysDataRemove( currentDate, req.body.checklistId, getCheckDetails.checkListName, '111' );
+      } else {
+        if ( newUpdatedDate > currentDate ) {
+          let deleteQuery = {
+            $and: [
+              { date_string: dayjs().format( 'YYYY-MM-DD' ) },
+              { sourceCheckList_id: new ObjectId( req.body.checklistId ) },
+              { scheduleEndTime_iso: { $gt: currentDate } },
+            ],
+          };
+          // await processedchecklistConfig.deleteMany( deleteQuery );
+          deleteQuery.$and.push( { checklistStatus: { $eq: 'open' } } );
+          await processedchecklist.deleteMany( deleteQuery );
+          logger.info( { function: 'updatePublish', query: deleteQuery } );
+
+          let checklistLogQuery = {};
+          checklistLogQuery.checkListName = getCheckDetails.checkListName;
+          checklistLogQuery.createdAt = { $gte: new Date( dayjs().format( 'YYYY-MM-DD' ) ) };
+          await checklistLogs.deleteMany( checklistLogQuery );
+
+          let checklistDetectionsQuery = {};
+          checklistDetectionsQuery.sourceChecklist_id = new ObjectId( req.body.checklistId );
+          checklistDetectionsQuery.date_iso = { $gte: new Date( dayjs().format( 'YYYY-MM-DD' ) ) };
+          // await processeddetections.deleteMany( checklistDetectionsQuery );
+          logger.info( { function: 'updatePublish', query: checklistDetectionsQuery } );
+        } else {
+          logger.info( `Schudled End Time Breached Checklist Unpublish false => Checklist Name: ${getCheckDetails.checkListName}` );
+        }
+
+        // //Delete Future Data////
+        futureDaysDataRemove( currentDate, req.body.checklistId, getCheckDetails.checkListName, '222' );
+      }
+    }
+    let logInsertData = {
+      action: req.body.publish ? 'publishChecklist' : 'unPublishChecklist',
+      ...( req.body?.checklistId ) ? { checklistId: req.body?.checklistId } : { type: req.body?.type },
+      checkListName: getCheckDetails.checkListName,
+      createdBy: req.user._id,
+      createdByName: req.user.userName,
+      client_id: req.body.clientId,
+      createdByEmail: req.user.email,
+    };
+    await checklistLogs.create( logInsertData );
+    return res.sendSuccess( { checklistName: getCheckDetails.checkListName, message: 'Updated Successfully' } );
+  } catch ( e ) {
+    logger.error( 'updatePublish erroe =>', e );
+    return res.sendError( e, 500 );
+  }
+};
+
+async function futureDaysDataRemove( currentDate, checklistId, checkListName, sourcefrom ) {
+  // //Delete Future Datas////
+  let futureDataDeleteQuery = {
+    $and: [
+      { date_iso: { $gt: currentDate } },
+      { sourceCheckList_id: new ObjectId( checklistId ) },
+    ],
+  };
+  await processedchecklistConfig.deleteMany( futureDataDeleteQuery );
+  futureDataDeleteQuery.$and.push( { checklistStatus: { $ne: 'submit' } } );
+  await processedchecklist.deleteMany( futureDataDeleteQuery );
+  logger.info( { function: 'futureDaysDataRemove', query: futureDataDeleteQuery } );
+  // ///////////////////////////////
+  return true;
+}
+
+export const validateUser = async ( req, res ) => {
+  try {
+    if ( !req.body.assignedUsers.length ) {
+      return res.sendError( 'Please Enter user Details', 400 );
+    }
+
+    let users = req.body.assignedUsers;
+    let userEmail = [];
+    let storeId = [];
+    let domainExists = [];
+
+    const duplicateStore = users.reduce( ( acc, obj ) => {
+      if ( !acc[obj.storeName.toLowerCase()] ) {
+        acc[obj.storeName.toLowerCase()] = {
           email: [ obj.userEmail.toLowerCase() ],
           count: 1,
         };
@@ -1552,24 +1936,255 @@ export const validateUser = async ( req, res ) => {
         } ) );
       }
     } else {
-      if ( req.body.hasOwnProperty( 'delete' ) ) {
-        let checkExists = await assignedService.findOne( { userEmail: req.body.assignedUsers[0].userEmail, storeName: req.body.assignedUsers[0].storeName, checkListId: req.body.id } );
-        if ( checkExists ) {
-          return res.sendError( 'User already Exists', 400 );
+      if ( req.body.hasOwnProperty( 'delete' ) ) {
+        let checkExists = await assignedService.findOne( { userEmail: req.body.assignedUsers[0].userEmail, storeName: req.body.assignedUsers[0].storeName, checkListId: req.body.id } );
+        if ( checkExists ) {
+          return res.sendError( 'User already Exists', 400 );
+        }
+      }
+
+      let id = await uploadUser( req, res );
+      if ( id ) {
+        return res.sendSuccess( { validate: true, id } );
+      }
+    }
+  } catch ( e ) {
+    logger.error( 'validateUser 2=>', e );
+    return res.sendError( e, 500 );
+  }
+};
+
+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 );
+      console.log( duplicateUsers, 'user' );
+      if ( duplicateUsers.length ) {
+        return res.sendError( { validate: false, duplicates: duplicateUsers, message: 'Email is Duplicated' }, 400 );
+      }
+    }
+
+    if ( req.body.hasOwnProperty( 'addSingle' ) ) {
+      let checkExists = await assignedService.findOne( { userEmail: assignDetails[0]?.userEmail, storeName: assignDetails[0]?.storeName, checkListId: req.body.id } );
+      if ( checkExists ) {
+        return res.sendError( 'User already Exists', 400 );
+      }
+    }
+
+    let 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,
+          email: 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.trim().toLowerCase() == item.storeName.trim().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;
         }
-      }
+      } );
+    }
 
-      let id = await uploadUser( req, res );
-      if ( id ) {
-        return res.sendSuccess( { validate: true, id } );
+    if ( ( newUserList.length || newStoreList.length || existEmail.length || inActiveStores.length ) && !req.body?.addUser ) {
+      newStoreList = [ ...new Set( newStoreList.map( ( item ) => item ) ) ];
+      newUserList = [ ...new Set( newUserList.map( ( item ) => item ) ) ];
+      existEmail = [ ...new Set( existEmail.map( ( item ) => item ) ) ];
+      inActiveStores = [ ...new Set( inActiveStores.map( ( item ) => item ) ) ];
+      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 );
   }
 };
 
+// export async function assignChecklistUser( req, res ) {
+//   try {
+//     let inputBody = req.body;
+//     let assignDetails = inputBody.assignUsers;
+//     let newUsers = inputBody.newUsers;
+//     let checklistDetails = await checklistService.findOne( { _id: inputBody.checklistId } );
+//     if ( !checklistDetails ) {
+//       return res.sendError( 'No data found', 204 );
+//     }
+//     await Promise.all( newUsers.map( async ( user ) => {
+//       let getUser = inputBody.assignUsers.find( ( ele ) => ele.userEmail.toLowerCase() == user.toLowerCase() );
+//       let userData = {
+//         userName: getUser.userName,
+//         email: user,
+//         mobileNumber: getUser?.phone,
+//         clientId: inputBody.clientId,
+//       };
+//       await createUser( userData );
+//     } ) );
+//     let assignData = [];
+//     await Promise.all( assignDetails.map( async ( assign ) => {
+//       assign.checklistId = inputBody.taskId;
+//       assign.checkListName = checklistDetails.checkListName;
+//       assign.coverage = inputBody.coverage;
+//       assign.clientId = inputBody.clientId;
+//       assign.upload = inputBody.type;
+//       let uploadData = await assignUsers( assign );
+//       if ( uploadData ) {
+//         if ( Array.isArray( uploadData ) ) {
+//           assignData.push( ...uploadData );
+//         } else {
+//           assignData.push( uploadData );
+//         }
+//       }
+//     } ) );
+//     return res.sendSuccess( { idList: [ ...new Set( assignData.map( ( item ) => {
+//       return { id: item?.assignId?.toString(), type: inputBody.coverage == 'store' ? typeof item.clusterName == 'undefined' ? 'store' : 'cluster' : typeof item.teamsName == 'undefined' ? 'user' : 'teams' };
+//     } ) ) ], assignData } );
+//   } catch ( e ) {
+//     logger.error( { functionName: 'assignUser', error: e } );
+//     return res.sendError( e, 500 );
+//   }
+// }
+
 async function uploadUser( req, res ) {
   try {
     let inputBody = req.body;
@@ -1944,6 +2559,8 @@ export async function insertSingleProcessData( checklistId, processId = 0, oldDa
       insertdata.approver = getCLconfig?.approver || [];
       insertdata.remainder = getCLconfig?.remainder || [];
       insertdata.restrictAttendance = getCLconfig?.restrictAttendance;
+      insertdata.coverage = getCLconfig?.coverage;
+      insertdata.rawImageUpload = getCLconfig?.rawImageUpload || false;
 
       let collectSections = [];
       let sectionQuery = [];
@@ -1981,7 +2598,7 @@ export async function insertSingleProcessData( checklistId, processId = 0, oldDa
           updatedchecklist = checklistDetails;
         }
         if ( updatedchecklist ) {
-          insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedchecklist, date, startTimeIso, endTimeIso, insertdata, processId, oldData, editSubmit, showEdit );
+          insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedchecklist, date, startTimeIso, endTimeIso, insertdata, processId, oldData, editSubmit, showEdit );
         }
       }
     }
@@ -1992,7 +2609,322 @@ export async function insertSingleProcessData( checklistId, processId = 0, oldDa
   }
 };
 
-async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedchecklist, date, startTimeIso, endTimeIso, insertdata, processId, oldData, editSubmit, showEdit ) {
+// async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedchecklist, date, startTimeIso, endTimeIso, insertdata, processId, oldData, editSubmit, showEdit ) {
+//   let getquestionQuery = [];
+//   if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection' ].includes( getCLconfig.checkListType ) ) {
+//     getquestionQuery.push(
+//         {
+//           $match: {
+//             checkListId: new ObjectId( checklistId ),
+//             checkFlag: true,
+//           },
+//         },
+//         {
+//           $group: {
+//             '_id': '$store_id',
+//             'store_id': { $first: '$store_id' },
+//             'client_id': { $first: '$client_id' },
+//             'storeName': { $first: '$storeName' },
+//             'userId': { $first: '$userId' },
+//             'userEmail': { $first: '$userEmail' },
+//             'userName': { $first: '$userName' },
+//             'checkFlag': { $first: '$checkFlag' },
+//             'checkListId': { $first: '$checkListId' },
+//             'checkListName': { $first: '$checkListName' },
+//             'country': { $first: '$country' },
+//             'createdAt': { $first: '$createdAt' },
+//             'updatedAt': { $first: '$updatedAt' },
+//           },
+//         },
+//     );
+//   } else {
+//     getquestionQuery.push( {
+//       $match: {
+//         checkListId: new ObjectId( checklistId ),
+//         checkFlag: true,
+//         isdeleted: false,
+//       },
+//     } );
+//   }
+//   let allQuestion = await assignedService.aggregate( getquestionQuery );
+//   if ( allQuestion ) {
+//     let userIdList = [];
+//     let tokenList = [];
+//     let notifyUserList = [];
+//     let status = [ { checklistStatus: { $ne: 'open' } } ];
+
+//     for ( let element4 of allQuestion ) {
+//       let getToken = await userService.findOne( { _id: element4.userId }, { fcmToken: 1 } );
+//       if ( getToken && getToken?.fcmToken && element4?.sendNotification && showEdit ) {
+//         tokenList.push( getToken.fcmToken );
+//       }
+//       if ( !element4?.sendNotification ) {
+//         notifyUserList.push( { token: getToken?.fcmToken, storeName: element4.storeName, id: element4._id } );
+//       }
+//       if ( !getCLconfig?.allowedMultiSubmit ) {
+//         let query;
+//         if ( getCLconfig.allowOnce && ![ 'onetime', 'daily' ].includes( getCLconfig.schedule ) ) {
+//           if ( [ 'weekday', 'weekly', 'monthly' ].includes( getCLconfig.schedule ) ) {
+//             let startDate; let endDate;
+//             if ( [ 'weekday', 'weekly' ].includes( getCLconfig.schedule ) ) {
+//               startDate = dayjs.utc( date ).clone().startOf( 'week' );
+//               endDate = dayjs.utc( date ).clone().endOf( 'week' );
+//             } else {
+//               startDate = dayjs.utc( date ).clone().startOf( 'month' );
+//               endDate = dayjs.utc( date ).clone().endOf( 'month' );
+//             }
+//             query = {
+//               sourceCheckList_id: getCLconfig._id,
+//               $or: [
+//                 { submitTime: { $exists: true } },
+//                 ...status,
+//               ],
+//               userId: element4.userId,
+//               store_id: element4.store_id,
+//               $and: [ {
+//                 date_iso: {
+//                   $gte: new Date( startDate.format( 'YYYY-MM-DD' ) ),
+//                   $lte: new Date( endDate.format( 'YYYY-MM-DD' ) ) },
+//               } ],
+//             };
+//           } else {
+//             if ( getCLconfig.schedule == 'range' ) {
+//               query = {
+//                 sourceCheckList_id: getCLconfig._id,
+//                 $or: [
+//                   { submitTime: { $exists: true } },
+//                   ...status,
+//                 ],
+//                 userId: element4.userId,
+//                 store_id: element4.store_id,
+//                 $and: [
+//                   {
+//                     date_iso: {
+//                       $gte: new Date( dayjs( getCLconfig.configStartDate ).format( 'YYYY-MM-DD' ) ),
+//                       $lte: new Date( dayjs( getCLconfig.configEndDate ).format( 'YYYY-MM-DD' ) ),
+//                     },
+//                   },
+//                 ],
+//               };
+//             }
+//           }
+//         } else {
+//           query = {
+//             date_string: date,
+//             sourceCheckList_id: getCLconfig._id,
+//             $or: [
+//               ...status,
+//               { submitTime: { $exists: true } },
+//             ],
+//             userId: element4.userId,
+//             store_id: element4.store_id,
+//           };
+//         }
+//         let getsubmitDetails = await processedchecklist.find( query );
+//         function findDifferences( obj1, obj2 ) {
+//           return Object.keys( obj1 ).reduce( ( diff, key ) => {
+//             if ( !isEqual( obj1[key], obj2[key] ) ) {
+//               diff[key] = { value1: obj1[key], value2: obj2[key] };
+//             }
+//             return diff;
+//           }, {} );
+//         }
+//         if ( getsubmitDetails.length ) {
+//           if ( showEdit && ( ( editSubmit && getsubmitDetails[0].checklistStatus == 'submit' ) || getsubmitDetails[0].checklistStatus == 'inprogress' ) ) {
+//             let modifiedCount = 0;
+//             let questionList = insertdata.questionAnswers;
+//             if ( getsubmitDetails[0].checkListName != getCLconfig.checkListName ) {
+//               getsubmitDetails[0].checkListName = getCLconfig.checkListName;
+//             }
+//             if ( getsubmitDetails[0].checkListDescription != getCLconfig.checkListDescription ) {
+//               getsubmitDetails[0].checkListDescription = getCLconfig.checkListDescription;
+//             }
+//             let sectionList = [];
+//             for ( let [ index, section ] of questionList.entries() ) {
+//               let checkExists = getsubmitDetails[0].questionAnswers.findIndex( ( sec ) => sec.sectionName == section?.sectionOldName || sec.sectionName == section.sectionName );
+//               if ( checkExists != -1 ) {
+//                 getsubmitDetails[0].questionAnswers[index].section_id = section.section_id;
+//                 getsubmitDetails[0].questionAnswers[index].sectionName = section.sectionName;
+//                 let question = [];
+//                 section.questions.forEach( ( qns ) => {
+//                   let findQuestion = getsubmitDetails[0].questionAnswers[index].questions.findIndex( ( ele ) => ele.qname.trim() == qns?.oldQname?.trim() || ele.qname.trim() == qns.qname.trim() );
+//                   if ( findQuestion != -1 ) {
+//                     let data = JSON.parse( JSON.stringify( getsubmitDetails[0].questionAnswers[index].questions[findQuestion] ) );
+//                     getsubmitDetails[0].questionAnswers[index].questions[findQuestion].qno = qns.qno;
+//                     delete data.userAnswer;
+//                     delete data.parentanswer;
+//                     delete data.remarks;
+//                     delete data.linkquestionenabled;
+//                     if ( data.descriptivetype == null ) {
+//                       delete data.descriptivetype;
+//                     }
+//                     qns.answers.forEach( ( ans ) => {
+//                       delete ans.validationAnswer;
+//                       delete ans.answeroptionNumber;
+//                     } );
+//                     data.answers.forEach( ( ans ) => {
+//                       delete ans.index;
+//                       delete ans.validationAnswer;
+//                       delete ans.answeroptionNumber;
+//                     } );
+//                     const compare = findDifferences( data, qns );
+//                     if ( compare?.answerType || compare?.answers || compare?.linkType ) {
+//                       logger.info( 'compare =>', compare );
+//                       modifiedCount++;
+//                       question.push( qns );
+//                     } else {
+//                       getsubmitDetails[0].questionAnswers[index].questions[findQuestion].qname = qns.qname;
+//                       question.push( getsubmitDetails[0].questionAnswers[index].questions[findQuestion] );
+//                     }
+//                   } else {
+//                     modifiedCount++;
+//                     question.push( qns );
+//                   }
+//                 } );
+//                 getsubmitDetails[0].questionAnswers[index].questions = question;
+//                 sectionList.push( getsubmitDetails[0].questionAnswers[index] );
+//               } else {
+//                 modifiedCount++;
+//                 sectionList.push( section );
+//               }
+//             }
+//             getsubmitDetails[0].questionAnswers = sectionList;
+//             if ( modifiedCount ) {
+//               getsubmitDetails[0].checklistStatus = 'inprogress';
+//               getsubmitDetails[0].date_string = dayjs( currentdate ).format( 'YYYY-MM-DD' );
+//               getsubmitDetails[0].date_iso = new Date( date );
+//               getsubmitDetails[0].redoStatus = false;
+//               getsubmitDetails[0].approvalStatus = false;
+//             }
+//             let data = { ...getsubmitDetails[0]._doc };
+//             await processedchecklist.updateOne( { _id: getsubmitDetails[0]._id }, data );
+//             if ( editSubmit && getsubmitDetails[0].checklistStatus == 'submit' ) {
+//               console.log( editSubmit );
+//               let user = {
+//                 _id: getsubmitDetails[0].userId,
+//                 clientId: getsubmitDetails[0].client_id,
+//               };
+//               updateOpenSearch( user, { processedcheckListId: getsubmitDetails[0]._id, date: getsubmitDetails[0].date_string } );
+//             }
+//           }
+//           if ( getsubmitDetails[0]?.checklistStatus == 'submit' ) {
+//             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( date );
+//       element4.date_string = dayjs( currentdate ).format( 'YYYY-MM-DD' );
+//       element4.allowedOverTime = getCLconfig.allowedOverTime;
+//       element4.allowedStoreLocation = getCLconfig.allowedStoreLocation;
+//       element4.scheduleStartTime = getCLconfig.scheduleStartTime;
+//       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 = getCLconfig.scheduleRepeatedType;
+//       element4.approvalEnable = getCLconfig.approver.length ? true : false;
+//       element4.remainder = getCLconfig?.remainder || [];
+//       element4.restrictAttendance = getCLconfig?.restrictAttendance;
+//     }
+//     if ( userIdList.length ) {
+//       allQuestion = allQuestion.filter( ( item ) => typeof item._id == 'undefined' );
+//     }
+//     if ( allQuestion ) {
+//       if ( getCLconfig?.allowedMultiSubmit || processId ) {
+//         if ( processId ) {
+//           let processedDetails = await processedchecklist.findOne( { _id: processId } );
+//           if ( processedDetails ) {
+//             let submitUser = allQuestion.find( ( item ) => item.userId.toString() == processedDetails.userId.toString() && item.store_id == processedDetails.store_id );
+//             await processedchecklist.insertMany( submitUser );
+//           }
+//         } else {
+//           let deleteInprogressQuery = {
+//             date_string: insertdata.date_string,
+//             date_iso: insertdata.date_iso,
+//             client_id: insertdata.client_id,
+//             checkListId: updatedchecklist._id,
+//             checklistStatus: { $nin: [ 'submit', 'inprogress' ] },
+//             redoStatus: false,
+//           };
+//           await processedchecklist.deleteMany( deleteInprogressQuery );
+//           deleteInprogressQuery.checklistStatus = 'inprogress';
+//           deleteInprogressQuery.redoStatus = false;
+//           let getInprogressData = await processedchecklist.find( deleteInprogressQuery, { userId: 1, store_id: 1 } );
+//           if ( getInprogressData ) {
+//             allQuestion = allQuestion.filter( ( item ) => {
+//               let inprogressData = getInprogressData.find( ( ele ) => ele.userId.toString() == item.userId.toString() && ele.store_id == item.store_id );
+//               if ( !inprogressData ) {
+//                 return item;
+//               }
+//             } );
+//           }
+//           if ( allQuestion.length ) {
+//             await processedchecklist.insertMany( allQuestion );
+//           }
+//         }
+//       } else {
+//         let unAssignedList = allQuestion.reduce( ( acc, item ) => {
+//           if ( !acc[item.userEmail] ) {
+//             acc[item.userEmail]=[ item.store_id ];
+//           } else {
+//             acc[item.userEmail].push( item.store_id );
+//           }
+//           return acc;
+//         }, {} );
+
+//         let userList = Object.keys( unAssignedList );
+
+//         await processedchecklist.deleteMany( { userEmail: { $nin: userList }, date_string: insertdata.date_string, date_iso: insertdata.date_iso, client_id: insertdata.client_id, checkListId: updatedchecklist._id, checklistStatus: { $nin: [ 'submit' ] } } );
+
+//         for ( let key in unAssignedList ) {
+//           if ( unAssignedList.hasOwnProperty( key ) ) {
+//             await processedchecklist.deleteMany( { date_string: insertdata.date_string, date_iso: insertdata.date_iso, client_id: insertdata.client_id, checkListId: updatedchecklist._id, $and: [ { userEmail: key }, { store_id: { $nin: unAssignedList[key] } } ], checklistStatus: { $nin: [ 'submit' ] } } );
+//           }
+//         }
+
+
+//         Promise.all( allQuestion.map( async ( ele ) => {
+//           await processedchecklist.updateOne( { date_string: insertdata.date_string, date_iso: insertdata.date_iso, client_id: insertdata.client_id, checkListId: updatedchecklist._id, userEmail: ele.userEmail, store_id: ele.store_id }, ele );
+//         } ) );
+//       }
+
+//       tokenList.forEach( ( item ) => {
+//         const title = `${getCLconfig.checkListName}`;
+//         const description = `Checklist has been updated and re-published!`;
+//         const fcmToken = item;
+//         sendPushNotification( title, description, fcmToken );
+//       } );
+
+//       notifyUserList.forEach( ( item ) => {
+//         const title = `New Checklist Assigned ${item.storeName}`;
+//         const description = `The ${getCLconfig.checkListName} checklist has been assigned to ${item.storeName} for the first time.complete to avoid compliance.`;
+//         const fcmToken = item.token;
+//         sendPushNotification( title, description, fcmToken );
+//       } );
+
+//       let updateUserList = notifyUserList.map( ( ele ) => ele.id );
+//       await assignedService.updateMany( { _id: { $in: updateUserList } }, { sendNotification: true } );
+//     }
+//   }
+// }
+
+async function insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedchecklist, date, startTimeIso, endTimeIso, insertdata, processId, oldData, editSubmit, showEdit ) {
   let getquestionQuery = [];
   if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection' ].includes( getCLconfig.checkListType ) ) {
     getquestionQuery.push(
@@ -2024,86 +2956,202 @@ async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedche
     getquestionQuery.push( {
       $match: {
         checkListId: new ObjectId( checklistId ),
-        checkFlag: true,
         isdeleted: false,
       },
     } );
   }
   let allQuestion = await assignedService.aggregate( getquestionQuery );
   if ( allQuestion ) {
+    let assignList = [];
+    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 ) ), ...teamDetails.flatMap( ( item ) => item.Teamlead.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 ];
     let userIdList = [];
     let tokenList = [];
     let notifyUserList = [];
     let status = [ { checklistStatus: { $ne: 'open' } } ];
-
-    for ( let element4 of allQuestion ) {
-      let getToken = await userService.findOne( { _id: element4.userId }, { fcmToken: 1 } );
-      if ( getToken && getToken?.fcmToken && element4?.sendNotification && showEdit ) {
-        tokenList.push( getToken.fcmToken );
-      }
-      if ( !element4?.sendNotification ) {
-        notifyUserList.push( { token: getToken?.fcmToken, storeName: element4.storeName, id: element4._id } );
-      }
-      if ( !getCLconfig?.allowedMultiSubmit ) {
-        let query;
-        if ( getCLconfig.allowOnce && ![ 'onetime', 'daily' ].includes( getCLconfig.schedule ) ) {
-          if ( [ 'weekday', 'weekly', 'monthly' ].includes( getCLconfig.schedule ) ) {
-            let startDate; let endDate;
-            if ( [ 'weekday', 'weekly' ].includes( getCLconfig.schedule ) ) {
-              startDate = dayjs.utc( date ).clone().startOf( 'week' );
-              endDate = dayjs.utc( date ).clone().endOf( 'week' );
-            } else {
-              startDate = dayjs.utc( date ).clone().startOf( 'month' );
-              endDate = dayjs.utc( date ).clone().endOf( 'month' );
-            }
+    let assignUserList = [];
+    let userList = allQuestion.map( ( item ) => item.userId );
+    let submittedDetails = [];
+    let userDetails = await userService.find( { _id: { $in: userList } }, { fcmToken: 1 } );
+    userDetails = new Map( userDetails.map( ( ele ) => [ ele._id.toString(), ele.fcmToken ] ) );
+    if ( !getCLconfig?.allowedMultiSubmit ) {
+      let query;
+      if ( getCLconfig.allowOnce && ![ 'onetime', 'daily' ].includes( getCLconfig.schedule ) ) {
+        if ( [ 'weekday', 'weekly', 'monthly' ].includes( getCLconfig.schedule ) ) {
+          let startDate; let endDate;
+          if ( [ 'weekday', 'weekly' ].includes( getCLconfig.schedule ) ) {
+            startDate = dayjs.utc( date ).clone().startOf( 'week' );
+            endDate = dayjs.utc( date ).clone().endOf( 'week' );
+          } else {
+            startDate = dayjs.utc( date ).clone().startOf( 'month' );
+            endDate = dayjs.utc( date ).clone().endOf( 'month' );
+          }
+          query = {
+            sourceCheckList_id: getCLconfig._id,
+            $or: [
+              { submitTime: { $exists: true } },
+              ...status,
+            ],
+            // userId: { $in: userList },
+            // ...( getCLconfig.coverage == 'store' ) ? { store_id: element4.store_id }:{},
+            $and: [ {
+              date_iso: {
+                $gte: new Date( startDate.format( 'YYYY-MM-DD' ) ),
+                $lte: new Date( endDate.format( 'YYYY-MM-DD' ) ) },
+            } ],
+          };
+        } else {
+          if ( getCLconfig.schedule == 'range' ) {
             query = {
               sourceCheckList_id: getCLconfig._id,
               $or: [
                 { submitTime: { $exists: true } },
                 ...status,
               ],
-              userId: element4.userId,
-              store_id: element4.store_id,
-              $and: [ {
-                date_iso: {
-                  $gte: new Date( startDate.format( 'YYYY-MM-DD' ) ),
-                  $lte: new Date( endDate.format( 'YYYY-MM-DD' ) ) },
-              } ],
-            };
-          } else {
-            if ( getCLconfig.schedule == 'range' ) {
-              query = {
-                sourceCheckList_id: getCLconfig._id,
-                $or: [
-                  { submitTime: { $exists: true } },
-                  ...status,
-                ],
-                userId: element4.userId,
-                store_id: element4.store_id,
-                $and: [
-                  {
-                    date_iso: {
-                      $gte: new Date( dayjs( getCLconfig.configStartDate ).format( 'YYYY-MM-DD' ) ),
-                      $lte: new Date( dayjs( getCLconfig.configEndDate ).format( 'YYYY-MM-DD' ) ),
-                    },
+              // userId: element4.userId,
+              // ...( getCLconfig.coverage == 'store' ) ? { store_id: element4.store_id }:{},
+              $and: [
+                {
+                  date_iso: {
+                    $gte: new Date( dayjs( getCLconfig.configStartDate ).format( 'YYYY-MM-DD' ) ),
+                    $lte: new Date( dayjs( getCLconfig.configEndDate ).format( 'YYYY-MM-DD' ) ),
                   },
-                ],
-              };
-            }
+                },
+              ],
+            };
           }
+        }
+      } else {
+        query = {
+          date_string: date,
+          sourceCheckList_id: getCLconfig._id,
+          $or: [
+            ...status,
+            { submitTime: { $exists: true } },
+          ],
+          // userId: element4.userId,
+          // ...( getCLconfig.coverage == 'store' ) ? { store_id: element4.store_id }:{},
+        };
+      }
+      submittedDetails = await processedchecklist.find( query );
+    }
+    await Promise.all( allQuestion.map( async ( element4 ) => {
+      let getToken = userDetails.get( element4.userId.toString() );
+      if ( getToken && element4?.sendNotification && showEdit ) {
+        tokenList.push( getToken );
+      }
+      if ( !element4?.sendNotification ) {
+        notifyUserList.push( { token: getToken, storeName: element4.storeName, id: element4._id } );
+      }
+      if ( !getCLconfig?.allowedMultiSubmit ) {
+        let getsubmitDetails;
+        if ( getCLconfig.coverage == 'store' ) {
+          getsubmitDetails = submittedDetails.find( ( checklist ) => checklist.userId.toString() == element4.userId.toString() && checklist.store_id == element4.store_id );
         } else {
-          query = {
-            date_string: date,
-            sourceCheckList_id: getCLconfig._id,
-            $or: [
-              ...status,
-              { submitTime: { $exists: true } },
-            ],
-            userId: element4.userId,
-            store_id: element4.store_id,
-          };
+          getsubmitDetails = submittedDetails.find( ( checklist ) => checklist.userId.toString() == element4.userId.toString() );
+        }
+        if ( getsubmitDetails ) {
+          getsubmitDetails = [ getsubmitDetails ];
+          console.log( submittedDetails, getsubmitDetails );
         }
-        let getsubmitDetails = await processedchecklist.find( query );
         function findDifferences( obj1, obj2 ) {
           return Object.keys( obj1 ).reduce( ( diff, key ) => {
             if ( !isEqual( obj1[key], obj2[key] ) ) {
@@ -2112,7 +3160,7 @@ async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedche
             return diff;
           }, {} );
         }
-        if ( getsubmitDetails.length ) {
+        if ( getsubmitDetails?.length ) {
           if ( showEdit && ( ( editSubmit && getsubmitDetails[0].checklistStatus == 'submit' ) || getsubmitDetails[0].checklistStatus == 'inprogress' ) ) {
             let modifiedCount = 0;
             let questionList = insertdata.questionAnswers;
@@ -2133,6 +3181,7 @@ async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedche
                   let findQuestion = getsubmitDetails[0].questionAnswers[index].questions.findIndex( ( ele ) => ele.qname.trim() == qns?.oldQname?.trim() || ele.qname.trim() == qns.qname.trim() );
                   if ( findQuestion != -1 ) {
                     let data = JSON.parse( JSON.stringify( getsubmitDetails[0].questionAnswers[index].questions[findQuestion] ) );
+                    getsubmitDetails[0].questionAnswers[index].questions[findQuestion].qno = qns.qno;
                     delete data.userAnswer;
                     delete data.parentanswer;
                     delete data.remarks;
@@ -2177,78 +3226,95 @@ async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedche
               getsubmitDetails[0].date_iso = new Date( date );
               getsubmitDetails[0].redoStatus = false;
               getsubmitDetails[0].approvalStatus = false;
-            } else {
-              if ( editSubmit && getsubmitDetails[0].checklistStatus == 'submit' ) {
-                console.log( editSubmit );
-                let user = {
-                  _id: getsubmitDetails[0].userId,
-                  clientId: getsubmitDetails[0].client_id,
-                };
-                updateOpenSearch( user, { processedcheckListId: getsubmitDetails[0]._id, date: getsubmitDetails[0].date_string } );
-              }
             }
             let data = { ...getsubmitDetails[0]._doc };
             await processedchecklist.updateOne( { _id: getsubmitDetails[0]._id }, data );
+            if ( editSubmit && getsubmitDetails[0].checklistStatus == 'submit' ) {
+              let user = {
+                _id: getsubmitDetails[0].userId,
+                clientId: getsubmitDetails[0].client_id,
+              };
+              updateOpenSearch( user, { processedcheckListId: getsubmitDetails[0]._id, date: getsubmitDetails[0].date_string } );
+            }
           }
           if ( getsubmitDetails[0]?.checklistStatus == 'submit' ) {
             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( date );
-      element4.date_string = dayjs( currentdate ).format( 'YYYY-MM-DD' );
-      element4.allowedOverTime = getCLconfig.allowedOverTime;
-      element4.allowedStoreLocation = getCLconfig.allowedStoreLocation;
-      element4.scheduleStartTime = getCLconfig.scheduleStartTime;
-      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 = getCLconfig.scheduleRepeatedType;
-      element4.approvalEnable = getCLconfig.approver.length ? true : false;
-      element4.remainder = getCLconfig?.remainder || [];
-      element4.restrictAttendance = getCLconfig?.restrictAttendance;
-    }
+      if ( !userIdList.includes( element4._id ) ) {
+        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( date );
+        element4.date_string = dayjs( currentdate ).format( 'YYYY-MM-DD' );
+        element4.allowedOverTime = getCLconfig.allowedOverTime;
+        element4.allowedStoreLocation = getCLconfig.allowedStoreLocation;
+        element4.scheduleStartTime = getCLconfig.scheduleStartTime;
+        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 = getCLconfig.scheduleRepeatedType;
+        element4.approvalEnable = getCLconfig.approver.length ? true : false;
+        element4.remainder = getCLconfig?.remainder || [];
+        element4.restrictAttendance = getCLconfig?.restrictAttendance;
+        element4.coverage = getCLconfig?.coverage;
+        element4.rawImageUpload = getCLconfig?.rawImageUpload || false;
+        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 ) {
       if ( getCLconfig?.allowedMultiSubmit || processId ) {
         if ( processId ) {
           let processedDetails = await processedchecklist.findOne( { _id: processId } );
           if ( processedDetails ) {
-            let submitUser = allQuestion.find( ( item ) => item.userId.toString() == processedDetails.userId.toString() && item.store_id == processedDetails.store_id );
+            let submitUser = assignUserList.find( ( item ) => getCLconfig.coverage == 'store' ? item.userId.toString() == processedDetails.userId.toString() && item.store_id == processedDetails.store_id : item.userId.toString() == processedDetails.userId.toString() );
             await processedchecklist.insertMany( submitUser );
           }
         } else {
-          let deleteQuery = {
+          let deleteInprogressQuery = {
             date_string: insertdata.date_string,
             date_iso: insertdata.date_iso,
             client_id: insertdata.client_id,
             checkListId: updatedchecklist._id,
-            checklistStatus: { $nin: [ 'submit' ] },
+            checklistStatus: { $nin: [ 'submit', 'inprogress' ] },
+            redoStatus: false,
           };
-          await processedchecklist.deleteMany( deleteQuery );
-          await processedchecklist.insertMany( allQuestion );
+          await processedchecklist.deleteMany( deleteInprogressQuery );
+          deleteInprogressQuery.checklistStatus = 'inprogress';
+          deleteInprogressQuery.redoStatus = false;
+          let getInprogressData = await processedchecklist.find( deleteInprogressQuery, { userId: 1, store_id: 1 } );
+          if ( getInprogressData ) {
+            assignUserList = assignUserList.filter( ( item ) => {
+              let inprogressData = getInprogressData.find( ( ele ) => getCLconfig.coverage == 'store' ? ele.userId.toString() == item.userId.toString() && ele.store_id == item.store_id : ele.userId.toString() == item.userId.toString() );
+              if ( !inprogressData ) {
+                return item;
+              }
+            } );
+          }
+          if ( assignUserList.length ) {
+            await processedchecklist.insertMany( assignUserList );
+          }
         }
       } else {
-        let unAssignedList = allQuestion.reduce( ( acc, item ) => {
+        let unAssignedList = assignUserList.reduce( ( acc, item ) => {
           if ( !acc[item.userEmail] ) {
             acc[item.userEmail]=[ item.store_id ];
           } else {
@@ -2260,17 +3326,36 @@ async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedche
         let userList = Object.keys( unAssignedList );
 
         await processedchecklist.deleteMany( { userEmail: { $nin: userList }, date_string: insertdata.date_string, date_iso: insertdata.date_iso, client_id: insertdata.client_id, checkListId: updatedchecklist._id, checklistStatus: { $nin: [ 'submit' ] } } );
-
-        for ( let key in unAssignedList ) {
-          if ( unAssignedList.hasOwnProperty( key ) ) {
-            await processedchecklist.deleteMany( { date_string: insertdata.date_string, date_iso: insertdata.date_iso, client_id: insertdata.client_id, checkListId: updatedchecklist._id, $and: [ { userEmail: key }, { store_id: { $nin: unAssignedList[key] } } ], checklistStatus: { $nin: [ 'submit' ] } } );
+        if ( getCLconfig.coverage == 'store' ) {
+          for ( let key in unAssignedList ) {
+            if ( unAssignedList.hasOwnProperty( key ) ) {
+              await processedchecklist.deleteMany( { date_string: insertdata.date_string, date_iso: insertdata.date_iso, client_id: insertdata.client_id, checkListId: updatedchecklist._id, $and: [ { userEmail: key }, { store_id: { $nin: unAssignedList[key] } } ], checklistStatus: { $nin: [ 'submit' ] } } );
+            }
           }
         }
 
+        let inprogressData = await processedchecklist.find( {
+          date_string: insertdata.date_string,
+          date_iso: insertdata.date_iso,
+          client_id: insertdata.client_id,
+          checkListId: updatedchecklist._id,
+          checklistStatus: 'inprogress',
+        }, { userId: 1, store_id: 1 } );
+
+        if ( inprogressData.length ) {
+          assignUserList = assignUserList.filter( ( item ) => {
+            let findData = inprogressData.find( ( ele ) => ele.userId.toString() == item.userId.toString() && ele.store_id == item.store_id );
+            if ( !findData ) {
+              return item;
+            }
+          } );
+        }
 
-        Promise.all( allQuestion.map( async ( ele ) => {
-          await processedchecklist.updateOne( { date_string: insertdata.date_string, date_iso: insertdata.date_iso, client_id: insertdata.client_id, checkListId: updatedchecklist._id, userEmail: ele.userEmail, store_id: ele.store_id }, ele );
-        } ) );
+        await processedchecklist.deleteMany( { date_string: insertdata.date_string,
+          date_iso: insertdata.date_iso,
+          client_id: insertdata.client_id,
+          checkListId: updatedchecklist._id, checklistStatus: 'open' } );
+        await processedchecklist.insertMany( assignUserList );
       }
 
       tokenList.forEach( ( item ) => {
@@ -2345,11 +3430,11 @@ async function updateOpenSearch( user, data ) {
 export const aiChecklist = async ( req, res ) => {
   try {
     let storeDetails = await storeService.count( { clientId: req.query.clientId, status: 'active' } );
-    let aiList = [ 'mobileusagedetection', 'storeopenandclose', 'uniformdetection', 'staffleftinthemiddle', 'customerunattended', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring' ];
+    let aiList = [ 'mobileusagedetection', 'storeopenandclose', 'uniformdetection', 'staffleftinthemiddle', 'customerunattended', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'queuealert', 'cleaning', 'scrum', 'suspiciousactivity', 'boxalert', 'suspiciousfootfall' ];
     let checklistDetails = [];
     let publishList = [];
     let unpublishList = [];
-    publishList = await checklistService.find( { client_id: req.query.clientId, checkListType: { $in: aiList } }, { publish: 1, checkListName: 1, checkListType: 1, client_id: 1, checkListDescription: 1 } );
+    publishList = await checklistService.find( { client_id: req.query.clientId, checkListType: { $in: aiList } }, { publish: 1, checkListName: 1, checkListType: 1, client_id: 1, checkListDescription: 1, storeCount: 1 } );
     if ( publishList.length ) {
       let existList = publishList.map( ( item ) => item.checkListType );
       aiList = aiList.filter( ( item ) => !existList.includes( item ) );
@@ -2358,7 +3443,9 @@ export const aiChecklist = async ( req, res ) => {
     checklistDetails = [ ...publishList, ...unpublishList ];
 
     checklistDetails.forEach( ( item ) => {
-      item.storeCount = storeDetails;
+      if ( ![ 'mobileusagedetection', 'storeopenandclose', 'cleaning', 'scrum' ].includes( item.checkListType ) ) {
+        item.storeCount = storeDetails;
+      }
     } );
 
     return res.sendSuccess( checklistDetails );
@@ -2534,3 +3621,441 @@ export const preDefinedChecklist = async ( req, res ) => {
   }
 };
 
+export const selectAssign = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resuldData;
+    if ( requestData.coverage == 'store' ) {
+      // //Select Store and cluster
+      if ( requestData.assignType == 'store' ) {
+        let storeQuery = [
+          { $match: { clientId: requestData.clientId, status: 'active' } },
+          {
+            $project: {
+              storeName: 1,
+              storeId: 1,
+              type: 'store',
+              userName: { $arrayElemAt: [ '$spocDetails.name', 0 ] },
+              userEmail: { $arrayElemAt: [ '$spocDetails.email', 0 ] },
+              contact: { $arrayElemAt: [ '$spocDetails.contact', 0 ] },
+              city: '$storeProfile.city',
+              openTime: '$storeProfile.open',
+              closeTime: '$storeProfile.close',
+            },
+          },
+
+        ];
+        resuldData = await storeService.aggregate( storeQuery );
+      } else {
+        let clusterQuery = [
+          { $match: { clientId: requestData.clientId } },
+          { $project: { 'clusterName': 1, 'type': 'cluster' } },
+        ];
+        resuldData = await clusterServices.aggregateCluster( clusterQuery );
+      }
+      // console.log( 'getStores =>', getStores );
+      // console.log( 'getClusters =>', getClusters );
+    } else if ( requestData.coverage == 'user' ) {
+      // //Select User and Teams
+      if ( requestData.assignType == 'user' ) {
+        let userQuery = [
+          { $match: { clientId: requestData.clientId, isActive: true } },
+          { $project: { 'userEmail': '$email', 'userName': 1, 'type': 'user' } },
+        ];
+        resuldData = await userService.aggregate( userQuery );
+      } else {
+        let teamQuery = [
+          { $match: { clientId: requestData.clientId } },
+          { $project: { 'teamName': 1, 'type': 'teams' } },
+        ];
+        resuldData = await teamsServices.aggregateTeams( teamQuery );
+      }
+      // let getUsers = await userService.aggregate( userQuery );
+      // console.log( 'getUsers =>', getUsers );
+
+      // let getTeams = await teamsServices.aggregateTeams( teamQuery );
+      // console.log( 'getTeams =>', getTeams );
+    }
+    return res.sendSuccess( { 'totalCount': resuldData.length, 'data': resuldData } );
+  } catch ( e ) {
+    console.log( 'e =>', e );
+    logger.error( 'selectAssign =>', e );
+    return res.sendError( e, 500 );
+  }
+};
+
+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 checklistAssign( req, res ) {
+  try {
+    if ( !req.body.checklistId ) {
+      return res.sendError( 'Checklist id is required', 400 );
+    }
+    if ( !req.body.coverage ) {
+      return res.sendError( 'Coverage is required', 400 );
+    }
+    if ( !req.body.idList ) {
+      return res.sendError( 'Id is required', 400 );
+    }
+
+    let checklistDetails = await checklistService.findOne( { _id: req.body.checklistId } );
+    if ( !checklistDetails ) {
+      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: 'checklistAssign', 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 checklistDetails = await checklistService.findOne( { _id: req.body.checkListId, client_id: req.body.clientId } );
+    if ( !checklistDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    req.body.assignedGroup = [ ...new Set( req.body.assignedGroup.map( ( item ) => item.id ) ) ];
+    // req.body.assignedGroup = req.body.assignedGroup.map( ( ele ) => {
+    //   return { id: ele };
+    // } );
+    await assignedService.deleteMany( { checkListId: req.body.checkListId } );
+    let assignedUserList = [];
+    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 );
+    for ( let assign of req.body.assignedList ) {
+    // 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?.userPhone || '',
+          clientId: req.body.clientId,
+        };
+        userDetails = await createUser( userData );
+        userDetails = userDetails;
+      }
+      let data = {
+        ...assign,
+        userEmail: userDetails?.email,
+        store_id: assign?.storeId,
+        client_id: req.body.clientId,
+        checkListId: req.body.checkListId,
+        coverage: req.body.coverage,
+        assignId: assign._id,
+        userId: userDetails?._id,
+        checkListName: checklistDetails.checkListName,
+      };
+      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.checkListId,
+          coverage: req.body.coverage,
+          assignId: assign,
+          checkListName: checklistDetails.checkListName,
+          ...( req.body.coverage == 'store' ) ? { clusterName: groupDetails?.clusterName } : { teamName: groupDetails?.teamName },
+        };
+        assignedUserList.push( groupData );
+      }
+    } ) );
+    await assignedService.insertMany( assignedUserList );
+    return res.sendSuccess( 'Assign details updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateAssign', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function updateAiConfigure( req, res ) {
+  try {
+    if ( !req.body.storeList.length && req.body.publish ) {
+      return res.sendError( 'Please assign a store', 400 );
+    }
+    if ( !req.body.id && !req.body.type ) {
+      return res.sendError( 'Type/Id is required', 400 );
+    }
+    if ( req.body.aiConfig?.assignConfig && req.body.aiConfig?.assignConfig == 'global' && !req.body?.aiConfig?.events?.length ) {
+      return res.sendError( 'Event is required', 400 );
+    }
+    let query;
+    query = req.body.type ? { checkListType: req.body.type, client_id: { $exists: false } } : { _id: req.body.id, client_id: req.body.clientId };
+    let aiChecklistDetails = await checklistService.findOne( query );
+    if ( !aiChecklistDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let details = {
+      checkListName: aiChecklistDetails.checkListName,
+      checkListDescription: aiChecklistDetails.checkListDescription,
+      client_id: req.body.clientId,
+      publish: req.body.publish,
+      aiConfig: req.body.aiConfig,
+      createdBy: req.user._id,
+      createdByName: req.user.userName,
+      questionCount: 0,
+      storeCount: req.body.storeList.length,
+      type: 'checklist',
+      checkListType: aiChecklistDetails.checkListType,
+      schedule: 'daily',
+      ...( req.body.publish ) ? { publishDate: new Date() } :{},
+      approver: req.body?.approver || [],
+      scheduleRepeatedDay: [ '01' ],
+      scheduleStartTime: '06:00 AM',
+      scheduleEndTime: '11:59 PM',
+    };
+    let aiResponse = await checklistService.updateOne( { checkListType: aiChecklistDetails.checkListType, client_id: req.body.clientId }, details );
+    let checklistId = req.body?.id || aiResponse?.upsertedId;
+    if ( req.body.storeList ) {
+      let storeData = [];
+      req.body.storeList.forEach( ( ele ) => {
+        let eventTime = [];
+        Object.keys( ele ).forEach( ( key ) => {
+          let keyValue ={};
+          if ( req.body.aiConfig?.assignConfig && req.body.aiConfig?.assignConfig == 'store' && key.includes( 'startTime' ) ) {
+            let num = key.slice( -1 );
+            keyValue['time'] = ele[key];
+            keyValue['duration'] = ele[`configTime${num}`];
+            eventTime.push( keyValue );
+          }
+        } );
+        if ( req.body.aiConfig?.assignConfig && req.body.aiConfig?.assignConfig == 'global' ) {
+          req.body.aiConfig.events.forEach( ( event ) => {
+            if ( event.time.split( ':' ).length <= 2 ) {
+              event.time = event.time + ':00';
+            }
+          } );
+          eventTime = req.body.aiConfig.events;
+        }
+        storeData.push( {
+          storeName: ele.storeName,
+          ...( req.body.aiConfig?.assignConfig ) ? { events: eventTime } : { events: [] },
+          checkListId: checklistId,
+          client_id: req.body.clientId,
+          checkListName: aiChecklistDetails.checkListName,
+          store_id: ele.storeId,
+          assignId: ele._id,
+        } );
+      } );
+      await assignedService.deleteMany( { checkListId: checklistId } );
+      await assignedService.insertMany( storeData );
+      if ( req.body.publish ) {
+        let processedData = {
+          client_id: req.body.clientId,
+          date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ),
+          date_string: dayjs().format( 'YYYY-MM-DD' ),
+          sourceCheckList_id: checklistId,
+          checkListName: aiChecklistDetails.checkListName,
+          checkListDescription: aiChecklistDetails.checkListDescription,
+          scheduleStartTime: '06:00 AM',
+          scheduleEndTime: '11:59 PM',
+          scheduleStartTime_iso: dayjs.utc( '06:00 AM', 'hh:mm A' ).format(),
+          scheduleEndTime_iso: dayjs.utc( '11:59 PM', 'hh:mm A' ).format(),
+          allowedOverTime: false,
+          allowedStoreLocation: false,
+          createdBy: req.user._id,
+          createdByName: req.user.userName,
+          questionAnswers: [],
+          isdeleted: false,
+          questionCount: 0,
+          storeCount: req.body.storeList.length,
+          publishDate: details?.publishDate,
+          locationCount: 1,
+          checkListType: aiChecklistDetails.checkListType,
+          scheduleRepeatedType: 'daily',
+          aiStoreList: storeData.length? storeData.map( ( store ) => {
+            return { storeName: store.storeName, events: store.events, storeId: store.store_id };
+          } ) : [],
+          aiConfig: req.body.aiConfig,
+          approver: req.body?.approver || [],
+        };
+        let configResponse = await processedchecklistConfig.updateOne( { date_string: dayjs().format( 'YYYY-MM-DD' ), sourceCheckList_id: checklistId, checkListType: aiChecklistDetails.checkListType }, processedData );
+        let data = {
+          ...( configResponse?.upsertedId ) ? { checkListId: configResponse?.upsertedId } : {},
+          checkListName: aiChecklistDetails.checkListName,
+          checkListDescription: aiChecklistDetails.checkListDescription,
+          date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ),
+          date_string: dayjs().format( 'YYYY-MM-DD' ),
+          allowedOverTime: false,
+          allowedStoreLocation: false,
+          scheduleStartTime: '06:00 AM',
+          scheduleStartTime_iso: dayjs.utc( '06:00 AM', 'hh:mm A' ).format(),
+          scheduleEndTime: '11:59 PM',
+          scheduleEndTime_iso: dayjs.utc( '11:59 PM', 'hh:mm A' ).format(),
+          createdBy: req.user._id,
+          createdByName: req.user.userName,
+          sourceCheckList_id: checklistId,
+          checkListType: aiChecklistDetails.checkListType,
+          storeCount: req.body.storeList.length,
+          questionCount: 0,
+          publishDate: new Date(),
+          locationCount: 0,
+          scheduleRepeatedType: 'daily',
+          client_id: req.body.clientId,
+          aiStoreList: req.body.storeList ? req.body.storeList.map( ( store ) => store.store_id ) : [],
+        };
+        await processedchecklist.updateOne( { date_string: dayjs().format( 'YYYY-MM-DD' ), sourceCheckList_id: checklistId, checkListType: aiChecklistDetails.checkListType }, data );
+      }
+    }
+    return res.sendSuccess( 'Checklist updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateAiConfigure', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
+export async function getAiDetails( req, res ) {
+  try {
+    let storeList = [];
+    if ( !req.query.id && !req.query.type ) {
+      return res.sendError( 'Type/Id is required', 400 );
+    }
+    let query = req.query.type ? { checkListType: req.query.type, client_id: { $exists: false } } : { _id: req.query.id, client_id: req.query.clientId };
+    let checklistDetails = await checklistService.findOne( query );
+    if ( !checklistDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    if ( req.query?.id ) {
+      storeList = await assignedService.find( { checkListId: req.query?.id } );
+      let data = [];
+      await Promise.all( ( storeList.map( async ( ele ) => {
+        let element = {};
+        element['storeName'] = ele.storeName,
+        element['storeId'] = ele.store_id;
+        element['_id'] = ele.assignId;
+        let getStoreDetails = await storeService.findOne( { storeId: ele.store_id, status: 'active', clientId: req.query.clientId } );
+        if ( getStoreDetails ) {
+          element['openTime'] = getStoreDetails?.storeProfile?.open;
+          element['closeTime'] = getStoreDetails?.storeProfile?.close;
+        }
+        if ( [ 'cleaning', 'scrum' ].includes( checklistDetails.checkListType ) && checklistDetails?.aiConfig?.assignConfig == 'store' ) {
+          ele.events.forEach( ( event, index ) => {
+            element[`startTime${index+1}`] = event.time;
+            element[`configTime${index+1}`] = event.duration;
+          } );
+        }
+        data.push( element );
+      } ) ) );
+      storeList = data;
+    }
+
+    let response = {
+      checkListName: checklistDetails?.checkListName,
+      checkListDescription: checklistDetails?.checkListDescription,
+      publish: checklistDetails?.publish,
+      aiConfig: checklistDetails?.aiConfig,
+      storeList: storeList,
+      approver: checklistDetails?.approver,
+      storeCount: checklistDetails?.storeCount,
+      ...( checklistDetails?.client_id ) ? { clientId: checklistDetails?.client_id } :{},
+      enableNewDeployedStore: checklistDetails?.enableNewDeployedStore,
+    };
+    return res.sendSuccess( response );
+  } catch ( e ) {
+    logger.error( { functionName: getAiDetails, error: e } );
+    return res.sendError( e, 500 );
+  }
+}