tango-app-api-trax 3.4.1-alpha-20 → 3.4.1-approvecheck-0

package/src/controllers/trax.controller.js

@@ -1,4 +1,4 @@
-import { fileUpload, chunkArray, logger, sendPushNotification } from 'tango-app-api-middleware';
+import { signedUrl, fileUpload, chunkArray, logger, sendPushNotification, sendTeamsNotification, insertOpenSearchData } from 'tango-app-api-middleware';
 import * as checklistService from '../services/checklist.service.js';
 import * as questionService from '../services/checklistQuestion.service.js';
 import * as assignedService from '../services/checklistAssign.service.js';
@@ -247,15 +247,14 @@ export const create = async ( req, res ) => {
                   section.questions[qIdx].answers[index].nestedQuestion = [];
                 }
                 if ( answer.showLinked ) {
-                  // section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
                   if ( nestedIndex != -1 ) {
-                    // if ( !section.questions[qIdx].answers[nestedIndex].nestedQuestion.includes( answer.linkedQuestion ) ) {
-                    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 {
-                    // if ( !section.questions[qIdx].answers[index].nestedQuestion.includes( answer.linkedQuestion ) ) {
-                    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 ) {
@@ -272,18 +271,6 @@ export const create = async ( req, res ) => {
               }
             }
           }
-          let checkNestedLevel = false;
-          section.questions.forEach( ( qns ) => {
-            qns.answers.forEach( ( answ ) => {
-              if ( answ.nestedQuestion.length > 20 ) {
-                checkNestedLevel = true;
-              }
-            } );
-          } );
-
-          if ( checkNestedLevel ) {
-            return res.sendError( { message: 'Unable to create more than 20 linked questions.' }, 400 );
-          }
 
           let sectionList = {
             section: section.name,
@@ -296,10 +283,54 @@ export const create = async ( req, res ) => {
           };
           await questionService.create( sectionList ).then( async ( data ) => {
             if ( i == inputBody.sections.length - 1 ) {
+              let actionType = 'created';
+              let teamsMsg;
+              let teamsAlertUrls = process.env.teamsAlertURL ? JSON.parse( process.env.teamsAlertURL ) : '';
+              actionType = 'Create';
+              teamsMsg = 'ClientId: '+ req.body.clientId + ', Action: '+ actionType + ', ChecklistId: '+ checkListId + ', Checklist Name: '+ inputBody.checklistName + ', UpDatedBy: '+ req.user.email;
+              sendTeamsNotification( teamsAlertUrls.checklist, teamsMsg );
+
+              let logObj = {
+                client_id: inputBody.clientId,
+                createAt: new Date(),
+                sourceCheckList_id: checkListId,
+                checkListName: inputBody.checklistName,
+                fromCheckListName: '',
+                type: 'checklist',
+                action: 'created',
+                storeName: '',
+                store_id: '',
+                createdByEmail: req.user.email,
+                createdBy: req.user.userName,
+                coverage: 'store',
+                logDetails: {},
+                userType: req.user.userType,
+              };
+              insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
+              if ( inputBody.submitType == 'save' ) {
+                let logObj = {
+                  client_id: inputBody.clientId,
+                  createAt: new Date(),
+                  sourceCheckList_id: checkListId,
+                  checkListName: inputBody.checklistName,
+                  fromCheckListName: '',
+                  type: 'checklist',
+                  action: 'draft',
+                  storeName: '',
+                  store_id: '',
+                  createdByEmail: req.user.email,
+                  createdBy: req.user.userName,
+                  coverage: 'store',
+                  logDetails: {},
+                  userType: req.user.userType,
+                };
+
+                insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
+              }
+
               return res.sendSuccess( { checklistId: checkListId, msg: 'CheckList Created Successfully' } );
             }
           } ).catch( ( e ) => {
-            console.log( e );
             return res.sendError( e, 500 );
           } );
         }
@@ -309,11 +340,11 @@ export const create = async ( req, res ) => {
         }
       }
     } ).catch( async ( e ) => {
-      console.log( e );
       await checklistService.deleteOne( { _id: checkListId } );
       return res.sendError( e, 500 );
     } );
   } catch ( e ) {
+    // console.log( 'e', e );
     logger.error( 'create =>', e );
     return res.sendError( e, 500 );
   }
