tango-app-api-trax 3.2.0-beta.1 → 3.2.0-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "3.2.0-beta.1",
+    "version": "3.2.0-beta.10",
     "description": "Trax",
     "main": "index.js",
     "type": "module",
@@ -27,7 +27,7 @@
         "nodemon": "^3.1.4",
         "path": "^0.12.7",
         "tango-api-schema": "^2.2.16",
-        "tango-app-api-middleware": "^3.1.48",
+        "tango-app-api-middleware": "^3.1.50",
         "url": "^0.11.4",
         "winston": "^3.13.1",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/gallery.controller.js

@@ -371,6 +371,13 @@ export async function redoChecklist( req, res ) {
 
     let response = await processedChecklist.updateOne( { _id: req.body.payload._id }, updateData );
     if ( response.modifiedCount || response.matchedCount ) {
+      let storeTimeZone = await storeService.findOne( { storeName: checklistDetails.storeName }, { 'storeProfile.timeZone': 1 } );
+      let currentDateTime;
+      if ( storeTimeZone?.storeProfile?.timeZone ) {
+        currentDateTime = dayjs().tz( storeTimeZone?.storeProfile?.timeZone );
+      } else {
+        currentDateTime = dayjs();
+      }
       data = {
         checklistId: checklistDetails.sourceCheckList_id,
         checkListName: checklistDetails.checkListName,
@@ -386,7 +393,7 @@ export async function redoChecklist( req, res ) {
         type: checklistDetails.checkListType,
         userAnswer: userAnswer,
         initiatedBy: req.user.userName,
-        initiatedTime: dayjs().format(),
+        initiatedTime: dayjs.utc( currentDateTime.format( 'hh:mm:ss A, DD MMM YYYY' ), 'hh:mm:ss A, DD MMM YYYY' ).format(),
         answerType: question[sectionIndex].questions[req.body.payload.qno - 1].answerType,
         submitedBy: checklistDetails.userName,
         submitTime: checklistDetails.submitTime,

package/src/controllers/internalTrax.controller.js

@@ -11,6 +11,7 @@ import * as storeService from '../services/store.service.js';
 import * as userService from '../services/user.service.js';
 import * as clientService from '../services/clients.services.js';
 import * as processedTaskService from '../services/processedTaskList.service.js';
+import * as taskService from '../services/taskConfig.service.js';
 import dayjs from 'dayjs';
 import customParseFormat from 'dayjs/plugin/customParseFormat.js';
 import timeZone from 'dayjs/plugin/timezone.js';
@@ -299,7 +300,7 @@ async function insertData( requestData ) {
                 },
               } );
               let getSections = await CLquestions.aggregate( sectionQuery );
-              if ( getSections.length || [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle' ].includes( getCLconfig.checkListType ) ) {
+              if ( getSections.length || [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring' ].includes( getCLconfig.checkListType ) ) {
                 if ( getSections.length ) {
                   for ( let element3 of getSections ) {
                     let collectQuestions = {};
@@ -441,7 +442,7 @@ async function insertData( requestData ) {
                         // }
                       }
                     } else {
-                      if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle' ].includes( getCLconfig.checkListType ) ) {
+                      if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring' ].includes( getCLconfig.checkListType ) ) {
                         let storeDetails = await storeService.find( { clientId: getCLconfig.client_id, status: 'active' }, { storeId: 1 } );
                         let data = {
                           checkListId: updatedchecklist._id,
@@ -1280,7 +1281,7 @@ export async function taskPushNotification( req, res ) {
     let query = [ {
       $match: {
         date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ),
-        $expr: { $gt: [ { $size: '$remainder' }, 0 ] },
+        // $expr: { $gt: [ { $size: '$remainder' }, 0 ] },
         checklistStatus: { $ne: 'submit' },
       },
     } ];
@@ -1306,6 +1307,7 @@ export async function taskPushNotification( req, res ) {
         scheduleEndTime: 1,
         remainder: 1,
         checkListType: 1,
+        sourceCheckList_id: 1,
       },
     } );
 
@@ -1326,6 +1328,12 @@ export async function taskPushNotification( req, res ) {
     async function checkTimeZone( ele ) {
       return Promise.all(
           ele.map( async ( data ) => {
+            let taskChecklistName='';
+            let checkLinkedTask = await taskService.findOne( { _id: data.sourceCheckList_id }, { referenceCheckListId: 1 } );
+            if ( checkLinkedTask?.referenceCheckListId ) {
+              let checklistDetails = await CLconfig.findOne( { _id: checkLinkedTask?.referenceCheckListId }, { checkListName: 1 } );
+              taskChecklistName = checklistDetails.checkListName;
+            }
             let getStoreZone = await storeService.findOne(
                 { storeId: data.store_id, clientId: data.client_id },
                 { storeProfile: 1 },
@@ -1333,14 +1341,14 @@ export async function taskPushNotification( req, res ) {
             if ( getStoreZone ) {
               let taskDate = dayjs( dayjs.utc( data.scheduleEndTime_iso ) ).tz( getStoreZone.storeProfile.timeZone, true );
               let date = dayjs( dayjs().format( 'hh:mm A' ), 'hh:mm A' ).tz( getStoreZone.storeProfile.timeZone );
-              if ( data?.remainder?.length && data.remainder.includes( taskDate.diff( date, 'minute' ) || taskDate.diff( date, 'minute' ) == 30 ) ) {
+              if ( ( data?.remainder?.length && data.remainder.includes( taskDate.diff( date, 'minute' ) ) ) || taskDate.diff( date, 'minute' ) == 30 ) {
                 let getToken = await userService.findOne( { _id: data.userId }, { fcmToken: 1 } );
                 if ( getToken?.fcmToken ) {
                   let existCheck = taskDetails.findIndex( ( item ) => item.checklistName == data.checkListName );
                   if ( existCheck != -1 ) {
                     taskDetails[existCheck].token.push( { token: getToken.fcmToken, store: data.storeName } );
                   } else {
-                    taskDetails.push( { checklistName: data.checkListName, token: [ { token: getToken.fcmToken, store: data.storeName } ], time: taskDate.diff( date, 'minute' ), checkListType: data.checkListType } );
+                    taskDetails.push( { checklistName: data.checkListName, token: [ { token: getToken.fcmToken, store: data.storeName } ], time: taskDate.diff( date, 'minute' ), taskChecklistName: taskChecklistName, checkListType: data.checkListType } );
                   }
                 }
               }
@@ -1365,13 +1373,15 @@ export async function taskPushNotification( req, res ) {
           data.token.map( async ( item ) => {
             let title = '';
             let description = '';
-
-            if ( item.checkListType === 'checklistTask' ) {
-              title = `Task Due Alert ${item.store}`;
-              description = `Today is the due date for ${data.checklistName}. Please complete the task by the end of the day to ensure compliance.`;
-            } else if ( item.checkListType === 'CCTV' ) {
+            if ( data.checkListType === 'checklistTask' ) {
+              title = `Task Due Alert ${data.taskChecklistName}`;
+              description = `The task created from the response for  ${item.store} is due today.`;
+            } else if ( data.checkListType === 'CCTV' ) {
               title = `Task Due Alert ${data.checklistName}`;
               description = `The task created from the live view for ${item.store} is due today.`;
+            } else {
+              title = `Task Due Alert ${item.store}`;
+              description = `Today is the due date for ${data.checklistName}. Please complete the task by the end of the day to ensure compliance.`;
             }
 
             const fcmToken = item.token;

package/src/controllers/mobileTrax.controller.js

@@ -490,6 +490,76 @@ export async function sopMobilechecklistQuestionValidator( req, res, next ) {
   }
 };
 
+export async function sopMobilechecklistQuestionValidatorv1( req, res, next ) {
+  try {
+    let requestData = req.body;
+
+    logger.error( { function: 'CheckEmptyQA', error: requestData } );
+
+    requestData.questionAnswers = typeof requestData.questionAnswers == 'string' ? JSON.parse( requestData.questionAnswers ) : requestData.questionAnswers;
+    let getChecklistQA = await processedchecklist.findOne( { _id: new ObjectId( requestData.processedcheckListId ) }, { questionAnswers: 1, sourceCheckList_id: 1 } );
+    if ( !getChecklistQA ) {
+      return res.sendError( 'Check List Got Edited Please Fill Again', 422 );
+    }
+
+    if ( getChecklistQA && requestData.submittype == 'submit' ) {
+      let checkChecklistStatus = await checklistService.findOne( { _id: getChecklistQA.sourceCheckList_id }, { publish: 1 } );
+      if ( !checkChecklistStatus.publish ) {
+        return res.sendError( 'Checklist got edited.please contact admin', 400 );
+      }
+    }
+
+    if ( !requestData.questionAnswers.length ) {
+      return res.sendError( 'Please Fill all Required Fields', 400 );
+    }
+
+    if ( requestData.submittype == 'submit' ) {
+      let reqAnswers = requestData.questionAnswers;
+      logger.error( { functionName: 'payload', message: reqAnswers } );
+      let CLQAnswers = getChecklistQA.questionAnswers;
+      logger.error( { functionName: 'CLQAnswers', message: CLQAnswers } );
+      let validationCount= 0;
+      let errorCount = 0;
+      CLQAnswers.forEach( ( section ) => {
+        let requestSection = reqAnswers.filter( ( reqSection ) => reqSection.sectionName == section?.sectionOldName || reqSection.sectionName == section?.sectionName );
+        if ( requestSection.length ) {
+          requestSection.forEach( ( item ) => item.section_id = section.section_id );
+          section.questions.forEach( ( question ) => {
+            // question.answers.forEach( ( answer ) => {
+            let sectionQuestion = requestSection.filter( ( secQuestion ) => secQuestion.qname == question.oldQname || secQuestion.qname == question.qname );
+            if ( sectionQuestion.length ) {
+              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++;
+                }
+              }
+            } else {
+              errorCount++;
+            }
+            // } );
+          } );
+        } else {
+          errorCount++;
+        }
+      } );
+      if ( validationCount ) {
+        return res.sendError( 'Please Fill all Required Fields', 400 );
+      } else if ( errorCount ) {
+        return res.sendError( 'Checklist got edited.please contact admin', 400 );
+      } else {
+        next();
+      }
+    } else {
+      next();
+    }
+  } catch ( e ) {
+    logger.error( { function: 'sopMobilechecklistQuestionValidator', error: e, body: req.body } );
+    return res.sendError( e, 500 );
+  }
+};
+
 export async function sopMobileTaskQuestionValidator( req, res, next ) {
   try {
     let requestData = req.body;
@@ -503,7 +573,7 @@ export async function sopMobileTaskQuestionValidator( req, res, next ) {
       let CLQAnswers = getChecklistQA.questionAnswers;
       let validationCount= 0;
       CLQAnswers.forEach( ( section ) => {
-        let requestSection = reqAnswers.filter( ( reqSection ) => reqSection.section_id == section.section_id );
+        let requestSection = reqAnswers.filter( ( reqSection ) => reqSection.sectionName == section?.sectionOldName || reqSection.sectionName == section.sectionName );
         section.questions.forEach( ( question ) => {
           question.answers.forEach( ( answer ) => {
             let sectionQuestion = requestSection.filter( ( secQuestion ) => secQuestion.qno == question.qno );
@@ -844,6 +914,372 @@ export async function sopMobilechecklistMultiSectionFormatter( req, res, next )
   }
 };
 
+export async function sopMobilechecklistMultiSectionFormatterv1( 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;
+    logger.error( { functionName: 'updatedPayload', message: reqAnswers } );
+    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 );
+          }
+        }
+      } );
+    }
+
+    if ( requestData?.editSubmit && requestData?.editSubmit == 'true' ) {
+      let sampleData = reqAnswers[0];
+      CLQAnswers.forEach( ( section ) => {
+        console.log( section, 'section' );
+        let requestSection = reqAnswers.filter( ( reqSection ) => reqSection.sectionName == section?.sectionOldName || reqSection.sectionName == section?.sectionName );
+        if ( requestSection.length ) {
+          requestSection.forEach( ( item ) => item.section_id = section.section_id );
+          section.questions.forEach( ( question ) => {
+            let sectionQuestion = requestSection.filter( ( secQuestion ) => secQuestion.qname == question.oldQname || secQuestion.qname == question.qname );
+            if ( !sectionQuestion.length ) {
+              let data = { ...requestSection[0] };
+              data.answerType = question.answerType;
+              data.qno = question.qno;
+              data.qname = question.qname;
+              data.answer = 'null';
+              data.remarks = '';
+              data.validationAnswer = '';
+              data.Multianswer = [];
+              data.linkType = question.linkType;
+              data.linkquestionenabled = question.linkType;
+              data.linkedQuestion = null;
+              data.showLinked = null;
+              data.parentanswer = '';
+              data.dateRangeType = false;
+              reqAnswers.push( data );
+            }
+          } );
+        } else {
+          section.questions.forEach( ( ele ) => {
+            let data = { ...sampleData };
+            data.section_id = section.section_id;
+            data.sectionName = section.sectionName;
+            data.answerType = ele.answerType;
+            data.qno = ele.qno;
+            data.qname = ele.qname;
+            data.answer = 'null';
+            data.remarks = '';
+            data.validationAnswer = '';
+            data.Multianswer = [];
+            data.linkType = ele.linkType;
+            data.linkquestionenabled = ele.linkType;
+            data.linkedQuestion = null;
+            data.showLinked = null;
+            data.parentanswer = '';
+            data.dateRangeType = false;
+            reqAnswers.push( data );
+          } );
+        }
+      } );
+    }
+
+    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.toString() == section.id.toString() );
+      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].qname == qaAnswers[j].oldQname || requestSection[i].qname == qaAnswers[j].qname ) {
+              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 ( typeof qaAnswers[j]?.redo === 'boolean' && requestData.submittype === 'submit' ) {
+                  structure.redo = false;
+                } else if ( requestData.submittype === 'draft' ) {
+                  structure.redo = qaAnswers[j]?.redo;
+                }
+                if ( qaAnswers[j]?.redoComment ) {
+                  structure.redoComment = qaAnswers[j]?.redoComment;
+                };
+                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 ( typeof qaAnswers[j]?.redo === 'boolean' && requestData.submittype === 'submit' ) {
+                  structure.redo = false;
+                } else if ( requestData.submittype === 'draft' ) {
+                  structure.redo = qaAnswers[j]?.redo;
+                }
+                if ( qaAnswers[j]?.redoComment ) {
+                  structure.redoComment = qaAnswers[j]?.redoComment;
+                };
+                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 ( typeof qaAnswers[j]?.redo === 'boolean' && requestData.submittype === 'submit' ) {
+                  structure.redo = false;
+                } else if ( requestData.submittype === 'draft' ) {
+                  structure.redo = qaAnswers[j]?.redo;
+                }
+                if ( qaAnswers[j]?.redoComment ) {
+                  structure.redoComment = qaAnswers[j]?.redoComment;
+                };
+                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 ( typeof qaAnswers[j]?.redo === 'boolean' && requestData.submittype === 'submit' ) {
+                  structure.redo = false;
+                } else if ( requestData.submittype === 'draft' ) {
+                  structure.redo = qaAnswers[j]?.redo;
+                }
+                if ( qaAnswers[j]?.redoComment ) {
+                  structure.redoComment = qaAnswers[j]?.redoComment;
+                };
+                newArray.push( structure );
+              } else {
+                let des = [];
+                if ( requestSection[i].answer != 'null' && requestSection[i].answer != '' && requestSection[i].answer != null ) {
+                  let validationAnswer = '';
+                  if ( requestSection[i].answer.split( '?' ).length > 1 ) {
+                    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 ( typeof qaAnswers[j]?.redo === 'boolean' && requestData.submittype === 'submit' ) {
+                  structure.redo = false;
+                } else if ( requestData.submittype === 'draft' ) {
+                  structure.redo = qaAnswers[j]?.redo;
+                }
+                if ( qaAnswers[j]?.redoComment ) {
+                  structure.redoComment = qaAnswers[j]?.redoComment;
+                };
+                newArray.push( structure );
+              }
+            }
+          }
+        }
+        let sectionData = {
+          'section_id': section.id,
+          'sectionName': section.name,
+          'questions': newArray,
+        };
+        sectionFormat.push( sectionData );
+      }
+    }
+
+
+    requestData.questionAnswers = sectionFormat;
+    logger.error( { message: requestData.questionAnswers, error: 'QuestionanswersPayload' } );
+    next();
+  } catch ( error ) {
+    logger.error( { function: 'sopMobilechecklistMultiSectionFormatter', error: error, body: req.body } );
+    return res.sendError( error, 500 );
+  }
+};
+
 export async function sopMobileTaskMultiSectionFormatter( req, res, next ) {
   try {
     let requestData = req.body;

package/src/controllers/teaxFlag.controller.js

@@ -609,7 +609,14 @@ export const flagCardsV1 = async ( req, res ) => {
     if ( data.questionFlag ) flagCards.questionFlag.count = data.questionFlag;
     if ( data.delayInSubmission ) flagCards.delayInSubmission.count = data.delayInSubmission;
 
-    const publishedAiChecklists = await checklistconfigService.find( { client_id: clientId, publish: true, checkListType: { $ne: 'custom' } }, { checkListType: 1 } );
+    const publishedAiChecklists = await checklistconfigService.find(
+        {
+          client_id: clientId,
+          publish: true,
+          checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection' ] },
+        },
+        { checkListType: 1 },
+    );
 
     if ( !publishedAiChecklists?.length ) {
       return res.sendError( { error: 'No Data Found' }, 204 );
@@ -623,7 +630,9 @@ export const flagCardsV1 = async ( req, res ) => {
 
     if ( resultData && resultData.status_code === '200' ) {
       published.forEach( ( item ) => {
-        flagCards.detectionFlag.count += resultData[item];
+        if ( resultData[item] ) {
+          flagCards.detectionFlag.count += resultData[item];
+        }
       } );
       flagCards.totalFlag = flagCards.detectionFlag.count;
     }
@@ -737,8 +746,14 @@ export const flagComparisonCardsV1 = async ( req, res ) => {
 
       console.log( dayjs( toDate ).startOf( 'day' ).subtract( 1, 'day' ).format( 'YYYY-MM-DD' ), 'new start of' );
 
-      const publishedAiChecklists = await checklistconfigService.find( { client_id: requestData.clientId, publish: true, checkListType: { $ne: 'custom' } }, { checkListType: 1 } );
-
+      const publishedAiChecklists = await checklistconfigService.find(
+          {
+            client_id: requestData.clientId,
+            publish: true,
+            checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection' ] },
+          },
+          { checkListType: 1 },
+      );
       if ( !publishedAiChecklists?.length ) {
         return 0;
       }
@@ -750,7 +765,11 @@ export const flagComparisonCardsV1 = async ( req, res ) => {
 
       if ( resultData?.status_code === '200' ) {
         let result = 0;
-        published.forEach( ( item ) => result += resultData[item] );
+        published.forEach( ( item ) => {
+          if ( resultData[item] ) {
+            result += resultData[item];
+          }
+        } );
         return result;
       }
       return 0;
@@ -804,7 +823,7 @@ export const flagTablesV1 = async ( req, res ) => {
     );
 
     if ( requestData?.filter === 'all' ) {
-      findAndQuery.push( { $or: [ { questionFlag: { $gte: 1 } }, { timeFlag: { $gte: 1 } }, { checkListType: { $ne: 'custom' } } ] } );
+      findAndQuery.push( { $or: [ { questionFlag: { $gte: 1 } }, { timeFlag: { $gte: 1 } }, { checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection' ] } } ] } );
     } else if ( requestData?.filter === 'question' ) {
       findAndQuery.push( { checkListType: 'custom' } );
       findAndQuery.push( { questionFlag: { $gte: 1 } } );
@@ -812,7 +831,7 @@ export const flagTablesV1 = async ( req, res ) => {
       findAndQuery.push( { checkListType: 'custom' } );
       findAndQuery.push( { timeFlag: { $gte: 1 } } );
     } else if ( requestData?.filter === 'detection' ) {
-      findAndQuery.push( { checkListType: { $ne: 'custom' } } );
+      findAndQuery.push( { checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection' ] } } );
     }
 
     findQuery.push( { $match: { $and: findAndQuery } } );
@@ -2629,7 +2648,7 @@ export const checklistDropdownV1 = async ( req, res ) => {
           $or: [
             { questionFlag: { $gte: 1 } },
             { timeFlag: { $gte: 1 } },
-            { checkListType: { $ne: 'custom' } },
+            { checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection' ] } },
           ],
         },
       ] } },

package/src/controllers/trax.controller.js

@@ -468,6 +468,78 @@ async function createUser( data ) {
       role: 'user',
       password: '5dqFKAJj29PsV6P+kL+3Dw==',
       isActive: true,
+      userType: 'client',
+      rolespermission: [
+        {
+          featureName: 'Global',
+          modules: [
+            {
+              name: 'Store',
+              isAdd: false,
+              isEdit: false,
+
+            },
+            {
+              name: 'User',
+              isAdd: false,
+              isEdit: false,
+
+            },
+            {
+              name: 'Camera',
+              isAdd: false,
+              isEdit: false,
+
+            },
+            {
+              name: 'Configuration',
+              isAdd: false,
+              isEdit: false,
+
+            },
+            {
+              name: 'Subscription',
+              isAdd: false,
+              isEdit: false,
+
+            },
+            {
+              name: 'Billing',
+              isAdd: false,
+              isEdit: false,
+
+            },
+          ],
+        },
+        {
+          featurName: 'TangoEye',
+          modules: [
+            {
+              name: 'ZoneTag',
+              isAdd: false,
+              isEdit: false,
+
+            },
+          ],
+        },
+        {
+          featurName: 'TangoTrax',
+          modules: [
+            {
+              name: 'checklist',
+              isAdd: false,
+              isEdit: false,
+
+            },
+            {
+              name: 'Task',
+              isAdd: false,
+              isEdit: false,
+
+            },
+          ],
+        },
+      ],
     };
     let response = await userService.create( params );
     return response._id;
@@ -562,6 +634,7 @@ export const duplicateChecklist = async ( req, res ) => {
           let userDetails = { ...userList[i]._doc };
           userDetails.checkListId = data._id;
           userDetails.checkListName = data.checkListName;
+          userDetails.sendNotification = false;
           delete userDetails['_id'];
           users.push( userDetails );
         }
@@ -935,7 +1008,11 @@ export const updateConfigure =async ( req, res ) => {
       return res.sendError( 'no data found', 204 );
     }
 
-    if ( inputBody.submitType == 'publish' && inputBody?.showEdit && typeof inputBody?.editSubmit == 'undefined' ) {
+    let currentDate = dayjs.utc().format();
+    let updatedscheduleEndTimeISO = dayjs.utc( inputBody?.checkListDetails?.scheduleStartTime, 'hh:mm A' ).format( 'HH:mm:ss' );
+    let newUpdatedDate = dayjs.utc( updatedscheduleEndTimeISO, 'HH:mm:ss' ).format();
+
+    if ( inputBody.submitType == 'publish' && inputBody?.showEdit && typeof inputBody?.editSubmit == 'undefined' && newUpdatedDate > currentDate ) {
       let checkSubmitDetails = await processedchecklist.findOne( { sourceCheckList_id: inputBody.checkListDetails._id, date_string: dayjs().format( 'YYYY-MM-DD' ), checklistStatus: 'submit' } );
       if ( checkSubmitDetails ) {
         return res.sendError( 'Checklist got submitted', 400 );
@@ -1253,7 +1330,7 @@ export const updatePublish = async ( req, res ) => {
               { scheduleEndTime_iso: { $gt: currentDate } },
             ],
           };
-          deleteQuery.$and.push( { checklistStatus: { $ne: 'submit' } } );
+          deleteQuery.$and.push( { checklistStatus: { $eq: 'open' } } );
           let PClicklist = await processedchecklist.deleteMany( deleteQuery );
           logger.info( { function: 'updatePublish', query: deleteQuery } );
           logger.info( `Deleted Checklist Before Insert => Checklist Name: ${getCheckDetails.checkListName}, PChecklist Count: ${PClicklist.deletedCount}` );
@@ -1276,8 +1353,8 @@ export const updatePublish = async ( req, res ) => {
               { scheduleEndTime_iso: { $gt: currentDate } },
             ],
           };
-          await processedchecklistConfig.deleteMany( deleteQuery );
-          deleteQuery.$and.push( { checklistStatus: { $ne: 'submit' } } );
+          // await processedchecklistConfig.deleteMany( deleteQuery );
+          deleteQuery.$and.push( { checklistStatus: { $eq: 'open' } } );
           await processedchecklist.deleteMany( deleteQuery );
           logger.info( { function: 'updatePublish', query: deleteQuery } );
 
@@ -1466,9 +1543,9 @@ export const validateUser = async ( req, res ) => {
           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]?.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' } );
           }
@@ -1957,7 +2034,7 @@ async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedche
     let userIdList = [];
     let tokenList = [];
     let notifyUserList = [];
-    let status = [ { checklistStatus: { $nin: 'open' } } ];
+    let status = [ { checklistStatus: { $ne: 'open' } } ];
 
     for ( let element4 of allQuestion ) {
       let getToken = await userService.findOne( { _id: element4.userId }, { fcmToken: 1 } );
@@ -2045,9 +2122,11 @@ async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedche
             if ( getsubmitDetails[0].checkListDescription != getCLconfig.checkListDescription ) {
               getsubmitDetails[0].checkListDescription = getCLconfig.checkListDescription;
             }
+            let sectionList = [];
             for ( let [ index, section ] of questionList.entries() ) {
-              let checkExists = getsubmitDetails[0].questionAnswers.findIndex( ( sec ) => sec.sectionName == section.sectionOldName );
+              let checkExists = getsubmitDetails[0].questionAnswers.findIndex( ( sec ) => sec.sectionName == section?.sectionOldName || sec.sectionName == section.sectionName );
               if ( checkExists != -1 ) {
+                getsubmitDetails[0].questionAnswers[index].section_id = section.section_id;
                 getsubmitDetails[0].questionAnswers[index].sectionName = section.sectionName;
                 let question = [];
                 section.questions.forEach( ( qns ) => {
@@ -2085,13 +2164,17 @@ async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedche
                   }
                 } );
                 getsubmitDetails[0].questionAnswers[index].questions = question;
+                sectionList.push( getsubmitDetails[0].questionAnswers[index] );
               } else {
                 modifiedCount++;
-                getsubmitDetails[0].questionAnswers.push( section );
+                sectionList.push( section );
               }
             }
+            getsubmitDetails[0].questionAnswers = sectionList;
             if ( modifiedCount ) {
               getsubmitDetails[0].checklistStatus = 'inprogress';
+              getsubmitDetails[0].date_string = dayjs( currentdate ).format( 'YYYY-MM-DD' );
+              getsubmitDetails[0].date_iso = new Date( date );
             }
             let data = { ...getsubmitDetails[0]._doc };
             await processedchecklist.updateOne( { _id: getsubmitDetails[0]._id }, data );
@@ -2189,7 +2272,7 @@ async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedche
 export const aiChecklist = async ( req, res ) => {
   try {
     let storeDetails = await storeService.count( { clientId: req.query.clientId, status: 'active' } );
-    let aiList = [ 'mobileusagedetection', 'storeopenandclose', 'uniformdetection', 'staffleftinthemiddle', 'customerunattended' ];
+    let aiList = [ 'mobileusagedetection', 'storeopenandclose', 'uniformdetection', 'staffleftinthemiddle', 'customerunattended', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring' ];
     let checklistDetails = [];
     let publishList = [];
     let unpublishList = [];

package/src/controllers/traxDashboard.controllers.js

@@ -3619,10 +3619,10 @@ export async function sendAlert( req, res ) {
           data.token.map( async ( item ) => {
             let title = '';
             let description = '';
-            if ( item.checklistStatus === 'open' ) {
+            if ( data.checklistStatus === 'open' ) {
               title = `${item.store} Checklist Open`;
               description = `The  ${data.checklistName} checklist is currently open. Complete now to avoid compliance.`;
-            } else if ( item.checklistStatus === 'inprogress' ) {
+            } else if ( data.checklistStatus === 'inprogress' ) {
               title = `${item.store} Checklist In-progress`;
               description = `The ${data.checklistName} checklist is currently in progress. Complete now to avoid compliance.`;
             }

package/src/routes/mobileTrax.routes.js

@@ -11,6 +11,7 @@ mobileRouter
     .post( '/startCheckList', isAllowedSessionHandler, validate( startValidation ), mobileController.startChecklist )
     .post( '/startTask', isAllowedSessionHandler, validate( startValidation ), mobileController.startTask )
     .post( '/submitCheckList', isAllowedSessionHandler, mobileController.sopMobilechecklistValidater, mobileController.sopMobilechecklistQuestionValidator, mobileController.sopMobilechecklistMultiSectionFormatter, mobileController.submitChecklist )
+    .post( '/submitCheckListv5', isAllowedSessionHandler, mobileController.sopMobilechecklistValidater, mobileController.sopMobilechecklistQuestionValidatorv1, mobileController.sopMobilechecklistMultiSectionFormatterv1, mobileController.submitChecklist )
     .post( '/submitTask', isAllowedSessionHandler, mobileController.sopMobilechecklistValidater, mobileController.sopMobileTaskQuestionValidator, mobileController.sopMobileTaskMultiSectionFormatter, mobileController.submitTask )
     .get( '/dashboard', isAllowedSessionHandler, validate( dashboardValidation ), mobileController.dashboard )
     .get( '/dashboardv1', isAllowedSessionHandler, validate( dashboardValidation ), mobileController.dashboardv1 )