tango-app-api-trax 1.0.0-beta-task.7 → 1.0.0-beta-task.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "1.0.0-beta-task.7",
+    "version": "1.0.0-beta-task.9",
     "description": "Trax",
     "main": "index.js",
     "type": "module",
@@ -28,6 +28,7 @@
         "path": "^0.12.7",
         "tango-api-schema": "2.2.5",
         "tango-app-api-middleware": "3.1.43-alpha.10",
+        "tango-app-api-trax": "^1.0.0-beta-task.7",
         "url": "^0.11.4",
         "winston": "^3.13.1",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/gallery.controller.js

@@ -343,6 +343,7 @@ export async function redoChecklist( req, res ) {
 
     question[sectionIndex].questions[req.body.payload.qno - 1] = data;
     question[sectionIndex].questions[req.body.payload.qno - 1].userAnswer = [];
+    question[sectionIndex].questions[req.body.payload.qno - 1].remarks = '';
     checklistDetails.questionAnswers = question;
     let updateData = {
       checklistStatus: 'open',
@@ -443,9 +444,7 @@ export async function getLogs( req, res ) {
 
 export async function approvalstatus( req, res ) {
   try {
-    if ( ( req?.user?.userType == 'client' && req.user.role == 'superadmin' ) ) {
-      return res.sendError( 'No Content', 204 );
-    }
+   
 
 
     let Approver = await ApproverModel.find( { checkListId: req.body.checklistId } );
@@ -454,6 +453,17 @@ export async function approvalstatus( req, res ) {
     }
     let filterApprover = Approver.filter( ( data ) => data.userEmail=== req.user.email );
     if ( filterApprover.length === 0 ) {
+      if ( ( req?.user?.userType == 'client' && req.user.role == 'superadmin' ) ) {
+        let url = JSON.parse( process.env.LAMBDAURL );
+        let resultData = await LamdaServiceCall( url.approvalstatus, req.body );
+        if ( resultData ) {
+          console.log( resultData.status_code );
+          if ( resultData.status_code == '200' ) {
+            return res.sendSuccess( resultData );
+          }
+        }
+        return res.sendError( 'No Content', 204 );
+      }
       return res.sendSuccess( 'suceess' );
     }
 

package/src/controllers/internalTrax.controller.js

@@ -953,9 +953,9 @@ export async function pushNotification( req, res ) {
                 if ( getToken?.fcmToken ) {
                   let existCheck = checklistDetails.findIndex( ( item ) => item.checklistName == data.checkListName );
                   if ( existCheck != -1 ) {
-                    checklistDetails[existCheck].token.push( getToken.fcmToken );
+                    checklistDetails[existCheck].token.push( { token: getToken.fcmToken, store: data.storeName } );
                   } else {
-                    checklistDetails.push( { checklistName: data.checkListName, token: [ getToken.fcmToken ] } );
+                    checklistDetails.push( { checklistName: data.checkListName, token: [ { token: getToken.fcmToken, store: data.storeName } ], time: checklistDate.diff( date, 'minute' ) } );
                   }
                 }
               }
@@ -968,26 +968,36 @@ export async function pushNotification( req, res ) {
       return res.sendError( 'no data found', 204 );
     }
 
-    for ( let [ index, item ] of checklistDetails.entries() ) {
-      const message = {
-        tokens: item.token,
-        notification: {
-          title: 'Reminder to Fill checklist',
-          body: `${item.checklistName} checklist is going to breach within few minutes`,
-        },
-        data: {
-          customKey: 'customValue',
-        },
-      };
-      const response = await admin.messaging().sendEachForMulticast( message );
-      if ( response.successCount ) {
-        logger.info( { message: 'push notification', success: item.token } );
-        if ( index == checklistDetails.length - 1 ) {
-          return res.sendSuccess( 'Push notification send successfully' );
-        }
-      } else {
-        logger.error( { message: 'push notification', error: item.token } );
-      }
+    const checklistPromise = checklistDetails.map( async ( ele ) => {
+      await sendNotification( ele );
+    } );
+
+    await Promise.all( checklistPromise );
+    return res.sendSuccess( 'Push notification send successfully' );
+
+    async function sendNotification( data ) {
+      return Promise.all(
+          data.token.map( async ( item ) => {
+            const message = {
+              token: item.token,
+              notification: {
+                title: item.store,
+                body: `The ${data.checklistName} is due. Complete it within ${data.time} minutes to avoid compliance.`,
+              },
+              data: {
+                customKey: 'customValue',
+              },
+            };
+            try {
+              let response = await admin.messaging().send( message );
+              if ( !response ) {
+                logger.error( { message: 'push notification', error: element.token } );
+              }
+            } catch ( e ) {
+              logger.error( { message: 'push notification', error: e, details: data } );
+            }
+          } ),
+      );
     }
   } catch ( e ) {
     logger.error( { function: 'pushNotification', error: e } );
@@ -1334,9 +1344,9 @@ export async function taskPushNotification( req, res ) {
                 if ( getToken?.fcmToken ) {
                   let existCheck = taskDetails.findIndex( ( item ) => item.checklistName == data.checkListName );
                   if ( existCheck != -1 ) {
-                    taskDetails[existCheck].token.push( getToken.fcmToken );
+                    taskDetails[existCheck].token.push( { token: getToken.fcmToken, store: data.storeName } );
                   } else {
-                    taskDetails.push( { checklistName: data.checkListName, token: [ getToken.fcmToken ] } );
+                    taskDetails.push( { checklistName: data.checkListName, token: [ { token: getToken.fcmToken, store: data.storeName } ], time: taskDate.diff( date, 'minute' ) } );
                   }
                 }
               }
@@ -1349,26 +1359,36 @@ export async function taskPushNotification( req, res ) {
       return res.sendError( 'no data found', 204 );
     }
 
-    for ( let [ index, item ] of taskDetails.entries() ) {
-      const message = {
-        tokens: item.token,
-        notification: {
-          title: 'Reminder to Fill task',
-          body: `${item.checklistName} task is going to breach within few minutes`,
-        },
-        data: {
-          customKey: 'customValue',
-        },
-      };
-      const response = await admin.messaging().sendEachForMulticast( message );
-      if ( response.successCount ) {
-        logger.info( { message: 'push notification', success: item.token } );
-        if ( index == taskDetails.length - 1 ) {
-          return res.sendSuccess( 'Push notification send successfully' );
-        }
-      } else {
-        logger.error( { message: 'push notification', error: item.token } );
-      }
+    const checklistPromise = taskDetails.map( async ( ele ) => {
+      await sendNotification( ele );
+    } );
+
+    await Promise.all( checklistPromise );
+    return res.sendSuccess( 'Push notification send successfully' );
+
+    async function sendNotification( data ) {
+      return Promise.all(
+          data.token.map( async ( item ) => {
+            try {
+              const message = {
+                token: item.token,
+                notification: {
+                  title: item.store,
+                  body: `The ${data.checklistName} is due. Complete it within ${data.time} minutes to avoid compliance`,
+                },
+                data: {
+                  customKey: 'customValue',
+                },
+              };
+              let response = await admin.messaging().send( message );
+              if ( !response ) {
+                logger.error( { message: 'push notification', error: data.token } );
+              }
+            } catch ( e ) {
+              logger.error( { message: 'push notification', error: e, details: data } );
+            }
+          } ),
+      );
     }
   } catch ( e ) {
     logger.error( { function: 'taskPushNotification', error: e } );

package/src/controllers/mobileTrax.controller.js

@@ -2006,142 +2006,338 @@ export async function questionList( req, res ) {
   }
 }
 
+// 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', '' ] },
+//           redoStatus: { $ifNull: [ '$redoStatus', false ] },
+//         },
+//       },
+//     ];
+
+//     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 ( Array.isArray( question.questionReferenceImage ) && question.questionReferenceImage.length ) {
+//           question.questionReferenceImage = await Promise.all(
+//               question.questionReferenceImage.map( async ( img ) => await getSignedUrl( img ) ),
+//           );
+//         }
+
+//         for ( const [ ansIndex, answer ] of answers.entries() ) {
+//           answer.index = ansIndex;
+
+//           if ( answer.referenceImage.length > 0 ) {
+//             answer.referenceImage = await Promise.all(
+//                 answer.referenceImage.map( async ( image ) => await getSignedUrl( image ) ),
+//             );
+//           }
+
+//           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', 'multipleImage' ].includes( answerType ) && userAns.answer ) {
+//             userAns.answer = await getSignedUrl( userAns.answer );
+//           }
+
+//           if ( Array.isArray( userAns.referenceImage ) ) {
+//             userAns.referenceImage = await Promise.all(
+//                 userAns.referenceImage.map( async ( image ) => await getSignedUrl( image ) ),
+//             );
+//           } else if ( 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 > 0 ?
+//               multiAnswer.map( ( item ) => ( {
+//                 answer: item.validationAnswer ? item.answer : null,
+//                 no: item.no,
+//                 validationAnswer: item.validationAnswer,
+//               } ) ) :
+//               answers.map( ( _, index ) => ( {
+//                 answer: null,
+//                 no: index,
+//                 validationAnswer: null,
+//               } ) );
+//         }
+//       }
+//     }
+
+//     return res.sendSuccess( [ checklist ] );
+//   } catch ( error ) {
+//     logger.error( { function: 'taskQuestionList', error, body: req.body } );
+//     return res.sendError( error.message || 'Internal Server Error', 500 );
+//   }
+// }
+
 export async function taskQuestionList( req, res ) {
   try {
-    const { processedcheckListId } = req.query;
-
-    if ( !processedcheckListId ) {
-      return res.sendError( 'processedcheckListId is required', 400 );
+    let requestData = req.query;
+    if ( !requestData.processedcheckListId ) {
+      res.sendError( 'processedTaskId 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', '' ] },
-          redoStatus: { $ifNull: [ '$redoStatus', false ] },
-        },
-      },
-    ];
-
-    const [ checklist ] = await processedTask.aggregate( findQuery );
+    let findQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push( { _id: new ObjectId( requestData.processedcheckListId ) } );
+    findQuery.push( { $match: { $and: findAndQuery } } );
 
-    if ( !checklist ) {
-      return res.sendError( 'Task got edited, please fill again', 422 );
-    }
+    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 ] },
+      },
+    } );
 
-    logger.info(
-        `v5 => Checklist Continue => store Name: ${checklist.storeName}, User Email: ${checklist.userEmail}, Checklist Name: ${checklist.checkListName}`,
-    );
+    let getchecklist = await processedtask.aggregate( findQuery );
+    if ( !getchecklist.length ) {
+      return res.sendError( 'Task Got Edited Please Fill Again', 422 );
+    } else {
+      logger.info( `v5 => Task Continue => store Name: ${getchecklist[0].storeName}, User Email: ${getchecklist[0].userEmail}, Task 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 = [];
+          let questionReferenceImage = getchecklist[0].questionAnswers[secIndex].questions[questionIndex].questionReferenceImage;
 
-    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 ) );
+          if ( questionReferenceImage ) {
+            if ( Array.isArray( questionReferenceImage ) ) {
+              getchecklist[0].questionAnswers[secIndex].questions[questionIndex].questionReferenceImage = await Promise.all(
+                  questionReferenceImage.map( async ( image ) => await signedUrl( { file_path: decodeURIComponent( image ), Bucket: bucket.sop } ) ),
+              );
+            } else if ( questionReferenceImage !== '' ) {
+              getchecklist[0].questionAnswers[secIndex].questions[questionIndex].questionReferenceImage = await signedUrl( {
+                file_path: decodeURIComponent( questionReferenceImage ),
+                Bucket: bucket.sop,
+              } );
             }
-            question.questionReferenceImage = image;
           }
-        }
 
-        for ( const [ ansIndex, answer ] of answers.entries() ) {
-          answer.index = ansIndex;
+          for ( let [ ansIndex, answer ] of question.answers.entries() ) {
+            let referenceImage = getchecklist[0].questionAnswers[secIndex].questions[questionIndex].answers[ansIndex].referenceImage;
+
+            if ( referenceImage ) {
+              if ( Array.isArray( referenceImage ) ) {
+                getchecklist[0].questionAnswers[secIndex].questions[questionIndex].answers[ansIndex].referenceImage = await Promise.all(
+                    referenceImage.map( async ( image ) => await signedUrl( { file_path: decodeURIComponent( image ), Bucket: bucket.sop } ) ),
+                );
+              } else if ( referenceImage !== '' ) {
+                getchecklist[0].questionAnswers[secIndex].questions[questionIndex].answers[ansIndex].referenceImage = await signedUrl( {
+                  file_path: decodeURIComponent( referenceImage ),
+                  Bucket: bucket.sop,
+                } );
+              }
+            }
 
-          if ( answer.referenceImage.length > 0 ) {
-            answer.referenceImage = await Promise.all(
-                answer.referenceImage.map( async ( image ) => {
-                  return await getSignedUrl( image );
-                } ),
-            );
+            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.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 ( [ 'Capture Image', 'Capture Video' ].includes( answer.validationType ) && answer.validationAnswer ) {
-            answer.validationAnswer = await getSignedUrl( answer.validationAnswer );
-          }
+          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 ( 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 ( question.answerType == 'multiplechoicemultiple' ) {
+            Multianswer.forEach( ( item ) => {
+              if ( item.validationAnswer == null ) {
+                item.answer = null;
+              }
+            } );
+            if ( Multianswer.length ) {
+              question.Multianswer = Multianswer;
+            } else {
+              question.Multianswer = Multianswer;
+            }
           }
-
-          if ( [ 'image', 'descriptiveImage', 'video' ].includes( answerType ) && userAns.answer ) {
-            userAns.answer = await getSignedUrl( userAns.answer );
+          if ( question.answerType == 'multipleImage' ) {
+            if ( Multianswer.length ) {
+              question.Multianswer = Multianswer;
+            } else {
+              Multianswer.push( { 'answer': null, 'no': 0, 'validationAnswer': null } );
+              question.Multianswer = Multianswer;
+            }
           }
+        }
+      }
 
-          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;
+      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 ( answerType === 'multipleImage' && userAns.answer ) {
-            const manswer = await getSignedUrl( userAns.answer );
-            multiAnswer.push( { answer: manswer, no: userAnsIndex, validationAnswer: '' } );
+        }
+        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 );
+              }
+            }
           }
         }
-
-        if ( [ 'multiplechoicemultiple', 'multipleImage' ].includes( answerType ) ) {
-          question.Multianswer = multiAnswer.length > 0 ?
-            multiAnswer.map( ( item ) => ( {
-              answer: item.validationAnswer ? item.answer : null,
-              no: item.no,
-              validationAnswer: item.validationAnswer,
-            } ) ) :
-            answers.map( ( _, index ) => ( {
-              answer: null,
-              no: index,
-              validationAnswer: null,
-            } ) );
+      }
+      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( [ checklist ] );
-  } catch ( error ) {
-    logger.error( { function: 'taskQuestionList', error, body: req.body } );
-    return res.sendError( error.message || 'Internal Server Error', 500 );
+      return res.sendSuccess( getchecklist );
+    }
+  } catch ( e ) {
+    logger.error( { function: 'taskQuestionList', error: e, body: req.body } );
+    return res.sendError( e, 500 );
   }
 }
 

package/src/controllers/trax.controller.js

@@ -932,6 +932,15 @@ export const updateConfigure =async ( req, res ) => {
       return res.sendError( 'no data found', 204 );
     }
 
+    if ( checklistDetails?.publishDate && inputBody.submitType == 'publish' ) {
+      let date = dayjs();
+      let diff = date.diff( dayjs.utc( checklistDetails?.publishDate ), 'minutes' );
+      if ( diff < 5 ) {
+        let mins = ( 5 - diff ) > 1 ? 'minutes' : 'minute';
+        return res.sendError( `Please try after ${5 - diff} ${mins}`, 400 );
+      }
+    }
+
     if ( inputBody?.checkListDetails?.scheduleRepeatedMonthSetup == 'date' ) {
       inputBody.checkListDetails.scheduleRepeatedDay = inputBody?.checkListDetails?.scheduleRepeatedDay;
     }

package/src/controllers/traxDashboard.controllers.js

@@ -1200,6 +1200,7 @@ export const checklistInfo = async ( req, res ) => {
         date_string: 1,
         sourceCheckList_id: 1,
         reinitiateStatus: 1,
+        redoStatus: 1,
       },
     } );
 
@@ -1244,6 +1245,7 @@ export const checklistInfo = async ( req, res ) => {
         checklistDate: '$date_string',
         sourceCheckList_id: 1,
         reinitiateStatus: 1,
+        redoStatus: 1,
       },
     } );
 
@@ -3575,9 +3577,9 @@ export async function sendAlert( req, res ) {
             if ( getToken?.fcmToken ) {
               let existCheck = checklistDetails.findIndex( ( item ) => item.checklistName == data.checkListName );
               if ( existCheck != -1 ) {
-                checklistDetails[existCheck].token.push( getToken.fcmToken );
+                checklistDetails[existCheck].token.push( { token: getToken.fcmToken, store: data.storeName } );
               } else {
-                checklistDetails.push( { checklistName: data.checkListName, token: [ getToken.fcmToken ] } );
+                checklistDetails.push( { checklistName: data.checkListName, token: [ { token: getToken.fcmToken, store: data.storeName } ] } );
               }
             }
           } ),
@@ -3588,6 +3590,38 @@ export async function sendAlert( req, res ) {
       return res.sendError( 'no data found', 204 );
     }
 
+    const checklistPromise = checklistDetails.map( async ( ele ) => {
+      await sendNotification( ele );
+    } );
+
+    await Promise.all( checklistPromise );
+    return res.sendSuccess( 'Alert send successfully' );
+
+    async function sendNotification( data ) {
+      return Promise.all(
+          data.token.map( async ( item ) => {
+            const message = {
+              token: item.token,
+              notification: {
+                title: `${item.store} Checklist In-progress`,
+                body: `The ${data.checklistName} checklist is currently in progress. Complete now to avoid compliance.`,
+              },
+              data: {
+                customKey: 'customValue',
+              },
+            };
+            try {
+              let response = await admin.messaging().send( message );
+              if ( !response ) {
+                logger.error( { message: 'send alert', error: element.token } );
+              }
+            } catch ( e ) {
+              logger.error( { message: 'send alert', error: e, details: data } );
+            }
+          } ),
+      );
+    }
+
     for ( let [ index, item ] of checklistDetails.entries() ) {
       const message = {
         tokens: item.token,