tango-app-api-task 1.0.0-alpha.1 → 1.0.0-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-task",
-    "version": "1.0.0-alpha.1",
+    "version": "1.0.0-alpha.10",
     "description": "Task",
     "main": "index.js",
     "type": "module",
@@ -23,8 +23,8 @@
         "handlebars": "^4.7.8",
         "mongodb": "^6.10.0",
         "nodemon": "^3.1.7",
-        "tango-api-schema": "^2.1.88",
-        "tango-app-api-middleware": "^3.1.43-alpha.9",
+        "tango-api-schema": "^2.1.94",
+        "tango-app-api-middleware": "^3.1.43-alpha.10",
         "winston": "^3.17.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/task.controller.js

@@ -6,6 +6,7 @@ import * as taskAssignService from '../service/taskAssign.service.js';
 import * as userService from '../service/user.service.js';
 import * as storeService from '../service/store.service.js';
 import * as traxApprover from '../service/approver.service.js';
+import * as processedChecklist from '../service/processedChecklist.service.js';
 // import * as domainService from '../service/domain.service.js';
 import mongoose from 'mongoose';
 const ObjectId = mongoose.Types.ObjectId;
@@ -16,7 +17,27 @@ dayjs.extend( utc );
 dayjs.extend( customParseFormat );
 import * as taskProcessedConfigService from '../service/processedTaskConfig.service.js';
 import * as taskProcessedService from '../service/processedTaskList.service.js';
