tango-app-api-trax 1.0.0-alpha-task.130

package/src/controllers/mobileTrax.controller.js

@@ -0,0 +1,2327 @@
+import { logger, signedUrl, fileUpload, getOtp, sendEmailWithSES, getUuid } from 'tango-app-api-middleware';
+import * as processedchecklist from '../services/processedchecklist.services.js';
+import * as processedtask from '../services/processedTaskList.service.js';
+import * as PCLconfig from '../services/processedchecklistconfig.services.js';
+import * as processedTaskConfigService from '../services/processedTaskConfig.service.js';
+import * as storeService from '../services/store.service.js';
+import * as checklistService from '../services/checklist.service.js';
+import * as processedTask from '../services/processedTaskList.service.js';
+import * as checklistLogs from '../services/checklistlog.service.js';
+import { insertSingleProcessData } from './trax.controller.js';
+import * as userService from '../services/user.service.js';
+import dayjs from 'dayjs';
+import mongoose from 'mongoose';
+import * as appService from '../services/app.service.js';
+const ObjectId = mongoose.Types.ObjectId;
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+import timeZone from 'dayjs/plugin/timezone.js';
+import { findOTP, updateOneOTP } from '../services/otp.service.js';
+import * as clientService from '../services/clients.services.js';
+import { create } from '../services/authentication.service.js';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import handlebars from 'handlebars';
+dayjs.extend( customParseFormat );
+dayjs.extend( timeZone );
+
+export async function storeList( req, res ) {
+  try {
+    if ( !req.query?.date ) {
+      return res.sendError( 'date is required', 400 );
+    }
+    let userChecklist = await processedchecklist.find( { userId: req.user._id, userEmail: req.user.email, client_id: req.user.clientId, date_string: dayjs( req.query.date ).format( 'YYYY-MM-DD' ) }, { store_id: 1, storeName: 1 } );
+    if ( !userChecklist.length ) {
+      return res.sendSuccess( [] );
+    }
+
+    userChecklist = Array.from(
+        new Map( userChecklist.map( ( item ) => [ item.store_id, item ] ) ).values(),
+    );
+
+    let storeIdList = userChecklist.map( ( item ) => item.store_id );
+    let storeStatus = await storeService.find( { storeId: { $in: storeIdList }, status: 'active', clientId: req.user.clientId }, { storeId: 1, storeName: 1 } );
+    if ( storeStatus.length ) {
+      storeStatus = storeStatus.map( ( item ) => {
+        return { store_id: item.storeId, storeName: item.storeName };
+      } );
+    }
+
+    return res.sendSuccess( storeStatus );
+  } catch ( e ) {
+    logger.error( { function: storeList, error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function storeListv1( req, res ) {
+  try {
+    if ( !req.query?.date ) {
+      return res.sendError( 'date is required', 400 );
+    }
+    let userChecklist = await processedchecklist.find( { userId: req.user._id, userEmail: req.user.email, date_string: dayjs( req.query.date ).format( 'YYYY-MM-DD' ) }, { store_id: 1, storeName: 1 } );
+
+    let userTask = await processedTask.find( { userId: req.user._id, userEmail: req.user.email, date_string: dayjs( req.query.date ).format( 'YYYY-MM-DD' ) }, { store_id: 1, storeName: 1 } );
+
+    if ( !userChecklist.length && !userTask.length ) {
+      return res.sendSuccess( [] );
+    }
+
+    let allStores = [ ...userChecklist, ...userTask ];
+
+    allStores = Array.from(
+        new Map( allStores.map( ( item ) => [ item.store_id, item ] ) ).values(),
+    );
+
+    let storeIdList = allStores.map( ( item ) => item.store_id );
+    let storeStatus = await storeService.find( { storeId: { $in: storeIdList }, status: 'active' }, { storeId: 1, storeName: 1 } );
+    if ( storeStatus.length ) {
+      storeStatus = storeStatus.map( ( item ) => {
+        return { store_id: item.storeId, storeName: item.storeName };
+      } );
+    }
+
+    return res.sendSuccess( storeStatus );
+  } catch ( e ) {
+    logger.error( { function: 'storeListv1', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function startChecklist( req, res ) {
+  try {
+    let requestData = req.body;
+    let findQuery = [];
+    findQuery.push( {
+      $match: {
+        $and: [
+          { _id: new ObjectId( requestData.processedcheckListId ) },
+          { userId: req.user._id },
+          { date_string: requestData.date },
+        ],
+      },
+    } );
+
+    let getBeforeChecklist = await processedchecklist.aggregate( findQuery );
+    if ( !getBeforeChecklist.length ) {
+      return res.sendError( 'Check List Got Edited Please Fill Again', 422 );
+    }
+
+    if ( getBeforeChecklist[0].checklistStatus != 'open' ) {
+      return res.sendError( 'already check list started', 400 );
+    }
+
+    logger.info( `v5 => Checklist Started => store Name: ${getBeforeChecklist[0].storeName}, User Email: ${getBeforeChecklist[0].userEmail}, Checklist Name: ${getBeforeChecklist[0].checkListName}` );
+    let PCLQusestion = await PCLconfig.findOne( { _id: new ObjectId( getBeforeChecklist[0].checkListId ) } );
+    let updateQuery = {};
+    updateQuery._id = new ObjectId( requestData.processedcheckListId );
+    updateQuery.userId = req.user._id;
+    updateQuery.date_string = requestData.date;
+
+    if ( PCLQusestion && PCLQusestion?.questionAnswers && PCLQusestion?.questionAnswers.length > 0 ) {
+      await PCLQusestion.questionAnswers.forEach( ( section ) => {
+        section.questions.forEach( ( question ) => {
+          if ( question.answerType == 'multiplechoicemultiple' ) {
+            let Multianswer = [];
+            if ( question.answers.length > 0 ) {
+              question.answers.forEach( ( answer, ansIndex ) => {
+                Multianswer.push( { 'answer': null, 'no': ansIndex, 'validationAnswer': null } );
+                answer.index = ansIndex;
+              } );
+              question.Multianswer = Multianswer;
+            }
+          } else if ( question.answerType == 'multipleImage' ) {
+            let Multianswer = [];
+            if ( question.answers.length > 0 ) {
+              question.answers.forEach( ( answer, ansIndex ) => {
+                Multianswer.push( { 'answer': null, 'no': ansIndex, 'validationAnswer': null } );
+                answer.index = ansIndex;
+              } );
+              question.Multianswer = Multianswer;
+            }
+          } else {
+            question.Multianswer = [];
+          }
+        } );
+      } );
+    }
+
+    let updateData = {};
+    let storeTimeZone = await storeService.findOne( { storeName: getBeforeChecklist[0].storeName }, { 'storeProfile.timeZone': 1 } );
+    let currentDateTime;
+    if ( storeTimeZone?.storeProfile?.timeZone ) {
+      currentDateTime = dayjs().tz( storeTimeZone?.storeProfile?.timeZone );
+    } else {
+      currentDateTime = dayjs();
+    }
+    updateData.checklistStatus = 'inprogress';
+    updateData.startMobileTime = requestData?.currentTime;
+    updateData.questionAnswers = getBeforeChecklist[0]?.redoStatus ? getBeforeChecklist[0].questionAnswers : PCLQusestion.questionAnswers;
+    // const newDateTime = currentDateTime.add(5, 'hours').add(30, 'minutes');
+    // updateData.startTime_string = newDateTime.format('hh:mm A, DD MMM');
+    updateData.startTime_string = currentDateTime.format( 'hh:mm A, DD MMM YYYY' );
+    updateData.startTime = dayjs.utc( updateData.startTime_string, 'hh:mm A, DD MMM YYYY' ).format();
+
+    let updatechecklist = await processedchecklist.updateOne( updateQuery, updateData );
+    PCLQusestion.startTime = dayjs.utc( updateData.startTime_string, 'hh:mm A, DD MMM YYYY' ).format();
+    PCLQusestion.save();
+    if ( updatechecklist.modifiedCount > 0 ) {
+      findQuery.push( {
+        $project: {
+          checkListName: { $ifNull: [ '$checkListName', '' ] },
+          scheduleStartTime: { $ifNull: [ '$scheduleStartTime', '' ] },
+          scheduleStartTime_iso: { $ifNull: [ '$scheduleStartTime_iso', '' ] },
+          scheduleEndTime: { $ifNull: [ '$scheduleEndTime', '' ] },
+          scheduleEndTime_iso: { $ifNull: [ '$scheduleEndTime_iso', '' ] },
+          checklistStatus: { $ifNull: [ '$checklistStatus', '' ] },
+          checkListId: { $ifNull: [ '$checkListId', '' ] },
+          startTime: { $ifNull: [ '$startTime', '' ] },
+          submitTime: { $ifNull: [ '$submitTime', '' ] },
+          allowedOverTime: { $ifNull: [ '$allowedOverTime', '' ] },
+          allowedStoreLocation: { $ifNull: [ '$checallowedStoreLocationkListName', false ] },
+          questionAnswers: { $ifNull: [ '$questionAnswers', '' ] },
+          redoStatus: { $ifNull: [ '$redoStatus', '' ] },
+        },
+      } );
+      let getupdatedchecklist = await processedchecklist.aggregate( findQuery );
+      let bucket = JSON.parse( process.env.BUCKET );
+      getupdatedchecklist[0].questionAnswers.forEach( ( section ) => {
+        section.questions.forEach( async ( question ) => {
+          if ( question.questionReferenceImage && question.questionReferenceImage!='' ) {
+            question.questionReferenceImage = await signedUrl( { Bucket: bucket.sop, file_path: decodeURIComponent( question.questionReferenceImage ) } );
+          }
+          question.answers.forEach( async ( answer ) => {
+            if ( answer.referenceImage != '' ) {
+              answer.referenceImage = await signedUrl( { Bucket: bucket.sop, file_path: decodeURIComponent( answer.referenceImage ) } );
+            }
+          } );
+        } );
+      } );
+      let logInsertData = {
+        store_id: getBeforeChecklist[0].store_id,
+        storeName: getBeforeChecklist[0].storeName,
+        action: 'started',
+        checklistId: getBeforeChecklist[0].checkListId,
+        checkListName: getBeforeChecklist[0].checkListName,
+        checkListType: getBeforeChecklist[0].checkListType,
+        client_id: req.user.clientId,
+      };
+      await checklistLogs.create( logInsertData );
+
+      let getchecklist = getupdatedchecklist;
+      let questions = [];
+      function processQuestion( question, section, questions, nested=false ) {
+        let findExists = questions.find( ( item ) => item?.qno && item.qno == question.qno );
+        if ( findExists && nested ) {
+          let findIndex = questions.findIndex( ( item ) => item?.qno && item.qno == question.qno );
+          questions.splice( findIndex, 1 );
+          questions.push( question );
+        }
+        if ( !findExists ) {
+          questions.push( question );
+          for ( let answer of question.answers ) {
+            if ( answer.showLinked && answer?.linkedQuestion != '' ) {
+              let linkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
+              if ( linkedQuestion ) {
+                processQuestion( linkedQuestion, section, questions, true );
+              }
+            }
+          }
+        }
+      }
+      for ( let [ index, data ] of getchecklist.entries() ) {
+        for ( let [ secIndex, section ] of data.questionAnswers.entries() ) {
+          questions = [];
+          for ( let question of section.questions ) {
+            processQuestion( question, section, questions );
+          }
+          getchecklist[index].questionAnswers[secIndex].questions = questions;
+        }
+      }
+      return res.sendSuccess( getchecklist );
+    } else {
+      return res.sendError( 'something went wrong please try again', 500 );
+    }
+  } catch ( e ) {
+    logger.error( { function: 'startChecklist', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function startTask( req, res ) {
+  try {
+    const { body: requestData, user } = req;
+
+    const findQuery = [
+      {
+        $match: {
+          $and: [
+            { _id: new ObjectId( requestData.processedcheckListId ) },
+            { userId: user._id },
+            { date_string: requestData.date },
+          ],
+        },
+      },
+    ];
+
+    const getBeforeTask = await processedTask.aggregate( findQuery );
+    if ( !getBeforeTask.length ) {
+      return res.sendError( 'Task edited. Please fill again.', 422 );
+    }
+
+    const task = getBeforeTask[0];
+    if ( task.checklistStatus !== 'open' ) {
+      return res.sendError( 'Task already started', 400 );
+    }
+
+    logger.info(
+        `v5 => Checklist Started => store Name: ${task.storeName}, User Email: ${task.userEmail}, Checklist Name: ${task.checkListName}`,
+    );
+
+    const processedTaskConfig = await processedTaskConfigService.findOne( { _id: new ObjectId( task.checkListId ) } );
+
+    if ( processedTaskConfig?.questionAnswers?.length > 0 ) {
+      for ( const section of processedTaskConfig.questionAnswers ) {
+        for ( const question of section.questions ) {
+          if ( [ 'multiplechoicemultiple', 'multipleImage' ].includes( question.answerType ) ) {
+            question.Multianswer = question.answers.map( ( _, index ) => ( {
+              answer: null,
+              no: index,
+              validationAnswer: null,
+            } ) );
+          } else {
+            question.Multianswer = [];
+          }
+        }
+      }
+    }
+
+    const storeTimeZone = await storeService.findOne(
+        { storeName: task.storeName },
+        { 'storeProfile.timeZone': 1 },
+    );
+    const currentDateTime = storeTimeZone?.storeProfile?.timeZone ?
+      dayjs().tz( storeTimeZone.storeProfile.timeZone ) :
+      dayjs();
+
+    const updateData = {
+      checklistStatus: 'inprogress',
+      startMobileTime: requestData?.currentTime,
+      questionAnswers: task.redoStatus ? task.questionAnswers : processedTaskConfig.questionAnswers,
+      startTime_string: currentDateTime.format( 'hh:mm A, DD MMM YYYY' ),
+      startTime: dayjs
+          .utc( currentDateTime.format( 'hh:mm A, DD MMM YYYY' ), 'hh:mm A, DD MMM YYYY' )
+          .format(),
+    };
+
+    const updateQuery = {
+      _id: new ObjectId( requestData.processedcheckListId ),
+      userId: user._id,
+      date_string: requestData.date,
+    };
+
+    const updateTaskResult = await processedTask.updateOne( updateQuery, updateData );
+
+    if ( !updateTaskResult?.matchedCount ) {
+      return res.sendError( 'Something went wrong, please try again', 500 );
+    }
+
+    processedTaskConfig.startTime = updateData.startTime;
+    await processedTaskConfig.save();
+
+    findQuery.push( {
+      $project: {
+        checkListName: { $ifNull: [ '$checkListName', '' ] },
+        scheduleStartTime: { $ifNull: [ '$scheduleStartTime', '' ] },
+        scheduleStartTime_iso: { $ifNull: [ '$scheduleStartTime_iso', '' ] },
+        scheduleEndTime: { $ifNull: [ '$scheduleEndTime', '' ] },
+        scheduleEndTime_iso: { $ifNull: [ '$scheduleEndTime_iso', '' ] },
+        checklistStatus: { $ifNull: [ '$checklistStatus', '' ] },
+        checkListId: { $ifNull: [ '$checkListId', '' ] },
+        startTime: { $ifNull: [ '$startTime', '' ] },
+        submitTime: { $ifNull: [ '$submitTime', '' ] },
+        allowedOverTime: { $ifNull: [ '$allowedOverTime', '' ] },
+        allowedStoreLocation: { $ifNull: [ '$allowedStoreLocation', false ] },
+        questionAnswers: { $ifNull: [ '$questionAnswers', '' ] },
+        redoStatus: { $ifNull: [ '$redoStatus', '' ] },
+      },
+    } );
+    const getUpdatedTask = await processedTask.aggregate( findQuery );
+
+
+    const bucket = JSON.parse( process.env.BUCKET );
+    await Promise.all(
+        getUpdatedTask[0].questionAnswers.map( ( section ) =>
+          section.questions.map( async ( question ) => {
+            if ( question.questionReferenceImage ) {
+              question.questionReferenceImage = await signedUrl( {
+                Bucket: bucket.sop,
+                file_path: decodeURIComponent( question.questionReferenceImage ),
+              } );
+            }
+            await Promise.all(
+                question.answers.map( async ( answer ) => {
+                  if ( answer.referenceImage ) {
+                    answer.referenceImage = await signedUrl( {
+                      Bucket: bucket.sop,
+                      file_path: decodeURIComponent( answer.referenceImage ),
+                    } );
+                  }
+                } ),
+            );
+          } ),
+        ).flat(),
+    );
+
+
+    const logData = {
+      store_id: task.store_id,
+      storeName: task.storeName,
+      action: 'started',
+      checklistId: task.checkListId,
+      checkListName: task.checkListName,
+      checkListType: task.checkListType,
+      client_id: user.clientId,
+    };
+    await checklistLogs.create( logData );
+
+    return res.sendSuccess( getUpdatedTask );
+  } catch ( error ) {
+    logger.error( { function: 'startTask', error } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function sopMobilechecklistValidater( req, res, next ) {
+  try {
+    let requestData = req.body;
+    let validateError = '';
+    if (
+      !requestData.hasOwnProperty( 'date' ) ||
+            requestData.date === undefined ||
+            requestData.date === null ||
+            requestData.date == ''
+    ) {
+      validateError = validateError + 'Date, ';
+    }
+
+    if ( !requestData.hasOwnProperty( 'processedcheckListId' ) ||
+            requestData.processedcheckListId === undefined ||
+            requestData.processedcheckListId === null ||
+            requestData.processedcheckListId == ''
+    ) {
+      validateError = validateError + 'ProcessedcheckListId, ';
+    }
+
+    if ( !requestData.hasOwnProperty( 'questionAnswers' ) || requestData.questionAnswerslength == 0 ) {
+      validateError = validateError + 'questionAnswers ';
+    }
+
+    if ( validateError.length > 0 ) {
+      return res.sendError( validateError + 'Is Reqired', 400 );
+    } else {
+      next();
+    }
+  } catch ( error ) {
+    logger.error( { function: 'sopMobilechecklistValidater', error: error } );
+    return res.sendError( error );
+  }
+};
+
+export async function sopMobilechecklistQuestionValidator( req, res, next ) {
+  try {
+    let requestData = req.body;
+    requestData.questionAnswers = typeof requestData.questionAnswers == 'string' ? JSON.parse( requestData.questionAnswers ) : requestData.questionAnswers;
+    let getChecklistQA = await processedchecklist.findOne( { _id: new ObjectId( requestData.processedcheckListId ) }, { questionAnswers: 1 } );
+    if ( !getChecklistQA ) {
+      return res.sendError( 'Check List Got Edited Please Fill Again', 422 );
+    }
+    if ( requestData.submittype == 'submit' ) {
+      let reqAnswers = requestData.questionAnswers;
+      let CLQAnswers = getChecklistQA.questionAnswers;
+      let validationCount= 0;
+      CLQAnswers.forEach( ( section ) => {
+        let requestSection = reqAnswers.filter( ( reqSection ) => reqSection.section_id == section.section_id );
+        section.questions.forEach( ( question ) => {
+          question.answers.forEach( ( answer ) => {
+            let sectionQuestion = requestSection.filter( ( secQuestion ) => secQuestion.qno == question.qno );
+            if ( question.answerType == 'multiplechoicemultiple' && ( sectionQuestion[0].Multianswer == null || sectionQuestion[0].Multianswer == '' || !sectionQuestion[0].Multianswer.length ) ) {
+              validationCount++;
+            } else {
+              if ( ![ 'multiplechoicemultiple', 'multipleImage' ].includes( question.answerType ) && ( ( !sectionQuestion[0].linkType && ( sectionQuestion[0].answer == null || sectionQuestion[0].answer == '' ) ) || ( sectionQuestion[0].linkType && sectionQuestion[0].linkquestionenabled && ( sectionQuestion[0].answer == null || sectionQuestion[0].answer == '' ) ) ) ) {
+                validationCount++;
+              }
+            }
+          } );
+        } );
+      } );
+      if ( validationCount ) {
+        return res.sendError( 'Please Fill all Required Fields', 400 );
+      } else {
+        next();
+      }
+    } else {
+      next();
+    }
+  } catch ( e ) {
+    logger.error( { function: 'sopMobilechecklistQuestionValidator', error: e } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export async function sopMobileTaskQuestionValidator( req, res, next ) {
+  try {
+    let requestData = req.body;
+    requestData.questionAnswers = typeof requestData.questionAnswers == 'string' ? JSON.parse( requestData.questionAnswers ) : requestData.questionAnswers;
+    let getChecklistQA = await processedtask.findOne( { _id: new ObjectId( requestData.processedcheckListId ) }, { questionAnswers: 1 } );
+    if ( !getChecklistQA ) {
+      return res.sendError( 'Check List Got Edited Please Fill Again', 422 );
+    }
+    if ( requestData.submittype == 'submit' ) {
+      let reqAnswers = requestData.questionAnswers;
+      let CLQAnswers = getChecklistQA.questionAnswers;
+      let validationCount= 0;
+      CLQAnswers.forEach( ( section ) => {
+        let requestSection = reqAnswers.filter( ( reqSection ) => reqSection.section_id == section.section_id );
+        section.questions.forEach( ( question ) => {
+          question.answers.forEach( ( answer ) => {
+            let sectionQuestion = requestSection.filter( ( secQuestion ) => secQuestion.qno == question.qno );
+            if ( question.answerType == 'multiplechoicemultiple' && ( sectionQuestion[0].Multianswer == null || sectionQuestion[0].Multianswer == '' || !sectionQuestion[0].Multianswer.length ) ) {
+              validationCount++;
+            } else {
+              if ( ![ 'multiplechoicemultiple', 'multipleImage' ].includes( question.answerType ) && ( ( !sectionQuestion[0].linkType && ( sectionQuestion[0].answer == null || sectionQuestion[0].answer == '' ) ) || ( sectionQuestion[0].linkType && sectionQuestion[0].linkquestionenabled && ( sectionQuestion[0].answer == null || sectionQuestion[0].answer == '' ) ) ) ) {
+                validationCount++;
+              }
+            }
+          } );
+        } );
+      } );
+      if ( validationCount ) {
+        return res.sendError( 'Please Fill all Required Fields', 400 );
+      } else {
+        next();
+      }
+    } else {
+      next();
+    }
+  } catch ( e ) {
+    logger.error( { function: 'sopMobileTaskQuestionValidator', error: e } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export async function sopMobilechecklistMultiSectionFormatter( req, res, next ) {
+  try {
+    let requestData = req.body;
+    requestData.questionAnswers = typeof requestData.questionAnswers == 'string' ? JSON.parse( requestData.questionAnswers ) : requestData.questionAnswers;
+    let getChecklistQA = await processedchecklist.findOne( { _id: new ObjectId( requestData.processedcheckListId ) }, { questionAnswers: 1 } );
+    let reqAnswers = requestData.questionAnswers;
+    let CLQAnswers = getChecklistQA.questionAnswers;
+
+    if ( requestData.submittype == 'submit' ) {
+      reqAnswers.forEach( ( reqA ) => {
+        if ( ![ 'multiplechoicemultiple', 'multipleImage' ].includes( reqA?.answerType ) ) {
+          if ( ( !reqA.linkType && ( reqA.answer == null || reqA.answer == '' ) ) || ( reqA.linkType && reqA.linkquestionenabled && ( reqA.answer == null || reqA.answer == '' ) ) ) {
+            return res.sendError( 'Please Fill All Fields', 400 );
+          }
+        }
+      } );
+    }
+
+    let sectionFormat = [];
+    let uniqueSections = {};
+    reqAnswers.forEach( ( item ) => {
+      const key = `${item.section_id}-${item.sectionName}`;
+      if ( !uniqueSections[key] ) {
+        uniqueSections[key] = { id: item.section_id, name: item.sectionName };
+      }
+    } );
+    const uniqueArray = Object.values( uniqueSections );
+    for ( let section of uniqueArray ) {
+      let CLQSection = CLQAnswers.find( ( item ) => item.section_id == section.id );
+      if ( CLQSection ) {
+        let newArray = [];
+        let qaAnswers = CLQSection.questions;
+        let requestSection = reqAnswers.filter( ( item ) => item.section_id == section.id );
+        for ( let i = 0; i < requestSection.length; i++ ) {
+          for ( let j = 0; j < qaAnswers.length; j++ ) {
+            if ( requestSection[i].qno == qaAnswers[j].qno ) {
+              if ( qaAnswers[j].answerType == 'yes/no' ) {
+                let qaans = qaAnswers[j].answers;
+                let yn = [];
+                for ( let k = 0; k < qaans.length; k++ ) {
+                  if ( requestSection[i].answer == qaans[k].answer ) {
+                    if ( qaans[k].validationType == 'Capture Image' || qaans[k].validationType == 'Capture Video' ) {
+                      if ( requestSection[i].validationAnswer ) {
+                        let validateAns = decodeURIComponent( requestSection[i].validationAnswer.split( '?' )[0] );
+                        if ( validateAns.length ) {
+                          let splitImgUrl = validateAns.split( '/' );
+                          if ( splitImgUrl.length > 1 ) {
+                            splitImgUrl.splice( 0, 3 );
+                            qaans[k].validationAnswer = splitImgUrl.join( '/' ) || '';
+                          }
+                        }
+                      }
+                    } else {
+                      qaans[k].descriptivetype = qaAnswers[j].descriptivetype || '';
+                      qaans[k].validationAnswer = requestSection[i].validationAnswer || '';
+                    }
+                    yn.push( qaans[k] );
+                  }
+                }
+                let structure = {};
+                structure.qno = qaAnswers[j].qno;
+                structure.qname = qaAnswers[j].qname;
+                structure.answerType = qaAnswers[j].answerType;
+                structure.runAI = qaAnswers[j].runAI;
+                structure.runAIDescription = qaAnswers[j].runAIDescription;
+                structure.allowUploadfromGallery = qaAnswers[j].allowUploadfromGallery;
+                structure.remarks = requestSection[i].remarks;
+                structure.answers = qaAnswers[j].answers;
+                structure.userAnswer = yn;
+                structure.linkType = qaAnswers[j].linkType;
+                structure.linkquestionenabled = requestSection[i].linkquestionenabled;
+                structure.parentanswer = requestSection[i].parentanswer;
+                structure.questionReferenceImage = qaAnswers[j].questionReferenceImage;
+                structure.descriptivetype = qaAnswers[j].descriptivetype;
+                if ( qaAnswers[j]?.redo ) {
+                  structure.redo = false;
+                }
+                newArray.push( structure );
+              } else if ( qaAnswers[j].answerType == 'multiplechoicesingle' ) {
+                let qaans = qaAnswers[j].answers;
+                let ms = [];
+                for ( let k = 0; k < qaans.length; k++ ) {
+                  if ( requestSection[i].answer == qaans[k].answer ) {
+                    if ( qaans[k].validationType == 'Capture Image' || qaans[k].validationType == 'Capture Video' ) {
+                      if ( requestSection[i].validationAnswer ) {
+                        let validationAnswer = decodeURIComponent( requestSection[i].validationAnswer.split( '?' )[0] );
+                        if ( validationAnswer.length ) {
+                          let splitImgUrl = validationAnswer.split( '/' );
+                          if ( splitImgUrl.length > 1 ) {
+                            splitImgUrl.splice( 0, 3 );
+                            qaans[k].validationAnswer = splitImgUrl.join( '/' ) || '';
+                          }
+                        }
+                      }
+                    } else {
+                      qaans[k].descriptivetype = qaAnswers[j].descriptivetype || '';
+                      qaans[k].validationAnswer = requestSection[i].validationAnswer || '';
+                    }
+                    ms.push( qaans[k] );
+                  }
+                }
+                let structure = {};
+                structure.qno = qaAnswers[j].qno;
+                structure.qname = qaAnswers[j].qname;
+                structure.answerType = qaAnswers[j].answerType;
+                structure.runAI = qaAnswers[j].runAI;
+                structure.runAIDescription = qaAnswers[j].runAIDescription;
+                structure.allowUploadfromGallery = qaAnswers[j].allowUploadfromGallery;
+                structure.remarks = requestSection[i].remarks;
+                structure.answers = qaAnswers[j].answers;
+                structure.userAnswer = ms;
+                structure.linkType = qaAnswers[j].linkType;
+                structure.linkquestionenabled = requestSection[i].linkquestionenabled;
+                structure.parentanswer = requestSection[i].parentanswer;
+                structure.questionReferenceImage = qaAnswers[j].questionReferenceImage;
+                structure.descriptivetype = qaAnswers[j].descriptivetype;
+                if ( qaAnswers[j]?.redo ) {
+                  structure.redo = false;
+                }
+                newArray.push( structure );
+              } else if ( qaAnswers[j].answerType == 'multiplechoicemultiple' ) {
+                let qaans = qaAnswers[j].answers;
+                let mcmo = [];
+                for ( let k = 0; k < qaans.length; k++ ) {
+                  let separatedArray = typeof requestSection[i].Multianswer == 'string' ? JSON.parse( requestSection[i].Multianswer ) : requestSection[i].Multianswer;
+                  for ( let s = 0; s < separatedArray.length; s++ ) {
+                    if ( separatedArray[s].answer == qaans[k].answer ) {
+                      if ( qaans[k].validationType == 'Capture Image' || qaans[k].validationType == 'Capture Video' ) {
+                        if ( separatedArray[s].validationAnswer ) {
+                          let validationAnswer = decodeURIComponent( separatedArray[s].validationAnswer.split( '?' )[0] );
+                          if ( validationAnswer.length ) {
+                            let splitImgUrl = validationAnswer.split( '/' );
+                            if ( splitImgUrl.length > 1 ) {
+                              splitImgUrl.splice( 0, 3 );
+                              qaans[k].validationAnswer = splitImgUrl.join( '/' ) || '';
+                            }
+                          }
+                        }
+                      } else {
+                        qaans[k].descriptivetype = qaAnswers[j].descriptivetype || '';
+                        qaans[k].validationAnswer = separatedArray[s].validationAnswer || '';
+                      }
+
+                      mcmo.push( qaans[k] );
+                    }
+                  }
+                }
+                let structure = {};
+                structure.qno = qaAnswers[j].qno;
+                structure.qname = qaAnswers[j].qname;
+                structure.answerType = qaAnswers[j].answerType;
+                structure.runAI = qaAnswers[j].runAI;
+                structure.runAIDescription = qaAnswers[j].runAIDescription;
+                structure.allowUploadfromGallery = qaAnswers[j].allowUploadfromGallery;
+                structure.remarks = requestSection[i].remarks;
+                structure.answers = qaAnswers[j].answers;
+                structure.userAnswer = mcmo;
+                structure.linkType = qaAnswers[j].linkType;
+                structure.linkquestionenabled = requestSection[i].linkquestionenabled;
+                structure.parentanswer = requestSection[i].parentanswer;
+                structure.questionReferenceImage = qaAnswers[j].questionReferenceImage;
+                structure.descriptivetype = qaAnswers[j].descriptivetype;
+                if ( qaAnswers[j]?.redo ) {
+                  structure.redo = false;
+                }
+                newArray.push( structure );
+              } else if ( qaAnswers[j].answerType == 'multipleImage' ) {
+                let separatedArray = typeof requestSection[i].Multianswer == 'string' ? JSON.parse( requestSection[i].Multianswer ) : requestSection[i].Multianswer;
+                let mcmi = [];
+                // for (let k = 0; k < qaans.length; k++) {
+                for ( let s = 0; s < separatedArray.length; s++ ) {
+                  if ( separatedArray[s].answer && separatedArray[s].answer !='' ) {
+                    let newAnswer = {};
+                    let validationAnswer = decodeURIComponent( separatedArray[s].answer.split( '?' )[0] );
+                    if ( validationAnswer.length ) {
+                      let splitImgUrl = validationAnswer.split( '/' );
+                      if ( splitImgUrl.length > 1 ) {
+                        splitImgUrl.splice( 0, 3 );
+                        newAnswer.answer = splitImgUrl.join( '/' ) || '';
+                      }
+                    }
+
+                    newAnswer.answeroptionNumber = 0;
+                    newAnswer.sopFlag = false;
+                    newAnswer.validation = false;
+                    newAnswer.validationType = '';
+                    newAnswer.referenceImage = '';
+                    newAnswer.allowUploadfromGallery = false;
+                    newAnswer.runAI = false;
+                    newAnswer.descriptivetype = '';
+                    newAnswer.showLinked = false;
+                    newAnswer.linkedQuestion = 0;
+                    newAnswer.nestedQuestion = [];
+                    newAnswer.index = s;
+                    mcmi.push( newAnswer );
+                  }
+                }
+                // }
+                let structure = {};
+                structure.qno = qaAnswers[j].qno;
+                structure.qname = qaAnswers[j].qname;
+                structure.answerType = qaAnswers[j].answerType;
+                structure.runAI = qaAnswers[j].runAI;
+                structure.runAIDescription = qaAnswers[j].runAIDescription;
+                structure.allowUploadfromGallery = qaAnswers[j].allowUploadfromGallery;
+                structure.remarks = requestSection[i].remarks;
+                structure.answers = qaAnswers[j].answers;
+                structure.userAnswer = mcmi;
+                structure.linkType = qaAnswers[j].linkType;
+                structure.linkquestionenabled = requestSection[i].linkquestionenabled;
+                structure.parentanswer = requestSection[i].parentanswer;
+                structure.questionReferenceImage = qaAnswers[j].questionReferenceImage;
+                structure.descriptivetype = qaAnswers[j].descriptivetype;
+                if ( qaAnswers[j]?.redo ) {
+                  structure.redo = false;
+                }
+                newArray.push( structure );
+              } else {
+                let des = [];
+                if ( requestSection[i].answer != 'null' && requestSection[i].answer != '' && requestSection[i].answer != null ) {
+                  let validationAnswer = decodeURIComponent( requestSection[i].answer.split( '?' )[0] );
+                  if ( validationAnswer.length ) {
+                    let splitImgUrl = validationAnswer.split( '/' );
+                    if ( splitImgUrl.length > 1 ) {
+                      splitImgUrl.splice( 0, 3 );
+                      requestSection[i].answer = splitImgUrl.join( '/' );
+                    }
+                  }
+                  let ansstructure = {
+                    answer: requestSection[i].answer,
+                    answeroptionNumber: 1,
+                    sopFlag: false,
+                    validation: false,
+                    validationType: '',
+                    validationAnswer: '',
+                    referenceImage: qaAnswers[j].answers[0].referenceImage,
+                    showLinked: qaAnswers[j].answers[0].showLinked,
+                    linkedQuestion: qaAnswers[j].answers[0].linkedQuestion,
+                  };
+                  if ( qaAnswers[j].answerType == 'date' ) {
+                    ansstructure.dateRangeType = requestSection[i].dateRangeType || false;
+                  }
+                  des.push( ansstructure );
+                }
+                let structure = {};
+                structure.qno = qaAnswers[j].qno;
+                structure.qname = qaAnswers[j].qname;
+                structure.answerType = qaAnswers[j].answerType;
+                structure.runAI = qaAnswers[j].runAI;
+                structure.runAIDescription = qaAnswers[j].runAIDescription;
+                structure.allowUploadfromGallery = qaAnswers[j].allowUploadfromGallery;
+                structure.remarks = requestSection[i].remarks;
+                structure.answers = qaAnswers[j].answers;
+                structure.userAnswer = des;
+                structure.linkType = qaAnswers[j].linkType;
+                structure.linkquestionenabled = requestSection[i].linkquestionenabled;
+                structure.parentanswer = requestSection[i].parentanswer;
+                structure.questionReferenceImage = qaAnswers[j].questionReferenceImage;
+                structure.descriptivetype = qaAnswers[j].descriptivetype;
+                if ( qaAnswers[j]?.redo ) {
+                  structure.redo = false;
+                }
+                newArray.push( structure );
+              }
+            }
+          }
+        }
+        let sectionData = {
+          'section_id': section.id,
+          'sectionName': section.name,
+          'questions': newArray,
+        };
+        sectionFormat.push( sectionData );
+      }
+    }
+
+
+    requestData.questionAnswers = sectionFormat;
+    next();
+  } catch ( error ) {
+    logger.error( { function: 'sopMobileValidater error =>', error: error } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export async function sopMobileTaskMultiSectionFormatter( req, res, next ) {
+  try {
+    let requestData = req.body;
+    requestData.questionAnswers = typeof requestData.questionAnswers == 'string' ? JSON.parse( requestData.questionAnswers ) : requestData.questionAnswers;
+    let getChecklistQA = await processedTask.findOne( { _id: new ObjectId( requestData.processedcheckListId ) }, { questionAnswers: 1 } );
+    let reqAnswers = requestData.questionAnswers;
+    let CLQAnswers = getChecklistQA.questionAnswers;
+
+    if ( requestData.submittype == 'submit' ) {
+      reqAnswers.forEach( ( reqA ) => {
+        if ( ![ 'multiplechoicemultiple', 'multipleImage' ].includes( reqA?.answerType ) ) {
+          if ( ( !reqA.linkType && ( reqA.answer == null || reqA.answer == '' ) ) || ( reqA.linkType && reqA.linkquestionenabled && ( reqA.answer == null || reqA.answer == '' ) ) ) {
+            return res.sendError( 'Please Fill All Fields', 400 );
+          }
+        }
+      } );
+    }
+
+    let sectionFormat = [];
+    let uniqueSections = {};
+    reqAnswers.forEach( ( item ) => {
+      const key = `${item.section_id}-${item.sectionName}`;
+      if ( !uniqueSections[key] ) {
+        uniqueSections[key] = { id: item.section_id, name: item.sectionName };
+      }
+    } );
+    const uniqueArray = Object.values( uniqueSections );
+    for ( let section of uniqueArray ) {
+      let CLQSection = CLQAnswers.find( ( item ) => item.section_id == section.id );
+      if ( CLQSection ) {
+        let newArray = [];
+        let qaAnswers = CLQSection.questions;
+        let requestSection = reqAnswers.filter( ( item ) => item.section_id == section.id );
+        for ( let i = 0; i < requestSection.length; i++ ) {
+          for ( let j = 0; j < qaAnswers.length; j++ ) {
+            if ( requestSection[i].qno == qaAnswers[j].qno ) {
+              if ( qaAnswers[j].answerType == 'yes/no' ) {
+                let qaans = qaAnswers[j].answers;
+                let yn = [];
+                for ( let k = 0; k < qaans.length; k++ ) {
+                  if ( requestSection[i].answer == qaans[k].answer ) {
+                    if ( qaans[k].validationType == 'Capture Image' || qaans[k].validationType == 'Capture Video' ) {
+                      if ( requestSection[i].validationAnswer ) {
+                        let validateAns = decodeURIComponent( requestSection[i].validationAnswer.split( '?' )[0] );
+                        if ( validateAns.length ) {
+                          let splitImgUrl = validateAns.split( '/' );
+                          if ( splitImgUrl.length > 1 ) {
+                            splitImgUrl.splice( 0, 3 );
+                            qaans[k].validationAnswer = splitImgUrl.join( '/' ) || '';
+                          }
+                        }
+                      }
+                    } else {
+                      qaans[k].descriptivetype = qaAnswers[j].descriptivetype || '';
+                      qaans[k].validationAnswer = requestSection[i].validationAnswer || '';
+                    }
+                    yn.push( qaans[k] );
+                  }
+                }
+                let structure = {};
+                structure.qno = qaAnswers[j].qno;
+                structure.qname = qaAnswers[j].qname;
+                structure.answerType = qaAnswers[j].answerType;
+                structure.runAI = qaAnswers[j].runAI;
+                structure.runAIDescription = qaAnswers[j].runAIDescription;
+                structure.allowUploadfromGallery = qaAnswers[j].allowUploadfromGallery;
+                structure.remarks = requestSection[i].remarks;
+                structure.answers = qaAnswers[j].answers;
+                structure.userAnswer = yn;
+                structure.linkType = qaAnswers[j].linkType,
+                structure.linkquestionenabled = requestSection[i].linkquestionenabled,
+                structure.parentanswer = requestSection[i].parentanswer,
+                structure.questionReferenceImage = qaAnswers[j].questionReferenceImage,
+                structure.descriptivetype = qaAnswers[j].descriptivetype,
+                structure.redo = qaAnswers[j]?.redo,
+                newArray.push( structure );
+              } else if ( qaAnswers[j].answerType == 'multiplechoicesingle' ) {
+                let qaans = qaAnswers[j].answers;
+                let ms = [];
+                for ( let k = 0; k < qaans.length; k++ ) {
+                  if ( requestSection[i].answer == qaans[k].answer ) {
+                    if ( qaans[k].validationType == 'Capture Image' || qaans[k].validationType == 'Capture Video' ) {
+                      if ( requestSection[i].validationAnswer ) {
+                        let validationAnswer = decodeURIComponent( requestSection[i].validationAnswer.split( '?' )[0] );
+                        if ( validationAnswer.length ) {
+                          let splitImgUrl = validationAnswer.split( '/' );
+                          if ( splitImgUrl.length > 1 ) {
+                            splitImgUrl.splice( 0, 3 );
+                            qaans[k].validationAnswer = splitImgUrl.join( '/' ) || '';
+                          }
+                        }
+                      }
+                    } else {
+                      qaans[k].descriptivetype = qaAnswers[j].descriptivetype || '';
+                      qaans[k].validationAnswer = requestSection[i].validationAnswer || '';
+                    }
+                    ms.push( qaans[k] );
+                  }
+                }
+                let structure = {};
+                structure.qno = qaAnswers[j].qno;
+                structure.qname = qaAnswers[j].qname;
+                structure.answerType = qaAnswers[j].answerType;
+                structure.runAI = qaAnswers[j].runAI;
+                structure.runAIDescription = qaAnswers[j].runAIDescription;
+                structure.allowUploadfromGallery = qaAnswers[j].allowUploadfromGallery;
+                structure.remarks = requestSection[i].remarks;
+                structure.answers = qaAnswers[j].answers;
+                structure.userAnswer = ms;
+                structure.linkType = qaAnswers[j].linkType,
+                structure.linkquestionenabled = requestSection[i].linkquestionenabled,
+                structure.parentanswer = requestSection[i].parentanswer,
+                structure.questionReferenceImage = qaAnswers[j].questionReferenceImage,
+                structure.descriptivetype = qaAnswers[j].descriptivetype,
+                structure.redo = qaAnswers[j]?.redo,
+                newArray.push( structure );
+              } else if ( qaAnswers[j].answerType == 'multiplechoicemultiple' ) {
+                let qaans = qaAnswers[j].answers;
+                let mcmo = [];
+                for ( let k = 0; k < qaans.length; k++ ) {
+                  let separatedArray = typeof requestSection[i].Multianswer == 'string' ? JSON.parse( requestSection[i].Multianswer ) : requestSection[i].Multianswer;
+                  for ( let s = 0; s < separatedArray.length; s++ ) {
+                    if ( separatedArray[s].answer == qaans[k].answer ) {
+                      if ( qaans[k].validationType == 'Capture Image' || qaans[k].validationType == 'Capture Video' ) {
+                        if ( separatedArray[s].validationAnswer ) {
+                          let validationAnswer = decodeURIComponent( separatedArray[s].validationAnswer.split( '?' )[0] );
+                          if ( validationAnswer.length ) {
+                            let splitImgUrl = validationAnswer.split( '/' );
+                            if ( splitImgUrl.length > 1 ) {
+                              splitImgUrl.splice( 0, 3 );
+                              qaans[k].validationAnswer = splitImgUrl.join( '/' ) || '';
+                            }
+                          }
+                        }
+                      } else {
+                        qaans[k].descriptivetype = qaAnswers[j].descriptivetype || '';
+                        qaans[k].validationAnswer = separatedArray[s].validationAnswer || '';
+                      }
+
+                      mcmo.push( qaans[k] );
+                    }
+                  }
+                }
+                let structure = {};
+                structure.qno = qaAnswers[j].qno;
+                structure.qname = qaAnswers[j].qname;
+                structure.answerType = qaAnswers[j].answerType;
+                structure.runAI = qaAnswers[j].runAI;
+                structure.runAIDescription = qaAnswers[j].runAIDescription;
+                structure.allowUploadfromGallery = qaAnswers[j].allowUploadfromGallery;
+                structure.remarks = requestSection[i].remarks;
+                structure.answers = qaAnswers[j].answers;
+                structure.userAnswer = mcmo;
+                structure.linkType = qaAnswers[j].linkType,
+                structure.linkquestionenabled = requestSection[i].linkquestionenabled,
+                structure.parentanswer = requestSection[i].parentanswer,
+                structure.questionReferenceImage = qaAnswers[j].questionReferenceImage,
+                structure.descriptivetype = qaAnswers[j].descriptivetype,
+                structure.redo = qaAnswers[j]?.redo,
+                newArray.push( structure );
+              } else if ( qaAnswers[j].answerType == 'multipleImage' ) {
+                let separatedArray = typeof requestSection[i].Multianswer == 'string' ? JSON.parse( requestSection[i].Multianswer ) : requestSection[i].Multianswer;
+                let mcmi = [];
+                // for (let k = 0; k < qaans.length; k++) {
+                for ( let s = 0; s < separatedArray.length; s++ ) {
+                  if ( separatedArray[s].answer && separatedArray[s].answer !='' ) {
+                    let newAnswer = {};
+                    let validationAnswer = decodeURIComponent( separatedArray[s].answer.split( '?' )[0] );
+                    if ( validationAnswer.length ) {
+                      let splitImgUrl = validationAnswer.split( '/' );
+                      if ( splitImgUrl.length > 1 ) {
+                        splitImgUrl.splice( 0, 3 );
+                        newAnswer.answer = splitImgUrl.join( '/' ) || '';
+                      }
+                    }
+
+                    newAnswer.answeroptionNumber = 0;
+                    newAnswer.sopFlag = false;
+                    newAnswer.validation = false;
+                    newAnswer.validationType = '';
+                    newAnswer.referenceImage = '';
+                    newAnswer.allowUploadfromGallery = false;
+                    newAnswer.runAI = false;
+                    newAnswer.descriptivetype = '';
+                    newAnswer.showLinked = false;
+                    newAnswer.linkedQuestion = 0;
+                    newAnswer.nestedQuestion = [];
+                    newAnswer.index = s;
+                    mcmi.push( newAnswer );
+                  }
+                }
+                // }
+                let structure = {};
+                structure.qno = qaAnswers[j].qno;
+                structure.qname = qaAnswers[j].qname;
+                structure.answerType = qaAnswers[j].answerType;
+                structure.runAI = qaAnswers[j].runAI;
+                structure.runAIDescription = qaAnswers[j].runAIDescription;
+                structure.allowUploadfromGallery = qaAnswers[j].allowUploadfromGallery;
+                structure.remarks = requestSection[i].remarks;
+                structure.answers = qaAnswers[j].answers;
+                structure.userAnswer = mcmi;
+                structure.linkType = qaAnswers[j].linkType,
+                structure.linkquestionenabled = requestSection[i].linkquestionenabled,
+                structure.parentanswer = requestSection[i].parentanswer,
+                structure.questionReferenceImage = qaAnswers[j].questionReferenceImage,
+                structure.descriptivetype = qaAnswers[j].descriptivetype,
+                structure.redo = qaAnswers[j]?.redo,
+                newArray.push( structure );
+              } else {
+                let des = [];
+                if ( requestSection[i].answer != 'null' && requestSection[i].answer != '' && requestSection[i].answer != null ) {
+                  let validationAnswer = decodeURIComponent( requestSection[i].answer.split( '?' )[0] );
+                  if ( validationAnswer.length ) {
+                    let splitImgUrl = validationAnswer.split( '/' );
+                    if ( splitImgUrl.length > 1 ) {
+                      splitImgUrl.splice( 0, 3 );
+                      requestSection[i].answer = splitImgUrl.join( '/' );
+                    }
+                  }
+                  let ansstructure = {
+                    answer: requestSection[i].answer,
+                    answeroptionNumber: 1,
+                    sopFlag: false,
+                    validation: false,
+                    validationType: '',
+                    validationAnswer: '',
+                    referenceImage: qaAnswers[j].answers[0]?.referenceImage,
+                    showLinked: qaAnswers[j].answers[0]?.showLinked,
+                    linkedQuestion: qaAnswers[j].answers[0]?.linkedQuestion,
+                  };
+                  if ( qaAnswers[j].answerType == 'date' ) {
+                    ansstructure.dateRangeType = requestSection[i].dateRangeType || false;
+                  }
+                  des.push( ansstructure );
+                }
+                let structure = {};
+                structure.qno = qaAnswers[j].qno;
+                structure.qname = qaAnswers[j].qname;
+                structure.answerType = qaAnswers[j].answerType;
+                structure.runAI = qaAnswers[j].runAI;
+                structure.runAIDescription = qaAnswers[j].runAIDescription;
+                structure.allowUploadfromGallery = qaAnswers[j].allowUploadfromGallery;
+                structure.remarks = requestSection[i].remarks;
+                structure.answers = qaAnswers[j].answers;
+                structure.userAnswer = des;
+                structure.linkType = qaAnswers[j].linkType,
+                structure.linkquestionenabled = requestSection[i].linkquestionenabled,
+                structure.parentanswer = requestSection[i].parentanswer,
+                structure.questionReferenceImage = qaAnswers[j].questionReferenceImage,
+                structure.descriptivetype = qaAnswers[j].descriptivetype,
+                structure.redo = qaAnswers[j]?.redo,
+                newArray.push( structure );
+              }
+            }
+          }
+        }
+        let sectionData = {
+          'section_id': section.id,
+          'sectionName': section.name,
+          'questions': newArray,
+        };
+        sectionFormat.push( sectionData );
+      }
+    }
+
+
+    requestData.questionAnswers = sectionFormat;
+    next();
+  } catch ( error ) {
+    logger.error( { function: 'sopMobileValidater error =>', error: error, message: req.body } );
+    return res.sendError( error, 500 );
+  }
+};
+
+function QuestionFlag( req, res ) {
+  try {
+    let flagCount = 0;
+    let inputData = req.body;
+    inputData.questionAnswers.forEach( ( sections ) => {
+      sections.questions.forEach( ( question ) => {
+        if ( question.userAnswer && question.userAnswer.length>0 ) {
+          let answervalidate = question.userAnswer.filter( ( answer ) => {
+            return answer.sopFlag == true;
+          } );
+          flagCount = flagCount + answervalidate.length;
+        }
+      } );
+    } );
+    return flagCount;
+  } catch ( error ) {
+    logger.error( { function: 'QuestionFlag error=>', error: error } );
+    let msg = error.error ? error.error : error;
+    return res.sendError( msg, 500 );
+  }
+}
+
+export async function submitChecklist( req, res ) {
+  try {
+    let requestData = req.body;
+    let findQuery = [];
+    findQuery.push( {
+      $match: {
+        $and: [
+          { _id: new ObjectId( requestData.processedcheckListId ) },
+          { userId: req.user._id },
+          { date_string: requestData.date },
+        ],
+      },
+    } );
+
+    let getchecklist = await processedchecklist.aggregate( findQuery );
+    if ( !getchecklist.length ) {
+      return res.sendError( 'Checklist Got Edited Please Fill Again', 422 );
+    }
+
+    let checklistDetails = await checklistService.findOne( { _id: getchecklist[0].sourceCheckList_id } );
+
+    if ( getchecklist[0].checklistStatus == 'open' ) {
+      return res.sendError( 'checklist in open status need to start', 400 );
+    } else if ( getchecklist[0].checklistStatus == 'submit' ) {
+      return res.sendError( 'checklist Already Submitted', 400 );
+    } else {
+      let updateQuery = {};
+      updateQuery._id = new ObjectId( requestData.processedcheckListId );
+      updateQuery.userId = req.user._id;
+      updateQuery.date_string = requestData.date;
+      let storeTimeZone = await storeService.findOne( { storeName: getchecklist[0].storeName }, { 'storeProfile.timeZone': 1 } );
+      let currentDateTime;
+      if ( storeTimeZone?.storeProfile?.timeZone ) {
+        currentDateTime = dayjs().tz( storeTimeZone?.storeProfile?.timeZone );
+      } else {
+        currentDateTime = dayjs();
+      }
+      let updateData = {};
+      let flagCount = QuestionFlag( req, res );
+      updateData.questionFlag = flagCount;
+      updateData.submitTime_string = currentDateTime.format( 'hh:mm A, DD MMM YYYY' );
+      if ( requestData.submittype == 'draft' ) {
+        logger.info( `v5 => Checklist Save => store Name: ${getchecklist[0].storeName}, User Email: ${getchecklist[0].userEmail}, Checklist Name: ${getchecklist[0].checkListName}` );
+        updateData.questionAnswers = requestData.questionAnswers;
+        updateData.updatedAt = dayjs.utc( currentDateTime.format( 'hh:mm:ss A, DD MMM YYYY' ), 'hh:mm:ss A, DD MMM YYYY' ).format();
+      } else {
+        logger.info( `v5 => Checklist Submit => store Name: ${getchecklist[0].storeName}, User Email: ${getchecklist[0].userEmail}, Checklist Name: ${getchecklist[0].checkListName}` );
+        updateData.questionAnswers = requestData.questionAnswers;
+        updateData.submitTime = dayjs.utc( currentDateTime.format( 'hh:mm:ss A, DD MMM YYYY' ), 'hh:mm:ss A, DD MMM YYYY' ).format();
+        updateData.checklistStatus = 'submit';
+        updateData.updatedAt = dayjs.utc( currentDateTime.format( 'hh:mm:ss A, DD MMM YYYY' ), 'hh:mm:ss A, DD MMM YYYY' ).format();
+        updateData.submitMobileTime = requestData?.currentTime;
+      }
+      updateData.questionAnswers.forEach( ( section ) => {
+        section.questions.forEach( ( question ) => {
+          if ( question.redo === true ) {
+            question.redo = false;
+          }
+        } );
+      } );
+      let updatechecklist = await processedchecklist.updateOne( updateQuery, updateData );
+      if ( updatechecklist?.modifiedCount > 0 ) {
+        if ( checklistDetails && checklistDetails.allowedMultiSubmit && requestData.submittype == 'submit' ) {
+          let currentTime;
+          let date = getchecklist[0].date_string +' '+ getchecklist[0].scheduleEndTime;
+          let scheduleTime;
+          if ( storeTimeZone?.storeProfile?.timeZone ) {
+            currentTime = dayjs().tz( storeTimeZone?.storeProfile?.timeZone );
+            scheduleTime = dayjs( date, 'YYYY-MM-DD hh:mm A' ).tz( storeTimeZone?.storeProfile?.timeZone );
+          } else {
+            currentTime = dayjs();
+            scheduleTime = dayjs( date, 'YYYY-MM-DD hh:mm A' );
+          }
+          if ( currentTime < scheduleTime ) {
+            await insertSingleProcessData( getchecklist[0].sourceCheckList_id, requestData.processedcheckListId );
+          }
+        }
+
+        let logInsertData = {
+          store_id: getchecklist[0].store_id,
+          storeName: getchecklist[0].storeName,
+          action: requestData?.submittype === 'draft' ? 'saved' : 'submitted',
+          checklistId: getchecklist[0].sourceCheckList_id,
+          processedChecklistId: getchecklist[0]._id,
+          checkListName: getchecklist[0].checkListName,
+          checkListType: getchecklist[0].checkListType,
+          client_id: req.user.clientId,
+        };
+
+        await checklistLogs.create( logInsertData );
+        // let time = dayjs().format( 'HH:mm:ss' );
+        // let [ hours, minutes ] = time.split( ':' ).map( Number );
+        // let nearestMultipleOf10Minutes = Math.floor( minutes / 10 ) * 10;
+        // let roundedHours = hours + Math.floor( ( minutes - nearestMultipleOf10Minutes ) / 60 );
+        // let roundedMinutes = nearestMultipleOf10Minutes;
+        // let roundedSeconds = 0;
+        // let roundedTime = `${String( roundedHours ).padStart( 2, '0' )}:${String( roundedMinutes ).padStart( 2, '0' )}:${String( roundedSeconds ).padStart( 2, '0' )}`;
+        // let createdAtDate;
+        // if ( storeTimeZone?.timezone ) {
+        //   createdAtDate = dayjs( `${getchecklist[0].date_string} ${time}`, 'YYYY-MM-DD hh:mm:ss' ).tz( storeTimeZone?.timezone ).utc( '+00:00' );
+        // } else {
+        //   createdAtDate = dayjs( `${getchecklist[0].date_string} ${time}`, 'YYYY-MM-DD hh:mm:ss' ).utc( '+00:00' );
+        // }
+        // let detectionData = {
+        //   client_id: req.user.clientId,
+        //   store_id: getchecklist[0].store_id,
+        //   userName: req.user.name,
+        //   userId: req.user._id,
+        //   time: time,
+        //   type: 'positive',
+        //   checklistName: getchecklist[0].checkListName,
+        //   checklistId: getchecklist[0].checkListId,
+        //   sourceChecklist_id: getchecklist[0].sourceCheckList_id,
+        //   category: 'custom',
+        //   scheduleTime: getchecklist[0].scheduleEndTime_iso,
+        //   startRange: roundedTime,
+        //   date_iso: getchecklist[0].date_iso,
+        //   date_string: getchecklist[0].date_string,
+        //   createdAt: createdAtDate,
+        // };
+        // await detectionService.create( detectionData );
+        updateOpenSearch( req.user, requestData );
+
+        return res.sendSuccess( 'Checklist Updated Successfully' );
+      } else {
+        return res.sendError( 'something went wrong please try again', 500 );
+      }
+    }
+  } catch ( e ) {
+    logger.error( { function: 'submitChecklist', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function submitTask( req, res ) {
+  try {
+    const { body: requestData, user } = req;
+    const { processedcheckListId, date, submittype, currentTime, questionAnswers } = requestData;
+
+
+    const findQuery = [
+      {
+        $match: {
+          _id: new ObjectId( processedcheckListId ),
+          userId: user._id,
+          date_string: date,
+        },
+      },
+    ];
+
+    const [ checklist ] = await processedTask.aggregate( findQuery );
+
+    if ( !checklist ) {
+      return res.sendError( 'Task edited. Please fill again', 422 );
+    }
+
+    // eslint-disable-next-line camelcase
+    const { checklistStatus, storeName, userEmail, checkListName, store_id } = checklist;
+
+    if ( checklistStatus === 'open' ) {
+      return res.sendError( 'Checklist is in open status. Please start.', 400 );
+    }
+
+    if ( checklistStatus === 'submit' ) {
+      return res.sendError( 'Checklist already submitted', 400 );
+    }
+
+    const storeTimeZone = await storeService.findOne( { storeName }, { 'storeProfile.timeZone': 1 } );
+    const currentDateTime = storeTimeZone?.storeProfile?.timeZone ?
+      dayjs().tz( storeTimeZone.storeProfile.timeZone ) :
+      dayjs();
+
+    const updateQuery = {
+      _id: new ObjectId( processedcheckListId ),
+      userId: user._id,
+      date_string: date,
+    };
+
+    questionAnswers.forEach( ( section ) => {
+      section.questions.forEach( ( question ) => {
+        if ( question.redo === true ) {
+          question.redo = false;
+        }
+      } );
+    } );
+
+    const updateData = {
+      questionAnswers,
+      updatedAt: dayjs.utc( currentDateTime.format( 'hh:mm:ss A, DD MMM YYYY' ), 'hh:mm:ss A, DD MMM YYYY' ).format(),
+      questionFlag: QuestionFlag( req, res ),
+    };
+
+    if ( submittype === 'draft' ) {
+      logger.info(
+          `v5 => Checklist Save => store Name: ${storeName}, User Email: ${userEmail}, Checklist Name: ${checkListName}`,
+      );
+      updateData.submitTime_string = currentDateTime.format( 'hh:mm A, DD MMM YYYY' );
+    } else {
+      logger.info(
+          `v5 => Checklist Submit => store Name: ${storeName}, User Email: ${userEmail}, Checklist Name: ${checkListName}`,
+      );
+      Object.assign( updateData, {
+        submitTime: dayjs.utc( currentDateTime.format( 'hh:mm:ss A, DD MMM YYYY' ), 'hh:mm:ss A, DD MMM YYYY' ).format(),
+        checklistStatus: 'submit',
+        submitMobileTime: currentTime,
+        submitTime_string: currentDateTime.format( 'hh:mm A, DD MMM YYYY' ),
+      } );
+    }
+
+    const updateResult = await processedTask.updateOne( updateQuery, updateData );
+
+    if ( updateResult.modifiedCount > 0 ) {
+      const logInsertData = {
+        // eslint-disable-next-line camelcase
+        store_id,
+        storeName,
+        action: submittype === 'draft' ? 'saved' : 'submitted',
+        checklistId: checklist.sourceCheckList_id,
+        processedChecklistId: checklist._id,
+        checkListType: checklist.checkListType,
+        checkListName,
+        client_id: user.clientId,
+      };
+      await checklistLogs.create( logInsertData );
+
+      updateOpenSearchTask( user, requestData );
+
+      return res.sendSuccess( 'Task Updated Successfully' );
+    } else {
+      return res.sendError( 'Something went wrong. Please try again', 500 );
+    }
+  } catch ( error ) {
+    logger.error( { function: 'submitTask', error } );
+    return res.sendError( error.message || 'Internal Server Error', 500 );
+  }
+}
+
+
+async function updateOpenSearch( user, data ) {
+  let findQuery = [ {
+    $match: {
+      $and: [
+        { _id: new ObjectId( data.processedcheckListId ) },
+        { userId: user._id },
+        { date_string: data.date },
+      ],
+    },
+  } ];
+
+  let getchecklist = await processedchecklist.aggregate( findQuery );
+  if ( getchecklist.length ) {
+    let logInsertData = {
+      store_id: getchecklist[0].store_id,
+      storeName: getchecklist[0].storeName,
+      action: 'OpenSearch insert Triggered',
+      checklistId: getchecklist[0].checkListId,
+      checkListName: getchecklist[0].checkListName,
+      checkListType: getchecklist[0].checkListType,
+      client_id: user.clientId,
+    };
+    await checklistLogs.create( logInsertData );
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify( { doc: { ...getchecklist[0] } } ),
+    };
+    let url = JSON.parse( process.env.LAMBDAURL );
+    let searchResponse = await fetch( url.submitChecklist, requestOptions );
+    if ( searchResponse.ok ) {
+      let logInsertData = {
+        store_id: getchecklist[0].store_id,
+        storeName: getchecklist[0].storeName,
+        action: 'OpenSearch inserted Successfully',
+        checklistId: getchecklist[0].checkListId,
+        checkListName: getchecklist[0].checkListName,
+        checkListType: getchecklist[0].checkListType,
+        client_id: user.clientId,
+      };
+      await checklistLogs.create( logInsertData );
+    }
+  }
+}
+
+async function updateOpenSearchTask( user, data ) {
+  let findQuery = [ {
+    $match: {
+      $and: [
+        { _id: new ObjectId( data.processedcheckListId ) },
+        { userId: user._id },
+        { date_string: data.date },
+      ],
+    },
+  } ];
+
+  let getchecklist = await processedTask.aggregate( findQuery );
+  if ( getchecklist.length ) {
+    let logInsertData = {
+      store_id: getchecklist[0].store_id,
+      storeName: getchecklist[0].storeName,
+      action: 'OpenSearch insert Triggered',
+      checklistId: getchecklist[0].checkListId,
+      checkListName: getchecklist[0].checkListName,
+      checkListType: getchecklist[0].checkListType,
+      client_id: user.clientId,
+    };
+    await checklistLogs.create( logInsertData );
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify( { doc: { ...getchecklist[0] } } ),
+    };
+    let url = JSON.parse( process.env.LAMBDAURL );
+    let searchResponse = await fetch( url.submitTask, requestOptions );
+    if ( searchResponse.ok ) {
+      let logInsertData = {
+        store_id: getchecklist[0].store_id,
+        storeName: getchecklist[0].storeName,
+        action: 'OpenSearch inserted Successfully',
+        checklistId: getchecklist[0].checkListId,
+        checkListName: getchecklist[0].checkListName,
+        checkListType: getchecklist[0].checkListType,
+        client_id: user.clientId,
+      };
+      await checklistLogs.create( logInsertData );
+    }
+  }
+}
+
+export async function dashboard( req, res ) {
+  try {
+    let requestData = req.query;
+    let query = [];
+    query.push(
+        {
+          $match: {
+            $and: [
+              { store_id: requestData.store_id },
+              { userId: req.user._id },
+              { date_string: requestData.date },
+              { checkListType: 'custom' },
+              { timeFlagStatus: true },
+            ],
+          },
+        },
+    );
+
+    query.push(
+        {
+          $facet: {
+            total: [
+              { $count: 'total' },
+            ],
+            toDo: [
+              {
+                $match: {
+                  checklistStatus: 'open',
+                },
+              },
+              {
+                $group: {
+                  _id: '',
+                  count: { $sum: 1 },
+                },
+              },
+            ],
+            inprogress: [
+              {
+                $match: {
+                  checklistStatus: 'inprogress',
+                },
+              },
+              {
+                $group: {
+                  _id: '',
+                  count: { $sum: 1 },
+                },
+              },
+            ],
+            submit: [
+              {
+                $match: {
+                  checklistStatus: 'submit',
+                },
+              },
+              {
+                $group: {
+                  _id: '',
+                  count: { $sum: 1 },
+                },
+              },
+            ],
+          },
+        },
+    );
+
+    let resultData = await processedchecklist.aggregate( query );
+
+    resultData = {
+      totalchecklist: resultData[0]?.total.length ? resultData[0]?.total[0]?.total : 0,
+      todo: resultData[0]?.toDo.length ? resultData[0]?.toDo[0]?.count : 0,
+      inprogress: resultData[0]?.inprogress.length ? resultData[0]?.inprogress[0]?.count : 0,
+      done: resultData[0]?.submit.length ? resultData[0]?.submit[0]?.count : 0,
+    };
+
+    return res.sendSuccess( resultData );
+  } catch ( e ) {
+    logger.error( { function: 'dahboard', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function dashboardv1( req, res ) {
+  try {
+    // eslint-disable-next-line camelcase
+    const { store_id, date } = req.query;
+    const userId = req.user._id;
+
+    const baseMatch = {
+      // eslint-disable-next-line camelcase
+      store_id,
+      userId,
+      date_string: date,
+      timeFlagStatus: true,
+    };
+
+    const buildPipeline = ( matchExtraConditions = {} ) => [
+      { $match: { ...baseMatch, ...matchExtraConditions } },
+      {
+        $facet: {
+          total: [ { $count: 'total' } ],
+          toDo: [
+            { $match: { checklistStatus: 'open' } },
+            { $group: { _id: '', count: { $sum: 1 } } },
+          ],
+          inprogress: [
+            { $match: { checklistStatus: 'inprogress' } },
+            { $group: { _id: '', count: { $sum: 1 } } },
+          ],
+          submit: [
+            { $match: { checklistStatus: 'submit' } },
+            { $group: { _id: '', count: { $sum: 1 } } },
+          ],
+        },
+      },
+    ];
+
+    const processResult = ( result ) => ( {
+      totalchecklist: result[0]?.total[0]?.total || 0,
+      todo: result[0]?.toDo[0]?.count || 0,
+      inprogress: result[0]?.inprogress[0]?.count || 0,
+      done: result[0]?.submit[0]?.count || 0,
+    } );
+
+    const checklistQuery = buildPipeline( { checkListType: 'custom' } );
+    const taskQuery = buildPipeline();
+
+    const [ checklistResult, taskResult ] = await Promise.allSettled( [
+      processedchecklist.aggregate( checklistQuery ),
+      processedTask.aggregate( taskQuery ),
+    ] );
+
+    const checklistResultData =
+      checklistResult.status === 'fulfilled' ?
+        processResult( checklistResult.value ) :
+        { totalchecklist: 0, todo: 0, inprogress: 0, done: 0 };
+
+    const taskResultData =
+      taskResult.status === 'fulfilled' ?
+        processResult( taskResult.value ) :
+        { totalchecklist: 0, todo: 0, inprogress: 0, done: 0 };
+
+    const totalResult = {
+      totalchecklist: checklistResultData.totalchecklist + taskResultData.totalchecklist,
+      todo: checklistResultData.todo + taskResultData.todo,
+      inprogress: checklistResultData.inprogress + taskResultData.inprogress,
+      done: checklistResultData.done + taskResultData.done,
+    };
+
+    return res.sendSuccess( totalResult );
+  } catch ( e ) {
+    logger.error( { function: 'dashboardv1', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function checklist( req, res ) {
+  try {
+    let requestData = req.query;
+    let findQuery = [];
+    let findAndQuery = [];
+    let limit;
+    let skip;
+    let sortColumnName;
+    let sortBy;
+    switch ( requestData.checklistStatus ) {
+      case 'open':
+        sortColumnName = 'timeDifference';
+        sortBy = 1;
+        break;
+      case 'inprogress':
+        sortColumnName = 'timeDifference';
+        sortBy = 1;
+        break;
+      case 'submit':
+        sortColumnName = 'submitTime';
+        sortBy = -1;
+        break;
+      default:
+        sortColumnName = 'timeDifference';
+        sortBy = 1;
+        break;
+    }
+
+    findAndQuery.push(
+        { store_id: requestData.store_id },
+        { userId: req.user._id },
+        { date_string: requestData.date },
+        { checkListType: 'custom' },
+        { timeFlagStatus: true },
+    );
+
+    if ( requestData.checklistStatus ) {
+      findAndQuery.push( { checklistStatus: requestData.checklistStatus } );
+    }
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    if ( requestData.searchValue && requestData.searchValue != '' ) {
+      findQuery.push( { $match: { $or: [ { checkListName: { $regex: requestData.searchValue, $options: 'i' } } ] } } );
+    }
+
+    findQuery.push( {
+      $project: {
+        checkListName: { $ifNull: [ '$checkListName', '' ] },
+        scheduleStartTime: { $ifNull: [ '$scheduleStartTime', '' ] },
+        scheduleStartTime_iso: { $ifNull: [ '$scheduleStartTime_iso', '' ] },
+        scheduleEndTime: { $ifNull: [ '$scheduleEndTime', '' ] },
+        scheduleEndTime_iso: { $ifNull: [ '$scheduleEndTime_iso', '' ] },
+        checklistStatus: { $ifNull: [ '$checklistStatus', '' ] },
+        checkListId: { $ifNull: [ '$checkListId', '' ] },
+        startTime: { $ifNull: [ '$startTime', '' ] },
+        submitTime: { $ifNull: [ '$submitTime', '' ] },
+        allowedOverTime: { $ifNull: [ '$allowedOverTime', '' ] },
+        allowedStoreLocation: { $ifNull: [ '$allowedStoreLocation', '' ] },
+        reinitiateStatus: { $ifNull: [ '$reinitiateStatus', '' ] },
+        startTime_string: { $ifNull: [ '$startTime_string', '' ] },
+        submitTime_string: { $ifNull: [ '$submitTime_string', '' ] },
+        timeFlag: { $ifNull: [ '$timeFlag', '' ] },
+        scheduleRepeatedType: { $ifNull: [ '$scheduleRepeatedType', '' ] },
+        timeDifference: { $subtract: [ '$scheduleEndTime_iso', '$date_iso' ] },
+      },
+    } );
+
+    if ( requestData.limit && requestData.offset ) {
+      limit = parseInt( requestData.limit ) || 10;
+      skip = limit * ( requestData.offset ) || 0;
+      findQuery.push( { $skip: skip }, { $limit: limit } );
+    }
+
+    findQuery.push( { $sort: { [sortColumnName]: sortBy } } );
+
+    let totalchecklist = await processedchecklist.aggregate( findQuery );
+
+    return res.sendSuccess( { count: totalchecklist.length, data: totalchecklist } );
+  } catch ( e ) {
+    logger.error( { function: 'checklist', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function checklistv1( req, res ) {
+  try {
+    // eslint-disable-next-line camelcase
+    const { store_id, date, checklistStatus, searchValue } = req.query;
+    const userId = req.user._id;
+
+    const buildPipeline = ( matchExtraConditions = [], type ) => {
+      const matchConditions = [
+        // eslint-disable-next-line camelcase
+        { store_id },
+        { userId },
+        { date_string: date },
+        { timeFlagStatus: true },
+        ...matchExtraConditions,
+      ];
+
+      if ( checklistStatus ) {
+        matchConditions.push( { checklistStatus } );
+      }
+
+      const pipeline = [
+        { $match: { $and: matchConditions } },
+        ...( searchValue ?
+          [ { $match: { $or: [ { checkListName: { $regex: searchValue, $options: 'i' } } ] } } ] :
+          [] ),
+        {
+          $project: {
+            checkListName: { $ifNull: [ '$checkListName', '' ] },
+            scheduleStartTime: { $ifNull: [ '$scheduleStartTime', '' ] },
+            scheduleStartTime_iso: { $ifNull: [ '$scheduleStartTime_iso', '' ] },
+            scheduleEndTime: { $ifNull: [ '$scheduleEndTime', '' ] },
+            scheduleEndTime_iso: { $ifNull: [ '$scheduleEndTime_iso', '' ] },
+            checklistStatus: { $ifNull: [ '$checklistStatus', '' ] },
+            checkListId: { $ifNull: [ '$checkListId', '' ] },
+            startTime: { $ifNull: [ '$startTime', '' ] },
+            submitTime: { $ifNull: [ '$submitTime', '' ] },
+            allowedOverTime: { $ifNull: [ '$allowedOverTime', '' ] },
+            allowedStoreLocation: { $ifNull: [ '$allowedStoreLocation', '' ] },
+            reinitiateStatus: { $ifNull: [ '$reinitiateStatus', '' ] },
+            startTime_string: { $ifNull: [ '$startTime_string', '' ] },
+            submitTime_string: { $ifNull: [ '$submitTime_string', '' ] },
+            timeFlag: { $ifNull: [ '$timeFlag', '' ] },
+            scheduleRepeatedType: { $ifNull: [ '$scheduleRepeatedType', '' ] },
+            timeDifference: { $subtract: [ '$scheduleEndTime_iso', '$date_iso' ] },
+            redoStatus: { $ifNull: [ '$redoStatus', false ] },
+            type: { $ifNull: [ '$checkListType', '' ] },
+          },
+        },
+      ];
+
+      return pipeline;
+    };
+
+    const [ checklistResult, taskResult ] = await Promise.allSettled( [
+      processedchecklist.aggregate( buildPipeline( [ { checkListType: 'custom' } ], 'checklist' ) ),
+      processedTask.aggregate( buildPipeline( [], 'task' ) ),
+    ] );
+
+    const checklistData = checklistResult.status === 'fulfilled' ? checklistResult.value : [];
+    const taskData = taskResult.status === 'fulfilled' ? taskResult.value : [];
+
+    const totalData = [ ...checklistData, ...taskData ];
+
+    if ( !totalData.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    const getSortingParams = ( status ) => {
+      switch ( status ) {
+        case 'submit':
+          return { column: 'submitTime', order: -1 };
+        case 'open':
+        case 'inprogress':
+        default:
+          return { column: 'timeDifference', order: 1 };
+      }
+    };
+
+    const { column: sortColumnName, order: sortBy } = getSortingParams( checklistStatus );
+
+    totalData.sort( ( a, b ) => {
+      if ( sortBy === 1 ) {
+        return ( a[sortColumnName] || 0 ) - ( b[sortColumnName] || 0 );
+      } else {
+        return ( b[sortColumnName] || 0 ) - ( a[sortColumnName] || 0 );
+      }
+    } );
+
+    return res.sendSuccess( { count: totalData.length, data: totalData } );
+  } catch ( e ) {
+    logger.error( { function: 'checklistv1', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function questionList( req, res ) {
+  try {
+    let requestData = req.query;
+    if ( !requestData.processedcheckListId ) {
+      res.sendError( 'processedcheckListId is Required', 400 );
+    }
+
+    let findQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push( { _id: new ObjectId( requestData.processedcheckListId ) } );
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    findQuery.push( {
+      $project: {
+        checkListName: { $ifNull: [ '$checkListName', '' ] },
+        scheduleStartTime: { $ifNull: [ '$scheduleStartTime', '' ] },
+        scheduleStartTime_iso: { $ifNull: [ '$scheduleStartTime_iso', '' ] },
+        scheduleEndTime: { $ifNull: [ '$scheduleEndTime', '' ] },
+        scheduleEndTime_iso: { $ifNull: [ '$scheduleEndTime_iso', '' ] },
+        checklistStatus: { $ifNull: [ '$checklistStatus', '' ] },
+        checkListId: { $ifNull: [ '$checkListId', '' ] },
+        startTime: { $ifNull: [ '$startTime', '' ] },
+        submitTime: { $ifNull: [ '$submitTime', '' ] },
+        allowedOverTime: { $ifNull: [ '$allowedOverTime', '' ] },
+        allowedStoreLocation: { $ifNull: [ '$allowedStoreLocation', '' ] },
+        reinitiateStatus: { $ifNull: [ '$reinitiateStatus', '' ] },
+        questionAnswers: { $ifNull: [ '$questionAnswers', '' ] },
+        getchecklist: { $ifNull: [ '$getchecklist', '' ] },
+        userEmail: { $ifNull: [ '$userEmail', '' ] },
+        storeName: { $ifNull: [ '$storeName', '' ] },
+        redoStatus: { $ifNull: [ '$redoStatus', false ] },
+      },
+    } );
+
+    let getchecklist = await processedchecklist.aggregate( findQuery );
+    if ( !getchecklist.length ) {
+      return res.sendError( 'Check List Got Edited Please Fill Again', 422 );
+    } else {
+      logger.info( `v5 => Checklist Continue => store Name: ${getchecklist[0].storeName}, User Email: ${getchecklist[0].userEmail}, Checklist Name: ${getchecklist[0].checkListName}` );
+      let bucket = JSON.parse( process.env.BUCKET );
+      for ( let [ secIndex, section ] of getchecklist[0].questionAnswers.entries() ) {
+        for ( let [ questionIndex, question ] of section.questions.entries() ) {
+          let Multianswer = [];
+          if ( getchecklist[0].questionAnswers[secIndex].questions[questionIndex].questionReferenceImage && getchecklist[0].questionAnswers[secIndex].questions[questionIndex].questionReferenceImage !='' ) {
+            getchecklist[0].questionAnswers[secIndex].questions[questionIndex].questionReferenceImage = await signedUrl( { file_path: decodeURIComponent( getchecklist[0].questionAnswers[secIndex].questions[questionIndex].questionReferenceImage ), Bucket: bucket.sop } );
+          }
+          for ( let [ ansIndex, answer ] of question.answers.entries() ) {
+            if ( question.answerType == 'multiplechoicemultiple' ) {
+              let checkvalidation = null;
+              if ( answer.validationAnswer && answer.validationAnswer !='' ) {
+                checkvalidation = await signedUrl( { file_path: decodeURIComponent( answer.validationAnswer ), Bucket: bucket.sop } );
+              }
+              Multianswer.push( { 'answer': answer.answer, 'no': ansIndex, 'validationAnswer': checkvalidation } );
+              getchecklist[0].questionAnswers[secIndex].questions[questionIndex].answers[ansIndex].index = ansIndex;
+            }
+            if ( answer.referenceImage != '' ) {
+              getchecklist[0].questionAnswers[secIndex].questions[questionIndex].answers[ansIndex].referenceImage = await signedUrl( { file_path: decodeURIComponent( answer.referenceImage ), Bucket: bucket.sop } );
+            }
+            if ( ( answer.validationType == 'Capture Image' || answer.validationType == 'Capture Video' ) && answer.validationAnswer && answer.validationAnswer != '' ) {
+              getchecklist[0].questionAnswers[secIndex].questions[questionIndex].answers[ansIndex].validationAnswer = await signedUrl( { file_path: decodeURIComponent( answer.validationAnswer ), Bucket: bucket.sop } );
+            }
+          }
+          if ( question?.userAnswer ) {
+            for ( let [ userAnsIndex, userAns ] of question.userAnswer.entries() ) {
+              if ( ( userAns.validationType == 'Capture Image' || userAns.validationType == 'Capture Video' ) && userAns.validationAnswer && userAns.validationAnswer != '' ) {
+                getchecklist[0].questionAnswers[secIndex].questions[questionIndex].userAnswer[userAnsIndex].validationAnswer = await signedUrl( { file_path: decodeURIComponent( userAns.validationAnswer ), Bucket: bucket.sop } );
+              }
+              if ( [ 'image', 'descriptiveImage', 'video' ].includes( question.answerType ) && userAns.answer != '' ) {
+                getchecklist[0].questionAnswers[secIndex].questions[questionIndex].userAnswer[userAnsIndex].answer = await signedUrl( { file_path: decodeURIComponent( userAns.answer ), Bucket: bucket.sop } );
+              }
+              if ( userAns.referenceImage != '' ) {
+                getchecklist[0].questionAnswers[secIndex].questions[questionIndex].userAnswer[userAnsIndex].referenceImage = await signedUrl( { file_path: decodeURIComponent( userAns.referenceImage ), Bucket: bucket.sop } );
+              }
+              if ( question.answerType == 'multiplechoicemultiple' ) {
+                let ansIndex = Multianswer.findIndex( ( item ) => item.answer == userAns.answer );
+                if ( ansIndex ) {
+                  Multianswer[ansIndex].validationAnswer = userAns.validationAnswer;
+                }
+              }
+              if ( question.answerType == 'multipleImage' ) {
+                if ( userAns && userAns.answer && userAns.answer !='' ) {
+                  let manswer = await signedUrl( { file_path: decodeURIComponent( userAns.answer ), Bucket: bucket.sop } );
+                  Multianswer.push( { 'answer': manswer, 'no': userAnsIndex, 'validationAnswer': '' } );
+                } else {
+
+                }
+              }
+            }
+          }
+          if ( question.answerType == 'multiplechoicemultiple' ) {
+            Multianswer.forEach( ( item ) => {
+              if ( item.validationAnswer == null ) {
+                item.answer = null;
+              }
+            } );
+            if ( Multianswer.length ) {
+              question.Multianswer = Multianswer;
+            } else {
+              question.Multianswer = Multianswer;
+            }
+          }
+          if ( question.answerType == 'multipleImage' ) {
+            if ( Multianswer.length ) {
+              question.Multianswer = Multianswer;
+            } else {
+              Multianswer.push( { 'answer': null, 'no': 0, 'validationAnswer': null } );
+              question.Multianswer = Multianswer;
+            }
+          }
+        }
+      }
+
+      let questions = [];
+      function processQuestion( question, section, questions, nested=false ) {
+        let findExists = questions.find( ( item ) => item?.qno && item.qno == question.qno );
+        if ( findExists && nested ) {
+          let findIndex = questions.findIndex( ( item ) => item?.qno && item.qno == question.qno );
+          questions.splice( findIndex, 1 );
+          questions.push( question );
+          for ( let answer of question.answers ) {
+            if ( answer.showLinked && answer?.linkedQuestion != '' ) {
+              let linkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
+              if ( linkedQuestion ) {
+                processQuestion( linkedQuestion, section, questions, true );
+              }
+            }
+          }
+        }
+        if ( !findExists ) {
+          questions.push( question );
+          for ( let answer of question.answers ) {
+            if ( answer.showLinked && answer?.linkedQuestion != '' ) {
+              let linkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
+              if ( linkedQuestion ) {
+                processQuestion( linkedQuestion, section, questions, true );
+              }
+            }
+          }
+        }
+      }
+      for ( let [ index, data ] of getchecklist.entries() ) {
+        for ( let [ secIndex, section ] of data.questionAnswers.entries() ) {
+          questions = [];
+          for ( let question of section.questions ) {
+            processQuestion( question, section, questions );
+          }
+          getchecklist[index].questionAnswers[secIndex].questions = questions;
+        }
+      }
+
+      return res.sendSuccess( getchecklist );
+    }
+  } catch ( e ) {
+    logger.error( { function: 'questionList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function taskQuestionList( req, res ) {
+  try {
+    const { processedcheckListId } = req.query;
+
+    if ( !processedcheckListId ) {
+      return res.sendError( 'processedcheckListId is required', 400 );
+    }
+
+    const findQuery = [
+      {
+        $match: {
+          _id: new ObjectId( processedcheckListId ),
+        },
+      },
+      {
+        $project: {
+          checkListName: { $ifNull: [ '$checkListName', '' ] },
+          scheduleStartTime: { $ifNull: [ '$scheduleStartTime', '' ] },
+          scheduleStartTime_iso: { $ifNull: [ '$scheduleStartTime_iso', '' ] },
+          scheduleEndTime: { $ifNull: [ '$scheduleEndTime', '' ] },
+          scheduleEndTime_iso: { $ifNull: [ '$scheduleEndTime_iso', '' ] },
+          checklistStatus: { $ifNull: [ '$checklistStatus', '' ] },
+          checkListId: { $ifNull: [ '$checkListId', '' ] },
+          startTime: { $ifNull: [ '$startTime', '' ] },
+          submitTime: { $ifNull: [ '$submitTime', '' ] },
+          allowedOverTime: { $ifNull: [ '$allowedOverTime', '' ] },
+          allowedStoreLocation: { $ifNull: [ '$allowedStoreLocation', '' ] },
+          reinitiateStatus: { $ifNull: [ '$reinitiateStatus', '' ] },
+          questionAnswers: { $ifNull: [ '$questionAnswers', '' ] },
+          userEmail: { $ifNull: [ '$userEmail', '' ] },
+          storeName: { $ifNull: [ '$storeName', '' ] },
+        },
+      },
+    ];
+
+    const [ checklist ] = await processedTask.aggregate( findQuery );
+
+    if ( !checklist ) {
+      return res.sendError( 'Task got edited, please fill again', 422 );
+    }
+
+    logger.info(
+        `v5 => Checklist Continue => store Name: ${checklist.storeName}, User Email: ${checklist.userEmail}, Checklist Name: ${checklist.checkListName}`,
+    );
+
+    const bucket = JSON.parse( process.env.BUCKET );
+    const sopBucket = bucket.sop;
+
+    const getSignedUrl = async ( filePath ) =>
+      filePath && filePath !== '' ?
+        await signedUrl( { file_path: decodeURIComponent( filePath ), Bucket: sopBucket } ) :
+        '';
+
+    for ( const section of checklist.questionAnswers || [] ) {
+      for ( const question of section.questions || [] ) {
+        const { answerType, answers = [], userAnswer = [] } = question;
+        const multiAnswer = [];
+
+        if ( typeof question.questionReferenceImage == 'string' && question.questionReferenceImage ) {
+          question.questionReferenceImage = await getSignedUrl( question.questionReferenceImage );
+        } else {
+          if ( question.questionReferenceImage.length ) {
+            let image = [];
+            for ( let img of question.questionReferenceImage ) {
+              image.push( await getSignedUrl( img ) );
+            }
+            question.questionReferenceImage = image;
+          }
+        }
+
+        for ( const [ ansIndex, answer ] of answers.entries() ) {
+          answer.index = ansIndex;
+
+          answer.referenceImage = answer?.referenceImage ? await getSignedUrl( answer.referenceImage ) : '';
+
+          if ( [ 'Capture Image', 'Capture Video' ].includes( answer.validationType ) && answer.validationAnswer ) {
+            answer.validationAnswer = await getSignedUrl( answer.validationAnswer );
+          }
+
+          if ( answerType === 'multiplechoicemultiple'&& answer.validationAnswer ) {
+            const validationAnswer = await getSignedUrl( answer.validationAnswer );
+            multiAnswer.push( { answer: answer.answer, no: ansIndex, validationAnswer } );
+          }
+        }
+
+        for ( const [ userAnsIndex, userAns ] of userAnswer.entries() ) {
+          if ( [ 'Capture Image', 'Capture Video' ].includes( userAns.validationType ) && userAns.validationAnswer ) {
+            userAns.validationAnswer = await getSignedUrl( userAns.validationAnswer );
+          }
+
+          if ( [ 'image', 'descriptiveImage', 'video' ].includes( answerType ) && userAns.answer ) {
+            userAns.answer = await getSignedUrl( userAns.answer );
+          }
+
+          userAns.referenceImage = userAns.referenceImage ? await getSignedUrl( userAns.referenceImage ) : '';
+
+          if ( answerType === 'multiplechoicemultiple' ) {
+            const ansIndex = multiAnswer.findIndex( ( item ) => item.answer === userAns.answer );
+            if ( ansIndex >= 0 ) {
+              multiAnswer[ansIndex].validationAnswer = userAns.validationAnswer;
+            }
+          }
+
+          if ( answerType === 'multipleImage' && userAns.answer ) {
+            const manswer = await getSignedUrl( userAns.answer );
+            multiAnswer.push( { answer: manswer, no: userAnsIndex, validationAnswer: '' } );
+          }
+        }
+
+        if ( [ 'multiplechoicemultiple', 'multipleImage' ].includes( answerType ) ) {
+          question.Multianswer = multiAnswer.length ?
+            multiAnswer.map( ( item ) => ( { ...item, answer: item.validationAnswer ? item.answer : null } ) ) :
+            [ { answer: null, no: 0, validationAnswer: null } ];
+        }
+      }
+    }
+
+    return res.sendSuccess( [ checklist ] );
+  } catch ( error ) {
+    logger.error( { function: 'taskQuestionList', error } );
+    return res.sendError( error.message || 'Internal Server Error', 500 );
+  }
+}
+
+
+export async function uploadAnswerImage( req, res ) {
+  try {
+    let input = req.body;
+    let bucket = JSON.parse( process.env.BUCKET );
+    if ( !input.checklistId ) {
+      return res.sensError( 'Invalid Request: Please include checklistId!', 400 );
+    }
+
+    if ( !input.sectionName ) {
+      return res.sensError( 'Invalid Request: Please include sectionName!', 400 );
+    }
+
+    if ( ( !input.questionNo && input.questionNo != 0 ) ) {
+      return res.sensError( 'Invalid Request: Please include questionNo!', 400 );
+    }
+
+    let date = dayjs().format( 'YYYY-MM-DD' );
+    let folder;
+
+    if ( input.type == 'custom' ) {
+      folder = 'checklist-answers';
+    } else {
+      folder = 'task-answers';
+    }
+
+    if ( req.files && req.files.answerImage ) {
+      let imageUrl;
+      let filePath = `${folder}/${req.user.clientId}/${date}/${input.checklistId}/${input.sectionName.replace( ' ', '' )}/${input.questionNo}/`;
+      let params = {
+        fileName: `${Date.now()}-${Math.floor( 1000 + Math.random() * 9000 )}.${req.files.answerImage.name.split( '.' )[1]}`,
+        Key: filePath,
+        Bucket: bucket.sop,
+        body: req.files.answerImage.data,
+        ContentType: req.files.answerImage.mimetype,
+      };
+
+      imageUrl = await fileUpload( params );
+      if ( imageUrl.errors && imageUrl.errors.length ) {
+        return res.sendError( imageUrl.errors[0].message, '400' );
+      }
+
+      if ( imageUrl != '' ) {
+        imageUrl = await signedUrl( { file_path: imageUrl.Key, Bucket: bucket.sop } );
+
+        return res.sendSuccess( {
+          bucketName: bucket.sop,
+          imageUrl: imageUrl,
+          message: 'Image uploaded successfully!',
+        } );
+      }
+    } else {
+      return res.sendError( 'Please upload an image with key answerImage!', 400 );
+    }
+  } catch ( e ) {
+    logger.error( { function: 'uploadAnswerImage', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function appVersion( req, res ) {
+  try {
+    let reqquery = req.query;
+    let query = [];
+    let limit = req.query.limit || 10;
+    let skip = req.query.limit * req.query.offset || 0;
+    let appNameIds = [];
+
+    if ( reqquery.appName && reqquery.appName !='' ) {
+      let storedata = reqquery.appName.split( ',' );
+      storedata.forEach( ( element ) => {
+        appNameIds.push( element );
+      } );
+    }
+
+    if ( reqquery.appName && reqquery.appName !='' ) {
+      query.push( { $match: { appName: { $in: appNameIds } } } );
+    }
+
+    query.push( {
+      $facet: {
+        data: [
+          { $skip: skip }, { $limit: limit },
+        ],
+        count: [
+          { $count: 'count' },
+        ],
+      },
+    } );
+
+    let response = await appService.aggregate( query );
+    return res.sendSuccess( { count: response[0].count.length ? response[0].count[0].count : 0, data: response[0].data } );
+  } catch ( e ) {
+    logger.error( { function: 'appVersion', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
+export async function updateappVersion( req, res ) {
+  try {
+    let reqData = req.body;
+    if ( !reqData.appName ) {
+      return res.sendError( 'appName Required', 400 );
+    }
+
+    if ( !reqData.appVersion ) {
+      return res.sendError( 'appVersion Required', 400 );
+    }
+
+    let checkQuery = {};
+    checkQuery.appName = reqData.appName;
+
+    let insertData = await appService.updateOne( checkQuery, reqData );
+    if ( insertData ) {
+      return res.sendSuccess( 'App Version Update Done' );
+    } else {
+      return res.sendError( 'Something went wrong please try again', 500 );
+    }
+  } catch ( error ) {
+    logger.error( { function: 'appVersionupdate', error: error } );
+    if ( error.name === 'ValidationError' ) return res.sendError( error, 400 );
+    else return res.sendError( error, 500 );
+  }
+};
+
+export async function login( req, res ) {
+  try {
+    let inputData = req.body;
+    const query = {
+      email: { $regex: new RegExp( `^${inputData.email}$`, 'i' ) },
+    };
+    const result = await userService.findOne( query );
+    if ( !result ) {
+      return res.sendError( `User mail not Exists`, 401 );
+    }
+    if ( !result.isActive ) {
+      return res.sendError( 'The user has been unauthorized to login', 401 );
+    }
+    if ( inputData.otp ) {
+      const otpMatching = await findOTP( { email: inputData.email, type: 'login', otp: inputData.otp } );
+      if ( !otpMatching?.length ) {
+        return res.sendError( `Invalid OTP`, 401 );
+      }
+    } else {
+      const otp = getOtp();
+      await updateOneOTP( { email: inputData.email, type: 'login' }, { email: inputData.email, otp: otp, type: 'login' } );
+      const emailVars = {
+        email: inputData.email,
+        otp: otp,
+        name: result.userName,
+      };
+      await sendSignInOtpEmail( emailVars );
+      return res.sendSuccess( { result: 'VERIFY-OTP' } );
+    }
+    const token = {
+      authenticationToken: await getUuid(),
+      refreshToken: await getUuid(),
+    };
+    const record = {
+      user: result?._id,
+      token: token?.authenticationToken,
+      refreshToken: token?.refreshToken,
+      type: 'retail',
+    };
+
+    let userDetails = await userService.findOne( { fcmToken: inputData.fcmToken } );
+
+    if ( userDetails ) {
+      await userService.updateOne( { _id: userDetails?._id }, { fcmToken: '' } );
+    }
+
+    const auth = await create( record );
+    await userService.updateOne( { _id: result?._id }, { refreshToken: token?.refreshToken, fcmToken: inputData.fcmToken } );
+
+    if ( auth ) {
+      return res.sendSuccess( { result: token } );
+    }
+  } catch ( e ) {
+    logger.error( { function: 'login', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export const sendSignInOtpEmail = async ( emailVars ) => {
+  try {
+    const ses = JSON.parse( process.env.SES );
+    const url = JSON.parse( process.env.URL );
+    const attachments = null;
+    const subject = 'Fwd:  Tango Eye | Verify OTP';
+    const fileContent = readFileSync( join() + '/src/hbs/login-otp.hbs', 'utf8' );
+    const htmlContent = handlebars.compile( fileContent );
+    const html = htmlContent( { ...emailVars, domain: url.apiDomain } );
+    const result = await sendEmailWithSES( emailVars.email, subject, html, attachments, ses.adminEmail );
+    return result;
+  } catch ( error ) {
+    logger.error( { error: error, function: 'sendSignInOtpEmail' } );
+    return error;
+  }
+};
+
+
+export async function location( req, res ) {
+  try {
+    let input = req.body;
+    if ( input.latitude && input.longitude ) {
+      let storeLatitude = req.sop_assigned_store.latitude;
+      let storeLongitude = req.sop_assigned_store.longitude;
+
+      function degreesToRadians( degrees ) {
+        let radians = ( degrees * Math.PI ) / 180;
+        return radians;
+      }
+
+      function calcDistance( startingCoords, destinationCoords ) {
+        let startingLat = degreesToRadians( startingCoords.latitude );
+        let startingLong = degreesToRadians( startingCoords.longitude );
+        let destinationLat = degreesToRadians( destinationCoords.latitude );
+        let destinationLong = degreesToRadians( destinationCoords.longitude );
+
+        // Radius of the Earth in kilometers
+        let radius = 6571;
+
+        // Haversine equation
+        let distanceInKilometers =
+                        Math.acos( Math.sin( startingLat ) * Math.sin( destinationLat ) +
+                        Math.cos( startingLat ) * Math.cos( destinationLat ) *
+                        Math.cos( startingLong - destinationLong ) ) * radius;
+        return distanceInKilometers*1000; // to metres
+      }
+
+      let sCoords = {
+        latitude: storeLatitude,
+        longitude: storeLongitude,
+      };
+
+      let dCoords = {
+        latitude: input.latitude,
+        longitude: input.longitude,
+      };
+
+      let distance = calcDistance( sCoords, dCoords );
+
+      let brand = await clientService.findOne( { clientId: req.user.clientId } );
+
+      let radiusConfigured = brand ? ( brand.storeRadiusConfig ? brand.storeRadiusConfig : 500 ) : 500;
+      let actualDistance = ( ( distance/1000.0 ) || 0 ).toFixed( 2 );
+      let actualDistanceMSG = 'You are '+actualDistance+' KM far from the store location';
+
+      if ( distance<=radiusConfigured ) {
+        return res.sendSuccess( { locationRadiusCheck: true, distance: distance, unit: 'metre', message: actualDistanceMSG } );
+      } else {
+        return res.sendSuccess( { locationRadiusCheck: false, distance: distance, unit: 'metre', message: actualDistanceMSG } );
+      }
+    } else {
+      return res.sendError( 'Please include latitude and longitude!', 400 );
+    }
+  } catch ( e ) {
+    logger.error( { error: e, function: 'location' } );
+    return sendError( error, 500 );
+  }
+}
+
+export async function getStoreLocation( req, res, next ) {
+  try {
+    let input = req.body;
+    if ( input.store_id ) {
+      let storeDetails = await storeService.findOne( { storeId: input.store_id }, { storeProfile: 1 } );
+      if ( storeDetails ) {
+        req.sop_assigned_store = storeDetails.storeProfile;
+        next();
+      } else {
+        return res.sendError( 'Invalid store_id provided!', 400 );
+      }
+    } else {
+      return res.sendError( 'No store/Checklist assigned to the user!', 400 );
+    }
+  } catch ( error ) {
+    logger.error( { function: 'SOP Mobile store check middleware error', error: error } );
+    let msg = error.error ? error.error : error;
+    return res.sendError( msg, 500 );
+  }
+};