@@ -373,23 +404,23 @@ export const getConfigDetails = async ( req, res ) => {
       let questionDetails = await questionService.find( query );
       if ( questionDetails.length ) {
         let sections = [];
-        // let bucket = JSON.parse( process.env.BUCKET );
+        let bucket = JSON.parse( process.env.BUCKET );
         questionDetails.forEach( ( item ) => {
           item.question.forEach( async ( question ) => {
             if ( question.questionReferenceImage && question.questionReferenceImage !='' ) {
-              // let inputData = {
-              //   Bucket: bucket.sop,
-              //   file_path: decodeURIComponent( question.questionReferenceImage ),
-              // };
-              question.questionReferenceImage = JSON.parse( process.env.CDNURL )?.TraxAnswerCDN+question.questionReferenceImage;
+              let inputData = {
+                Bucket: bucket.sop,
+                file_path: decodeURIComponent( question.questionReferenceImage ),
+              };
+              question.questionReferenceImage = await signedUrl( inputData );
             }
             question.answers.forEach( async ( answer ) => {
               if ( answer.referenceImage != '' ) {
-                // let inputData = {
-                //   Bucket: bucket.sop,
-                //   file_path: decodeURIComponent( answer.referenceImage ),
-                // };
-                answer.referenceImage = JSON.parse( process.env.CDNURL )?.TraxAnswerCDN+answer.referenceImage;
+                let inputData = {
+                  Bucket: bucket.sop,
+                  file_path: decodeURIComponent( answer.referenceImage ),
+                };
+                answer.referenceImage = await signedUrl( inputData );
               }
             } );
           } );
@@ -621,6 +652,30 @@ export const deleteChecklist = async ( req, res ) => {
     await processedchecklist.deleteMany( { date_string: { $ne: date }, date_iso: { $gt: date }, sourceCheckList_id: req.params.checklistId, checklistStatus: { $ne: 'submit' } } );
     logger.info( { function: 'deleteChecklist', query: { date_string: { $ne: date }, date_iso: { $gt: date }, sourceCheckList_id: req.params.checklistId, checklistStatus: { $ne: 'submit' } } } );
     checklistDetails.save().then( () => {
+      let actionType = 'Deleted';
+      let teamsMsg;
+      let teamsAlertUrls = process.env.teamsAlertURL ? JSON.parse( process.env.teamsAlertURL ) : '';
+      teamsMsg = 'ClientId: '+ checklistDetails.client_id + ', Action: '+ actionType + ', ChecklistId: '+ req.params.checklistId + ', Checklist Name: '+ checklistDetails.checkListName + ', UpDatedBy: '+ req.user.email;
+      sendTeamsNotification( teamsAlertUrls.checklist, teamsMsg );
+
+      let logObj = {
+        client_id: checklistDetails.client_id,
+        createAt: new Date(),
+        sourceCheckList_id: checklistDetails._id,
+        checkListName: checklistDetails.checkListName,
+        fromCheckListName: '',
+        type: 'checklist',
+        action: 'deleted',
+        storeName: '',
+        store_id: '',
+        createdByEmail: req.user.email,
+        createdBy: req.user.userName,
+        coverage: checklistDetails.coverage,
+        logDetails: {},
+        userType: req.user.userType,
+      };
+      insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
+
       return res.sendSuccess( { message: 'Checklist Deleted Successfully' } );
     } ).catch( ( e ) => {
       return res.sendError( e, 500 );
@@ -694,6 +749,29 @@ export const duplicateChecklist = async ( req, res ) => {
           sections.push( sectionDetails );
         }
         await questionService.insertMany( sections );
+        let actionType = 'Duplicated';
+        let teamsMsg;
+        let teamsAlertUrls = process.env.teamsAlertURL ? JSON.parse( process.env.teamsAlertURL ) : '';
+        teamsMsg = 'ClientId: '+ checkDetails.client_id + ', Action: '+ actionType + ', ChecklistId: '+ data._id + ', Checklist Name: '+ checkDetails.checkListName + ', UpDatedBy: '+ req.user.email;
+        sendTeamsNotification( teamsAlertUrls.checklist, teamsMsg );
+
+        let logObj = {
+          client_id: checkDetails.client_id,
+          createAt: new Date(),
+          sourceCheckList_id: checkDetails._id,
+          checkListName: checkDetails.checkListName,
+          fromCheckListName: '',
+          type: 'checklist',
+          action: 'duplicated',
+          storeName: '',
+          store_id: '',
+          createdByEmail: req.user.email,
+          createdBy: req.user.userName,
+          coverage: checkDetails.coverage,
+          logDetails: {},
+          userType: req.user.userType,
+        };
+        insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
         return res.sendSuccess( { message: 'CheckList Duplicated Successfully' } );
       } else {
         return res.sendSuccess( { message: 'duplicated Successfully' } );
@@ -730,6 +808,8 @@ export const update = async ( req, res ) => {
       return res.sendError( 'no data found', 204 );
     }
 
+    let getExistQuestions = await questionService.find( { checkListId: req.params.checklistId, client_id: req.body.clientId } );
+
     inputBody.sections.forEach( async ( element ) => {
       if ( !element.questions.length && inputBody.submitType == 'configure' ) {
         return res.sendError( { message: 'Question is Required' }, 400 );
@@ -740,128 +820,235 @@ export const update = async ( req, res ) => {
       }
     } );
 
-    checkListDetails.checkListName = inputBody.checklistName;
-    checkListDetails.checkListDescription = inputBody.checklistDescription;
-    checkListDetails.questionCount = questionCount;
 
-    checkListDetails.save().then( async () => {
-      let checkListId = req.params.checklistId;
-      let logInsertData = {
-        action: 'checklistUpdate',
-        checklistId: checkListId,
-        checkListName: inputBody.checklistName,
-        createdBy: req.user._id,
-        createdByName: req.user.userName,
-        client_id: req.body.clientId,
-        sections: inputBody?.sections,
-        createdByEmail: req.user.email,
-      };
-      await checklistLogs.create( logInsertData );
-      if ( inputBody.sections.length ) {
-        let sectionId =[];
-        for ( let i = 0; i < inputBody?.sections?.length; i++ ) {
-          let section = inputBody.sections[i];
-          section.questions.forEach( ( section ) => {
-            if ( section.questionReferenceImage && section.questionReferenceImage !='' ) {
-              let imgUrl = section.questionReferenceImage.split( '?' )[0];
+    let params = {
+      checkListName: inputBody.checklistName,
+      checkListDescription: inputBody.checklistDescription,
+      questionCount: questionCount,
+    };
+
+    await checklistService.updateOne( { _id: req.params.checklistId }, params );
+    let checkListId = req.params.checklistId;
+    let logInsertData = {
+      action: 'checklistUpdate',
+      checklistId: checkListId,
+      checkListName: inputBody.checklistName,
+      createdBy: req.user._id,
+      createdByName: req.user.userName,
+      client_id: req.body.clientId,
+      sections: inputBody?.sections,
+      createdByEmail: req.user.email,
+    };
+    await checklistLogs.create( logInsertData );
+    let sectionList =[];
+    if ( inputBody.sections.length ) {
+      for ( let i = 0; i < inputBody?.sections?.length; i++ ) {
+        let section = inputBody.sections[i];
+        section.questions.forEach( ( section ) => {
+          if ( section.questionReferenceImage && section.questionReferenceImage !='' ) {
+            let imgUrl = section.questionReferenceImage.split( '?' )[0];
+            let url = imgUrl.split( '/' );
+            url.splice( 0, 3 );
+            section.questionReferenceImage = url.join( '/' );
+          }
+          section.answers.forEach( ( answer ) => {
+            if ( answer.referenceImage != '' ) {
+              let imgUrl = answer.referenceImage.split( '?' )[0];
               let url = imgUrl.split( '/' );
               url.splice( 0, 3 );
-              section.questionReferenceImage = url.join( '/' );
+              answer.referenceImage = url.join( '/' );
             }
-            // if (['image', 'descriptiveImage'].includes(section.answerType)) {
-            section.answers.forEach( ( answer ) => {
-              if ( answer.referenceImage != '' ) {
-                let imgUrl = answer.referenceImage.split( '?' )[0];
-                let url = imgUrl.split( '/' );
-                url.splice( 0, 3 );
-                answer.referenceImage = url.join( '/' );
-              }
-            } );
-            // }
           } );
+        } );
 
-          for ( let [ index, question ] of section.questions.entries() ) {
-            await processNested( index, question );
-          }
+        for ( let [ index, question ] of section.questions.entries() ) {
+          await processNested( index, question );
+        }
 
-          async function processNested( qIdx, question, nestedIndex=-1 ) {
-            if ( question?.answers?.length ) {
-              for ( let [ index, answer ] of question?.answers?.entries() ) {
-                if ( !section.questions[qIdx].answers[index]?.nestedQuestion && nestedIndex == -1 ) {
-                  section.questions[qIdx].answers[index].nestedQuestion = [];
-                }
-                if ( answer.showLinked ) {
-                  if ( nestedIndex != -1 ) {
-                    // if ( !section.questions[qIdx].answers[nestedIndex].nestedQuestion.includes( answer.linkedQuestion ) ) {
+        async function processNested( qIdx, question, nestedIndex=-1 ) {
+          if ( question?.answers?.length ) {
+            for ( let [ index, answer ] of question?.answers?.entries() ) {
+              if ( !section.questions[qIdx].answers[index]?.nestedQuestion && nestedIndex == -1 ) {
+                section.questions[qIdx].answers[index].nestedQuestion = [];
+              }
+              if ( answer.showLinked ) {
+                if ( nestedIndex != -1 ) {
+                  if ( !section.questions[qIdx].answers[nestedIndex].nestedQuestion.includes( answer.linkedQuestion ) ) {
                     section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
-                    // }
-                  } else {
-                    // if ( !section.questions[qIdx].answers[index].nestedQuestion.includes( answer.linkedQuestion ) ) {
+                  }
+                } else {
+                  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 ) {
-                    let findNestedAnswers = nestedLinkedQuestion.answers.find( ( item ) => item.showLinked );
-                    if ( findNestedAnswers ) {
-                      if ( nestedIndex != -1 ) {
-                        await processNested( qIdx, nestedLinkedQuestion, nestedIndex );
-                      } else {
-                        await processNested( qIdx, nestedLinkedQuestion, index );
-                      }
+                }
+                let nestedLinkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
+                if ( nestedLinkedQuestion ) {
+                  let findNestedAnswers = nestedLinkedQuestion.answers.find( ( item ) => item.showLinked );
+                  if ( findNestedAnswers ) {
+                    if ( nestedIndex != -1 ) {
+                      await processNested( qIdx, nestedLinkedQuestion, nestedIndex );
+                    } else {
+                      await processNested( qIdx, nestedLinkedQuestion, index );
                     }
                   }
                 }
               }
             }
           }
+        }
 
-          let checkNestedLevel = false;
-          section.questions.forEach( ( qns ) => {
-            qns.answers.forEach( ( answ ) => {
-              if ( answ.nestedQuestion.length > 20 ) {
-                checkNestedLevel = true;
-              }
-            } );
-          } );
+        sectionList.push( {
+          section: section.name,
+          sectionOldName: section.oldName,
+          createdBy: req.user._id,
+          createdByName: req.user.userName,
+          client_id: req.body.clientId,
+          checkListId: checkListId,
+          question: section.questions,
+          checkList: inputBody.checklistName,
+        } );
+      }
+    }
+    await questionService.deleteMany( { checkListId: checkListId, client_id: req.body.clientId } );
+    if ( sectionList.length ) {
+      await questionService.insertMany( sectionList );
+    }
 
-          console.log( checkNestedLevel, 'lebej' );
+    let questionList = {
+      questionAdd: [],
+      questionEdit: [],
+      questionDelete: [],
+    };
+    let updateSection = [];
 
-          if ( checkNestedLevel ) {
-            return res.sendError( { message: 'Unable to create more than 20 linked questions' }, 400 );
-          }
+    function findDifferences( obj1, obj2 ) {
+      return Object.keys( obj1 ).reduce( ( diff, key ) => {
+        if ( !isEqual( obj1[key], obj2[key] ) ) {
+          diff[key] = { previous: obj1[key], new: obj2[key] };
+        }
+        return diff;
+      }, {} );
+    }
 
-          let sectionList = {
-            section: section.name,
-            sectionOldName: section.oldName,
-            createdBy: req.user._id,
-            createdByName: req.user.userName,
-            client_id: req.body.clientId,
-            checkListId: checkListId,
-            question: section.questions,
-            checkList: inputBody.checklistName,
-          };
-          await questionService.create( sectionList ).then( async ( data ) => {
-            sectionId.push( data._id );
-            if ( i == inputBody.sections.length - 1 ) {
-              await questionService.deleteMany( { checkListId: checkListId, client_id: req.body.clientId, _id: { $nin: sectionId } } );
-              await assignedService.updateMany( { checkListId: checkListId }, { checkListName: inputBody.checklistName } );
-              return res.sendSuccess( { checklistId: checkListId, msg: 'CheckList Created Successfully' } );
-            }
-          } ).catch( ( e ) => {
-            return res.sendError( e, 500 );
+    getExistQuestions.forEach( ( ele ) => {
+      let sectionDetails = inputBody.sections.find( ( sec ) => sec.oldName === ele.section );
+
+      if ( !sectionDetails ) {
+        questionList.questionDelete.push( { sectionName: ele.section, questions: ele.question } );
+        return;
+      }
+
+      if ( ele.section !== sectionDetails.name ) {
+        updateSection.push( { previous: ele.section, new: sectionDetails.name } );
+      }
+
+      ele.question.forEach( ( qn ) => {
+        let question = sectionDetails.questions.find( ( qns ) => qns.oldQname === qn.qname );
+
+        if ( question ) {
+          qn.answers.forEach( ( ans ) => {
+            delete ans.answeroptionNumber;
           } );
+          question.answers.forEach( ( ans ) => {
+            delete ans.answeroptionNumber;
+          } );
+          let compare = findDifferences( qn, question );
+          if ( Object.keys( compare ).length ) {
+            questionList.questionEdit.push( { sectionName: ele.section, questions: [ { previous: qn, new: question } ] } );
+          }
+        } else {
+          let sectionIndex = questionList.questionDelete.findIndex( ( sec ) => sec.sectionName === ele.section );
+
+          if ( sectionIndex !== -1 ) {
+            questionList.questionDelete[sectionIndex].questions.push( qn );
+          } else {
+            questionList.questionDelete.push( { sectionName: ele.section, questions: [ qn ] } );
+          }
         }
-      } else {
-        if ( inputBody.submitType == 'save' ) {
-          await questionService.deleteMany( { checkListId: checkListId, client_id: req.body.clientId } );
-          return res.sendSuccess( { message: 'CheckList Updated Successfully' } );
-        }
+      } );
+    } );
+
+    inputBody.sections.forEach( ( ele ) => {
+      let sectionDetails = getExistQuestions.find( ( sec ) => sec.section === ele.oldName );
+
+      if ( !sectionDetails ) {
+        questionList.questionAdd.push( { sectionName: ele.name, questions: ele.questions } );
+        return;
       }
-    } ).catch( ( e ) => {
-      logger.error( 'update =>', e );
-      return res.sendError( e, 500 );
+
+      ele.questions.forEach( ( qn ) => {
+        let question = sectionDetails.question.find( ( qns ) => qns.qname === qn.oldQname );
+
+        if ( !question ) {
+          let sectionIndex = questionList.questionAdd.findIndex( ( sec ) => sec.sectionName === ele.name );
+
+          if ( sectionIndex !== -1 ) {
+            questionList.questionAdd[sectionIndex].questions.push( qn );
+          } else {
+            questionList.questionAdd.push( { sectionName: ele.name, questions: [ qn ] } );
+          }
+        }
+      } );
     } );
+
+    if ( updateSection.length || questionList.questionAdd.length || questionList.questionEdit.length || questionList.questionDelete.length || inputBody.checklistName.toLowerCase() != checkListDetails.checkListName.toLowerCase() || inputBody.checklistDescription.toLowerCase() != checkListDetails.checkListDescription.toLowerCase() ) {
+      let insertLogData = {
+        client_id: req.body.clientId,
+        createAt: new Date(),
+        sourceCheckList_id: req.params.checklistId,
+        checkListName: inputBody.checklistName,
+        fromCheckListName: '',
+        type: 'checklist',
+        action: 'edited',
+        storeName: '',
+        store_id: '',
+        createdByEmail: req.user.email,
+        createdBy: req.user.userName,
+        coverage: checkListDetails.coverage,
+        logDetails: {
+          ...( inputBody.checklistName.toLowerCase() == checkListDetails.checkListName.toLowerCase() ) ? { updatedChecklistName: {} } :{ updatedChecklistName: {
+            previous: checkListDetails.checkListName,
+            new: inputBody.checklistName,
+          } },
+          ...( inputBody.checklistDescription.toLowerCase() == checkListDetails.checkListDescription.toLowerCase() ) ? { updatedChecklistDescription: {} } :{ updatedChecklistDescription: {
+            previous: checkListDetails.checkListDescription,
+            new: inputBody.checklistDescription,
+          } },
+          updatedSectionName: updateSection,
+          questionAdd: questionList.questionAdd,
+          questionEdit: questionList.questionEdit,
+          questionDelete: questionList.questionDelete,
+        },
+        userType: req.user.userType,
+      };
+      insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, insertLogData );
+    }
+
+    if ( inputBody.submitType == 'save' ) {
+      let logObj = {
+        client_id: inputBody.clientId,
+        createAt: new Date(),
+        sourceCheckList_id: req.params.checklistId,
+        checkListName: inputBody.checklistName,
+        fromCheckListName: '',
+        type: 'checklist',
+        action: 'draft',
+        storeName: '',
+        store_id: '',
+        createdByEmail: req.user.email,
+        createdBy: req.user.userName,
+        coverage: 'store',
+        logDetails: {},
+        userType: req.user.userType,
+      };
+      insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
+    }
+    let actionType = 'Checklist Updated';
+    let teamsMsg;
+    let teamsAlertUrls = process.env.teamsAlertURL ? JSON.parse( process.env.teamsAlertURL ) : '';
+    teamsMsg = 'ClientId: '+ req.body.clientId + ', Action: '+ actionType + ', ChecklistId: '+ checkListId + ', Checklist Name: '+ inputBody.checklistName + ', UpDatedBy: '+ req.user.email;
+    sendTeamsNotification( teamsAlertUrls.checklist, teamsMsg );
+    return res.sendSuccess( { message: 'CheckList Updated Successfully', checklistId: req.params.checklistId } );
   } catch ( e ) {
     logger.error( 'update =>', e );
     return res.sendError( e, 500 );
@@ -889,11 +1076,11 @@ export const uploadImage = async ( req, res ) => {
     };
     imgUrl = await fileUpload( params );
 
-    // let inputData = {
-    //   Bucket: bucket.sop,
-    //   file_path: imgUrl.Key,
-    // };
-    imgUrl = JSON.parse( process.env.CDNURL )?.TraxAnswerCDN+imgUrl.Key;
+    let inputData = {
+      Bucket: bucket.sop,
+      file_path: imgUrl.Key,
+    };
+    imgUrl = await signedUrl( inputData );
     if ( !imgUrl ) {
       return res.sendError( { message: 'Something went Wrong' }, 500 );
     }
@@ -1487,6 +1674,7 @@ export const updateConfigurev1 =async ( req, res ) => {
     await checklistLogs.create( logInsertData );
 
     checklistDetails = await checklistService.findOne( { _id: inputBody.checkListDetails._id, type: 'checklist', isdeleted: false } );
+    let oldPublish = checklistDetails.publish;
 
     if ( [ 'mobileusagedetection', 'storeopenandclose', 'uniformdetection' ].includes( inputBody.checkListDetails.checkListType ) && inputBody.uploadUser ) {
       checklistDetails = await checklistService.findOne( { _id: inputBody.checkListDetails._id, type: 'checklist' } );
@@ -1499,8 +1687,9 @@ export const updateConfigurev1 =async ( req, res ) => {
     if ( inputBody.timeZone ) {
       currentDate = dayjs().tz( inputBody.timeZone ).format();
     } else {
-      currentDate = dayjs().format();
+      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();
 
@@ -1643,6 +1832,124 @@ export const updateConfigurev1 =async ( req, res ) => {
         futureDaysDataRemove( currentDate, req.params.checklistId, checklistDetails.checkListName, '333' );
       }
     }
+    checklistDetails = checklistDetails.toObject();
+    checklistDetails.configStartDate = checklistDetails.configStartDate ? dayjs.utc( checklistDetails?.configStartDate ).format( 'YYYY-MM-DD' ) : '';
+    checklistDetails.configEndDate = checklistDetails.configEndDate ? dayjs.utc( checklistDetails?.configEndDate ).format( 'YYYY-MM-DD' ) : '';
+    checklistDetails.scheduleDate = checklistDetails.scheduleDate ? dayjs.utc( checklistDetails?.scheduleDate ).format( 'YYYY-MM-DD' ) : '';
+    checklistDetails.scheduleRepeatedDay = Array.isArray( checklistDetails.scheduleRepeatedDay ) ? checklistDetails.scheduleRepeatedDay[0] : checklistDetails.scheduleRepeatedDay;
+    configDetails.scheduleRepeatedDay = Array.isArray( configDetails.scheduleRepeatedDay ) ? configDetails?.scheduleRepeatedDay?.[0] || '' : configDetails?.scheduleRepeatedDay;
+    configDetails.scheduleDate = configDetails.scheduleDate ? dayjs( configDetails?.scheduleDate ).format( 'YYYY-MM-DD' ) : '';
+    let removedKeys = [ 'publish', 'publishDate', 'storeCount', 'sections', 'createdAt', 'updatedAt', 'scheduleStartTimeISO', 'scheduleEndTimeISO', 'aiConfig' ];
+    removedKeys.forEach( ( item ) => {
+      delete configDetails?.[item];
+      delete checklistDetails?.[item];
+    } );
+    let differences = findObjectDifference( checklistDetails, configDetails );
+    if ( Object.keys( differences ).length || req.body.added.length || req.body.removed?.user?.length || req.body.removed?.store?.length ) {
+      let showSchedule = false;
+      let scheduleKeys = [ 'scheduleDate', 'schedule', 'scheduleEndTime', 'scheduleStartTime', 'scheduleRepeatedDay', 'scheduleRepeatedType', 'configStartDate', 'configEndDate', 'scheduleWeekDays', 'scheduleRepeatedMonthWeek', 'specificDate' ];
+
+      if ( scheduleKeys.some( ( key ) => differences?.[key] ) ) {
+        showSchedule = true;
+      }
+      let insertData = {
+        client_id: req.body.clientId,
+        createAt: new Date(),
+        sourceCheckList_id: configDetails._id,
+        checkListName: configDetails.checkListName,
+        fromCheckListName: '',
+        type: 'checklist',
+        action: inputBody.checkListDetails.publish ? 'updated' : 'draft',
+        storeName: '',
+        store_id: '',
+        createdByEmail: req.user.email,
+        createdBy: req.user.userName,
+        coverage: configDetails.coverage,
+        logDetails: {
+          schedule: {
+            previous: {
+              ...( showSchedule && checklistDetails.schedule == 'onetime' ) ? { scheduleDateString: dayjs( checklistDetails?.scheduleDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              schedule: showSchedule ? checklistDetails.schedule : '',
+              time: ( ( showSchedule ) && ( checklistDetails.scheduleStartTime != '' || checklistDetails.scheduleEndTime != '' ) ) ? checklistDetails.scheduleStartTime + ' to ' + checklistDetails.scheduleEndTime : '',
+              scheduleRepeatedDay: showSchedule ? checklistDetails?.scheduleRepeatedDay : '',
+              scheduleRepeatedType: showSchedule ? checklistDetails?.scheduleRepeatedType : '',
+              ...( showSchedule && checklistDetails?.configStartDate ) ? { configStartDate: dayjs( checklistDetails?.configStartDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              ...( showSchedule && checklistDetails?.configEndDate ) ? { configEndDate: dayjs( checklistDetails?.configEndDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              scheduleWeekDays: showSchedule ? checklistDetails?.scheduleWeekDays : [],
+              scheduleRepeatedMonthWeek: showSchedule ? checklistDetails?.scheduleRepeatedMonthWeek : '',
+              specificDate: showSchedule ? checklistDetails?.specificDate : [],
+
+            },
+            new: {
+              ...( showSchedule && configDetails.schedule == 'onetime' ) ? { scheduleDateString: dayjs( configDetails?.scheduleDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              schedule: showSchedule ? configDetails.schedule : '',
+              time: ( ( showSchedule ) && ( configDetails.scheduleStartTime != '' || configDetails.scheduleEndTime != '' ) ) ? configDetails.scheduleStartTime + ' to ' + configDetails.scheduleEndTime : '',
+              scheduleRepeatedDay: showSchedule ? configDetails?.scheduleRepeatedDay : '',
+              scheduleRepeatedType: showSchedule ? configDetails?.scheduleRepeatedType : '',
+              ...( showSchedule && configDetails?.configStartDate ) ? { configStartDate: dayjs( configDetails?.configStartDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              ...( showSchedule && configDetails?.configEndDate ) ? { configEndDate: dayjs( configDetails?.configEndDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              scheduleWeekDays: showSchedule ? configDetails?.scheduleWeekDays : [],
+              scheduleRepeatedMonthWeek: showSchedule ? configDetails?.scheduleRepeatedMonthWeek : '',
+              specificDate: showSchedule ? configDetails?.specificDate : [],
+            },
+          },
+          response: {
+            previous: [
+              ...( differences?.allowedStoreLocation && checklistDetails.allowedStoreLocation ? [ 'Geo fencing' ] : [] ),
+              ...( differences?.allowedMultiSubmit && checklistDetails.allowedMultiSubmit? [ 'Allow multiple responses' ] : [] ),
+              ...( differences?.allowedOverTime && checklistDetails.allowedOverTime ? [ 'Fill response after configure time.' ] : [] ),
+              ...( differences?.allowOnce && checklistDetails.allowOnce ? [ 'Only one time' ] : [] ),
+            ],
+            new: [
+              ...( differences?.allowedStoreLocation && configDetails.allowedStoreLocation ? [ 'Geo fencing' ] : [] ),
+              ...( differences?.allowedMultiSubmit && configDetails.allowedMultiSubmit? [ 'Allow multiple responses' ] : [] ),
+              ...( differences?.allowedOverTime && configDetails.allowedOverTime ? [ 'Fill response after configure time' ] : [] ),
+              ...( differences?.allowOnce && configDetails.allowOnce ? [ 'Only one time' ] : [] ),
+            ],
+          },
+          ...( differences?.approver ) ? { approver:
+           { previous: checklistDetails?.approver.map( ( item ) => item.name ).toString(),
+             new: configDetails?.approver.map( ( item ) => item.name ).toString() },
+          } : { approver: {} },
+          ...( differences?.owner ) ? { owner:
+           { previous: checklistDetails?.owner.map( ( item ) => item.name ).toString(),
+             new: configDetails?.owner.map( ( item ) => item.name ).toString() },
+          } : { owner: {} },
+          ...( req.body.checkListDetails.coverage == 'store' ) ? { storeAdded: req.body.added } :{ storeAdded: [] },
+          ...( req.body.removed.store.length ) ? { storeRemoved: req.body.removed.store } :{ storeRemoved: [] },
+          ...( req.body.checkListDetails.coverage == 'user' ) ? { userAdded: req.body.added } :{ userAdded: [] },
+          ...( req.body.removed.user.length ) ? { userRemoved: req.body.removed.user } :{ userRemoved: [] },
+        },
+        userType: req.user.userType,
+      };
+      insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, insertData );
+    }
+
+    if ( inputBody.checkListDetails.publish != oldPublish ) {
+      let logObj = {
+        client_id: inputBody.checkListDetails.client_id,
+        createAt: new Date(),
+        sourceCheckList_id: inputBody.checkListDetails._id,
+        checkListName: inputBody.checkListDetails.checkListName,
+        fromCheckListName: '',
+        type: 'checklist',
+        action: inputBody.checkListDetails.publish ? 'published' : 'unpublished',
+        storeName: '',
+        store_id: '',
+        createdByEmail: req.user.email,
+        createdBy: req.user.userName,
+        coverage: inputBody.checkListDetails.coverage,
+        logDetails: {},
+        userType: req.user.userType,
+      };
+      insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
+    }
+    let actionType;
+    let teamsMsg;
+    actionType = inputBody.checkListDetails.publish ? 'configPublish' : 'configDraft';
+    let teamsAlertUrls = process.env.teamsAlertURL ? JSON.parse( process.env.teamsAlertURL ) : '';
+    teamsMsg = 'ClientId: '+ checklistDetails.client_id + ', Action: '+ actionType + ', ChecklistId: '+ checklistDetails._id + ', Checklist Name: '+ checklistDetails.checkListName + ', UpDatedBy: '+ req.user.email;
+    sendTeamsNotification( teamsAlertUrls.checklist, teamsMsg );
     if ( response?.modifiedCount || response?.matchedCount || response?.upsertedCount ) {
       return res.sendSuccess( { id, message: 'Configured Updated Successfully' } );
     }
@@ -1654,6 +1961,31 @@ export const updateConfigurev1 =async ( req, res ) => {
     return res.sendError( e, 500 );
   }
 };
+function findObjectDifference( oldObj, newObj ) {
+  const isEqual = ( a, b ) => JSON.stringify( a ) === JSON.stringify( b );
+
+  const getArrayDiff = ( oldArr, newArr ) => {
+    const removed = oldArr.filter( ( item ) => !newArr.some( ( newItem ) => isEqual( newItem, item ) ) );
+    const added = newArr.filter( ( item ) => !oldArr.some( ( oldItem ) => isEqual( oldItem, item ) ) );
+    if ( removed.length || added.length ) {
+      return { previous: oldArr, new: newArr };
+    }
+    return [];
+  };
+  const difference = Object.keys( oldObj ).reduce( ( diff, key ) => {
+    oldObj[key] = oldObj[key] == null ? '' : oldObj[key];
+    if ( !isEqual( oldObj[key], newObj[key] ) ) {
+      if ( !Array.isArray( newObj[key] ) ) {
+        diff[key] = { previous: oldObj[key], new: newObj[key] };
+      } else {
+        diff[key] = getArrayDiff( oldObj[key] || [], newObj[key] || [] );
+      }
+    }
+    return diff;
+  }, {} );
+
+  return difference;
+}
 
 export const updatePublish = async ( req, res ) => {
   try {
@@ -1729,11 +2061,29 @@ export const updatePublish = async ( req, res ) => {
 
 
     await checklistService.updateOne( query, getCheckDetails );
+    let logObj = {
+      client_id: req.body.clientId,
+      createAt: new Date(),
+      sourceCheckList_id: req.body.checklistId,
+      checkListName: getCheckDetails.checkListName,
+      fromCheckListName: '',
+      type: 'checklist',
+      action: req.body.publish ? 'published' : 'unpublished',
+      storeName: '',
+      store_id: '',
+      createdByEmail: req.user.email,
+      createdBy: req.user.userName,
+      coverage: getCheckDetails.coverage,
+      logDetails: {},
+      userType: req.user.userType,
+    };
+    insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
     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 = {
@@ -1799,6 +2149,12 @@ export const updatePublish = async ( req, res ) => {
       createdByEmail: req.user.email,
     };
     await checklistLogs.create( logInsertData );
+    let actionType;
+    let teamsMsg;
+    actionType = req.body.publish ? 'publish' : 'unpublish';
+    let teamsAlertUrls = process.env.teamsAlertURL ? JSON.parse( process.env.teamsAlertURL ) : '';
+    teamsMsg = 'ClientId: '+ getCheckDetails.client_id + ', Action: '+ actionType + ', ChecklistId: '+ getCheckDetails._id + ', Checklist Name: '+ getCheckDetails.checkListName + ', UpDatedBy: '+ req.user.email;
+    sendTeamsNotification( teamsAlertUrls.checklist, teamsMsg );
     return res.sendSuccess( { checklistName: getCheckDetails.checkListName, message: 'Updated Successfully' } );
   } catch ( e ) {
     logger.error( 'updatePublish erroe =>', e );
@@ -2031,7 +2387,7 @@ export const validateUserv1 = async ( req, res ) => {
       }, {} );
 
       const duplicateUsers = Object.keys( duplicateUser ).filter( ( storeName ) => duplicateUser[storeName].count > 1 );
-      console.log( duplicateUsers, 'user' );
+      // console.log( duplicateUsers, 'user' );
       if ( duplicateUsers.length ) {
         return res.sendError( { validate: false, duplicates: duplicateUsers, message: 'Email is Duplicated' }, 400 );
       }
@@ -2070,7 +2426,7 @@ export const validateUserv1 = async ( req, res ) => {
       {
         $project: {
           newEmail: { $toLower: '$email' },
-          isActive: 1,
+          // isActive: 1,
           clientId: 1,
           email: 1,
         },
@@ -2078,7 +2434,7 @@ export const validateUserv1 = async ( req, res ) => {
       {
         $match: {
           newEmail: { $in: userEmailList },
-          isActive: true,
+          // isActive: true,
           clientId: { $ne: req.body.clientId },
         },
       },
@@ -2120,7 +2476,7 @@ export const validateUserv1 = async ( req, res ) => {
     let newStoreList = storeList.filter( ( ele ) => ele != null && !existsStore.includes( ele.toLowerCase() ) );
     if ( req.body.coverage == 'store' ) {
       assignDetails.forEach( ( item ) => {
-        let getStoreDetails = storeDetails.find( ( store ) => store.storeName.toLowerCase() == item.storeName.toLowerCase() );
+        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;
@@ -2141,6 +2497,10 @@ export const validateUserv1 = async ( req, res ) => {
       } );
     }
 
+    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 ) ) ];
     if ( ( newUserList.length || newStoreList.length || existEmail.length || inActiveStores.length ) && !req.body?.addUser ) {
       return res.sendError( { validate: false, user: newUserList, store: newStoreList, existEmail, inActiveStores, data: assignDetails }, 400 );
     }
@@ -2586,6 +2946,7 @@ export async function insertSingleProcessData( checklistId, processId = 0, oldDa
       insertdata.restrictAttendance = getCLconfig?.restrictAttendance;
       insertdata.coverage = getCLconfig?.coverage;
       insertdata.rawImageUpload = getCLconfig?.rawImageUpload || false;
+      insertdata.rawVideoUpload = getCLconfig?.rawVideoUpload || false;
 
       let collectSections = [];
       let sectionQuery = [];
@@ -2991,7 +3352,7 @@ async function insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedche
     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 } } );
+        let clusterDetails = await clusterServices.findcluster( { _id: { $in: clusterList }, clientId: getCLconfig.client_id } );
         if ( clusterDetails.length ) {
           let idList = clusterDetails.flatMap( ( item ) => item.stores.map( ( ele ) => ele.store ) );
           let getStoreDetails = await storeService.find( { _id: { $in: idList }, status: 'active' } );
@@ -3058,7 +3419,7 @@ async function insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedche
     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 } } );
+        let teamDetails = await teamsServices.findteams( { _id: { $in: teamsList }, clientId: getCLconfig.client_id } );
         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() );
@@ -3175,6 +3536,7 @@ async function insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedche
         }
         if ( getsubmitDetails ) {
           getsubmitDetails = [ getsubmitDetails ];
+          // console.log( submittedDetails, getsubmitDetails );
         }
         function findDifferences( obj1, obj2 ) {
           return Object.keys( obj1 ).reduce( ( diff, key ) => {
@@ -3210,7 +3572,6 @@ async function insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedche
                     delete data.parentanswer;
                     delete data.remarks;
                     delete data.linkquestionenabled;
-                    delete data.uniqueNo;
                     if ( data.descriptivetype == null ) {
                       delete data.descriptivetype;
                     }
@@ -3222,101 +3583,29 @@ async function insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedche
                       delete ans.index;
                       delete ans.validationAnswer;
                       delete ans.answeroptionNumber;
-                      ans.nestedQuestion = ans?.oldNestedQuestion ? ans.oldNestedQuestion : ans.nestedQuestion;
-                      ans.linkedQuestion = ans?.oldLinkedQuestion ? ans.oldLinkedQuestion : ans.linkedQuestion;
-                      delete ans.oldNestedQuestion;
-                      delete ans.oldLinkedQuestion;
                     } );
                     const compare = findDifferences( data, qns );
                     if ( compare?.answerType || compare?.answers || compare?.linkType ) {
                       logger.info( 'compare =>', compare );
-                      logger.info( 'compareSection =>', { section: section.sectionName } );
-                      logger.info( 'qno =>', { qno: data.qno } );
                       modifiedCount++;
-                      question.push( { question: qns, type: 'qnEdit' } );
+                      question.push( qns );
                     } else {
-                      if ( getsubmitDetails[0].questionAnswers[index].questions[findQuestion].qname != qns.qname ) {
-                        question.push( { type: 'nameChange', question: qns } );
-                      }
-                      // getsubmitDetails[0].questionAnswers[index].questions[findQuestion].qname = qns.qname;
+                      getsubmitDetails[0].questionAnswers[index].questions[findQuestion].qname = qns.qname;
+                      question.push( getsubmitDetails[0].questionAnswers[index].questions[findQuestion] );
                     }
                   } else {
                     modifiedCount++;
-                    question.push( { question: qns, type: 'add' } );
+                    question.push( qns );
                   }
                 } );
-                // getsubmitDetails[0].questionAnswers[index].questions = question;
-                sectionList.push( { sectionName: section.sectionName, oldName: section.sectionOldName, question: question, type: 'edit' } );
+                getsubmitDetails[0].questionAnswers[index].questions = question;
+                sectionList.push( getsubmitDetails[0].questionAnswers[index] );
               } else {
                 modifiedCount++;
-                sectionList.push( { section: section, type: 'add' } );
+                sectionList.push( section );
               }
             }
-            // getsubmitDetails[0].questionAnswers = sectionList;
-            sectionList.forEach( ( sec ) => {
-              if ( sec.type == 'add' ) {
-                getsubmitDetails[0].questionAnswers.push( sec.section );
-              } else {
-                sec.question.forEach( ( qn ) => {
-                  let sectionDetails = getsubmitDetails[0].questionAnswers.findIndex( ( section ) => section.sectionName == sec?.oldName || section.sectionName == sec.sectionName );
-                  if ( qn.type == 'add' ) {
-                    getsubmitDetails[0].questionAnswers[sectionDetails].questions.push( qn.question );
-                  } else {
-                    let questions = getsubmitDetails[0].questionAnswers[sectionDetails].questions.reduce( ( acc, ele, idx ) => {
-                      if ( ele.qname.trim() == qn?.question?.oldQname?.trim() || ele.qname.trim() == qn.question.qname.trim() ) {
-                        acc.push( idx );
-                      }
-                      return acc;
-                    }, [] );
-                    if ( questions.length && [ 'qnEdit', 'nameChange' ].includes( qn.type ) ) {
-                      if ( qn.type == 'qnEdit' ) {
-                        let checkLinkType = getsubmitDetails[0].questionAnswers[sectionDetails].questions[questions[0]].linkType;
-                        if ( checkLinkType && !qn.question.linkType ) {
-                          questions.forEach( ( qnIdx, index ) => {
-                            if ( index != 0 ) {
-                              getsubmitDetails[0].questionAnswers[sectionDetails].questions.splice( qnIdx, 1 );
-                            }
-                          } );
-                          questions = [ questions[0] ];
-                        }
-                      }
-                      questions.forEach( ( qnIdx ) => {
-                        if ( qn.type == 'qnEdit' ) {
-                          getsubmitDetails[0].questionAnswers[sectionDetails].questions[qnIdx].answers.forEach( ( ele ) => {
-                            console.log( ele?.nestedQuestion );
-                            if ( ele?.nestedQuestion.length ) {
-                              ele?.nestedQuestion.forEach( ( nested ) => {
-                                let findIndex = getsubmitDetails[0].questionAnswers[sectionDetails].questions.findIndex( ( qn ) => qn.uniqueNo == nested );
-                                if ( findIndex != -1 ) {
-                                  delete getsubmitDetails[0].questionAnswers[sectionDetails].questions[findIndex].userAnswer;
-                                  let questionDetails = getsubmitDetails[0].questionAnswers[sectionDetails].questions[findIndex];
-                                  let checkQuestionExists = getsubmitDetails[0].questionAnswers[sectionDetails].questions.filter( ( qnDetails ) => qnDetails.qname == questionDetails.qname );
-                                  if ( checkQuestionExists.length > 1 ) {
-                                    getsubmitDetails[0].questionAnswers[sectionDetails].questions.splice( findIndex, 1 );
-                                  } else {
-                                    delete getsubmitDetails[0].questionAnswers[sectionDetails].questions[findIndex].uniqueNo;
-                                    getsubmitDetails[0].questionAnswers[sectionDetails].questions[findIndex].linkquestionenabled = false;
-                                    getsubmitDetails[0].questionAnswers[sectionDetails].questions[findIndex].answers.forEach( ( ele ) => {
-                                      if ( ele?.oldNestedQuestion?.length ) {
-                                        ele.nestedQuestion = ele.oldNestedQuestion;
-                                        ele.linkedQuestion = ele.oldLinkedQuestion;
-                                      }
-                                    } );
-                                  }
-                                }
-                              } );
-                            }
-                          } );
-                          getsubmitDetails[0].questionAnswers[sectionDetails].questions[qnIdx] = qn.question;
-                        } else {
-                          getsubmitDetails[0].questionAnswers[sectionDetails].questions[qnIdx].qname = qn.question.qname;
-                        }
-                      } );
-                    }
-                  }
-                } );
-              }
-            } );
+            getsubmitDetails[0].questionAnswers = sectionList;
             if ( modifiedCount ) {
               getsubmitDetails[0].checklistStatus = 'inprogress';
               getsubmitDetails[0].date_string = dayjs( currentdate ).format( 'YYYY-MM-DD' );
@@ -3370,6 +3659,7 @@ async function insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedche
         element4.restrictAttendance = getCLconfig?.restrictAttendance;
         element4.coverage = getCLconfig?.coverage;
         element4.rawImageUpload = getCLconfig?.rawImageUpload || false;
+        element4.rawVideoUpload = getCLconfig?.rawVideoUpload || false;
         assignUserList.push( { ...element4 } );
       }
     } ) );
@@ -3411,25 +3701,19 @@ async function insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedche
           }
         }
       } else {
-        let unAssignedList = assignUserList.reduce( ( acc, item ) => {
-          if ( !acc[item.userEmail] ) {
-            acc[item.userEmail]=[ item.store_id ];
-          } else {
-            acc[item.userEmail].push( item.store_id );
-          }
-          return acc;
-        }, {} );
+        let deletedList = [];
 
-        let userList = Object.keys( unAssignedList );
+        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.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' ] } } );
-        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 actionType = 'deleteOpenUsers';
+        let teamsMsg;
+        let teamsAlertUrls = process.env.teamsAlertURL ? JSON.parse( process.env.teamsAlertURL ) : '';
+        teamsMsg = 'ClientId: '+ insertdata.client_id + ', Action: '+ actionType + ', ChecklistId: '+ getCLconfig._id + ', Checklist Name: '+ getCLconfig.checkListName;
+        sendTeamsNotification( teamsAlertUrls.checklist, teamsMsg );
 
         let inprogressData = await processedchecklist.find( {
           date_string: insertdata.date_string,
@@ -3440,6 +3724,12 @@ async function insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedche
         }, { userId: 1, store_id: 1 } );
 
         if ( inprogressData.length ) {
+          inprogressData.forEach( ( item ) => {
+            let checkData = assignUserList.find( ( ele ) => ele.userId.toString() == item.userId.toString() && ele.store_id == item.store_id );
+            if ( !checkData ) {
+              deletedList.push( item._id );
+            }
+          } );
           assignUserList = assignUserList.filter( ( item ) => {
             let findData = inprogressData.find( ( ele ) => ele.userId.toString() == item.userId.toString() && ele.store_id == item.store_id );
             if ( !findData ) {
@@ -3448,11 +3738,15 @@ async function insertPCBulkV4( getCLconfig, checklistId, currentdate, updatedche
           } );
         }
 
-        await processedchecklist.deleteMany( { date_string: insertdata.date_string,
-          date_iso: insertdata.date_iso,
-          client_id: insertdata.client_id,
-          checkListId: updatedchecklist._id, checklistStatus: 'open' } );
+        if ( deletedList.length ) {
+          await processedchecklist.deleteMany( { date_string: insertdata.date_string, date_iso: insertdata.date_iso, client_id: insertdata.client_id, checkListId: updatedchecklist._id, _id: { $in: deletedList } } );
+        }
         await processedchecklist.insertMany( assignUserList );
+        actionType = 'insertAssignUsers';
+        teamsMsg;
+        teamsAlertUrls = process.env.teamsAlertURL ? JSON.parse( process.env.teamsAlertURL ) : '';
+        teamsMsg = 'ClientId: '+ insertdata.client_id + ', Action: '+ actionType + ', ChecklistId: '+ getCLconfig._id + ', Checklist Name: '+ getCLconfig.checkListName + ', assignedUserCount:'+ assignUserList.length+', inprogressSubmitCount:' + submittedDetails?.length;
+        sendTeamsNotification( teamsAlertUrls.checklist, teamsMsg );
       }
 
       tokenList.forEach( ( item ) => {
@@ -3527,11 +3821,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', 'queuealert', 'cleaning', 'scrum' ];
+    let aiList = [ 'mobileusagedetection', 'storeopenandclose', 'uniformdetection', 'staffleftinthemiddle', 'customerunattended', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'queuealert', 'cleaning', 'scrum', 'suspiciousactivity', 'boxalert', 'suspiciousfootfall', 'drinking', 'bagdetection' ];
     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 ) );
@@ -3540,9 +3834,13 @@ export const aiChecklist = async ( req, res ) => {
     checklistDetails = [ ...publishList, ...unpublishList ];
 
     checklistDetails.forEach( ( item ) => {
-      item.storeCount = storeDetails;
+      if ( ![ 'mobileusagedetection', 'storeopenandclose', 'cleaning', 'scrum', 'uniformdetection', 'staffleftinthemiddle', 'customerunattended' ].includes( item.checkListType ) ) {
+        item.storeCount = storeDetails;
+      }
     } );
 
+    checklistDetails.sort( ( a, b ) => a.checkListName.localeCompare( b.checkListName ) );
+
     return res.sendSuccess( checklistDetails );
   } catch ( e ) {
     logger.error( 'aiChecklist =>', e );
@@ -3724,12 +4022,7 @@ export const selectAssign = async ( req, res ) => {
       // //Select Store and cluster
       if ( requestData.assignType == 'store' ) {
         let storeQuery = [
-          {
-            $match: {
-              ...( req.user.userType==='client'&&req.user.role!='superadmin' ) ? { storeId: { $in: requestData?.assignedStores } } :{ clientId: requestData.clientId },
-              status: 'active',
-            },
-          },
+          { $match: { clientId: requestData.clientId, status: 'active' } },
           {
             $project: {
               storeName: 1,
@@ -3739,6 +4032,8 @@ export const selectAssign = async ( req, res ) => {
               userEmail: { $arrayElemAt: [ '$spocDetails.email', 0 ] },
               contact: { $arrayElemAt: [ '$spocDetails.contact', 0 ] },
               city: '$storeProfile.city',
+              openTime: '$storeProfile.open',
+              closeTime: '$storeProfile.close',
             },
           },
 
@@ -3776,7 +4071,7 @@ export const selectAssign = async ( req, res ) => {
     }
     return res.sendSuccess( { 'totalCount': resuldData.length, 'data': resuldData } );
   } catch ( e ) {
-    console.log( 'e =>', e );
+    // console.log( 'e =>', e );
     logger.error( 'selectAssign =>', e );
     return res.sendError( e, 500 );
   }
@@ -3788,7 +4083,9 @@ async function assignUsers( data ) {
     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 );
+      // console.log( clusterList );
       let storeDetails = await storeService.find( { _id: { $in: clusterList }, status: 'active' } );
+      // console.log( storeDetails.length );
       assignedData = await Promise.all( storeDetails.map( async ( store ) => {
         let userData = {
           storeId: store.storeId,
@@ -3796,7 +4093,7 @@ async function assignUsers( data ) {
           userName: store.spocDetails?.[0]?.name,
           userEmail: store.spocDetails?.[0]?.email,
           clusterName: clusterDetails?.[0]?.clusterName,
-          id: clusterDetails?.[0]?._id,
+          id: [ clusterDetails?.[0]?._id ],
         };
         return userData;
       } ) );
@@ -3811,7 +4108,7 @@ async function assignUsers( data ) {
           userName: user.userName,
           userEmail: user.email,
           teamName: teamDetails?.[0]?.teamName,
-          id: teamDetails?.[0]?._id,
+          id: [ teamDetails?.[0]?._id ],
         };
         return userData;
       } );
@@ -3849,12 +4146,12 @@ export async function checklistAssign( req, res ) {
         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;
+            acc[obj.storeName].id.push( ...obj.id );
           } else {
             acc[obj.storeName] = { ...obj };
           }
@@ -3866,6 +4163,7 @@ export async function checklistAssign( req, res ) {
         uniqueArr = uniqueArr.reduce( ( acc, obj ) => {
           if ( acc[obj.userEmail] ) {
             acc[obj.userEmail].teamName += ','+ obj.teamName;
+            acc[obj.userEmail].id.push( ...obj.id );
           } else {
             acc[obj.userEmail] = { ...obj };
           }
@@ -3891,10 +4189,83 @@ export async function updateAssign( req, res ) {
     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 };
-    // } );
+    let groupList = [];
+    let groupAssignList = req.body.assignedGroup;
+    req.body.assignedGroup = [ ...new Set( req.body.assignedGroup.flatMap( ( item ) => item.id ) ) ];
+
+    groupAssignList.forEach( ( ele ) => {
+      let gName;
+      if ( ele?.clusterName ) {
+        gName = ele.clusterName.split( ',' );
+      }
+      if ( ele?.teamName ) {
+        gName = ele.teamName.split( ',' );
+      }
+      gName.forEach( ( name ) => {
+        if ( !groupList.includes( name ) ) {
+          groupList.push( name );
+        }
+      } );
+    } );
+
+    let getAssignedDetails = await assignedService.find( { checkListId: req.body.checkListId } );
+    let oldCoverage;
+    if ( getAssignedDetails.length ) {
+      oldCoverage = getAssignedDetails?.[0]?.coverage;
+      let storeClusterDetails = getAssignedDetails.filter( ( ele ) => ele?.storeName || ele?.clusterName );
+      let userTeamDetails = getAssignedDetails.filter( ( ele ) => !ele?.storeName && ( ele?.userName || ele?.teamName ) );
+      storeClusterDetails = [ ...new Set( storeClusterDetails.map( ( ele ) => ele?.storeName || ele?.clusterName ) ) ];
+      userTeamDetails= [ ...new Set( userTeamDetails.map( ( ele ) => ele?.userName || ele?.teamName ) ) ];
+      getAssignedDetails = [ ...storeClusterDetails, ...userTeamDetails ];
+    }
+    let assignedAllList = [ ...req.body.assignedList, ...groupList ];
+    let added = assignedAllList.filter( ( item ) => {
+      let storeUsername;
+      let clusterTeamName;
+      if ( req.body.coverage == 'store' ) {
+        if ( item?.storeName ) {
+          storeUsername = item?.storeName;
+        } else {
+          clusterTeamName = item;
+        }
+      } else {
+        if ( item?.userName ) {
+          storeUsername = item?.userName;
+        } else {
+          clusterTeamName = item;
+        }
+      }
+      if ( !getAssignedDetails.includes( storeUsername ) && !getAssignedDetails.includes( clusterTeamName ) ) {
+        return item;
+      }
+    } ).map( ( ele ) => {
+      if ( req.body.coverage == 'store' ) {
+        return ele?.storeName || ele;
+      } else {
+        return ele?.userName || ele;
+      }
+    } );
+    let removed = getAssignedDetails.filter( ( item ) => {
+      let list;
+      if ( req.body.coverage == 'store' ) {
+        list = assignedAllList.map( ( item ) => item?.storeName );
+        let clusterList = assignedAllList.filter( ( item ) => !item?.storeName );
+        list = [ ...list, ...clusterList ];
+      } else {
+        list = assignedAllList.map( ( item ) => item.userName );
+        let teamList = assignedAllList.filter( ( item ) => !item?.userName );
+        list = [ ...list, ...teamList ];
+      }
+      if ( !list.includes( item ) ) {
+        return item;
+      }
+    } );
+    if ( getAssignedDetails.length ) {
+      removed = { user: oldCoverage == 'user' ? removed : [], store: oldCoverage == 'store' ? removed : [] };
+    } else {
+      removed = { user: [], store: [] };
+    }
+
     await assignedService.deleteMany( { checkListId: req.body.checkListId } );
     let assignedUserList = [];
     let userEmailList = req.body.assignedList.map( ( ele ) => ele.userEmail.toLowerCase() );
@@ -3912,7 +4283,7 @@ export async function updateAssign( req, res ) {
       },
     ];
     let assignUserDetails = await userService.aggregate( query );
-    await Promise.all( req.body.assignedList.map( async ( assign ) => {
+    for ( let assign of req.body.assignedList ) {
       let userDetails = assignUserDetails.find( ( ele ) => ele.email.toLowerCase() == assign.userEmail.toLowerCase() );
       if ( !userDetails ) {
         let userData = {
@@ -3922,7 +4293,7 @@ export async function updateAssign( req, res ) {
           clientId: req.body.clientId,
         };
         userDetails = await createUser( userData );
-        userDetails = userDetails;
+        assignUserDetails.push( userDetails );
       }
       let data = {
         ...assign,
@@ -3936,7 +4307,7 @@ export async function updateAssign( req, res ) {
       };
       delete data._id;
       assignedUserList.push( data );
-    } ) );
+    }
     let assignGroupDetails = [];
     if ( req.body.coverage == 'store' ) {
       assignGroupDetails = await clusterServices.findcluster( { _id: { $in: req.body.assignedGroup } } );
@@ -3958,9 +4329,231 @@ export async function updateAssign( req, res ) {
       }
     } ) );
     await assignedService.insertMany( assignedUserList );
-    return res.sendSuccess( 'Assign details updated successfully' );
+    return res.sendSuccess( { messgage: 'Assign details updated successfully', added, removed } );
   } 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,
+      ...( !req.body?.id ) ? { 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',
+      enableNewDeployedStore: req.body.enableNewDeployedStore,
+      checkListNumber: aiChecklistDetails?.checkListNumber || 1,
+    };
+    let aiResponse = await checklistService.updateOne( { checkListType: aiChecklistDetails.checkListType, client_id: req.body.clientId }, details );
+    let checklistId = req.body?.id || aiResponse?.upsertedId;
+    if ( req.body?.approver ) {
+      let data = [];
+      let existEmail = await traxApprover.find( { checkListId: checklistId, isDeleted: false } );
+      let mailList = existEmail.map( ( item ) => item.userEmail );
+      existEmail = req.body?.approver.filter( ( item ) => mailList.includes( item.value ) ).map( ( item ) => item.value );
+      let userMailList = req.body?.approver.map( ( ele ) => ele.value );
+      req.body?.approver.forEach( ( ele ) => {
+        if ( !existEmail.includes( ele.value ) ) {
+          data.push( {
+            userEmail: ele.value,
+            checkListId: checklistId,
+            type: 'checklist',
+            checkListName: aiChecklistDetails.checkListName,
+            client_id: req.body.clientId,
+          } );
+        }
+      } );
+
+      await traxApprover.updateMany( { checkListId: checklistId, userEmail: { $nin: userMailList } }, { isDeleted: true } );
+      if ( data.length ) {
+        await traxApprover.insertMany( data );
+      }
+    }
+    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 );
+            if ( ele[key] && ele[`configTime${num}`] ) {
+              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: storeData.length,
+          questionCount: 0,
+          publishDate: new Date(),
+          locationCount: 0,
+          scheduleRepeatedType: 'daily',
+          client_id: req.body.clientId,
+          aiStoreList: storeData?.length ? storeData.map( ( store ) => store.store_id ) : [],
+          approvalEnable: req.body?.approver.length ? true : false,
+        };
+        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 );
+    }
+    let clientDetails = await clientService.findOne( { clientId: req.query.clientId }, { 'planDetails.product': 1 } );
+    if ( !clientDetails ) {
+      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,
+      product: clientDetails?.planDetails?.product.map( ( product ) => product.productName ),
+    };
+    return res.sendSuccess( response );
+  } catch ( e ) {
+    logger.error( { functionName: getAiDetails, error: e } );
+    return res.sendError( e, 500 );
+  }
+}