-
+async function LamdaServiceCall( url, data ) {
+  try {
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify( data ),
+    };
+    const response = await fetch( url, requestOptions );
+    if ( !response.ok ) {
+      throw new Error( `Response status: ${response.status}` );
+      return false;
+    }
+    const json = await response.json();
+    return json;
+  } catch ( error ) {
+    logger.error( { error: error, message: data, function: 'LamdaServiceCall' } );
+    return false;
+  }
+}
 export async function createUpdateTask( req, res ) {
   try {
     let inputBody = req.body;
@@ -75,15 +96,19 @@ export async function createUpdateTask( req, res ) {
         for ( let i = 0; i < inputBody?.sections?.length; i++ ) {
           let section = inputBody.sections[i];
           section.questions.forEach( ( section ) => {
-            if ( section.questionReferenceImage && section.questionReferenceImage !='' ) {
-              let imgUrl = decodeURIComponent( section.questionReferenceImage.split( '?' )[0] );
-              let url = imgUrl.split( '/' );
-              url.splice( 0, 3 );
-              section.questionReferenceImage = url.join( '/' );
+            if ( section.questionReferenceImage && section.questionReferenceImage.length ) {
+              let image = [];
+              for ( let img of section.questionReferenceImage ) {
+                let imgUrl = decodeURIComponent( img.split( '?' )[0] );
+                let url = imgUrl.split( '/' );
+                url.splice( 0, 3 );
+                image.push( url.join( '/' ) );
+              }
+              section.questionReferenceImage = image;
             }
             section.answers.forEach( ( answer ) => {
               if ( answer.referenceImage != '' ) {
-                let imgUrl = decodeURIComponent( answer.referenceImage.split( '?' )[0] );
+                let imgUrl = decodeURIComponent( answer.referenceImage?.split( '?' )[0] );
                 let url = imgUrl.split( '/' );
                 url.splice( 0, 3 );
                 answer.referenceImage = url.join( '/' );
@@ -145,6 +170,8 @@ export async function createUpdateTask( req, res ) {
           return res.sendSuccess( { checklistId: checkListId, message: message } );
         }
       }
+    } else {
+      return res.sendError( { message: 'something went wrong' }, 500 );
     }
   } catch ( e ) {
     logger.error( { functionName: 'createTask', error: e } );
@@ -208,12 +235,24 @@ export async function taskDetails( req, res ) {
       let bucket = JSON.parse( process.env.BUCKET );
       questionDetails.forEach( ( item ) => {
         item.question.forEach( async ( question ) => {
-          if ( question.questionReferenceImage && question.questionReferenceImage !='' ) {
+          if ( question.questionReferenceImage && question.questionReferenceImage !='' && typeof question.questionReferenceImage == 'string' ) {
             let inputData = {
               Bucket: bucket.sop,
               file_path: decodeURIComponent( question.questionReferenceImage ),
             };
             question.questionReferenceImage = await signedUrl( inputData );
+          } else {
+            if ( question.questionReferenceImage.length ) {
+              let image = [];
+              for ( let img of question.questionReferenceImage ) {
+                let inputData = {
+                  Bucket: bucket.sop,
+                  file_path: decodeURIComponent( img ),
+                };
+                image.push( await signedUrl( inputData ) );
+              }
+              question.questionReferenceImage = image;
+            }
           }
           question.answers.forEach( async ( answer ) => {
             if ( answer.referenceImage != '' ) {
@@ -297,7 +336,7 @@ export async function validateUser( req, res ) {
           }
           if ( alreadyExist.length ) {
             let email = [ ...new Set( alreadyExist ) ];
-            return res.sendError( `${email.join()} - email already exist`, 500 );
+            return res.sendError( `${email.join()} - email already exist for another brand`, 500 );
           } else {
             userEmail.forEach( ( item ) => {
               data.push( {
@@ -588,6 +627,7 @@ export async function taskConfig( req, res ) {
     let storeCount = 0;
     let locationCount = 0;
     let checklistDetails;
+    inputBody.client_id = inputBody.clientId;
     if ( !inputBody._id ) {
       return res.sendError( { message: 'Task Id is Required' }, 400 );
     }
@@ -605,7 +645,7 @@ export async function taskConfig( req, res ) {
       checkListName: inputBody?.checkListName,
       createdBy: req.user._id,
       createdByName: req.user.userName,
-      client_id: req.body.client_id,
+      client_id: inputBody.client_id,
     };
     await checklistLogs.create( logInsertData );
 
@@ -617,6 +657,7 @@ export async function taskConfig( req, res ) {
 
     let configDetails = { ...req.body };
     configDetails.scheduleEndTimeISO = dayjs.utc( configDetails.scheduleEndTime, 'hh:mm A' ).format();
+    configDetails.publishDate = dayjs().format();
 
     let response = await taskService.updateOne( { _id: inputBody._id }, configDetails );
     if ( inputBody?.approver.length ) {
@@ -631,7 +672,7 @@ export async function taskConfig( req, res ) {
             userEmail: ele.value,
             checkListId: inputBody._id,
             type: 'task',
-            client_id: req.body.client_id,
+            client_id: inputBody.client_id,
           } );
         }
       } );
@@ -653,7 +694,7 @@ export async function taskConfig( req, res ) {
       let query = [
         {
           $match: {
-            client_id: req.body.clientId,
+            client_id: inputBody.client_id,
             id: { $in: storeList },
             city: { $exists: true },
           },
@@ -676,7 +717,7 @@ export async function taskConfig( req, res ) {
     await taskService.updateOne( { _id: inputBody._id }, { storeCount, locationCount } );
     if ( inputBody.submitType == 'publish' ) {
       let currentDate = dayjs.utc().format();
-      let updatedscheduleEndTimeISO = dayjs( checklistDetails?.scheduleDate ).format( 'YYYY-MM-DD' ) + ' ' + checklistDetails.scheduleEndTime;
+      let updatedscheduleEndTimeISO = dayjs.utc( checklistDetails?.scheduleDate ).format( 'YYYY-MM-DD' ) + ' ' + checklistDetails.scheduleEndTime;
       updatedscheduleEndTimeISO = dayjs.utc( updatedscheduleEndTimeISO, 'YYYY-MM-DD hh:mm A' ).format();
       if ( updatedscheduleEndTimeISO >= currentDate ) {
         let deleteQuery = {
@@ -850,6 +891,7 @@ async function insertPCBulkV3( getCLconfig, checklistId, currentdate, updatedche
       element4.publishDate = getCLconfig.publishDate;
       element4.locationCount = getCLconfig.locationCount;
       element4.scheduleRepeatedType = 'daily';
+      element4.approvalEnable = getCLconfig.approver.length ? true : false;
     }
     if ( userIdList.length ) {
       allQuestion = allQuestion.filter( ( item ) => typeof item._id == 'undefined' );
@@ -993,6 +1035,21 @@ export async function reinitiateTask( req, res ) {
 export async function createChecklistTask( req, res ) {
   try {
     let inputBody = req.body;
+    let userId;
+    let userDetails = await userService.findOne( { email: inputBody.userEmail } );
+    if ( !userDetails ) {
+      let userData = {
+        userName: inputBody.userName,
+        email: inputBody.userEmail,
+        mobileNumber: '',
+        clientId: inputBody.clientId,
+      };
+      userId = await createUser( userData );
+    } else {
+      userId = userDetails._id;
+    }
+    let time = inputBody?.scheduleEndTime || '11:59 PM';
+    let date = inputBody?.scheduleDate || dayjs().format( 'YYYY-MM-DD' );
     let data = {
       checkListName: inputBody.checkListName,
       checkListDescription: inputBody.checkListDescription,
@@ -1001,15 +1058,15 @@ export async function createChecklistTask( req, res ) {
       publish: true,
       questionCount: 1,
       storeCount: 1,
-      scheduleDate: inputBody?.scheduleDate || dayjs().format( 'YYYY-MM-DD' ),
-      scheduleEndTime: inputBody?.scheduleEndTime || '11:59 PM',
-      scheduleEndTimeISO: dayjs.utc( inputBody.scheduleEndTime, 'hh:mm A' ).format(),
+      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,
-      referenceCheckListId: inputBody?.checkListId,
+      referenceCheckListId: inputBody?.checkListId || '',
     };
 
     let response = await taskService.create( data );
@@ -1033,7 +1090,7 @@ export async function createChecklistTask( req, res ) {
         client_id: inputBody.clientId,
       };
       await taskQuestionService.create( question );
-      let storeDetails = await storeService.findOne( { storeName: inputBody.storeName }, { storeId: 1, storeProfile: 1 } );
+      let storeDetails = await storeService.findOne( { storeName: inputBody.storeName, status: 'active' }, { storeId: 1, storeProfile: 1 } );
       if ( !storeDetails ) {
         return res.sendError( 'No data found', 204 );
       }
@@ -1047,8 +1104,52 @@ export async function createChecklistTask( req, res ) {
         checkListId: response?._id,
         checkListName: inputBody.checkListName,
         client_id: inputBody.clientId,
+        userId: userId,
       };
       await taskAssignService.create( userDetails );
+
+      if ( inputBody.checkListType == 'checklistTask' ) {
+        let taskDetails = await processedChecklist.findOne( { _id: req.body.processedChecklistId }, { questionAnswers: 1, taskStatus: 1, checklistStatus: 1, client_id: 1, store_id: 1, storeName: 1, checkListType: 1, sourceCheckList_id: 1, checkListName: 1 } );
+        if ( !taskDetails ) {
+          return res.sendError( 'No data found', 204 );
+        }
+        let question = taskDetails.questionAnswers;
+        let sectionIndex = question.findIndex( ( sec ) => sec.section_id == req.body.sectionId );
+        if ( sectionIndex == -1 ) {
+          return res.sendError( 'section is not found', 400 );
+        }
+        let data = { ...question[sectionIndex].questions[req.body.qno - 1], 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: req.body.processedChecklistId }, updateData );
+        let params = {
+          'payload': {
+            _id: inputBody.processedChecklistId,
+            section_id: inputBody.sectionId,
+            qno: inputBody.qno,
+          },
+          'upsert': {
+            taskId: String( response?._id ),
+            taskStatus: true,
+            task: true,
+          },
+        };
+        const requestOptions = {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify( params ),
+        };
+        let searchResponse = await fetch( 'https://7et6pebvmii725tcntww4w56yq0rjpqw.lambda-url.ap-south-1.on.aws/', requestOptions );
+        if ( !searchResponse.ok ) {
+          return res.sendError( 'Something went wrong', 500 );
+        }
+      }
       await insertSingleProcessData( response?._id );
       return res.sendSuccess( 'Task created successfully' );
     }
@@ -1057,3 +1158,281 @@ export async function createChecklistTask( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+export async function approveTask( req, res ) {
+  try {
+    let toDate = new Date( req.body.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+    let query = { sourceCheckList_id: req.body.sourceCheckList_id, date_iso: { $gte: req.body.fromDate, $lte: toDate }, checklistStatus: 'submit', approvalEnable: true };
+    if ( req.body?.storeId?.length ) {
+      query['store_id'] = { $in: req.body.storeId };
+    }
+    let taskDetails = await taskProcessedService.find( query, { _id: 1 } );
+    if ( !taskDetails.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let idList = taskDetails.map( ( item ) => item._id );
+    let updateResponse = await taskProcessedService.updateMany( { _id: { $in: idList } }, { approvalStatus: true } );
+    if ( updateResponse.modifiedCount || updateResponse.matchedCount ) {
+      let params = {
+        'payload': {
+          sourceCheckList_id: req.body.sourceCheckList_id,
+          fromDate: req.body.fromDate,
+          toDate: req.body.toDate,
+          store_id: req.body.storeId,
+        },
+        'upsert': {
+          approvalStatus: true,
+        },
+      };
+      const requestOptions = {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify( params ),
+      };
+      let searchResponse = await fetch( 'https://wnx32v5mtyqx6kh3nt6xuosjqa0xvdfq.lambda-url.ap-south-1.on.aws', requestOptions );
+      if ( searchResponse.ok ) {
+        return res.sendSuccess( 'Task Approved successfully' );
+      } else {
+        return res.sendError( 'Something went wrong', 500 );
+      }
+    }
+  } catch ( e ) {
+    logger.error( { function: 'approveTask', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function redoTask( req, res ) {
+  try {
+    if ( !req.body.payload._id ) {
+      return res.sendError( 'Id is Required', 400 );
+    }
+    if ( !req.body.payload.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: 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 } );
+    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 };
+    let userAnswer = data.userAnswer;
+    question[sectionIndex].questions[req.body.payload.qno - 1] = data;
+    question[sectionIndex].questions[req.body.payload.qno - 1].userAnswer = [];
+    taskDetails.questionAnswers = question;
+    let updateData = {
+      checklistStatus: 'open',
+      redoStatus: true,
+      questionAnswers: question,
+    };
+
+    let response = await taskProcessedService.updateOne( { _id: req.body.payload._id }, updateData );
+    if ( response.modifiedCount || response.matchedCount ) {
+      data = {
+        checklistId: taskDetails.sourceCheckList_id,
+        checkListName: taskDetails.checkListName,
+        sectionId: req.body.payload.section_id,
+        sectionName: question[sectionIndex].sectionName,
+        questionName: question[sectionIndex].questions[req.body.payload.qno - 1].qname,
+        action: 'redo',
+        store_id: taskDetails.store_id,
+        storeName: taskDetails.storeName,
+        client_id: taskDetails.client_id,
+        processedChecklistId: taskDetails._id,
+        type: taskDetails.checkListType,
+        userAnswer: userAnswer,
+      };
+      await checklistLogs.create( data );
+      const requestOptions = {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify( req.body ),
+      };
+      let searchResponse = await fetch( 'https://ottrgmadjmqptsxdmlckjxdjuy0qvpnt.lambda-url.ap-south-1.on.aws/', requestOptions );
+      if ( searchResponse.ok ) {
+        return res.sendSuccess( 'Question redo successfully' );
+      } else {
+        return res.sendError( 'Something went wrong', 500 );
+      }
+    } else {
+      return res.sendError( 'Something went wrong', 500 );
+    }
+  } catch ( e ) {
+    logger.error( { function: 'redoChecklist', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
+export async function getQuestions( req, res ) {
+  try {
+    let url = JSON.parse( process.env.LAMBDAURL );
+    let resultData = await LamdaServiceCall( url.taskQuestion, req.body );
+    if ( resultData ) {
+      if ( resultData.status_code == '200' ) {
+        return res.sendSuccess( resultData );
+      } else {
+        return res.sendError( 'No Content', 204 );
+      }
+    } else {
+      return res.sendError( 'No Content', 204 );
+    }
+  } catch ( error ) {
+    logger.error( error, 'getQuestions' );
+    return res.sendError( error, 500 );
+  }
+}
+export async function getAnswers( req, res ) {
+  try {
+    let url = JSON.parse( process.env.LAMBDAURL );
+    let resultData = await LamdaServiceCall( url.taskAnswer, req.body );
+    if ( resultData ) {
+      if ( resultData.status_code == '200' ) {
+        return res.sendSuccess( resultData );
+      } else {
+        return res.sendError( 'No Content', 204 );
+      }
+    } else {
+      return res.sendError( 'No Content', 204 );
+    }
+  } catch ( error ) {
+    logger.error( error, 'getAnswers' );
+    return res.sendError( error, 500 );
+  }
+}
+export async function getAnswerCount( req, res ) {
+  try {
+    let url = JSON.parse( process.env.LAMBDAURL );
+    let resultData = await LamdaServiceCall( url.taskAnswercount, req.body );
+    if ( resultData ) {
+      if ( resultData.status_code == '200' ) {
+        return res.sendSuccess( resultData );
+      } else {
+        return res.sendError( 'No Content', 204 );
+      }
+    } else {
+      return res.sendError( 'No Content', 204 );
+    }
+  } catch ( error ) {
+    logger.error( error, 'getAnswerCount' );
+    return res.sendError( error, 500 );
+  }
+}
+export const taskDropdown = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+
+    let result = {};
+
+    let findQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { client_id: requestData.clientId },
+        // { date_iso: { $gte: fromDate } },
+        // { date_iso: { $lte: toDate } },
+        { checkListType: { $in: [ 'task', 'checklistTask', 'cctv' ] } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListName: 1,
+        checkListType: 1,
+        createdByName: 1,
+        storeCount: 1,
+        scheduleRepeatedType: 1,
+        scheduleStartTime: 1,
+        scheduleEndTime: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+        sourceCheckList_id: { $last: '$sourceCheckList_id' },
+        checkListName: { $last: '$checkListName' },
+        checkListType: { $last: '$checkListType' },
+        createdByName: { $last: '$createdByName' },
+        storeCount: { $max: '$storeCount' },
+        scheduleRepeatedType: { $last: '$scheduleRepeatedType' },
+        scheduleStartTime: { $last: '$scheduleStartTime' },
+        scheduleEndTime: { $last: '$scheduleEndTime' },
+      },
+    } );
+
+    findQuery.push( {
+      $lookup: {
+        from: 'checklistconfigs',
+        let: { sourceCheckList_id: '$sourceCheckList_id' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: [ '$_id', '$$sourceCheckList_id' ] },
+                ],
+              },
+            },
+          },
+          {
+            $project: {
+              checkListName: 1,
+              checkListDescription: 1,
+              publish: 1,
+            },
+          },
+        ], as: 'checklistconfigs',
+      },
+    } );
+    findQuery.push( { $unwind: { path: '$checklistconfigs', preserveNullAndEmptyArrays: true } } );
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListName: 1,
+        checkListType: 1,
+        createdByName: 1,
+        storeCount: 1,
+        scheduleRepeatedType: 1,
+        scheduleStartTime: 1,
+        scheduleEndTime: 1,
+        checkListDescription: '$checklistconfigs.checkListDescription',
+        publish: '$checklistconfigs.publish',
+      },
+    } );
+
+    let getTotalCount = await taskProcessedConfigService.aggregate( findQuery );
+    if ( !getTotalCount.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
+      findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
+    } else {
+      findQuery.push( { $sort: { ['checkListName']: -1 } } );
+    }
+
+    let getChecklistData = await taskProcessedConfigService.aggregate( findQuery );
+    result.checklistData = getChecklistData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'checklistDropdown' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};

package/src/controllers/taskActionCenter.controllers.js

@@ -2,19 +2,20 @@ import * as traxApprover from '../service/approver.service.js';
 import * as processedTask from '../service/processedTaskList.service.js';
 import { logger } from 'tango-app-api-middleware';
 import * as processedChecklist from '../service/processedChecklist.service.js';
+import * as checklistLog from '../service/checklistLog.service.js';
 import mongoose from 'mongoose';
 const ObjectId = mongoose.Types.ObjectId;
-export const overallCards = async ( req, res ) => {
+export const overallCardsV1 = async ( req, res ) => {
   try {
     let query;
     let taskIdList = [];
     let checklistIdList = [];
     let resultData;
-    if ( req?.user?.userType == 'client' && req.user.role == 'superadmin' || req.body?.clientId ) {
-      let clientId = req.user?.clientId || req.body?.clientId;
+    if ( ( req?.user?.userType == 'client' && req.user.role == 'superadmin' ) ) {
+      let clientId = req.user?.clientId;
       query = { client_id: clientId };
     } else {
-      query = { userEmail: req.user.userEmail };
+      query = { userEmail: req.user.email };
     }
     let details = await traxApprover.find( query );
     if ( details.length ) {
@@ -34,7 +35,7 @@ export const overallCards = async ( req, res ) => {
       ].map( ( item ) => new ObjectId( item ) );
     }
 
-    let toDate = new Date( req.body.date );
+    let toDate = new Date( req.body.toDate );
     let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
     toDate = new Date( toDate.getTime() - userTimezoneOffset );
     toDate.setUTCHours( 23, 59, 59, 59 );
@@ -45,31 +46,37 @@ export const overallCards = async ( req, res ) => {
       },
     };
 
-    query = [
+    let taskQuery = [
       {
         $match: {
-          date_iso: { $gte: new Date( req.body.date ), $lte: toDate },
+          date_iso: { $gte: new Date( req.body.fromDate ), $lte: toDate },
           sourceCheckList_id: { $in: taskIdList },
+          ...( req.body?.storeId?.length ) ? { store_id: { $in: req.body.storeId } } :{},
           approvalStatus: false,
         },
       },
       { ...groupQuery },
     ];
-    let taskCount = await processedTask.aggregate( query );
 
-    query = [
+    let checklistQuery = [
       {
         $match: {
-          date_iso: { $gte: new Date( req.body.date ), $lte: toDate },
+          date_iso: { $gte: new Date( req.body.fromDate ), $lte: toDate },
           sourceCheckList_id: { $in: checklistIdList },
+          ...( req.body?.storeId?.length ) ? { store_id: { $in: req.body.storeId } } :{},
           approvalStatus: false,
         },
       },
       { ...groupQuery },
     ];
-    let checklistCount = await processedChecklist.aggregate( query );
-    resultData = { taskCount: taskCount?.[0]?.count || 0, checklistCount: checklistCount?.[0]?.count || 0 };
-    return res.sendSuccess( resultData );
+
+    let [ taskCount, checklistCount ] = await Promise.all( [
+      processedTask.aggregate( taskQuery ),
+      processedChecklist.aggregate( checklistQuery ),
+    ] );
+
+    resultData = { taskApproval: { count: taskCount?.[0]?.count || 0 }, checklistApproval: { count: checklistCount?.[0]?.count || 0 } };
+    return res.sendSuccess( { cardData: resultData } );
   } catch ( error ) {
     console.log( 'error =>', error );
     logger.error( { error: error, function: 'overallCards' } );
@@ -77,37 +84,17 @@ export const overallCards = async ( req, res ) => {
   }
 };
 
-// async function overallCardsData( requestData ) {
-//   try {
-//     let cardData = {
-//       'checklistApproval': {
-//         'count': 50, // Checklist Count
-//       },
-//       'taskApproval': {
-//         'count': 40, // Task Count
-//       },
-//     };
-//     // resultData.card = cardData;
-//     return { cardData: cardData };
-//   } catch ( error ) {
-//     console.log( 'error =>', error );
-//     logger.error( { error: error, message: data, function: 'overallCardsData' } );
-//   }
-// }
-
-export const approvalTable = async ( req, res ) => {
+export const approvalTableV1 = async ( req, res ) => {
   try {
     let query;
     let taskIdList = [];
     let checklistIdList = [];
     let resultData;
-    let taskResult = [];
-    let checklistResult = [];
-    if ( req?.user?.userType == 'client' && req.user.role == 'superadmin' || req.body?.clientId ) {
-      let clientId = req.user?.clientId || req.body?.clientId;
+    if ( ( req?.user?.userType == 'client' && req.user.role == 'superadmin' ) ) {
+      let clientId = req.user?.clientId;
       query = { client_id: clientId };
     } else {
-      query = { userEmail: req.user.userEmail };
+      query = { userEmail: req.user.email };
     }
     let details = await traxApprover.find( query );
     if ( details.length ) {
@@ -118,6 +105,7 @@ export const approvalTable = async ( req, res ) => {
                 .map( ( ele ) => ele.checkListId.toString() ),
         ),
       ].map( ( item ) => new ObjectId( item ) );
+
       checklistIdList = [
         ...new Set(
             details
@@ -127,7 +115,7 @@ export const approvalTable = async ( req, res ) => {
       ].map( ( item ) => new ObjectId( item ) );
     }
 
-    let toDate = new Date( req.body.date );
+    let toDate = new Date( req.body.toDate );
     let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
     toDate = new Date( toDate.getTime() - userTimezoneOffset );
     toDate.setUTCHours( 23, 59, 59, 59 );
@@ -176,33 +164,65 @@ export const approvalTable = async ( req, res ) => {
       },
     } ];
 
+    const promises = [];
 
     if ( [ 'task', 'all' ].includes( req.body.type ) ) {
       query = [
         {
           $match: {
-            date_iso: { $gte: new Date( req.body.date ), $lte: toDate },
+            date_iso: { $gte: new Date( req.body.fromDate ), $lte: toDate },
             sourceCheckList_id: { $in: taskIdList },
+            ...( req.body?.storeId?.length ) ? { store_id: { $in: req.body.storeId } } :{},
           },
         },
         ...groupQuery,
       ];
-      taskResult = await processedTask.aggregate( query );
+      if ( req.body?.searchValue?.trim() && req.body?.searchValue?.trim().length ) {
+        query.push( {
+          $match: {
+            checkListName: { $regex: req.body?.searchValue, $options: 'i' },
+          },
+        } );
+      }
+      if ( req.body?.filter.length ) {
+        query.push( {
+          $match: {
+            priorityType: { $in: req.body?.filter },
+          },
+        } );
+      }
+      promises.push( processedTask.aggregate( query ) );
+    } else {
+      promises.push( Promise.resolve( null ) );
     }
+
+
     if ( [ 'checklist', 'all' ].includes( req.body.type ) ) {
       query = [
         {
           $match: {
-            date_iso: { $gte: new Date( req.body.date ), $lte: toDate },
+            date_iso: { $gte: new Date( req.body.fromDate ), $lte: toDate },
             sourceCheckList_id: { $in: checklistIdList },
+            ...( req.body?.storeId?.length ) ? { store_id: { $in: req.body.storeId } } : {},
           },
         },
         ...groupQuery,
       ];
-
-      checklistResult = await processedChecklist.aggregate( query );
+      promises.push( processedChecklist.aggregate( query ) );
+      if ( req.body?.searchValue.trim() && req.body?.searchValue.trim().length ) {
+        query.push( {
+          $match: {
+            checkListName: { $regex: req.body?.searchValue, $options: 'i' },
+          },
+        } );
+      }
+    } else {
+      promises.push( Promise.resolve( null ) );
     }
-    const taskSummary = taskResult.reduce(
+
+    const [ taskResult, checklistResult ] = await Promise.all( promises );
+
+    const taskSummary = taskResult?.reduce(
         ( acc, ele ) => {
           if ( ele.unApproveCount === ele.storeCount ) {
             acc.openTask.push( ele );
@@ -215,9 +235,9 @@ export const approvalTable = async ( req, res ) => {
         },
         { openTask: [], inprogressTask: [], doneTask: [] },
     );
-    const { openTask, inprogressTask, doneTask } = taskSummary;
+    const { openTask, inprogressTask, doneTask } = taskSummary || { openTask: [], inprogressTask: [], doneTask: [] };
 
-    const checklistSummary = checklistResult.reduce(
+    const checklistSummary = checklistResult?.reduce(
         ( acc, ele ) => {
           if ( ele.unApproveCount === ele.storeCount ) {
             acc.openChecklist.push( ele );
@@ -230,7 +250,7 @@ export const approvalTable = async ( req, res ) => {
         },
         { openChecklist: [], inprogressChecklist: [], doneChecklist: [] },
     );
-    const { openChecklist, inprogressChecklist, doneChecklist } = checklistSummary;
+    const { openChecklist, inprogressChecklist, doneChecklist } = checklistSummary || { openChecklist: [], inprogressChecklist: [], doneChecklist: [] };
 
     resultData = { open: [ ...openTask, ...openChecklist ], inprogress: [ ...inprogressTask, ...inprogressChecklist ], done: [ ...doneTask, ...doneChecklist ] };
 
@@ -241,72 +261,167 @@ export const approvalTable = async ( req, res ) => {
   }
 };
 
-// async function approvalTableData( requestData ) {
-//   try {
-//     let tableData = {
-//       'totalCount': 50,
-//       'approvalList': [
-//         {
-//           'taskName': 'Hustlr Tray',
-//           'createdBy': 'Olivia Rhye',
-//           'totalAssigned': 100,
-//           'totalSubmitted': 200,
-//           'scheduledRepeatedType': 'daily', // weekly or monthly,
-//           'dateString': '12 Jan,2024',
-//           'sorceTaskId': '4862896912909',
-//           'taskType': 'task', // checklist or redo
-//           'status': 'open', // inprogress or approved
-//           'priority': 'high',
-//           'approved': 90,
-//         },
-//         {
-//           'taskName': 'Hustlr Tray',
-//           'createdBy': 'Olivia Rhye',
-//           'totalAssigned': 100,
-//           'totalSubmitted': 200,
-//           'scheduledRepeatedType': 'daily', // weekly or monthly,
-//           'dateString': '12 Jan,2024',
-//           'sorceTaskId': '4862896912909',
-//           'taskType': 'redo', // checklist or redo
-//           'status': 'inprogress', // inprogress or approved
-//           'priority': 'low',
-//           'approved': 90,
-//         },
-//         {
-//           'taskName': 'Hustlr Tray',
-//           'createdBy': 'Olivia Rhye',
-//           'totalAssigned': 100,
-//           'totalSubmitted': 200,
-//           'scheduledRepeatedType': 'daily', // weekly or monthly,
-//           'dateString': '12 Jan,2024',
-//           'sorceTaskId': '4862896912909',
-//           'taskType': 'task', // checklist or redo
-//           'status': 'approved', // inprogress or approved
-//           'priority': 'low',
-//           'approved': 90,
-//         },
-//         {
-//           'taskName': 'Hustlr Tray',
-//           'createdBy': 'Olivia Rhye',
-//           'totalAssigned': 100,
-//           'totalSubmitted': 200,
-//           'scheduledRepeatedType': 'daily', // weekly or monthly,
-//           'dateString': '12 Jan,2024',
-//           'sorceTaskId': '4862896912909',
-//           'taskType': 'task', // checklist or redo
-//           'status': 'approved', // inprogress or approved
-//           'priority': 'low',
-//           'approved': 90,
-//         },
-//       ],
-//     };
-//     return tableData;
-//   } catch ( error ) {
-//     console.log( 'error =>', error );
-//     logger.error( { error: error, message: requestData, function: 'approvalTableData' } );
-//     return res.sendError( error, 500 );
-//   }
-// }
+export const activityLogV1 = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let findQuery = [];
+    let findAndQuery = [];
+
+
+    findAndQuery.push(
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+        { action: { $in: [ 'submitted', 'started' ] } },
+    );
+
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+    findQuery.push( {
+      $project: {
+        checkListName: 1,
+        storeName: 1,
+        action: 1,
+        createdAt: 1,
+        type: 1,
+      },
+    } );
+    let limit = parseInt( requestData?.limit ) || 10;
+    let skip = limit * ( requestData?.offset -1 ) || 0;
+
+    findQuery.push( {
+      $facet: {
+        activityLogData: [
+          { $skip: skip },
+          { $limit: limit },
+        ],
+        count: [
+          { $count: 'total' },
+        ],
+      },
+    } );
+
+
+    let activityLogData = await checklistLog.aggregate( findQuery );
+
+    if ( activityLogData && activityLogData.length > 0 ) {
+      return res.sendSuccess( activityLogData );
+    } else {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'activityLogV1' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const overallCards = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await overallCardsData( requestData );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'overallCards' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+async function overallCardsData( requestData ) {
+  try {
+    let cardData = {
+      'checklistApproval': {
+        'count': 50, // Checklist Count
+      },
+      'taskApproval': {
+        'count': 40, // Task Count
+      },
+    };
+    // resultData.card = cardData;
+    return { cardData: cardData };
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: data, function: 'overallCardsData' } );
+  }
+}
+
+export const approvalTable = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let resultData = await approvalTableData( requestData );
+    return res.sendSuccess( resultData );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, function: 'taskTable' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+async function approvalTableData( requestData ) {
+  try {
+    let tableData = {
+      'totalCount': 50,
+      'approvalList': [
+        {
+          'taskName': 'Hustlr Tray',
+          'createdBy': 'Olivia Rhye',
+          'totalAssigned': 100,
+          'totalSubmitted': 200,
+          'scheduledRepeatedType': 'daily', // weekly or monthly,
+          'dateString': '12 Jan,2024',
+          'sorceTaskId': '4862896912909',
+          'taskType': 'task', // checklist or redo
+          'status': 'open', // inprogress or approved
+          'priority': 'high',
+          'approved': 90,
+        },
+        {
+          'taskName': 'Hustlr Tray',
+          'createdBy': 'Olivia Rhye',
+          'totalAssigned': 100,
+          'totalSubmitted': 200,
+          'scheduledRepeatedType': 'daily', // weekly or monthly,
+          'dateString': '12 Jan,2024',
+          'sorceTaskId': '4862896912909',
+          'taskType': 'redo', // checklist or redo
+          'status': 'inprogress', // inprogress or approved
+          'priority': 'low',
+          'approved': 90,
+        },
+        {
+          'taskName': 'Hustlr Tray',
+          'createdBy': 'Olivia Rhye',
+          'totalAssigned': 100,
+          'totalSubmitted': 200,
+          'scheduledRepeatedType': 'daily', // weekly or monthly,
+          'dateString': '12 Jan,2024',
+          'sorceTaskId': '4862896912909',
+          'taskType': 'task', // checklist or redo
+          'status': 'approved', // inprogress or approved
+          'priority': 'low',
+          'approved': 90,
+        },
+        {
+          'taskName': 'Hustlr Tray',
+          'createdBy': 'Olivia Rhye',
+          'totalAssigned': 100,
+          'totalSubmitted': 200,
+          'scheduledRepeatedType': 'daily', // weekly or monthly,
+          'dateString': '12 Jan,2024',
+          'sorceTaskId': '4862896912909',
+          'taskType': 'task', // checklist or redo
+          'status': 'approved', // inprogress or approved
+          'priority': 'low',
+          'approved': 90,
+        },
+      ],
+    };
+    return tableData;
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: requestData, function: 'approvalTableData' } );
+    return res.sendError( error, 500 );
+  }
+}
 
 export const activityLog = async ( req, res ) => {
   try {
@@ -319,6 +434,7 @@ export const activityLog = async ( req, res ) => {
     return res.sendError( error, 500 );
   }
 };
+
 async function activityLogData( requestData ) {
   try {
     let activityLogData = {

package/src/controllers/taskDashboard.controllers.js

@@ -58,7 +58,6 @@ export const overallCardsV1 = async ( req, res ) => {
     let findAndQuery = [];
 
     findAndQuery.push(
-        { checkListType: { $eq: 'task' } },
         { date_iso: { $gte: fromDate, $lte: toDate } },
         { client_id: requestData.clientId },
         { store_id: { $in: requestData.storeId } },
@@ -67,7 +66,7 @@ export const overallCardsV1 = async ( req, res ) => {
     findQuery.push( { $match: { $and: findAndQuery } } );
     findQuery.push( {
       $group: {
-        _id: '$checklistStatus',
+        _id: { status: '$checklistStatus', redoType: '$redoStatus', approvalStatus: '$approvalStatus' },
         count: { $sum: 1 },
       },
     },
@@ -75,11 +74,11 @@ export const overallCardsV1 = async ( req, res ) => {
       $group: {
         _id: null,
         TotalTasks: { $sum: '$count' },
-        open: { $sum: { $cond: [ { $eq: [ '$_id', 'open' ] }, '$count', 0 ] } },
-        inprogress: { $sum: { $cond: [ { $eq: [ '$_id', 'inprogress' ] }, '$count', 0 ] } },
-        reopen: { $sum: { $cond: [ { $eq: [ '$_id', 'reopen' ] }, '$count', 0 ] } },
-        submitted: { $sum: { $cond: [ { $eq: [ '$_id', 'submit' ] }, '$count', 0 ] } },
-        closed: { $sum: { $cond: [ { $eq: [ '$_id', 'closed' ] }, '$count', 0 ] } },
+        open: { $sum: { $cond: [ { $and: [ { $eq: [ '$_id.status', 'open' ] }, { $eq: [ '$_id.redoType', false ] } ] }, '$count', 0 ] } },
+        inprogress: { $sum: { $cond: [ { $eq: [ '$_id.status', 'inprogress' ] }, '$count', 0 ] } },
+        reopen: { $sum: { $cond: [ { $and: [ { $eq: [ '$_id.status', 'open' ] }, { $eq: [ '$_id.redoType', true ] } ] }, '$count', 0 ] } },
+        submitted: { $sum: { $cond: [ { $and: [ { $eq: [ '$_id.status', 'submit' ] }, { $eq: [ '$_id.approvalStatus', false ] } ] }, '$count', 0 ] } },
+        closed: { $sum: { $cond: [ { $and: [ { $eq: [ '$_id.status', 'submit' ] }, { $eq: [ '$_id.approvalStatus', true ] } ] }, '$count', 0 ] } },
       },
     },
     {
@@ -112,7 +111,7 @@ export const taskTableV1 = async ( req, res ) => {
     query.push(
         {
           $match: {
-            checkListType: 'task',
+            // checkListType: 'task',
             client_id: req.body.clientId,
             isdeleted: false,
           },
@@ -230,11 +229,10 @@ export const taskInfoTableV1 = async ( req, res ) => {
     let findAndQuery = [];
 
     findAndQuery.push(
+        { date_iso: { $gte: fromDate, $lte: toDate } },
         { client_id: requestData.clientId },
         { store_id: { $in: requestData.storeId } },
-        { date_iso: { $gte: fromDate } },
-        { date_iso: { $lte: toDate } },
-        { checkListType: { $eq: 'task' } },
+        // { checkListType: { $eq: 'task' } },
         { sourceCheckList_id: new mongoose.Types.ObjectId( requestData.taskId ) },
     );
     if ( requestData.checklistStatus && requestData.checklistStatus != 'All' ) {
@@ -315,12 +313,6 @@ export const taskInfoTableV1 = async ( req, res ) => {
       },
     } );
 
-    let getTotalCount = await processedTaskService.aggregate( findQuery );
-    console.log( 'getTotalCount', getTotalCount );
-    if ( !getTotalCount.length ) {
-      return res.sendError( { error: 'No Data Found' }, 204 );
-    }
-
     if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
       findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
     } else {
@@ -329,14 +321,30 @@ export const taskInfoTableV1 = async ( req, res ) => {
 
     let limit = parseInt( requestData?.limit ) || 10;
     let skip = limit * ( requestData?.offset -1 ) || 0;
-    findQuery.push( { $skip: skip }, { $limit: limit } );
+
+    findQuery.push( {
+      $facet: {
+        data: [
+          { $skip: skip },
+          { $limit: limit },
+        ],
+        count: [
+          { $count: 'total' },
+        ],
+      },
+    } );
+
     let taskInfoData = await processedTaskService.aggregate( findQuery );
 
-    result.totalCount = getTotalCount.length;
-    for ( let i = 0; i < taskInfoData.length; i++ ) {
-      taskInfoData[i].scheduleEndTime_iso = dayjs( taskInfoData[i].scheduleEndTime_iso ).format( 'DD MMM YYYY' );
+    if ( !taskInfoData[0].data.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+
+    result.totalCount = taskInfoData[0].count[0].total;
+    for ( let i = 0; i < taskInfoData[0].data.length; i++ ) {
+      taskInfoData[0].data[i].scheduleEndTime_iso = dayjs( taskInfoData[0].data[i].scheduleEndTime_iso ).format( 'DD MMM YYYY' );
     }
-    result.taskInfo = taskInfoData;
+    result.taskInfo = taskInfoData[0].data;
     return res.sendSuccess( result );
   } catch ( error ) {
     console.log( 'error =>', error );
@@ -668,7 +676,8 @@ export const taskDropdownListV1 = async ( req, res ) => {
     let findAndQuery = [];
     findAndQuery.push(
         { client_id: requestData.clientId },
-        { checkListType: 'task' },
+        // { checkListType: 'task' },
+        { isdeleted: false },
     );
     findQuery.push( { $match: { $and: findAndQuery } } );
     findQuery.push( {
@@ -680,6 +689,7 @@ export const taskDropdownListV1 = async ( req, res ) => {
         createdByName: 1,
         storeCount: 1,
         scheduleEndTimeISO: 1,
+        submitTime_string: 1,
       },
     } );
     if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
@@ -745,3 +755,35 @@ async function taskInfoViewData( requestData ) {
     return res.sendError( error, 500 );
   }
 }
+export const taskDeleteV1 = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+
+    if ( !requestData.taskId ) {
+      return res.sendError( 'Missing taskId in request body', 400 );
+    }
+
+    const taskConfig = await taskService.findOne( { _id: new mongoose.Types.ObjectId( requestData.taskId ) }, { _id: 1 } );
+    if ( !taskConfig ) {
+      console.log( 'Task found:', taskConfig );
+      return res.sendError( 'Task not found', 404 );
+    }
+
+    let resultData = await taskService.updateOne(
+        { _id: new mongoose.Types.ObjectId( requestData.taskId ) },
+        { isdeleted: true },
+    );
+
+    if ( resultData ) {
+      console.log( 'Update result:', resultData );
+      return res.sendSuccess( { message: 'Task deleted successfully' } );
+    } else {
+      return res.sendError( 'Something went wrong please try again', 500 );
+    }
+  } catch ( e ) {
+    logger.error( 'taskDeleteV1 =>', e );
+    return res.sendError( e, 500 );
+  }
+};
+
+

package/src/routes/task.routes.js

@@ -14,6 +14,12 @@ taskRouter
     .post( '/uploadImage', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.uploadImage )
     .post( '/config', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.taskConfig )
     .post( '/reinitiate', isAllowedSessionHandler, isAllowedClient, 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( '/checklistTask', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.createChecklistTask )
+    .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( '/taskDropdown', isAllowedSessionHandler, taskController.taskDropdown )
+    .post( '/getQuestions', isAllowedSessionHandler, taskController.getQuestions )
+    .post( '/getAnswers', isAllowedSessionHandler, taskController.getAnswers )
+    .post( '/getAnswerCount', isAllowedSessionHandler, taskController.getAnswerCount );
 
 

package/src/routes/taskActionCenter.routes.js

@@ -3,14 +3,16 @@ import { isAllowedSessionHandler } from 'tango-app-api-middleware';
 export const taskActionCenterRouter = express.Router();
 
 import {
-  overallCards, approvalTable, activityLog,
+  overallCards, approvalTable, activityLog, overallCardsV1, approvalTableV1, activityLogV1,
 } from '../controllers/taskActionCenter.controllers.js';
 
 taskActionCenterRouter
-    .post( '/overallcards', isAllowedSessionHandler, overallCards )
-    // .post( '/overallcardsV1', overallCardsV1 )
-    .post( '/approvalTable', isAllowedSessionHandler, approvalTable )
-    // .post( '/approvalTableV1', approvalTableV1 )
-    .post( '/activityLog', activityLog );
+    .post( '/overallcardsV1', isAllowedSessionHandler, overallCardsV1 )
+    .post( '/overallcards', overallCards )
+    .post( '/approvalTableV1', isAllowedSessionHandler, approvalTableV1 )
+    .post( '/approvalTable', approvalTable )
+    .post( '/activityLog', activityLog )
+    .post( '/activityLogV1', isAllowedSessionHandler, activityLogV1 );
+
 
 export default taskActionCenterRouter;

package/src/routes/taskDashboard.routes.js

@@ -2,7 +2,7 @@ import express from 'express';
 export const taskDashboardRouter = express.Router();
 
 import {
-  overallCards, taskTable, taskInfoTable, taskDropdownList, taskTableV1, overallCardsV1, taskInfoTableV1, taskDropdownListV1,
+  overallCards, taskTable, taskInfoTable, taskDropdownList, taskTableV1, overallCardsV1, taskInfoTableV1, taskDropdownListV1, taskDeleteV1,
 } from '../controllers/taskDashboard.controllers.js';
 
 taskDashboardRouter
@@ -13,6 +13,7 @@ taskDashboardRouter
     .post( '/taskInfoTable', taskInfoTable )
     .post( '/taskInfoTableV1', taskInfoTableV1 )
     .post( '/taskDropdownList', taskDropdownList )
-    .post( '/taskDropdownListV1', taskDropdownListV1 );
+    .post( '/taskDropdownListV1', taskDropdownListV1 )
+    .post( '/taskDeleteV1', taskDeleteV1 );
 
 export default taskDashboardRouter;

package/src/service/processedChecklist.service.js

@@ -4,3 +4,11 @@ export const aggregate = ( query = [] ) => {
   return model.processedchecklistModel.aggregate( query );
 };
 
+export const findOne = ( query = {}, field = {} ) => {
+  return model.processedchecklistModel.findOne( query, field );
+};
+
+export const updateOne = ( query = {}, record = {} ) => {
+  return model.processedchecklistModel.updateOne( query, { $set: record } );
+};
+

package/src/service/processedTaskList.service.js

@@ -12,6 +12,10 @@ export const updateMany = async ( query = {}, record={} ) => {
   return model.taskProcessedModel.updateMany( query, { $set: record } );
 };
 
+export const updateOne = async ( query = {}, record={} ) => {
+  return model.taskProcessedModel.updateOne( query, { $set: record } );
+};
+
 export const insertMany = async ( data = [] ) => {
   return model.taskProcessedModel.insertMany( data );
 };