tango-app-api-task 3.3.1-hotfix-3 → 3.4.0-alpha-1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-task",
-    "version": "3.3.1-hotfix-3",
+    "version": "3.4.0-alpha-1",
     "description": "Task",
     "main": "index.js",
     "type": "module",
@@ -24,7 +24,7 @@
         "mongodb": "^6.10.0",
         "nodemon": "^3.1.7",
         "npm": "^10.9.2",
-        "tango-api-schema": "^2.2.52",
+        "tango-api-schema": "^2.2.73",
         "tango-app-api-middleware": "^3.1.58",
         "winston": "^3.17.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/task.controller.js

@@ -1,4 +1,4 @@
-import { logger, fileUpload, signedUrl, getObject } from 'tango-app-api-middleware';
+import { logger, fileUpload, signedUrl, getObject, insertOpenSearchData } 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';
@@ -1688,6 +1688,7 @@ export async function createChecklistTask( req, res ) {
             section_id: inputBody.sectionId,
             qno: inputBody.qno,
             parentQuestion: inputBody.parentQuestion,
+            uniqueNo: inputBody.uniqueNo,
           },
           'upsert': {
             taskId: String( response?._id ),
@@ -1696,7 +1697,7 @@ export async function createChecklistTask( req, res ) {
             taskDate: dayjs( response.scheduleDate ).format( 'YYYY-MM-DD' ),
           },
         };
