tango-app-api-task 1.0.0-alpha.0

package/src/controllers/task.controller.js

@@ -0,0 +1,1059 @@
+import { logger, fileUpload, signedUrl } from 'tango-app-api-middleware';
+import * as taskService from '../service/task.service.js';
+import * as checklistLogs from '../service/checklistLog.service.js';
+import * as taskQuestionService from '../service/taskQuestion.service.js';
+import * as taskAssignService from '../service/taskAssign.service.js';
+import * as userService from '../service/user.service.js';
+import * as storeService from '../service/store.service.js';
+import * as traxApprover from '../service/approver.service.js';
+// import * as domainService from '../service/domain.service.js';
+import mongoose from 'mongoose';
+const ObjectId = mongoose.Types.ObjectId;
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+import utc from 'dayjs/plugin/utc.js';
+dayjs.extend( utc );
+dayjs.extend( customParseFormat );
+import * as taskProcessedConfigService from '../service/processedTaskConfig.service.js';
+import * as taskProcessedService from '../service/processedTaskList.service.js';
+
+export async function createUpdateTask( req, res ) {
+  try {
+    let inputBody = req.body;
+    let questionCount = 0;
+    let checkListId;
+    let query;
+    let checkExistsQuery = { client_id: req.body.clientId, checkListName: inputBody.checklistName, isdeleted: false };
+    let checkExists;
+    if ( req.body._id ) {
+      checkExistsQuery['_id'] = { $nin: [ new ObjectId( req.body._id ) ] };
+    }
+
+    checkExists = await taskService.findOne( checkExistsQuery );
+
+    if ( checkExists ) {
+      return res.sendError( { message: 'Task name already exists' }, 400 );
+    }
+
+    inputBody.sections.forEach( async ( element ) => {
+      if ( !element?.questions?.length && inputBody.submitType == 'configure' ) {
+        return res.sendError( { message: 'Question is required' }, 400 );
+      }
+      if ( element?.questions?.length ) {
+        questionCount = questionCount + element?.questions?.length;
+      }
+    } );
+
+    let checkListDetails = {
+      checkListName: inputBody.checklistName,
+      checkListDescription: inputBody.checklistDescription,
+      createdBy: req.user._id,
+      createdByName: req.user.userName,
+      questionCount: questionCount,
+      client_id: req.body?.clientId,
+    };
+    if ( req.body._id ) {
+      query = { _id: req.body._id, client_id: req.body?.clientId };
+    } else {
+      query = { checkListName: inputBody.checklistName, client_id: req.body?.clientId };
+    }
+    let data = await taskService.updateOne( query, checkListDetails );
+    if ( data.upsertedId || req.body._id ) {
+      checkListId = data?.upsertedId || req.body._id;
+      let logInsertData = {
+        action: req.body?._id ? 'checklistupdate' : 'checklistCreate',
+        checklistId: checkListId,
+        checkListName: inputBody.checklistName,
+        createdBy: req.user._id,
+        createdByName: req.user.userName,
+        client_id: req.body.clientId,
+        sections: inputBody?.sections,
+      };
+      await checklistLogs.create( logInsertData );
+      let sectionList = [];
+      if ( inputBody.sections.length ) {
+        for ( let i = 0; i < inputBody?.sections?.length; i++ ) {
+          let section = inputBody.sections[i];
+          section.questions.forEach( ( section ) => {
+            if ( section.questionReferenceImage && section.questionReferenceImage !='' ) {
+              let imgUrl = decodeURIComponent( section.questionReferenceImage.split( '?' )[0] );
+              let url = imgUrl.split( '/' );
+              url.splice( 0, 3 );
+              section.questionReferenceImage = url.join( '/' );
+            }
+            section.answers.forEach( ( answer ) => {
+              if ( answer.referenceImage != '' ) {
+                let imgUrl = decodeURIComponent( answer.referenceImage.split( '?' )[0] );
+                let url = imgUrl.split( '/' );
+                url.splice( 0, 3 );
+                answer.referenceImage = url.join( '/' );
+              }
+            } );
+          } );
+
+          for ( let [ index, question ] of section.questions.entries() ) {
+            await processNested( index, question );
+          }
+
+          async function processNested( qIdx, question, nestedIndex=-1 ) {
+            if ( question?.answers?.length ) {
+              for ( let [ index, answer ] of question?.answers?.entries() ) {
+                if ( !section.questions[qIdx].answers[index]?.nestedQuestion && nestedIndex == -1 ) {
+                  section.questions[qIdx].answers[index].nestedQuestion = [];
+                }
+                if ( answer.showLinked ) {
+                  if ( nestedIndex != -1 ) {
+                    section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
+                  } else {
+                    section.questions[qIdx].answers[index].nestedQuestion.push( answer.linkedQuestion );
+                  }
+                  let nestedLinkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
+                  if ( nestedLinkedQuestion ) {
+                    let findNestedAnswers = nestedLinkedQuestion.answers.find( ( item ) => item.showLinked );
+                    if ( findNestedAnswers ) {
+                      if ( nestedIndex != -1 ) {
+                        await processNested( qIdx, nestedLinkedQuestion, nestedIndex );
+                      } else {
+                        await processNested( qIdx, nestedLinkedQuestion, index );
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+
+          sectionList.push( {
+            section: section?.name || 'Section 1',
+            createdBy: req.user._id,
+            createdByName: req.user.userName,
+            client_id: req.body.clientId,
+            checkListId: checkListId,
+            question: section.questions,
+            checkList: inputBody.checklistName,
+          } );
+        }
+
+        if ( req.body._id ) {
+          await taskQuestionService.deleteMany( { checkListId: checkListId } );
+        }
+        await taskQuestionService.insertMany( sectionList );
+        let message = req.body?._id ? 'Task Updated Successfully' : 'Task Created Successfully';
+        return res.sendSuccess( { checklistId: checkListId, message: message } );
+      } else {
+        if ( inputBody.submitType == 'save' ) {
+          return res.sendSuccess( { checklistId: checkListId, message: message } );
+        }
+      }
+    }
+  } catch ( e ) {
+    logger.error( { functionName: 'createTask', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function deleteTask( req, res ) {
+  try {
+    let taskDetails = await taskService.findOne( { _id: req.params.taskId }, { isdeleted: 1 } );
+    if ( !taskDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    taskDetails.isdeleted = true;
+    taskDetails.save().then( async () => {
+      await taskAssignService.updateMany( { checkListId: req.params.taskId }, { isdeleted: true } );
+      await taskQuestionService.updateMany( { checkListId: req.params.taskId }, { isdeleted: true } );
+      return res.sendSuccess( 'Task Deleted Successfully' );
+    } ).catch( ( e ) => {
+      logger.error( { functionName: 'deleteTask', error: e } );
+      return res.sendError( e, 500 );
+    } );
+  } catch ( e ) {
+    logger.error( { functionName: 'deleteTask', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function taskDetails( req, res ) {
+  try {
+    let result = {};
+    let sectionList = [];
+    let storechecklistdetails;
+    let query = {};
+
+    if ( !req.query.taskId ) {
+      return res.sendError( { message: 'Task Id is required' }, 400 );
+    }
+
+    if ( !req.query.clientId ) {
+      return res.sendError( { message: 'Client Id is required' }, 400 );
+    }
+
+    query._id = req.query.taskId,
+    query.client_id = req.query.clientId;
+
+    storechecklistdetails = await taskService.findOne( query );
+
+    if ( !storechecklistdetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    query = {
+      checkListId: storechecklistdetails._id,
+      isdeleted: false,
+    };
+
+    let questionDetails = await taskQuestionService.find( query );
+    if ( questionDetails.length ) {
+      let sections = [];
+      let bucket = JSON.parse( process.env.BUCKET );
+      questionDetails.forEach( ( item ) => {
+        item.question.forEach( async ( question ) => {
+          if ( question.questionReferenceImage && question.questionReferenceImage !='' ) {
+            let inputData = {
+              Bucket: bucket.sop,
+              file_path: decodeURIComponent( question.questionReferenceImage ),
+            };
+            question.questionReferenceImage = await signedUrl( inputData );
+          }
+          question.answers.forEach( async ( answer ) => {
+            if ( answer.referenceImage != '' ) {
+              let inputData = {
+                Bucket: bucket.sop,
+                file_path: decodeURIComponent( answer.referenceImage ),
+              };
+              answer.referenceImage = await signedUrl( inputData );
+            }
+          } );
+        } );
+        sections.push( {
+          id: item._id,
+          name: item.section,
+          questions: item.question,
+        } );
+      } );
+      sectionList = sections;
+    }
+    if ( storechecklistdetails ) {
+      result.checkListDetails = { ...storechecklistdetails._doc };
+      let removedUsers = await taskAssignService.find( { checkFlag: false, checkListId: storechecklistdetails._id }, { _id: 1 } );
+      removedUsers = removedUsers?.map( ( item ) => item._id );
+      result.checkListDetails = { ...result.checkListDetails, ...{ sections: sectionList }, ...{ removedUsers: removedUsers } };
+    }
+    return res.sendSuccess( result );
+  } catch ( e ) {
+    logger.error( { functionName: 'taskDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function validateUser( req, res ) {
+  try {
+    if ( !req.body.assignedUsers.length ) {
+      return res.sendError( 'Please Enter User Details', 400 );
+    }
+
+    let users = req.body.assignedUsers;
+    let userEmail = [];
+    let storeId = [];
+    let domainExists = [];
+
+    const duplicateStore = users.reduce( ( acc, obj ) => {
+      if ( !acc[obj.storeName.toLowerCase()] ) {
+        acc[obj.storeName.toLowerCase()] = {
+          email: [ obj.userEmail.toLowerCase() ],
+          count: 1,
+        };
+      } else {
+        if ( acc[obj.storeName.toLowerCase()] ) {
+          if ( acc[obj.storeName.toLowerCase()].email.includes( obj.userEmail.toLowerCase() ) ) {
+            acc[obj.storeName.toLowerCase()].count++;
+          } else {
+            acc[obj.storeName.toLowerCase()].email.push( obj.userEmail.toLowerCase() );
+          }
+        }
+      }
+      return acc;
+    }, {} );
+
+    const duplicateStores = Object.keys( duplicateStore ).filter( ( storeName ) => duplicateStore[storeName].count > 1 );
+    if ( duplicateStores.length ) {
+      return res.sendSuccess( { validate: false, ExistsEmail: duplicateStores, message: 'Store and email are duplicated' } );
+    }
+
+    if ( !req.body?.addUser ) {
+      await Promise.all( users.map( async ( chunk ) => {
+        await processUser( [ chunk ] );
+      } ) );
+
+      if ( userEmail.length || storeId.length || domainExists.length ) {
+        if ( userEmail.length ) {
+          let data = [];
+          let alreadyExist = [];
+          for ( let user of userEmail ) {
+            let checkExistEmail = await userService.findOne( { email: user.userEmail } );
+            if ( checkExistEmail ) {
+              alreadyExist.push( user.userEmail );
+            }
+          }
+          if ( alreadyExist.length ) {
+            let email = [ ...new Set( alreadyExist ) ];
+            return res.sendError( `${email.join()} - email already exist`, 500 );
+          } else {
+            userEmail.forEach( ( item ) => {
+              data.push( {
+                userName: item.userName,
+                email: item.userEmail,
+                mobileNumber: '',
+                clientId: req.body.clientId,
+              } );
+            } );
+            await Promise.all( data.map( async ( chunk ) => {
+              await createUser( chunk );
+            } ) );
+          }
+        }
+        return res.sendSuccess( { validate: false, user: userEmail, store: storeId, domain: domainExists } );
+      }
+
+      let id = await uploadUser( req, res );
+      if ( id ) {
+        return res.sendSuccess( { validate: true, id } );
+      }
+
+      async function processUser( data ) {
+        await Promise.all( data.map( async ( item ) => {
+          let email = item.userEmail.toLowerCase();
+          let query = [
+            {
+              $project: {
+                newEmail: { $toLower: '$email' },
+                isActive: 1,
+                clientId: 1,
+              },
+            },
+            {
+              $match: {
+                newEmail: email,
+                isActive: true,
+                clientId: req.body.clientId,
+              },
+            },
+          ];
+          let userDetails = await userService.aggregate( query );
+          if ( !userDetails.length ) {
+            // let checkDomain = item.userEmail.split( '@' )[1].toLowerCase();
+            // let brandDomainExists = await domainService.findOne( { domain: { $regex: checkDomain } } );
+            // if ( !brandDomainExists ) {
+            //   domainExists.push( { message: 'Domain is not exists', email: item.userEmail } );
+            // }
+            let filteredEmail = userEmail.find( ( ele ) => ele.userEmail.toLowerCase() == item.userEmail.toLowerCase() );
+            if ( !filteredEmail ) {
+              userEmail.push( { userName: item.userName, userEmail: item.userEmail } );
+            }
+          }
+          let storeName = item.storeName.toLowerCase();
+          let storeQuery = [
+            {
+              $project: {
+                'storeName': { $toLower: '$storeName' },
+                'clientId': 1,
+                'storeProfile.city': 1,
+                'status': 1,
+              },
+            },
+            {
+              $match: {
+                clientId: req.body.clientId,
+                storeName: storeName,
+              },
+            },
+          ];
+          let storeExists = await storeService.aggregate( storeQuery );
+          if ( !storeExists.length ) {
+            storeId.push( { store: item.storeName, message: '' } );
+          }
+          if ( storeExists.length && !storeExists[0]?.storeProfile?.city && !item.city ) {
+            storeId.push( { store: item.storeName, message: 'city is required' } );
+          }
+          if ( storeExists.length && storeExists[0].status != 'active' ) {
+            storeId.push( { store: item.storeName, message: 'store is inactive' } );
+          }
+        } ) );
+      }
+    } else {
+      if ( req.body.hasOwnProperty( 'delete' ) ) {
+        let checkExists = await taskAssignService.findOne( { userEmail: req.body.assignedUsers[0].userEmail, storeName: req.body.assignedUsers[0].storeName } );
+        if ( checkExists ) {
+          return res.sendSuccess( 'User already exists' );
+        }
+      }
+
+      let id = await uploadUser( req, res );
+      if ( id ) {
+        return res.sendSuccess( { validate: true, id } );
+      }
+    }
+  } catch ( e ) {
+    logger.error( { functionName: 'validateUser 2=>', error: e } );
+    return res.sendSuccess( e );
+  }
+};
+
+async function uploadUser( req, res ) {
+  try {
+    let inputBody = req.body;
+    let checklistDetails;
+    let assignedList = [];
+    checklistDetails = await taskService.findOne( { _id: inputBody.id, isdeleted: false } );
+    if ( !checklistDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    if ( inputBody.assignedUsers.length ) {
+      if ( !inputBody.hasOwnProperty( 'delete' ) ) {
+        await taskAssignService.deleteMany( { checkListId: inputBody.id, client_id: req.body.clientId } );
+      }
+
+      await Promise.all( inputBody.assignedUsers.map( async ( chunk ) => {
+        await insertUsers( chunk );
+      } ) );
+
+      await taskAssignService.insertMany( assignedList );
+      let storeList = assignedList.map( ( store ) => store.store_id );
+      let storeCount = storeList.length;
+      let locationCount;
+      if ( storeList.length ) {
+        let query = [
+          {
+            $match: {
+              'client_id': req.body.clientId,
+              'id': { $in: storeList },
+              'storeProfile.city': { $exists: true },
+              'status': 'active',
+            },
+          },
+          {
+            $group: {
+              _id: '$storeProfile.city',
+            },
+          },
+          {
+            $project: {
+              '_id': 0,
+              'storeProfile.city': '$_id',
+            },
+          },
+        ];
+        let storeDetails = await storeService.aggregate( query );
+        locationCount = storeDetails.length;
+      }
+      await taskService.updateOne( { _id: inputBody.id }, { storeCount: storeCount, locationCount: locationCount } );
+      return inputBody.id;
+
+      async function insertUsers( data ) {
+        let user = data;
+        let storeName = user.storeName.toLowerCase();
+        let email = user.userEmail.toLowerCase();
+        let query = [
+          {
+            $project: {
+              newEmail: { $toLower: '$email' },
+              isActive: 1,
+              email: 1,
+              mobileNumber: 1,
+              userName: 1,
+              clientId: 1,
+            },
+          },
+          {
+            $match: {
+              newEmail: email,
+              isActive: true,
+              clientId: req.body.clientId,
+            },
+          },
+        ];
+        let getUserDetails = await userService.aggregate( query );
+        let storeQuery = [
+          {
+            $project: {
+              store: { $toLower: '$storeName' },
+              clientId: 1,
+              storeId: 1,
+              storeProfile: 1,
+              storeName: 1,
+            },
+          },
+          {
+            $match: {
+              clientId: req.body.clientId,
+              store: storeName,
+            },
+          },
+        ];
+        let storeDetails = await storeService.aggregate( storeQuery );
+
+        if ( !storeDetails[0].storeProfile?.city ) {
+          let city = user.city;
+          await storeService.updateOne( { storeName: storeDetails[0].storeName }, { 'storeProfile.city': city } );
+          storeDetails = await storeService.aggregate( storeQuery );
+        }
+
+        let storeId = storeDetails[0].storeId;
+        if ( getUserDetails[0]._id ) {
+          let userDetails = {
+            store_id: storeId,
+            storeName: storeDetails[0]?.storeName ? storeDetails[0].storeName : user.storeName,
+            userId: getUserDetails[0]._id,
+            userEmail: getUserDetails[0]?.email ? getUserDetails[0]?.email : user.userEmail,
+            userName: getUserDetails[0]?.userName ? getUserDetails[0]?.userName : user.userName,
+            userPhone: getUserDetails[0]?.mobileNumber ? getUserDetails[0].mobileNumber : user.userPhone,
+            city: storeDetails[0]?.storeProfile?.city,
+            country: storeDetails[0]?.storeProfile?.country,
+            checkFlag: true,
+            checkListId: inputBody.id,
+            checkListName: checklistDetails.checkListName,
+            client_id: req.body.clientId,
+          };
+          assignedList.push( userDetails );
+        }
+      }
+    }
+  } catch ( e ) {
+    logger.error( { functionName: 'upload User', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function userDetails( req, res ) {
+  try {
+    if ( !req.query.taskId ) {
+      return res.sendError( { message: 'Task Id is required' }, 400 );
+    }
+    let limit = parseInt( req.query.limit ) || 5;
+    let page = parseInt( req.query.offset ) || 0;
+    let skip = limit * page;
+
+    let query = [ { $match: { checkListId: new ObjectId( req.query.taskId ) } } ];
+    if ( req.query?.search?.trim() && req.query?.search?.trim() != '' ) {
+      let searchValue = req.query.search;
+      searchValue = searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
+      if ( searchValue.length > 1 ) {
+        query.push( { $addFields: { storeLower: { $toLower: '$storeName' } } } );
+        query.push( { $match: { storeLower: { $in: searchValue } } } );
+      } else {
+        query.push( { $match: { storeName: { $regex: req.query.search.trim(), $options: 'i' } } } );
+      }
+    }
+
+    query.push( {
+      $facet: {
+        data: [
+          { $skip: skip }, { $limit: limit },
+        ],
+        count: [
+          { $count: 'total' },
+        ],
+      },
+    } );
+
+    let taskDetails = await taskAssignService.aggregate( query );
+
+    if ( !taskDetails[0].data.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    let userDetails = [];
+    taskDetails[0].data.forEach( ( item ) => {
+      userDetails.push( {
+        id: item._id,
+        userName: item.userName,
+        userEmail: item.userEmail,
+        store_id: item.store_id,
+        storeName: item.storeName,
+        userPhone: item.userPhone,
+        city: item.city,
+        checkFlag: item.checkFlag,
+      } );
+    } );
+    return res.sendSuccess( { users: userDetails, count: taskDetails[0].count[0].total } );
+  } catch ( e ) {
+    logger.error( { functionName: 'userDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export async function taskConfig( req, res ) {
+  try {
+    let inputBody = req.body;
+    let storeCount = 0;
+    let locationCount = 0;
+    let checklistDetails;
+    if ( !inputBody._id ) {
+      return res.sendError( { message: 'Task Id is Required' }, 400 );
+    }
+
+    if ( inputBody.submitType == 'publish' ) {
+      let checkUserAssigned = await taskAssignService.findOne( { checkListId: inputBody._id, checkFlag: true } );
+      if ( !checkUserAssigned ) {
+        return res.sendError( { message: 'Please assign a user' }, 400 );
+      }
+    }
+
+    let logInsertData = {
+      action: inputBody.submitType == 'publish' ? 'checklistPublishUsingConfigPage' : 'checklistConfigDraft',
+      checklistId: inputBody._id,
+      checkListName: inputBody?.checkListName,
+      createdBy: req.user._id,
+      createdByName: req.user.userName,
+      client_id: req.body.client_id,
+    };
+    await checklistLogs.create( logInsertData );
+
+    checklistDetails = await taskService.findOne( { _id: inputBody._id, isdeleted: false } );
+
+    if ( !checklistDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    let configDetails = { ...req.body };
+    configDetails.scheduleEndTimeISO = dayjs.utc( configDetails.scheduleEndTime, 'hh:mm A' ).format();
+
+    let response = await taskService.updateOne( { _id: inputBody._id }, configDetails );
+    if ( inputBody?.approver.length ) {
+      let data = [];
+      let existEmail = await traxApprover.find( { checkListId: inputBody._id, isDeleted: false } );
+      let mailList = existEmail.map( ( item ) => item.userEmail );
+      existEmail = inputBody?.approver.filter( ( item ) => mailList.includes( item.value ) ).map( ( item ) => item.value );
+      let userMailList = inputBody?.approver.map( ( ele ) => ele.value );
+      inputBody?.approver.forEach( ( ele ) => {
+        if ( !existEmail.includes( ele.value ) ) {
+          data.push( {
+            userEmail: ele.value,
+            checkListId: inputBody._id,
+            type: 'task',
+            client_id: req.body.client_id,
+          } );
+        }
+      } );
+
+      await traxApprover.updateMany( { checkListId: inputBody._id, userEmail: { $nin: userMailList } }, { isDeleted: true } );
+      if ( data.length ) {
+        await traxApprover.insertMany( data );
+      }
+    }
+    await taskAssignService.updateMany( { checkListId: inputBody._id }, { checkFlag: true } );
+    if ( inputBody.removedUsers.length ) {
+      await taskAssignService.updateMany( { _id: { $in: inputBody.removedUsers } }, { checkFlag: false } );
+    }
+    let storeDetails = await taskAssignService.find( { checkListId: inputBody._id, checkFlag: true }, { _id: 0, store_id: 1, userEmail: 1 } );
+    let storeList = storeDetails.map( ( store ) => store.store_id );
+
+    storeCount = storeList.length;
+    if ( storeList.length ) {
+      let query = [
+        {
+          $match: {
+            client_id: req.body.clientId,
+            id: { $in: storeList },
+            city: { $exists: true },
+          },
+        },
+        {
+          $group: {
+            _id: '$city',
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            city: '$_id',
+          },
+        },
+      ];
+      let storeDetails = await storeService.aggregate( query );
+      locationCount = storeDetails.length;
+    }
+    await taskService.updateOne( { _id: inputBody._id }, { storeCount, locationCount } );
+    if ( inputBody.submitType == 'publish' ) {
+      let currentDate = dayjs.utc().format();
+      let updatedscheduleEndTimeISO = dayjs( checklistDetails?.scheduleDate ).format( 'YYYY-MM-DD' ) + ' ' + checklistDetails.scheduleEndTime;
+      updatedscheduleEndTimeISO = dayjs.utc( updatedscheduleEndTimeISO, 'YYYY-MM-DD hh:mm A' ).format();
+      if ( updatedscheduleEndTimeISO >= currentDate ) {
+        let deleteQuery = {
+          $and: [
+            { date_string: dayjs().format( 'YYYY-MM-DD' ) },
+            { sourceCheckList_id: new ObjectId( req.params.checklistId ) },
+            { scheduleEndTime_iso: { $gt: currentDate } },
+          ],
+        };
+        deleteQuery.$and.push( { checklistStatus: { $ne: 'submit' } } );
+        await taskProcessedService.deleteMany( deleteQuery );
+        await insertSingleProcessData( inputBody._id );
+      } else {
+        logger.info( `Schudled End Time Breached Checklist publish true => Checklist Name: ${checklistDetails.checkListName}` );
+      }
+
+      futureDaysDataRemove( currentDate, req.params.checklistId );
+    }
+    if ( response?.modifiedCount || response?.matchedCount || response?.upsertedCount ) {
+      return res.sendSuccess( { id: inputBody._id, message: 'Configuration Updated Successfully' } );
+    }
+    if ( inputBody.submitType == 'save' ) {
+      if ( response?.modifiedCount || response?.matchedCount || response?.upsertedCount ) {
+        return res.sendSuccess( { message: 'Configuration Updated Successfully' } );
+      }
+    }
+  } catch ( e ) {
+    logger.error( { functionName: 'updateConfigure =>', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function insertSingleProcessData( checklistId ) {
+  try {
+    let currentdate = new Date();
+    let date = dayjs( currentdate ).format();
+    let getCLconfig = await taskService.findOne( { _id: new ObjectId( checklistId ), publish: true } );
+    if ( getCLconfig ) {
+      let startTimeIso; let endTimeIso;
+      let endDate = dayjs( getCLconfig?.scheduleDate ).format( 'YYYY-MM-DD' ) + ' ' + getCLconfig.scheduleEndTime;
+      endDate = dayjs.utc( endDate, 'YYYY-MM-DD hh:mm A' ).format();
+      if ( endDate >= date ) {
+        if ( dayjs( getCLconfig?.scheduleDate ).format( 'YYYY-MM-DD' ) != dayjs( currentdate ).format( 'YYYY-MM-DD' ) ) {
+          getCLconfig.scheduleEndTime = '11:59 PM';
+        }
+      } else {
+        return false;
+      }
+
+      startTimeIso = dayjs.utc( '12:00 AM', 'hh:mm A' );
+      endTimeIso = dayjs.utc( getCLconfig.scheduleEndTime, 'hh:mm A' );
+      let insertdata = {};
+      insertdata.date_iso = startTimeIso.format();
+      insertdata.date_string = dayjs( currentdate ).format( 'YYYY-MM-DD' );
+      insertdata.sourceCheckList_id = getCLconfig._id;
+      insertdata.checkListName = getCLconfig.checkListName;
+      insertdata.publish = getCLconfig.publish;
+      insertdata.scheduleStartTime = '12:00 AM';
+      insertdata.scheduleStartTime_iso = startTimeIso.format();
+      insertdata.scheduleEndTime = getCLconfig.scheduleEndTime;
+      insertdata.scheduleEndTime_iso = endTimeIso.format();
+      insertdata.allowedOverTime = false;
+      insertdata.allowedStoreLocation = getCLconfig.allowedStoreLocation;
+      insertdata.client_id = getCLconfig.client_id;
+      insertdata.createdBy = new ObjectId( getCLconfig.createdBy );
+      insertdata.createdByName = getCLconfig.createdByName;
+      insertdata.checkListType = getCLconfig.checkListType;
+      insertdata.storeCount = getCLconfig.storeCount;
+      insertdata.questionCount = getCLconfig.questionCount;
+      insertdata.publishDate = getCLconfig.publishDate;
+      insertdata.locationCount = getCLconfig.locationCount;
+      insertdata.allowedMultiSubmit = false;
+      insertdata.scheduleRepeatedType = 'daily';
+      let collectSections = [];
+      let sectionQuery = [];
+      sectionQuery.push( {
+        $match: {
+          checkListId: new ObjectId( checklistId ),
+          isdeleted: false,
+        },
+      } );
+      let getSections = await taskQuestionService.aggregate( sectionQuery );
+      if ( getSections.length ) {
+        if ( getSections.length ) {
+          for ( let element3 of getSections ) {
+            let collectQuestions = {};
+            collectQuestions.section_id = element3._id;
+            collectQuestions.sectionName = element3.section;
+            collectQuestions.questions = element3.question;
+            collectSections.push( collectQuestions );
+          }
+        }
+        insertdata.questionAnswers = collectSections;
+        insertdata.updatedAt = new Date();
+        let insertdataquery = {};
+        insertdataquery.date_string = insertdata.date_string;
+        insertdataquery.date_iso = insertdata.date_iso;
+        insertdataquery.client_id = insertdata.client_id;
+        insertdataquery.sourceCheckList_id = insertdata.sourceCheckList_id;
+        let updatedchecklist;
+        let checklistDetails = await taskProcessedConfigService.findOne( insertdataquery );
+        if ( !checklistDetails ) {
+          updatedchecklist = await taskProcessedConfigService.insert( insertdata );
+        } else {
+          await taskProcessedConfigService.updateOne( { _id: checklistDetails._id }, insertdata );
+          updatedchecklist = checklistDetails;
+        }
+        if ( updatedchecklist ) {
+          insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedchecklist, date, startTimeIso, endTimeIso, insertdata );
+        }
+      }
+    }
+    return true;
+  } catch ( error ) {
+    logger.error( 'PCLchecklistCreationValidator error =>', error );
+    return false;
+  }
+};
+
+async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedchecklist, date, startTimeIso, endTimeIso, insertdata ) {
+  let getquestionQuery = [];
+  getquestionQuery.push( {
+    $match: {
+      checkListId: new ObjectId( checklistId ),
+      checkFlag: true,
+      isdeleted: false,
+      ...( getCLconfig?.reinitiate ) ? { reinitiate: true } : {},
+    },
+  } );
+  let allQuestion = await taskAssignService.aggregate( getquestionQuery );
+  if ( allQuestion ) {
+    let userIdList = [];
+    for ( let element4 of allQuestion ) {
+      let query;
+      query = {
+        date_string: date,
+        sourceCheckList_id: getCLconfig._id,
+        $or: [ {
+          checklistStatus: { $in: [ 'submit' ] } },
+        { submitTime: { $exists: true } },
+        ],
+        userId: element4.userId,
+        store_id: element4.store_id,
+      };
+      let getsubmitDetails = await taskProcessedService.find( query );
+      if ( getsubmitDetails.length ) {
+        userIdList.push( element4._id );
+        continue;
+      }
+      delete element4._id;
+      delete element4.checkFlag;
+      delete element4.isdeleted;
+      delete element4.createdAt;
+      delete element4.updatedAt;
+      element4.checkListId = updatedchecklist._id;
+      element4.checkListName = getCLconfig.checkListName;
+      element4.date_iso = startTimeIso.format();
+      element4.date_string = dayjs( currentdate ).format( 'YYYY-MM-DD' );
+      element4.allowedOverTime = false;
+      element4.allowedStoreLocation = getCLconfig.allowedStoreLocation;
+      element4.scheduleStartTime = '12:00 AM';
+      element4.scheduleStartTime_iso = startTimeIso.format();
+      element4.scheduleEndTime = getCLconfig.scheduleEndTime;
+      element4.scheduleEndTime_iso = endTimeIso.format();
+      element4.createdBy = new ObjectId( getCLconfig.createdBy );
+      element4.createdByName = getCLconfig.createdByName;
+      element4.sourceCheckList_id = getCLconfig._id;
+      element4.checkListType = getCLconfig.checkListType;
+      element4.storeCount = getCLconfig.storeCount;
+      element4.questionCount = getCLconfig.questionCount;
+      element4.publishDate = getCLconfig.publishDate;
+      element4.locationCount = getCLconfig.locationCount;
+      element4.scheduleRepeatedType = 'daily';
+    }
+    if ( userIdList.length ) {
+      allQuestion = allQuestion.filter( ( item ) => typeof item._id == 'undefined' );
+    }
+    if ( allQuestion ) {
+      let assigndeletequery = {};
+      assigndeletequery.date_string = insertdata.date_string;
+      assigndeletequery.date_iso = insertdata.date_iso;
+      assigndeletequery.client_id = insertdata.client_id;
+      assigndeletequery.brandId = insertdata.brandId;
+      assigndeletequery.checkListId = updatedchecklist._id;
+      assigndeletequery.checklistStatus = { $nin: [ 'submit' ] };
+      await taskProcessedService.deleteMany( assigndeletequery );
+      await taskProcessedService.insertMany( allQuestion );
+      logger.info( { function: 'insertPCBulk_v3', query: assigndeletequery } );
+    }
+  }
+}
+
+async function futureDaysDataRemove( currentDate, checklistId ) {
+  // //Delete Future Datas////
+  let futureDataDeleteQuery = {
+    $and: [
+      { date_iso: { $gt: currentDate } },
+      { sourceCheckList_id: new ObjectId( checklistId ) },
+    ],
+  };
+  await taskProcessedConfigService.deleteMany( futureDataDeleteQuery );
+  futureDataDeleteQuery.$and.push( { checklistStatus: { $ne: 'submit' } } );
+  await taskProcessedService.deleteMany( futureDataDeleteQuery );
+  logger.info( { function: 'futureDaysDataRemove', query: futureDataDeleteQuery } );
+  // ///////////////////////////////
+  return true;
+}
+
+export async function uploadImage( req, res ) {
+  try {
+    let imgUrl;
+    if ( typeof req.files.file == 'undefined' ) {
+      return res.sendError( { message: 'Please upload a file' }, 400 );
+    }
+    req.files.file.name = req.files.file.name.replace( /\s/g, '' );
+    let name = req.files.file.name.split( '.' )[0];
+    let imageFormat = req.files.file.name.split( '.' )[1];
+
+    let bucket = JSON.parse( process.env.BUCKET );
+
+    let params = {
+      fileName: `/${name}_${( Date.now() )}.${imageFormat}`,
+      Key: `task`,
+      Bucket: bucket.sop,
+      ContentType: req.files.file.mimetype,
+      body: req.files.file.data,
+    };
+    imgUrl = await fileUpload( params );
+
+    let inputData = {
+      Bucket: bucket.sop,
+      file_path: imgUrl.Key,
+    };
+    imgUrl = await signedUrl( inputData );
+    if ( !imgUrl ) {
+      return res.sendError( { message: 'Something went wrong' }, 500 );
+    }
+
+    return res.sendSuccess( { message: 'Uploaded Successfully', imgUrl: imgUrl } );
+  } catch ( e ) {
+    logger.error( 'uploadImage =>', e );
+    return res.sendError( e, 500 );
+  }
+};
+
+async function createUser( data ) {
+  try {
+    let params = {
+      userName: data.userName,
+      email: data.email,
+      mobileNumber: data?.mobileNumber || '',
+      clientId: data.clientId,
+      role: 'user',
+      password: '5dqFKAJj29PsV6P+kL+3Dw==',
+      isActive: true,
+    };
+    let response = await userService.create( params );
+    return response._id;
+  } catch ( e ) {
+    logger.error( 'createUser =>', e );
+    return false;
+  }
+}
+
+export async function reinitiateTask( req, res ) {
+  try {
+    let taskDetails = await taskService.findOne( { _id: req.body.taskId, isDeleted: false } );
+    if ( !taskDetails ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    let data = {};
+    data.scheduleDate = req.body.scheduleDate;
+    data.scheduleEndTime = req.body.scheduleEndTime;
+    data.scheduleEndTimeISO = dayjs.utc( req.body.scheduleEndTime, 'hh:mm A' ).format();
+    data.allowedStoreLocation = req.body.allowedStoreLocation;
+    data.approver = req.body.approver;
+    data.priorityType = req.body.priorityType;
+    data.restrictAttendance = req.body.restrictAttendance;
+    data.reinitiate = true;
+
+    if ( req.body?.approver.length ) {
+      let data = [];
+      let existEmail = await traxApprover.find( { checkListId: req.body.taskId, isDeleted: false } );
+      let mailList = existEmail.map( ( item ) => item.userEmail );
+      existEmail = req.body?.approver.filter( ( item ) => mailList.includes( item.value ) ).map( ( item ) => item.value );
+      let userMailList = req.body?.approver.map( ( ele ) => ele.value );
+      req.body?.approver.forEach( ( ele ) => {
+        if ( !existEmail.includes( ele.value ) ) {
+          data.push( {
+            userEmail: ele.value,
+            checkListId: req.body.taskId,
+            type: 'task',
+            client_id: req.body.client_id,
+          } );
+        }
+      } );
+
+      await traxApprover.updateMany( { checkListId: req.body.taskId, userEmail: { $nin: userMailList } }, { isDeleted: true } );
+      if ( data.length ) {
+        await traxApprover.insertMany( data );
+      }
+    }
+
+    await taskService.updateOne( { _id: req.body.taskId }, data );
+    await taskAssignService.updateOne( { userEmail: req.body.userEmail, storeName: req.body.storeName, checkListId: req.body.taskId }, { reinitiate: true } );
+    await insertSingleProcessData( req.body.taskId );
+    return res.sendSuccess( 'Task reinitaite SUccessfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'reinitiateTask', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function createChecklistTask( req, res ) {
+  try {
+    let inputBody = req.body;
+    let data = {
+      checkListName: inputBody.checkListName,
+      checkListDescription: inputBody.checkListDescription,
+      createdBy: req.user._id,
+      createdByName: req.user.userName,
+      publish: true,
+      questionCount: 1,
+      storeCount: 1,
+      scheduleDate: inputBody?.scheduleDate || dayjs().format( 'YYYY-MM-DD' ),
+      scheduleEndTime: inputBody?.scheduleEndTime || '11:59 PM',
+      scheduleEndTimeISO: dayjs.utc( inputBody.scheduleEndTime, 'hh:mm A' ).format(),
+      priorityType: 'high',
+      client_id: inputBody.clientId,
+      checkListType: inputBody.checkListType,
+      publishDate: new Date(),
+      locationCount: 1,
+      referenceCheckListId: inputBody?.checkListId,
+    };
+
+    let response = await taskService.create( data );
+
+    if ( response?._id ) {
+      if ( inputBody.question[0].questionReferenceImage.length ) {
+        let images = [];
+        inputBody.question[0].questionReferenceImage.forEach( ( ele ) => {
+          let imgUrl = decodeURIComponent( ele.split( '?' )[0] );
+          let url = imgUrl.split( '/' );
+          url.splice( 0, 3 );
+          images.push( url.join( '/' ) );
+        } );
+        inputBody.question[0].questionReferenceImage = images;
+      }
+      let question = {
+        checkListId: response?._id,
+        question: inputBody.question,
+        section: 'Section 1',
+        checkList: inputBody.checkListName,
+        client_id: inputBody.clientId,
+      };
+      await taskQuestionService.create( question );
+      let storeDetails = await storeService.findOne( { storeName: inputBody.storeName }, { storeId: 1, storeProfile: 1 } );
+      if ( !storeDetails ) {
+        return res.sendError( 'No data found', 204 );
+      }
+      let userDetails = {
+        userName: inputBody.userName,
+        userEmail: inputBody.userEmail,
+        store_id: storeDetails.storeId,
+        storeName: inputBody.storeName,
+        city: storeDetails?.storeProfile?.city,
+        checkFlag: true,
+        checkListId: response?._id,
+        checkListName: inputBody.checkListName,
+        client_id: inputBody.clientId,
+      };
+      await taskAssignService.create( userDetails );
+      await insertSingleProcessData( response?._id );
+      return res.sendSuccess( 'Task created successfully' );
+    }
+  } catch ( e ) {
+    logger.error( { functionName: 'createChecklistTask', error: e } );
+    return res.sendError( e, 500 );
+  }
+}