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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-task",
-    "version": "3.4.0-alpha-1",
+    "version": "3.4.0-alpha-3",
     "description": "Task",
     "main": "index.js",
     "type": "module",
@@ -21,6 +21,7 @@
         "express": "^4.21.1",
         "express-fileupload": "^1.5.1",
         "handlebars": "^4.7.8",
+        "lodash": "^4.17.21",
         "mongodb": "^6.10.0",
         "nodemon": "^3.1.7",
         "npm": "^10.9.2",

package/src/controllers/task.controller.js

@@ -25,6 +25,7 @@ import * as ApproverModel from '../service/approver.service.js';
 import { createTeamsModel, findOneTeams, updateOneTeamModel, findteams } from '../service/teams.service.js';
 import { sendPushNotification } from 'tango-app-api-middleware';
 import * as checklistService from '../service/checklist.service.js';
+import isEqual from 'lodash/isEqual.js';
 async function LamdaServiceCall( url, data ) {
   try {
     const requestOptions = {
@@ -52,17 +53,26 @@ export async function createUpdateTask( req, res ) {
     let questionCount = 0;
     let checkListId;
     let query;
-    let checkExistsQuery = { client_id: req.body.clientId, checkListName: inputBody.checklistName, isdeleted: false };
+    let checkExistsQuery = { client_id: inputBody.clientId, checkListName: inputBody.checklistName, isdeleted: false };
     let checkExists;
-    if ( req.body._id ) {
-      checkExistsQuery['_id'] = { $nin: [ new ObjectId( req.body._id ) ] };
+    let taskDetails;
+    if ( inputBody._id ) {
+      checkExistsQuery['_id'] = { $nin: [ new ObjectId( inputBody._id ) ] };
     }
 
     checkExists = await taskService.findOne( checkExistsQuery );
-
     if ( checkExists ) {
       return res.sendError( { message: 'Task name already exists' }, 400 );
     }
+    if ( inputBody._id ) {
+      taskDetails = await taskService.findOne( { _id: inputBody._id } );
+
+      if ( !taskDetails ) {
+        return res.sendError( 'No data found', 204 );
+      }
+    }
+
+    let getExistQuestions = await taskQuestionService.find( { checkListId: inputBody._id } );
 
     inputBody.sections.forEach( async ( element ) => {
       if ( !element?.questions?.length && inputBody.submitType == 'configure' ) {
@@ -81,14 +91,14 @@ export async function createUpdateTask( req, res ) {
       questionCount: questionCount,
       client_id: req.body?.clientId,
     };
-    if ( req.body._id ) {
-      query = { _id: req.body._id, client_id: req.body?.clientId };
+    if ( inputBody._id ) {
+      query = { _id: inputBody._id, client_id: req.body?.clientId };
     } else {
       query = { checkListName: inputBody.checklistName, client_id: req.body?.clientId };
     }
     let data = await taskService.updateOne( query, checkListDetails );
-    if ( data.upsertedId || req.body._id ) {
-      checkListId = data?.upsertedId || req.body._id;
+    if ( data.upsertedId || inputBody._id ) {
+      checkListId = data?.upsertedId || inputBody._id;
       let logInsertData = {
         action: req.body?._id ? 'taskUpdate' : 'taskCreate',
         type: 'task',
@@ -96,7 +106,7 @@ export async function createUpdateTask( req, res ) {
         checkListName: inputBody.checklistName,
         createdBy: req.user._id,
         createdByName: req.user.userName,
-        client_id: req.body.clientId,
+        client_id: inputBody.clientId,
         sections: inputBody?.sections,
         createdByEmail: req.user.email,
       };
@@ -132,31 +142,138 @@ export async function createUpdateTask( req, res ) {
             section: section?.name || 'Section 1',
             createdBy: req.user._id,
             createdByName: req.user.userName,
-            client_id: req.body.clientId,
+            client_id: inputBody.clientId,
             checkListId: checkListId,
             question: section.questions,
             checkList: inputBody.checklistName,
           } );
         }
+      }
+      if ( inputBody._id ) {
+        await taskQuestionService.deleteMany( { checkListId: checkListId } );
+        await taskAssignService.updateMany( { checkListId: inputBody._id }, { checkListName: inputBody.checklistName } );
+      }
+      if ( sectionList.length ) {
+        await taskQuestionService.insertMany( sectionList );
+      }
+      let message = req.body?._id ? 'Task Updated Successfully' : 'Task Created Successfully';
+      if ( inputBody.submitType == 'save' ) {
+        message = 'Saved in draft successfully';
+      }
+      if ( inputBody._id ) {
+        let questionList = {
+          questionAdd: [],
+          questionEdit: [],
+          questionDelete: [],
+        };
 
-        if ( req.body._id ) {
-          await taskQuestionService.deleteMany( { checkListId: checkListId } );
-          await taskAssignService.updateMany( { checkListId: req.body._id }, { checkListName: inputBody.checklistName } );
+        function findDifferences( obj1, obj2 ) {
+          return Object.keys( obj1 ).reduce( ( diff, key ) => {
+            if ( !isEqual( obj1[key], obj2[key] ) ) {
+              diff[key] = { previous: obj1[key], new: obj2[key] };
+            }
+            return diff;
+          }, {} );
         }
-        await taskQuestionService.insertMany( sectionList );
-        let message = req.body?._id ? 'Task Updated Successfully' : 'Task Created Successfully';
-        if ( inputBody.submitType == 'save' ) {
-          message = 'Saved in draft successfully';
+
+        console.log( inputBody.sections );
+        getExistQuestions.forEach( ( ele ) => {
+          ele.question.forEach( ( qn ) => {
+            console.log( qn );
+            console.log( JSON.stringify( inputBody.sections[0].questions ) );
+            let question = inputBody.sections[0].questions.find( ( qns ) => qns.oldQname === qn.qname );
+            console.log( question, 'tion' );
+            if ( question ) {
+              qn.answers.forEach( ( ans ) => {
+                delete ans.answeroptionNumber;
+              } );
+              question.answers.forEach( ( ans ) => {
+                delete ans.answeroptionNumber;
+              } );
+              let compare = findDifferences( qn, question );
+              if ( Object.keys( compare ).length && ( compare?.answerType || compare?.answers || compare?.linkType ) ) {
+                questionList.questionEdit.push( { sectionName: ele.section, questions: [ { previous: qn }, { new: question } ] } );
+              }
+            } else {
+              let sectionIndex = questionList.questionDelete.findIndex( ( sec ) => sec.sectionName === ele.section );
+
+              if ( sectionIndex !== -1 ) {
+                questionList.questionDelete[sectionIndex].questions.push( qn );
+              } else {
+                questionList.questionDelete.push( { sectionName: ele?.section || 'Section 1', questions: [ qn ] } );
+              }
+            }
+          } );
+        } );
+
+        console.log( getExistQuestions, 'qns' );
+
+        inputBody.sections.forEach( ( ele ) => {
+          ele.questions.forEach( ( qn ) => {
+            let question = getExistQuestions[0].question.find( ( qns ) => qns.qname === qn.oldQname );
+
+            if ( !question ) {
+              let sectionIndex = questionList.questionAdd.findIndex( ( sec ) => sec.sectionName === ele.name );
+
+              if ( sectionIndex !== -1 ) {
+                questionList.questionAdd[sectionIndex].questions.push( qn );
+              } else {
+                questionList.questionAdd.push( { sectionName: ele?.name || 'Section 1', questions: [ qn ] } );
+              }
+            }
+          } );
+        } );
+
+        if ( questionList.questionAdd.length || questionList.questionEdit.length || questionList.questionDelete.length || inputBody.checklistName.toLowerCase() != checkListDetails.checkListName.toLowerCase() || inputBody.checklistDescription.toLowerCase() != checkListDetails.checkListDescription.toLowerCase() ) {
+          let insertLogData = {
+            client_id: req.body.clientId,
+            createAt: new Date(),
+            sourceCheckList_id: inputBody._id,
+            checkListName: inputBody.checklistName,
+            fromCheckListName: '',
+            type: 'checklist',
+            action: 'edited',
+            storeName: '',
+            store_id: '',
+            createdByEmail: req.user.email,
+            createdBy: req.user.userName,
+            coverage: taskDetails?.coverage,
+            logDetails: {
+              ...( inputBody.checklistName.toLowerCase() == checkListDetails.checkListName.toLowerCase() ) ? { updatedChecklistName: {} } :{ updatedChecklistName: {
+                previous: checkListDetails.checkListName,
+                new: inputBody.checklistName,
+              } },
+              ...( inputBody.checklistDescription.toLowerCase() == checkListDetails.checkListDescription.toLowerCase() ) ? { updatedChecklistDescription: {} } :{ updatedChecklistDescription: {
+                previous: checkListDetails.checkListDescription,
+                new: inputBody.checklistDescription,
+              } },
+              updatedSectionName: [],
+              questionAdd: questionList.questionAdd,
+              questionEdit: questionList.questionEdit,
+              questionDelete: questionList.questionDelete,
+            },
+          };
+          await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, insertLogData );
         }
-        return res.sendSuccess( { checklistId: checkListId, message: message } );
       } else {
-        if ( inputBody.submitType == 'save' ) {
-          let message = 'Saved in draft successfully';
-          return res.sendSuccess( { checklistId: checkListId, message: message } );
-        } else {
-          return res.sendSuccess( { message: 'Question is required' } );
-        }
+        let logObj = {
+          client_id: inputBody.clientId,
+          createAt: new Date(),
+          sourceCheckList_id: inputBody._id,
+          checkListName: inputBody.checklistName,
+          fromCheckListName: '',
+          type: 'task',
+          action: 'created',
+          storeName: '',
+          store_id: '',
+          createdByEmail: req.user.email,
+          createdBy: req.user.userName,
+          coverage: 'store',
+          logDetails: {},
+        };
+        await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
       }
+      return res.sendSuccess( { checklistId: checkListId, message: message } );
     } else {
       return res.sendError( { message: 'something went wrong' }, 500 );
     }
@@ -883,13 +1000,13 @@ export async function taskConfig( req, res ) {
     };
     await checklistLogs.create( logInsertData );
 
-    checklistDetails = await taskService.findOne( { _id: inputBody._id, isdeleted: false, client_id: inputBody.clientId } );
+    checklistDetails = await taskService.findOne( { _id: inputBody._id, isdeleted: false, client_id: inputBody.clientId, checkListName: 1 } );
 
     if ( !checklistDetails ) {
       return res.sendError( 'No data found', 204 );
     }
 
-    let configDetails = { ...req.body };
+    let configDetails = { ...inputBody };
     configDetails.approver = configDetails.approver.length ? configDetails.approver.map( ( item ) => {
       return { name: item.name, value: item.value };
     } ) : [];
@@ -960,6 +1077,81 @@ export async function taskConfig( req, res ) {
     }
     if ( response?.modifiedCount || response?.matchedCount || response?.upsertedCount ) {
       let message = inputBody.submitType == 'publish' ? 'Configuration Updated Successfully' : 'Saved in draft successfully';
+      checklistDetails = checklistDetails.toObject();
+      checklistDetails.scheduleEndTimeISO = checklistDetails?.scheduleEndTime ? dayjs.utc( checklistDetails?.scheduleEndTime, 'hh:mm A' ).format() : '';
+      checklistDetails.scheduleDate = checklistDetails.scheduleDate ? dayjs.utc( checklistDetails?.scheduleDate ).format( 'YYYY-MM-DD' ) : '';
+      configDetails.scheduleDate = configDetails.scheduleDate ? dayjs( configDetails?.scheduleDate ).format( 'YYYY-MM-DD' ) : '';
+      let removedKeys = [ 'publish', 'publishDate', 'storeCount', 'sections', 'createdAt', 'updatedAt', 'scheduleEndTimeISO' ];
+      removedKeys.forEach( ( item ) => {
+        delete checklistDetails?.[item];
+        delete configDetails?.[item];
+      } );
+      let differences = findObjectDifference( checklistDetails, configDetails );
+      if ( Object.keys( differences ).length || inputBody.added.length || inputBody.removed.length ) {
+        let insertData = {
+          client_id: inputBody.clientId,
+          createAt: new Date(),
+          sourceCheckList_id: configDetails._id,
+          checkListName: checklistDetails.checkListName,
+          fromCheckListName: '',
+          type: 'task',
+          action: 'updated',
+          storeName: '',
+          store_id: '',
+          createdByEmail: req.user.email,
+          createdBy: req.user.userName,
+          coverage: configDetails.coverage,
+          logDetails: {
+            schedule: {
+              previous: {
+                ...( differences?.scheduleDate && ( differences?.scheduleDate.previous != '' && differences?.scheduleDate.previous != null ) ) ? { scheduleDate: checklistDetails?.scheduleDate } :{},
+                time: differences?.scheduleEndTime ? checklistDetails.scheduleEndTime : '',
+                priority: differences?.priorityType ? checklistDetails?.priorityType : '',
+              },
+              new: {
+                ...( differences?.scheduleDate && ( differences?.scheduleDate.new != '' && differences?.scheduleDate.new != null ) ) ? { scheduleDate: configDetails?.scheduleDate } :{},
+                time: differences?.scheduleEndTime ? configDetails.scheduleEndTime : '',
+                priority: differences?.priorityType ? configDetails?.priorityType : '',
+              },
+            },
+            response: {
+              previous: [
+                ...( differences?.allowedStoreLocation && checklistDetails.allowedStoreLocation ? [ 'Geo fencing' ] : [] ),
+              ],
+              new: [
+                ...( differences?.allowedStoreLocation && configDetails.allowedStoreLocation ? [ 'Geo fencing' ] : [] ),
+              ],
+            },
+            ...( differences?.approver ) ? { approver:
+           { previous: differences?.approver?.previous.map( ( item ) => item.name ).toString(),
+             new: differences?.approver?.new.map( ( item ) => item.name ).toString() },
+            } : { approver: {} },
+            owner: {},
+            ...( inputBody.coverage == 'store' ) ? { storeAdded: inputBody.added } :{ storeAdded: [] },
+            ...( inputBody.coverage == 'store' ) ? { storeRemoved: inputBody.removed } :{ storeRemoved: [] },
+            ...( inputBody.coverage == 'user' ) ? { userAdded: inputBody.added } :{ userAdded: [] },
+            ...( inputBody.coverage == 'user' ) ? { userRemoved: inputBody.removed } :{ userRemoved: [] },
+          },
+        };
+        await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, insertData );
+      }
+
+      let logObj = {
+        client_id: inputBody.client_id,
+        createAt: new Date(),
+        sourceCheckList_id: inputBody._id,
+        checkListName: checklistDetails.checkListName,
+        fromCheckListName: '',
+        type: 'task',
+        action: inputBody.publish ? 'published' : 'unpublished',
+        storeName: '',
+        store_id: '',
+        createdByEmail: req.user.email,
+        createdBy: req.user.userName,
+        coverage: inputBody.coverage,
+        logDetails: {},
+      };
+      await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
       return res.sendSuccess( { id: inputBody._id, message: message } );
     }
   } catch ( e ) {
@@ -969,6 +1161,32 @@ export async function taskConfig( req, res ) {
   }
 }
 
+function findObjectDifference( oldObj, newObj ) {
+  const isEqual = ( a, b ) => JSON.stringify( a ) === JSON.stringify( b );
+
+  const getArrayDiff = ( oldArr, newArr ) => {
+    const removed = oldArr.filter( ( item ) => !newArr.some( ( newItem ) => isEqual( newItem, item ) ) );
+    const added = newArr.filter( ( item ) => !oldArr.some( ( oldItem ) => isEqual( oldItem, item ) ) );
+    if ( removed.length || added.length ) {
+      return { previous: oldArr, new: newArr };
+    }
+    return [];
+  };
+  const difference = Object.keys( oldObj ).reduce( ( diff, key ) => {
+    oldObj[key] = oldObj[key] == null ? '' : oldObj[key];
+    if ( !isEqual( oldObj[key], newObj[key] ) ) {
+      if ( !Array.isArray( newObj[key] ) ) {
+        diff[key] = { previous: oldObj[key], new: newObj[key] };
+      } else {
+        diff[key] = getArrayDiff( oldObj[key] || [], newObj[key] || [] );
+      }
+    }
+    return diff;
+  }, {} );
+
+  return difference;
+}
+
 export async function insertSingleProcessData( checklistId ) {
   try {
     let currentdate = new Date();
@@ -2571,7 +2789,7 @@ export const updatePublish = async ( req, res ) => {
 
     if ( req.body.checklistId ) {
       query = { _id: req.body.checklistId };
-      getCheckDetails = await taskService.findOne( { _id: req.body.checklistId, client_id: req.body.clientId } );
+      getCheckDetails = await taskService.findOne( { _id: req.body.checklistId, client_id: req.body.clientId, checkListName: 1 } );
     }
 
     if ( !getCheckDetails ) {
@@ -2668,6 +2886,22 @@ export const updatePublish = async ( req, res ) => {
       createdByEmail: req.user.email,
     };
     await checklistLogs.create( logInsertData );
+    let logObj = {
+      client_id: req.body.clientId,
+      createAt: new Date(),
+      sourceCheckList_id: req.body.checklistId,
+      checkListName: getCheckDetails.checkListName,
+      fromCheckListName: '',
+      type: 'task',
+      action: req.body.publish ? 'published' : 'unpublished',
+      storeName: '',
+      store_id: '',
+      createdByEmail: req.user.email,
+      createdBy: req.user.userName,
+      coverage: getCheckDetails.coverage,
+      logDetails: {},
+    };
+    await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
     return res.sendSuccess( { checklistName: getCheckDetails.checkListName, message: 'Updated Successfully' } );
   } catch ( e ) {
     logger.error( 'updatePublish task erroe =>', e );
@@ -4062,6 +4296,43 @@ export async function updateAssign( req, res ) {
     // req.body.assignedGroup = req.body.assignedGroup.map( ( ele ) => {
     //   return { id: ele };
     // } );
+    let getAssignedDetails = await taskAssignService.find( { checkListId: req.body.taskId } );
+    if ( getAssignedDetails.length ) {
+      if ( req.body.coverage == 'store' ) {
+        getAssignedDetails = [ ...new Set( getAssignedDetails.map( ( ele ) => ele.storeName ) ) ];
+      } else {
+        getAssignedDetails = [ ...new Set( getAssignedDetails.map( ( ele ) => ele.userName ) ) ];
+      }
+    }
+
+    let added = req.body.assignedList.filter( ( item ) => {
+      let storeUsername;
+      if ( req.body.coverage == 'store' ) {
+        storeUsername = item.storeName;
+      } else {
+        storeUsername = item.userName;
+      }
+      if ( !getAssignedDetails.includes( storeUsername ) ) {
+        return item;
+      }
+    } ).map( ( ele ) => {
+      if ( req.body.coverage == 'store' ) {
+        return ele.storeName;
+      } else {
+        return ele.userName;
+      }
+    } );
+    let removed = getAssignedDetails.filter( ( item ) => {
+      let list;
+      if ( req.body.coverage == 'store' ) {
+        list = req.body.assignedList.map( ( item ) => item.storeName );
+      } else {
+        list = req.body.assignedList.map( ( item ) => item.userName ); ;
+      }
+      if ( !list.includes( item ) ) {
+        return item;
+      }
+    } );
     await taskAssignService.deleteMany( { checkListId: req.body.taskId } );
     let assignedUserList = [];
     let userEmailList = req.body.assignedList.map( ( ele ) => ele.userEmail.toLowerCase() );
@@ -4124,7 +4395,7 @@ export async function updateAssign( req, res ) {
       }
     } ) );
     await taskAssignService.insertMany( assignedUserList );
-    return res.sendSuccess( 'Assign details updated successfully' );
+    return res.sendSuccess( { message: 'Assign details updated successfully', added, removed } );
   } catch ( e ) {
     logger.error( { functionName: 'updateAssign', error: e } );
   }