-
+        console.log( params );
         const requestOptions = {
           method: 'POST',
           headers: {
@@ -1712,6 +1713,26 @@ export async function createChecklistTask( req, res ) {
         if ( !searchResponse.ok ) {
           return res.sendError( 'Something went wrong', 500 );
         }
+        let logData= {
+          'client_id': inputBody.clientId,
+          'createAt': new Date(),
+          'sourceCheckList_id': taskDetails.sourceCheckList_id,
+          'checkListName': inputBody.checkListName,
+          'fromCheckListName': taskDetails.checkListName,
+          'type': 'task',
+          'action': 'created',
+          'store_id': storeDetails?.storeId?storeDetails.storeId:'',
+          'storeName': inputBody?.storeName?inputBody?.storeName:'',
+          'createdByEmail': req.user.email,
+          'createdBy': req.user._id,
+          'userName': inputBody.userName,
+          'userEmail': inputBody.userEmail,
+          'coverage': 'store',
+          'logDetails': {},
+        };
+        let urlopensearch = JSON.parse( process.env.OPENSEARCH );
+        console.log( 'logData', logData );
+        await insertOpenSearchData( urlopensearch.traxActivityLog, logData );
       }
       await insertSingleProcessData( response?._id );
       return res.sendSuccess( 'Task created successfully' );
@@ -1722,6 +1743,225 @@ export async function createChecklistTask( req, res ) {
   }
 }
 
+export async function createChecklistMultiTask( req, res ) {
+  try {
+    let inputBody = req.body;
+    console.log( inputBody );
+    let inputData= inputBody.coverage==='user'?inputBody.userEmail:inputBody.storeName;
+    let userDetailList;
+    for ( let user of inputData ) {
+      userDetailList = await userService.findOne( { email: user.userEmail } );
+      if ( !userDetailList ) {
+        let userData = {
+          userName: user.userName,
+          email: user.userEmail,
+          mobileNumber: '',
+          clientId: inputBody.clientId,
+        };
+        userDetailList = await createUser( userData );
+      }
+    }
+
+    // let title = `New Task Alert ${inputBody.checkListName}`;
+    // let description = '';
+
+    // if ( inputBody.checkListType === 'checklistTask' ) {
+    //   description = `A new task has been generated from the response for ${inputBody.storeName}.`;
+    // } else if ( inputBody.checkListType === 'CCTV' ) {
+    //   description = `A new task has been generated from the Live view for ${inputBody.storeName}.`;
+    // }
+
+    // if ( userDetails.fcmToken ) {
+    //   const fcmToken = userDetails.fcmToken;
+    //   await sendPushNotification( title, description, fcmToken );
+    // }
+
+    let time = inputBody?.scheduleEndTime || '11:59 PM';
+    let date = inputBody?.scheduleDate || dayjs().format( 'YYYY-MM-DD' );
+    for ( let originaldata of inputData ) {
+      let checklistDetails = await checklistService.findOne( { _id: originaldata?.checkListId }, { coverage: 1 } );
+      let data = {
+        checkListName: inputBody.checkListName,
+        checkListDescription: inputBody.checkListDescription,
+        createdBy: req.user._id,
+        createdByName: req.user.userName,
+        publish: true,
+        questionCount: 1,
+        storeCount: 1,
+        scheduleDate: date,
+        scheduleEndTime: time,
+        scheduleEndTimeISO: dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' ).format(),
+        priorityType: 'high',
+        client_id: inputBody.clientId,
+        checkListType: inputBody.checkListType,
+        publishDate: new Date(),
+        locationCount: 1,
+        ...( originaldata?.checkListId ) ? { referenceCheckListId: originaldata?.checkListId } : {},
+        coverage: checklistDetails?.coverage || 'store',
+      };
+
+      if ( req.user.userType == 'tango' || ( req.user.userType == 'client' && [ 'user' ].includes( req.user.role ) ) ) {
+        let userList = await userService.findOne( { clientId: inputBody.clientId, role: 'superadmin' }, { userName: 1, email: 1 } );
+        if ( userList ) {
+          data['approver'] = { name: userList.userName, value: userList.email };
+        }
+      } else {
+        data['approver'] = { name: req.user.userName, value: req.user.email };
+      }
+
+      let response = await taskService.create( data );
+      if ( response?.approver.length ) {
+        let data = [];
+        response?.approver.forEach( ( ele ) => {
+          data.push( {
+            userEmail: ele.value,
+            checkListId: response._id,
+            type: 'task',
+            client_id: inputBody.clientId,
+            checkListName: inputBody?.checkListName || '',
+          } );
+        } );
+        await traxApprover.insertMany( 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( '/' );
+            if ( url.includes( 'https:' ) || url.includes( 'http:' ) ) {
+              url.splice( 0, 3 );
+            }
+            images.push( url.join( '/' ) );
+          } );
+          inputBody.question[0].questionReferenceImage = images;
+        }
+        if ( inputBody.question[0].answers[0].referenceImage.length ) {
+          let images = [];
+          inputBody.question[0].answers[0].referenceImage.forEach( ( ele ) => {
+            let imgUrl = decodeURIComponent( ele.split( '?' )[0] );
+            let url = imgUrl.split( '/' );
+            if ( url.includes( 'https:' ) || url.includes( 'http:' ) ) {
+              url.splice( 0, 3 );
+            }
+            images.push( url.join( '/' ) );
+          } );
+          inputBody.question[0].answers[0].referenceImage = images;
+        }
+        let question = {
+          checkListId: response?._id,
+          question: inputBody.question,
+          section: 'Section 1',
+          checkList: data.checkListName,
+          client_id: inputBody.clientId,
+        };
+        await taskQuestionService.create( question );
+        let storeDetails;
+        if ( originaldata?.storeName ) {
+          storeDetails = await storeService.findOne( { storeName: originaldata.storeName, status: 'active' }, { storeId: 1, storeProfile: 1 } );
+        }
+
+        let userDetails = {
+          userName: originaldata.userName?originaldata.userName:'',
+          userEmail: originaldata.userEmail?originaldata.userEmail:'',
+          store_id: storeDetails?.storeId?storeDetails.storeId:'',
+          storeName: originaldata?.storeName?originaldata?.storeName:'',
+          city: storeDetails?.storeProfile?.city?storeDetails?.storeProfile?.city:'',
+          checkFlag: true,
+          checkListId: response?._id,
+          checkListName: data.checkListName,
+          client_id: inputBody.clientId,
+          userId: userDetailList&&userDetailList._id?userDetailList._id:'',
+          assignId: response?.coverage == 'store' ? storeDetails?._id : userDetailList._id,
+          coverage: response?.coverage || 'store',
+        };
+        await taskAssignService.create( userDetails );
+        console.log( originaldata?.checklistId );
+        if ( inputBody.checkListType == 'checklistTask' ) {
+          let taskDetails = await processedChecklist.findOne( { _id: originaldata?.checklistId }, { questionAnswers: 1, taskStatus: 1, checklistStatus: 1, client_id: 1, store_id: 1, storeName: 1, checkListType: 1, sourceCheckList_id: 1, checkListName: 1 } );
+          console.log( taskDetails );
+          if ( !taskDetails ) {
+            return res.sendError( 'No data found', 204 );
+          }
+          let question = taskDetails.questionAnswers;
+          let sectionIndex = question.findIndex( ( sec ) => sec?.sectionName == req.body?.sectionName );
+          if ( sectionIndex == -1 ) {
+            return res.sendError( 'section is not found', 400 );
+          }
+          let findQuestion = question[sectionIndex].questions.findIndex( ( ele ) => ele.qno == req.body.qno );
+
+          let data = { ...question[sectionIndex].questions[findQuestion], taskId: response?._id, task: true };
+          question[sectionIndex].questions[req.body.qno - 1] = data;
+          taskDetails.questionAnswers = question;
+          let updateData = {
+            taskStatus: true,
+            questionAnswers: question,
+          };
+          await processedChecklist.updateOne( { _id: originaldata.checklistId }, updateData );
+          let params = {
+            'payload': {
+              _id: originaldata.checklistId,
+              section_id: originaldata.section_id,
+              uniqueNo: originaldata.uniqueNo,
+              qno: inputBody.qno,
+              parentQuestion: inputBody.parentQuestion,
+            },
+            'upsert': {
+              taskId: String( response?._id ),
+              taskStatus: true,
+              task: true,
+              taskDate: dayjs( response.scheduleDate ).format( 'YYYY-MM-DD' ),
+            },
+          };
+
+          const requestOptions = {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+            },
+            body: JSON.stringify( params ),
+          };
+          let url = JSON.parse( process.env.LAMBDAURL );
+
+          let searchResponse = await fetch( url.redoChecklist, requestOptions );
+          console.log( searchResponse.ok );
+
+
+          if ( !searchResponse.ok ) {
+            return res.sendError( 'Something went wrong', 500 );
+          }
+          let logData= {
+            'client_id': inputBody.clientId,
+            'createAt': new Date(),
+            'sourceCheckList_id': taskDetails.sourceCheckList_id,
+            'checkListName': inputBody.checkListName,
+            'fromCheckListName': taskDetails.checkListName,
+            'type': 'task',
+            'action': 'created',
+            'store_id': storeDetails?.storeId?storeDetails.storeId:'',
+            'storeName': originaldata?.storeName?originaldata?.storeName:'',
+            'createdByEmail': req.user.email,
+            'createdBy': req.user._id,
+            // 'userName': inputBody.userName,
+            // 'userEmail': inputBody.userEmail,
+            'coverage': 'store',
+            'logDetails': {},
+          };
+          let urlopensearch = JSON.parse( process.env.OPENSEARCH );
+          console.log( 'logData', logData );
+          await insertOpenSearchData( urlopensearch.traxActivityLog, logData );
+        }
+        await insertSingleProcessData( response?._id );
+      }
+    }
+    return res.sendSuccess( 'Task created successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'createChecklistMultiTask', error: e, message: req.body } );
+    return res.sendError( e, 500 );
+  }
+}
+
 export async function approveTask( req, res ) {
   try {
     let toDate = new Date( req.body.toDate );
@@ -1801,7 +2041,7 @@ export async function redoTask( req, res ) {
       return res.sendError( 'Question number is Required', 400 );
     }
 
-    let taskDetails = await taskProcessedService.findOne( { _id: req.body.payload._id }, { questionAnswers: 1, redoStatus: 1, checklistStatus: 1, client_id: 1, store_id: 1, storeName: 1, checkListType: 1, sourceCheckList_id: 1, checkListName: 1, submitTime: 1, userName: 1, answerType: 1 } );
+    let taskDetails = await taskProcessedService.findOne( { _id: req.body.payload._id }, { questionAnswers: 1, redoStatus: 1, checklistStatus: 1, client_id: 1, store_id: 1, storeName: 1, checkListType: 1, sourceCheckList_id: 1, checkListName: 1, submitTime: 1, userName: 1, answerType: 1, userEmail: 1, coverage: 1 } );
     if ( !taskDetails ) {
       return res.sendError( 'No data found', 204 );
     }
@@ -1866,6 +2106,26 @@ export async function redoTask( req, res ) {
       let url = JSON.parse( process.env.LAMBDAURL );
       let searchResponse = await fetch( url.redoTask, requestOptions );
       // console.log( searchResponse.ok );
+      let logData= {
+        'client_id': taskDetails.client_id,
+        'createAt': new Date(),
+        'sourceCheckList_id': taskDetails.sourceCheckList_id,
+        'checkListName': taskDetails.checkListName,
+        'fromCheckListName': taskDetails.checkListName,
+        'type': 'checklist',
+        'action': 'redo',
+        'storeName': taskDetails?.storeName?taskDetails?.storeName:'',
+        'store_id': taskDetails?.store_id?taskDetails?.store_id:'',
+        'userName': taskDetails.userName,
+        'userEmail': taskDetails.userEmail,
+        'createdByEmail': req.user.email,
+        'createdBy': req.user.userName,
+        'coverage': taskDetails.coverage,
+        'logDetails': {},
+      };
+      let urlopensearch = JSON.parse( process.env.OPENSEARCH );
+      console.log( 'logData', logData );
+      await insertOpenSearchData( urlopensearch.traxActivityLog, logData );
       if ( searchResponse.ok ) {
         return res.sendSuccess( 'Question redo successfully' );
       } else {
@@ -1879,6 +2139,117 @@ export async function redoTask( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+export async function redomultiTask( req, res ) {
+  try {
+    let inputData = req.body.payload.coverage==='user'?req.body.payload.userEmail:req.body.payload.storeName;
+
+
+    for ( let originalData of inputData ) {
+      if ( !originalData.checklistId ) {
+        return res.sendError( 'Id is Required', 400 );
+      }
+      if ( !originalData.section_id ) {
+        return res.sendError( 'Section id is Required', 400 );
+      }
+      if ( !req.body.payload.qno ) {
+        return res.sendError( 'Question number is Required', 400 );
+      }
+
+      let taskDetails = await taskProcessedService.findOne( { _id: originalData.checklistId }, { questionAnswers: 1, redoStatus: 1, checklistStatus: 1, client_id: 1, store_id: 1, storeName: 1, checkListType: 1, sourceCheckList_id: 1, checkListName: 1, submitTime: 1, userName: 1, answerType: 1, userEmail: 1, coverage: 1 } );
+      if ( !taskDetails ) {
+        return res.sendError( 'No data found', 204 );
+      }
+      let question = taskDetails.questionAnswers;
+      let sectionIndex = question.findIndex( ( sec ) => sec.section_id == req.body.payload.section_id );
+      if ( sectionIndex == -1 ) {
+        return res.sendError( 'section is not found', 400 );
+      }
+      let data = { ...question[sectionIndex].questions[req.body.payload.qno - 1], redo: true, redoComment: req.body.payload?.checklistDescription || '' };
+      let userAnswer = data.userAnswer;
+
+      question[sectionIndex].questions[req.body.payload.qno - 1] = data;
+      question[sectionIndex].questions[req.body.payload.qno - 1].remarks = '';
+      question[sectionIndex].questions[req.body.payload.qno - 1].userAnswer = [];
+      taskDetails.questionAnswers = question;
+      let updateData = {
+        checklistStatus: 'open',
+        redoStatus: true,
+        questionAnswers: question,
+        ...( dayjs.utc( taskDetails.scheduleEndTime_iso ).format( 'YYYY-MM-DD' ) == dayjs().format( 'YYYY-MM-DD' ) ) ? { scheduleEndTime_iso: dayjs.utc().endOf( 'day' ) } : {},
+      };
+
+      let response = await taskProcessedService.updateOne( { _id: originalData.checklistId }, updateData );
+      // console.log( response );
+      if ( response.modifiedCount || response.matchedCount ) {
+        let storeTimeZone = await storeService.findOne( { storeName: taskDetails.storeName }, { 'storeProfile.timeZone': 1 } );
+        let currentDateTime;
+        if ( storeTimeZone?.storeProfile?.timeZone ) {
+          currentDateTime = dayjs().tz( storeTimeZone?.storeProfile?.timeZone );
+        } else {
+          currentDateTime = dayjs();
+        }
+        data = {
+          checklistId: taskDetails.sourceCheckList_id,
+          checkListName: taskDetails.checkListName,
+          checklistDescription: req.body.payload.checklistDescription,
+          sectionId: originalData.section_id,
+          sectionName: question[sectionIndex].sectionName,
+          questionName: question[sectionIndex].questions[req.body.payload.qno - 1].qname,
+          action: 'redo',
+          store_id: taskDetails?.store_id?taskDetails?.store_id:'',
+          storeName: taskDetails.storeName?taskDetails.storeName:'',
+          client_id: taskDetails.client_id,
+          processedChecklistId: taskDetails._id,
+          type: taskDetails.checkListType,
+          userAnswer: userAnswer,
+          initiatedBy: req.user.userName,
+          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: taskDetails.userName,
+          submitTime: taskDetails.submitTime,
+        };
+        req.body.payload._id=originalData.checklistId;
+        req.body.payload.section_id=originalData.section_id;
+        req.body.payload.uniqueNo=originalData.uniqueNo;
+        await checklistLogs.create( data );
+        const requestOptions = {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify( req.body ),
+        };
+        let url = JSON.parse( process.env.LAMBDAURL );
+        let searchResponse = await fetch( url.redoTask, requestOptions );
+        console.log( searchResponse.ok );
+        let logData= {
+          'client_id': taskDetails.client_id,
+          'createAt': new Date(),
+          'sourceCheckList_id': taskDetails.sourceCheckList_id,
+          'checkListName': taskDetails.checkListName,
+          'fromCheckListName': taskDetails.checkListName,
+          'type': 'checklist',
+          'action': 'redo',
+          'storeName': taskDetails?.storeName?taskDetails?.storeName:'',
+          'store_id': taskDetails?.store_id?taskDetails?.store_id:'',
+          'userName': taskDetails.userName,
+          'userEmail': taskDetails.userEmail,
+          'createdByEmail': req.user.email,
+          'createdBy': req.user.userName,
+          'coverage': taskDetails.coverage,
+          'logDetails': {},
+        };
+        let urlopensearch = JSON.parse( process.env.OPENSEARCH );
+        console.log( 'logData', logData );
+        await insertOpenSearchData( urlopensearch.traxActivityLog, logData );
+      }
+    }
+    return res.sendSuccess( 'Question redo successfully' );
+  } catch ( e ) {
+    logger.error( { function: 'redomultiTask', error: e, message: req.body } );
+    return res.sendError( e, 500 );
+  }
+}
 
 
 export async function getQuestions( req, res ) {
@@ -4149,6 +4520,7 @@ export async function taskcreation( req, res ) {
         checkListName: data.checkListName,
         client_id: inputBody.clientId,
         userId: userId,
+        assignId: storeDetails._id,
       };
       await taskAssignService.create( userDetails );
       await insertSingleProcessData( response?._id );

package/src/routes/task.routes.js

@@ -15,8 +15,10 @@ taskRouter
     .post( '/config', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.taskConfig )
     .post( '/reinitiate', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.reinitiateTask )
     .post( '/checklistTask', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.createChecklistTask )
+    .post( '/checklistMultiTask', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.createChecklistMultiTask )
     .post( '/updateApprove', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.approveTask )
     .post( '/redo', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.redoTask )
+    .post( '/multiredo', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.redomultiTask )
     .post( '/taskDropdown', isAllowedSessionHandler, taskController.taskDropdown )
     .post( '/getQuestions', isAllowedSessionHandler, taskController.getQuestions )
     .post( '/getAnswers', isAllowedSessionHandler, taskController.getAnswers )